[ JOGL ] Display VBO

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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];
    }
 
}

27/11/2010, 00h13
LittleWhite

Bonjour,

Citation:

Envoyé par gladek

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 ...
29/11/2010, 11h22
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 ?
29/11/2010, 11h28
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.
01/12/2010, 18h06
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 ?

pour infos voici un cube en .obj :

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
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

01/12/2010, 18h30
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 ...
02/12/2010, 11h07
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).
02/12/2010, 11h20
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.

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:

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
    }

02/12/2010, 13h56
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 :aie: (que l'on peut lire sur la wiki d'OpenGL)
Et le code que ovus me montrez, fonctionne?

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:

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
    }

02/12/2010, 18h40
gladek

Pour aider voici des screenshots du rendu de drawArrays :

MODE DIRECT GL_TRIANGLE_FAN
-> renderer POINT
http://img15.imageshack.us/img15/283...tivepoints.png

-> renderer LINE
http://img228.imageshack.us/img228/4...mitiveline.png

MODE VBO renderer LINE
drawArrays POINTS :
http://img802.imageshack.us/img802/7...ysglpoints.png

drawArrays TRIANGLES :
http://img571.imageshack.us/img571/4...gltriangle.png

drawArrays TRIANGLES_STRIP :
http://img440.imageshack.us/img440/4...gltriangle.png

drawArrays POLYGON :
http://img530.imageshack.us/img530/6...sglpolygon.png
02/12/2010, 18h55
gladek

MODE DIRECT GL_TRIANGLE_STRIP
-> renderer FILL

http://img193.imageshack.us/img193/2...ererfilltr.png

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"
02/12/2010, 19h00
gladek

MODE VBO GL_POLYGON
-> renderer FILL

http://img28.imageshack.us/img28/728...rendererfi.png

Voici mon rendu :
http://img190.imageshack.us/img190/3729/teapot.png

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:

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
        }
    }

09/12/2010, 13h36
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 ?
09/12/2010, 14h06
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?
10/12/2010, 15h48
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 ?

Voici mon code qui ordonne mes index :

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
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

Voir 40 message(s) de cette discussion en une page