Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/importer/md2Model.cc @ 5876

Last change on this file since 5876 was 5284, checked in by bensch, 19 years ago

orxonox/trunk: issue in MD2Data: loaded filename even if it was NULL

File size: 12.9 KB
RevLine 
[4682]1/*
[4245]2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Patrick Boenzli
13*/
14
15#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_IMPORTER
16
17#include "md2Model.h"
18#include "material.h"
19
[5075]20#include "debug.h"
[4246]21#include "resource_manager.h"
22
[4697]23//#include <fstream>
[4245]24
25
26using namespace std;
27
[4682]28//! the model anorms
[4276]29sVec3D MD2Model::anorms[NUM_VERTEX_NORMALS] = {
[4245]30 #include "anorms.h"
31};
32
[4459]33//! anormal dots, no idea of how this shall work, but it does
[4276]34float MD2Model::anormsDots[SHADEDOT_QUANT][256] = {
[4245]35  #include "anormtab.h"
36};
37
[4459]38//! again one of these strange id software parts
[4276]39static float *shadeDots = MD2Model::anormsDots[0];
[4245]40
[4682]41//! the angle under which the model is viewd, used internaly
[4245]42float md2Angle = 0.0f;
43
44
[4459]45//! list of all different animations a std md2model supports
[4276]46sAnim MD2Model::animationList[21] =
[4245]47  {
[4682]48 // begin, end, fps
[4459]49    {   0,  39,  9 },   //!< STAND
50    {  40,  45, 10 },   //!< RUN
51    {  46,  53, 10 },   //!< ATTACK
52    {  54,  57,  7 },   //!< PAIN_A
53    {  58,  61,  7 },   //!< PAIN_B
54    {  62,  65,  7 },   //!< PAIN_C
55    {  66,  71,  7 },   //!< JUMP
56    {  72,  83,  7 },   //!< FLIP
57    {  84,  94,  7 },   //!< SALUTE
58    {  95, 111, 10 },   //!< FALLBACK
59    { 112, 122,  7 },   //!< WAVE
60    { 123, 134,  6 },   //!< POINTT
61    { 135, 153, 10 },   //!< CROUCH_STAND
62    { 154, 159,  7 },   //!< CROUCH_WALK
63    { 160, 168, 10 },   //!< CROUCH_ATTACK
64    { 196, 172,  7 },   //!< CROUCH_PAIN
65    { 173, 177,  5 },   //!< CROUCH_DEATH
66    { 178, 183,  7 },   //!< DEATH_FALLBACK
67    { 184, 189,  7 },   //!< DEATH_FALLFORWARD
68    { 190, 197,  7 },   //!< DEATH_FALLBACKSLOW
69    { 198, 198,  5 },   //!< BOOM
[4245]70  };
71
72
73
74/********************************************************************************
[4459]75 *   MD2Model                                                                   *
76 ********************************************************************************/
[4245]77
[4461]78/**
[4284]79  \brief simple constructor initializing all variables
80*/
[4459]81MD2Model::MD2Model(const char* modelFileName, const char* skinFileName)
[4245]82{
[4280]83  /* this creates the data container via ressource manager */
[4462]84  this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, (void*)skinFileName);
[4787]85  if( unlikely(this->data == NULL))
86    PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
[5075]87
[4282]88  this->scaleFactor = this->data->scaleFactor;
[5087]89  this->setAnim(STAND);
[4245]90}
91
[4461]92/**
[4284]93  \brief simple destructor, dereferencing all variables
[4245]94
[4284]95  this is where the ressource manager is cleaning the stuff
96*/
[4276]97MD2Model::~MD2Model()
[4245]98{
[4462]99  ResourceManager::getInstance()->unload(this->data);
[4245]100}
101
102
103/**
[4836]104 *  initializes an array of vert with the current frame scaled vertices
105 * @param verticesList: the list of vertices to interpolate between
[4245]106
107   we won't use the pVertices array directly, since its much easier and we need
108   saving of data anyway
109*/
[4276]110void MD2Model::interpolate(sVec3D* verticesList)
[4245]111{
112  sVec3D* currVec;
113  sVec3D* nextVec;
114
[4281]115  currVec = &this->data->pVertices[this->data->numVertices * this->animationState.currentFrame];
116  nextVec = &this->data->pVertices[this->data->numVertices * this->animationState.nextFrame];
[4245]117
[5086]118  for( int i = 0; i < this->data->numVertices; ++i)
[4245]119    {
[5086]120      verticesList[i][0] = currVec[i][0] + this->animationState.interpolationState * (nextVec[i][0] - currVec[i][0]);
121      verticesList[i][1] = currVec[i][1] + this->animationState.interpolationState * (nextVec[i][1] - currVec[i][1]);
122      verticesList[i][2] = currVec[i][2] + this->animationState.interpolationState * (nextVec[i][2] - currVec[i][2]);
[4245]123    }
124}
125
126
[4461]127/**
[4284]128  \brief sets the animation type
[4836]129* @param type: animation type
[4284]130
131  the animation types can be looked up in the animationType table
132*/
[4276]133void MD2Model::setAnim(int type)
[4245]134{
135  if( (type < 0) || (type > MAX_ANIMATIONS) )
[5087]136    type = STAND;
[4245]137
138  this->animationState.startFrame = animationList[type].firstFrame;
139  this->animationState.endFrame = animationList[type].lastFrame;
140  this->animationState.nextFrame = animationList[type].firstFrame + 1;
141  this->animationState.fps = animationList[type].fps;
142  this->animationState.type = type;
[4682]143
[5087]144  this->animationState.interpolationState = 0.0f;
145  this->animationState.localTime = 0.0f;
146  this->animationState.lastTime = 0.0f;
[4245]147  this->animationState.currentFrame = animationList[type].firstFrame;
148}
149
150
[4461]151/**
[4284]152  \brief sets the time in seconds passed since the last tick
[4836]153* @param time: in sec
[4284]154*/
[4276]155void MD2Model::tick(float time)
[4245]156{
157  this->animationState.localTime += time;
158}
159
160
[4461]161/**
[4284]162  \brief draws the model: interface for all other classes out in the world
163*/
[4276]164void MD2Model::draw()
[4245]165{
166  if( likely(this->animationState.localTime > 0.0))
167    this->animate();
168
169  glPushMatrix();
170
[5087]171  this->renderFrame();
[4245]172
173  glPopMatrix();
[4682]174}
[4245]175
176
[4461]177/**
[4284]178  \brief this is an internal function to render this special frame selected by animate()
179*/
[5087]180void MD2Model::renderFrame()
[4245]181{
182  static sVec3D verticesList[MD2_MAX_VERTICES]; /* performance: created only once in a lifetime */
[4281]183  int* pCommands = this->data->pGLCommands;
[4245]184
185  /* some face culling stuff */
186  glPushAttrib(GL_POLYGON_BIT);
187  glFrontFace(GL_CW);
188  glEnable(GL_CULL_FACE);
189  glCullFace(GL_BACK);
[4682]190
[4245]191  this->processLighting();
192  this->interpolate(verticesList);
[4281]193  this->data->material->select();
[4245]194
195  /* draw the triangles */
196  while( int i = *(pCommands++)) /* strange looking while loop for maximum performance */
197    {
198      if( i < 0)
[4682]199        {
200          glBegin(GL_TRIANGLE_FAN);
201          i = -i;
202        }
[4245]203      else
[4682]204        {
205          glBegin(GL_TRIANGLE_STRIP);
206        }
[4245]207
[4717]208
[4245]209      for(; i > 0; i--, pCommands += 3) /* down counting for loop, next 3 gl commands */
[4682]210        {
[4717]211          glTexCoord2f( ((float *)pCommands)[0], ((float *)pCommands)[1] );
[4682]212          glNormal3fv(anorms[this->data->pLightNormals[pCommands[2]]]);
213          glVertex3fv(verticesList[pCommands[2]]);
214        }
[4245]215      glEnd();
[4717]216
[4245]217    }
218  glDisable(GL_CULL_FACE);
219  glPopAttrib();
220}
221
222
[4461]223/**
[4284]224  \brief animates the current model
225
226  depending on the time passed (tick function), the player will select another model
227*/
[4280]228void MD2Model::animate()
229{
230  if( this->animationState.localTime - this->animationState.lastTime > (1.0f / this->animationState.fps))
231    {
232      this->animationState.currentFrame = this->animationState.nextFrame;
233      this->animationState.nextFrame++;
[4682]234
[4280]235      if( this->animationState.nextFrame > this->animationState.endFrame)
[4682]236        this->animationState.nextFrame = this->animationState.startFrame;
[4280]237      this->animationState.lastTime = this->animationState.localTime;
238    }
239
[4281]240  if( this->animationState.currentFrame > (this->data->numFrames - 1) )
[4280]241    this->animationState.currentFrame = 0;
[4281]242  if( this->animationState.nextFrame > (this->data->numFrames - 1) )
[4280]243    this->animationState.nextFrame = 0;
244
[4682]245  this->animationState.interpolationState = this->animationState.fps *
[4280]246    (this->animationState.localTime - this->animationState.lastTime);
247}
248
249
[4461]250/**
[4284]251  \brief this is how id is precessing their lightning
252
253  the details of how the whole lighting process is beeing handled - i have no idea... :)
254*/
[4280]255void MD2Model::processLighting()
256{
257  shadeDots = anormsDots[((int)(md2Angle*(SHADEDOT_QUANT / 360.0)))&(SHADEDOT_QUANT - 1)];
258}
259
[4461]260
261/**
[4284]262  \brief prints out debug informations
263*/
[4276]264void MD2Model::debug()
[4245]265{
[4282]266  PRINT(0)("\n==========================| MD2Model::debug() |===\n");
[4281]267  PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName);
268  PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName);
269  PRINT(0)("=  Size in Memory:\t%i Bytes\n", this->data->header->frameSize * this->data->header->numFrames + 64); // 64bytes is the header size
270  PRINT(0)("=  Number of Vertices:\t%i\n", this->data->header->numVertices);
271  PRINT(0)("=  Number of Frames: \t%i\n", this->data->header->numFrames);
[4282]272  PRINT(0)("=  Height, Width:\t%i, %i\n", this->data->header->skinHeight, this->data->header->skinWidth);
[4488]273  PRINT(0)("=  Pointer to the data object: %p\n", this->data);
[4245]274  PRINT(0)("===================================================\n\n");
275}
[4280]276
277
[4282]278/********************************************************************************
279 *   MD2Data                                                                    *
280 ********************************************************************************/
[4280]281
[4461]282/**
[4284]283  \brief simple constructor
284*/
[4459]285MD2Data::MD2Data(const char* modelFileName, const char* skinFileName)
[4280]286{
287  this->pVertices = NULL;
288  this->pGLCommands = NULL;
[4682]289  this->pLightNormals = NULL;
[5085]290  this->pTexCoor = NULL;
[4280]291
292  this->numFrames = 0;
293  this->numVertices = 0;
294  this->numGLCommands = 0;
[5085]295  this->numTexCoor = 0;
[4459]296
[4682]297  this->scaleFactor = 0.2f;
298
[5284]299  this->fileName = NULL;
300  this->skinFileName = NULL;
[4459]301  this->loadModel(modelFileName);
302  this->loadSkin(skinFileName);
[4280]303}
304
305
[4461]306/**
[4284]307  \brief simple destructor
308
309  this will clean out all the necessary data for a specific md2model
310*/
[4280]311MD2Data::~MD2Data()
312{
[5235]313  delete [] this->fileName;
314  delete [] this->skinFileName;
315  delete this->header;
[4460]316
[4280]317  delete [] this->pVertices;
318  delete [] this->pGLCommands;
319  delete [] this->pLightNormals;
[5085]320  delete [] this->pTexCoor;
[4460]321
322  delete this->material;
[4280]323}
324
325
326
[4461]327/**
[4284]328  \brief this will load the whole model data (vertices, opengl command list, ...)
[4836]329* @param fileName: the name of the model file
[4284]330  \return true if success
331*/
[4280]332bool MD2Data::loadModel(const char* fileName)
333{
334  FILE *pFile;                            //file stream
335  char* buffer;                           //buffer for frame data
336  sFrame* frame;                          //temp frame
337  sVec3D *pVertex;
338  int* pNormals;
339
[5284]340  //! @todo this chek should include deleting a loaded model (eventually)
341  if (fileName == NULL)
342    return false;
343
[4280]344  pFile = fopen(fileName, "rb");
[4682]345  if( unlikely(!pFile))
[4280]346    {
347      PRINTF(1)("Couldn't open the MD2 File for loading. Exiting.\n");
348      return false;
349    }
350  this->header = new MD2Header;
351  fread(this->header, 1, sizeof(MD2Header), pFile);
352  /* check for the header version: make sure its a md2 file :) */
353  if( unlikely(this->header->version != MD2_VERSION) && unlikely(this->header->ident != MD2_IDENT))
354    {
355      PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName);
356      return false;
357    }
358
359  this->fileName = new char[strlen(fileName)+1];
360  strcpy(this->fileName, fileName);
361  /* got the data: map it to locals */
362  this->numFrames = this->header->numFrames;
363  this->numVertices = this->header->numVertices;
364  this->numTriangles = this->header->numTriangles;
365  this->numGLCommands = this->header->numGlCommands;
[5085]366  this->numTexCoor = this->header->numTexCoords;
[4280]367  /* allocate memory for the data storage */
368  this->pVertices = new sVec3D[this->numVertices * this->numFrames];
369  this->pGLCommands = new int[this->numGLCommands];
370  this->pLightNormals = new int[this->numVertices * this->numFrames];
[4787]371  this->pTriangles = new sTriangle[this->numTriangles];
[5085]372  this->pTexCoor = new sTexCoor[this->numTexCoor];
[4280]373  buffer = new char[this->numFrames * this->header->frameSize];
374
[4787]375
[4280]376  /* read frame data from the file to a temp buffer */
377  fseek(pFile, this->header->offsetFrames, SEEK_SET);
378  fread(buffer, this->header->frameSize, this->numFrames, pFile);
379  /* read opengl commands */
380  fseek(pFile, this->header->offsetGlCommands, SEEK_SET);
381  fread(this->pGLCommands, sizeof(int), this->numGLCommands, pFile);
[4787]382  /* triangle list */
383  fseek(pFile, this->header->offsetTriangles, SEEK_SET);
384  fread(this->pTriangles, sizeof(sTriangle), this->numTriangles, pFile);
[5085]385  /*  read in texture coordinates */
386  fseek(pFile, this->header->offsetTexCoords, SEEK_SET);
387  fread(this->pTexCoor, sizeof(sTexCoor), this->numTexCoor, pFile);
[4280]388
[5087]389
[4280]390  for(int i = 0; i < this->numFrames; ++i)
391    {
[4682]392      frame = (sFrame*)(buffer + this->header->frameSize * i);
[4280]393      pVertex = this->pVertices + this->numVertices  * i;
394      pNormals = this->pLightNormals + this->numVertices * i;
395
396      for(int j = 0; j < this->numVertices; ++j)
[4682]397        {
398          /* SPEEDUP: *(pVerts + i + 0) = (*(frame->pVertices + i + 0)...  */
399          pVertex[j][0] = ((frame->pVertices[j].v[0] * frame->scale[0] ) + frame->translate[0] )* this->scaleFactor;
400          pVertex[j][1] = ((frame->pVertices[j].v[2] * frame->scale[2]) + frame->translate[2]) * this->scaleFactor;
401          pVertex[j][2] = (-1.0 * (frame->pVertices[j].v[1] * frame->scale[1] + frame->translate[1])) * this->scaleFactor;
402
403          pNormals[j] = frame->pVertices[j].lightNormalIndex;
404        }
[4280]405    }
406
407  delete [] buffer;
408  fclose(pFile);
409}
410
411
[4461]412/**
[4284]413  \brief loads the skin/material stuff
[4836]414* @param fileName: name of the skin file
[4284]415  \return true if success
416*/
[4280]417bool MD2Data::loadSkin(const char* fileName)
418{
[4459]419  if( fileName == NULL)
420    {
421      this->skinFileName = NULL;
422      return false;
423    }
424
[4280]425  this->skinFileName = new char[strlen(fileName)+1];
426  strcpy(this->skinFileName, fileName);
[4281]427
[4280]428  this->material = new Material("md2ModelTest");
429  this->material->setDiffuseMap(fileName);
430  this->material->setIllum(3);
431  this->material->setAmbient(1.0, 1.0, 1.0);
432}
Note: See TracBrowser for help on using the repository browser.