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:
        dcpp::int32_kt first;
        dcpp::int32_kt num;
        dcpp::int32_kt looping;
        dcpp::int32_kt fps;
    };
 
 
// byte-align classes
#include <duckcpp/core/engine/irrpack.hpp>
 
    class SMD3Header
    {
    public:
        dcpp::char_kt headerID[4];  //id of file, always "IDP3"
        dcpp::int32_kt Version; //this is a version number, always 15
        dcpp::int8_kt fileName[68];//sometimes left Blank... 65 chars, 32bit aligned == 68 chars
        dcpp::int32_kt numFrames;   //number of KeyFrames
        dcpp::int32_kt numTags; //number of 'tags' per frame
        dcpp::int32_kt numMeshes;   //number of meshes/skins
        dcpp::int32_kt numMaxSkins;//maximum number of unique skins used in md3 file. artefact md2
        dcpp::int32_kt frameStart;  //starting position of frame-structur
        dcpp::int32_kt tagStart;    //starting position of tag-classes
        dcpp::int32_kt tagEnd;  //ending position of tag-classes/starting position of mesh-classes
        dcpp::int32_kt fileSize;
    } PACK_CLASS;
 
    class SMD3MeshHeader
    {
    public:
        dcpp::char_kt meshID[4];        //id, must be IDP3
        dcpp::char_kt meshName[68]; //name of mesh 65 chars, 32 bit aligned == 68 chars
 
        dcpp::int32_kt numFrames;       //number of meshframes in mesh
        dcpp::int32_kt numShader;       //number of skins in mesh
        dcpp::int32_kt numVertices; //number of vertices
        dcpp::int32_kt numTriangles;    //number of Triangles
 
        dcpp::int32_kt offset_triangles;    //starting position of Triangle data, relative to start of Mesh_Header
        dcpp::int32_kt offset_shaders;  //size of header
        dcpp::int32_kt offset_st;       //starting position of texvector data, relative to start of Mesh_Header
        dcpp::int32_kt vertexStart; //starting position of vertex data,relative to start of Mesh_Header
        dcpp::int32_kt offset_end;
    } PACK_CLASS;
 
 
    class SMD3Vertex
    {
    public:
        dcpp::int16_kt position[3];
        dcpp::uint8_kt normal[2];
    } PACK_CLASS;
 
    class SMD3TexCoord
    {
    public:
        dcpp::float32_kt u;
        dcpp::float32_kt v;
    } PACK_CLASS;
 
    class SMD3Face
    {
    public:
        dcpp::int32_kt Index[3];
    } PACK_CLASS;
 
 
// Default alignment
#include <duckcpp/core/engine/irrunpack.hpp>
 
    class SMD3MeshBuffer : public IReferenceCounted
    {
    public:
        SMD3MeshHeader MeshHeader;
 
        dcpp::nub::string Shader;
        dcpp::nub::array < dcpp::int32_kt > Indices;
        dcpp::nub::array < SMD3Vertex > Vertices;
        dcpp::nub::array < SMD3TexCoord > Tex;
    };
 
 
    class SMD3QuaternionTag
    {
    public:
        // construct for searching
        SMD3QuaternionTag( const dcpp::nub::string& name )
            : Name ( name ) {}
 
        // construct from a position and euler angles in degrees
        SMD3QuaternionTag ( const dcpp::nub::vector3df &pos, const dcpp::nub::vector3df &angle )
            : position(pos), rotation(angle * dcpp::nub::DEGTORAD) {}
 
        // set to matrix
        void setto ( dcpp::nub::matrix4 &m )
        {
            rotation.getMatrix ( m, position );
        }
 
        bool operator == ( const SMD3QuaternionTag &other ) const
        {
            return Name == other.Name;
        }
 
        dcpp::nub::string Name;
        dcpp::nub::vector3df position;
        dcpp::nub::quaternion rotation;
    };
 
    class SMD3QuaternionTagList
    {
    public:
        SMD3QuaternionTagList()
        {
            Container.setAllocStrategy(dcpp::nub::ALLOC_STRATEGY_SAFE);
        }
 
        SMD3QuaternionTag* get(const dcpp::nub::string& name)
        {
            SMD3QuaternionTag search ( name );
            const dcpp::int32_kt index = Container.linear_search ( search );
            if ( index >= 0 )
                return &Container[index];
            return 0;
        }
 
        dcpp::uint32_kt size () const
        {
            return Container.size();
        }
 
        void set_used(dcpp::uint32_kt new_size)
        {
            const dcpp::int32_kt diff = (dcpp::int32_kt) new_size - (dcpp::int32_kt) Container.allocated_size();
            if ( diff > 0 )
            {
                SMD3QuaternionTag e("");
                for ( dcpp::int32_kt i = 0; i < diff; ++i )
                    Container.push_back(e);
            }
        }
 
        const SMD3QuaternionTag& operator[](dcpp::uint32_kt index) const
        {
            return Container[index];
        }
 
        SMD3QuaternionTag& operator[](dcpp::uint32_kt index)
        {
            return Container[index];
        }
 
        void push_back(const SMD3QuaternionTag& other)
        {
            Container.push_back(other);
        }
 
    private:
        dcpp::nub::array < SMD3QuaternionTag > Container;
    };
 
 
    class SMD3Mesh: public IReferenceCounted
    {
    public:
        SMD3Mesh ()
        {
            MD3Header.numFrames = 0;
        }
 
        virtual ~SMD3Mesh()
        {
            for (dcpp::uint32_kt i=0; i<Buffer.size(); ++i)
                Buffer[i]->drop();
        }
 
        dcpp::nub::string Name;
        dcpp::nub::array<SMD3MeshBuffer*> Buffer;
        SMD3QuaternionTagList TagList;
        SMD3Header MD3Header;
    };
 
 
    class IAnimatedMeshMD3 : public IAnimatedMesh
    {
    public:
 
        virtual void setInterpolationShift(dcpp::uint32_kt shift, dcpp::uint32_kt loopMode) =0;
 
        virtual SMD3QuaternionTagList* getTagList(dcpp::int32_kt frame, dcpp::int32_kt detailLevel, dcpp::int32_kt startFrameLoop, dcpp::int32_kt endFrameLoop) =0;
 
        virtual SMD3Mesh* getOriginalMesh() =0;
    };
 
} // end namespace scene
} // end namespace dcpp
 
#endif