IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Moteurs 3D Discussion :

Question de format !


Sujet :

Moteurs 3D

  1. #1
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut 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?

  2. #2
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    Leger UP:

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

  3. #3
    Rédacteur
    Avatar de Bakura
    Homme Profil pro
    Étudiant
    Inscrit en
    Septembre 2005
    Messages
    1 386
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Septembre 2005
    Messages : 1 386
    Points : 2 640
    Points
    2 640
    Par défaut
    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.

  4. #4
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    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.

  5. #5
    Rédacteur
    Avatar de Bakura
    Homme Profil pro
    Étudiant
    Inscrit en
    Septembre 2005
    Messages
    1 386
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Septembre 2005
    Messages : 1 386
    Points : 2 640
    Points
    2 640
    Par défaut
    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 : 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
    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 : 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
    #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 : 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
    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 : 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
    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".

  6. #6
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    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 ) en c++.

  7. #7
    Rédacteur
    Avatar de Bakura
    Homme Profil pro
    Étudiant
    Inscrit en
    Septembre 2005
    Messages
    1 386
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Septembre 2005
    Messages : 1 386
    Points : 2 640
    Points
    2 640
    Par défaut
    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.

  8. #8
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    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.

  9. #9
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Points : 15 920
    Points
    15 920
    Par défaut
    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 ?

  10. #10
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    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.

  11. #11
    Yno
    Yno est déconnecté
    Membre habitué Avatar de Yno
    Inscrit en
    Novembre 2005
    Messages
    138
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 138
    Points : 141
    Points
    141
    Par défaut
    Je ne comprends pas...

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

  12. #12
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Points : 15 920
    Points
    15 920
    Par défaut
    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).

  13. #13
    Membre éclairé
    Avatar de ArKam
    Inscrit en
    Mars 2007
    Messages
    528
    Détails du profil
    Informations personnelles :
    Âge : 37

    Informations forums :
    Inscription : Mars 2007
    Messages : 528
    Points : 680
    Points
    680
    Par défaut
    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


    Merci de vos reponses et pour ton viewer.

  14. #14
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    Février 2006
    Messages
    943
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Secteur : Finance

    Informations forums :
    Inscription : Février 2006
    Messages : 943
    Points : 1 156
    Points
    1 156
    Par défaut
    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

  15. #15
    Rédacteur
    Avatar de Bakura
    Homme Profil pro
    Étudiant
    Inscrit en
    Septembre 2005
    Messages
    1 386
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Septembre 2005
    Messages : 1 386
    Points : 2 640
    Points
    2 640
    Par défaut
    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...

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Petite question fonction Format
    Par Geoffroy123 dans le forum VB 6 et antérieur
    Réponses: 6
    Dernier message: 12/02/2009, 12h44
  2. [A-07] Question de format ?
    Par AlainL dans le forum VBA Access
    Réponses: 1
    Dernier message: 04/01/2009, 15h27
  3. Question bête format dans requête
    Par Nessie37 dans le forum VBA Access
    Réponses: 2
    Dernier message: 17/01/2008, 13h23
  4. [audiovisuel] Question convertion format vidéo
    Par Dark Raph dans le forum C++
    Réponses: 15
    Dernier message: 27/08/2007, 22h23
  5. question sur format scientifique
    Par jayjay.f dans le forum AWT/Swing
    Réponses: 1
    Dernier message: 09/02/2007, 21h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo