Discussion :

[le_ptit_lutin]

Salut à tous,

Je cherche à savoir s'il y a un ordre strict dans lequel créer les matrices pour effectuer un rendu avec OpenGL 3.
J'ai besoin dans mon cas de générer les matrices modelViewMatrix, modelViewProjectionMatrix et normalMatrix. Suivant les termes d'OpenGL.

Savoir comment les générer individuellement ne me pose aucun problème. J'ai juste l'impression que je ne fais pas les choses dans le bon ordre, pour le moment je fais :

1. Génération de la matrice de projection, je la stocke dans un coin et je n'y touche plus.
"Pour chaque image"
{
2. Je positionne ma camera et donc génère une matrice de base que j'appel (peut-être à tord) la base de ma modelViewMatrix.
3. Je génére ma normalMatrix depuis la modelViewMatrix.
4. Je génére une nouvelle matrice en multipliant ma modelViewMatrix avec matrice de projection (1), j'obtient la modelViewProjectionMatrix.

"Pour chaque objet"
{
5. Je reprend mes trois matrices modelViewMatrix, modelViewProjectionMatrix et normalMatrix, et j'applique les coordonnées de l'objet en cours.
6. J'envois le tout au program GLSL pour le rendu.
}
}

Voila, c'était donc pour savoir si l'ordre était correct ?

Pour infos, mes images sont droites , j'essaie simplement d'appliquer une éclairage de type Phong, et je m'en sort pas avec les reflets (ils sont figés) et je doute des matrices, particulièrement de la modelViewMatrix et la normalMatrix.

[pyros]

Salut,

Le problème vient peut être de l'ordre dans lequel tu multiplies tes matrices modelView et projection. En notant les vecteurs en colonne (<troll> La seul réel convention qui devrait exister </troll>):

modelViewProj = Projection * modelView.

Et p(ecran) = modelViewProj * p(local).

[le_ptit_lutin]

Voici les lignes responsables des multiplications :

Code :

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

1
2
3
 
// Avant de dessiner un objet
Math3D::Geomatrix mvp = static_cast< Math3D::Geomatrix >( m_3dProjectionMatrix * m_modelViewMatrix );

Code :

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

1
2
3
 
// Dans le shader
gl_Position = em_ModelViewProjectionMatrix * em_VertexPosition;

Je pense que c'est bon. Par contre l'histoire des colonnes en vecteur Si c'est l'ordre des matrices, elles sont "column major".

[LittleWhite]

Bonjour,

Je ne serai pas contre le code du shader qui fait le Phong et d'une image pour accompagner la description du bug.

Sinon, utilisez une bibliothèque telle que GLM ? (pour les matrices)

[le_ptit_lutin]

J'ai compris mon erreur !

J'ai en fait mixé deux tutoriels dont un (celui du livre OpenGL Superbible 5) qui s'appliquait sur une espèce de visionneuse d'objet, et l'autre dans une scène avec camera libre.

Je n'avais pas tenu compte d'une petite subtilité avec le vecteur de la camera pendant le calcule de la réflexion.

Voici quand même les shaders avec un commentaire aux endroits qui manquaient. Les lumières sont générées dans le shader pour le moment, et il manque plusieurs paramètres comme les couleurs etc.

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
 
#version 330
 
precision highp float;
 
uniform mat4 em_ModelViewMatrix;
uniform mat4 em_ModelViewProjectionMatrix;
uniform mat3 em_NormalMatrix;
 
in vec4 em_VertexPosition;
in vec4 em_VertexColor;
in vec3 em_VertexNormal;
in vec2 em_VertexTexCoord0;
 
smooth out vec2 em_FragTexCoord0;
smooth out vec4 em_FrontColor;
 
smooth out vec3 normal;
smooth out vec3 lightDir[3];
smooth out vec3 eyeVec; // La petite subtilité (1)
 
void main (void)
{
	em_FragTexCoord0 = em_VertexTexCoord0;
	em_FrontColor = em_VertexColor;
 
	normal = em_NormalMatrix * em_VertexNormal;
 
    // Get vertex position in eye coordinates
    vec4 vPosition4 = em_ModelViewMatrix * em_VertexPosition;
    vec3 vPosition3 = vPosition4.xyz / vPosition4.w;
    eyeVec = -vPosition3;  // La petite subtilité (2)
 
    vec4 lPos[3];
    lPos[0] = vec4(128000.0, 256000.0, 128000.0, 1.0);
    lPos[1] = vec4(-96000.0, 256000.0, 64000.0, 1.0);
    lPos[2] = vec4(64000.0, 196000.0, -128000.0, 1.0);
 
	int i;
	for ( i = 0; i < 3; i++ )
	{
		// Get light position in eye coordinates
		vec4 lPosition4 = em_ModelViewMatrix * lPos[i];
		vec3 lPosition3 = lPosition4.xyz / lPosition4.w;
 
		// Get vector to light source
		lightDir[i] = normalize(lPosition3 - vPosition3);
    }
 
	gl_Position = em_ModelViewProjectionMatrix * em_VertexPosition;
}

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
 
#version 330
 
precision highp float;
 
uniform sampler2D em_DiffuseTexture;
 
smooth in vec2 em_FragTexCoord0;
smooth in vec4 em_FrontColor;
 
smooth in vec3 normal;
smooth in vec3 lightDir[3];
smooth in vec3 eyeVec;  // La petite subtilité (3)
 
float computeFog (float density)
{
	const float LOG2 = 1.442695;
 
	float z = gl_FragCoord.z / gl_FragCoord.w;
	float fogFactor = exp2(-density * density * z * z * LOG2);
 
	return clamp(fogFactor, 0.0, 1.0);
}
 
void main (void)
{
	vec4 fogColor = vec4(0.1, 0.0, 0.0, 1.0);
	float fogFactor = computeFog(0.0001);
 
	vec4 baseColor = mix(texture2D(em_DiffuseTexture, em_FragTexCoord0), em_FrontColor, 0.5);
 
	// Ambient
	vec4 finalColor = vec4(0.01, 0.0, 0.0, 1.0);
 
	int i;
	for ( i = 0; i < 3; i++ )
	{
		// Diffuse
		float diffuseFactor = max(0.0, dot(normalize(normal), normalize(lightDir[i])));
 
		if ( diffuseFactor > 0.0 )
		{
			finalColor += diffuseFactor * baseColor;
 
			// Specular
			vec3 E = normalize(eyeVec);  // La petite subtilité (4)
			vec3 R = normalize(reflect(-normalize(lightDir[i]), normalize(normal)));
 
			float spec = max(0.0, dot(R, E)); //  // La petite subtilité (5), avant j'utilisais le vecteur normal.
		    float fSpec = pow(spec, 128.0);
 
			finalColor.rgb += vec3(fSpec, fSpec, fSpec);
		}
	}
 
	gl_FragColor = mix(fogColor, vec4(finalColor.rgb, 1.0), fogFactor);
}

[DonQuiche]

En notant les vecteurs en colonne (<troll> La seul réel convention qui devrait exister </troll>)

Au risque de paraître cavalier, je t'aime, toi.