---

/home/rdbrown/doxygen/cse125g1/IGameExporter/IGameExporter.cpp

/**********************************************************************
 *<
        FILE: IGameExporter.cpp

        DESCRIPTION:    Sample to test the IGame Interfaces.  It follows a similar format
                                        to the Ascii Exporter.  However is does diverge a little in order
                                        to handle properties etc..

        TODO: Break the file down into smaller chunks for easier loading.

        CREATED BY:             Neil Hazzard    

        HISTORY:                parttime coding Summer 2002

 *>     Copyright (c) 2002, All Rights Reserved.
 **********************************************************************/

#include "msxml2.h"
#include "IGameExporter.h"
#include "XMLUtility.h"
#include "decomp.h"

#include "IGame.h"
#include "IGameObject.h"
#include "IGameProperty.h"
#include "IGameControl.h"
#include "IGameModifier.h"
#include "IConversionManager.h"
#include "IGameError.h"

#include <vector>
using namespace std;


#define IGAMEEXPORTER_CLASS_ID  Class_ID(0x79d613a4, 0x4f21c3ad)

#define BEZIER  0
#define TCB             1
#define LINEAR  2
#define SAMPLE  3


class IGameExporter : public SceneExport {
        public:

                FILE *outfile;
                IGameScene * pIgame;

                IXMLDOMDocument * pXMLDoc;
                IXMLDOMNode * pRoot;            //this is our root node         
                CComPtr<IXMLDOMNode> iGameNode; //the IGame child - which is the main node
                CComPtr<IXMLDOMNode> rootNode;
                static HWND hParams;

                int curNode;

                int staticFrame;
                int framePerSample;
                BOOL exportGeom;
                BOOL exportNormals;
                BOOL exportVertexColor;
                BOOL exportControllers;
                BOOL exportFaceSmgp;
                BOOL exportTexCoords;
                BOOL exportMappingChannel;
                BOOL exportConstraints;
                BOOL exportMaterials;
                BOOL exportSplines;
                BOOL exportModifiers;
                BOOL exportSkin;
                BOOL exportGenMod;
                BOOL forceSample;
                BOOL splitFile;
                BOOL exportQuaternions;
                BOOL exportObjectSpace;
                BOOL exportRelative;
                BOOL exportNormalsPerFace;
                int cS;
                int exportCoord;
                bool showPrompts;
                bool exportSelected;

                TSTR splitPath;

                float version;



                int                             ExtCount();                                     // Number of extensions supported
                const TCHAR *   Ext(int n);                                     // Extension #n (i.e. "3DS")
                const TCHAR *   LongDesc();                                     // Long ASCII description (i.e. "Autodesk 3D Studio File")
                const TCHAR *   ShortDesc();                            // Short ASCII description (i.e. "3D Studio")
                const TCHAR *   AuthorName();                           // ASCII Author name
                const TCHAR *   CopyrightMessage();                     // ASCII Copyright message
                const TCHAR *   OtherMessage1();                        // Other message #1
                const TCHAR *   OtherMessage2();                        // Other message #2
                unsigned int    Version();                                      // Version number * 100 (i.e. v3.01 = 301)
                void                    ShowAbout(HWND hWnd);           // Show DLL's "About..." box

                //BOOL SupportsOptions(int ext, DWORD options);
                int     DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts=FALSE, DWORD options=0);

                
                void ExportSceneInfo();
                void ExportNodeInfo(IGameNode * node);
                void ExportChildNodeInfo(IGameNode * child);
                void ExportMaterials();
                void ExportPositionControllers(CComPtr<IXMLDOMNode> node, IGameControl * cont);
                void ExportRotationControllers(CComPtr<IXMLDOMNode> node, IGameControl * cont);
                void ExportScaleControllers(CComPtr<IXMLDOMNode> node, IGameControl * cont);
                void ExportControllers(CComPtr<IXMLDOMNode> node, IGameControl * cont);

                void DumpMaterial(CComPtr<IXMLDOMNode> node,IGameMaterial * mat, int index, int matID = -1);
                void DumpTexture(CComPtr<IXMLDOMNode> node,IGameMaterial * mat);
                void DumpBezierKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData);
                void DumpTCBKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData);
                void DumpLinearKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData);
                void DumpConstraints(CComPtr<IXMLDOMNode> prsData, IGameConstraint * c);
                void DumpModifiers(CComPtr<IXMLDOMNode> prsData, IGameModifier * m);
                void DumpSkin(CComPtr<IXMLDOMNode> modNode, IGameSkin * s);
                void DumpIKChain(IGameIKChain * ikch, CComPtr<IXMLDOMNode> ikData);

                void DumpEulerController(IGameControl * sc,CComPtr<IXMLDOMNode> prsNode);
                void DumpProperties(CComPtr<IXMLDOMNode> node, IGameProperty * prop);
                void DumpMesh(IGameMesh *gm,CComPtr<IXMLDOMNode> geomData);
                void DumpSpline(IGameSpline *sp,CComPtr<IXMLDOMNode> splineData);
                void DumpLight(IGameLight *lt, CComPtr<IXMLDOMNode> parent);
                void DumpCamera(IGameCamera *ca, CComPtr<IXMLDOMNode> parent);
                void DumpGenericFace(IGameMesh * gm,FaceEx *fe, CComPtr<IXMLDOMNode> faceData, bool smgrp, bool n, bool vc, bool tv);
                void DumpSampleKeys(IGameControl * sc,CComPtr<IXMLDOMNode> prsNode, DWORD Type, bool quick = false);
                void DumpListController(IGameControl * sc,CComPtr<IXMLDOMNode> listNode);
                void DumpMatrix(Matrix3 tm,CComPtr<IXMLDOMNode> parent);


                void MakeSplitFilename(IGameNode * node, TSTR & buf);
                BOOL ReadConfig();
                void WriteConfig();
                TSTR GetCfgFilename();
                IGameExporter();
                ~IGameExporter();

                //good stuff
                IGameMesh *mesh;
                IGameNode *skel;
                IGameSkin *skin;
                vector<IGameKeyTab> boneKeys;
                void ExportMesh();
                void ExportSkeleton(IGameNode *bone);
                void ExportAnimation();
                int RecursiveChildCount(IGameNode *node, int count);
                int *boneIndices;
                int numBones, currBone;
};


class IGameExporterClassDesc:public ClassDesc2 {
        public:
        int                     IsPublic() { return TRUE; }
        void *                  Create(BOOL loading = FALSE) { return new IGameExporter(); }
        const TCHAR *   ClassName() { return GetString(IDS_CLASS_NAME); }
        SClass_ID               SuperClassID() { return SCENE_EXPORT_CLASS_ID; }
        Class_ID                ClassID() { return IGAMEEXPORTER_CLASS_ID; }
        const TCHAR*    Category() { return GetString(IDS_CATEGORY); }

        const TCHAR*    InternalName() { return _T("IGameExporter"); }  // returns fixed parsable name (scripter-visible name)
        HINSTANCE               HInstance() { return hInstance; }                               // returns owning module handle

};



static IGameExporterClassDesc IGameExporterDesc;
ClassDesc2* GetIGameExporterDesc() { return &IGameExporterDesc; }

int numVertex;

void stripWhiteSpace(TSTR * buf, TCHAR &newBuf)
{

        TCHAR newb[256]={""};
        strcpy(newb,buf->data());

        int len = strlen(newb);

        int index = 0;

        for(int i=0;i<len;i++)
        {
                if((newb[i] != ' ') && (!ispunct(newb[i])))
                        (&newBuf)[index++] = newb[i];
        }
}
int IGameExporter::RecursiveChildCount(IGameNode *node, int count)
{
        int newBones = 1;
        for(int i = 0; i < node->GetChildCount(); i++)
                newBones += RecursiveChildCount(node->GetNodeChild(i), count);

        return count+newBones;
}
void IGameExporter::ExportSkeleton(IGameNode *bone)
{
        IGameObject * obj = bone->GetIGameObject();
        boneIndices[currBone] = bone->GetNodeID();
        currBone++;
        IGameKey xKey,yKey,zKey;
        GMatrix tm = bone->GetLocalTM();
        IGameControl *control = bone->GetIGameControl();
        fprintf(outfile,"bone %s\n",bone->GetName());
        fprintf(outfile,"offset %f %f %f\n",tm.GetRow(3).x,tm.GetRow(3).y,tm.GetRow(3).z);
        if(control)
        {       
                IGameKeyTab keys;
                float ex,ey,ez;
                control->GetFullSampledKeys(keys,1,IGAME_ROT,false);
                keys[0].sampleKey.qval.GetEuler(&ex,&ey,&ez);
                fprintf(outfile,"pose %f %f %f\n",ex,ey,ez);
                boneKeys.push_back(keys);
        }
        if(skin)
        {       
                skin->GetInitBoneTM(bone,tm);
                for(int i = 0; i < 4; i++)
                        fprintf(outfile,"%f %f %f\n",tm.GetRow(i).x,tm.GetRow(i).y,tm.GetRow(i).z);
        }
        for(int i = 0; i < bone->GetChildCount(); i++)
                ExportSkeleton(bone->GetNodeChild(i));
        fprintf(outfile,"endbone\n");
}
void IGameExporter::ExportMesh()
{
        mesh->SetCreateOptimizedNormalList();
        if(!mesh->InitializeData())
                return;
        int numVerts = mesh->GetNumberOfNormals();
        int numFaces = mesh->GetNumberOfFaces();
        fprintf(outfile,"mesh\n");
        fprintf(outfile,"scale 0.0133\n");
        fprintf(outfile,"verts\n");
        fprintf(outfile,"%d\n", numVerts);

        Point3 currVert;
        for(int i = 0; i < numVerts; i++)
        {
                int currVertIndex = 0;
                for(int j = 0; j < numFaces; j++)
                {
                        FaceEx *face = mesh->GetFace(j);
                        if(face->norm[0] == i) { currVertIndex = face->vert[0]; break; }
                        if(face->norm[1] == i) { currVertIndex = face->vert[1]; break; }
                        if(face->norm[2] == i) { currVertIndex = face->vert[2]; break; }
                }
                //figure out which tex coord goes with this normal
                int currTexIndex = 0;
                for(int j = 0; j < numFaces; j++)
                {
                        FaceEx *face = mesh->GetFace(j);
                        if(face->norm[0] == i) { currTexIndex = face->texCoord[0]; break; }
                        if(face->norm[1] == i) { currTexIndex = face->texCoord[1]; break; }
                        if(face->norm[2] == i) { currTexIndex = face->texCoord[2]; break; }
                }
                //output the vert
                mesh->GetVertex(currVertIndex,currVert,true);
                fprintf(outfile,"%f %f %f ",currVert.x, currVert.y, currVert.z);
                if(skin)
                {
                        int numWeights = skin->GetNumberOfBones(currVertIndex);
                        fprintf(outfile,"%d ",numWeights);
                        //output the bones and weights
                        for(int j = 0; j < numWeights; j++)
                        {
                                int boneIndex = skin->GetBoneID(currVertIndex,j);
                                //find bone index
                                for(int k = 0; k < numBones; k++)
                                        if(boneIndices[k] == boneIndex)
                                        {
                                                boneIndex = k;
                                                break;
                                        }
                                fprintf(outfile,"%d %f ",boneIndex,skin->GetWeight(currVertIndex,j));
                        }
                        fprintf(outfile,"\n");
                }
                else fprintf(outfile,"0\n");
                //output tex coords
                Point2 texCoords;
                mesh->GetTexVertex(currTexIndex,texCoords);
                fprintf(outfile,"%f %f\n",texCoords.x,texCoords.y);
                //output normal
                Point3 currNorm;
                mesh->GetNormal(i,currNorm);
                fprintf(outfile,"%f %f %f\n",currNorm.x, currNorm.y, currNorm.z);
        }

        //fprintf(outfile,"texture\n");
        //fprintf(outfile,"%s\n",mesh->GetMaterialFromFace(0)->GetIGameTextureMap(0)->GetBitmapFileName());

        fprintf(outfile,"faces\n");
        fprintf(outfile,"%d\n", numFaces);
        FaceEx *currFace;
        for(int i = 0; i < numFaces; i++)
        {
                currFace = mesh->GetFace(i);
                fprintf(outfile,"%d %d %d %d %d %d\n",currFace->vert[0],currFace->vert[1],currFace->vert[2],
                                                                                        currFace->norm[0],currFace->norm[1],currFace->norm[2]);
        }
}

void IGameExporter::ExportAnimation()
{
        float ex,ey,ez;
        int numKeys = boneKeys[0].Count();
        fprintf(outfile,"keyframes %d\n", numKeys);
        IGameControl *control = skel->GetIGameControl();
        IGameKeyTab rootTranslation;
        if(control)
        {       
                fprintf(outfile,"roottranslation\n");
                float ex,ey,ez;
                control->GetFullSampledKeys(rootTranslation,1,IGAME_POS,false);
        }
        fprintf(outfile,"numbones %d\n", numBones);
        for(int j = 0; j < numKeys; j++)
        {
                fprintf(outfile,"time %f\n",0.05f*(float)j);
                if(control)
                {
                        Point3 pval = rootTranslation[j].sampleKey.pval;
                        fprintf(outfile,"%f %f %f\n",pval.x,pval.y,pval.z);
                }
                for(int i = 0; i < boneKeys.size(); i++)
                {
                        boneKeys[i][j].sampleKey.qval.GetEuler(&ex,&ey,&ez);
                        fprintf(outfile,"%f %f %f\n",ex,ey,ez);
                }
        }

}
//--- IGameExporter -------------------------------------------------------
IGameExporter::IGameExporter()
{

        staticFrame = 0;
        framePerSample = 4;
        exportGeom = TRUE;
        exportNormals = TRUE;
        exportVertexColor = FALSE;
        exportControllers = FALSE;
        exportFaceSmgp = FALSE;
        exportTexCoords = TRUE;
        exportMappingChannel = FALSE;
        exportMaterials = TRUE;
        exportConstraints = FALSE;
        exportSplines = FALSE;
        exportModifiers = FALSE;
        forceSample = FALSE;
        exportSkin = TRUE;
        exportGenMod = FALSE;
        cS = 0; //max default
        pRoot = NULL;
        pXMLDoc = NULL;
        splitFile = TRUE;
        exportQuaternions = TRUE;
        exportObjectSpace = FALSE;
        exportRelative = FALSE;
        exportNormalsPerFace = FALSE;

}

IGameExporter::~IGameExporter() 
{
        iGameNode = NULL;
        if(pRoot)
                pRoot->Release(); 
        pRoot = NULL;
        if(pXMLDoc)
                pXMLDoc->Release();
        
        pXMLDoc = NULL;
}

int IGameExporter::ExtCount()
{
        //TODO: Returns the number of file name extensions supported by the plug-in.
        return 1;
}

const TCHAR *IGameExporter::Ext(int n)
{               
        //TODO: Return the 'i-th' file name extension (i.e. "3DS").
        return _T("mma");
}

const TCHAR *IGameExporter::LongDesc()
{
        //TODO: Return long ASCII description (i.e. "Targa 2.0 Image File")
        return _T("Merry Men Animation");
}
        
const TCHAR *IGameExporter::ShortDesc() 
{                       
        //TODO: Return short ASCII description (i.e. "Targa")
        return _T("Merry Men Animation");
}

const TCHAR *IGameExporter::AuthorName()
{                       
        //TODO: Return ASCII Author name
        return _T("Ryan Brown");
}

const TCHAR *IGameExporter::CopyrightMessage() 
{       
        // Return ASCII Copyright message
        return _T("You can't use this, jackface.");
}

const TCHAR *IGameExporter::OtherMessage1() 
{               
        //TODO: Return Other message #1 if any
        return _T("Moron.");
}

const TCHAR *IGameExporter::OtherMessage2() 
{               
        //TODO: Return other message #2 in any
        return _T("Don't read this.");
}

unsigned int IGameExporter::Version()
{                               
        //TODO: Return Version number * 100 (i.e. v3.01 = 301)
        return 1;
}

void IGameExporter::ShowAbout(HWND hWnd)
{                       
        // Optional
}

void IGameExporter::MakeSplitFilename(IGameNode * node, TSTR & buf)
{
        buf = splitPath;
        buf = buf + "\\" + node->GetName() + ".xml";
        
}

void IGameExporter::ExportSceneInfo()
{
        TSTR buf;
        CComPtr <IXMLDOMNode> sceneNode;
        CComPtr <IXMLDOMNode> tempNode;

        struct tm *newtime;
        time_t aclock;

        time( &aclock );
        newtime = localtime(&aclock);

        TSTR today = _tasctime(newtime);        // The date string has a \n appended.
        today.remove(today.length()-1);         // Remove the \n

        CreateXMLNode(pXMLDoc, pRoot, _T("IGame"), &iGameNode);
        AddXMLAttribute(iGameNode, _T("Version"), _T("1.0"));
        AddXMLAttribute(iGameNode, _T("Date"), today.data());
        
        CreateXMLNode(pXMLDoc,iGameNode,_T("SceneInfo"),&sceneNode);

        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        AddXMLAttribute(tempNode,_T("FileName"),const_cast<TCHAR*>(pIgame->GetSceneFileName()));
        tempNode = NULL;

        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        buf.printf("%d",pIgame->GetSceneStartTime() / pIgame->GetSceneTicks());
        AddXMLAttribute(tempNode,_T("StartFrame"),buf.data());
        tempNode = NULL;
        
        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        buf.printf("%d",pIgame->GetSceneEndTime()/pIgame->GetSceneTicks());
        AddXMLAttribute(tempNode,_T("EndFrame"),buf.data());
        tempNode = NULL;
        
        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        buf.printf("%d",GetFrameRate());
        AddXMLAttribute(tempNode,_T("FrameRate"),buf.data());
        tempNode = NULL;
        
        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        buf.printf("%d",pIgame->GetSceneTicks());
        AddXMLAttribute(tempNode,_T("TicksPerFrame"),buf.data());
        tempNode = NULL;

        CreateXMLNode(pXMLDoc,sceneNode,_T("Info"),&tempNode);
        if(cS == 0)
                buf = TSTR("3dsmax");
        if(cS == 1)
                buf = TSTR("directx");
        if(cS == 2)
                buf = TSTR("opengl");

        AddXMLAttribute(tempNode,_T("CoordinateSystem"),buf.data());

        sceneNode = NULL;
        tempNode = NULL;


}

void IGameExporter::ExportChildNodeInfo(IGameNode * child)
{
        if(child->IsGroupOwner())
        {

        }
        else
        {
                IGameObject * obj = child->GetIGameObject();
                //fprintf(outfile,"node %s\n",child->GetName());
                switch(obj->GetIGameType())
                {
                        
                        case IGameObject::IGAME_BONE:
                        {
                                skel = child;
                                break;
                        }


                        case IGameObject::IGAME_MESH:
                        {
                                if(child->GetChildCount() == 0)
                                {
                                        mesh = (IGameMesh*)obj;
                                        skin = mesh->GetIGameSkin();
                                }
                                else
                                {
                                        fprintf(outfile,"this skel is a mesh\n");
                                        skel = child;
                                }
                                break;
                        }
                }

                /*
                if(splitFile)
                {
                        TSTR buf;
                        MakeSplitFilename(child,buf);
                        pSubDocMesh->save(CComVariant(buf.data()));

                }
                //dump PRS Controller data
                prsNode = NULL;

                // In our "Game Engine" we deal with Bezier Position, Scale and TCB Rotation controllers !!
                // Only list controllers on position, rotation...
                if(exportControllers)
                {
                        CComPtr<IXMLDOMNode>subContNode;
                        bool exportBiped = false;
                        CreateXMLNode(pXMLDoc,parent,_T("PRSData"),&prsNode);
                        IGameControl * pGameControl = child->GetIGameControl();
                        ExportControllers(prsNode,pGameControl);

                }

                if(exportModifiers)
                {
                        int numMod = obj->GetNumModifiers();
                        if(numMod > 0)
                        {
                                CComPtr <IXMLDOMNode> mod;
                                CreateXMLNode(pXMLDoc,parent,_T("Modifiers"),&mod);
                                TSTR Buf;
                                buf.printf("%d",numMod);
                                AddXMLAttribute(mod,_T("count"),buf.data());

                                for(int i=0;i<numMod;i++)
                                {
                                        IGameModifier * m = obj->GetIGameModifier(i);
                                        DumpModifiers(mod,m);
                                }
                        }
                }
                */
        }       
        /*
        for(int i=0;i<child->GetChildCount();i++)
        {
                IGameNode * newchild = child->GetNodeChild(i);
                // we deal with targets in the light/camera section
                if(newchild->IsTarget())
                        continue;

                ExportChildNodeInfo(newchild);
        }

        child->ReleaseIGameObject();
        */
}


void IGameExporter::ExportControllers(CComPtr<IXMLDOMNode> node, IGameControl * pGameControl)
{
        ExportPositionControllers(node,pGameControl);
        ExportRotationControllers(node,pGameControl);
        ExportScaleControllers(node,pGameControl);
}

void IGameExporter::ExportPositionControllers(CComPtr<IXMLDOMNode> node, IGameControl * pGameControl)
{
        IGameKeyTab poskeys;
        bool exportBiped = false;


        IGameControl::MaxControlType T = pGameControl->GetControlType(IGAME_POS);

        //position
        if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetBezierKeys(poskeys,IGAME_POS) && !forceSample)
                DumpBezierKeys(IGAME_POS,poskeys,node);

        else if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetLinearKeys(poskeys,IGAME_POS) && !forceSample)
                DumpLinearKeys(IGAME_POS,poskeys,node);

        else if(T==IGameControl::IGAME_POS_CONSTRAINT && !forceSample)
        {
                IGameConstraint * cnst = pGameControl->GetConstraint(IGAME_POS);
                DumpConstraints(node,cnst);
        }
        else if(T==IGameControl::IGAME_LIST && !forceSample)
        {
                DumpListController(pGameControl,node);

        }
        else if(T==IGameControl::IGAME_BIPED)
                exportBiped = true;
        else
        {
                if(forceSample || T==IGameControl::IGAME_UNKNOWN)
                        DumpSampleKeys(pGameControl,node,IGAME_POS);
        }
        if(exportBiped)
                DumpSampleKeys(pGameControl,node,IGAME_TM);
                
}

void IGameExporter::ExportRotationControllers(CComPtr<IXMLDOMNode> node, IGameControl * pGameControl)
{

        IGameKeyTab rotkeys;
        bool exportBiped = false;
        bool exported = false;          //this will at least export something !!

        //rotation
        IGameControl::MaxControlType T = pGameControl->GetControlType(IGAME_ROT);

        if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetTCBKeys(rotkeys,IGAME_ROT) && !forceSample)
        {
                DumpTCBKeys(IGAME_ROT,rotkeys,node);
                exported = true;
        }
        else if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetLinearKeys(rotkeys,IGAME_ROT) && !forceSample)
        {
                DumpLinearKeys(IGAME_ROT,rotkeys,node);
                exported = true;
        }
        else if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetBezierKeys(rotkeys,IGAME_ROT) && !forceSample)
        {
                DumpBezierKeys(IGAME_ROT,rotkeys,node);
                exported = true;
        }
        else if(T==IGameControl::IGAME_ROT_CONSTRAINT && !forceSample)
        {
                IGameConstraint * cnst = pGameControl->GetConstraint(IGAME_ROT);
                DumpConstraints(node,cnst);
                exported = true;
        }
        else if(T==IGameControl::IGAME_LIST&& !forceSample)
        {
                DumpListController(pGameControl,node);
                exported = true;

        }
        else if(T==IGameControl::IGAME_EULER&& !forceSample)
        {
                DumpEulerController(pGameControl,node);
                exported = true;
        }

        else if(T==IGameControl::IGAME_BIPED)
        {
                exportBiped = true;
                exported = true;
        }

        else
        {
                if(forceSample || !exported || T==IGameControl::IGAME_UNKNOWN)
                        DumpSampleKeys(pGameControl,node, IGAME_ROT);
        }
        if(exportBiped)
                DumpSampleKeys(pGameControl,node,IGAME_TM);
}

void IGameExporter::ExportScaleControllers(CComPtr<IXMLDOMNode> node, IGameControl * pGameControl)
{
        IGameKeyTab scalekeys;
        bool exportBiped = false;


        //scale
        IGameControl::MaxControlType T= pGameControl->GetControlType(IGAME_SCALE);

        if(T==IGameControl::IGAME_MAXSTD && pGameControl->GetBezierKeys(scalekeys,IGAME_SCALE) && !forceSample)
                DumpBezierKeys(IGAME_SCALE,scalekeys,node);
        else if(T==IGameControl::IGAME_BIPED)
                exportBiped = true;
        else
        {
                if(forceSample || T==IGameControl::IGAME_UNKNOWN)
                        DumpSampleKeys(pGameControl,node, IGAME_SCALE);
        }

        if(exportBiped)
                DumpSampleKeys(pGameControl,node,IGAME_TM);


        
}

void IGameExporter::DumpMatrix(Matrix3 tm,CComPtr<IXMLDOMNode> parent)
{
        CComPtr <IXMLDOMNode> tmNode;
        AffineParts ap;
        float rotAngle;
        Point3 rotAxis;
        float scaleAxAngle;
        Point3 scaleAxis;
        Matrix3 m = tm;
        TSTR Buf;
        
        decomp_affine(m, &ap);

        // Quaternions are dumped as angle axis.
        AngAxisFromQ(ap.q, &rotAngle, rotAxis);
        AngAxisFromQ(ap.u, &scaleAxAngle, scaleAxis);

//      CreateXMLNode(pXMLDoc,parent,_T("NodeTM"),&tmNodeParent);
        CreateXMLNode(pXMLDoc,parent,_T("Translation"),&tmNode);
        Buf.printf("%f %f %f",ap.t.x,ap.t.y,ap.t.z);
        AddXMLText(pXMLDoc,tmNode,Buf.data());
        tmNode = NULL;
        CreateXMLNode(pXMLDoc,parent,_T("Rotation"),&tmNode);
        if(!exportQuaternions)
                Buf.printf("%f %f %f %f",rotAxis.x, rotAxis.y, rotAxis.z, rotAngle);
        else
                Buf.printf("%f %f %f %f",ap.q.x, ap.q.y, ap.q.z, ap.q.w);

        AddXMLText(pXMLDoc,tmNode,Buf.data());
        tmNode = NULL;
        CreateXMLNode(pXMLDoc,parent,_T("Scale"),&tmNode);

        Buf.printf("%f %f %f %f %f %f",ap.k.x, ap.k.y, ap.k.z, scaleAxis.x,scaleAxis.y,scaleAxis.z);
        AddXMLText(pXMLDoc,tmNode,Buf.data());


}

void GetKeyTypeName(TSTR &name, DWORD Type)
{
        if(Type==IGAME_POS)
                name.printf("Position");
        else if(Type==IGAME_ROT)
                name.printf("Rotation");
        else if(Type==IGAME_POINT3)
                name.printf("Point3");
        else if(Type==IGAME_FLOAT)
                name.printf("float");
        else if(Type==IGAME_SCALE)
                name.printf("Scale");
        else if(Type == IGameConstraint::IGAME_PATH)
                name.printf("Path");
        else if(Type == IGameConstraint::IGAME_POSITION)
                name.printf("Position");
        else if(Type == IGameConstraint::IGAME_ORIENTATION)
                name.printf("Orientation");
        else if (Type == IGameConstraint::IGAME_LOOKAT)
                name.printf("lookAt");
        else if(Type == IGAME_TM)
                name.printf("NodeTM");
        else if(Type == IGAME_EULER_X)
                name.printf("EulerX");
        else if(Type == IGAME_EULER_Y)
                name.printf("EulerY");
        else if(Type == IGAME_EULER_Z)
                name.printf("EulerZ");


        else
                name.printf("Huh!!");

}

void IGameExporter::DumpEulerController(IGameControl * sc,CComPtr<IXMLDOMNode> prsNode)
{
        TSTR data;
        CComPtr <IXMLDOMNode> eulerNode = NULL;

        IGameKeyTab xCont,yCont,zCont;

        if(sc->GetBezierKeys(xCont,IGAME_EULER_X))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);

                DumpBezierKeys(IGAME_EULER_X,xCont,eulerNode);
        }

        if(sc->GetBezierKeys(yCont,IGAME_EULER_Y))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);
                
                DumpBezierKeys(IGAME_EULER_Y,yCont,eulerNode);
                
        }

        if(sc->GetBezierKeys(zCont,IGAME_EULER_Z))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);
                        
                DumpBezierKeys(IGAME_EULER_Z,zCont,eulerNode);
                
        }
        if(sc->GetLinearKeys(xCont,IGAME_EULER_X))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);
        
                DumpLinearKeys(IGAME_EULER_X,xCont,eulerNode);

        }

        if(sc->GetLinearKeys(yCont,IGAME_EULER_Y))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);
                
                DumpLinearKeys(IGAME_EULER_Y,yCont,eulerNode);
                
        }

        if(sc->GetLinearKeys(zCont,IGAME_EULER_Z))
        {
                if(eulerNode ==NULL)
                        CreateXMLNode(pXMLDoc,prsNode,_T("EulerController"),&eulerNode);
                
                DumpLinearKeys(IGAME_EULER_Z,zCont,eulerNode);
        }

}

void IGameExporter::DumpListController(IGameControl * sc,CComPtr<IXMLDOMNode> prsNode)
{
        TSTR data;
        CComPtr <IXMLDOMNode> posListNode,rotListNode;
        int subNum;
        subNum = sc->GetNumOfListSubControls(IGAME_POS);
        if(subNum)
        {
        data.printf("%d",subNum);
                CreateXMLNode(pXMLDoc,prsNode,_T("PositionListController"),&posListNode);
                AddXMLAttribute(posListNode,_T("NumSubController"),data.data());
                for(int i=0;i<subNum;i++)
        {
                IGameKeyTab SubCont;
                        IGameControl * sub = sc->GetListSubControl(i,IGAME_POS);
                        ExportPositionControllers(posListNode,sub);

                }
        }
        subNum = sc->GetNumOfListSubControls(IGAME_ROT);
        if(subNum)
                {
                data.printf("%d",subNum);
                CreateXMLNode(pXMLDoc,prsNode,_T("RotationListController"),&rotListNode);
                AddXMLAttribute(rotListNode,_T("NumSubController"),data.data());
                for(int i=0;i<subNum;i++)
                {
                        IGameKeyTab SubCont;
                        IGameControl * sub = sc->GetListSubControl(i,IGAME_POS);
                        ExportRotationControllers(rotListNode,sub);

                }
        }
}

void IGameExporter::DumpSampleKeys(IGameControl * sc,CComPtr<IXMLDOMNode> prsNode, DWORD Type, bool quick)
{
        Tab<Matrix3>sKey;  
        Tab<GMatrix>gKey;
        IGameKeyTab Key;
        IGameControl * c = sc;
        CComPtr<IXMLDOMNode> sampleData;
        TSTR Buf;
        bool relative = false;

        TSTR name;
        GetKeyTypeName(name,Type);
        sampleData = NULL;

        if(!c)
                return;

        relative = exportRelative ? true : false;

        if(!quick && c->GetFullSampledKeys(Key,framePerSample,IGameControlType(Type),relative) )
        {

                CreateXMLNode(pXMLDoc,prsNode,name,&sampleData);
                Buf.printf("%d",Key.Count());
                AddXMLAttribute(sampleData,_T("KeyCount"),Buf.data());
                AddXMLAttribute(sampleData,_T("Type"),_T("FullSampled"));
                Buf.printf("%d",framePerSample);
                AddXMLAttribute(sampleData,_T("SampleRate"),Buf.data());

                for(int i=0;i<Key.Count();i++)
                {
                        CComPtr<IXMLDOMNode> data;
                        CreateXMLNode(pXMLDoc,sampleData,_T("Sample"),&data);
                        int fc = Key[i].t;
                        Buf.printf("%d",fc);
                        AddXMLAttribute(data,_T("frame"),Buf.data());

                        if(Type ==IGAME_POS)
                        {
                                Point3 k = Key[i].sampleKey.pval;
                                Buf.printf("%f %f %f",k.x,k.y,k.z); 
                                AddXMLText(pXMLDoc,data,Buf.data());
                        }
                        if(Type == IGAME_ROT)
                        {
                                Quat q = Key[i].sampleKey.qval;
                                AngAxis a(q);
                                if(!exportQuaternions)
                                        Buf.printf("%f %f %f %f",a.axis.x, a.axis.y, a.axis.z, a.angle);
                                else
                                        Buf.printf("%f %f %f %f",q.x,q.y, q.z, q.w);

                                AddXMLText(pXMLDoc,data,Buf.data());

                        }
                        if(Type == IGAME_SCALE)
                        {
                                ScaleValue sval = Key[i].sampleKey.sval;
                                Point3 s = sval.s;
                                AngAxis a(sval.q);
                                if(!exportQuaternions)
                                        Buf.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,a.axis.x, a.axis.y, a.axis.z, a.angle);
                                else
                                        Buf.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,sval.q.x, sval.q.y,sval.q.z, sval.q.w);
                                AddXMLText(pXMLDoc,data,Buf.data());

                        }
                        if(Type == IGAME_FLOAT)
                        {
                                float f = Key[i].sampleKey.fval;
                                Buf.printf("%f",f);     
                                AddXMLText(pXMLDoc,data,Buf.data());
                        }
                        if(Type == IGAME_TM)
                        {
                                //Even though its a 4x4 we dump it as a 4x3 ;-)
                                GMatrix m;
                                DumpMatrix(Key[i].sampleKey.gval.ExtractMatrix3(),data);
                        }
                }
        }

        //mainly for the IK On/Off controller
        if(quick && c->GetQuickSampledKeys(Key,IGameControlType(Type)) )
        {

                CreateXMLNode(pXMLDoc,prsNode,name,&sampleData);
                Buf.printf("%d",Key.Count());
                AddXMLAttribute(sampleData,_T("KeyCount"),Buf.data());
                AddXMLAttribute(sampleData,_T("Type"),_T("QuickSampled"));

                for(int i=0;i<Key.Count();i++)
                {
                        CComPtr<IXMLDOMNode> data;
                        CreateXMLNode(pXMLDoc,sampleData,_T("Sample"),&data);
                        int fc = Key[i].t;
                        Buf.printf("%d",fc);
                        AddXMLAttribute(data,_T("frame"),Buf.data());
                        if(Type == IGAME_FLOAT)
                        {
                                float f = Key[i].sampleKey.fval;
                                Buf.printf("%f",f);     
                                AddXMLText(pXMLDoc,data,Buf.data());
                        }

                }
        }

}
void IGameExporter::DumpSkin(CComPtr<IXMLDOMNode> modNode, IGameSkin * s)
{
        CComPtr <IXMLDOMNode> skinNode;
        TSTR Buf;

        if(s->GetSkinType()== IGameSkin::IGAME_PHYSIQUE)
                Buf.printf("%s",_T("Physique"));
        else
                Buf.printf("%s",_T("MaxSkin"));

        AddXMLAttribute(modNode,_T("skinType"),Buf.data());

        GMatrix skinTM;

        s->GetInitSkinTM(skinTM);

        for(int x=0; x<s->GetNumOfSkinnedVerts();x++)
        {
                int type = s->GetVertexType(x);
                if(type==IGameSkin::IGAME_RIGID)
                {
                        CComPtr <IXMLDOMNode> boneNode;
                        skinNode = NULL;
                        CreateXMLNode(pXMLDoc,modNode,_T("Skin"),&skinNode);
                        Buf.printf("%d",x);
                        AddXMLAttribute(skinNode,_T("vertexID"),Buf.data());
                        AddXMLAttribute(skinNode,_T("Type"),_T("Rigid"));
                        CreateXMLNode(pXMLDoc,skinNode,_T("Bone"),&boneNode);
                        ULONG id = s->GetBoneID(x,0);
                        Buf.printf("%d",id);
                        AddXMLAttribute(boneNode,_T("BoneID"),Buf.data());

                }
                else //blended
                {
                        CComPtr <IXMLDOMNode> boneNode;
                        skinNode = NULL;
                        CreateXMLNode(pXMLDoc,modNode,_T("Skin"),&skinNode);
                        Buf.printf("%d",x);
                        AddXMLAttribute(skinNode,_T("vertexID"),Buf.data());
                        AddXMLAttribute(skinNode,_T("Type"),_T("Blended"));

                        for(int y=0;y<s->GetNumberOfBones(x);y++)
                        {
                                boneNode = NULL;
                                CreateXMLNode(pXMLDoc,skinNode,_T("Bone"),&boneNode);
                                ULONG id = s->GetBoneID(x,y);
                                Buf.printf("%d",id);
                                AddXMLAttribute(boneNode,_T("BoneID"),Buf.data());
                                float weight = s->GetWeight(x,y);
                                Buf.printf("%f",weight);
                                AddXMLAttribute(boneNode,_T("Weight"),Buf.data());
                        }
                }
        }
}

void IGameExporter::DumpModifiers(CComPtr<IXMLDOMNode> modNode, IGameModifier * m)
{
        CComPtr <IXMLDOMNode> propNode;
        TSTR buf;
        if(exportSkin || exportGenMod)
        {
        
                CreateXMLNode(pXMLDoc,modNode,_T("Modifier"),&propNode);
                AddXMLAttribute(propNode,_T("modName"),m->GetInternalName());
                bool bS = m->IsSkin();
                if(bS)
                        buf.printf(_T("true"));
                else
                        buf.printf(_T("false"));
                AddXMLAttribute(propNode,_T("IsSkin"),buf.data());
                
                if(m->IsSkin() && exportSkin)
                {
                        IGameSkin * skin = (IGameSkin*)m;
                        DumpSkin(propNode,skin);
                }
        }

}

void IGameExporter::DumpLight(IGameLight *lt, CComPtr<IXMLDOMNode> parent)
{

        IGameProperty * prop;
        CComPtr <IXMLDOMNode> propNode,targNode;


        CreateXMLNode(pXMLDoc,parent,_T("Properties"),&propNode);
        prop = lt->GetLightColor();
        DumpProperties(propNode,prop);
        prop = lt->GetLightMultiplier();
        DumpProperties(propNode,prop);
        prop = lt->GetLightAspectRatio();
        DumpProperties(propNode,prop);
        prop = lt->GetLightAttenEnd();
        DumpProperties(propNode,prop);
        prop = lt->GetLightAttenStart();
        DumpProperties(propNode,prop);
        prop = lt->GetLightFallOff();
        DumpProperties(propNode,prop);
        prop = lt->GetLightAspectRatio();
        DumpProperties(propNode,prop);
        
        if(lt->GetLightType()==TSPOT_LIGHT )
        {
                CreateXMLNode(pXMLDoc,parent,_T("Target"),&targNode);
//              ExportChildNodeInfo(targNode,lt->GetLightTarget());
        }

}

void IGameExporter::DumpCamera(IGameCamera *ca, CComPtr<IXMLDOMNode> parent)
{

        IGameProperty * prop;
        CComPtr <IXMLDOMNode> propNode,targNode;


        CreateXMLNode(pXMLDoc,parent,_T("Properties"),&propNode);
        prop = ca->GetCameraFOV();
        DumpProperties(propNode,prop);
        prop = ca->GetCameraFarClip();
        DumpProperties(propNode,prop);
        prop = ca->GetCameraNearClip();
        DumpProperties(propNode,prop);
        prop = ca->GetCameraTargetDist();
        DumpProperties(propNode,prop);
        
        if(ca->GetCameraTarget())
        {
                CreateXMLNode(pXMLDoc,parent,_T("Target"),&targNode);
//              ExportChildNodeInfo(targNode,ca->GetCameraTarget());
        }
        

}

void IGameExporter::DumpIKChain(IGameIKChain * ikch, CComPtr<IXMLDOMNode> ikData)
{
        CComPtr <IXMLDOMNode> ikRoot,ikNode, ikEnabled;
        TSTR buf;

        CreateXMLNode(pXMLDoc,ikData,_T("IKNodes"),&ikRoot);
        buf.printf("%d",ikch->GetNumberofBonesinChain());
        AddXMLAttribute(ikRoot,_T("NumOfNodesInChain"),buf.data());

        for(int i=0;i<ikch->GetNumberofBonesinChain();i++)
        {
                ikNode = NULL;
                IGameNode * node = ikch->GetIGameNodeInChain(i);
                CreateXMLNode(pXMLDoc,ikRoot,_T("ChainNode"),&ikNode);
                buf.printf("%d",node->GetNodeID());
                AddXMLAttribute(ikNode,_T("NodeID"),buf.data());
                
        }

        IGameControl * cont = ikch->GetIKEnabledController();
        if(cont)
        {
                CreateXMLNode(pXMLDoc,ikData,_T("IKEnabled"),&ikEnabled);
                DumpSampleKeys(cont,ikEnabled,IGAME_FLOAT,true);
        }

        
}

void IGameExporter::DumpSpline(IGameSpline * sp,CComPtr<IXMLDOMNode> splineData)
{
        CComPtr <IXMLDOMNode> spline,knotData;
        TSTR buf;

        buf.printf("%d",sp->GetNumberOfSplines());
        AddXMLAttribute(splineData,_T("NumOfSplines"),buf.data());

        for(int i=0;i<sp->GetNumberOfSplines();i++)
        {
                IGameSpline3D * sp3d = sp->GetIGameSpline3D(i);
                spline=NULL;
                CreateXMLNode(pXMLDoc,splineData,_T("Spline"),&spline);
                buf.printf("%d",i+1);
                AddXMLAttribute(spline,_T("index"),buf.data());
                int num = sp3d->GetIGameKnotCount();
                buf.printf("%d",num);
                AddXMLAttribute(spline,_T("NumOfKnots"),buf.data());
                for(int j=0;j<num;j++)
                {
                        TSTR data;
                        Point3 v;
                        CComPtr <IXMLDOMNode> point,invec,outvec;
                        knotData=NULL;
                        IGameKnot * knot = sp3d->GetIGameKnot(j);
                        CreateXMLNode(pXMLDoc,spline,_T("knot"),&knotData);
                        CreateXMLNode(pXMLDoc,knotData,_T("Point"),&point);
                        v = knot->GetKnotPoint();
                        if(exportObjectSpace)
                        {
                                GMatrix g = sp->GetIGameObjectTM();
                                Matrix3 gm = g.ExtractMatrix3();
                                Matrix3 invgm = Inverse(gm);
                                v = v * invgm;
                        }
                        data.printf("%f %f %f",v.x,v.y,v.z);
                        AddXMLText(pXMLDoc,point,data.data());
                        CreateXMLNode(pXMLDoc,knotData,_T("inVec"),&invec);
                        v = knot->GetInVec();
                        if(exportObjectSpace)
                        {
                                GMatrix g = sp->GetIGameObjectTM();
                                Matrix3 gm = g.ExtractMatrix3();
                                Matrix3 invgm = Inverse(gm);
                                v = v * invgm;
                        }
                        data.printf("%f %f %f",v.x,v.y,v.z);
                        AddXMLText(pXMLDoc,invec,data.data());
                        CreateXMLNode(pXMLDoc,knotData,_T("outVec"),&outvec);
                        v = knot->GetOutVec();
                        if(exportObjectSpace)
                        {
                                GMatrix g = sp->GetIGameObjectTM();
                                Matrix3 gm = g.ExtractMatrix3();
                                Matrix3 invgm = Inverse(gm);
                                v = v * invgm;
                        }
                        data.printf("%f %f %f",v.x,v.y,v.z);
                        AddXMLText(pXMLDoc,outvec,data.data());

                }
        }

        IPropertyContainer * cc = sp->GetIPropertyContainer();
        IGameProperty * prop = cc->QueryProperty(_T("IGameTestString"));
        prop = cc->QueryProperty(_T("IGameTestString"));

        if(prop)
        {
                TCHAR * name;
                prop->GetPropertyValue(name);

        }

                

}

void IGameExporter::DumpGenericFace(IGameMesh * gM,FaceEx *fe, CComPtr<IXMLDOMNode> faceData, bool smgrp, bool n, bool vc, bool tv)
{
        TSTR data;
        FaceEx *f = fe;
        CComPtr <IXMLDOMNode> prop = NULL;
        TSTR buf;

        CreateXMLNode(pXMLDoc,faceData,_T("vert"),&prop);
        buf.printf("%d %d %d",f->vert[0],f->vert[1],f->vert[2]);
        AddXMLText(pXMLDoc,prop,buf.data());
        
        prop =NULL;     
        if(smgrp){
                CreateXMLNode(pXMLDoc,faceData,_T("smGrp"),&prop);
                buf.printf("%d",f->smGrp);
                AddXMLText(pXMLDoc,prop,buf.data());
        }

        prop =NULL;
        CreateXMLNode(pXMLDoc,faceData,_T("MatID"),&prop);
        buf.printf("%d",f->matID);
        AddXMLText(pXMLDoc,prop,buf.data());

        if(exportNormals && n && !exportNormalsPerFace)
        {
                prop =NULL;
                CreateXMLNode(pXMLDoc,faceData,_T("norm"),&prop);
                buf.printf("%d %d %d",f->norm[0],f->norm[1],f->norm[2]);
                AddXMLText(pXMLDoc,prop,buf.data());
        }
        if(exportVertexColor && vc)
        {
                prop =NULL;
                CreateXMLNode(pXMLDoc,faceData,_T("vColor"),&prop);
                buf.printf("%d %d %d",f->color[0],f->color[1],f->color[2]);
                AddXMLText(pXMLDoc,prop,buf.data());
        }
        if(exportTexCoords && tv)
        {
                prop =NULL;
                CreateXMLNode(pXMLDoc,faceData,_T("tvert"),&prop);
                buf.printf("%d %d %d",f->texCoord[0],f->texCoord[1],f->texCoord[2]);
                AddXMLText(pXMLDoc,prop,buf.data());
        }

        if(exportNormalsPerFace)
        {
                CComPtr <IXMLDOMNode> perFaceNorm = NULL;
                CreateXMLNode(pXMLDoc,faceData,_T("VertexNormals"),&perFaceNorm);
                for(int vv=0; vv<3; vv++)
                {
                        CComPtr <IXMLDOMNode> normals = NULL;
                        CreateXMLNode(pXMLDoc,perFaceNorm,_T("Normal"),&normals);
                        Point3 n;
                        if(gM->GetNormal(f,vv, n))
                        {
                                buf.printf("%f %f %f\n",n.x,n.y,n.z);
                                AddXMLText(pXMLDoc,normals,buf.data());
                        }
                }
        }





}

void IGameExporter::DumpMesh(IGameMesh * gm,CComPtr<IXMLDOMNode> geomData)
{
        CComPtr <IXMLDOMNode> vertData,normData,faceData,vcData,tvData;
        CComPtr <IXMLDOMNode> propNode;
        TSTR buf;
        bool vcSet = false;
        bool nSet = false;
        bool tvSet = false;


        // dump Vertices
        CreateXMLNode(pXMLDoc,geomData,_T("Vertices"),&vertData);
        int numVerts = gm->GetNumberOfVerts();
        numVertex = numVerts;

        buf.printf("%d",numVerts);
        AddXMLAttribute(vertData,_T("Count"),buf.data());
        for(int i = 0;i<numVerts;i++)
        {
                CComPtr <IXMLDOMNode> vert = NULL;
                TSTR data;
                CreateXMLNode(pXMLDoc,vertData,_T("vertex"),&vert);

                buf.printf("%d",i);
                AddXMLAttribute(vert,_T("index"),buf.data());
                Point3 v; 
                if(gm->GetVertex(i,v))
                {
                        if(exportObjectSpace)
                        {
                                GMatrix g = gm->GetIGameObjectTM();
                                Matrix3 gm = g.ExtractMatrix3();
                                Matrix3 invgm = Inverse(gm);
                                v = v * invgm;
                        }
                        data.printf("%f %f %f",v.x,v.y,v.z);
                        AddXMLText(pXMLDoc,vert,data.data());
                }
                        
        }
        if(exportNormals && !exportNormalsPerFace)
        {
                // dump Normals
                int numNorms = gm->GetNumberOfNormals();
                if(numNorms >0)
                {
                        nSet = true;
                        CreateXMLNode(pXMLDoc,geomData,_T("Normals"),&normData);
                        buf.printf("%d",numNorms);
                        AddXMLAttribute(normData,_T("Count"),buf.data());
                }
                
                for(int i = 0;i<numNorms;i++)
                {
                        CComPtr <IXMLDOMNode> norm = NULL;
                        TSTR data;
                        CreateXMLNode(pXMLDoc,normData,_T("normal"),&norm);
                        buf.printf("%d",i);
                        AddXMLAttribute(norm,_T("index"),buf.data());
                        Point3 n;
                        if(gm->GetNormal(i,n))
                        {
                                buf.printf("%f %f %f",n.x,n.y,n.z);
                                AddXMLText(pXMLDoc,norm,buf.data());
                        }
                }
        }
        if(exportTexCoords)
        {
                // dump tvs
                int numTVs = gm->GetNumberOfTexVerts();
                if(numTVs >0)
                {
                        tvSet = true;
                        CreateXMLNode(pXMLDoc,geomData,_T("TextureCordinates"),&tvData);
                        buf.printf("%d",numTVs);
                        AddXMLAttribute(tvData,_T("Count"),buf.data());
                }
                for(int i = 0;i<numTVs;i++)
                {
                        CComPtr <IXMLDOMNode> norm = NULL;
                        TSTR data;
                        CreateXMLNode(pXMLDoc,tvData,_T("tVertex"),&norm);
                        buf.printf("%d",i);
                        AddXMLAttribute(norm,_T("index"),buf.data());
                        Point2 tv;
                        if(gm->GetTexVertex(i,tv))
                        {
                                buf.printf("%f %f",tv.x,tv.y);
                                AddXMLText(pXMLDoc,norm,buf.data());
                        }
                }
        }

        if(exportVertexColor)
        {
                // dump VC
                int numVCs = gm->GetNumberOfColorVerts();
                if(numVCs >0)
                {
                        vcSet = true;
                        CreateXMLNode(pXMLDoc,geomData,_T("VertexColor"),&vcData);
                        buf.printf("%d",numVCs);
                        AddXMLAttribute(vcData,_T("Count"),buf.data());
                }
                for(int i = 0;i<numVCs;i++)
                {
                        CComPtr <IXMLDOMNode> vc = NULL;
                        TSTR data;
                        CreateXMLNode(pXMLDoc,vcData,_T("vColor"),&vc);
                        buf.printf("%d",i);
                        AddXMLAttribute(vc,_T("index"),buf.data());
                        Point3 n;
                        if(gm->GetColorVertex(i,n))
                        {
                                buf.printf("%f %f %f",n.x,n.y,n.z);
                                AddXMLText(pXMLDoc,vc,buf.data());
                        }
                }
        }

        // dump Face data
        CreateXMLNode(pXMLDoc,geomData,_T("Faces"),&faceData);

        if(exportFaceSmgp)
        {
                Tab<DWORD> smGrps = gm->GetActiveSmgrps();

                for (int x=0;x<smGrps.Count();x++)
                {
                        CComPtr <IXMLDOMNode> smgrpFace;
                        TSTR data;
                        Tab <int > smFace = gm->GetFaceIndexFromSmgrp(smGrps[x]);
                        CreateXMLNode(pXMLDoc,faceData,_T("SmoothingBased"),&smgrpFace);
                        buf.printf("%d",smGrps[x]);
                        AddXMLAttribute(smgrpFace,_T("Group"),buf.data());
                        buf.printf("%d",smFace.Count());
                        AddXMLAttribute(smgrpFace,_T("Count"),buf.data());

                        for(int f=0;f<smFace.Count();f++)
                        {
                                CComPtr <IXMLDOMNode> norm = NULL;
                                CreateXMLNode(pXMLDoc,smgrpFace,_T("Face"),&norm);
                                data.printf("%d",smFace[f]);
                                AddXMLAttribute(norm,_T("index"),data.data());
                                DumpGenericFace(gm,gm->GetFace(smFace[f]),norm,false,nSet,vcSet,tvSet);
                        }

                }
        }
        else
        {
                TSTR data;
                int numFaces = gm->GetNumberOfFaces();
                buf.printf("%d",numFaces);
                AddXMLAttribute(faceData,_T("Count"),buf.data());

                for(int f=0;f<numFaces;f++)
                {
                        CComPtr <IXMLDOMNode> norm = NULL;
                        CreateXMLNode(pXMLDoc,faceData,_T("Face"),&norm);
                        data.printf("%d",f);
                        AddXMLAttribute(norm,_T("index"),data.data());
                        DumpGenericFace(gm, gm->GetFace(f),norm,true,nSet,vcSet,tvSet);


                }
                
        }

        if(exportMappingChannel)
        {
                TSTR data;
                CComPtr <IXMLDOMNode> channelNode;
                Tab<int> mapNums = gm->GetActiveMapChannelNum();
                CreateXMLNode(pXMLDoc,geomData,_T("MappingChannels"),&channelNode);
                int mapCount = mapNums.Count();
                buf.printf("%d",mapCount);
                AddXMLAttribute(channelNode,_T("Count"),buf.data());

                for(int i=0;i < mapCount;i++)
                {
                        CComPtr <IXMLDOMNode> channelItem, mvertData,vert,mfaceData,face;
                        CreateXMLNode(pXMLDoc,channelNode,_T("MapChannel"),&channelItem);
                        buf.printf("%d",mapNums[i]);
                        AddXMLAttribute(channelItem,_T("ChannelNum"),buf.data());
                        CreateXMLNode(pXMLDoc,channelItem,_T("MapVertexData"),&mvertData);
                        int vCount = gm->GetNumberOfMapVerts(mapNums[i]);
                        buf.printf("%d",vCount);
                        AddXMLAttribute(mvertData,_T("Count"),buf.data());

                        for(int j=0;j<vCount;j++)
                        {
                                vert = NULL;
                                CreateXMLNode(pXMLDoc,mvertData,_T("mapvertex"),&vert);
                                buf.printf("%d",j);
                                AddXMLAttribute(vert,_T("index"),buf.data());
                                Point3 v;
                                if(gm->GetMapVertex(mapNums[i],j,v))
                                {
                                        data.printf("%f %f %f",v.x,v.y,v.z);
                                        AddXMLText(pXMLDoc,vert,data.data());
                                }
                
                        }
                        CreateXMLNode(pXMLDoc,channelItem,_T("MapFaceData"),&mfaceData);
                        int fCount = gm->GetNumberOfFaces();
                        buf.printf("%d",fCount);
                        AddXMLAttribute(mfaceData,_T("Count"),buf.data());

                        for(int k=0;k<fCount;k++)
                        {
                                face = NULL;
                                CreateXMLNode(pXMLDoc,mfaceData,_T("mapface"),&face);
                                buf.printf("%d",k);
                                AddXMLAttribute(face,_T("index"),buf.data());
                                DWORD  v[3];
                                gm->GetMapFaceIndex(mapNums[i],k,v);
                                data.printf("%d %d %d",v[0],v[1],v[2]);
                                AddXMLText(pXMLDoc,face,data.data());
                        
                        }
                }

        }

#if 0
//test code
        Tab<int> matids;

        matids = gm->GetActiveMatIDs();

        for(i=0;i<matids.Count();i++)
        {
                Tab<FaceEx*> faces;

                faces = gm->GetFacesFromMatID(matids[i]);

                for(int k=0; k<faces.Count();k++)
                {
                        IGameMaterial * faceMat = gm->GetMaterialFromFace(faces[k]);
//                      TSTR name(faceMat->GetMaterialName());
                }
                for(k=0;k<gm->GetNumberOfFaces();k++)
                {
                        IGameMaterial * faceMat = gm->GetMaterialFromFace(k);
                }
                
        }

        Tab <DWORD> smgrps = gm->GetActiveSmgrps();
#endif

        vertData = NULL;
        normData = NULL;
        faceData = NULL;
}



void IGameExporter::DumpConstraints(CComPtr<IXMLDOMNode> prsData, IGameConstraint * c)
{
        TSTR buf,name;
        CComPtr <IXMLDOMNode> prsChild;
        CComPtr <IXMLDOMNode> constNode;

        if(exportConstraints)
        {
        
                CreateXMLNode(pXMLDoc,prsData,_T("Constrainst"),&prsChild);
                GetKeyTypeName(name, c->GetConstraintType());
                AddXMLAttribute(prsChild,_T("Type"),name.data());
                buf.printf("%d",c->NumberOfConstraintNodes());
                AddXMLAttribute(prsChild,_T("NodeCount"),buf.data());

                for(int i=0;i<c->NumberOfConstraintNodes();i++ )
                {
                        constNode = NULL;
                        CreateXMLNode(pXMLDoc,prsChild,_T("ConstNode"),&constNode);
                        float w = c->GetConstraintWeight(i);
                        int id = c->GetConstraintNodes(i)->GetNodeID();
                        
                        buf.printf("%d", id);
                        AddXMLAttribute(constNode,_T("NodeID"),buf.data());

                        buf.printf("%f", w);
                        AddXMLAttribute(constNode,_T("Weight"),buf.data());

                }
                for(i=0;i<c->GetIPropertyContainer()->GetNumberOfProperties();i++)
                {
                        DumpProperties(prsChild,c->GetIPropertyContainer()->GetProperty(i));
                }
        }
}




void IGameExporter::DumpBezierKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData)
{
        TSTR buf,name;
        CComPtr <IXMLDOMNode> prsChild;
        GetKeyTypeName(name,Type);

        if(Keys.Count()==0)
                return;

        CreateXMLNode(pXMLDoc,prsData,name,&prsChild);

        buf.printf("%d",Keys.Count());
        AddXMLAttribute(prsChild,_T("KeyCount"),buf.data());
        AddXMLAttribute(prsChild,_T("Type"),_T("Bezier"));

        for(int i = 0;i<Keys.Count();i++)
        {
                CComPtr <IXMLDOMNode> key = NULL;
                TSTR data;
                CreateXMLNode(pXMLDoc,prsChild,_T("Key"),&key);
                buf.printf("%d",Keys[i].t);
                AddXMLAttribute(key,_T("time"),buf.data());
                if(Type==IGAME_POS || Type==IGAME_POINT3)
                {
                        Point3 k = Keys[i].bezierKey.pval;
                        data.printf("%f %f %f",k.x,k.y,k.z); 
                }
                else if (Type == IGAME_ROT)
                {
                        Quat q = Keys[i].bezierKey.qval;
                        AngAxis a(q);
                        if(!exportQuaternions)
                                data.printf("%f %f %f %f",a.axis.x, a.axis.y, a.axis.z, a.angle);
                        else
                                data.printf("%f %f %f %f",q.x, q.y, q.z, q.w);

                }
                else if ( Type == IGAME_FLOAT || Type==IGAME_EULER_X || Type == IGAME_EULER_Y || Type==IGAME_EULER_Z)
                {
                        float f = Keys[i].bezierKey.fval;
                        data.printf("%f",f);
                }
                else{
                        ScaleValue sval = Keys[i].bezierKey.sval;
                        Point3 s = sval.s;
                        AngAxis a(sval.q);
                        if(!exportQuaternions)
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,a.axis.x, a.axis.y, a.axis.z, a.angle);
                        else
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,sval.q.x, sval.q.y,sval.q.z, sval.q.w);

                }
                AddXMLText(pXMLDoc,key,data.data());
                
        }

        prsChild = NULL;

}
void IGameExporter::DumpLinearKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData)
{
        TSTR buf,name;
        CComPtr <IXMLDOMNode> prsChild;
        GetKeyTypeName(name,Type);

        if(Keys.Count()==0)
                return;

        CreateXMLNode(pXMLDoc,prsData,name.data(),&prsChild);

        buf.printf("%d",Keys.Count());
        AddXMLAttribute(prsChild,_T("KeyCount"),buf.data());
        AddXMLAttribute(prsChild,_T("Type"),_T("Linear"));

        for(int i = 0;i<Keys.Count();i++)
        {
                CComPtr <IXMLDOMNode> key = NULL;
                TSTR data;
                CreateXMLNode(pXMLDoc,prsChild,_T("Key"),&key);
                buf.printf("%d",Keys[i].t);
                AddXMLAttribute(key,_T("time"),buf.data());
                if(Type==IGAME_POS)
                {
                        Point3 k = Keys[i].linearKey.pval;
                        data.printf("%f %f %f",k.x,k.y,k.z); 
                }
                else if (Type == IGAME_ROT)
                {
                        Quat q = Keys[i].linearKey.qval;
                        AngAxis a(q);
                        if(!exportQuaternions)
                                data.printf("%f %f %f %f",a.axis.x, a.axis.y, a.axis.z, a.angle);
                        else
                                data.printf("%f %f %f %f",q.x, q.y, q.z, q.w);

                }
                else if ( Type == IGAME_FLOAT || Type==IGAME_EULER_X || Type == IGAME_EULER_Y || Type==IGAME_EULER_Z)
                {
                        float f = Keys[i].linearKey.fval;
                        data.printf("%f",f);    
                }
                else{
                        ScaleValue sval = Keys[i].linearKey.sval;
                        Point3 s = sval.s;
                        AngAxis a(sval.q);
                        if(exportQuaternions)
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,a.axis.x, a.axis.y, a.axis.z, a.angle);
                        else
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,sval.q.x, sval.q.y,sval.q.z, sval.q.w);

                }
                AddXMLText(pXMLDoc,key,data.data());
                
        }

        prsChild = NULL;


}
void IGameExporter::DumpTCBKeys(DWORD Type, IGameKeyTab Keys, CComPtr<IXMLDOMNode> prsData)
{
        TSTR buf,name;
        CComPtr <IXMLDOMNode> prsChild;

        if(Keys.Count()==0)
                return;

        GetKeyTypeName(name,Type);
        CreateXMLNode(pXMLDoc,prsData,name.data(),&prsChild);

        buf.printf("%d",Keys.Count());
        AddXMLAttribute(prsChild,_T("KeyCount"),buf.data());
        AddXMLAttribute(prsChild,_T("Type"),_T("TCB"));

        for(int i = 0;i<Keys.Count();i++)
        {
                CComPtr <IXMLDOMNode> key = NULL;
                TSTR data;
                CreateXMLNode(pXMLDoc,prsChild,_T("Key"),&key);
                buf.printf("%d",Keys[i].t);
                AddXMLAttribute(key,_T("time"),buf.data());
                if(Type==IGAME_POS)
                {
                        Point3 k = Keys[i].tcbKey.pval;
                        data.printf("%f %f %f",k.x,k.y,k.z); 
                }
                else if (Type == IGAME_ROT)
                {
                        AngAxis a = Keys[i].tcbKey.aval;
                        data.printf("%f %f %f %f",a.axis.x, a.axis.y, a.axis.z, a.angle);

                }
                else{
                        ScaleValue sval = Keys[i].tcbKey.sval;
                        Point3 s = sval.s;
                        AngAxis a(sval.q);
                        if(!exportQuaternions)
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,a.axis.x, a.axis.y, a.axis.z, a.angle);
                        else
                                data.printf("%f %f %f %f %f %f %f",sval.s.x,sval.s.y,sval.s.z,sval.q.x, sval.q.y,sval.q.z, sval.q.w);

                }
                AddXMLText(pXMLDoc,key,data.data());
                
        }

        prsChild = NULL;


}

void IGameExporter::DumpProperties(CComPtr<IXMLDOMNode> node, IGameProperty * prop)
{
        TSTR Buf;
        IGameKeyTab keys;
        CComPtr <IXMLDOMNode> propData;
        CComPtr <IXMLDOMNode> keyNode;

        if(!prop)       //fix me NH...
                return;
        CreateXMLNode(pXMLDoc,node,_T("Prop"),&propData);
        AddXMLAttribute(propData,_T("name"),prop->GetName());

        if(prop->GetType() == IGAME_POINT3_PROP)
        {
                Point3 p; 
                prop->GetPropertyValue(p);
                Buf.printf("%f %f %f",p.x,p.y,p.z);
        }
        else if( prop->GetType() == IGAME_FLOAT_PROP)
        {
                float f;
                prop->GetPropertyValue(f);
                Buf.printf("%f", f);
        }
        else if(prop->GetType()==IGAME_STRING_PROP)
        {
                TCHAR * b;
                prop->GetPropertyValue(b);
                Buf.printf("$s",b);
        }
        else
        {
                int i;
                prop->GetPropertyValue(i);
                Buf.printf("%d", i);

        }
        AddXMLAttribute(propData,_T("value"),Buf.data());

        if(prop->IsPropAnimated() && exportControllers)
        {
                IGameControl * c = prop->GetIGameControl();
                CreateXMLNode(pXMLDoc,propData,_T("PropKeyData"),&keyNode);


                if(prop->GetType() == IGAME_POINT3_PROP)
                {
                        if(     c->GetBezierKeys(keys,IGAME_POINT3 )){
                                DumpBezierKeys(IGAME_POINT3,keys,keyNode);
                        }
                }
                if(prop->GetType()==IGAME_FLOAT_PROP)
                {
                        if(     c->GetBezierKeys(keys,IGAME_FLOAT )){
                                DumpBezierKeys(IGAME_FLOAT,keys,keyNode);
                        }
                }
        }
        propData = NULL;
        keyNode = NULL;
}       


void IGameExporter::DumpTexture(CComPtr<IXMLDOMNode> node,IGameMaterial * mat)
{
        CComPtr <IXMLDOMNode> textureRoot;
        TSTR buf;
        int texCount = mat->GetNumberOfTextureMaps();

        if(texCount>0)
        {
                CreateXMLNode(pXMLDoc,node,_T("TextureMaps"),&textureRoot);
                buf.printf("%d",texCount);
                AddXMLAttribute(textureRoot,_T("Count"),buf.data());
        }
        
        for(int i=0;i<texCount;i++)
        {
                CComPtr <IXMLDOMNode> texture;
                IGameTextureMap * tex = mat->GetIGameTextureMap(i);
                CreateXMLNode(pXMLDoc,textureRoot,_T("Texture"),&texture);
                buf.printf("%d",i);
                AddXMLAttribute(texture,_T("index"),buf.data());
                TCHAR * name = tex->GetTextureName();
                AddXMLAttribute(texture,_T("name"),name);
                int slot = tex->GetStdMapSlot();
                buf.printf("%d",slot);
                AddXMLAttribute(texture,_T("StdSlotType"),buf.data());

                if(tex->IsEntitySupported())    //its a bitmap texture
                {
                        CComPtr <IXMLDOMNode> bitmapTexture;
                        CreateXMLNode(pXMLDoc,texture,_T("BitmapTexture"),&bitmapTexture);

                        CComPtr <IXMLDOMNode> bitmapName;
                        CreateXMLNode(pXMLDoc,bitmapTexture,_T("Name"),&bitmapName);
                        AddXMLText(pXMLDoc,bitmapName,tex->GetBitmapFileName());

                        IGameProperty * prop = tex->GetClipHData();
                        DumpProperties(bitmapTexture,prop);

                        prop = tex->GetClipUData();
                        DumpProperties(bitmapTexture,prop);

                        prop = tex->GetClipVData();
                        DumpProperties(bitmapTexture,prop);

                        prop = tex->GetClipWData();
                        DumpProperties(bitmapTexture,prop);

                }

        }

}

void IGameExporter::DumpMaterial(CComPtr<IXMLDOMNode> node,IGameMaterial * mat, int index, int matID )
{
        TSTR buf;
        IGameProperty *prop;
        CComPtr <IXMLDOMNode> material;
        CComPtr <IXMLDOMNode> propNode;

        CreateXMLNode(pXMLDoc,node,_T("Material"),&material);
        buf.printf("%d",index);
        AddXMLAttribute(material,_T("index"),buf.data());
        
        if(matID !=-1)  // we are not a sub material
        {
                buf.printf("%d",matID);
                AddXMLAttribute(material,_T("MaterialID"),buf.data());
        }

        AddXMLAttribute(material,_T("Name"),mat->GetMaterialName());
        CComPtr <IXMLDOMNode> matData;
        CreateXMLNode(pXMLDoc,material,_T("NumSubMtls"),&matData);
        buf.printf("%d",mat->GetSubMaterialCount());
        AddXMLText(pXMLDoc,matData,buf.data());

        //WE ONLY WANT THE PROPERTIES OF THE ACTUAL MATERIAL NOT THE CONTAINER - FOR NOW.....
        if(!mat->IsMultiType())
        {
                CreateXMLNode(pXMLDoc,material,_T("Properties"),&propNode);
                prop = mat->GetDiffuseData();
                DumpProperties(propNode,prop);
                prop = mat->GetAmbientData();
                DumpProperties(propNode,prop);
                prop = mat->GetSpecularData();
                DumpProperties(propNode,prop);
                prop = mat->GetOpacityData();
                DumpProperties(propNode,prop);
                prop = mat->GetGlossinessData();
                DumpProperties(propNode,prop);
                prop = mat->GetSpecularLevelData();
                DumpProperties(propNode,prop);
        }

        //do the textures if they are there

        DumpTexture(material,mat);

        if(mat->IsMultiType())
        {
                CComPtr <IXMLDOMNode> multi;
                CreateXMLNode(pXMLDoc,material,_T("MultiMaterial"),&multi);
                for(int k=0;k<mat->GetSubMaterialCount();k++)
                {
                        int mID = mat->GetMaterialID(k);
                        IGameMaterial * subMat = mat->GetSubMaterial(k);
                        DumpMaterial(multi,subMat,k, mID);
                }
        }
        
}

void IGameExporter::ExportMaterials()
{
        CComPtr <IXMLDOMNode> matNode;
        TSTR buf;
        if(exportMaterials)
        {
        
                CreateXMLNode(pXMLDoc,iGameNode,_T("MaterialList"),&matNode);
                int matCount = pIgame->GetRootMaterialCount();
                buf.printf("%d",matCount);
                AddXMLAttribute(matNode,_T("Count"),buf.data());

                for(int j =0;j<matCount;j++)
                {
                        IGameMaterial * mat = pIgame->GetRootMaterial(j);
                        if(mat)
                                DumpMaterial(matNode,mat,j);
                }
        }
}

// Dummy function for progress bar
DWORD WINAPI fn(LPVOID arg)
{
        return(0);
}



class MyErrorProc : public IGameErrorCallBack
{
public:
        void ErrorProc(IGameError error)
        {
                TCHAR * buf = GetLastIGameErrorText();
                DebugPrint("ErrorCode = %d ErrorText = %s\n", error,buf);
        }
};


int     IGameExporter::DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts, DWORD options)
{       
        outfile = fopen(name,_T("w"));
        Interface * ip = GetCOREInterface();

        MyErrorProc pErrorProc;

        SetErrorCallBack(&pErrorProc);

        curNode = 0;
        ip->ProgressStart(_T("Exporting Using IGame.."), TRUE, fn, NULL);
        
        pIgame = GetIGameInterface();

        IGameConversionManager * cm = GetConversionManager();
//      cm->SetUserCoordSystem(Whacky);
        cm->SetCoordSystem(IGameConversionManager::IGAME_OGL);
//      pIgame->SetPropertyFile(_T("hello world"));
        pIgame->InitialiseIGame(false);
        
//      TSTR path,file,ext;
        
//      ExportSceneInfo();
//      ExportMaterials();


        skel = NULL;
        mesh = NULL;
        skin = NULL;

        for(int loop = 0; loop < pIgame->GetTopLevelNodeCount();loop++)
        {
                IGameNode * pGameNode = pIgame->GetTopLevelNode(loop);
                //check for selected state - we deal with targets in the light/camera section
                if(pGameNode->IsTarget())
                        continue;
                ExportChildNodeInfo(pGameNode);

        }
        if(skel)
        {
                fprintf(outfile,"numbones %d\n", numBones = RecursiveChildCount(skel,0));
                fprintf(outfile,"scale 0.0533\n");
                currBone = 0;
                boneIndices = new int[numBones];
                ExportSkeleton(skel);
        }
        if(mesh)
        {
                ExportMesh();
        }
        if(skel)
        {
                ExportAnimation();
        }

        pIgame->ReleaseIGame();
        ip->ProgressEnd();
        fclose(outfile);
        return TRUE;
}


TSTR IGameExporter::GetCfgFilename()
{
        TSTR filename;
        
        filename += GetCOREInterface()->GetDir(APP_PLUGCFG_DIR);
        filename += "\\";
        filename += "IgameExport.cfg";
        return filename;
}

// NOTE: Update anytime the CFG file changes
#define CFG_VERSION 0x03

BOOL IGameExporter::ReadConfig()
{
        TSTR filename = GetCfgFilename();
        FILE* cfgStream;

        cfgStream = fopen(filename, "rb");
        if (!cfgStream)
                return FALSE;
        
        exportGeom = fgetc(cfgStream);
        exportNormals = fgetc(cfgStream);
        exportControllers = fgetc(cfgStream);
        exportFaceSmgp = fgetc(cfgStream);
        exportVertexColor = fgetc(cfgStream);
        exportTexCoords = fgetc(cfgStream);
        staticFrame = _getw(cfgStream);
        framePerSample = _getw(cfgStream);
        exportMappingChannel = fgetc(cfgStream);
        exportMaterials = fgetc(cfgStream);
        exportSplines = fgetc(cfgStream);
        exportModifiers = fgetc(cfgStream);
        forceSample = fgetc(cfgStream);
        exportConstraints = fgetc(cfgStream);
        exportSkin = fgetc(cfgStream);
        exportGenMod = fgetc(cfgStream);
        cS = fgetc(cfgStream);
        splitFile = fgetc(cfgStream);
        exportQuaternions = fgetc(cfgStream);
        exportObjectSpace = fgetc(cfgStream);
        exportRelative = fgetc(cfgStream);
        exportNormalsPerFace = fgetc(cfgStream);
        fclose(cfgStream);
        return TRUE;
}

void IGameExporter::WriteConfig()
{
        TSTR filename = GetCfgFilename();
        FILE* cfgStream;

        cfgStream = fopen(filename, "wb");
        if (!cfgStream)
                return;

        
        fputc(exportGeom,cfgStream);
        fputc(exportNormals,cfgStream);
        fputc(exportControllers,cfgStream);
        fputc(exportFaceSmgp,cfgStream);
        fputc(exportVertexColor,cfgStream);
        fputc(exportTexCoords,cfgStream);
        _putw(staticFrame,cfgStream);
        _putw(framePerSample,cfgStream);
        fputc(exportMappingChannel,cfgStream);
        fputc(exportMaterials,cfgStream);
        fputc(exportSplines,cfgStream);
        fputc(exportModifiers,cfgStream);
        fputc(forceSample,cfgStream);
        fputc(exportConstraints,cfgStream);
        fputc(exportSkin,cfgStream);
        fputc(exportGenMod,cfgStream);
        fputc(cS,cfgStream);
        fputc(splitFile,cfgStream);
        fputc(exportQuaternions,cfgStream);
        fputc(exportObjectSpace,cfgStream);
        fputc(exportRelative,cfgStream);
        fputc(exportNormalsPerFace, cfgStream);
        fclose(cfgStream);
}

---