Question de format !

Alors voila j'ai une question, est ce que le format ase pour les mesh est dur a coder, enfin à integrer dans un moteur?

Quel est le format d'esportation pour les animations?

Leger UP:

Bah alors personne n'a de reponse à me donner??, pourtant la question me semble simple non?

J'ai fait un loader ASE, c'est très facile étant donné que c'est un format texte. Par contre il ne gère pas les animations (enfin il ne me semble pas), et son désavantage est que les fichiers deviennent vite énormes dès que le modèle est un peu complexe.

est ce que tu pourrais me filer ton loader ase? car ce format m'interresse beaucoup pour le jeu c'est la reference et comme les modeles depassent pas les 10 000 poly c'est bon.

Citation:

Envoyé par ArKam

est ce que tu pourrais me filer ton loader ase? car ce format m'interresse beaucoup pour le jeu c'est la reference et comme les modeles depassent pas les 10 000 poly c'est bon.

Ce format c'est pas du tout une "référence" ^^. C'est juste qu'il est facile à charger, mais pas du tout une référence (trop limité et les fichiers montent trop vite en taille).

Voici mon loader (je te préviens, c'est un loader tout simple, en rien optimisé,...). Pour le chargement des images j'utilise une bibliothèque très légère appelé corona, mais rien ne t'empêche d'adapter le passage d'ouverture de textures à ce que tu connais.

"Mesh.hpp" :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#ifndef MESH_HPP
#define MESH_HPP
 
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <corona.h>
#include "Vector.hpp"
 
using namespace std;
 
struct aseVertex
{
   float x, y, z;
};
 
struct aseNormale
{
   float x, y, z;
};
 
struct aseTexture
{
   float u, v;
};
 
struct aseMaterial
{
   CVector ambDif; // Valeurs ambiant & diffuse
   CVector specular; // Valeurs specular
   std::string nomTexture; // Nom de la texture
};
 
struct aseFace
{
   int indexVertices [3];
   int indexTextures [3];
};
 
class CMesh
{
   public:
      CMesh ();
      ~CMesh ();
 
      bool OuvrirString (std::string contenuObj);
      bool OuvrirTexture ();
      void AssignerMaterial (aseMaterial sMaterial);
      void Shutdown ();
 
      void CreerTableauVertices ();
      void CreerTableauTexture ();
      void Dessiner ();
 
      int GetNumPoints () const {return m_iNumPoints;}
      int GetNumVertices () const {return m_iNumVertices;}
      int GetNumFaces () const {return m_iNumFaces;}
 
      std::vector <aseFace> GetFaces () const {return m_vFaces;}
      std::vector <aseVertex> GetVertices () const {return m_vVertices;}
 
   private:
      int m_iNumPoints;
      int m_iNumVertices;
      int m_iNumFaces;
      int m_iNumTCoords;
 
      bool m_bTexture;
      unsigned int m_uiTexture;
 
      unsigned int m_uiVBO;
 
      std::vector <aseVertex> m_vVertices;
      std::vector <aseNormale> m_vNormales;
      std::vector <aseFace> m_vFaces;
      std::vector <aseTexture> m_vTexCoords;
 
      aseMaterial m_sMaterial;
 
      float * tabVertices;
      float * tabTextures;
};
 
#endif // MESH_HPP

"Model.hpp" :

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
#ifndef MODEL_H
#define MODEL_H
 
#include <algorithm>
#include <cmath>
#include "Matrix.hpp"
#include "Mesh.hpp"
 
class CModel
{
   public:
      CModel ();
      virtual ~CModel ();
 
      bool OuvrirFichier (std::string nomFichier);
      void Shutdown ();
 
      void Dessiner ();
		void SetPosition (const float * matrix);
		void SetOffset ();
 
      int GetNumMeshs () const {return m_iNumMesh;}
      int GetNumFaces (int i) const {return m_vMeshs [i]->GetNumFaces ();}
 
		CVector GetLongueurs () const;
 
      CMesh * GetMesh (int i) const {return m_vMeshs [i];}
 
      std::vector <aseFace> GetFaces (int i) const {return m_vMeshs [i]->GetFaces();}
      std::vector <aseVertex> GetVertices (int i) const {return m_vMeshs [i]->GetVertices();}
 
   private:
      int m_iNumMesh;
      int m_iNumMaterials;
 
		Matrix _matrix;
		CVector _offset;
 
      std::vector <CMesh *> m_vMeshs;
      std::vector <aseMaterial> m_vMaterials;
};
 
#endif // MODEL_H

"Mesh.cpp" :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
#include "Mesh.hpp"
 
CMesh::CMesh ()
   : m_iNumVertices (0), m_iNumFaces (0), m_iNumTCoords (0), tabVertices (NULL),
     tabTextures (NULL)
{
   m_bTexture = false; // Pas de texture de base
   m_iNumPoints = 3; // On ne gère pas les quads, seulement les triangles
}
 
CMesh::~CMesh ()
{
   Shutdown ();
}
 
void CMesh::Shutdown ()
{
   // On vide tous les vectors
   m_vVertices.clear ();
   m_vNormales.clear ();
   m_vFaces.clear ();
   m_vTexCoords.clear ();
 
   glDeleteTextures (1, &m_uiTexture);
   m_bTexture = false;
 
   glDeleteBuffers (1, &m_uiVBO);
}
 
bool CMesh::OuvrirString (std::string contenuObj)
{
   std::string chaine;
   std::istringstream iss (contenuObj);
 
   int iCurrentTex = 0;
 
   while (iss >> chaine)
   {
      if (chaine == "*MESH_NUMVERTEX") // *MESH_NUMVERTEX nbVertex
      {
         iss >> m_iNumVertices;
      }
 
      else if (chaine == "*MESH_NUMFACES") // *MESH_NUMFACES nbFaces
      {
         iss >> m_iNumFaces;
      }
 
      else if (chaine == "*MESH_NUMTVERTEX") // *MESH_NUMTVERTEX nbTextureCoordonees
      {
         iss >> m_iNumTCoords;
 
         m_bTexture = true; // Il y a des textures
      }
   }
 
   iss.clear(); // On remet à zéro l'EOF pour la prochaine fois
   iss.seekg (0); // Et on replace le curseur au début de celui-ci
 
 
   // On alloue de la mémoire pour les vector, suivant les valeurs trouvées plus haut
   m_vVertices.reserve (m_iNumVertices);
   m_vFaces.reserve (m_iNumFaces);
   m_vNormales.reserve (m_iNumFaces * m_iNumPoints); // Le nombre de faces * nbPoints
   m_vTexCoords.reserve (m_iNumTCoords);
 
   // A présent que la mémoire est réservé, nous allons parcourir une nouvelle fois
   // le buffer mais en récupérant toutes les données relatives aux vertices, normales,
   // et faces,...
 
   while (iss >> chaine)
   {
      if (chaine == "*MESH_VERTEX")
      {
         aseVertex tmpStruct; // Structure temporaire
         int tmpInt;
 
         iss >> tmpInt >> tmpStruct.x >> tmpStruct.y >> tmpStruct.z;
 
         m_vVertices.push_back (tmpStruct); // On ajoute la structure
      }
 
      else if (chaine == "*MESH_FACE")
      {
         aseFace tmpStruct;
 
         // La chaine récupérée se présentera comme ceci :
         // 0: A: 0 B: 1 C: 2 AB: 1 BC: 1
         std::string tmpStr;
 
         iss >> tmpStr >> tmpStr >> tmpStruct.indexVertices [0] >> tmpStr >>
                tmpStruct.indexVertices [1] >> tmpStr >> tmpStruct.indexVertices [2];
 
         m_vFaces.push_back (tmpStruct); // On remplit le vecteur
      }
 
      else if (chaine == "*MESH_TVERT")
      {
         aseTexture tmpStruct;
         int tmpInt;
 
         iss >> tmpInt >> tmpStruct.u >> tmpStruct.v;
 
         m_vTexCoords.push_back (tmpStruct);
      }
 
      else if (chaine == "*MESH_TFACE")
      {
         std::string tmpStr;
         int indice;
 
         iss >> indice;
 
         iss >> m_vFaces [iCurrentTex].indexTextures [0] >>
                m_vFaces [iCurrentTex].indexTextures [1] >>
                m_vFaces [iCurrentTex].indexTextures [2];
 
         ++iCurrentTex;
      }
 
      else if (chaine == "*MESH_VERTEXNORMAL")
      {
         aseNormale tmpStruct;
         std::string tmpStr;
 
         iss >> tmpStr >> tmpStruct.x >> tmpStruct.y >> tmpStruct.z;
 
         m_vNormales.push_back (tmpStruct);
      }
   }
 
   CreerTableauVertices (); // On duplique les vertices
 
   // Si le mesh a une texture, on effectue certaines manipulations différentes
   if (m_bTexture)
   {
      CreerTableauTexture ();
 
      int taille = sizeof (float) * (m_iNumFaces * 9);
      int taille2 = sizeof (float) * (m_iNumFaces * 6);
      int sizeBuffer = 0;
 
      glGenBuffers (1, &m_uiVBO);
      glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
      glBufferData (GL_ARRAY_BUFFER, taille * 2 + taille2, NULL, GL_STATIC_DRAW);
      glBufferSubData (GL_ARRAY_BUFFER, 0, taille, tabVertices);
      glBufferSubData (GL_ARRAY_BUFFER, taille, taille2, tabTextures);
      glBufferSubData (GL_ARRAY_BUFFER, taille + taille2, taille, &m_vNormales [0].x);
 
      glGetBufferParameteriv (GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &sizeBuffer);
 
      // On vérifie que la mémoire ait bien été allouée
      if (sizeBuffer <= 0)
      {
         std::cerr << "Impossible d'allouer de la mémoire pour les VBOs.";
         return false;
      }
 
      // A présent que les données sont dans la mémoire du GPU, on peut les supprimer
      delete [] tabVertices, tabVertices = NULL;
      delete [] tabTextures, tabTextures = NULL;
   }
   else
   {
      int taille = sizeof (float) * (m_iNumFaces * 9);
      int sizeBuffer = 0;
 
      glGenBuffers (1, &m_uiVBO);
      glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
      glBufferData (GL_ARRAY_BUFFER, taille * 2, NULL, GL_STATIC_DRAW);
      glBufferSubData (GL_ARRAY_BUFFER, 0, taille, tabVertices);
      glBufferSubData (GL_ARRAY_BUFFER, taille, taille, &m_vNormales [0].x);
 
      glGetBufferParameteriv (GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &sizeBuffer);
 
      // On vérifie que la mémoire ait bien été allouée
      if (sizeBuffer <= 0)
      {
         std::cerr << "Impossible d'allouer de la mémoire pour les VBOs.";
         return false;
      }
 
      // A présent que les données sont dans la mémoire du GPU, on peut les supprimer
      delete [] tabVertices, tabVertices = NULL;
   }
 
   return true;
}
 
void CMesh::AssignerMaterial (aseMaterial sMaterial)
{
   m_sMaterial.ambDif = sMaterial.ambDif;
   m_sMaterial.specular = sMaterial.specular;
 
   if (!sMaterial.nomTexture.empty() && (m_sMaterial.nomTexture != "\"Untitled\""))
   {
      m_sMaterial.nomTexture = sMaterial.nomTexture;
 
      m_sMaterial.nomTexture.erase (0, 1);
      m_sMaterial.nomTexture.erase ((m_sMaterial.nomTexture.size() - 1), 1);
 
      OuvrirTexture ();
      m_bTexture = true;
   }
}
 
void CMesh::CreerTableauVertices ()
{
   // On duplique toutes les vertices pour pouvoir utiliser les VBO
   tabVertices = new float [m_iNumFaces * 9];
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabVertices [9 * i] = m_vVertices [m_vFaces [i].indexVertices [0]].x;
      tabVertices [9 * i + 1] = m_vVertices [m_vFaces [i].indexVertices [0]].y;
      tabVertices [9 * i + 2] = m_vVertices [m_vFaces [i].indexVertices [0]].z;
 
      tabVertices [9 * i + 3] = m_vVertices [m_vFaces [i].indexVertices [1]].x;
      tabVertices [9 * i + 4] = m_vVertices [m_vFaces [i].indexVertices [1]].y;
      tabVertices [9 * i + 5] = m_vVertices [m_vFaces [i].indexVertices [1]].z;
 
      tabVertices [9 * i + 6] = m_vVertices [m_vFaces [i].indexVertices [2]].x;
      tabVertices [9 * i + 7] = m_vVertices [m_vFaces [i].indexVertices [2]].y;
      tabVertices [9 * i + 8] = m_vVertices [m_vFaces [i].indexVertices [2]].z;
   }
}
 
void CMesh::CreerTableauTexture ()
{
   tabTextures = new float [m_iNumFaces * 6];
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabTextures [6 * i] = m_vTexCoords [m_vFaces [i].indexTextures [0]].u;
      tabTextures [6 * i + 1] = m_vTexCoords [m_vFaces [i].indexTextures [0]].v;
 
      tabTextures [6 * i + 2] = m_vTexCoords [m_vFaces [i].indexTextures [1]].u;
      tabTextures [6 * i + 3] = m_vTexCoords [m_vFaces [i].indexTextures [1]].v;
 
      tabTextures [6 * i + 4] = m_vTexCoords [m_vFaces [i].indexTextures [2]].u;
      tabTextures [6 * i + 5] = m_vTexCoords [m_vFaces [i].indexTextures [2]].v;
   }
}
 
bool CMesh::OuvrirTexture ()
{
   corona::Image * image = corona::OpenImage (m_sMaterial.nomTexture.c_str());
 
   if (!image)
      std::cerr << "Impossible d'ouvrir " << m_sMaterial.nomTexture << ".";
 
   FlipImage (image, corona::CA_X);
 
   int width = image->getWidth();
   int height = image->getHeight();
   void * pixels = image->getPixels();
   corona::PixelFormat format = image->getFormat();
 
   glGenTextures (1, &m_uiTexture);
   glBindTexture (GL_TEXTURE_2D, m_uiTexture);
 
   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 
   switch (format)
   {
      case corona::PF_R8G8B8A8:
         gluBuild2DMipmaps (GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
         break;
      case corona::PF_R8G8B8:
         gluBuild2DMipmaps (GL_TEXTURE_2D, GL_RGB, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);
         break;
      default:
         std::cerr << "Impossible de traiter l'image (ni RGB, ni RGBA)";
         return false;
         break;
   }
 
   delete image;
 
   return true;
}
 
void CMesh::Dessiner ()
{
   glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
   glColor3f (m_sMaterial.ambDif.x, m_sMaterial.ambDif.y, m_sMaterial.ambDif.z);
   glColorMaterial (GL_FRONT_AND_BACK, GL_SPECULAR);
   glColor3f (m_sMaterial.specular.x, m_sMaterial.specular.y, m_sMaterial.specular.z);
   glColorMaterial (GL_FRONT_AND_BACK, GL_EMISSION);
   glColor3f (0.0, 0.0, 0.0);
   glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 100);
 
   glEnable (GL_COLOR_MATERIAL);
 
   int taille = sizeof (float) * (m_iNumFaces * 9);
   int taille2 = sizeof (float) * (m_iNumFaces * 6);
 
   if (m_bTexture)
   {
      glEnable (GL_TEXTURE_2D);
      glBindTexture (GL_TEXTURE_2D, m_uiTexture);
 
      glEnableClientState (GL_VERTEX_ARRAY);
      glEnableClientState (GL_NORMAL_ARRAY);
      glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
      glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
 
      glVertexPointer (3, GL_FLOAT, 0, (void *) NULL);
      glTexCoordPointer (2, GL_FLOAT, 0, (void *) (taille));
      glNormalPointer (GL_FLOAT, 0, (void *) (taille + taille2));
      glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);
 
      glBindBuffer (GL_ARRAY_BUFFER, 0);
 
      glDisableClientState (GL_TEXTURE_COORD_ARRAY);
      glDisableClientState (GL_NORMAL_ARRAY);
      glDisableClientState (GL_VERTEX_ARRAY);
 
      glDisable (GL_TEXTURE_2D);
   }
   else
   {
      glEnableClientState (GL_VERTEX_ARRAY);
      glEnableClientState (GL_NORMAL_ARRAY);
 
      glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
 
      glVertexPointer (3, GL_FLOAT, 0, (void *) NULL);
      glNormalPointer (GL_FLOAT, 0, (void *) (taille));
      glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);
 
      glBindBuffer (GL_ARRAY_BUFFER, 0);
 
      glDisableClientState (GL_NORMAL_ARRAY);
      glDisableClientState (GL_VERTEX_ARRAY);
   }
}

"Model.cpp" :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
#include "Model.hpp"
 
CModel::CModel()
   : m_iNumMesh (0), m_iNumMaterials (0), _matrix (), _offset ()
{
}
 
CModel::~CModel()
{
   Shutdown ();
}
 
void CModel::Shutdown ()
{
	//std::for_each (m_vMeshs.begin(), m_vMeshs.end(), Delete());
 
   m_vMeshs.clear (); // On vide le vector
   m_vMaterials.clear ();
}
 
bool CModel::OuvrirFichier (std::string nomFichier)
{
   ifstream fichier (nomFichier.c_str(), std::ios::in); // On ouvre le fichier
 
   if (fichier.fail())
   {
      std::cerr << "Impossible d'ouvrir le fichier " << nomFichier;
      return false;
   }
 
   // On commence pour nettoyer le contenu de l'objet, au cas ou,...
   Shutdown ();
 
   // On met le contenu du fichier dans un buffer
   std::stringstream buffer;
   std::string strBuffer;
   buffer << fichier.rdbuf();
   strBuffer = buffer.str ();
   fichier.close (); // On ferme le fichier, on en a plus besoin
   std::string tmp; // Chaîne temporaire
 
   // Plusieurs structures et valeurs temporaires
   std::string contenuObj;
 
   // On récupère plusieurs positions
   while (buffer >> tmp)
   {
      if (tmp == "*MATERIAL")
      {
         buffer >> tmp;
 
         aseMaterial matTmp;
 
         while (tmp != "}") // Fermeture de la partie Material
         {
            if (tmp == "*MATERIAL_DIFFUSE")
               buffer >> matTmp.ambDif.x >> matTmp.ambDif.y >> matTmp.ambDif.z;
            else if (tmp == "*MATERIAL_SPECULAR")
               buffer >> matTmp.specular.x >> matTmp.specular.y >> matTmp.specular.z;
            else if (tmp == "*BITMAP")
               buffer >> matTmp.nomTexture;
 
            buffer >> tmp; // On va au mot suivant
         }
 
         m_vMaterials.push_back (matTmp);
      }
      else if (tmp == "*MESH")
      {
         int numMat;
 
         buffer >> tmp;
 
         while (tmp != "*MATERIAL_REF") // Fermeture de la géometrie
         {
            contenuObj += tmp;
            contenuObj += ' ';
 
            buffer >> tmp;
         }
 
         buffer >> numMat; // On enregistre le numéro du materiel
 
         CMesh * tmpObj = new CMesh ();
         tmpObj->AssignerMaterial (m_vMaterials [numMat]);
         if (!tmpObj->OuvrirString (contenuObj))
         {
            std::cerr << "Impossible d'ouvrir le mesh n° " << m_iNumMesh;
            return false;
         }
         m_vMeshs.push_back (tmpObj);
 
         contenuObj.clear ();
         ++m_iNumMesh;
      }
   }
 
	SetOffset ();
 
   return true;
}
 
void CModel::SetOffset ()
{
	_offset = GetLongueurs ();
	_offset /= 2.0;
}
 
CVector CModel::GetLongueurs () const
{
	CVector min, max; // Deux vecteurs représentant la valeur la plus petite et la plus
							// grande
 
	for (int i = 0 ; i < GetNumMeshs() ; ++i)
	{
		std::vector <aseVertex> vertexTmp = m_vMeshs [i]->GetVertices ();
 
		if (i == 0) // Première itération
		{
			min.SetCoordonnees (vertexTmp [0].x, vertexTmp [0].y, vertexTmp [0].z);
			max.SetCoordonnees (vertexTmp [0].x, vertexTmp [0].y, vertexTmp [0].z);
		}
 
		for (int j = 0 ; j < m_vMeshs [i]->GetNumVertices () ; ++j)
		{
			// Pour les x
			if (vertexTmp [j].x < min.x)
				min.x = vertexTmp [j].x;
			else if (vertexTmp [j].x > max.x)
				max.x = vertexTmp [j].x;
 
			// Pour les y
			if (vertexTmp [j].y < min.y)
				min.y = vertexTmp [j].y;
			else if (vertexTmp [j].y > max.y)
				max.y = vertexTmp [j].y;
 
			// Pour les z
			if (vertexTmp [j].z < min.z)
				min.z = vertexTmp [j].z;
			else if (vertexTmp [j].z > max.z)
				max.z = vertexTmp [j].z;
		}
	}
 
	//CVector final ((abs (min.x) + abs (max.x)), (abs (min.y) + abs (max.y)), (abs (min.z) + abs (max.z)));
	CVector final ((float)(max.x - min.x), (float)(max.y - min.y), (float)(max.z - min.z));
 
	std::cout << final.x << ' ' << final.y << ' ' << final.z;
	return final;
}
 
void CModel::SetPosition (const float * mat)
{
	for (int i = 0 ; i < 16 ; ++i)
		_matrix._matrix [i] = mat [i];
}
 
void CModel::Dessiner ()
{
   glPushMatrix (); // On sauvegarde la matrice actuelle
      glMultMatrixf (&_matrix._matrix [0]);
 
   for (int i = 0 ; i < m_iNumMesh ; ++i)
      m_vMeshs [i]->Dessiner ();
 
	glPopMatrix ();
}

Quand tu veux ouvrir un modèle, tu fais juste :

CModel * monModele = new CModel ();
monModele->OuvrirFichier ("nomFichier.ase");

et pour le dessiner :

monModele->Dessiner ();

Je l'utilise tous le temps et il marche très bien pour ce que je lui demande. L'affichage se fait à l'aide des VBOs, c'est bien plus rapide. Seul truc qui peut faire planter le loader, c'est quand tu exportes ton modèle, il se peut que tu ais une ligne *BITMAP "Untitled". Si c'est le cas, vire la ligne. Par contre si c'est autre chose que "Untitled" faut pas que t'y touches ! (c'est le nom de la texture, par exemple *BITMAP "TextureRoue1.jpg".

OK merci bien pour le lodear, sinon dans un moteur de jeu comment on fait pour que celui-ci prenne en charge tels ou tels fichiers?

je suis debutant (voir plus:yaisse2: ) en c++.

Citation:

Envoyé par ArKam

OK merci bien pour le lodear, sinon dans un moteur de jeu comment on fait pour que celui-ci prenne en charge tels ou tels fichiers?

C'est à dire ? Il te suffit de créer un loader et ton moteur ouvrira ce type de formats.

Ben par exemple la je me suis attaquer a faire un editeur pour ogre et modifier un peu ce moteur genial, dans les modifications j'aimerais que OGRE prenne en compte les fichiers ase au moment de l'import des mesh dans mon editeur.

J'espere que c'est clair sinon dit le moi.

Et bien il faut que tu écrives du code qui charge un .ASE et en crée une mesh Ogre.

Mais pourquoi vouloir charger autre chose que les formats de Ogre, alors qu'ils ont sorti des exporteurs pour à peu près tous les logiciels de modélisation 3D ?

c'est vraie les exporteurs 3ds me serve enormement mais en fait c'est pour l'editeur de mon moteur etant donner qu'il est basé sur ogre il me faut un import/export ase et obj car pour les utilisateurs du moteur, sa serais pas pratique de telecharger ou bien d'installer un plug non-proprietaire au moteur.

:aie: Je ne comprends pas...

Ogre ne gère-t-il pas déjà ces formats ?

Les concepteurs de Ogre se sont cassé la tête à produire un format personnalisé, disponible via de nombreux exporteurs pour les différents logiciels de modélisation. Alors pourquoi vouloir charger autre chose ? Vous n'exportez pas vos modèles vous-même ?

Vous pouvez aussi taper dans les plugins, il y a peut-être ce genre de choses (par exemple il y a un plugin pour COLLADA).

bien on vas rester sur du format ogre car je viens de recuperer un plug-ins gratuit totalement open source redistribuable et qui s'install sous 3ds9 qui plus est ce plug ins me permet d'avoir un apercue temps reel de ce que donnera le model sous ogre grace a la fenetre perspective de max9.0:yaisse2:

Merci de vos reponses et pour ton viewer.

au fait bakura, je n'ai pas lu vraiment ton code, mais dans le premier (mesh.hpp je crois), tu as un "using namespace std ;" et ensuite tu as des "std::".

tu devrais réussir à alléger tout ca ;)

Citation:

Envoyé par ash.ice.loky

au fait bakura, je n'ai pas lu vraiment ton code, mais dans le premier (mesh.hpp je crois), tu as un "using namespace std ;" et ensuite tu as des "std::".

tu devrais réussir à alléger tout ca ;)

Oops c'est vrai :|. En plus le using namespace std; ne me sert à rien étant donné que j'ai toujours préféré écrire le namespace juste devant, je trouve ça plus clair...