Problème VBO openGl [Résolu]

[Lintel-oo]

Bonjour à tous
Je m'intéresse en ce moment aux vbos et je doit dire que malgré de nombreux tutos je galère encore pas mal et je me heurte à un problème d'affichage pour ne serait-ce qu'un cube. Je ne vois en effet aucun point s'afficher lorsque j'utilise les vbos, ce qui n'est pas le cas avec une méthode "classique" glBegin(...) (mon problème ne vient donc pas d'un mauvais positionnement de la caméra ou quelque chose dans le genre). Voici mon code :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
glGenBuffers(4,m_numberVBO);
 
    glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[0]);
    glBufferData(GL_ARRAY_BUFFER, m_vertexBufferList->size(), m_vertexBuffer, GL_DYNAMIC_DRAW);
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_numberVBO[1]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_elementBufferList->size(), m_elementBuffer, GL_DYNAMIC_DRAW);
 
    if(m_bindColor)
    {
        glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[2]);
        glBufferData(GL_ARRAY_BUFFER, m_colorBufferList->size(), m_colorBuffer, GL_DYNAMIC_DRAW);
    }
 
    if(m_bindTexture)
    {
        glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[3]);
        glBufferData(GL_ARRAY_BUFFER, m_textCoordBufferList->size(), m_textCoordBuffer, GL_DYNAMIC_DRAW);
    }
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

Comme vous pouvez le voir, je génère tout d'abord 4 buffers (un pour les vertices, un pour les index, un pour les couleurs et un pour les textures). Je les remplis par des tableaux de données dynamiques dont les valeurs proviennent des 4 références sur std::list<int ou double> passées en argument, dont la taille est passée en paramètre à chaque glBufferData (par exemple m_vertexBufferList->size()). Les 4 listes sont pointées dans la classe par 4 pointeurs et ces 4 pointeurs sont "bons" au début de l'affichage (pas de problème de mémoire ni de modification de données).
Le problème est donc lors de l'affichage, mais je ne sais pas où (voici mon code) :

Code :

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
 
glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[0]);
    glVertexPointer(3, GL_DOUBLE, 3*m_sizeVBO*sizeof(double),((double*)NULL + (0)));
 
    if(m_bindColor)
    {
        glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[2]);
        glColorPointer(3, GL_DOUBLE, 3*m_sizeVBO*sizeof(double), ((double*)NULL + (0)));
    }
 
    if(m_bindTexture)
    {
        glBindBuffer(GL_ARRAY_BUFFER, m_numberVBO[3]);
        glTexCoordPointer(2, GL_DOUBLE, 2*m_sizeVBO*sizeof(double), ((double*)NULL + (0)));
    }
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_numberVBO[1]);
 
    glEnableClientState(GL_VERTEX_ARRAY);
    if(m_bindColor)
        glEnableClientState(GL_COLOR_ARRAY);
    if(m_bindTexture)
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    glDrawElements(GL_QUADS, m_elementBufferList->size(), GL_UNSIGNED_INT, ((int*)NULL + (0)));
 
    if(m_bindColor)
        glDisableClientState(GL_COLOR_ARRAY);
    if(m_bindTexture)
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);

C'est la que j'ai besoin de votre aide, car rien de s'affiche et pourtant je ne vois pas ce qui peut clocher dans ce code. Ai-je oublié quelque chose de fondamental ? Sachant que cette fonction draw est appelée dans un contexte permettant l'affichage d'éléments (lorsque j'utilise les glBegin() dans la fonction appelant draw, après le glClear() et avant le glFlush(), les surfaces s'affichent !)
J'espère avoir été relativement clair, si vous avez des questions n'hésitez pas

[dragonjoker59]

std::list est un très mauvais choix pour un VBO car les données ne sont pas dans un espace mémoire contigü.
Utilise des std::vector qui eux garantissent la contigüité des données en mémoire.
De plus, donner le pointeur directement ne fera pas non plus ton affaire, je te conseille de passer un pointeur sur le premier élément de ton vector :
& (*m_vertexBuffer)[0]

[LittleWhite]

Bonjour,

Code :

1
2
3
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_elementBufferList->size(), m_elementBuffer, GL_DYNAMIC_DRAW);
glColorPointer(3, GL_DOUBLE, 3*m_sizeVBO*sizeof(double), ((double*)NULL + (0)));
glBufferData(GL_ARRAY_BUFFER, m_colorBufferList->size(), m_colorBuffer, GL_DYNAMIC_DRAW);

J'ai quelques doutes par rapport à ses appels. Notamment du fait que vous semblez avoir des buffers indépendants et que du coup, le stride pourrait être de 0.

Je vous conseille d'utiliser un débogueur, du style gDEBugger (qui est maintenant gratuit). Il vous permettra de voir le contenu des buffers envoyés à OpenGL et même de les afficher selon les stride / offset (ça ne peut qu'aider).

[Lintel-oo]

Je viens de trouver un problème important grâce au debugger que tu m'as indiqué (je t'en remercie d'ailleurs cet outil m'a l'air d'être bien adapté ). En effet, lors de l'initialisation dynamique des buffers, je donnais une taille de sizeof(vertexBuffer.size()) à la place de vertexBuffer.size() (j'avais oublié d'enlevé le sizeof car je testais d'autres choses). Les vbo ne contenaient en effet pas assez de données (d'après le debugger). J'ai également changé les list en vector même si il était évident que cela ne changerait rien au problème même si c'est toujours utile . Cependant, le problème persiste et les buffers sont toujours aussi petits (environ 4 fois plus petits que la taille initiale). Je me demande donc d'où cela peut provenir. Je vais effectuer d'autres tests dans la soirée pour essayer d'en savoir plus !

[gbdivers]

Envoyé par Lintel-oo

En effet, lors de l'initialisation dynamique des buffers, je donnais une taille de sizeof(vertexBuffer.size()) à la place de vertexBuffer.size() (j'avais oublié d'enlevé le sizeof car je testais d'autres choses).

Il ne faut pas hésiter à lire la doc des fonctions que l'on utilise... Tu es sensé donner la taille en octet. La taille que tu donnes est le nombre d'éléments du tableau. La bonne façon (et unique) :

Code :

sizeof(float) * vertexBuffer.size()

Est ce que tu réalises ce que tu récupère avec le sizeof suivant :

Code :

sizeof(vertexBuffer.size())

Envoyé par Lintel-oo

J'ai également changé les list en vector même si il était évident que cela ne changerait rien au problème même si c'est toujours utile

Cette phrase me fait penser que tu n'as pas compris ce que fait la fonction et ce qu'est un buffer
Utiliser un vector n'est pas optionnel ici

Il semble qu'il te manque des bases en C++ et en gpu. Tu peux lire le tutoriel que j'ai donné
Bon courage

[Lintel-oo]

En fait je dupliquais les buffers :
la liste (maintenant le vector) passé(e) en argument était pointée à l'intérieur de la classe afin de récupérer la taille du buffer, et ses données étaient recopiées à l'intérieur d'un tableau dynamique alloué par new[taille du vector passé en argument] permettant de le passer en argument lors de la construction du VBO (je ne passais pas l'adresse du vector (de la liste) car je ne savais pas que les données dans un vector étaient contigues, ce qui explique pourquoi je pensais que mettre des vector à la place de liste ne changerait rien )
Je suis peut être en train de me tromper en disant cela, si c'est le cas dites le moi car mon niveau n'est pas très élevé, surtout en ce qui concerne opengl que je n'ai pas encore eu l'occasion d'utiliser réellement
Pour ce qui concerne la taille des buffers passée en argument lors de la construction du vbo, j'ai effectivement oublié le sizeof(type de données). Maintenant les vbo sont bien construits et contiennent les bonnes données mais pourtant toujours rien ne s'affiche. Avez-vous une explication ? (encore une ^^)
Je peux vous repasser le code si vous le souhaitez

[Lintel-oo]

Ca y est j'ai trouvé
J'ai regardé la doc opengl et je me suis rendu compte que le troisième paramètre de la fonction glvertexpointer (ou glcolorpointer) n'était pas la taille du tableau mais "l'espace" entre chaque vertex dans le buffer
Maintenant le cube s'affiche correctement
sujet résolu merci pour votre aide