Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8346 in orxonox.OLD for branches/bsp_model/src/lib/graphics


Ignore:
Timestamp:
Jun 13, 2006, 5:03:53 PM (18 years ago)
Author:
patrick
Message:

bsp: the md2 model moved to subdir md2, mode md3 structural data

Location:
branches/bsp_model/src/lib/graphics/importer
Files:
4 edited
2 moved

Legend:

Unmodified
Added
Removed

  • branches/bsp_model/src/lib/graphics/importer/Makefile.am

    r8344 r8346  
    1111                           objModel.cc \
    1212                           primitive_model.cc \
    13                            md2Model.cc \
    1413                           material.cc \
    1514                           texture.cc \
    … …  
    2322                           bsp_tree_node.cc \
    2423                           bsp_tree_leaf.cc \
     24                           \
     25                           md2/md2Model.cc \
    2526                           \
    2627                           md3/md3_model.cc \
    … …  
    4445                objModel.h \
    4546                primitive_model.h \
    46                 md2Model.h \
    4747                material.h \
    4848                texture.h \
    … …  
    5858                bsp_tree_node.h \
    5959                bsp_tree_leaf.h \
     60                \
     61                md2/md2Model.h \
    6062                \
    6163                md3/md3_model.h \

  • branches/bsp_model/src/lib/graphics/importer/md3/md3_data.cc

    r8344 r8346  
    7676  FILE *pFile;                            //file stream
    7777  char* buffer;                           //buffer for frame data
     78
     79
    7880  sFrame* frame;                          //temp frame
    7981  sVec3D *pVertex;
    8082  int* pNormals;
     83
     84
    8185
    8286  //! @todo this chek should include deleting a loaded model (eventually)
    … …  
    174178  this->material.setAmbient(1.0, 1.0, 1.0);
    175179}
     180
     181
     182/**
     183 * read heaader
     184 */
     185void MD3Data::readHeader()
     186{}
     187
     188
     189/**
     190 * read bone frames
     191 */
     192void MD3Data::readBoneFrames()
     193{}
     194
     195
     196/**
     197 * read the tags
     198 */
     199void MD3Data::readTags()
     200{}
     201
     202
     203/**
     204 * read meshes
     205 */
     206void MD3Data::readMeshes()
     207{}

  • branches/bsp_model/src/lib/graphics/importer/md3/md3_data.h

    r8344 r8346  
    8181   bool loadSkin(const std::string& fileName = "");
    8282
     83   void readHeader();
     84   void readBoneFrames();
     85   void readTags();
     86   void readMeshes();
     87
    8388
    8489 public:

  • branches/bsp_model/src/lib/graphics/importer/md3/md3_model.cc

    r8342 r8346  
    1515#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_IMPORTER
    1616
    17 #include "md2Model.h"
     17#include "md3_model.h"
    1818#include "material.h"
    1919
    … …  
    2323
    2424using namespace std;
    25 
    26 //! the model anorms
    27 sVec3D MD2Model::anorms[NUM_VERTEX_NORMALS] = {
    28  #include "anorms.h"
    29 };
    30 
    31 //! anormal dots, no idea of how this shall work, but it does
    32 float MD2Model::anormsDots[SHADEDOT_QUANT][256] = {
    33   #include "anormtab.h"
    34 };
    35 
    36 
    37 //! the angle under which the model is viewd, used internaly
    38 float md2Angle = 0.0f;
    39 
    40 
    41 //! list of all different animations a std md2model supports
    42 sAnim MD2Model::animationList[21] =
    43   {
    44  // begin, end, fps, interruptable
    45     {   0,  39,  9, 1 },   //!< STAND
    46     {  40,  45, 10, 1 },   //!< RUN
    47     {  46,  53, 10, 0 },   //!< ATTACK
    48     {  54,  57,  7, 1 },   //!< PAIN_A
    49     {  58,  61,  7, 1 },   //!< PAIN_B
    50     {  62,  65,  7, 1 },   //!< PAIN_C
    51     {  66,  71,  7, 0 },   //!< JUMP
    52     {  72,  83,  7, 1 },   //!< FLIP
    53     {  84,  94,  7, 1 },   //!< SALUTE
    54     {  95, 111, 10, 1 },   //!< FALLBACK
    55     { 112, 122,  7, 1 },   //!< WAVE
    56     { 123, 134,  6, 1 },   //!< POINTT
    57     { 135, 153, 10, 1 },   //!< CROUCH_STAND
    58     { 154, 159,  7, 1 },   //!< CROUCH_WALK
    59     { 160, 168, 10, 1 },   //!< CROUCH_ATTACK
    60     { 196, 172,  7, 1 },   //!< CROUCH_PAIN
    61     { 173, 177,  5, 0 },   //!< CROUCH_DEATH
    62     { 178, 183,  10, 0 },   //!< DEATH_FALLBACK
    63     { 184, 189,  10, 0 },   //!< DEATH_FALLFORWARD
    64     { 190, 197,  10, 0 },   //!< DEATH_FALLBACKSLOW
    65     { 198, 198,  5, 1 },   //!< BOOM
    66   };
    67 
    68 
    69 
    70 /********************************************************************************
    71  *   MD2Model                                                                   *
    72  ********************************************************************************/
    73 
    74 /**
    75   \brief simple constructor initializing all variables
    76 */
    77 MD2Model::MD2Model(const std::string& modelFileName, const std::string& skinFileName, float scale)
    78 {
    79   this->setClassID(CL_MD2_MODEL, "MD2Model");
    80   /* this creates the data container via ressource manager */
    81   if (!modelFileName.empty())
    82     this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
    83   if( unlikely(this->data == NULL))
    84     PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
    85 
    86   this->scaleFactor = scale;
    87 
    88   shadeDots = MD2Model::anormsDots[0];
    89   /* set the animation stat mannualy */
    90   this->animationState.type = STAND;
    91   this->animationState.numPlays = 1;
    92   this->setAnim(STAND);
    93 
    94   this->debug();
    95 
    96     //write the modelinfo information
    97   this->pModelInfo.numVertices = this->data->numVertices;
    98   this->pModelInfo.numTriangles = this->data->numTriangles;
    99   this->pModelInfo.numNormals = 0;
    100   this->pModelInfo.numTexCoor = this->data->numTexCoor;
    101   this->pModelInfo.pVertices = (float*)this->data->pVertices;
    102   this->pModelInfo.pNormals = NULL;
    103   this->pModelInfo.pTexCoor = (float*)this->data->pTexCoor;
    104 
    105   // triangle conversion
    106   this->pModelInfo.pTriangles = new sTriangleExt[this->data->numTriangles];
    107   for( int i = 0; i < this->data->numTriangles; i++)
    108   {
    109     this->pModelInfo.pTriangles[i].indexToVertices[0] = this->data->pTriangles[i].indexToVertices[0];
    110     this->pModelInfo.pTriangles[i].indexToVertices[1] = this->data->pTriangles[i].indexToVertices[1];
    111     this->pModelInfo.pTriangles[i].indexToVertices[2] = this->data->pTriangles[i].indexToVertices[2];
    112 
    113     this->pModelInfo.pTriangles[i].indexToTexCoor[0] = this->data->pTriangles[i].indexToTexCoor[0];
    114     this->pModelInfo.pTriangles[i].indexToTexCoor[1] = this->data->pTriangles[i].indexToTexCoor[1];
    115     this->pModelInfo.pTriangles[i].indexToTexCoor[2] = this->data->pTriangles[i].indexToTexCoor[2];
    116   }
    117 }
    118 
    119 
    120 /**
    121   \brief simple destructor, dereferencing all variables
    122 
    123   this is where the ressource manager is cleaning the stuff
    124 */
    125 MD2Model::~MD2Model()
    126 {
    127   this->pModelInfo.pVertices = NULL;
    128   this->pModelInfo.pNormals = NULL;
    129   this->pModelInfo.pTexCoor = NULL;
    130   this->pModelInfo.pTriangles = NULL;
    131 
    132   ResourceManager::getInstance()->unload(this->data);
    133 }
    134 
    135 
    136 /**
    137  *  initializes an array of vert with the current frame scaled vertices
    138  * @param this->verticesList: the list of vertices to interpolate between
    139 
    140    we won't use the pVertices array directly, since its much easier and we need
    141    saving of data anyway
    142 */
    143 void MD2Model::interpolate(/*sVec3D* this->verticesList*/)
    144 {
    145   sVec3D* currVec;
    146   sVec3D* nextVec;
    147 
    148   currVec = &this->data->pVertices[this->data->numVertices * this->animationState.currentFrame];
    149   nextVec = &this->data->pVertices[this->data->numVertices * this->animationState.nextFrame];
    150 
    151   for( int i = 0; i < this->data->numVertices; ++i)
    152     {
    153       this->verticesList[i][0] = currVec[i][0] + this->animationState.interpolationState * (nextVec[i][0] - currVec[i][0]);
    154       this->verticesList[i][1] = currVec[i][1] + this->animationState.interpolationState * (nextVec[i][1] - currVec[i][1]);
    155       this->verticesList[i][2] = currVec[i][2] + this->animationState.interpolationState * (nextVec[i][2] - currVec[i][2]);
    156     }
    157 }
    158 
    159 
    160 /**
    161   \brief sets the animation type
    162 * @param type: animation type
    163 
    164   the animation types can be looked up in the animationType table
    165 */
    166 void MD2Model::setAnim(int type, int animPlayback)
    167 {
    168   if( (type < 0) || (type > MAX_ANIMATIONS) )
    169     type = STAND;
    170 
    171   if( MD2Model::animationList[this->animationState.type].bStoppable == 0)
    172   {
    173     if( this->animationState.numPlays == 0 )
    174       return;
    175   }
    176 
    177   this->animationState.startFrame = animationList[type].firstFrame;
    178   this->animationState.endFrame = animationList[type].lastFrame;
    179   this->animationState.nextFrame = animationList[type].firstFrame + 1;
    180   this->animationState.fps = animationList[type].fps;
    181   this->animationState.type = type;
    182   this->animationState.numPlays = 0;
    183   this->animationState.animPlaybackMode = animPlayback;
    184 
    185   this->animationState.interpolationState = 0.0f;
    186   this->animationState.localTime = 0.0f;
    187   this->animationState.lastTime = 0.0f;
    188   this->animationState.currentFrame = animationList[type].firstFrame;
    189 }
    190 
    191 
    192 /**
    193   \brief sets the time in seconds passed since the last tick
    194 * @param time: in sec
    195 */
    196 void MD2Model::tick(float time)
    197 {
    198   this->animate(time);
    199   this->processLighting();
    200   this->interpolate(/*this->verticesList*/);
    201 }
    202 
    203 
    204 /**
    205  * @brief draws the model: interface for all other classes out in the world
    206  * @todo make it const and virtual
    207  * FIXME
    208  */
    209 void MD2Model::draw() const
    210 {
    211   glPushMatrix();
    212   this->renderFrame();
    213   // renderFrameTriangles();
    214   glPopMatrix();
    215 }
    216 
    217 
    218 /**
    219   \brief this is an internal function to render this special frame selected by animate()
    220 */
    221 void MD2Model::renderFrame() const
    222 {
    223   int* pCommands = this->data->pGLCommands;
    224 
    225   /* some face culling stuff */
    226   glPushAttrib(GL_POLYGON_BIT);
    227   glFrontFace(GL_CW);
    228   glEnable(GL_CULL_FACE);
    229   glCullFace(GL_BACK);
    230 
    231   this->data->material.select();
    232 
    233   /* draw the triangles */
    234   while( int i = *(pCommands++)) /* strange looking while loop for maximum performance */
    235     {
    236       if( i < 0)
    237         {
    238           glBegin(GL_TRIANGLE_FAN);
    239           i = -i;
    240         }
    241       else
    242         {
    243           glBegin(GL_TRIANGLE_STRIP);
    244         }
    245 
    246       for(; i > 0; i--, pCommands += 3) /* down counting for loop, next 3 gl commands */
    247         {
    248           glTexCoord2f( ((float *)pCommands)[0], ((float *)pCommands)[1] );
    249           glNormal3fv(anorms[this->data->pLightNormals[pCommands[2]]]);
    250           glVertex3fv(this->verticesList[pCommands[2]]);
    251         }
    252       glEnd();
    253 
    254     }
    255   glDisable(GL_CULL_FACE);
    256   glPopAttrib();
    257 }
    258 
    259 
    260 void MD2Model::renderFrameTriangles() const
    261 {
    262   //static sVec3D this->verticesList[MD2_MAX_VERTICES]; /* performance: created only once in a lifetime */
    263   int* pCommands = this->data->pGLCommands;
    264   /* some face culling stuff */
    265 //   glPushAttrib(GL_POLYGON_BIT);
    266 //   glFrontFace(GL_CW);
    267 //   glEnable(GL_CULL_FACE);
    268 //   glCullFace(GL_BACK);
    269 //
    270 //   this->processLighting();
    271 //   this->interpolate(/*this->verticesList*/);
    272   this->data->material.select();
    273 
    274   /* draw the triangles */
    275   glBegin(GL_TRIANGLES);
    276 
    277   for( int i = 0, k = 0; i < this->data->numTriangles; ++i, k += 3)
    278   {
    279     float* v = this->data->pVertices[this->data->pTriangles[i].indexToVertices[0]];
    280 
    281     printf("triangle: %i\n", i);
    282     printf("     v0: (%f, %f, %f)\n", v[0], v[1], v[2]);
    283     v = this->data->pVertices[this->data->pTriangles[i].indexToVertices[1]];
    284     printf("     v1: (%f, %f, %f)\n", v[0], v[1], v[2]);
    285     v = this->data->pVertices[this->data->pTriangles[i].indexToVertices[2]];
    286     printf("     v2: (%f, %f, %f)\n", v[0], v[1], v[2]);
    287 
    288 
    289     glNormal3f(anorms[i][0], anorms[i][1], anorms[i][2]);
    290     glVertex3fv(this->data->pVertices[this->data->pTriangles[i].indexToVertices[0]]);
    291 
    292     glNormal3f(anorms[i][0], anorms[i][1], anorms[i][2]);
    293     glVertex3fv(this->data->pVertices[this->data->pTriangles[i].indexToVertices[1]]);
    294 
    295     glNormal3f(anorms[i][0], anorms[i][1], anorms[i][2]);
    296     glVertex3fv(this->data->pVertices[this->data->pTriangles[i].indexToVertices[2]]);
    297   }
    298 
    299   glEnd();
    300 }
    301 
    302 
    303 /**
    304   \brief animates the current model
    305 
    306   depending on the time passed (tick function), the player will select another model
    307 */
    308 void MD2Model::animate(float time)
    309 {
    310   this->animationState.localTime += time;
    311 
    312   if( this->animationState.localTime - this->animationState.lastTime > (1.0f / this->animationState.fps))
    313     {
    314       this->animationState.currentFrame = this->animationState.nextFrame;
    315       this->animationState.nextFrame++;
    316 
    317       if( this->animationState.nextFrame > this->animationState.endFrame )
    318       {
    319         if( this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
    320         {
    321           this->animationState.nextFrame = this->animationState.startFrame;
    322           this->animationState.numPlays++;
    323         }
    324         else
    325         {
    326           this->animationState.nextFrame = this->animationState.endFrame;
    327         }
    328       }
    329       this->animationState.lastTime = this->animationState.localTime;
    330     }
    331 
    332 //     if( this->animationState.currentFrame > (this->data->numFrames - 1) )
    333 //       this->animationState.currentFrame = 0;
    334 
    335 //     if( (this->animationState.nextFrame > (this->data->numFrames - 1)) && this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
    336 //     this->animationState.nextFrame = 0;
    337 
    338   this->animationState.interpolationState = this->animationState.fps *
    339     (this->animationState.localTime - this->animationState.lastTime);
    340 }
    341 
    342 
    343 /**
    344   \brief this is how id is precessing their lightning
    345 
    346   the details of how the whole lighting process is beeing handled - i have no idea... :)
    347 */
    348 void MD2Model::processLighting()
    349 {
    350   shadeDots = anormsDots[((int)(md2Angle*(SHADEDOT_QUANT / 360.0)))&(SHADEDOT_QUANT - 1)];
    351 }
    352 
    353 
    354 /**
    355   \brief prints out debug informations
    356 */
    357 void MD2Model::debug()
    358 {
    359   PRINT(0)("\n==========================| MD2Model::debug() |===\n");
    360   PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName.c_str());
    361   PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName.c_str());
    362   PRINT(0)("=  Size in Memory:\t%i Bytes\n", this->data->header->frameSize * this->data->header->numFrames + 64); // 64bytes is the header size
    363   PRINT(0)("=  Number of Vertices:\t%i\n", this->data->header->numVertices);
    364   PRINT(0)("=  Number of Frames: \t%i\n", this->data->header->numFrames);
    365   PRINT(0)("=  Height, Width:\t%i, %i\n", this->data->header->skinHeight, this->data->header->skinWidth);
    366   PRINT(0)("=  Pointer to the data object: %p\n", this->data);
    367   PRINT(0)("===================================================\n\n");
    368 }
    369 
    370 
    371 /********************************************************************************
    372  *   MD2Data                                                                    *
    373  ********************************************************************************/
    374 
    375 /**
    376   \brief simple constructor
    377 */
    378 MD2Data::MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale)
    379 {
    380   scale *= 0.1f;
    381 
    382   this->pVertices = NULL;
    383   this->pGLCommands = NULL;
    384   this->pLightNormals = NULL;
    385   this->pTexCoor = NULL;
    386 
    387   this->numFrames = 0;
    388   this->numVertices = 0;
    389   this->numGLCommands = 0;
    390   this->numTexCoor = 0;
    391 
    392 //   this->scaleFactor = 1.0f;
    393   this->scaleFactor = scale;
    394 
    395   this->fileName = "";
    396   this->skinFileName = "";
    397   this->loadModel(modelFileName);
    398   this->loadSkin(skinFileName);
    399 }
    400 
    401 
    402 /**
    403   \brief simple destructor
    404 
    405   this will clean out all the necessary data for a specific md2model
    406 */
    407 MD2Data::~MD2Data()
    408 {
    409   delete this->header;
    410 
    411   delete [] this->pVertices;
    412   delete [] this->pGLCommands;
    413   delete [] this->pLightNormals;
    414   delete [] this->pTexCoor;
    415 }
    416 
    417 
    418 
    419 /**
    420   \brief this will load the whole model data (vertices, opengl command list, ...)
    421 * @param fileName: the name of the model file
    422   \return true if success
    423 */
    424 bool MD2Data::loadModel(const std::string& fileName)
    425 {
    426   FILE *pFile;                            //file stream
    427   char* buffer;                           //buffer for frame data
    428   sFrame* frame;                          //temp frame
    429   sVec3D *pVertex;
    430   int* pNormals;
    431 
    432   //! @todo this chek should include deleting a loaded model (eventually)
    433   if (fileName.empty())
    434     return false;
    435 
    436   pFile = fopen(fileName.c_str(), "rb");
    437   if( unlikely(!pFile))
    438     {
    439       PRINTF(1)("Couldn't open the MD2 File for loading. Exiting.\n");
    440       return false;
    441     }
    442   this->header = new MD2Header;
    443   fread(this->header, 1, sizeof(MD2Header), pFile);
    444   /* check for the header version: make sure its a md2 file :) */
    445   if( unlikely(this->header->version != MD2_VERSION) && unlikely(this->header->ident != MD2_IDENT))
    446     {
    447       PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName.c_str());
    448       return false;
    449     }
    450 
    451   this->fileName =fileName;
    452   /* got the data: map it to locals */
    453   this->numFrames = this->header->numFrames;
    454   this->numVertices = this->header->numVertices;
    455   this->numTriangles = this->header->numTriangles;
    456   this->numGLCommands = this->header->numGlCommands;
    457   this->numTexCoor = this->header->numTexCoords;
    458   /* allocate memory for the data storage */
    459   this->pVertices = new sVec3D[this->numVertices * this->numFrames];
    460   this->pGLCommands = new int[this->numGLCommands];
    461   this->pLightNormals = new int[this->numVertices * this->numFrames];
    462   this->pTriangles = new sTriangle[this->numTriangles];
    463   this->pTexCoor = new sTexCoor[this->numTexCoor];
    464   buffer = new char[this->numFrames * this->header->frameSize];
    465 
    466 
    467   /* read frame data from the file to a temp buffer */
    468   fseek(pFile, this->header->offsetFrames, SEEK_SET);
    469   fread(buffer, this->header->frameSize, this->numFrames, pFile);
    470   /* read opengl commands */
    471   fseek(pFile, this->header->offsetGlCommands, SEEK_SET);
    472   fread(this->pGLCommands, sizeof(int), this->numGLCommands, pFile);
    473   /* triangle list */
    474   fseek(pFile, this->header->offsetTriangles, SEEK_SET);
    475   fread(this->pTriangles, sizeof(sTriangle), this->numTriangles, pFile);
    476   /*  read in texture coordinates */
    477   fseek(pFile, this->header->offsetTexCoords, SEEK_SET);
    478   fread(this->pTexCoor, sizeof(sTexCoor), this->numTexCoor, pFile);
    479 
    480 
    481   for(int i = 0; i < this->numFrames; ++i)
    482     {
    483       frame = (sFrame*)(buffer + this->header->frameSize * i);
    484       pVertex = this->pVertices + this->numVertices  * i;
    485       pNormals = this->pLightNormals + this->numVertices * i;
    486 
    487       for(int j = 0; j < this->numVertices; ++j)
    488         {
    489           /* SPEEDUP: *(pVerts + i + 0) = (*(frame->pVertices + i + 0)...  */
    490            pVertex[j][0] = ((frame->pVertices[j].v[0] * frame->scale[0] ) + frame->translate[0] )* this->scaleFactor;
    491            pVertex[j][1] = ((frame->pVertices[j].v[2] * frame->scale[2]) + frame->translate[2]) * this->scaleFactor;
    492            pVertex[j][2] = (-1.0 * (frame->pVertices[j].v[1] * frame->scale[1] + frame->translate[1])) * this->scaleFactor;
    493 
    494           //printf("vertex %i/%i: (%f, %f, %f)\n", j, this->numVertices, pVertex[j][0], pVertex[j][1], pVertex[j][2]);
    495 
    496           pNormals[j] = frame->pVertices[j].lightNormalIndex;
    497         }
    498     }
    499     PRINTF(4)("Finished loading the md2 file\n");
    500 
    501   delete [] buffer;
    502   fclose(pFile);
    503 }
    504 
    505 
    506 /**
    507   \brief loads the skin/material stuff
    508 * @param fileName: name of the skin file
    509   \return true if success
    510 */
    511 bool MD2Data::loadSkin(const std::string& fileName)
    512 {
    513   if( fileName.empty())
    514     {
    515       this->skinFileName = "";
    516       return false;
    517     }
    518 
    519   this->skinFileName = fileName;
    520 
    521   this->material.setName("md2ModelMaterial");
    522   this->material.setDiffuseMap(fileName);
    523   this->material.setIllum(3);
    524   this->material.setAmbient(1.0, 1.0, 1.0);
    525 }
Note: See TracChangeset for help on using the changeset viewer.