Irrlicht 3D Engine
IAnimatedMeshMD3.h
Go to the documentation of this file.
1 // Copyright (C) 2007-2012 Nikolaus Gebhardt / Thomas Alten
2 // This file is part of the "Irrlicht Engine".
3 // For conditions of distribution and use, see copyright notice in irrlicht.h
4 
5 #ifndef __I_ANIMATED_MESH_MD3_H_INCLUDED__
6 #define __I_ANIMATED_MESH_MD3_H_INCLUDED__
7 
8 #include "IAnimatedMesh.h"
9 #include "IQ3Shader.h"
10 #include "quaternion.h"
11 
12 namespace irr
13 {
14 namespace scene
15 {
16 
18  {
19  EMD3_HEAD = 0,
24  };
25 
28  {
29  // Animations for both lower and upper parts of the player
36 
37  // Animations for the upper part
45 
46  // Animations for the lower part
59 
62  };
63 
65  {
74  };
75 
76 
77 // byte-align structures
78 #include "irrpack.h"
79 
81  struct SMD3Header
82  {
83  c8 headerID[4]; //id of file, always "IDP3"
84  s32 Version; //this is a version number, always 15
85  s8 fileName[68];//sometimes left Blank... 65 chars, 32bit aligned == 68 chars
86  s32 numFrames; //number of KeyFrames
87  s32 numTags; //number of 'tags' per frame
88  s32 numMeshes; //number of meshes/skins
89  s32 numMaxSkins;//maximum number of unique skins used in md3 file. artefact md2
90  s32 frameStart; //starting position of frame-structur
91  s32 tagStart; //starting position of tag-structures
92  s32 tagEnd; //ending position of tag-structures/starting position of mesh-structures
94  } PACK_STRUCT;
95 
98  {
99  c8 meshID[4]; //id, must be IDP3
100  c8 meshName[68]; //name of mesh 65 chars, 32 bit aligned == 68 chars
101 
102  s32 numFrames; //number of meshframes in mesh
103  s32 numShader; //number of skins in mesh
104  s32 numVertices; //number of vertices
105  s32 numTriangles; //number of Triangles
106 
107  s32 offset_triangles; //starting position of Triangle data, relative to start of Mesh_Header
108  s32 offset_shaders; //size of header
109  s32 offset_st; //starting position of texvector data, relative to start of Mesh_Header
110  s32 vertexStart; //starting position of vertex data,relative to start of Mesh_Header
112  } PACK_STRUCT;
113 
114 
116  struct SMD3Vertex
117  {
119  u8 normal[2];
120  } PACK_STRUCT;
121 
124  {
127  } PACK_STRUCT;
128 
130  struct SMD3Face
131  {
132  s32 Index[3];
133  } PACK_STRUCT;
134 
135 
136 // Default alignment
137 #include "irrunpack.h"
138 
141  {
143 
148  };
149 
151 
153  {
155  {
156  position.X = 0.f;
157  }
158 
159  // construct copy constructor
161  {
162  *this = copyMe;
163  }
164 
165  // construct for searching
167  : Name ( name ) {}
168 
169  // construct from a position and euler angles in degrees
170  SMD3QuaternionTag ( const core::vector3df &pos, const core::vector3df &angle )
171  : position(pos), rotation(angle * core::DEGTORAD) {}
172 
173  // set to matrix
174  void setto ( core::matrix4 &m )
175  {
176  rotation.getMatrix ( m, position );
177  }
178 
179  bool operator == ( const SMD3QuaternionTag &other ) const
180  {
181  return Name == other.Name;
182  }
183 
185  {
186  Name = copyMe.Name;
187  position = copyMe.position;
188  rotation = copyMe.rotation;
189  return *this;
190  }
191 
195  };
196 
199  {
201  {
202  Container.setAllocStrategy(core::ALLOC_STRATEGY_SAFE);
203  }
204 
205  // construct copy constructor
207  {
208  *this = copyMe;
209  }
210 
212 
214  {
215  SMD3QuaternionTag search ( name );
216  s32 index = Container.linear_search ( search );
217  if ( index >= 0 )
218  return &Container[index];
219  return 0;
220  }
221 
222  u32 size () const
223  {
224  return Container.size();
225  }
226 
227  void set_used(u32 new_size)
228  {
229  s32 diff = (s32) new_size - (s32) Container.allocated_size();
230  if ( diff > 0 )
231  {
232  SMD3QuaternionTag e("");
233  for ( s32 i = 0; i < diff; ++i )
234  Container.push_back(e);
235  }
236  }
237 
238  const SMD3QuaternionTag& operator[](u32 index) const
239  {
240  return Container[index];
241  }
242 
244  {
245  return Container[index];
246  }
247 
248  void push_back(const SMD3QuaternionTag& other)
249  {
250  Container.push_back(other);
251  }
252 
254  {
255  Container = copyMe.Container;
256  return *this;
257  }
258 
259  private:
261  };
262 
263 
266  {
268  {
269  MD3Header.numFrames = 0;
270  }
271 
272  virtual ~SMD3Mesh()
273  {
274  for (u32 i=0; i<Buffer.size(); ++i)
275  Buffer[i]->drop();
276  }
277 
282  };
283 
284 
287  {
288  public:
289 
291  virtual void setInterpolationShift(u32 shift, u32 loopMode) =0;
292 
294  virtual SMD3QuaternionTagList* getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop) =0;
295 
297  virtual SMD3Mesh* getOriginalMesh() =0;
298  };
299 
300 } // end namespace scene
301 } // end namespace irr
302 
303 #endif
304 
SMD3QuaternionTagList(const SMD3QuaternionTagList &copyMe)
bool drop() const
Drops the object. Decrements the reference counter by one.
signed short s16
16 bit signed variable.
Definition: irrTypes.h:52
Holding Frames Buffers and Tag Infos.
core::array< s32 > Indices
float f32
32 bit floating point variable.
Definition: irrTypes.h:108
SMD3QuaternionTagList & operator=(const SMD3QuaternionTagList &copyMe)
SMD3QuaternionTag(const core::stringc &name)
char c8
8 bit character variable.
Definition: irrTypes.h:35
SMD3QuaternionTag & operator=(const SMD3QuaternionTag &copyMe)
Compressed Vertex Data.
T X
X coordinate of the vector.
Definition: vector3d.h:410
this holds the header info of the MD3 file
SMD3QuaternionTagList TagList
Everything in the Irrlicht Engine can be found in this namespace.
Definition: aabbox3d.h:12
hold a tag info for connecting meshes
Very simple string class with some useful features.
Definition: irrString.h:37
Not an animation, but amount of animation types.
bool operator==(const SMD3QuaternionTag &other) const
s32 fps
Frames per second.
unsigned char u8
8 bit unsigned variable.
Definition: irrTypes.h:22
struct irr::scene::SMD3Header PACK_STRUCT
SMD3QuaternionTag & operator[](u32 index)
this holds the header info of an MD3 mesh section
void setto(core::matrix4 &m)
signed int s32
32 bit signed variable.
Definition: irrTypes.h:70
unsigned int u32
32 bit unsigned variable.
Definition: irrTypes.h:62
core::array< SMD3MeshBuffer * > Buffer
const SMD3QuaternionTag & operator[](u32 index) const
virtual SMD3QuaternionTagList * getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop)=0
get the tag list of the mesh.
const f32 DEGTORAD
32bit Constant for converting from degrees to radians
Definition: irrMath.h:75
signed char s8
8 bit signed variable.
Definition: irrTypes.h:30
Holding Frame Data for a Mesh.
virtual SMD3Mesh * getOriginalMesh()=0
get the original md3 mesh.
4x4 matrix. Mostly used as transformation matrix for 3d calculations.
Definition: matrix4.h:45
SMD3QuaternionTag(const core::vector3df &pos, const core::vector3df &angle)
EMD3_ANIMATION_TYPE
Animation list.
core::array< SMD3TexCoord > Tex
matrix4 getMatrix() const
Creates a matrix from this quaternion.
Definition: quaternion.h:346
Interface for using some special functions of MD3 meshes.
SMD3QuaternionTag * get(const core::stringc &name)
void push_back(const SMD3QuaternionTag &other)
holds a associative list of named quaternions
virtual void setInterpolationShift(u32 shift, u32 loopMode)=0
tune how many frames you want to render in between.
Base class of most objects of the Irrlicht Engine.
Quaternion class for representing rotations.
Definition: quaternion.h:31
Interface for an animated mesh.
Definition: IAnimatedMesh.h:20
SMD3QuaternionTag(const SMD3QuaternionTag &copyMe)
Texture Coordinate.
core::array< SMD3Vertex > Vertices