Discussion :

[tankerpat]

Bonjour,

Alors voilà je me pose pas mal de questions sur la 3D concernant les matrices de projection,world, view.

J'ai passé y a quelque temps mon moteur 2D en 3D juste pour pouvoir faire des zoom plus propre, une vrai gestion de profondeur des assets graphique et également pouvoir faire un petit water effect 2.5D.

Le passage de la 2D à la 3D n'était pas très compliqué finalement, mais j'ai des soucis maintenant lorsque je veux faire un effet de réflexion sur l'eau.
Pas mal de tuto parle de passer les matrices World, view et prjection dans les shaders sauf que si je le fais mon rendu est super pixelisé et en plus il est super loin.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
VertexShaderOutput MainVS(in VertexShaderInput input)
{
	VertexShaderOutput output;
 
	output.Position3D = mul(input.Position, World);
	matrix vp = mul(View, Projection);
	output.Position =  mul(output.Position3D, vp);
	output.TexureCoordinateA = input.TexureCoordinateA;
	output.Normal = normalize(mul(input.Normal, World));
 
	return output;
}

Alors que si je fais ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
VertexShaderOutput MainVS(in VertexShaderInput input)
{
	VertexShaderOutput output;
 
	output.Position =  float4(input.Position, 1);
	output.TexureCoordinateA = input.TexureCoordinateA;
	output.Normal = normalize(mul(input.Normal, World));
 
	return output;
}

Ma texture apparait en full screen, et c'est que je veux pour la reflexion, enfin je crois, je suis bloqué là en fait.

Qu'est-ce qui fait que je ne puisse pas récupérer ma texture en fullscreen?
Pour info je code en C# avec Monogame du coup, et j'utilise des RenderTarget sur un quad render :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
public class QuadRenderer
    {
        //buffers for rendering the quad
        private readonly VertexPositionNormalTexture[] _vertexBuffer;
        private readonly short[] _indexBuffer;
 
        //Declaration des Vector3 position
        public Vector3 Origin;
        public Vector3 UpperLeft;
        public Vector3 LowerLeft;
        public Vector3 UpperRight;
        public Vector3 LowerRight;
        public Vector3 Normal;
        public Vector3 Up;
        public Vector3 Left;
        public Vector3 Position;
 
        //Déclaration du type de vertex à utiliser
        List<Vector2> textureCorner;
        //private VertexBuffer _vBuffer;
        //private IndexBuffer _iBuffer;
 
        public QuadRenderer(GraphicsDevice graphicsDevice)
        {
            _vertexBuffer = new VertexPositionNormalTexture[4];
            _vertexBuffer[0] = new VertexPositionNormalTexture(new Vector3(-1, -0, 0), Vector3.Forward, new Vector2(0, 0));
            _vertexBuffer[1] = new VertexPositionNormalTexture(new Vector3(1, 0, 0), Vector3.Forward, new Vector2(1, 0));
            _vertexBuffer[2] = new VertexPositionNormalTexture(new Vector3(0, 1, 0), Vector3.Forward, new Vector2(0, 1));
            _vertexBuffer[3] = new VertexPositionNormalTexture(new Vector3(-0, 0, 0), Vector3.Forward, new Vector2(1, 1));
 
            _indexBuffer = new short[] { 0, 3, 2, 0, 1, 3 };
 
        }
 
        public QuadRenderer(Vector3 origin, Vector3 normal, Vector3 up, float width, float height)
        {
            textureCorner = new List<Vector2>();
 
            Position = Vector3.Zero;
            Origin = origin;
            Normal = normal;
            Up = up;
 
            // Calculate the quad corners
            Left = Vector3.Cross(normal, Up);
            Vector3 uppercenter = (Up * height / 2) + origin;
            UpperLeft = uppercenter + (Left * width / 2);
            UpperRight = uppercenter - (Left * width / 2);
            LowerLeft = UpperLeft - (Up * height);
            LowerRight = UpperRight - (Up * height);
 
 
            _vertexBuffer = new VertexPositionNormalTexture[4];
 
            Vector2 textureUpperLeft = new Vector2(0.0f, 0.0f);
            Vector2 textureUpperRight = new Vector2(1.0f, 0.0f);
            Vector2 textureLowerLeft = new Vector2(0.0f, 1.0f);
            Vector2 textureLowerRight = new Vector2(1.0f, 1.0f);
 
            _vertexBuffer[0].Position = LowerLeft;
            _vertexBuffer[0].TextureCoordinate = textureLowerLeft;
            _vertexBuffer[1].Position = UpperLeft;
            _vertexBuffer[1].TextureCoordinate = textureUpperLeft;
            _vertexBuffer[2].Position = LowerRight;
            _vertexBuffer[2].TextureCoordinate = textureLowerRight;
            _vertexBuffer[3].Position = UpperRight;
            _vertexBuffer[3].TextureCoordinate = textureUpperRight;
 
            _indexBuffer = new short[6];
            _indexBuffer[0] = 0;
            _indexBuffer[1] = 3;
            _indexBuffer[2] = 2;
            _indexBuffer[3] = 0;
            _indexBuffer[4] = 1;
            _indexBuffer[5] = 3;
        }
 
        public void RenderQuad(GraphicsDevice graphicsDevice )
        {
            graphicsDevice.DrawUserIndexedPrimitives
            (PrimitiveType.TriangleList, _vertexBuffer, 0, _vertexBuffer.Length, _indexBuffer, 0, _indexBuffer.Length / 3);
        }
 
        public void RenderQuad(GraphicsDevice graphicsDevice, Vector2 v1, Vector2 v2, bool invert)
        {
            if (invert)
            {
                _vertexBuffer[0].Position.X = v1.X;
                _vertexBuffer[0].Position.Y = -v2.Y;
 
                _vertexBuffer[2].Position.X = v2.X;
                _vertexBuffer[2].Position.Y = -v2.Y;
 
                _vertexBuffer[1].Position.X = v1.X;
                _vertexBuffer[1].Position.Y = -v1.Y;
 
                _vertexBuffer[3].Position.X = v2.X;
                _vertexBuffer[3].Position.Y = -v1.Y;
            }
            else
            {
                _vertexBuffer[0].Position.X = v1.X;
                _vertexBuffer[0].Position.Y = v2.Y;
 
                _vertexBuffer[1].Position.X = v2.X;
                _vertexBuffer[1].Position.Y = v2.Y;
 
                _vertexBuffer[2].Position.X = v1.X;
                _vertexBuffer[2].Position.Y = v1.Y;
 
                _vertexBuffer[3].Position.X = v2.X;
                _vertexBuffer[3].Position.Y = v1.Y;
            }
            for (int i = 0; i < _vertexBuffer.Length; i++)
            {
                _vertexBuffer[i].Position.Z = 0;
            }
 
            graphicsDevice.DrawUserIndexedPrimitives
            (PrimitiveType.TriangleList, _vertexBuffer, 0, _vertexBuffer.Length, _indexBuffer, 0, _indexBuffer.Length / 3);
        }
    }

J'ai l'impression que le soucis vient directement de là, sachant que je ne passe pas par les BasicEffect pour ce rendu.
Et les coordonnées v1 et v2 sont des vecteurs unitaires si cela peut aider.

Merci d'avance

[tankerpat]

Bon j'ai beau chercher je n'arrive à rien aussi bien sur Google que faire des tests sur le projet.

Je pense que vu que je ne sais pas bien ce qui ne va pas, j'ai du mal a trouver l'information qu'il me faut

Sinon y a ce bouquin ( HLSL Development Cookbook de Feinstein Doronque ) que je me tâte a acheter pour avoir des connaissances, mais c'est en anglais, quelques articles ou bouquin sur la physique ça passe c'est ma branche pro +/-.
Mais lorsque je lis sur les API graphiques, sérieusement Sartre et Proust à coté c'est de la rigolade (oui c'est vrai c'est de l'humain)

Si vous avez des connaissances même limites partagez les, se sera toujours plus que moi sur la question. Peut-être que j'aurai un déclic
Et/ou un avis sur le bouquin, ça se trouve il est déjà trop poussé pour moi, je ne sais pas/ plu, je suis perdu là.

Merci

Edit : un aperçu de ce que je sais faire et afficher avec mon quadrenderer

[dragonjoker59]

Salut !

Pour appliquer des transformations (même 2D) il est plus pratique de passer par des matrices de transformation, qui permettent de concaténer ces transformations.

Vu qu'il te manque des connaissances sur leur fonctionnement, je te conseille la partie "matrices" des tutos OGLdev :
https://jeux.developpez.com/tutoriel...n-translation/

C'est un tuto OpenGL, mais c'est facilement transposable en D3D.

[tankerpat]

Salut et merci

En fait c'était ma classe Camera qui avait quelques problèmes, ma fonction LookAt() était codée avec les pieds .
J'avais ma fonction LookAt "fixe" pour mon rendu 2D avec quelques conditions pour changer mais je passais toujours par la première transformation puis j'ajoutais la deuxième .

Et du coup avec le tuto je m’essayai à faire une skybox et ça va, j'ai quelques soucis avec la texture mais ça va le faire.
Je m'amuse à essayer plusieurs tests avant de repartir sur l'effet reflet pour être sûr de bien l'avoir assimilé.

Encore merci

[tankerpat]

Bonjour,

Voilà qui est intéressant, ma rotation de caméra sur l'axe Y est parfaite et sur mon axe X elle part en cacahuète si je part trop long dans la rotation sur l'axe Y ou si je veux faire un 360° sur l'axe X.

Est-ce que cela vient du point de référence de la caméra ou il y a un trick à faire au moment de la rotation suivant un autre axe?

Edit : Ok c'est bon c'était bien ça, ma référence pour la caméra doit mise à jour alors qu'elle était fixe auparavant

Merci