Discussion :

[MrDuChnok]

Bonjour,

Je me tourne vers la communauté car mes connaissances sur OpenGL commence à dater un peu... Mon besoin est assez simple : importer et dessiner une forme (mesh) contenant plusieurs materiaux (textures).
L'import, ça j'ai réussi à faire, en me basant sur un parseur existant (libASE).
Je me retrouve donc avec toutes les données nécessaires pour afficher ma forme, mais c'est là que je sèche...
J'ai donc un liste de faces avec pour chacune des faces :
- 3 vertex
- 3 coordonnées de textures
- le matériel à utiliser
- la normal de la face.

Comment je peux donc maintenant faire pour dessiner ma forme ?
Je comptais faire un truc comme ça :

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
62
63
64
65
66
67
68
69
70
 
// Render all scene
                for( int i=0; i<_meshList.size(); i++ )
                {
                        OBJMesh m = (OBJMesh)_meshList.get( i );
 
                        // If current material has texture, bind it
                        if( m.material.texId > 0 )
                        {
                                gl.glEnable( GL.GL_TEXTURE_2D );
                                gl.glBindTexture( GL.GL_TEXTURE_2D, m.material.texId );
                        }
                        else
                        {
                                gl.glDisable( GL.GL_TEXTURE_2D );
                                gl.glBindTexture( GL.GL_TEXTURE_2D, 0 );
                        }
 
                        gl.glMaterialfv( GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[]{m.material.ambient.x, m.material.ambient.y, m.material.ambient.z, m.material.alpha}, 0 );
                        gl.glMaterialfv( GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, new float[]{m.material.diffuse.x, m.material.diffuse.y, m.material.diffuse.z, m.material.alpha}, 0 );
                        gl.glMaterialfv( GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, new float[]{m.material.specular.x, m.material.specular.y, m.material.specular.z, m.material.alpha}, 0 );
                        gl.glMateriali( GL.GL_FRONT_AND_BACK,GL.GL_SHININESS, 128 );
 
                        // render triangles.. this is too basic. should be optimized
                        gl.glBegin( GL.GL_TRIANGLES );
                        gl.glColor4f( m.material.diffuse.x, m.material.diffuse.y, m.material.diffuse.z, m.material.alpha );
                        boolean has_texture=false;
                        if(_texcoordList!=null&&_texcoordList.size()>0)
                        {
                                has_texture=true;
                        }
                        for( int fi=0; fi<m.faceList.size(); fi++ )
                        {
                                OBJFace f = (OBJFace)m.faceList.get( fi );
 
                                p1 = (Vector3f)_vertexList.get(f.a);
                                p2 = (Vector3f)_vertexList.get(f.b);
                                p3 = (Vector3f)_vertexList.get(f.c);
                                n1 = (Vector3f)_normalList.get(f.na);
                                n2 = (Vector3f)_normalList.get(f.nb);
                                n3 = (Vector3f)_normalList.get(f.nc);
 
                                //these should only be drawn if there are texture 2d coordinates
                                if(has_texture){
                                        tc1 = (Vector3f)_texcoordList.get(f.ta);
                                        tc2 = (Vector3f)_texcoordList.get(f.tb);
                                        tc3 = (Vector3f)_texcoordList.get(f.tc);
                                }
 
                                gl.glNormal3f( n1.x, n1.y, n1.z );
                                if(has_texture){
                                        gl.glTexCoord2f( tc1.x, tc1.y );
                                }
                                gl.glVertex3f( p1.x, p1.y, p1.z );
 
                                gl.glNormal3f( n2.x, n2.y, n2.z );
                                if(has_texture){
                                        gl.glTexCoord2f( tc2.x, tc2.y );
                                }
                                gl.glVertex3f( p2.x, p2.y, p2.z );
 
                                gl.glNormal3f( n3.x, n3.y, n3.z );
                                if(has_texture){
                                        gl.glTexCoord2f( tc3.x, tc3.y );
                                }
                                gl.glVertex3f( p3.x, p3.y, p3.z );
                        }
                        gl.glEnd();
                }
        }

mais j'ai pas le droit d'utiliser les glBegin / glEnd sous openGL ES....
Donc si vous aviez une piste pour m'aider, ça serait cool.
Merci.

[LittleWhite]

Bonjour,

Je trouve cela rare de voir un programmeur de OpenGL ES , mais chance, je m'y connais un peu.
Il faut savoir, qu'OpenGL ES ( dès la version 1), n'embarque pas les glBegin() / glEnd() ni tout le blabla associé à ces fonctions ( glVertex*() glColor*() ).
Donc, et comme tant à devenir OpenGL ( desktop ), nous devons utiliser des pointeurs directement sur les données que l'on veut envoyé à la carte graphique.
La première documentation à voir ( car les ressources manques un peu sur internet, pour cette branche d'OpenGL ) c'est directement le site de Khronos ( qui est l'organisation développant la spécification ).
http://www.khronos.org/registry/gles/ -> http://www.khronos.org/opengles/sdk/1.1/docs/man/

Les fonctions sur lesquelles il faut se pencher sont:
- http://www.khronos.org/opengles/sdk/...texPointer.xml ( vertex )
- http://www.khronos.org/opengles/sdk/...lorPointer.xml ( couleurs brutes )
- http://www.khronos.org/opengles/sdk/...ordPointer.xml ( textures )
- http://www.khronos.org/opengles/sdk/...glMaterial.xml ( materiaux ( cela est quasi identique à OpenGL )
- http://www.khronos.org/opengles/sdk/...malPointer.xml ( normales )

- http://www.khronos.org/opengles/sdk/...lientState.xml ( pour activer les différents pointeurs ) ( ne pas oublier les glDisableClientState() )
- http://www.khronos.org/opengles/sdk/...DrawArrays.xml ( pour dessiner le tout )

[MrDuChnok]

Salut,

Tout d'abord merci de ton intérêt pour mon problème.
Là j'arrive bien à afficher un mesh sur l'iphone (enfin il ressemble au résultat attendu ^^). mais les textures ne sont pas bien positionnées.
En effet, pour mon mesh, j'ai plusieurs textures (images) à placer sur mes faces, mais je n'ai qu'un seul gros tableau de coordonnées de textures.
Du coup, comment faire pour lui dire que pour cette face là, c'est ces coodonnées là de textures qu'il faut utilisés, combinées à cette texture (image) ?

[LittleWhite]

Je pense que votre problème est lié à un problème de compréhension des données lus dans le fichier du mesh.

Je ne suis pas sur d'avoir compris si c'était du multitexturing ( application de deux textures au même endroit ) ou pas.
Sinon, c'est un jeu avec les textures ( glBindTexture() ) et les différents pointeurs de coordonnées de texture.

Sinon, je pense que les coordonnées de textures, sont dans le même ordre que les points du mesh. Donc juste le glTexCoordPointer() suffira. ( Il faut juste savoir si les coordonnées de textures ont deux, ou quatres composantes par point ).

[MrDuChnok]

en faite, je ne fais pas du multitexturing à proprement parlé (pas 2 textures sur un même triangle). Mais je cherchais à réaliser simplement 2 textures sur 2 triangles d'un même ensemble (model, mesh).

Donc voilà ce que j'ai fini par faire :
au moment du parsing de mon fichier, je regroupe par "matériaux" mes différentes faces.
Ensuite je construit un buffer pour chacun de ces groupes.
Et enfin, avant de dessiner chacun de ces groupes de face, je bind la bonne texture (le bon matériel).
et ça marche