D:/Zythum/DinoKod/mdlMaxExport/MDLMaxExporter.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : MDLMaxExporter.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 02/01/2003
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "resource.h"
#include "mdlMaxExporter.h"
#include "Common/Console.h"
#include "Common/Vertex.h"
#include "Model/MdlLoader.h"
#include "Model/MdlMesh.h"

#include <modstack.h>
#include <iskin.h>
//#include <simpmod.h>

//#define CLUSTOSM_CLASS_ID                     0x25215824

#define PLUGIN_NAME     "3Dino MODEL Exporter"

int                     g_ControlsInit = FALSE;
HINSTANCE       g_hInstance = NULL;
HWND            g_hWnd = NULL;

//---------------------------------------------------------------------------------------------
BOOL WINAPI DllMain( HINSTANCE hinstDLL, ULONG fdwReason, LPVOID lpvReserved ) 
{ 
        g_hInstance = hinstDLL;
        // Hang on to this DLL's instance handle.
        if( !g_ControlsInit )
        {
                g_ControlsInit = TRUE;

                // Initialize MAX's custom controls
                InitCustomControls( hinstDLL );

                // Initialize Win95 controls
                InitCommonControls();
        }

        return TRUE;
}

//---------------------------------------------------------------------------------------------
__declspec( dllexport ) int LibNumberClasses()
{
        return 1;
}

//---------------------------------------------------------------------------------------------
__declspec( dllexport ) ClassDesc* LibClassDesc( int i )
{
        switch( i )
        {
        case 0:
                return (ClassDesc*)&MdlExporterClassDesc;
        default:
                return 0;
        }
}

//---------------------------------------------------------------------------------------------
__declspec( dllexport ) const TCHAR* LibDescription()
{
        return _T( PLUGIN_NAME );
}

//---------------------------------------------------------------------------------------------
extern "C" __declspec( dllexport ) ULONG LibVersion()
{
        return VERSION_3DSMAX;
}

//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
KMdlExporter::KMdlExporter()
: SceneExport()
{
#if _DEBUG
        g_Console.Create( "MdlExporter", true, g_hInstance );
#endif _DEBUG
}

//---------------------------------------------------------------------------------------------
KMdlExporter::~KMdlExporter()
{
#if _DEBUG
        g_Console.Close();
#endif _DEBUG
}

//---------------------------------------------------------------------------------------------
void KMdlExporter::ShowAbout( HWND hWnd )
{
}

//---------------------------------------------------------------------------------------------
int KMdlExporter::DoExport( const TCHAR *pName, ExpInterface *pExtInterface, Interface *pInterface, BOOL bSuppressPrompts, DWORD Options )
{
//      s32             AnimStart;
//      s32             AnimEnd;
//      s32             AnimStep;
        KMdlLoader      Loader;

        g_hWnd = pInterface->GetMAXHWnd();

        g_Console << "===============================================================" << KENDL;
        g_Console << "Prompt options... " << (char*)pName << "..." << KENDL;

        if( !bSuppressPrompts )
        {
/*              if( !DialogBoxParam( g_hInstance, MAKEINTRESOURCE(IDD_DIALOG_EXPORT), pInterface->GetMAXHWnd(), ExportDlgProc, (LPARAM)this ) )
                {
                        g_Console << "Canceled." << KENDL;
                        return 1;
                }*/
        }

        g_Console << "Exporting " << (char*)pName << "..." << KENDL;

        // Exporte les materiaux
        if( !ExportMaterials( Loader, pInterface->GetSceneMtls() ) )
                return 1;

        Interval interval = pInterface->GetAnimRange();

        m_TickStart     = interval.Start();
        m_TickEnd       = interval.End();
        m_TickStep      = /*GetFrameRate() * */GetTicksPerFrame();

        // Frame Interval
        Loader.SetStartFrame( m_TickStart / GetTicksPerFrame() );
        Loader.SetEndFrame( m_TickEnd / GetTicksPerFrame() );
        g_Console << "Frames " << Loader.GetStartFrame() << " to " << Loader.GetEndFrame() << KENDL;
        
        // Exporte les nodes
//      ResetXFormAll( pInterface, pInterface->GetRootNode(), 0 );
        if( !ExportNode( Loader, NULL, pInterface->GetRootNode(), (Options & SCENE_EXPORT_SELECTED) ? TRUE : FALSE, 0 ) )
                return 1;

        // Sauve le fichier
        Loader.SaveMDL( (char*)pName );

        g_Console << "Done." << KENDL;

        char    pText[256];
        sprintf( pText, "File [%s] successfully exported!", pName );
        MessageBox( g_hWnd, pText, "MDL Export", MB_OK );

        return 1;
}

//---------------------------------------------------------------------------------------------
INT_PTR CALLBACK KMdlExporter::ExportDlgProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam )
{
        KMdlExporter* pExporter = (KMdlExporter*)(u64)GetWindowLongPtr( hWnd, GWLP_USERDATA ); 

        switch( Msg )
        {
        case WM_INITDIALOG:
                break;
        case WM_COMMAND:
                switch( LOWORD( wParam ) )
                {
                case IDOK:
                        EndDialog( hWnd, 1 );
                        break;
                case IDCANCEL:
                        EndDialog( hWnd, 0 );
                        break;
                }
                break;
                default:
                        return FALSE;
        }

        return TRUE;
}

//---------------------------------------------------------------------------------------------
bool KMdlExporter::ExportMaterials( KMdlLoader& Loader, MtlBaseLib* pMtlBaseLib )
{
        if( !pMtlBaseLib )
        {
                MessageBox( g_hWnd, "No material set.\nYou need one material!", "MDL Export Error", MB_OK | MB_ICONSTOP );
                return false;
        }
/*
        MtlBase*        pMtl;
        for( int i = 0; i < pMtlBaseLib->Count(); i ++ )
        {
                pMtl = (*pMtlBaseLib)[i];

                // Ajoute le materiel
                Loader.AddTexture( (char*)pMtl->GetName() );
                g_Console << "Shader " << i << " : " << (char*)pMtl->GetName() << KENDL;
        }*/
        if( pMtlBaseLib->Count() != 1 )
        {
                char    pText[256];
                sprintf( pText, "%i material(s) detected.\nYou need only 1 material!", pMtlBaseLib->Count() );
                MessageBox( g_hWnd, pText, "MDL Export Error", MB_OK | MB_ICONWARNING );
//              return false;
        }

        if( pMtlBaseLib->Count() == 0 )
        {
                // Cree un material par defaut
                Loader.AddShader( "Error" );
                g_Console << "No material detected, a default shader added." << KENDL;
                return true;
        }

        Mtl*    pMtl;
        
        pMtl = (Mtl*)(*pMtlBaseLib)[0];

        int NumMat = pMtl->NumSubMtls();

        if( NumMat < 1 )
        {
                char    pText[256];
                sprintf( pText, "0 sub-material detected.\nYou need a least one sub-material!" );
                MessageBox( g_hWnd, pText, "MDL Export Error", MB_OK | MB_ICONWARNING );

                // Cree un material par defaut
                Loader.AddShader( "Error" );
                g_Console << "No material detected, a default shader added." << KENDL;
                return true;
        }


        for( int mat = 0; mat < NumMat; mat ++ )
        {
                Mtl* pSubMat = pMtl->GetSubMtl( mat );

                if( pSubMat )
                {
                        // Ajoute le materiel
                        Loader.AddShader( (char*)pSubMat->GetName() );
                        g_Console << "Shader " << mat << " : " << (char*)pSubMat->GetName() << KENDL;
                }
        }


        return true;
}

//---------------------------------------------------------------------------------------------
bool KMdlExporter::ExportNode( KMdlLoader& Loader, KMdlMesh* pMesh, INode* pNode, bool bSelected, TimeValue Time )
{
        KMdlMesh*       pCurrentMesh = pMesh;

        g_Console << "Node Name : " << pNode->GetName() << KENDL;

        if( !bSelected || pNode->Selected() )
        {
                // Exporte la node
                ObjectState     ObjState = pNode->EvalWorldState( Time );
                if( ObjState.obj )
                {
                        switch( ObjState.obj->SuperClassID() )
                        {
                        case GEOMOBJECT_CLASS_ID:
                                {
                                        KMdlMesh*       pNodeMesh = ExportTriObject( Loader, pNode, Time );
                                        if( pNodeMesh )
                                        {
                                                // Ajoute le mesh au modele
                                                Loader.AddMesh( pNodeMesh );
                                                pCurrentMesh = pNodeMesh;
                                        }
                                        break;
                                }

                        case HELPER_CLASS_ID:
                                {
                                        KMdlMesh*       pNodeMesh = ExportHelpers( Loader, pNode, Time );
                                        if( pNodeMesh )
                                        {
                                                // Ajoute le mesh au modele
                                                Loader.AddMesh( pNodeMesh );
                                                pCurrentMesh = pNodeMesh;
                                        }
                                        break;
                                }

/*                      case CAMERA_CLASS_ID:
                                break;
                        case LIGHT_CLASS_ID:
                                break;
                        case SHAPE_CLASS_ID:
                                break;
                        case HELPER_CLASS_ID:
                                {
                                        ExportHelper( pNode, Time );                            
                                }
                                break;*/
                        default:
                                KError::Warning( NULL, "Unknown object type, skipping node [%s]", pNode->GetName() );
                                return true;
                        }
                }
        }

        // Exporte les fils
        for( int i = 0; i < pNode->NumberOfChildren(); i ++ )
        {
                if( !ExportNode( Loader, pCurrentMesh, pNode->GetChildNode( i ), bSelected, Time ) )
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------
KMdlMesh* KMdlExporter::ExportTriObject( KMdlLoader& Loader, INode* pNode, TimeValue Time )
{
        TriObject*      pTriObject;
        Object*         pObject;
        
        pObject = pNode->EvalWorldState( Time ).obj;

        //
        //      TriObject
        //
//      if( pObject->ClassID() != Class_ID( TRIOBJ_CLASS_ID, 0 ) )
//      {
//              KError::Warning( NULL, "Unknown geomobject type, skipping node [%s]", pNode->GetName() );
//              return NULL;
//      }
        
//      EDITTRIOBJ_CLASS_ID


        if( !pObject->CanConvertToType( Class_ID( TRIOBJ_CLASS_ID, 0 ) ) )
        {
                char    pText[256];
                sprintf( pText, "Error : Cannot convert node [%s] to TriObject", pNode->GetName() );
//              MessageBox( g_hWnd, pText, "MDL Export Error", MB_OK | MB_ICONSTOP );
                g_Console << pText << KENDL;
                return NULL;
        }

        pTriObject = (TriObject*)pObject->ConvertToType( Time, Class_ID( TRIOBJ_CLASS_ID, 0) );
        if( !pTriObject )
        {
                char    pText[256];
                sprintf( pText, "Error : Cannot convert node [%s] to TriObject", pNode->GetName() );
//              MessageBox( g_hWnd, pText, "MDL Export Error", MB_OK | MB_ICONSTOP );
                g_Console << pText << KENDL;
                return NULL;
        }

        // Creation du mesh
        KMdlMesh*               pMdlMesh        = new KMdlMesh();

        //
        //      Skin
        //
        ISkin*                          pSkin = NULL;
        ISkinContextData*       pSkinData = NULL;
        Object*                         pObjectRef = pNode->GetObjectRef();

        if( pObjectRef )
        {
                if( pObjectRef->SuperClassID() == GEN_DERIVOB_CLASS_ID )
                {
                        IDerivedObject*         pDerivedObject = (IDerivedObject*)pObjectRef;

                        // Recherche le modifier I_SKIN
                        for( int Mod = 0; Mod < pDerivedObject->NumModifiers(); Mod ++ )
                        {
                                Modifier*       pModifier = pDerivedObject->GetModifier( Mod );

                                pSkin = (ISkin*)pModifier->GetInterface(I_SKIN);
                                if( pSkin )
                                {
                                        pSkinData = pSkin->GetContextInterface( pNode );
                                        if( pSkinData )
                                        {
                                                // Skin trouvé
                                                g_Console << "Mesh Skinning :" << KENDL;

                                                int     NumBones = pSkin->GetNumBones();
                                                
                                                // Le vertex shader code l'indice du bone sur un u8, donc de 0 à 255
                                                if( NumBones > 254 )
                                                {
                                                        KError::Warning( NULL, "Too much bones for object [%s]\nBones : %i Maximum allowed : 254", pNode->GetName(), NumBones );
                                                }

                                                g_Console << "Bones : " << NumBones << KENDL;
                                                
                                                KMdlBone*       pMdlBone;
                                                for( int Bone = 0; Bone < NumBones; Bone ++ )
                                                {
                                                        INode*  pBone = pSkin->GetBone( Bone );
                                                        Matrix3 BoneMatrix = pBone->GetNodeTM( Time );
                                                        Point3  r;
/*                                              
                                                        g_Console << "Bone : " << pBone->GetName() << KENDL;
                                                        r = BoneMatrix.GetRow( 0 );
                                                        g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                                                        r = BoneMatrix.GetRow( 1 );
                                                        g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                                                        r = BoneMatrix.GetRow( 2 );
                                                        g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                                                        r = BoneMatrix.GetRow( 3 );
                                                        g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 1.0f << KENDL;
*/
                                                        // Ajoute le bone
                                                        pMdlBone = new KMdlBone();
                                                        pMdlBone->m_Name = pBone->GetName();
                                                        pMdlMesh->AddpBone( pMdlBone );
                                                }
                                                break;
                                        }
                                }
                        }
                }
                
        }

        Mesh*                   pMesh           = &pTriObject->GetMesh();
        int                             NumFaces        = pMesh->getNumFaces();
        int                             Face;

        // Génération des normals
        pMesh->buildNormals();

        // Verifie qu'il y est les coordonnées de textures
        bool    bHasUV = pMesh->tVerts ? true : false;

        if( !bHasUV )
        {
//              char    pText[256];
//              sprintf( pText, "Object [%s] need texture coordinate.", pNode->GetName() );
//              MessageBox( g_hWnd, pText, "MDL Export Error", MB_OK | MB_ICONSTOP );
//              return NULL;
                KError::Warning( NULL, "Object [%s] has not texture coordinate.", pNode->GetName() );
        }

        // Type
        if( pObject->ClassID() == BONE_OBJ_CLASSID )
        {
                pMdlMesh->m_Type = KMMT_BONE;
                g_Console << "Type : BONE" << KENDL;
        }
        else
        {
                pMdlMesh->m_Type = KMMT_MESH;
                g_Console << "Type : MESH" << KENDL;
        }

        // Nom
        pMdlMesh->m_Name                = KStr( pNode->GetName() );
        pMdlMesh->m_FatherName  = ( pNode->GetParentNode()->IsRootNode() ) ? KStr( "" ) : KStr( pNode->GetParentNode()->GetName() );

        // Matrice de transformation animée
        ExportMatrices( pMdlMesh, pNode );
/*      
        //
        // Matrice de transformation animée
        //
        KMatrix* pLastMatrix = NULL;

        g_Console << "Frame : ";
        for( TimeValue CurrentTime = m_TickStart; CurrentTime < m_TickEnd; CurrentTime += m_TickStep )
        {
                Matrix3 NodeMatrix              = pNode->GetNodeTM( CurrentTime );
                Matrix3 ParentMatrix    = pNode->GetParentTM( CurrentTime );
                Matrix3 LocalMatrix;

                LocalMatrix = NodeMatrix * Inverse( ParentMatrix );

                Point3  r;
                KMatrix Matrix;

                r = LocalMatrix.GetRow( 0 );
                Matrix._11 = r.x;       Matrix._12 = r.y;       Matrix._13 = r.z;       Matrix._14 = 0.0f;
                r = LocalMatrix.GetRow( 1 );
                Matrix._21 = r.x;       Matrix._22 = r.y;       Matrix._23 = r.z;       Matrix._24 = 0.0f;
                r = LocalMatrix.GetRow( 2 );
                Matrix._31 = r.x;       Matrix._32 = r.y;       Matrix._33 = r.z;       Matrix._34 = 0.0f;
                r = LocalMatrix.GetRow( 3 );
                Matrix._41 = r.x;       Matrix._42 = r.y;       Matrix._43 = r.z;       Matrix._44 = 1.0f;

                // Ajoute la matrice si elle est diferente de la clé précédente
                if( pLastMatrix && ((*pLastMatrix) == Matrix ) )
                        continue;

                KMdlFrameMatrix*        pFrameMatrix = new KMdlFrameMatrix();
                pFrameMatrix->m_FrameId = CurrentTime / GetTicksPerFrame();
                pFrameMatrix->m_Matrix  = Matrix;
                pMdlMesh->m_FrameMatrix.Add( pFrameMatrix );

                pLastMatrix = &pFrameMatrix->m_Matrix;

                g_Console << pFrameMatrix->m_FrameId << " ";
        }
        g_Console << KENDL;
*/
        //
        // Calcul et alloue le nombre de primitives
        //
        MtlID                   Mtl;
        bool                    bAlready;
        for( Face = 0; Face < NumFaces; Face ++ )
        {
                Mtl = pMesh->getFaceMtlIndex( Face );

                // Max utilise un modulo pour recupere le id de materiau
                Mtl %= Loader.GetnTextures();

                // Regarde s'il est deja dans la liste
                bAlready = false;
                for( int m = 0; m < (int)pMdlMesh->GetnPrimitives(); m ++ )
                {
                        // Oui, on l'a déja
                        if( pMdlMesh->GetpPrimitive( m )->m_ShaderId == Mtl )
                        {
                                // Ajoute 1 face de plus
                                pMdlMesh->GetpPrimitive( m )->m_nIndices += 3;
                                bAlready = true;
                                break;
                        }
                }
                // Non, on l'ajoute
                if( !bAlready )
                {
                        KMdlPrimitive*  pPrimitive = new KMdlPrimitive();
                        pPrimitive->m_ShaderId = Mtl;
                        pPrimitive->m_nIndices += 3;
                        pMdlMesh->AddpPrimitive( pPrimitive );
                }
        }

        // DUMP
        for( int m = 0; m < (int)pMdlMesh->GetnPrimitives(); m ++ )
        {
                g_Console << "Shader " << pMdlMesh->GetpPrimitive( m )->m_ShaderId << " : " << pMdlMesh->GetpPrimitive( m )->m_nIndices / 3 << " Faces." << KENDL;
        }


        //
        //      Index/Vertex
        //
        // Aloue les index et vertex
        for( int p = 0; p < (int)pMdlMesh->GetnPrimitives(); p ++ )
        {
                // Alloue le maximum possible, de toute facon on s'en fou, au reload l'allocation se fera au plus juste
                pMdlMesh->GetpPrimitive( p )->m_nIndices = 0;
                pMdlMesh->GetpPrimitive( p )->m_pIndices = new u16[NumFaces*3];
                
                KMdlFrameVertex*        pFrameVertex = new KMdlFrameVertex();
                pFrameVertex->m_FrameId         = 0;
                pFrameVertex->m_nVertices       = 0;
                pFrameVertex->m_pVertices       = new KMdlVertex[NumFaces*3];
                pMdlMesh->GetpPrimitive( p )->m_FrameVertices.Add( pFrameVertex );
                pMdlMesh->GetpPrimitive( p )->m_nFrames ++;
        }



        int                     v2;
        KMdlVertex      Vertex;
        int                     VtxID[3] = { 0, 2, 1 };
        int                     Index[3];

        for( Face = 0; Face < NumFaces; Face ++ )
        {
                // Recherche la primitive qui correspond a ce material
                Mtl = pMesh->getFaceMtlIndex( Face );

                // Max utilise un modulo pour recupere le id du material
                Mtl %= Loader.GetnTextures();

                for( int m = 0; m < (int)pMdlMesh->GetnPrimitives(); m ++ )
                {
                        KMdlPrimitive*          pPrimitive              = pMdlMesh->GetpPrimitive( m );
                        KMdlFrameVertex*        pFrameVertex    = pPrimitive->m_FrameVertices[0];

                        if( pPrimitive->m_ShaderId == Mtl )
                        {
                                // Ajoute les vertex
                                for( int j = 0; j < 3; j ++ )
                                {
                                        int     i = VtxID[j];

                                        // Vertex id
                                        v2 = pMesh->faces[Face].v[i];

                                        // Position
                                        Vertex.m_Position.x     = pMesh->verts[v2].x;
                                        Vertex.m_Position.y     = pMesh->verts[v2].y;
                                        Vertex.m_Position.z     = pMesh->verts[v2].z;
                                        
                                        // Normal
                                        Point3  Normal = GetVertexNormal( pMesh, Face, pMesh->getRVertPtr( v2 ) );
                                        Vertex.m_Normal.x       = Normal.x;
                                        Vertex.m_Normal.y       = Normal.y;
                                        Vertex.m_Normal.z       = Normal.z;

                                        // Blending Weights/Indices
                                        for( int BoneId = 0; BoneId < KBVERTEX_NUNBLENDWEIGHT; BoneId++ )
                                        {
                                                Vertex.m_Weight[BoneId]         = 255;
                                                Vertex.m_Indices[BoneId]        = 0; // 20 = pas de bone
                                        }

                                        if( pSkinData )
                                        {
                                                int NumBones = pSkinData->GetNumAssignedBones( v2 );
                                                if( NumBones > KBVERTEX_NUNBLENDWEIGHT )
                                                {
                                                        KError::Error( NULL, "Too mush assigned bones for this vertex\nVertex %i of object : %s\nNumber assigned for this vertex: %i\nNumber maximum allowed by vertex %i", v2, pNode->GetName(), NumBones, KBVERTEX_NUNBLENDWEIGHT );
                                                        return NULL;
                                                }
                                                
                                                for( int BoneId = 0; BoneId < NumBones; BoneId++ )
                                                {
                                                        Vertex.m_Weight[BoneId]         = (u8)(pSkinData->GetBoneWeight( v2, BoneId ) * 255.0f);
                                                        Vertex.m_Indices[BoneId]        = (u8)pSkinData->GetAssignedBone( v2, BoneId ) + 1;
                                                }
                                        }


                                        // Texture coordonnées
                                        if( bHasUV )
                                        {
                                                Vertex.m_TU     = pMesh->tVerts[pMesh->tvFace[Face].t[i]].x;
                                                Vertex.m_TV     = -pMesh->tVerts[pMesh->tvFace[Face].t[i]].y;
                                        }
                                        else
                                        {
                                                Vertex.m_TU     = 0.0;
                                                Vertex.m_TV     = 0.0;
                                        }

                                        // Recherche si le vertex n'est pas deja dans la liste
                                        int     vidx = -1;
                                        for( int vv = 0; vv < pFrameVertex->m_nVertices; vv ++ )
                                        {
                                                if( pFrameVertex->m_pVertices[vv] == Vertex )
                                                {
                                                        // Le vertex existe deja dans la liste, on recupere l'index
                                                        vidx = vv;
                                                        break;
                                                }
                                        }

                                        if( vidx == -1 )
                                        {
                                                // Nouveau vertex, ajoute le vertex
                                                pFrameVertex->m_pVertices[pFrameVertex->m_nVertices] = Vertex;
                                                // Recupere l'index
                                                Index[j] = pFrameVertex->m_nVertices;
                                                // et oui, y'a 2 compteurs... :(
                                                pFrameVertex->m_nVertices ++;
                                                pPrimitive->m_nVertices ++;
                                        }
                                        else
                                        {
                                                // Un vertex similaire existe deja
                                                Index[j] = vidx;
                                        }
                                }

                                // Ajoute les index
                                // vertex 0
                                pPrimitive->m_pIndices[pPrimitive->m_nIndices + 0] = Index[0];//pPrimitive->m_nIndices + 0;
                                // vertex 1
                                pPrimitive->m_pIndices[pPrimitive->m_nIndices + 1] = Index[1];//pPrimitive->m_nIndices + 1;
                                // vertex 2
                                pPrimitive->m_pIndices[pPrimitive->m_nIndices + 2] = Index[2];//pPrimitive->m_nIndices + 2;
                                pPrimitive->m_nIndices += 3;
                        }
                }
        }       

        return pMdlMesh;
}

//---------------------------------------------------------------------------------------------
KMdlMesh* KMdlExporter::ExportHelpers( KMdlLoader& Loader, INode* pNode, TimeValue Time )
{
        KMdlMesh*       pMdlMesh = new KMdlMesh();

        // Nom
        pMdlMesh->m_Name                = KStr( pNode->GetName() );
        pMdlMesh->m_FatherName  = ( pNode->GetParentNode()->IsRootNode() ) ? KStr( "" ) : KStr( pNode->GetParentNode()->GetName() );

        // Type
        pMdlMesh->m_Type                = KMMT_DUMMY;

        // Matrice de transformation animée
        ExportMatrices( pMdlMesh, pNode );

        return pMdlMesh;
}

//---------------------------------------------------------------------------------------------
Point3 KMdlExporter::GetVertexNormal(Mesh* mesh, int faceNo, RVertex* rv)
{
        Face* f = &mesh->faces[faceNo];
        DWORD smGroup = f->smGroup;
        int numNormals;
        Point3 vertexNormal;
        
        // Is normal specified
        // SPCIFIED is not currently used, but may be used in future versions.
        if (rv->rFlags & SPECIFIED_NORMAL) {
                vertexNormal = rv->rn.getNormal();
        }
        // If normal is not specified it's only available if the face belongs
        // to a smoothing group
        else if ((numNormals = rv->rFlags & NORCT_MASK) && smGroup) {
                // If there is only one vertex is found in the rn member.
                if (numNormals == 1) {
                        vertexNormal = rv->rn.getNormal();
                }
                else {
                        // If two or more vertices are there you need to step through them
                        // and find the vertex with the same smoothing group as the current face.
                        // You will find multiple normals in the ern member.
                        for (int i = 0; i < numNormals; i++) {
                                if (rv->ern[i].getSmGroup() & smGroup) {
                                        vertexNormal = rv->ern[i].getNormal();
                                }
                        }
                }
        }
        else {
                // Get the normal from the Face if no smoothing groups are there
                vertexNormal = mesh->getFaceNormal(faceNo);
        }
        
        return vertexNormal;
}

//---------------------------------------------------------------------------------------------
KMdlMesh* KMdlExporter::ExportBoneObject( KMdlLoader& Loader, INode* pNode, TimeValue Time )
{
//      TriObject*      pTriObject;
//      Object*         pObject;
        
//      pObject = pNode->EvalWorldState( Time ).obj;

        //
        //      Bone
        //
/*      if( pObject->ClassID() == BONE_OBJ_CLASSID )
        {*/
                g_Console << "BONE_OBJ_CLASSID" << KENDL;
                Matrix3 m = pNode->GetNodeTM( Time );
                Point3  r;
        
                r = m.GetRow( 0 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = m.GetRow( 1 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = m.GetRow( 2 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = m.GetRow( 3 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 1.0f << KENDL;
/*              
                return NULL;
        }*/

        return NULL;
}

//---------------------------------------------------------------------------------------------
void KMdlExporter::ExportMatrices( KMdlMesh* pMdlMesh, INode* pNode )
{
        //
        // Matrice de transformation animée
        //
        KMatrix* pLastMatrix = NULL;

        g_Console << "Frame : ";
        for( TimeValue CurrentTime = m_TickStart; CurrentTime < m_TickEnd; CurrentTime += m_TickStep )
        {
//              Matrix3 ResetMatrix             = ResetXForm( pNode, CurrentTime );
                Matrix3 NodeMatrix              = pNode->GetObjectTM( CurrentTime );//pNode->GetNodeTM( CurrentTime );
//              Matrix3 ParentMatrix    = pNode->GetParentTM( CurrentTime );
                Matrix3 ParentMatrix;
                ParentMatrix.IdentityMatrix();
                if( pNode->GetParentNode() )
                        ParentMatrix = pNode->GetParentNode()->GetObjectTM( CurrentTime );
                Matrix3 LocalMatrix;

                LocalMatrix = NodeMatrix * Inverse( ParentMatrix );
//              LocalMatrix = ResetXForm( pNode, CurrentTime );
//              LocalMatrix.IdentityMatrix();

                Point3  r;
                KMatrix Matrix;

                r = LocalMatrix.GetRow( 0 );
                Matrix._11 = r.x;       Matrix._12 = r.y;       Matrix._13 = r.z;       Matrix._14 = 0.0f;
                r = LocalMatrix.GetRow( 1 );
                Matrix._21 = r.x;       Matrix._22 = r.y;       Matrix._23 = r.z;       Matrix._24 = 0.0f;
                r = LocalMatrix.GetRow( 2 );
                Matrix._31 = r.x;       Matrix._32 = r.y;       Matrix._33 = r.z;       Matrix._34 = 0.0f;
                r = LocalMatrix.GetRow( 3 );
                Matrix._41 = r.x;       Matrix._42 = r.y;       Matrix._43 = r.z;       Matrix._44 = 1.0f;

                // Ajoute la matrice si elle est diferente de la clé précédente
                if( pLastMatrix && ((*pLastMatrix) == Matrix ) )
                        continue;
/*
                g_Console << "Matrix : " << pNode->GetName() << KENDL;
                r = LocalMatrix.GetRow( 0 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = LocalMatrix.GetRow( 1 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = LocalMatrix.GetRow( 2 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 0.0f << KENDL;
                r = LocalMatrix.GetRow( 3 );
                g_Console << r.x << "   " << r.y << "   " << r.z << "   " << 1.0f << KENDL;
*/
                KMdlFrameMatrix*        pFrameMatrix = new KMdlFrameMatrix();
                pFrameMatrix->m_FrameId = CurrentTime / GetTicksPerFrame();
                pFrameMatrix->m_Matrix  = Matrix;
                pMdlMesh->AddpFrameMatrix( pFrameMatrix );

                pLastMatrix = &pFrameMatrix->m_Matrix;

                g_Console << pFrameMatrix->m_FrameId << " ";
        }
        g_Console << KENDL;
}
/*
//---------------------------------------------------------------------------------------------
void KMdlExporter::ResetXFormAll( Interface* pInterface, INode* pNode, TimeValue Time )
{
        ResetXForm( pInterface, pNode, Time );

        // Exporte les fils
        for( int i = 0; i < pNode->NumberOfChildren(); i ++ )
                ResetXFormAll( pInterface, pNode->GetChildNode( i ), Time );
}

//---------------------------------------------------------------------------------------------
Matrix3 KMdlExporter::ResetXForm( Interface* pInterface, INode* pNode, TimeValue Time )
{
        Matrix3 ntm, ptm, rtm(1), piv(1), tm;

        // Get Parent and Node TMs
        ntm = pNode->GetNodeTM( Time );
        ptm = pNode->GetParentTM( Time );

        // Compute the relative TM
        ntm = ntm * Inverse( ptm );

        // The reset TM only inherits position
        rtm.SetTrans( ntm.GetTrans() );

        // Set the node TM to the reset TM  
        tm = rtm*ptm;
        pNode->SetNodeTM( Time, tm );

        // Compute the pivot TM
        piv.SetTrans( pNode->GetObjOffsetPos() );
        PreRotateMatrix( piv, pNode->GetObjOffsetRot() );
        ApplyScaling( piv, pNode->GetObjOffsetScale() );

        // Reset the offset to 0
        pNode->SetObjOffsetPos( Point3(0,0,0) );
        pNode->SetObjOffsetRot( IdentQuat() );
        pNode->SetObjOffsetScale( ScaleValue( Point3( 1,1,1 ) ) );

        // Take the position out of the matrix since 
        // we don't reset position
        ntm.NoTrans();

        // Apply the offset to the TM
        ntm = piv * ntm;

        // Apply a derived object to the node's object
        Object *obj = pNode->GetObjectRef();
        IDerivedObject *dobj = CreateDerivedObject(obj);

        // Create an XForm mod
        SimpleMod *mod = (SimpleMod*)pInterface->CreateInstance(
        OSM_CLASS_ID,
        Class_ID(CLUSTOSM_CLASS_ID,0));

        // Apply the transformation to the mod.
        SetXFormPacket pckt(ntm);
        mod->tmControl->SetValue( Time,&pckt);

        // Add the modifier to the derived object.
        ModContext* mc = new ModContext(new Matrix3(1), NULL, NULL); 
        dobj->AddModifier(mod, mc);

        // Replace the node's object
        pNode->SetObjectRef(dobj);

        return ntm;
}*/

---