Discussion :

[gladek]

Salut,

J'essaie de mettre en place les VBO sur mon projet.
L'affichage présente qq bizarreries... il ne manque pas grand chose

Je charge des .obj, ils sont tres bien affichés via la méthode classique de rendering (glBegin(), glEnd()). Je peux changer seul le parametre : GL.POINT, GL.QUAD, GL.TRIANGLES, etc.. et l'affichage reste parfait.

Or avec les VBO, si je dessine en GL.POINT, l'affichage est correct mais en GL.TRIANGLES voir STRIP seul la moitié des faces est dessiné.
Exemple un carré n'aura qu'un des 2 triangles le constituant...

Via des Junit je suis sur de stocker dans le bon ordre mes vertexData, le bon nombre de vertex etc..

AVez vous des pistes pour m'orienter ?

je glisse mon code source :

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
public class VBORenderer implements Renderer<SolidObjet> {
 
    private GL gl = AbstractScene.GL;
 
    private int verticesId;
    // private int indexId;
    private int nbVertices;
 
    // private int nbIndex;
 
    public void init(SolidObjet objet) {
        VertexBufferObjectStructure vbo = objet.getStructure().getVertexBufferObject();
        this.nbVertices = vbo.getNbVertices();
        // this.nbIndex = vbo.getIndexNb();
 
        // Generate a new buffer object
        // Bind the buffer object
        this.verticesId = generateID();
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, verticesId);
        gl.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB, vbo.getVertexData().capacity() * BufferUtil.SIZEOF_FLOAT,
                vbo.getVertexData(), GL.GL_STATIC_DRAW_ARB);
 
        // // Index vertices
        // this.indexId = generateID();
        // gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId);
        // gl.glBufferDataARB(GL.GL_ELEMENT_ARRAY_BUFFER, vbo.getIndexData().capacity() *
        // BufferUtil.SIZEOF_INT,
        // vbo.getIndexData(), GL.GL_STATIC_DRAW_ARB);
    }
 
    public void render(SolidObjet objet) {
 
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, verticesId);
        // gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId);
 
        // Enable Pointers
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY); // Enable Vertex Arrays
 
        // Set The Vertex Pointer To The Vertex Buffer
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
 
        // Render
        // Draw All Of The Triangles At Once
        gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POINTS, 0, nbVertices);
        // gl.glDrawElements(GL.GL_TRIANGLES, nbIndex, GL.GL_UNSIGNED_INT, 0);
        // gl.glDrawElements(GL.GL_POINT, nbIndex, GL.GL_UNSIGNED_INT, 0);
 
        // Disable Pointers
        // Disable Vertex Arrays
        gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
    }
 
    private int generateID() {
        int[] tabId = new int[1];
        gl.glGenBuffersARB(1, tabId, 0);
 
        return tabId[0];
    }
 
}

[LittleWhite]

Bonjour,

Or avec les VBO, si je dessine en GL.POINT, l'affichage est correct mais en GL.TRIANGLES voir STRIP seul la moitié des faces est dessiné.
Exemple un carré n'aura qu'un des 2 triangles le constituant...

N'est ce pas là un problème de backface culling, donc d'ordre de présentation des vertices dans la carte graphique. Car si un triangle a ces vertex dans l'ordre des aiguilles d'une montre il sera affiché, mais pas dans l'autre sens (enfin pour l'exemple).
Cela peut se désactiver si besoin ... (malgré que ce soit une optimisation).

Enfin ceci est ma première idée ...

[gladek]

Ok j'ai désactivé
gl.glCullFace(faceHidden); //GL_FRONT or GL_BACK
gl.glEnable(GL.GL_CULL_FACE);

Plus de probleme, de triangle vide, mon carré est parfaitement remplit.
Au niveau des spheres j'ai des rendus en forme de sphere mais avec qq defauts,
je vais ajouter les normales pour mieux me rendre compte du rendu, je ne vois que la forme mais pas le relief...

Merci pour le backfaceculling.
Y a t il des algo pour corriger l'orientation des triangles quelque soit la forme ?

[LittleWhite]

Pour les normales, cela aidera si votre scene utilise des lumieres ... a mes aussi pour le backfacing ... je crois.

Sinon, il n'y a pas d'algo special, juste peut etre dans le plugin d'export en .obj de votre logiciel en 3D.

[gladek]

Je suis toujours sur ce probleme.
Ma scene contient des lumieres...

Je ne rencontrais pas ce soucis en mode primitif que ce soit pour POINTS, TRIANGLES, TRIANGLE_STRIP, LINE, POLYGON.

Quelque soit ma methode VBO le rendu echoue :

• dessine vertex apres vertex dans l'ordre lu dans le fichier
• dessine vertex apres vertex en ajoutant un buffer pour les index des vertices (l'ordre est défini par les faces du fichier)

A noté que

• lorsque j'ajoute les index de vertices(gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId)), ma scene semble plus éloignée...
• dessiner via gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, 0); fais chuter mon FPS a 5 au lieu de 70...

Avez vous des idées ou pistes ?

[gladek]

pour infos voici un cube en .obj :

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
# file generated by UVMapper
# NumVerts/NumTVerts/NumVNormals/NumFacets   8/24/8/6
# NumGroups/NumMaterials/NumRegions   1/1/0
# x/y/color/ppu   256/192/0/50.00000000
 
v -1.00000000 -1.00000000  1.00000000
v -1.00000000  1.00000000  1.00000000
v  1.00000000  1.00000000  1.00000000
v  1.00000000 -1.00000000  1.00000000
v -1.00000000 -1.00000000 -1.00000000
v -1.00000000  1.00000000 -1.00000000
v  1.00000000  1.00000000 -1.00000000
v  1.00000000 -1.00000000 -1.00000000
 
vt  0.26499999  0.35000002
vt  0.48999998  0.35000002
vt  0.48999998  0.65000004
vt  0.26499999  0.65000004
 
vt  0.26499999  0.32500002
vt  0.26499999  0.02500000
vt  0.48999998  0.02500000
vt  0.48999998  0.32500002
 
vt  0.24499999  0.65000004
vt  0.02000000  0.65000004
vt  0.02000000  0.35000002
vt  0.24499999  0.35000002
 
vt  0.48999998  0.67500001
vt  0.48999998  0.97500002
vt  0.26499999  0.97500002
vt  0.26499999  0.67500001
 
vt  0.50999999  0.35000002
vt  0.73500001  0.35000002
vt  0.73500001  0.65000004
vt  0.50999999  0.65000004
 
vt  0.98000002  0.65000004
vt  0.75500000  0.65000004
vt  0.75500000  0.35000002
vt  0.98000002  0.35000002
 
vn -0.57735002 -0.57735002  0.57735002
vn -0.57735002  0.57735002  0.57735002
vn  0.57735002  0.57735002  0.57735002
vn  0.57735002 -0.57735002  0.57735002
vn -0.57735002 -0.57735002 -0.57735002
vn -0.57735002  0.57735002 -0.57735002
vn  0.57735002  0.57735002 -0.57735002
vn  0.57735002 -0.57735002 -0.57735002
 
g cube1_default
usemtl default
f 1/1/1 4/2/4 3/3/3 2/4/2
f 1/5/1 5/6/5 8/7/8 4/8/4
f 2/9/2 6/10/6 5/11/5 1/12/1
f 3/13/3 7/14/7 6/15/6 2/16/2
f 4/17/4 8/18/8 7/19/7 3/20/3
f 6/21/6 7/22/7 8/23/8 5/24/5

[LittleWhite]

Il faut normalement dessiné les mesh en prenant en compte les index. Car c'est les index qui indiquent l'ordre des vertex, et donc l'orientation de la face.
Pour la commande 'glDrawElements()' j'imagine qu'il n'est pas très bon de lui donner 0 en dernier argument ...

[gladek]

J'ai un buffer pour mes vertices, un second pour les index, un troisieme pour mes normales.
Donc pour
gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, 0);

je pensais mettre zero 0, car il commence au premier index de mon buffer, je me trompe ?

Bien sur, une fois cette étape validée, je n'enverrai qu'un seul buffer (postions, normals, textCoord).

[LittleWhite]

Euh, c'est que je me trompe vraiment souvent avec les commandes de ce type.
Mais, d'apres la documentation je pense que le dernier parametres, doit etre le tableau d'indices.

[gladek]

en passant en parametre le buffer des indices je leve l'exception suivante :
Caused by: javax.media.opengl.GLException: array vertex_buffer_object must be disabled to call this method

levé par :
gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, vbo.getIndexData());

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
public void render(SolidObjet objet) {
        VertexBufferObjectStructure vbo = objet.getStructure().getVertexBufferObject();
 
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, verticesId);
        // gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, normalsId);
        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId);
 
        // Enable Pointers
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY); // Enable Vertex
        // gl.glEnableClientState(GL.GL_NORMAL_ARRAY); // Enable Normals
 
        // Set The Vertex Pointer To The Vertex Buffer
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
        // vbo.getVertexData());
        // gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
        // vbo.getNormalsData());
 
        // Render
        // Draw All Of The Triangles At Once
        // gl.glDrawArrays(GL.GL_TRIANGLES, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POLYGON, 0, nbVertices);
        gl.glDrawArrays(GL.GL_POINTS, 0, nbVertices);
        // gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, vbo.getIndexData());
        // indexId);
        // gl.glDrawElements(GL.GL_POINT, nbIndex, GL.GL_UNSIGNED_INT, 0);
 
        // Disable Pointers
        gl.glDisableClientState(GL.GL_VERTEX_ARRAY); // Disable Vertex Arrays
        // gl.glDisableClientState(GL.GL_NORMAL_ARRAY); // Disable Normals
    }

[LittleWhite]

Vous me montrez un autre code ... et je crois que vous aviez raison pour le 0 ... je me rappelle d'un truc assez etrange sur les VBO (que l'on peut lire sur la wiki d'OpenGL)
Et le code que ovus me montrez, fonctionne?

[gladek]

Le code suivant marche mais :
si je dessine avec glDrawElements je leve l'exception
si je dessine avec gl.glDrawArrays le rendu n'est pas correct (hormis en POINTS)

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
public void render(SolidObjet objet) {
        VertexBufferObjectStructure vbo = objet.getStructure().getVertexBufferObject();
        // Enable Pointers
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY); // Enable Vertex
        gl.glEnableClientState(GL.GL_NORMAL_ARRAY); // Enable Normals
 
        // vertices
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, verticesId);
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
 
        // normals
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, normalsId);
        gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
 
        // index
        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId);
 
        // Render
        // Draw All Of The Triangles At Once
        // gl.glDrawArrays(GL.GL_TRIANGLES, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POLYGON, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POINTS, 0, nbVertices);
        gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, vbo.getIndexV());
        // gl.glDrawElements(GL.GL_POINT, nbIndex, GL.GL_UNSIGNED_INT, vbo.getIndexV());
 
        // Disable Pointers
        gl.glDisableClientState(GL.GL_VERTEX_ARRAY); // Disable Vertex Arrays
        gl.glDisableClientState(GL.GL_NORMAL_ARRAY); // Disable Normals
    }

[gladek]

Pour aider voici des screenshots du rendu de drawArrays :

MODE DIRECT GL_TRIANGLE_FAN
-> renderer POINT


-> renderer LINE



MODE VBO renderer LINE
drawArrays POINTS :


drawArrays TRIANGLES :


drawArrays TRIANGLES_STRIP :


drawArrays POLYGON :

[gladek]

MODE DIRECT GL_TRIANGLE_STRIP
-> renderer FILL



Je pense que le probleme vient du sens de rotation de certains triangles...
J'en reviens au pb d'ordonnencement des vertex associés a ces "triangles inversés"

[gladek]

MODE VBO GL_POLYGON
-> renderer FILL

[gladek]

Voici mon rendu :


Mon code display VBO me semble correct voir à la fin de ce poste pour les curieux .
J'ai codé mon parser .obj, avec pas mal de junit pour tester les indices oud différentes données récoltées. En mode primitive tous s'affiche correctement.
Je fais attention de dessiner groupe par groupe, face apres face...

J'ai lu pas mal de topics negatifs sur les fichiers .obj.
J'ai remarqué que mes fichiers avaient des faces triangles, quads voir polygon.
Est ce une raison de cet affichage en VBO ?
Faut il que je retraite toutes mes vertices et index avec la triangularisation de delaunay ?

D'avance, merci de votre aide...

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
public void render(SolidObjet objet) {
        VertexBufferObjectStructure vbo = objet.getStructure().getVertexBufferObject();
        // Enable Pointers
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY); // Enable Vertex
        if (normalsId > 0) {
            gl.glEnableClientState(GL.GL_NORMAL_ARRAY); // Enable Normals
        }
 
        // vertices
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, verticesId);
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
        // normals
        if (normalsId > 0) {
            gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, normalsId);
            gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
        }
 
        // Render
        // Draw All Of The Triangles At Once
        // gl.glDrawArrays(GL.GL_TRIANGLES, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, nbVertices);
        // gl.glDr
        // gl.glDrawArrays(GL.GL_TRIANGLE_FAN, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POLYGON, 0, nbVertices);
        // gl.glDrawArrays(GL.GL_POINTS, 0, nbVertices);
        // index
        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER, indexId);
        gl.glDrawElements(GL.GL_QUADS, nbIndex, GL.GL_UNSIGNED_INT, 0);
        // gl.glDrawElements(GL.GL_TRIANGLES, nbIndex, GL.GL_UNSIGNED_INT, 0);
        // gl.glDrawElements(GL.GL_POLYGON, nbIndex, GL.GL_UNSIGNED_INT, 0);
 
        gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
 
        // Disable Pointers
        gl.glDisableClientState(GL.GL_VERTEX_ARRAY); // Disable Vertex Arrays
        if (normalsId > 0) {
            gl.glDisableClientState(GL.GL_NORMAL_ARRAY); // Disable Normals
        }
    }

[gladek]

un pti up
pas forcément LA solution... quoi que
mais si vous avez des pistes.

le dernier rendu illustre bien le mauvais tracé de ma tea_pot non ?

[LittleWhite]

Pour les spheres ... il y a le problemes d'orientation des triangles.

Pour le teapot ... peut etre que c'est juste a cause des quads ... sinon cela semble etre un probleme de strip ... mais le code n'utilise pas les strips a ce moment la. Sinon un probleme de lecture peut etre meme avec les indexs ?
(Ah! en regardant de plus pres, cela ne pourra jamais etre un probleme de strip, ou alors cela est a cause de vos groupes ?)

J'ai aussi remarque l'histoire des .obj qui ont des Triangles / Quads / Polygones, et juste pour cela, je n'aime pas du tout (cela oblige tout un tas de travail un peu inutile sur le renderer)

A quoi servirai la triangulation de Delaunay?

[gladek]

Je me concentre sur le teapot.obj qui semble un fichier simple pour tester mes VBO. Il ne contient que des faces TRIANGLE.
J'ecarte ainsi le pb des quads et polygons.

L'ordre des index est celui défini par les faces sans tenir compte du tout des groupes. Ainsi :
indexV1 = face1.indice1
indexV2 = face1.indice2
indexV3 = face1.indice3
Ainsi j'ai mon premier triangle et ainsi de suite...

Je le test via des junit et celui-ci est correct.

Une question, comment expliquer les faces reliés anormalement ?
Redondance d'index, mauvaise definition des index pour une face ?

[gladek]

Voici mon code qui ordonne mes index :

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
private void buildIndex(Data data, VertexBufferObjectStructure vbo) {
        // index vertices
        int nbIndex = data.getFaceNbElement();
        int[] indexV = new int[nbIndex];
        int[] indexVT = new int[nbIndex];
        int[] indexVN = new int[nbIndex];
 
        int j = 0;
        for (List<Integer> indices : data.getFaces()) {
            int i = 0;
            while (i < indices.size()) {
                indexV[j] = indices.get(i++);
                if (data.isFaceHaveVT()) {
                    indexVT[j] = indices.get(i++);
                }
                if (data.isFaceHaveVN()) {
                    indexVN[j] = indices.get(i++);
                }
                j++;
            }
        }
 
        vbo.addIndexV(indexV);
        vbo.addIndexVT(indexVT);
        vbo.addIndexVN(indexVN);
    }

PS : data contient les données du fichier .obj