Discussion :

[j_sb12]

Bonjour,

Je débute en OpenGL et cela fait maintenant deux jours que je bloque.

J'ai fait un tutoriel pour pouvoir dessiner un triangle, jusque là ça va mais j'ai besoin de charger un .obj et l'afficher.

J'ai chargé ce .obj grâce un bout de code trouvé sur le web, cela fonctionne. Toutes les données sont stockées dans des vectors.

Dans mon code je commence par allouer la mémoire pour les deux tableaux de vertices et faces.

Code :

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

1
2
3
 
GLfloat * vertices = (GLfloat*)malloc(sizeof(GLfloat) * model.object_.vertices.size() * 3);
GLuint * faces = (GLuint*)malloc(sizeof(GLuint) * model.object_.faces.size() * 4); // 4 car dans le .obj il y a 4 vertices par faces.

Ensuite je remplis ces tableaux

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
 
for (int i = 0; i < model.object_.vertices.size(); i++)
{
	vertices[j] = model.object_.vertices.at(i).coords[0];
	vertices[j + 1] = model.object_.vertices.at(i).coords[1];
	vertices[j + 2] = model.object_.vertices.at(i).coords[2];
 
	j += 3;
}
 
j = 0;	
 
for (int i = 0; i < model.object_.faces.size(); ++i)
{
	faces[j] = model.object_.faces.at(i).items.at(0).vertexIndex - 1; // -1 car le tableau des vertices commence à 0
	faces[j + 1] = model.object_.faces.at(i).items.at(1).vertexIndex - 1;
	faces[j + 2] = model.object_.faces.at(i).items.at(2).vertexIndex - 1;
	faces[j + 3] = model.object_.faces.at(i).items.at(3).vertexIndex - 1;
 
	j += 4;	
}

Ensuite je crée, link mon vertex shader et fragment shader et le VBO, VAO et EBO. Je vous épargne ce code car je sais qu'il fonctionne mais si n'hésitez pas à le demander.

Voici la boucle while indispensable à GLFW.

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
 
while (!glfwWindowShouldClose(window))
{
	glfwPollEvents();
 
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
 
        glUseProgram(shaderProgram);
	glBindVertexArray(VAO);
 
        // La taille est comme cela car il y a 4 vertices par faces dans le .obj
        glDrawElements(GL_TRIANGLES, model.object_.faces.size() * 4, GL_UNSIGNED_INT, 0);
 
        glBindVertexArray(0);
        glfwSwapBuffers(window);
}
 
Ensuite quand on quitte la boucle je free le VAO, VBO, EBO.

Tout cela m'affiche seulement la couleur verdâtre du glClearColor.
Quand je mets quelques valeurs du obj en dur dans un tableau et que je change la taille dans glDrawElements en conséquence cela fonctionne !

Je ne comprends vraiment pas...

De plus,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
glColor3f(0.0f, 0.0f, 1.0f);
 
glBegin(GL_POLYGON);//begin drawing of polygon
   glVertex3f(-0.5f, 0.5f, 0.0f);//first vertex
   glVertex3f(0.5f, 0.5f, 0.0f);//second vertex
   glVertex3f(1.0f, 0.0f, 0.0f);//third vertex
   glVertex3f(0.5f, -0.5f, 0.0f);//fourth vertex
   glVertex3f(-0.5f, -0.5f, 0.0f);//fifth vertex
   glVertex3f(-1.0f, 0.0f, 0.0f);//sixth vertex
glEnd();//end drawing of polygon

Je ne mets que ce code dans la boucle bien sûr en plus des choses indispensables de GLFW.

ne fonctionne pas non plus...

Si vous avez des idées, je suis preneur !

Merci

[Iradrille]

Toutes les données sont stockées dans des vectors.

Dans mon code je commence par allouer la mémoire pour les deux tableaux de vertices et faces.

Code :

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

1
2
3
 
GLfloat * vertices = (GLfloat*)malloc(sizeof(GLfloat) * model.object_.vertices.size() * 3);
GLuint * faces = (GLuint*)malloc(sizeof(GLuint) * model.object_.faces.size() * 4); // 4 car dans le .obj il y a 4 vertices par faces.

C'est très bien les vector, pourquoi allouer des tableaux manuellement ?

Si tu veux une copie c'est simple

Code :

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

1
2
std::vector<GLfloat> vertices = model.object_.vertices;
std::vector<GLuint> faces = model.object_.faces;

Ensuite je remplis ces tableaux

Code :

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

1
2
3
4
5
6
7
8
9
 
for (int i = 0; i < model.object_.vertices.size(); i++)
{
	vertices[j] = model.object_.vertices.at(i).coords[0];
	vertices[j + 1] = model.object_.vertices.at(i).coords[1];
	vertices[j + 2] = model.object_.vertices.at(i).coords[2];
 
	j += 3;
}

Ça c'est bon (une simple copie).

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
 
j = 0;	
 
for (int i = 0; i < model.object_.faces.size(); ++i)
{
	faces[j] = model.object_.faces.at(i).items.at(0).vertexIndex - 1; // -1 car le tableau des vertices commence à 0
	faces[j + 1] = model.object_.faces.at(i).items.at(1).vertexIndex - 1;
	faces[j + 2] = model.object_.faces.at(i).items.at(2).vertexIndex - 1;
	faces[j + 3] = model.object_.faces.at(i).items.at(3).vertexIndex - 1;
 
	j += 4;	
}
[...]
// La taille est comme cela car il y a 4 vertices par faces dans le .obj
glDrawElements(GL_TRIANGLES, model.object_.faces.size() * 4, GL_UNSIGNED_INT, 0); // des triangles composés de 4 vertices ? :o

Çà c'est plus suspect, tu devrais triangulariser ton modèle (que ce soit sous Blender, lors de l'export, ou lors de l'import).
Si tu ne triangularise pas, il faut dessiner des GL_QUADS et non des GL_TRIANGLES.

[j_sb12]

Salut,

C'est très bien les vector, pourquoi allouer des tableaux manuellement ?

Parce DrawElements demande un GLVoid* et je ne pense pas qu'un vector fonctionne dans cette fonction.

Çà c'est plus suspect, tu devrais triangulariser ton modèle (que ce soit sous Blender, lors de l'export, ou lors de l'import).
Si tu ne triangualise pas, il faut dessiner des GL_QUADS et non des GL_TRIANGLES.

J'ai triangualisé le .obj sous Blender. J'ai modifié le code en conséquence. J'ai passé j à j += 3 pour le décalage et supprimé la dernière ligne d'ajout.

Dans drawElements j'ai mis GL_TRIANGLES et une taille de 10 pour tester sur peu de points. Toujours rien.

En ce qui concerne le glVertex3f, je sais que c'est du vieuw openGL mais il fallait bien que je teste au moins un affichage..

[dragonjoker59]

vector fonctionne tout à fait avec glDrawElements grâce à son utilisation de mémoire continue.
Tu peux donc utiliser &monvector[0] ou monvector.data()

[j_sb12]

Je pensais que c'était justement le contraire, je pensais qu'ils n'étaient pas à la suite.

J'ai dû mal écouter en cours... haha

Je teste ça et je vous dis !

[j_sb12]

Bon j'ai tout mis dans deux vectors.

Code :

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

1
2
3
4
5
6
7
 
for (int i = 0; i < model.object_.vertices.size(); i++)
{
	vertices.push_back(model.object_.vertices.at(i).coords[0]);
	vertices.push_back(model.object_.vertices.at(i).coords[1]);
	vertices.push_back(model.object_.vertices.at(i).coords[2]);
}

Code :

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

1
2
3
4
5
6
7
 
for (int i = 0; i < model.object_.faces.size(); ++i)
{
	faces.push_back(model.object_.faces.at(i).items.at(0).vertexIndex - 1);
	faces.push_back(model.object_.faces.at(i).items.at(1).vertexIndex - 1);
	faces.push_back(model.object_.faces.at(i).items.at(2).vertexIndex - 1);	
}

Ensuite j'ai modifié les glBufferData mais je suis sceptique. Dois-je mettre faces.data() ou alors &faces ? idem pour vertices.

Code :

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

1
2
 
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_STATIC_DRAW);

Code :

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

1
2
 
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(faces), faces.data(), GL_STATIC_DRAW);

Pour drawElements j'ai :

Code :

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

1
2
 
glDrawElements(GL_TRIANGLES, faces.size(), GL_UNSIGNED_INT, faces.data());

Toujours rien.

[dragonjoker59]

Tu ne dois pas utiliser sizeof( monvector ) mais monvector.size() * sizeof(type de coordonnées (float?))EDIT:

Et c'est bien monvector.data() que tu dois utiliser.

[j_sb12]

Cela fait planter le programme. Selon des topics sur le net, c'est un taille trop grande qui est allouée par rapport à la taille réelle. J'ai donc décidé de mettre seulement

10 * sizeof(GLfloat)

et

10 * sizeof(GLuint)

pour tenter de faire fonctionner au moins quelque chose mais en vain.

J'ai regardé les codes d'erreurs et le glBufferData du VBO me renvoie l'erreur

GL_INVALID_ENUM

.

D'après la doc,

GL_INVALID_ENUM is generated if target is not one of the accepted buffer targets.

GL_INVALID_ENUM is generated if usage is not
GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY,
GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY,
GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY.

C'est pourtant bon...

Le glBufferData de l'EBO ne génère aucune erreur à part aussi un plantage si je laisse la taille comme tu m'as dit.

[j_sb12]

Je suis allé voir un camarade de classe qui m'a aidé. Je n'ai plus le crash après glDataBuffer mais ça ne fonctionne toujours pas.

De plus j'ai toujours l'erreur INVALID_ENUM.

Les modifications sont :

Code :

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

1
2
3
4
5
6
7
8
9
 
// &vertices transformé en &vertices[0]
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(GLfloat), &vertices[0], GL_STATIC_DRAW);
 
// &faces transformé en &faces[0]
glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces.size() * sizeof(GLuint), &faces[0], GL_STATIC_DRAW);
 
// faces.data transformé en 0
glDrawElements(GL_TRIANGLES, faces.size(), GL_UNSIGNED_INT, 0);

[dragonjoker59]

Bon, on va revoir les bases.

Déjà quand on a des problèmes avec OpenGL, on ne se pose pas la question, on met des glGetError après chaque appel d'une fonction OpenGL.
Ce qui se fait généralement, c'est une macro qui sera désactivée en Release, ainsi on ne perd pas de temps à les enlever puis les remettre.

Ensuite, j'aimerais voir le code d'initialisation de ton VAO.

[j_sb12]

C'est que j'avais fait, c'est pour cela que je dis que le glGetError renvoie GL_INVALID_ENUM.
Mais après avoir regardé de plus près et sur le net, cette erreur vient de

glExperimental = GL_TRUE

Juste après cette ligne (qui est dans ma fonction qui initialise la fenêtre) j'affiche l'erreur. L'erreur GL_INVALID_ENUM apparaît mais tous les autres appels suivant à glGetError me renvoie : pas d'erreur.

Je suppose donc que l'erreur reste en mémoire tant qu'il n'y a pas eu d'autres erreurs. Mon code a l'air donc bon. Enfin la forme est bonne.

Voici le code de mon VAO, VBO et BEO :

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
 
GLuint VBO, VAO, EBO;
 
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
 
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
 
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(GLfloat), &vertices[0], GL_STATIC_DRAW);
 
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
 
glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces.size() * sizeof(GLuint), &faces[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);

[dragonjoker59]

Si tu enlèves la ligne 17 glBindBuffer(GL_ARRAY_BUFFER, 0);, il se passe quoi?

[j_sb12]

J'ai refais des tests.

J'ai mis en dur dans les vecteurs les coordonnées de deux triangles formant un rectangle.

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
 
std::vector<GLfloat> vertices_vector;
std::vector<GLuint> faces_vector;
 
vertices_vector.push_back(0.5f);
vertices_vector.push_back(0.5f);
vertices_vector.push_back(0.0f);
 
vertices_vector.push_back(0.5f);
vertices_vector.push_back(-0.5f);
vertices_vector.push_back(0.0f);
 
vertices_vector.push_back(-0.5f);
vertices_vector.push_back(-0.5f);
vertices_vector.push_back(0.0f);
 
vertices_vector.push_back(-0.5f);
vertices_vector.push_back(0.5f);
vertices_vector.push_back(0.0f);
 
 
faces_vector.push_back(0);
faces_vector.push_back(1);
faces_vector.push_back(3);
 
faces_vector.push_back(1);
faces_vector.push_back(2);
faces_vector.push_back(3);

Ces coordonnées viennent d'un tutoriel de LearnOpenGL. J'ai testé le code fourni, il fonctionne donc elles sont bonnes. Le code fonctionne avec des tableaux ces mêmes valeurs en dur mais avec les vectors, ça ne fonctionne pas.

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
 
glBindBuffer(GL_ARRAY_BUFFER, VBO);	
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * vertices_vector.size(), &vertices_vector[0], GL_STATIC_DRAW);
 
//glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // Ligne utilisée lorsque c'est un tableau
 
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint) * faces_vector.size(), &faces_vector[0], GL_STATIC_DRAW);
 
//glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);// Ligne utilisée lorsque c'est un tableau	
 
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
 
glBindBuffer(GL_ARRAY_BUFFER, 0);
 
glBindVertexArray(0);
 
 
// Dans la boucle
glDrawElements(GL_TRIANGLES, faces_vector.size(), GL_UNSIGNED_INT, 0);

Lorsque je modifie la taille dans DrawElements, cela ne change rien. Je soupçonne donc VertexAttribPointer et BufferData.

Les sommets sont 3 par 3 alors VertexAttribPointer me semble bon et BufferData aussi m'a l'air bon mais au point où j'en suis je ne sais plus quoi penser ...