D:/Zythum/DinoKod/Model/MdlMesh.h

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : MdlMesh.h
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#ifndef __MDLMESH_H__
#define __MDLMESH_H__

#include "Model/ModelDll.h"
#include "Common/Types.h"
#include "Common/Vertex.h"
#include "Common/File.h"
#include "Common/Error.h"
#include "Common/Table.h"
#include "Common/Matrix.h"
#include "Common/List.h"

#define MAGIC_MESH              "MSH"
#define MAGIC_PRIMITIVE "PRI"
#define MAGIC_VERTEX    "VTX"

#define WRITEMAGIC( __magic ) \
                KStr    Magic( __magic ); \
                File.WriteString( Magic );

#define TESTMAGIC( __magic ) \
                KStr    Magic; \
                File.ReadString( Magic ); \
                if( Magic != KStr( __magic ) ) \
                        KError::FatalError( NULL, "KMdlMesh::Load(...) : Bad magic %s, file corrupted", __magic );

class KMdlMesh;

//---------------------------------------------------------------------------
typedef enum _KMODELMESHTYPE
{
        KMMT_MESH,
        KMMT_BONE,
        KMMT_DUMMY
} KMODELMESHTYPE;

//---------------------------------------------------------------------------
class MODEL_API KMdlShader
{
public:
        char*           m_pShaderName;
};

//---------------------------------------------------------------------------
class MODEL_API KMdlVertex : public KBVertex
{
public:
        void Save( KFile& File )
        {
                File << m_Position.x;
                File << m_Position.y;
                File << m_Position.z;
                File << m_Normal.x;
                File << m_Normal.y;
                File << m_Normal.z;
                
                for( u32 i = 0; i < KBVERTEX_NUNBLENDWEIGHT; i ++ )
                        File << m_Weight[i];
                
                for( u32 i = 0; i < KBVERTEX_NUNBLENDWEIGHT; i ++ )
                        File << m_Indices[i];
                
                File << m_TU;
                File << m_TV;
        }

        void Load( KFile& File )
        {
                File >> m_Position.x;
                File >> m_Position.y;
                File >> m_Position.z;
                File >> m_Normal.x;
                File >> m_Normal.y;
                File >> m_Normal.z;

                m_Normal.Normalize();
        
                for( u32 i = 0; i < KBVERTEX_NUNBLENDWEIGHT; i ++ )
                        File >> m_Weight[i];
                
                for( u32 i = 0; i < KBVERTEX_NUNBLENDWEIGHT; i ++ )
                        File >> m_Indices[i];
                
                File >> m_TU;
                File >> m_TV;
        }
};

//---------------------------------------------------------------------------
class MODEL_API KMdlFrameVertex
{
public:
        u32                                     m_FrameId;
        u16                                     m_nVertices;
        KMdlVertex*                     m_pVertices;

        KMdlFrameVertex()
        {
                m_FrameId               = 0;
                m_nVertices             = 0;
                m_pVertices             = NULL;
        }

        ~KMdlFrameVertex()
        {
                if( m_pVertices )       Deletev( m_pVertices );
        }

        void Save( KFile& File )
        {
                WRITEMAGIC( MAGIC_VERTEX );
                File << m_FrameId;
                File << m_nVertices;

                u32     VertexId;
                for( VertexId = 0; VertexId < m_nVertices; VertexId ++ )
                        m_pVertices[VertexId].Save( File );
        }

        void Load( KFile& File )
        {
                TESTMAGIC( MAGIC_VERTEX );
                File >> m_FrameId;
                File >> m_nVertices;
                
                if( m_nVertices )
                {
                        m_pVertices = new KMdlVertex[m_nVertices];              

                        u32     VertexId;
                        for( VertexId = 0; VertexId < m_nVertices; VertexId ++ )
                                m_pVertices[VertexId].Load( File );
                }
        }

        void GenerateBlendList()
        {
                
        }
};

//---------------------------------------------------------------------------
class MODEL_API KMdlPrimitive
{
public:
        u32                                                     m_ShaderId;
        u16                                                     m_nIndices;
        u16*                                            m_pIndices;
        u16                                                     m_nVertices;
        u32                                                     m_nFrames;
        KTable<KMdlFrameVertex*>        m_FrameVertices;
        u32                                                     m_MaxFrames;                    // Inutile de sauvegarder pour le moment
        KMdlFrameVertex**                       m_pFastFrameVertex;             // Inutile de sauvegarder pour le moment
        KVertex*                                        m_pTranformedVertices;  // Inutile de sauvegarder pour le moment

        KMdlPrimitive();
        ~KMdlPrimitive();

        void                                            Free();
        void                                            Save( KFile& File );
        void                                            Load( KFile& File );

        KMdlFrameVertex*                        GetSlowFrameVertex( u32 Frame );
        void                                            GenerateFastFrameVertex();
        KMdlFrameVertex*                        GetFrameVertex( u32 Frame );
};

//---------------------------------------------------------------------------
class MODEL_API KMdlFrameMatrix
{
public:
        u32                                     m_FrameId;
        KMatrix                         m_Matrix;

        KMdlFrameMatrix()
        {
                m_FrameId       = 0;
        }

        void Save( KFile& File )
        {
                File << m_FrameId;
                File << m_Matrix;
        }

        void Load( KFile& File )
        {
                File >> m_FrameId;
                File >> m_Matrix;
        }
};

//---------------------------------------------------------------------------
class MODEL_API KMdlBone
{
public:
        KStr                            m_Name;
        KMdlMesh*                       m_pBone;

        KMdlBone()
        {
                m_pBone = NULL;
        }

        void Save( KFile& File )
        {
                File.WriteString( m_Name );
        }

        void Load( KFile& File )
        {
                File.ReadString( m_Name );
                m_pBone = NULL;
        }
};

//---------------------------------------------------------------------------
typedef enum _KMDLMESHRENDEREFFECT
{
        KMMRE_NORMAL,
        KMMRE_NORMALWIREFRAME
} KMDLMESHRENDEREFFECT;

//---------------------------------------------------------------------------
class MODEL_API KMdlMesh
{
private:
        KTable<KMdlPrimitive*>          m_Primitives;
        KTable<KMdlFrameMatrix*>        m_FrameMatrix;
        KList<KMdlMesh*>                        m_pChildrens;
        KTable<KMdlBone*>                       m_Bones;

public:
        KStr                                            m_Name;
        KStr                                            m_FatherName;
        KMdlMesh*                                       m_pFather;
        KMODELMESHTYPE                          m_Type;
        
        KMatrix                                         m_FirstWorldMatrix;
        KMatrix                                         m_CurrentWorldMatrix;
        KMDLMESHRENDEREFFECT            m_RenderEffect;         // Inutile de sauvegarder pour le moment
        u32                                                     m_MaxFrame;                     // Inutile de sauvegarder pour le moment
        KMdlFrameMatrix**                       m_pFastFrameMatrix;     // Inutile de sauvegarder pour le moment
        u32                                                     m_CurrentFrame;         // Inutile de sauvegarder pour le moment
        KMatrix                                         m_BlendMatrix;          // Inutile de sauvegarder pour le moment

        KMdlMesh();
        ~KMdlMesh();

        void                                            Save( KFile& File );
        void                                            Load( KFile& File, s32 EndFrame );
        KMdlFrameMatrix*                        GetSlowFrameMatrix( u32 Frame );
        void                                            GenerateFastFrameMatrix();

        KMdlFrameMatrix* GetFrameMatrix( u32 Frame )
        {
                KASSERT( Frame >= 0 );
                KASSERT( Frame <= m_MaxFrame );
                KASSERT( m_pFastFrameMatrix );
                return m_pFastFrameMatrix[Frame];
        }

        void SetFrame( u32 Frame )
        {
                KASSERT( Frame >= 0 );
                KASSERT( Frame <= m_MaxFrame );
                m_CurrentFrame = Frame;
        }

        static void     SetMeshFrame( KMdlMesh* pMesh, u32 Frame, bool bInherit );

        void                                            AddpChild( KMdlMesh* pChild )                                           { m_pChildrens.Add( pChild );                   }
        void                                            ClearChilds()                                                                           { m_pChildrens.Clear();                                 }
        KMdlMesh*                                       GetpFirstChild()                                                                        { return m_pChildrens.GetFirst();               }
        KMdlMesh*                                       GetpNextChild( KMdlMesh* pChild )                                       { return m_pChildrens.GetNext( pChild );}

        void                                            AddpBone( KMdlBone* pBone )                                                     { m_Bones.Add( pBone );                                 }
        KMdlBone*                                       GetpBone( u32 BoneId )                                                          { return m_Bones[BoneId];                               }
        u32                                                     GetnBones()                                                                                     { return m_Bones.GetSize();                             }

        void                                            AddpPrimitive( KMdlPrimitive* pPrimitive )                      { m_Primitives.Add( pPrimitive );               }
        KMdlPrimitive*                          GetpPrimitive( u32 PrimitiveId )                                        { return m_Primitives[PrimitiveId];             }
        u32                                                     GetnPrimitives()                                                                        { return m_Primitives.GetSize();                }

        void                                            AddpFrameMatrix( KMdlFrameMatrix* pFrameMatrix )        { m_FrameMatrix.Add( pFrameMatrix );            }
};

#endif  __MDLMESH_H__

---