IAnimatedMeshMD3.hpp

// Copyright (C) 2007-2012 Nikolaus Gebhardt / Thomas Alten
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_I_ANIMATED_MESH_MD3_HPP_INCLUDED
#define DCPP_I_ANIMATED_MESH_MD3_HPP_INCLUDED
 
#include <duckcpp/core/engine/IAnimatedMesh.hpp>
#include <duckcpp/core/engine/IQ3Shader.hpp>
#include <duckcpp/core/engine/quaternion.hpp>
 
namespace dcpp
{
namespace scene
{
 
    enum eMD3Models
    {
        EMD3_HEAD = 0,
        EMD3_UPPER,
        EMD3_LOWER,
        EMD3_WEAPON,
        EMD3_NUMMODELS
    };
 
    enum EMD3_ANIMATION_TYPE
    {
        // Animations for both lower and upper parts of the player
        EMD3_BOTH_DEATH_1 = 0,
        EMD3_BOTH_DEAD_1,
        EMD3_BOTH_DEATH_2,
        EMD3_BOTH_DEAD_2,
        EMD3_BOTH_DEATH_3,
        EMD3_BOTH_DEAD_3,
 
        // Animations for the upper part
        EMD3_TORSO_GESTURE,
        EMD3_TORSO_ATTACK_1,
        EMD3_TORSO_ATTACK_2,
        EMD3_TORSO_DROP,
        EMD3_TORSO_RAISE,
        EMD3_TORSO_STAND_1,
        EMD3_TORSO_STAND_2,
 
        // Animations for the lower part
        EMD3_LEGS_WALK_CROUCH,
        EMD3_LEGS_WALK,
        EMD3_LEGS_RUN,
        EMD3_LEGS_BACK,
        EMD3_LEGS_SWIM,
        EMD3_LEGS_JUMP_1,
        EMD3_LEGS_LAND_1,
        EMD3_LEGS_JUMP_2,
        EMD3_LEGS_LAND_2,
        EMD3_LEGS_IDLE,
        EMD3_LEGS_IDLE_CROUCH,
        EMD3_LEGS_TURN,
 
        EMD3_ANIMATION_COUNT
    };
 
    class SMD3AnimationInfo
    {
    public:
        i32 first;
        i32 num;
        i32 looping;
        i32 fps;
    };
 
 
// byte-align classes
#include <duckcpp/core/engine/irrpack.hpp>
 
    class SMD3Header
    {
    public:
        c8 headerID[4]; //id of file, always "IDP3"
        i32 Version;    //this is a version number, always 15
        i8 fileName[68];//sometimes left Blank... 65 chars, 32bit aligned == 68 chars
        i32 numFrames;  //number of KeyFrames
        i32 numTags;    //number of 'tags' per frame
        i32 numMeshes;  //number of meshes/skins
        i32 numMaxSkins;//maximum number of unique skins used in md3 file. artefact md2
        i32 frameStart; //starting position of frame-structur
        i32 tagStart;   //starting position of tag-classes
        i32 tagEnd; //ending position of tag-classes/starting position of mesh-classes
        i32 fileSize;
    } PACK_CLASS;
 
    class SMD3MeshHeader
    {
    public:
        c8 meshID[4];       //id, must be IDP3
        c8 meshName[68];    //name of mesh 65 chars, 32 bit aligned == 68 chars
 
        i32 numFrames;      //number of meshframes in mesh
        i32 numShader;      //number of skins in mesh
        i32 numVertices;    //number of vertices
        i32 numTriangles;   //number of Triangles
 
        i32 offset_triangles;   //starting position of Triangle data, relative to start of Mesh_Header
        i32 offset_shaders; //size of header
        i32 offset_st;      //starting position of texvector data, relative to start of Mesh_Header
        i32 vertexStart;    //starting position of vertex data,relative to start of Mesh_Header
        i32 offset_end;
    } PACK_CLASS;
 
 
    class SMD3Vertex
    {
    public:
        i16 position[3];
        u8 normal[2];
    } PACK_CLASS;
 
    class SMD3TexCoord
    {
    public:
        f32 u;
        f32 v;
    } PACK_CLASS;
 
    class SMD3Face
    {
    public:
        i32 Index[3];
    } PACK_CLASS;
 
 
// Default alignment
#include <duckcpp/core/engine/irrunpack.hpp>
 
    class SMD3MeshBuffer : public IReferenceCounted
    {
    public:
        SMD3MeshHeader MeshHeader;
 
        nub::string Shader;
        nub::array < i32 > Indices;
        nub::array < SMD3Vertex > Vertices;
        nub::array < SMD3TexCoord > Tex;
    };
 
 
    class SMD3QuaternionTag
    {
    public:
        // construct for searching
        SMD3QuaternionTag( const nub::string& name )
            : Name ( name ) {}
 
        // construct from a position and euler angles in degrees
        SMD3QuaternionTag ( const nub::vector3df &pos, const nub::vector3df &angle )
            : position(pos), rotation(angle * nub::DEGTORAD) {}
 
        // set to matrix
        void setto ( nub::matrix4 &m )
        {
            rotation.getMatrix ( m, position );
        }
 
        bool operator == ( const SMD3QuaternionTag &other ) const
        {
            return Name == other.Name;
        }
 
        nub::string Name;
        nub::vector3df position;
        nub::quaternion rotation;
    };
 
    class SMD3QuaternionTagList
    {
    public:
        SMD3QuaternionTagList()
        {
            Container.setAllocStrategy(nub::ALLOC_STRATEGY_SAFE);
        }
 
        SMD3QuaternionTag* get(const nub::string& name)
        {
            SMD3QuaternionTag search ( name );
            const i32 index = Container.linear_search ( search );
            if ( index >= 0 )
                return &Container[index];
            return 0;
        }
 
        u32 size () const
        {
            return Container.size();
        }
 
        void set_used(u32 new_size)
        {
            const i32 diff = (i32) new_size - (i32) Container.allocated_size();
            if ( diff > 0 )
            {
                SMD3QuaternionTag e("");
                for ( i32 i = 0; i < diff; ++i )
                    Container.push_back(e);
            }
        }
 
        const SMD3QuaternionTag& operator[](u32 index) const
        {
            return Container[index];
        }
 
        SMD3QuaternionTag& operator[](u32 index)
        {
            return Container[index];
        }
 
        void push_back(const SMD3QuaternionTag& other)
        {
            Container.push_back(other);
        }
 
    private:
        nub::array < SMD3QuaternionTag > Container;
    };
 
 
    class SMD3Mesh: public IReferenceCounted
    {
    public:
        SMD3Mesh ()
        {
            MD3Header.numFrames = 0;
        }
 
        virtual ~SMD3Mesh()
        {
            for (u32 i=0; i<Buffer.size(); ++i)
                Buffer[i]->drop();
        }
 
        nub::string Name;
        nub::array<SMD3MeshBuffer*> Buffer;
        SMD3QuaternionTagList TagList;
        SMD3Header MD3Header;
    };
 
 
    class IAnimatedMeshMD3 : public IAnimatedMesh
    {
    public:
 
        virtual void setInterpolationShift(u32 shift, u32 loopMode) =0;
 
        virtual SMD3QuaternionTagList* getTagList(i32 frame, i32 detailLevel, i32 startFrameLoop, i32 endFrameLoop) =0;
 
        virtual SMD3Mesh* getOriginalMesh() =0;
    };
 
} // end namespace scene
} // end namespace dcpp
 
#endif