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

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

//---------------------------------------------------------------------------------------------------------------------
KMdlMesh::KMdlMesh()
{
        m_Type                          = KMMT_MESH;
        m_pFather                       = NULL;
        m_RenderEffect          = KMMRE_NORMAL;

        // Anim
        m_MaxFrame                      = 0;
        m_CurrentFrame          = 0;
        m_pFastFrameMatrix      = NULL;

        m_BlendMatrix.LoadIdentity();
        m_CurrentWorldMatrix.LoadIdentity();
        m_FirstWorldMatrix.LoadIdentity();
}

//---------------------------------------------------------------------------------------------------------------------
KMdlMesh::~KMdlMesh()
{
        m_pChildrens.Clear();

        u32 i;
        // Primitives
        for( i = 0; i < m_Primitives.GetSize(); i ++ )
                Deletep( m_Primitives[i] );
        m_Primitives.Clear();

        // Matrice de transformation
        for( i = 0; i < m_FrameMatrix.GetSize(); i ++ )
                Deletep( m_FrameMatrix[i] );
        m_FrameMatrix.Clear();

        // Bones
        for( i = 0; i < m_Bones.GetSize(); i ++ )
                Deletep( m_Bones[i] );
        m_Bones.Clear();

        // Matrices optimisées
        if( m_pFastFrameMatrix )
                Deletev( m_pFastFrameMatrix );
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlMesh::Save( KFile& File )
{
        WRITEMAGIC( MAGIC_MESH );
        File.WriteString( m_Name );
        File.WriteString( m_FatherName );
        File << m_Type;
        
        // Matrice de transformation
        u32 nMatrices = m_FrameMatrix.GetSize();
        File << nMatrices;
        for( u32 MatrixId = 0; MatrixId < nMatrices; MatrixId ++ )
                m_FrameMatrix[MatrixId]->Save( File );
        
        // Primitives
        u32 nPrimitives = m_Primitives.GetSize();
        File << nPrimitives;
        for( u32 PrimitiveId = 0; PrimitiveId < nPrimitives; PrimitiveId ++ )
                m_Primitives[PrimitiveId]->Save( File );

        // Bones
        u32 nBones = m_Bones.GetSize();
        File << nBones;
        for( u32 BoneId = 0; BoneId < nBones; BoneId ++ )
                m_Bones[BoneId]->Save( File );
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlMesh::Load( KFile& File, s32 EndFrame )
{
        TESTMAGIC( MAGIC_MESH );
        File.ReadString( m_Name );
        File.ReadString( m_FatherName );
        File >> m_Type;
        
        // End Frame
        m_MaxFrame = EndFrame;

        // Matrice de transformation
        u32                                     nMatrices;
        KMdlFrameMatrix*        pFrameMatrix;

        File >> nMatrices;
        for( u32 MatrixId = 0; MatrixId < nMatrices; MatrixId ++ )
        {
                pFrameMatrix = new KMdlFrameMatrix();
                pFrameMatrix->Load( File );
                m_FrameMatrix.Add( pFrameMatrix );
        }

        // Primitives
        u32                                     nPrimitives;
        KMdlPrimitive*          pPrimitive;

        File >> nPrimitives;
        for( u32 PrimitiveId = 0; PrimitiveId < nPrimitives; PrimitiveId ++ )
        {
                pPrimitive = new KMdlPrimitive();
                pPrimitive->Load( File );
                m_Primitives.Add( pPrimitive );
        }

        // Bones
        u32                                     nBones;
        KMdlBone*                       pBone;

        File >> nBones;
        for( u32 BoneId = 0; BoneId < nBones; BoneId ++ )
        {
                pBone = new KMdlBone();
                pBone->Load( File );
                m_Bones.Add( pBone );
        }

        // Genere les matrices par frame
        GenerateFastFrameMatrix();
}

//---------------------------------------------------------------------------------------------------------------------
KMdlFrameMatrix* KMdlMesh::GetSlowFrameMatrix( u32 Frame )
{
        // Cherche la matrice clé en fonctione de la frame
        KMdlFrameMatrix* pFrameMatrix = NULL;
        for( u32 i = 0; i < m_FrameMatrix.GetSize(); i ++ )
        {
                if( m_FrameMatrix[i]->m_FrameId <= Frame )
                        pFrameMatrix = m_FrameMatrix[i];
                else
                        if( !pFrameMatrix )
                                continue;       // La 1ere clé n'est pas forcement là 0, donc on cherche un peu plus loin...
                        else
                                return pFrameMatrix;
        }

        // Si aucune clé n'a été trouvée, on prend la premiere
        if( !pFrameMatrix && m_FrameMatrix.GetSize() )
        {
                pFrameMatrix = m_FrameMatrix[0];
        }

        return pFrameMatrix;
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlMesh::GenerateFastFrameMatrix()
{
        KASSERT( m_FrameMatrix.GetSize() );
        KASSERT( !m_pFastFrameMatrix );

        // Génère autant de matrice qu'il y a de frame pour un acces memoire plus rapide
//      m_MaxFrame = m_FrameMatrix[m_FrameMatrix.GetSize() - 1]->m_FrameId;
        m_pFastFrameMatrix = new KMdlFrameMatrix*[m_MaxFrame + 1];
        for( u32 i = 0; i < m_MaxFrame + 1; i ++ )
                m_pFastFrameMatrix[i] = GetSlowFrameMatrix( i );
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlMesh::SetMeshFrame( KMdlMesh* pMesh, u32 Frame, bool bInherit )
{
        KASSERT( pMesh );

        pMesh->SetFrame( (Frame <= pMesh->m_MaxFrame) ? Frame : pMesh->m_MaxFrame );
        
        // Hérite l'anim aux fils si demandé
        if( bInherit )
        {
                for( KMdlMesh* pChild = pMesh->m_pChildrens.GetFirst(); pChild; pChild = pMesh->m_pChildrens.GetNext( pChild ) )
                {
                        SetMeshFrame( pChild, Frame, bInherit );
                }
        }
}

//---------------------------------------------------------------------------------------------------------------------
// PRIMITIVE
//---------------------------------------------------------------------------------------------------------------------
KMdlPrimitive::KMdlPrimitive()
{
        m_ShaderId                              = (u32)-1;
        m_nFrames                               = 0;
        m_nIndices                              = 0;
        m_pIndices                              = NULL;
        m_nVertices                             = 0;
        m_MaxFrames                             = 0;
        m_pFastFrameVertex              = NULL;
        m_pTranformedVertices   = NULL;
}

//---------------------------------------------------------------------------------------------------------------------
KMdlPrimitive::~KMdlPrimitive()
{
        Free();
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlPrimitive::Free()
{
        if( m_pIndices )
                Deletev( m_pIndices );
        
        for( u32 i = 0; i < m_FrameVertices.GetSize(); i ++ )
                Deletep( m_FrameVertices[i] );
        m_FrameVertices.Clear();

        SafeDeletev( m_pFastFrameVertex );
        SafeDeletev( m_pTranformedVertices );
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlPrimitive::Save( KFile& File )
{
        WRITEMAGIC( MAGIC_PRIMITIVE );
        File << m_ShaderId;
        File << m_nFrames;
        File << m_nIndices;
        File << m_nVertices;
        
        u32     IndiceId;
        for( IndiceId = 0; IndiceId < m_nIndices; IndiceId ++ )
                File << m_pIndices[IndiceId];

        u32                                     FrameId;
        for( FrameId = 0; FrameId < m_nFrames; FrameId ++ )
                m_FrameVertices[FrameId]->Save( File );
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlPrimitive::Load( KFile& File )
{
        Free();

        TESTMAGIC( MAGIC_PRIMITIVE );
        File >> m_ShaderId;
        File >> m_nFrames;
        File >> m_nIndices;
        File >> m_nVertices;
        
        if( m_nIndices )
        {
                m_pIndices = new u16[m_nIndices];

                u32     IndiceId;
                for( IndiceId = 0; IndiceId < m_nIndices; IndiceId ++ )
                        File >> m_pIndices[IndiceId];
        }

        KMdlFrameVertex*        pFrameVertex;
        u32                                     FrameId;
        for( FrameId = 0; FrameId < m_nFrames; FrameId ++ )
        {
                pFrameVertex = new KMdlFrameVertex();
                pFrameVertex->Load( File );
                m_FrameVertices.Add( pFrameVertex );
        }


        m_pTranformedVertices = new KVertex[m_nVertices];

        GenerateFastFrameVertex();
}

//---------------------------------------------------------------------------------------------------------------------
KMdlFrameVertex* KMdlPrimitive::GetSlowFrameVertex( u32 Frame )
{
        KMdlFrameVertex* pFrameVertex = NULL;
        for( u32 i = 0; i < m_FrameVertices.GetSize(); i ++ )
        {
                if( m_FrameVertices[i]->m_FrameId <= Frame )
                        pFrameVertex = m_FrameVertices[i];
                else
                        return pFrameVertex;
        }
        return pFrameVertex;
}

//---------------------------------------------------------------------------------------------------------------------
void KMdlPrimitive::GenerateFastFrameVertex()
{
        KASSERT( m_FrameVertices.GetSize() );
        KASSERT( !m_pFastFrameVertex );
        m_MaxFrames = m_FrameVertices[m_FrameVertices.GetSize() - 1]->m_FrameId;
        m_pFastFrameVertex = new KMdlFrameVertex*[m_MaxFrames + 1];
        for( u32 i = 0; i < m_MaxFrames + 1; i ++ )
                m_pFastFrameVertex[i] = GetSlowFrameVertex( i );
}

//---------------------------------------------------------------------------------------------------------------------
KMdlFrameVertex* KMdlPrimitive::GetFrameVertex( u32 Frame )
{
        KASSERT( Frame >= 0 );
//      KASSERT( Frame <= m_MaxFrames );
        KASSERT( m_pFastFrameVertex );

        return (Frame > m_MaxFrames) ? m_pFastFrameVertex[m_MaxFrames] : m_pFastFrameVertex[Frame];
}

---