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

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

#define HEADER_MDLMAGIC "3DMODEL"
#define HEADER_ANMMAGIC "ANIM"

u32 KMdlLoader::m_MDLVersion = 104;     // 1.04
u32 KMdlLoader::m_ANMVersion = 100;     // 1.00

//--------------------------------------------------------------------------------------------
KMdlLoader::KMdlLoader()
{
        m_StartFrame    = 0;
        m_EndFrame              = 0;
}

//--------------------------------------------------------------------------------------------
KMdlLoader::~KMdlLoader()
{
        Flush();
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::Flush()
{
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
                Deletep( m_Meshes[m] );
        for( u32 a = 0; a < m_Anims.GetSize(); a ++ )
                Deletep( m_Anims[a] );
        for( u32 t = 0; t < m_Shaders.GetSize(); t ++ )
                Freep( m_Shaders[t] );
        
        m_Meshes.Clear();
        m_Anims.Clear();
        m_Shaders.Clear();
}

//--------------------------------------------------------------------------------------------
bool KMdlLoader::LoadMDL( char* pFileName )
{
        KFile           File;
        char            pMagic[] = { HEADER_MDLMAGIC };
        u32                     Version;

        // Flush shaders & meshes
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
                Deletep( m_Meshes[m] );
        m_Meshes.Clear();

        for( u32 t = 0; t < m_Shaders.GetSize(); t ++ )
                Freep( m_Shaders[t] );
        m_Shaders.Clear();
        

        // Ouvre le fichier
        memset( pMagic, 0, sizeof( pMagic ) );
        
        if( !File.Open( pFileName ) )
        {
                KError::Warning( NULL, "Cannot open model file : %s", pFileName );
                return false;
        }

        // Header
        File >> pMagic;
        if( strncmp( pMagic, HEADER_MDLMAGIC, strlen( HEADER_MDLMAGIC ) ) != 0 )
        {
                KError::Error( NULL, "Bad model header in file : %s", pFileName );
                return false;
        }

        // Version
        File >> Version;
        if( Version != m_MDLVersion )
        {
                KError::Error( NULL, "Bad model version in file : %s\nFile version : %i, Expected version %i", pFileName, Version, m_MDLVersion );
                return false;
        }

        // Shader
        u32             ShaderId;
        u32             Length;
        u32             nTextures;
        char*   pTextureName;

        File >> nTextures;
        for( ShaderId = 0; ShaderId < nTextures; ShaderId ++ )
        {
                File >> Length;
                pTextureName = (char*)malloc(Length + 1);
                File.Read( (u8*)pTextureName, Length );
                pTextureName[Length] = '\0';
                m_Shaders.Add( pTextureName );
        }

        // Anim intervalle
        File >> m_StartFrame >> m_EndFrame;

        // Meshes
        u32                     MeshId;
        u32                     nMeshes;
        KMdlMesh*       pMesh = NULL;

        File >> nMeshes;
        for( MeshId = 0; MeshId < nMeshes; MeshId ++ )
        {
                pMesh = new KMdlMesh();
                pMesh->Load( File, m_EndFrame );
                m_Meshes.Add( pMesh );
        }
        
        File.Close();

        // Hierarchy
        GenerateHierarchy();
        
        // Bones
        GenerateBones();

        // World matrices
        ComputeFirstWorldMatrix();

        return true;
}

//--------------------------------------------------------------------------------------------
#define FINDTOKEN               Parser.FindToken()
#define TOKEN                   Parser.GetToken()
#define NEWLINETOKEN    Parser.IsNewLine()
#define CMPTOKEN(__s)   (stricmp(__s,Parser.GetToken()) == 0)

//--------------------------------------------------------------------------------------------
bool KMdlLoader::LoadANM( char* pFileName )
{
        KParser         Parser;

        // Flush les anims
        for( u32 a = 0; a < m_Anims.GetSize(); a ++ )
                Deletep( m_Anims[a] );
        m_Anims.Clear();

        // Parse le fichier
        if( !Parser.LoadASE( pFileName ) )
        {
                KError::Warning( NULL, "Cannot open anim file : %s\nThe model will not be animated.", pFileName );
                return true;
        }

        // Header
        FINDTOKEN;
        if( !CMPTOKEN( HEADER_ANMMAGIC ) )
        {
                KError::Error( NULL, "Bad anim header in file : %s", pFileName );
                return false;
        }

        // Version
        FINDTOKEN;
        if( atoi( TOKEN ) != m_ANMVersion )
        {
                KError::Error( NULL, "Bad anim version in file : %s\nFile version : %i, Expected version %i", pFileName, atoi( TOKEN ), m_ANMVersion );
                return false;
        }

        // Anims
        while( !Parser.IsEOF() )
        {
                #define TEST_TOKEN_THROW( x )   if( !CMPTOKEN( x ) ) throw x

                KMdlAnim* pAnim = new KMdlAnim();

                try
                {
                        // ANIM_NAME
                        FINDTOKEN;
                        if( !CMPTOKEN( "ANIM_NAME" ) )
                                continue;
                        
                        FINDTOKEN;
                        pAnim->SetName( KStr( TOKEN ) );

                        // {
                        FINDTOKEN;
                        TEST_TOKEN_THROW( "{" );
                        
                        // FRAME_COUNT
                        FINDTOKEN;
                        TEST_TOKEN_THROW( "FRAME_COUNT" );
                        FINDTOKEN;
                        if( atoi( TOKEN ) < 1 )
                        {
                                KError::Error( NULL, "Error in anim file [%s]\nFRAME_COUNT should be greater than 1 [%i]", pFileName, atoi( TOKEN ) );
                                return false;
                        }
                        pAnim->SetMaxFrame( atoi( TOKEN ) - 1 );

                        // FPS
                        FINDTOKEN;
                        TEST_TOKEN_THROW( "FPS" );
                        FINDTOKEN;
                        if( atoi( TOKEN ) < 1 )
                        {
                                KError::Error( NULL, "Error in anim file [%s]\nFPS should be greater than 1 [%i]", pFileName, atoi( TOKEN ) );
                                return false;
                        }
                        pAnim->SetFPS( atoi( TOKEN ) );

                        // }
                        FINDTOKEN;
                        while( !CMPTOKEN( "}" ) )
                        {
                                KMdlMeshAnim* pMeshAnim = new KMdlMeshAnim();

                                // MESHANIM_NAME
                                TEST_TOKEN_THROW( "MESHANIM_NAME" );
                                FINDTOKEN;
                                pMeshAnim->SetpMesh( GetpMeshByName( TOKEN ) );
                                if( !pMeshAnim->GetpMesh() )
                                {
                                        KError::Error( NULL, "Error in anim file [%s]\nUnknown mesh name [%s]", pFileName, TOKEN );
                                        return false;
                                }

                                // {
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "{" );

                                // MESHANIM_INHERITFRAME
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "MESHANIM_INHERITFRAME" );
                                FINDTOKEN;
                                pMeshAnim->SetInheritFrame( atoi( TOKEN ) ? true : false );

                                // MESHANIM_FRAMESTART
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "MESHANIM_FRAMESTART" );
                                FINDTOKEN;
                                pMeshAnim->SetFrameStart( atoi( TOKEN ) );

                                // MESHANIM_FRAMEEND
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "MESHANIM_FRAMEEND" );
                                FINDTOKEN;
                                pMeshAnim->SetFrameEnd( atoi( TOKEN ) );

                                // MESHANIM_MESHFRAMESTART
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "MESHANIM_MESHFRAMESTART" );
                                FINDTOKEN;
                                pMeshAnim->SetMeshFrameStart( atoi( TOKEN ) );

                                // MESHANIM_MESHFRAMEEND
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "MESHANIM_MESHFRAMEEND" );
                                FINDTOKEN;
                                pMeshAnim->SetMeshFrameEnd( atoi( TOKEN ) );

                                pAnim->AddMeshAnim( pMeshAnim );
                                
                                // }
                                FINDTOKEN;
                                TEST_TOKEN_THROW( "}" );

                                FINDTOKEN;
                        }
                }
                catch( char* pToken )
                {
                        KError::Error( NULL, "Error in anim file [%s] line %i\nToken %s not found", pFileName, Parser.GetCurrentLine(), pToken );
                        return false;
                }

                AddAnim( pAnim );
        }

        return true;
}

//--------------------------------------------------------------------------------------------
bool KMdlLoader::SaveMDL( char* pFileName )
{
        KFile           File;
        
        if( !File.Create( pFileName ) )
                return false;

        // Header
        File << HEADER_MDLMAGIC;
        // Version
        File << m_MDLVersion;
        
        // Shader
        u32             ShaderId;
        u32             Length;
        u32             nShaders = m_Shaders.GetSize();
        
        File << nShaders;
        for( ShaderId = 0; ShaderId < m_Shaders.GetSize(); ShaderId ++ )
        {
                Length = (u32)strlen( m_Shaders[ShaderId] );
                File << Length;
                File.Write( (u8*)m_Shaders[ShaderId], Length );
        }

        // Anim intervalle
        File << m_StartFrame << m_EndFrame;

        // Meshes
        u32             MeshId;
        u32             nMeshes = m_Meshes.GetSize();

        File << nMeshes;
        for( MeshId = 0; MeshId < m_Meshes.GetSize(); MeshId ++ )
                m_Meshes[MeshId]->Save( File );
        
        File.Close();

        return true;
}

//--------------------------------------------------------------------------------------------
bool KMdlLoader::SaveANM( char* pFileName )
{
        KFile   File;
        KStr    sText;

        if( !File.Create( pFileName ) )
                return false;

        // MAGIC
        sText = "// Magic\r\n";
        sText += HEADER_ANMMAGIC;
        sText += "\r\n";
        File.WriteText( sText );

        // VERSION
        sText = "// File version\r\n";
        sText += (s32)KMdlLoader::m_ANMVersion;
        sText += "\r\n\r\n";
        File.WriteText( sText );

        // ANIM
        for( u32 AnimId = 0; AnimId < m_Anims.GetSize(); AnimId ++ )
        {
                KMdlAnim*       pAnim = m_Anims[AnimId];

                sText = "ANIM_NAME ";
                sText += pAnim->GetName();
                sText += "\r\n";
                File.WriteText( sText );

                File.WriteText( KStr( "{\r\n" ) );

                sText = "       FRAME_COUNT     ";
                sText += (s32)(pAnim->GetMaxFrame() + 1);
                sText += "\r\n";
                File.WriteText( sText );

                sText = "       FPS             ";
                sText += (s32)pAnim->GetFPS();
                sText += "\r\n\r\n";
                File.WriteText( sText );

                // MESHANIM
                for( u32 MeshAnimId = 0; MeshAnimId < pAnim->GetnMeshAnims(); MeshAnimId ++ )
                {
                        KMdlMeshAnim*   pMeshAnim = pAnim->GetpMeshAnims( MeshAnimId );
                        sText = "       MESHANIM_NAME ";
                        sText += pMeshAnim->GetpMesh()->m_Name;
                        sText += "\r\n";
                        File.WriteText( sText );

                        File.WriteText( KStr( " {\r\n" ) );

                        sText = "               MESHANIM_INHERITFRAME   ";
                        sText += (s32)pMeshAnim->IsInheritFrame();
                        sText += "\r\n";
                        File.WriteText( sText );

                        sText = "               MESHANIM_FRAMESTART     ";
                        sText += (s32)pMeshAnim->GetFrameStart();
                        sText += "\r\n";
                        File.WriteText( sText );

                        sText = "               MESHANIM_FRAMEEND       ";
                        sText += (s32)pMeshAnim->GetFrameEnd();
                        sText += "\r\n";
                        File.WriteText( sText );

                        sText = "               MESHANIM_MESHFRAMESTART ";
                        sText += (s32)pMeshAnim->GetMeshFrameStart();
                        sText += "\r\n";
                        File.WriteText( sText );

                        sText = "               MESHANIM_MESHFRAMEEND   ";
                        sText += (s32)pMeshAnim->GetMeshFrameEnd();
                        sText += "\r\n";
                        File.WriteText( sText );

                        File.WriteText( KStr( " }\r\n\r\n" ) );
                }
                File.WriteText( KStr( "}\r\n\r\n" ) );
        }

        File.Close();

        return true;
}

//--------------------------------------------------------------------------------------------
u32 KMdlLoader::AddMesh( KMdlMesh* pMesh )
{
        m_Meshes.Add( pMesh );
        return m_Meshes.GetSize() - 1;
}

//--------------------------------------------------------------------------------------------
u32 KMdlLoader::AddAnim( KMdlAnim* pAnim )
{
        m_Anims.Add( pAnim );
        return m_Anims.GetSize() - 1;
}

//--------------------------------------------------------------------------------------------
u32 KMdlLoader::AddShader( char* pShaderName )
{
        m_Shaders.Add( strdup( pShaderName ) );
        return m_Shaders.GetSize() - 1;
}

//--------------------------------------------------------------------------------------------
u32 KMdlLoader::RemoveAnim( KMdlAnim* pAnim )
{
        for( u32 i = 0; i < m_Anims.GetSize(); i++ )
        {
                if( m_Anims[i] == pAnim )
                {
                        m_Anims.Erase( i );
                        break;
                }
        }
        return m_Anims.GetSize() - 1;
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::GenerateHierarchy()
{
        // Flush
        FlushHierarchy();

        // Generation de la hierarchie
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
        {
                if( m_Meshes[m]->m_FatherName.GetLength() )
                {
                        // Recherche le pere
                        for( u32 f = 0; f < m_Meshes.GetSize(); f ++ )
                        {
                                if( m_Meshes[f]->m_Name == m_Meshes[m]->m_FatherName )
                                {
                                        m_Meshes[f]->AddpChild( m_Meshes[m] );
                                        m_Meshes[m]->m_pFather = m_Meshes[f];
                                        break;
                                }
                        }
                }
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::FlushHierarchy()
{
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
        {
                m_Meshes[m]->m_pFather  = NULL;
                m_Meshes[m]->ClearChilds();
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::GenerateBones()
{
        // Associe les KMdlBones au KMdlMesh de bone correspondant
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
        {
                KMdlMesh*       pMesh = m_Meshes[m];

                for( u32 b = 0; b < pMesh->GetnBones(); b ++ )
                {
                        KMdlBone*       pBone = pMesh->GetpBone( b );

                        // Recherche le KMdlMesh qui correspond au bone
                        for(u32 bm = 0; bm < m_Meshes.GetSize(); bm ++ )
                        {
                                if( m_Meshes[bm]->m_Name == pBone->m_Name )
                                {
                                        pBone->m_pBone = m_Meshes[bm];
                                        break;
                                }
                        }
                }
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::ComputeFirstWorldMatrix()
{
        // Calcule la matrice monde de chaque mesh pour la 1ere frame
        KMdlMesh*               pMesh;
        KMatrix                 CurrentMatrix;

        CurrentMatrix.LoadIdentity();

        // Affiche les meshes
        for( u32 MeshId = 0; MeshId < m_Meshes.GetSize(); MeshId ++ )
        {
                pMesh = m_Meshes[MeshId];
                if( !pMesh->m_pFather )
                {
                        ComputeFirstMeshWorldMatrix( pMesh, CurrentMatrix );
                }
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::ComputeFirstMeshWorldMatrix( KMdlMesh* pMesh, KMatrix CurrentMatrix )
{
        KMdlFrameMatrix* pFrameMatrix = pMesh->GetFrameMatrix( 0 );

        KASSERT( pFrameMatrix );

        KMatrix WorldMatrix = pFrameMatrix->m_Matrix * CurrentMatrix;

        pMesh->m_FirstWorldMatrix = WorldMatrix;
    
        KMdlMesh*               pChild;
        for( pChild = pMesh->GetpFirstChild(); pChild; pChild = pMesh->GetpNextChild( pChild ) )
        {
                ComputeFirstMeshWorldMatrix( pChild, WorldMatrix );
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::ComputeWorldMatrix()
{
        // Calcule la matrice monde de chaque mesh pour la frame courante
        KMdlMesh*               pMesh;
        KMatrix                 CurrentMatrix;

        CurrentMatrix.LoadIdentity();

        // Affiche les meshes
        for( u32 MeshId = 0; MeshId < m_Meshes.GetSize(); MeshId ++ )
        {
                pMesh = m_Meshes[MeshId];
                if( !pMesh->m_pFather )
                {
                        ComputeMeshWorldMatrix( pMesh, CurrentMatrix );
                }
        }
}

//--------------------------------------------------------------------------------------------
void KMdlLoader::ComputeMeshWorldMatrix( KMdlMesh* pMesh, KMatrix CurrentMatrix )
{
        KMdlFrameMatrix* pFrameMatrix = pMesh->GetFrameMatrix( pMesh->m_CurrentFrame );

        KASSERT( pFrameMatrix );

        KMatrix WorldMatrix = pFrameMatrix->m_Matrix * CurrentMatrix;

        // World Matrix
        pMesh->m_CurrentWorldMatrix = WorldMatrix;

        // Blend Matrix
        KMatrix FirstPostureMat = pMesh->m_FirstWorldMatrix;
        FirstPostureMat.Inverse();
        pMesh->m_BlendMatrix = FirstPostureMat * pMesh->m_CurrentWorldMatrix;
    
        KMdlMesh*               pChild;
        for( pChild = pMesh->GetpFirstChild(); pChild; pChild = pMesh->GetpNextChild( pChild ) )
        {
                ComputeMeshWorldMatrix( pChild, WorldMatrix );
        }
}

//--------------------------------------------------------------------------------------------
KMdlMesh* KMdlLoader::GetpMeshByName( KStr MeshName )
{
        for( u32 m = 0; m < m_Meshes.GetSize(); m ++ )
        {
                if( m_Meshes[m]->m_Name == MeshName )
                        return m_Meshes[m];
        }
        return NULL;
}

---