Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/importer/md2Model.h @ 5452

Last change on this file since 5452 was 5304, checked in by bensch, 19 years ago

orxonox/trunk: so, ResourceManager now operates on BaseObjects. If this is better, i do not know, but at least it is more intuitive, i think

File size: 6.8 KB
Line 
1/*!
2 * @file md2Model.h
3  *  Definition of an MD2 Model, a model format invented by ID Software.
4
5    We are deeply thankfull for all the wunderfull things id software made for us gamers!
6
7    The md2 file format is structured in a very simple way: it contains animations which are made out of
8    frames (so called keyframes). Each frame is a complete draweable model in a specific position.
9    A frame is a collection of vertex and its compagnions (normals, texture coordinates).
10
11    A typical model has about 200 frames, the maximum frame count is fixed by MD2_MAX_FRAMES to currently
12    512 frames. The maximal vetices count is set to 2048 verteces, not enough?
13    You just have to change the MD2_MAX_* values if it doesn't fit your purposes...
14
15    Surface Culling is fully implemented in md2 models: quake2 uses front face culling.
16*/
17
18#ifndef _MD2MODEL_H
19#define _MD2MODEL_H
20
21#include "abstract_model.h"
22#include "base_object.h"
23#include "stdincl.h"
24
25
26//! These are the needed defines for the max values when loading .MD2 files
27#define MD2_IDENT                       (('2'<<24) + ('P'<<16) + ('D'<<8) + 'I') //!< the md2 identifier tag in the bin file
28#define MD2_VERSION                     8                                        //!< the md2 version in the header
29#define MD2_MAX_TRIANGLES               4096                                     //!< maximal triangles count
30#define MD2_MAX_VERTICES                2048                                     //!< maximal vertices count
31#define MD2_MAX_TEXCOORDS               2048                                     //!< maximal tex coordinates
32#define MD2_MAX_FRAMES                  512                                      //!< maximal frames
33#define MD2_MAX_SKINS                   32                                       //!< maximal skins
34#define MD2_MAX_FRAMESIZE               (MD2_MAX_VERTICES * 4 + 128)             //!< maximal framesize
35
36#define NUM_VERTEX_NORMALS              162                                      //!< number of vertex normals
37#define SHADEDOT_QUANT                  16                                       //!< shade dot quantity - no idea what it is
38
39//! This stores the speed of the animation between each key frame - currently conflicting with the animation framework
40#define kAnimationSpeed                 12.0f                                    //!< animation speed
41
42//! This holds the header information that is read in at the beginning of the file: id software definition
43struct MD2Header
44{
45   int ident;                           //!< This is used to identify the file
46   int version;                         //!< The version number of the file (Must be 8)
47
48   int skinWidth;                       //!< The skin width in pixels
49   int skinHeight;                      //!< The skin height in pixels
50   int frameSize;                       //!< The size in bytes the frames are
51
52   int numSkins;                        //!< The number of skins associated with the model
53   int numVertices;                     //!< The number of vertices (constant for each frame)
54   int numTexCoords;                    //!< The number of texture coordinates
55   int numTriangles;                    //!< The number of faces (polygons)
56   int numGlCommands;                   //!< The number of gl commands
57   int numFrames;                       //!< The number of animation frames
58
59   int offsetSkins;                     //!< The offset in the file for the skin data
60   int offsetTexCoords;                 //!< The offset in the file for the texture data
61   int offsetTriangles;                 //!< The offset in the file for the face data
62   int offsetFrames;                    //!< The offset in the file for the frames data
63   int offsetGlCommands;                //!< The offset in the file for the gl commands data
64   int offsetEnd;                       //!< The end of the file offset
65};
66
67
68
69//! animation names enumeration
70typedef enum animType
71  {
72    STAND,
73    RUN,
74    ATTACK,
75    PAIN_A,
76    PAIN_B,
77    PAIN_C,
78    JUMP,
79    FLIP,
80    SALUTE,
81    FALLBACK,
82    WAVE,
83    POINTT,
84    CROUCH_STAND,
85    CROUCH_WALK,
86    CROUCH_ATTACK,
87    CROUCH_PAIN,
88    CROUCH_DEATH,
89    DEATH_FALLBACK,
90    DEATH_FALLFORWARD,
91    DEATH_FALLBACKSLOW,
92    BOOM,
93
94    MAX_ANIMATIONS
95  };
96
97
98
99/* forward definitions */
100class Material;
101
102
103
104//! class to store the md2 data in
105class MD2Data : public BaseObject
106{
107 public:
108  MD2Data(const char* modelFileName, const char* skinFileName);
109  virtual ~MD2Data();
110
111 private:
112  bool loadModel(const char* fileName);
113  bool loadSkin(const char* fileName = NULL);
114
115 public:
116  int                numFrames;             //!< number of frames
117  int                numVertices;           //!< number of vertices
118  int                numTriangles;          //!< number of triangles
119  int                numTexCoor;            //!< number of texture coordinates
120  int                numGLCommands;         //!< number of gl commands in the glList (tells how to draw)
121  char*              fileName;              //!< file name of the model File
122  char*              skinFileName;          //!< file name of the skin file
123  MD2Header*         header;                //!< the header file
124
125  sVec3D*            pVertices;             //!< pointer to the vertices data block
126  sTriangle*         pTriangles;            //!< pointer to the triangles data
127  sTexCoor*          pTexCoor;              //!< pointer to the texture coordinate data
128  int*               pGLCommands;           //!< pointer to the gllist data block
129  int*               pLightNormals;         //!< pointer to the light normals
130
131  Material*          material;              //!< pointer to the material
132  float              scaleFactor;           //!< the scale factor of the model, (global)
133};
134
135
136
137
138//! This is a MD2 Model class
139class MD2Model : public AbstractModel {
140
141public:
142  MD2Model(const char* modelFileName, const char* skinFileName = NULL);
143  virtual ~MD2Model();
144
145  void draw();
146
147  void setAnim(int type);
148  /**
149   *  scales the current model
150   * @param scaleFactor: the factor [0..1] to use for scaling
151  */
152  void scaleModel(float scaleFactor) { this->scaleFactor = scaleFactor;}
153
154  void tick(float dtS);
155  void debug();
156
157
158private:
159  void animate();
160  void processLighting();
161  void interpolate(sVec3D* verticesList);
162  void renderFrame();
163
164
165 public:
166  /* these variables are static, because they are all the same for every model */
167  static sVec3D       anorms[NUM_VERTEX_NORMALS];       //!< the anormals
168  static float        anormsDots[SHADEDOT_QUANT][256];  //!< the anormals dot products
169  static sAnim        animationList[21];                //!< the anomation list
170
171  MD2Data*            data;                             //!< the md2 data pointer
172
173 private:
174  float               scaleFactor;                      //!< the scale factor (individual)
175  sAnimState          animationState;                   //!< animation state of the model
176};
177
178
179
180
181
182#endif /* _MD2MODEL_H */
Note: See TracBrowser for help on using the repository browser.