Terminapor I'll see you rise. | Je sais pas si tu dois tout faire à la main, ou s'il vous ont fourni des outils.
En faisant un petit tours sur internet, le format STL (en ASCII) est comme ça :
facet normal ni nj nk
outer loop
vertex v1x v1y v1z
vertex v2x v2y v2z
vertex v3x v3y v3z
endloop
endfacet
En gros, pour chaque triangle tu as :
Sa normal ( nX, nY,nZ)
Et les 3 sommets.
Sache que si tu souhaites utiliser la normal (ça indique l'orientation d'une surface, c'est utilisé pour les lumières), openGL t'imposera d'avoir une normal / sommets.
En gros, la structure d'un modèle dans openGL se découpe comme ça :
Vertex :
Position (XYZ)
Normal (XYZ)
etc, etc
Face :
Index[3] <- Les 3 indices des sommets (on admet que tu vas dessiner des triangles)
La seule "obligation", c'est d'avoir la position du vertex. Le reste, tout dépend:
Si tu utilise OpenGL 1.X (je te le recommande, il est plus utilisé mais plus facile d'accès), les attributs par sommets sont limités.
Pour chaque sommet, tu peux définir la position, la normal, la couleur et les coordonnées UVs (pour les textures).
Bref, donc au final, le but ça va être de pouvoir stocker dans un tableau les sommets, et un autre les indices des triangles et d'utiliser des glBegin/glEnd (encore une fois, c'est déprécié mais si tu dois te manger des shaders + VBO ça va être compliqué  )
Un exemple (pour dessiner un quad)
Code :
- int main( int arg_c, char* arg_v[] )
- {
- //-------------------------------------
- // On initialise la matrix de projection
- // Projection orthographique ( en admettant que ta fenêtre est en 800x600)
- // zNear/zFar à - et + 1000 (cf google pour savoir ce que c'est)
- // Comme glOrtho effectue une multiplication, il faut d'abord charger la matrix d'identité (cf google pour les détails)
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0,800,600,0,-1000.f,1000.f);
- //-------------------------------------
- //-------------------------------------
- // On initialise la matrice modelview
- // Elle est à la fois la matrice qui est utilisée pour la caméra
- // Et celle utilisée pour les transformations du model (rotation/translation/changement d'échelle)
- // Dans cet exemple, on veut just la matrice d'identité (pas de caméra ou quoi)
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- //-------------------------------------
- //-------------------------------------
- // Boucle principale
- while ( IsRunning )
- {
- //-----------------
- // Dessin d'une primitive
- // Dans ce cas, un Quad
- // Tu as GL_TRIANGLE pour les tris
- glBegin (GL_QUAD);
- glNormal3f(0.0f, 0.0f, 1.0f); // Normal : (0,0,-1)
- glVertex3f(0.0f, 0.0f, 0.0f); // Position : (0,0,0)
- glNormal3f(0.0f, 0.0f, 1.0f); // Normal : (0,0,-1)
- glVertex3f(128.0f, 0.0f, 0.0f); // Position : (128,0,0)
- glNormal3f(0.0f, 0.0f, 1.0f); // Normal : (0,0,-1)
- glVertex3f(128.0f, 128.0f, 0.0f); // Position : (128,128,0)
- glNormal3f(0.0f, 0.0f, 1.0f); // Normal : (0,0,-1)
- glVertex3f(0.0f, 128.0f, 0.0f); // Position : (0,128,0)
- glEnd();
- //-----------------
- }
- //-------------------------------------
- // Ici tu rafraîchis ta fenêtre (tout dépend de l'API)
- }
|
Donc, dans ton cas, il faudra stocker les infos du modèle dans deux tableaux (un pour les sommets, l'autre pour les indices des triangles) :
Code :
- struct GLVertex
- {
- float Location[3];
- float Normal[3];
- GLVertex(float x, float y, float z, float nX, float nY, float nZ )
- {
- Location[0] = x;
- Location[1] = y;
- Location[2] = z;
- Normal[0] = nX;
- Normal[1] = nY;
- Normal[2] = nZ;
- }
- };
- struct GLTriangle
- {
- int Indices[3];
- GLTriangle( int Index0, int Index1, int Index2 )
- {
- Indices[0] = Index0;
- Indices[1] = Index1;
- Indices[2] = Index2;
- }
- };
- int main( int arg_c, char* arg_v[] )
- {
- std::vector<GLVertex> Vertices;
- std::vector<GLTriangle> Triangles;
- /*================================
- On veut dessiner un quad (cette fois avec des triangles)
- v0 v1
- +-----+
- |\ |
- | \ t0|
- | \ |
- | t1\ |
- | \|
- +-----+
- v3 v2
-
- Il faut penser à respecter l'ordre (faut que la primitive se fasse
- en CW (pour t0 d'abords v0, ensuite v1, et enfin v2 et pas dans l'autre sens)
- Normalement, le format STL doit avoir les sommets dans l'ordre cyclique.
-
- ================================*/
- //--------------------------------
- // Initialisation des tableaux
- Vertices.push_back( GLVertex(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f) );
- Vertices.push_back( GLVertex(128.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f) );
- Vertices.push_back( GLVertex(128.0f, 128.0f, 0.0f, 0.0f, 0.0f, 1.0f) );
- Vertices.push_back( GLVertex(0.0f, 128.0f, 0.0f, 0.0f, 0.0f, 1.0f) );
- Triangles.push_back( GLTriangle(0,1,2) );
- Triangles.push_back( GLTriangle(0,2,3) );
- //--------------------------------
- //-------------------------------------
- // On initialise la matrix de projection
- // Projection orthographique ( en admettant que ta fenêtre est en 800x600)
- // zNear/zFar à - et + 1000 (cf google pour savoir ce que c'est)
- // Comme glOrtho effectue une multiplication, il faut d'abord charger la matrix d'identité (cf google pour les détails)
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0,800,600,0,-1000.f,1000.f);
- //-------------------------------------
- //-------------------------------------
- // On initialise la matrice modelview
- // Elle est à la fois la matrice qui est utilisée pour la caméra
- // Et celle utilisée pour les transformations du model (rotation/translation/changement d'échelle)
- // Dans cet exemple, on veut just la matrice d'identité (pas de caméra ou quoi)
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- //-------------------------------------
- //-------------------------------------
- // Boucle principale
- while ( IsRunning )
- {
- //-----------------
- // Dessin des tris
- glBegin(GL_TRIANGLES);
- for (size_t i=0; i< Triangles.size(); ++i )
- {
- for ( int j=0;j<3;++j )
- {
- const GLVertex& Vtx = Vertices[ Triangles[i].Indices[j] ] ;
- glNormal3f( Vtx.Normal.x, Vtx.Normal.y, Vtx.Normal.z );
- glVertex3f( Vtx.Location.x, Vtx.Location.y, Vtx.Location.z );
- }
- }
- glEnd();
- //-----------------
- // Ici tu rafraîchis ta fenêtre (tout dépend de l'API)
- }
- //-------------------------------------
- }
|
Je t'invite à zieuter les tutos sur le web pour la gestion de la camera (avec les gluLookAt et les matrix de projection en perspective ).
Normalement tu as tout ce qu'il faut là, il te reste plus qu'à écrire ta fonction pour charger un fichier STL en stockant dans des tableaux les indices & sommets.
Je te conseille de commencer par laisser tomber la normal ( vu que c'est une normal/faces dans ce format, il faudra calculer par sommets) et à la rigueur dessiner ton modèle en wireframe (glPolygonMode(GL_LINE) avant les glBegin/glEnd, pour repasser en mode "normal" faut faire glPolygonMode(GL_FILL) il me semble).
---------------
Perhaps you don't deserve to breathe
|
.
.