md2.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/

#ifndef LILITH_MD2_INCLUDED
#define LILITH_MD2_INCLUDED

#include "animated.h"
#include "../grinliz/glvector.h"

namespace lilith3d
{
        
enum {
        MD2_STAND,
        MD2_RUN,
        MD2_ATTACK,
        MD2_PAIN0,
        MD2_PAIN1,
        MD2_PAIN2,
        MD2_JUMP,
        MD2_FLIP,
        MD2_SALUTE,
        MD2_TAUNT,              
        MD2_WAVE,               
        MD2_POINT,              
        MD2_CRSTAND,    
        MD2_CRWALK,             
        MD2_CRATTACK,   
        MD2_CRPAIN,             
        MD2_CRDEATH,    
        MD2_DEATH0,
        MD2_DEATH1,
        MD2_DEATH2,
        MD2_COUNT,

        MD2_PAIN = MD2_PAIN0,
        MD2_DEATH = MD2_DEATH0,
};

struct LMD2Vertex
{
        grinliz::Vector3F       pos;
        grinliz::Vector3F       normal;
};

// 0 model, 1 weapon
struct LMD2RenderIn
{
        U32 actionID;
        U32 time;
};

struct LMD2RenderOut
{
        // 0 for model, 1 for weapon
        U32 nVertex[2];
        const Texture*  texture[2];

        // Each array needs to be at least 2048 in length.
        LMD2Vertex* vertex[2];
};

class MD2Resource : public AnimatedResource
{
  public:
        MD2Resource( const std::string& name );
        virtual ~MD2Resource();
        virtual const MD2Resource* ToMD2() const        { return this; }

        enum {
                SPRITE, 
                WEAPON
        };

        bool Load( const std::string& filename, int type );

        void SetTexture( const Texture* tex, int type ) { 
                if ( type == SPRITE )
                        sprite.texture = tex;
                else if ( type == WEAPON )
                        weapon.texture = tex;
        }

        U32 AnimationLength( int action ) const;
        
        void SetMelee( bool _melee )    { this->melee = _melee; }
        bool Melee() const                      { return melee; }
        bool Ranged() const                     { return !melee; }

        // NOTE: this runs in world space, unlike the StaticMesh
        int IntersectRay(       const LMD2RenderOut& out, const grinliz::Matrix4& m,
                const grinliz::Vector3F& point, const grinliz::Vector3F& dir, grinliz::Vector3F* intersection ) const;

        const grinliz::Vector3F& WeaponOrigin() const { return weaponOrigin; }
        const grinliz::Matrix4& ResXForm() const { return resXForm; }
        void GenerateVertex( const LMD2RenderIn& in, LMD2RenderOut* out ) const;
        void StreamOutMD2(  int i, const LMD2RenderOut& out ) const;
        void StreamOutShadowMD2( ShadowVolumeCache* cache, const LMD2RenderOut& out, const grinliz::Matrix4& mat ) const;
        bool IsLooping( int action ) const;

  private:

        //int ActionToMD2Id( int action, bool* looping ) const;

        static grinliz::Vector3F normals[256];
        static bool normalsFlipped;

        struct MD2Header
        {
                U32 magic;          // magic number: "IDP2"
                U32 version;        // version: must be 8

                U32 textureWidth;   // not used by lilith
                U32 textureHeight;  // not used by lilith

                U32 frameSize;      // the size of the frame in bytes

                U32 numSkins;           
                U32 numVertices;        // number of vertices per frame
                U32 numST;                      // number of texture coordinates
                U32 numTri;                     // number of triangles
                U32 numGlCmds;          //
                U32 numFrames;          // number of frames

                U32 offsetSkins;        // offset skin data
                U32 offsetST;           // offset texture coordinate data
                U32 offsetTris;         // offset triangle data
                U32 offsetFrames;       // offset frame data 
                U32 offsetGlCmds;       // offset OpenGL command data
                U32 offsetEnd;          // offset end of file
        };

        struct MD2Tri
        {
                U16 vertexIndex[3];
                U16 textureIndex[3];
        };

        // MD2 texture coordinates.
        // Texture coordinates are stored in a structure as short integers. 
        // To get the true texture coordinates, you have to divide s by skinwidth and t by skinheight
        struct MD2TexST
        {
                S16 s;
                S16 t;
        };

        // Vertices are composed of "compressed" 3D coordinates, which are stored in one byte for 
        // each coordinate, and of a normal vector index. 
        struct MD2Vertex
        {
                U8 x, y, z;
                U8 normal;
        };

        struct MD2Frame
        {
                grinliz::Vector3F       scale;
                grinliz::Vector3F       translate;
                char                            name[16];
                MD2Vertex                       md2Vertex[2048];        // Note it will be 2048 OR LESS
        };

        struct Action
        {
                U32                                     numFrames;
                U32                                     startFrame;
                U32                                     msecPerFrame;
        };

        struct LObject
        {
                const MD2Header* header;
                const Texture*   texture;

                enum { MAX_INDEX = 4096*3 };
                mutable U16 index[MAX_INDEX];
                mutable bool hasIndex;
                grinliz::Vector2F st[2048];

                #ifdef DEBUG
                void* memStart;
                void* memEnd;
                #endif
        
                const MD2Frame* GetFrame( int i ) const {
                        const size_t FRAME_SIZE = sizeof(float)*6 + sizeof(char)*16 + 4*header->numVertices;

                        const MD2Frame* frame = (const MD2Frame*)((U8*)header + header->offsetFrames + FRAME_SIZE*i );
                        GLASSERT( frame > memStart );
                        GLASSERT( frame < memEnd );
                        return frame;
                }
                const MD2TexST* GetTexST() const  {
                        const MD2TexST* texst = (const MD2TexST*)((U8*)header + header->offsetST );
                        GLASSERT( texst > memStart );
                        GLASSERT( texst < memEnd );
                        return texst;
                }
                const MD2Tri* GetTri() const {
                        const MD2Tri* tri = (const MD2Tri*)((U8*)header + header->offsetTris );
                        GLASSERT( tri > memStart );
                        GLASSERT( tri < memEnd );
                        return tri;
                }
        };

        void GenerateObjectVertex(      const LObject* obj,                                     
                                                                int frameId,
                                                                float frame,
                                                                LMD2Vertex* vertex,
                                                                U32 *nVertex ) const;

        bool LoadInner( FILE* fp, LObject* obj, int type );

        inline static void Transform(   const MD2Vertex& md2Vertex, 
                                                                        const MD2Frame* frame,
                                                                        grinliz::Vector3F* out )
        {
                out->x =  (frame->scale.x * (float)md2Vertex.x + frame->translate.x);
                out->y = -(frame->scale.y * (float)md2Vertex.y + frame->translate.y);
                out->z =  (frame->scale.z * (float)md2Vertex.z + frame->translate.z);           
        }

        LObject                         sprite, 
                                                weapon;

        float                           allScale;                       // Scale factor for converting from size in MD2
                                                                                        // coordinates to Lilith coordinates.
        float                           deltaZ;                         // Offset in Lilith coordinates to move feet 
                                                                                        // to the ground.

        Action                          actions[ MD2_COUNT ];   
        grinliz::Vector3F       weaponOrigin;
        bool                            melee;
        grinliz::Matrix4        resXForm;
};


class MD2Mesh : public AnimatedMesh
{
  public:
        MD2Mesh( const MD2Resource* meshResource );
        virtual ~MD2Mesh();

        void SetAction( int action );
        int GetAction();

        bool ActionOkay( int newAction );

        void StreamOutMesh( ELightPass light, EPass pass );

        #ifdef SHADOW_VOLUME
        virtual void StreamOutShadow( ShadowVolumeCache* cache );
        #endif

        //virtual void UpdateZ( float z );
        //virtual void SetPosV( const grinliz::Vector3F& pos, const grinliz::Matrix4& rotation );

        void CalcWeaponOrigin( grinliz::Vector3F* origin ) const;

        const MD2Resource* GetMD2Resource() const { return md2Resource; }

        virtual void IntersectRay(      int flags, 
                                                                const grinliz::Vector3F& point, 
                                                                const grinliz::Vector3F& dir, 
                                                                LilithObjectList* vec );

  protected:
        void VertexCacheCurrent();

        const MD2Resource* md2Resource;
        int action;
        U32 actionStart;
        U32 lastAttack;         // There is a minimum time between attacks.

        LMD2RenderIn  renderIn;
        LMD2RenderOut renderOut;
        bool texGen;

        LMD2Vertex vertex0[2048];
        LMD2Vertex vertex1[2048];
};


};      // namespace lilith3d
#endif

---