Discussion :

[ludo86]

Salut à tous,

J'essaye de me mettre aux développement d'application sous openGL ES 2.0.
Pour se faire je tente déjà le basique en dessinant un simple cube. Cependant j'ai en changeant le glOrtho par un glPerspective mon cube disparait et je ne comprends pas pourquoi.

Je ne comprends plus.

Y voyez vous une erreur flagrante :

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
 
 
const GLfloat cubeVertices[] = {
	// face de devant
	-0.5, 0.5, -0.5,             
	-0.5, -0.5, -0.5,           
	0.5, -0.5, -0.5,             
	0.5, 0.5, -0.5,              
 
	// haut
	-0.5, 0.5, -0.5,           
	-0.5, 0.5, 0.5,             
	0.5, 0.5, 0.5,              
	0.5, 0.5, -0.5,             
 
	// arrière
	0.5, 0.5, 0.5,         
	0.5, -0.5, 0.5,           
	-0.5, -0.5, 0.5,           
	-0.5, 0.5, 0.5,            
 
	// dessous
	-0.5, -0.5, 0.5,
	-0.5, -0.5, -0.5,
	0.5, -0.5, -0.5,
	0.5, -0.5, 0.5,
 
	// gauche
	-0.5, 0.5, -0.5,
	-0.5, 0.5, 0.5,
	-0.5, -0.5, 0.5,
	-0.5, -0.5, -0.5,
 
	// droit
	0.5, 0.5, 0.5,
	0.5, 0.5, -0.5,
	0.5, -0.5, -0.5,
	0.5, -0.5, 0.5
}; 
 
static const GLubyte squareColors[] = {
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
 
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
 
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
 
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
 
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
 
	0, 0, 204, 255,
	0, 204, 0, 255,
	204, 0, 0, 255,
	204, 0, 204, 255,
};
 
 
-(void)render{
 
	Mat4x4 cameraView = Camera::getInstance()->gluLookAtMatrix();
	Mat4x4 proj = Mat4x4::setPerspective((float)(768.0f/1024.0f), 60.0f, 1.0, 20.0f);
 
	//Mat4x4::setOrtho(proj, -4.0f, 4.0f, -6.0f, 6.0f, -4.0f, 4.0f);
 
 
	Mat4x4 rot,trans = Mat4x4::setTranslation(0.0f, 1.0f, 5.0f);
	rot.rotY(r_angle);
 
	Mat4x4 mvp = cameraView * proj * rot * trans;
 
 
 
 
	r_angle += 0.05f;
	glUseProgram([s_loader getProgramIdentifier]);
	glVertexAttribPointer(attribPositionOnShader, 3, GL_FLOAT, 0, 0, cubeVertices);
	glEnableVertexAttribArray(attribPositionOnShader);
	glVertexAttribPointer(attribColorOnShader, 4, GL_UNSIGNED_BYTE, 1, 0, squareColors);
	glEnableVertexAttribArray(attribColorOnShader);
	glUniformMatrix4fv(projMatOnShader, 16, GL_FALSE, mvp.toArray());
 
	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 4, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 8, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 12, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 16, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 20, 4);
 
	glUseProgram(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Mat4x4 Mat4x4::setPerspective(float aspect,float fov,float zFar,float zNear){
	Mat4x4 perspectiveMat;
	float f = atanf((fov * M_PI / 180) / 2);
 
	perspectiveMat[0] = f/aspect;	
	perspectiveMat[5] = f;
	perspectiveMat[10] = (zFar - zNear)/(zNear+zFar);
	perspectiveMat[11] = 2 * (zFar * zNear)/(zNear - zFar);
	perspectiveMat[14] = -1;
 
	return perspectiveMat;
 
}

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
 
Camera* Camera::getInstance(){
	if(instance == NULL){
		Point3D pt(0.0f,3.0f,-5.0f);
		Vec3 up(0.0f,1.0f,0.0f);
		Point3D to(0.0f,0.0f,0.0f);
		instance = new Camera(pt,up,to);
	}
 
	return instance;
 
}
 
 
Mat4x4 Camera::gluLookAtMatrix(){
	Vec3 vForward, vUpNorm, vSide;
	Mat4x4 result,translation = Mat4x4::setTranslation(-(*position)[0], -(*position)[1], -(*position)[2]);
	Point3D tmp = *lookAt - *position;
	vForward = tmp.ptToVec();
 
	vForward.normalize();
	vUpNorm = up->normalized();
	vSide   = vUpNorm * vForward;
	vUpNorm = vSide * vForward;
 
	result[0] = vSide[0];		result[1] = vSide[1];		result[2] = vSide[2];		result[3] = 0;
	result[4] = vUpNorm[0];		result[5] = vUpNorm[1];		result[6] = vUpNorm[2];		result[7] = 0;
	result[8] = -vForward[0];	result[9] = -vForward[1];	result[10] = -vForward[2];	result[11] = 0;
	result[12] = 0;				result[13] = 0;				result[14] = 0;				result[15] = 1;
 
 
	result *= translation;
 
	return result;
 
 
}

[LittleWhite]

Bonjour,

Peut on voir le code des shaders?

Un grand conseil: Utilisez la commande glGetError() après chaque appel aux fonctions OpenGL pour savoir s'il n'y en a pas une qui c'est ma dérouler.

Vous développer sur quoi?

[ludo86]

On peut se tutoyer si ça ne te dérange pas.

Je développe sous mac et pour iPad et iPhone.

Entre autre sur iPad le langage est l'openGL ES 2.0 donc je suis obligé de faire sans les glLoadIdentity() glFrustrum et glPerspective.

Voici mon code de shader. Il était dans le template du projet à sa création :
Fragment shader

Code :

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

1
2
3
4
5
6
7
 
 
varying lowp vec4 colorVarying;
 
void main(){
    gl_FragColor = colorVarying;
}

Vertex shader

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
 
attribute vec4 position;
attribute vec4 color;
 
varying vec4 colorVarying;
 
uniform float translate;
uniform mat4 orthoMat;
 
void main(){
 
	gl_Position = orthoMat * position;
 
    colorVarying = color;
}

Dans mon code précédent, j'ai pu constater une erreur, j'avais inversé le near et le far.De plus la fonction setPerspective comportait une erreur pour l'affectation de la 10ème valeur de la perspectiveMat. Je vois maintenant le cube mais il est déformé. Peut être une erreur dans les opérations matricielles non?

Merci de ton aide.

[stardeath]

Je vois maintenant le cube mais il est déformé. Peut être une erreur dans les opérations matricielles non?

Merci de ton aide.

déformé? peux tu être plus explicite?

[ludo86]

Désolé c'est vrai qu'en image c'est mieux.

[stardeath]

effectivement, tu dois avoir un problème de matrice '^^

[ludo86]

Je le comprends mais verrais tu une erreur flagrante dans les matrices que j'ai mis? Aurais je fais un oubli?

ça m'embete vraiement ce genre de problème car j'ai pas mal tourné/viré sur d'autres solutions et à chaque fois j'ai une matrice différente.

Si quelqu'un pouvait se donner la peine de m'orienter.

[stardeath]

quand j'acquiesçais pour ton problème, j'aurai du dire explicitement que je cherchais le problème ^^

ta matrice de projection semble pas bonne : http://pyopengl.sourceforge.net/docu...ective.3G.html

[ludo86]

Merci de cette aide!!!

[ludo86]

Alors justement à la base j'avais pris cette matrice, mais j'ai toujours une déformation du cube comme sur les images que j'ai joint.

Ensuite voyant que ça marchait pas j'ai opté pour celle-là : http://h30097.www3.hp.com/docs/base_...3/2129____.HTM

Alors je ne sais plus à qui me fier. Est ce la même matrice?

De plus dans le lien que tu as cité il spécifie que fovy doit être en degrée alors que dans bon nombre d'autres documentations il doit être en radian!
Le fait de mettre le fov en degré ne change rien à la déformation et le cube apparait juste en plus gros.

[LittleWhite]

Pouvez vous essayer:

Code :

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

1
2
3
4
5
6
 
perspectiveMat[0] = f/aspect;	
perspectiveMat[5] = f;
perspectiveMat[10] = (zFar - zNear)/(zNear+zFar);
perspectiveMat[14] = 2 * (zFar * zNear)/(zNear - zFar);
perspectiveMat[11] = -1;

à la place de:

Code :

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

1
2
3
4
5
6
 
perspectiveMat[0] = f/aspect;	
perspectiveMat[5] = f;
perspectiveMat[10] = (zFar - zNear)/(zNear+zFar);
perspectiveMat[11] = 2 * (zFar * zNear)/(zNear - zFar);
perspectiveMat[14] = -1;

et peut être aussi:

Code :

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

1
2
3
4
5
 
result[0] = vSide[0];		result[4] = vSide[1];		result[8] = vSide[2];		result[12] = 0;
	result[1] = vUpNorm[0];		result[5] = vUpNorm[1];		result[9] = vUpNorm[2];		result[13] = 0;
	result[2] = -vForward[0];	result[6] = -vForward[1];	result[10] = -vForward[2];	result[14] = 0;
	result[3] = 0;				result[7] = 0;				result[11] = 0;				result[15] = 1;

à la place de:

Code :

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

1
2
3
4
5
 
result[0] = vSide[0];		result[1] = vSide[1];		result[2] = vSide[2];		result[3] = 0;
	result[4] = vUpNorm[0];		result[5] = vUpNorm[1];		result[6] = vUpNorm[2];		result[7] = 0;
	result[8] = -vForward[0];	result[9] = -vForward[1];	result[10] = -vForward[2];	result[11] = 0;
	result[12] = 0;				result[13] = 0;				result[14] = 0;				result[15] = 1;

En espérant que je ne me trompe pas :s

[ludo86]

Bonjour,

Je ne vois du tout plus mon cube.

Je vois que tu as transposé la matrice.
Après je ne sais pas si ce n'est pas dû à ce que je fais avant. Pourtant c'est juste un simple cube que je veux dessiner.

Comme tu n'as pas corrigé autre chose cela voudrait il dire que les opération avant sont bonnes?

Ci-joint l'opération de multiplication. Je ne pense pas qu'il y est une erreur mais on ne sait jamais.

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
 
Mat4x4 Mat4x4::operator*(Mat4x4& m){
	Mat4x4 mul;
 
	mul[0] = (*this)[0] * m[0] + (*this)[1] * m[4] + (*this)[2] * m[8] + (*this)[3] * m[12];
	mul[1] = (*this)[0] * m[1] + (*this)[1] * m[5] + (*this)[2] * m[9] + (*this)[3] * m[13];
	mul[2] = (*this)[0] * m[2] + (*this)[1] * m[6] + (*this)[2] * m[10] + (*this)[3] * m[14];
	mul[3] = (*this)[0] * m[3] + (*this)[1] * m[7] + (*this)[2] * m[11] + (*this)[3] * m[15];
 
	mul[4] = (*this)[4] * m[0] + (*this)[5] * m[4] + (*this)[6] * m[8] + (*this)[7] * m[12];
	mul[5] = (*this)[4] * m[1] + (*this)[5] * m[5] + (*this)[6] * m[9] + (*this)[7] * m[13];
	mul[6] = (*this)[4] * m[2] + (*this)[5] * m[6] + (*this)[6] * m[10] + (*this)[7] * m[14];
	mul[7] = (*this)[4] * m[3] + (*this)[5] * m[7] + (*this)[6] * m[11] + (*this)[7] * m[15];
 
	mul[8] =  (*this)[8] * m[0] + (*this)[9] * m[4] + (*this)[10] * m[8] + (*this)[11] * m[12];
	mul[9] =  (*this)[8] * m[1] + (*this)[9] * m[5] + (*this)[10] * m[9] + (*this)[11] * m[13];
	mul[10] = (*this)[8] * m[2] + (*this)[9] * m[6] + (*this)[10] * m[10] + (*this)[11] * m[14];
	mul[11] = (*this)[8] * m[3] + (*this)[9] * m[7] + (*this)[10] * m[11] + (*this)[11] * m[15];
 
	mul[12] = (*this)[12] * m[0] + (*this)[13] * m[4] + (*this)[14] * m[8] + (*this)[15] * m[12];
	mul[13] = (*this)[12] * m[1] + (*this)[13] * m[5] + (*this)[14] * m[9] + (*this)[15] * m[13];
	mul[14] = (*this)[12] * m[2] + (*this)[13] * m[6] + (*this)[14] * m[10] + (*this)[15] * m[14];
	mul[15] = (*this)[12] * m[3] + (*this)[13] * m[7] + (*this)[14] * m[11] + (*this)[15] * m[15];
 
	return mul;
}

[ludo86]

J'ai peut être une solution la multiplication de la matrice n'est pas correct.

Je viens de tester en multipliant 2 matrices de translations et le resultat ne me donne pas la somme des translations. A partir de là on peut je pense avoir une piste sur toutes les autres problèmes.

[ludo86]

Ok l'erreur de multiplication de matrice est résolue.
J'avais fais une erreur dans mon *=.

Pourtant j'obtiens toujours ceci.

En ce qui concerne la transposition de matrice est ce que je dois la faire pour toutes les autres matrices?

[ludo86]

plus d'idée?
Ne serait ce pas un problème dans l'ordre des matrices.

[ludo86]

Un petit peu de nouveau en changeant l'ordre des matrices j'ai reussi à obtenir mon cube que voici :

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
 
-(void)render{
	Mat4x4 cameraView = Camera::getInstance()->gluLookAtMatrix();
 
	Mat4x4 proj = Mat4x4::setPerspective((float)(768.0f/1024.0f), C_FOV, C_NEAR, C_FAR);
 
	Mat4x4 mModelView;
	mModelView.rotY(r_angle);
 
	Mat4x4 mvp = mModelView * proj * cameraView;
 
	r_angle += 0.05f;
	glUseProgram([s_loader getProgramIdentifier]);
	glVertexAttribPointer(attribPositionOnShader, 3, GL_FLOAT, 0, 0, cubeVertices);
	glEnableVertexAttribArray(attribPositionOnShader);
	glVertexAttribPointer(attribColorOnShader, 4, GL_UNSIGNED_BYTE, 1, 0, squareColors);
	glEnableVertexAttribArray(attribColorOnShader);
	glUniformMatrix4fv(projMatOnShader, 16, GL_FALSE, mvp.toArray());
 
	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 4, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 8, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 12, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 16, 4);
	glDrawArrays(GL_TRIANGLE_FAN, 20, 4);
 
	glUseProgram(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
}

J'ai de même ajouté la normalisation du vecteur vSide dans gluLookAt.

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
 
Mat4x4 Camera::gluLookAtMatrix(){
	Vec3 vForward, vUpNorm, vSide;
	Mat4x4 result,translation = Mat4x4::setTranslation(-(*position)[0], -(*position)[1], -(*position)[2]);
	Point3D tmp = (*lookAt) - (*position);
	vForward = tmp.ptToVec();
 
	vForward.normalize();
	vUpNorm = up->normalized();
	vSide   = vUpNorm * vForward;
	vSide.normalize();
	vUpNorm = vSide * vForward;
 
	result[0] = vSide[0];		result[4] = vSide[1];		result[8] = vSide[2];		result[12] = 0;
	result[1] = vUpNorm[0];		result[5] = vUpNorm[1];		result[9] = vUpNorm[2];		result[13] = 0;
	result[2] = -vForward[0];	result[6] = -vForward[1];	result[10] = -vForward[2];	result[14] = 0;
	result[3] = 0;				result[7] = 0;				result[11] = 0;				result[15] = 1;
 
	/*
	result[0] = vSide[0];		result[1] = vSide[1];		result[2] = vSide[2];		result[3] = 0;
	result[4] = vUpNorm[0];		result[5] = vUpNorm[1];		result[6] = vUpNorm[2];		result[7] = 0;
	result[8] = -vForward[0];	result[9] = -vForward[1];	result[10] = -vForward[2];	result[11] = 0;
	result[12] = 0;				result[13] = 0;				result[14] = 0;				result[15] = 1;
	*/
 
	result *= translation;
 
	return result;
 
 
}

Néanmoins quand je change la position de la caméra(je change le y de 0 à 2) j'ai un effet bizarre. Serait ce dû au vecteur up que je n'ai pas mis à jour?



Ce qui me choque également c'est qu'en regardant sur ce site :
http://www.songho.ca/opengl/gl_transform.html

L'auteur spécifie ModelViewMatrix = ViewMatrix * ModelMatrix alors que de mon coté je dois faire l'inverse

[LittleWhite]

Pour mes changements ... essayez aussi sans ... je ne savais pas ce qui était juste ...
Le seul truc que je sais c'est que OpenGL utilise les matrices dans le sens inverse des choses qui sont font habituellement ( je crois que ça s'appelle 'column based' ).

Après pour votre dernier problème, il semble que ce soit un problème avec la matrice de vue... ( donc peut être problème que j'ai rajouté moi même ).

Sinon pas très bien compris de l'inverse que vous avez par rapport au site ...

[ludo86]

Pas de pb je viens d'identifier mon problème et ça y est enfin mon cube tourne et n'est pas déformé par la position de la caméra.

J'ai dû motifier le sens du produit vectoriel vUpNorm = vSide * vForward;
en vFroward * vSide.

Je vais tester l'ajout d'une translation et vous tiens au courant afin de partager le code.