include/IAnimatedMeshMD3.h

   1 // Copyright (C) 2007-2012 Nikolaus Gebhardt / Thomas Alten\r
   2 // This file is part of the "Irrlicht Engine".\r
   3 // For conditions of distribution and use, see copyright notice in irrlicht.h\r
   4 \r
   5 #ifndef __I_ANIMATED_MESH_MD3_H_INCLUDED__\r
   6 #define __I_ANIMATED_MESH_MD3_H_INCLUDED__\r
   7 \r
   8 #include "IAnimatedMesh.h"\r
   9 #include "IQ3Shader.h"\r
  10 #include "quaternion.h"\r
  11 \r
  12 namespace irr\r
  13 {\r
  14 namespace scene\r
  15 {\r
  16 \r
  17         enum eMD3Models\r
  18         {\r
  19                 EMD3_HEAD = 0,\r
  20                 EMD3_UPPER,\r
  21                 EMD3_LOWER,\r
  22                 EMD3_WEAPON,\r
  23                 EMD3_NUMMODELS\r
  24         };\r
  25 \r
  26         //! Animation list\r
  27         enum EMD3_ANIMATION_TYPE\r
  28         {\r
  29                 // Animations for both lower and upper parts of the player\r
  30                 EMD3_BOTH_DEATH_1 = 0,\r
  31                 EMD3_BOTH_DEAD_1,\r
  32                 EMD3_BOTH_DEATH_2,\r
  33                 EMD3_BOTH_DEAD_2,\r
  34                 EMD3_BOTH_DEATH_3,\r
  35                 EMD3_BOTH_DEAD_3,\r
  36 \r
  37                 // Animations for the upper part\r
  38                 EMD3_TORSO_GESTURE,\r
  39                 EMD3_TORSO_ATTACK_1,\r
  40                 EMD3_TORSO_ATTACK_2,\r
  41                 EMD3_TORSO_DROP,\r
  42                 EMD3_TORSO_RAISE,\r
  43                 EMD3_TORSO_STAND_1,\r
  44                 EMD3_TORSO_STAND_2,\r
  45 \r
  46                 // Animations for the lower part\r
  47                 EMD3_LEGS_WALK_CROUCH,\r
  48                 EMD3_LEGS_WALK,\r
  49                 EMD3_LEGS_RUN,\r
  50                 EMD3_LEGS_BACK,\r
  51                 EMD3_LEGS_SWIM,\r
  52                 EMD3_LEGS_JUMP_1,\r
  53                 EMD3_LEGS_LAND_1,\r
  54                 EMD3_LEGS_JUMP_2,\r
  55                 EMD3_LEGS_LAND_2,\r
  56                 EMD3_LEGS_IDLE,\r
  57                 EMD3_LEGS_IDLE_CROUCH,\r
  58                 EMD3_LEGS_TURN,\r
  59 \r
  60                 //! Not an animation, but amount of animation types.\r
  61                 EMD3_ANIMATION_COUNT\r
  62         };\r
  63 \r
  64         struct SMD3AnimationInfo\r
  65         {\r
  66                 //! First frame\r
  67                 s32 first;\r
  68                 //! Last frame\r
  69                 s32 num;\r
  70                 //! Looping frames\r
  71                 s32 looping;\r
  72                 //! Frames per second\r
  73                 s32 fps;\r
  74         };\r
  75 \r
  76 \r
  77 // byte-align structures\r
  78 #include "irrpack.h"\r
  79 \r
  80         //! this holds the header info of the MD3 file\r
  81         struct SMD3Header\r
  82         {\r
  83                 c8 headerID[4]; //id of file, always "IDP3"\r
  84                 s32 Version;    //this is a version number, always 15\r
  85                 s8 fileName[68];//sometimes left Blank... 65 chars, 32bit aligned == 68 chars\r
  86                 s32 numFrames;  //number of KeyFrames\r
  87                 s32 numTags;    //number of 'tags' per frame\r
  88                 s32 numMeshes;  //number of meshes/skins\r
  89                 s32 numMaxSkins;//maximum number of unique skins used in md3 file. artefact md2\r
  90                 s32 frameStart; //starting position of frame-structur\r
  91                 s32 tagStart;   //starting position of tag-structures\r
  92                 s32 tagEnd;     //ending position of tag-structures/starting position of mesh-structures\r
  93                 s32 fileSize;\r
  94         } PACK_STRUCT;\r
  95 \r
  96         //! this holds the header info of an MD3 mesh section\r
  97         struct SMD3MeshHeader\r
  98         {\r
  99                 c8 meshID[4];           //id, must be IDP3\r
 100                 c8 meshName[68];        //name of mesh 65 chars, 32 bit aligned == 68 chars\r
 101 \r
 102                 s32 numFrames;          //number of meshframes in mesh\r
 103                 s32 numShader;          //number of skins in mesh\r
 104                 s32 numVertices;        //number of vertices\r
 105                 s32 numTriangles;       //number of Triangles\r
 106 \r
 107                 s32 offset_triangles;   //starting position of Triangle data, relative to start of Mesh_Header\r
 108                 s32 offset_shaders;     //size of header\r
 109                 s32 offset_st;          //starting position of texvector data, relative to start of Mesh_Header\r
 110                 s32 vertexStart;        //starting position of vertex data,relative to start of Mesh_Header\r
 111                 s32 offset_end;\r
 112         } PACK_STRUCT;\r
 113 \r
 114 \r
 115         //! Compressed Vertex Data\r
 116         struct SMD3Vertex\r
 117         {\r
 118                 s16 position[3];\r
 119                 u8 normal[2];\r
 120         } PACK_STRUCT;\r
 121 \r
 122         //! Texture Coordinate\r
 123         struct SMD3TexCoord\r
 124         {\r
 125                 f32 u;\r
 126                 f32 v;\r
 127         } PACK_STRUCT;\r
 128 \r
 129         //! Triangle Index\r
 130         struct SMD3Face\r
 131         {\r
 132                 s32 Index[3];\r
 133         } PACK_STRUCT;\r
 134 \r
 135 \r
 136 // Default alignment\r
 137 #include "irrunpack.h"\r
 138 \r
 139         //! Holding Frame Data for a Mesh\r
 140         struct SMD3MeshBuffer : public IReferenceCounted\r
 141         {\r
 142                 SMD3MeshHeader MeshHeader;\r
 143 \r
 144                 core::stringc Shader;\r
 145                 core::array < s32 > Indices;\r
 146                 core::array < SMD3Vertex > Vertices;\r
 147                 core::array < SMD3TexCoord > Tex;\r
 148         };\r
 149 \r
 150         //! hold a tag info for connecting meshes\r
 151         /** Basically its an alternate way to describe a transformation. */\r
 152         struct SMD3QuaternionTag\r
 153         {\r
 154                 virtual ~SMD3QuaternionTag()\r
 155                 {\r
 156                         position.X = 0.f;\r
 157                 }\r
 158 \r
 159                 // construct copy constructor\r
 160                 SMD3QuaternionTag( const SMD3QuaternionTag & copyMe )\r
 161                 {\r
 162                         *this = copyMe;\r
 163                 }\r
 164 \r
 165                 // construct for searching\r
 166                 SMD3QuaternionTag( const core::stringc& name )\r
 167                         : Name ( name ) {}\r
 168 \r
 169                 // construct from a position and euler angles in degrees\r
 170                 SMD3QuaternionTag ( const core::vector3df &pos, const core::vector3df &angle )\r
 171                         : position(pos), rotation(angle * core::DEGTORAD) {}\r
 172 \r
 173                 // set to matrix\r
 174                 void setto ( core::matrix4 &m )\r
 175                 {\r
 176                         rotation.getMatrix ( m, position );\r
 177                 }\r
 178 \r
 179                 bool operator == ( const SMD3QuaternionTag &other ) const\r
 180                 {\r
 181                         return Name == other.Name;\r
 182                 }\r
 183 \r
 184                 SMD3QuaternionTag & operator=( const SMD3QuaternionTag & copyMe )\r
 185                 {\r
 186                         Name = copyMe.Name;\r
 187                         position = copyMe.position;\r
 188                         rotation = copyMe.rotation;\r
 189                         return *this;\r
 190                 }\r
 191 \r
 192                 core::stringc Name;\r
 193                 core::vector3df position;\r
 194                 core::quaternion rotation;\r
 195         };\r
 196 \r
 197         //! holds a associative list of named quaternions\r
 198         struct SMD3QuaternionTagList\r
 199         {\r
 200                 SMD3QuaternionTagList()\r
 201                 {\r
 202                         Container.setAllocStrategy(core::ALLOC_STRATEGY_SAFE);\r
 203                 }\r
 204 \r
 205                 // construct copy constructor\r
 206                 SMD3QuaternionTagList(const SMD3QuaternionTagList& copyMe)\r
 207                 {\r
 208                         *this = copyMe;\r
 209                 }\r
 210 \r
 211                 virtual ~SMD3QuaternionTagList() {}\r
 212 \r
 213                 SMD3QuaternionTag* get(const core::stringc& name)\r
 214                 {\r
 215                         SMD3QuaternionTag search ( name );\r
 216                         s32 index = Container.linear_search ( search );\r
 217                         if ( index >= 0 )\r
 218                                 return &Container[index];\r
 219                         return 0;\r
 220                 }\r
 221 \r
 222                 u32 size () const\r
 223                 {\r
 224                         return Container.size();\r
 225                 }\r
 226 \r
 227                 void set_used(u32 new_size)\r
 228                 {\r
 229                         s32 diff = (s32) new_size - (s32) Container.allocated_size();\r
 230                         if ( diff > 0 )\r
 231                         {\r
 232                                 SMD3QuaternionTag e("");\r
 233                                 for ( s32 i = 0; i < diff; ++i )\r
 234                                         Container.push_back(e);\r
 235                         }\r
 236                 }\r
 237 \r
 238                 const SMD3QuaternionTag& operator[](u32 index) const\r
 239                 {\r
 240                         return Container[index];\r
 241                 }\r
 242 \r
 243                 SMD3QuaternionTag& operator[](u32 index)\r
 244                 {\r
 245                         return Container[index];\r
 246                 }\r
 247 \r
 248                 void push_back(const SMD3QuaternionTag& other)\r
 249                 {\r
 250                         Container.push_back(other);\r
 251                 }\r
 252 \r
 253                 SMD3QuaternionTagList& operator = (const SMD3QuaternionTagList & copyMe)\r
 254                 {\r
 255                         Container = copyMe.Container;\r
 256                         return *this;\r
 257                 }\r
 258 \r
 259         private:\r
 260                 core::array < SMD3QuaternionTag > Container;\r
 261         };\r
 262 \r
 263 \r
 264         //! Holding Frames Buffers and Tag Infos\r
 265         struct SMD3Mesh: public IReferenceCounted\r
 266         {\r
 267                 SMD3Mesh ()\r
 268                 {\r
 269                         MD3Header.numFrames = 0;\r
 270                 }\r
 271 \r
 272                 virtual ~SMD3Mesh()\r
 273                 {\r
 274                         for (u32 i=0; i<Buffer.size(); ++i)\r
 275                                 Buffer[i]->drop();\r
 276                 }\r
 277 \r
 278                 core::stringc Name;\r
 279                 core::array<SMD3MeshBuffer*> Buffer;\r
 280                 SMD3QuaternionTagList TagList;\r
 281                 SMD3Header MD3Header;\r
 282         };\r
 283 \r
 284 \r
 285         //! Interface for using some special functions of MD3 meshes\r
 286         class IAnimatedMeshMD3 : public IAnimatedMesh\r
 287         {\r
 288         public:\r
 289 \r
 290                 //! tune how many frames you want to render in between.\r
 291                 virtual void setInterpolationShift(u32 shift, u32 loopMode) =0;\r
 292 \r
 293                 //! get the tag list of the mesh.\r
 294                 virtual SMD3QuaternionTagList* getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop) =0;\r
 295 \r
 296                 //! get the original md3 mesh.\r
 297                 virtual SMD3Mesh* getOriginalMesh() =0;\r
 298         };\r
 299 \r
 300 } // end namespace scene\r
 301 } // end namespace irr\r
 302 \r
 303 #endif\r
 304 \r