[ JOGL ] Display VBO

**gladek** · 26/11/2010, 16h11

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** · 27/11/2010, 00h13

Bonjour,

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

**gladek** · 29/11/2010, 11h22

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** · 29/11/2010, 11h28

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** · 01/12/2010, 18h06

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** · 01/12/2010, 18h30

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** · 01/12/2010, 18h30

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

[ JOGL ] Display VBO

OpenGL

Vue hybride

Discussions similaires

Partager

Partager