pcggui.cpp

Go to the documentation of this file.

/**********************************************************************
 *<
        FILE: pcggui.cpp

        DESCRIPTION:    Appwizard generated plugin

        CREATED BY: 

        HISTORY: 

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

#include "pcggui.h"
#include <map>

#define pcggui_CLASS_ID Class_ID(0x67910a43, 0xc56b6dbc)

static pcggui thepcggui;
static FILE     *file;

#define SKIN_INTERFACE 0x00010000
#define SKIN_CLASS_ID Class_ID(9815843,87654)
#define PHYSIQUE_CLASS_ID Class_ID(PHYSIQUE_CLASS_ID_A, PHYSIQUE_CLASS_ID_B)

typedef signed int sint32;
typedef std::map<INode*, uint> TInodePtrInt;




class pcgguiClassDesc : public ClassDesc2 {
public:
        int                     IsPublic() { return TRUE; }
        void *                  Create(BOOL loading = FALSE) { return &thepcggui; }
        const TCHAR *   ClassName() { return GetString(IDS_CLASS_NAME); }
        SClass_ID               SuperClassID() { return UTILITY_CLASS_ID; }
        Class_ID                ClassID() { return pcggui_CLASS_ID; }
        const TCHAR*    Category() { return GetString(IDS_CATEGORY); }

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


};

static pcgguiClassDesc pcgguiDesc;
ClassDesc2* GetpcgguiDesc() { return &pcgguiDesc; }




static BOOL CALLBACK pcgguiDlgProc(
                HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch (msg) {
                case WM_INITDIALOG:
                        thepcggui.Init(hWnd);
                        break;

                case WM_DESTROY:
                        thepcggui.Destroy(hWnd);
                        break;

                case WM_COMMAND:
                        switch(LOWORD(wParam)) { //switch on ID
                                case IDC_BUTTON_CONVERT: // A specific button's ID.
                                        thepcggui.CovertScene();
                                        break;

                                case IDC_REFERENCE_MODEL:
                                        thepcggui.SetReferenceModelMode(IsDlgButtonChecked(hWnd, IDC_REFERENCE_MODEL));
                                        break;

                                case IDC_BUTTON_EXPORT:
                                        thepcggui.ExportAll();
                                        break;

                                case IDC_BUTTON_SAVE:
                                        thepcggui.SaveAll();
                                        break;

                                case IDC_BUTTON_LOAD:
                                        thepcggui.LoadAll();
                                        break;

                                case IDC_BUTTON_SAVE_ANALYZER:
                                        thepcggui.SaveAnalyzer();
                                        break;

                                case IDC_BUTTON_LOAD_ANALYZER:
                                        thepcggui.LoadAnalyzer();
                                        break;

                                case IDC_BUTTON_ANALYZE:
                                        thepcggui.Analyze();
                                        break;

                                case IDC_BUTTON_RENDER:
                                        thepcggui.Render();
                                        break;

                                default:
                                        break;
                        };
                        break;


                case WM_LBUTTONDOWN:
                case WM_LBUTTONUP:
                case WM_MOUSEMOVE:
                        thepcggui.ip->RollupMouseMessage(hWnd,msg,wParam,lParam); 
                        break;

                default:
                        return FALSE;
        }
        return TRUE;
}


class NullView: public View {
public:
        Point2 ViewToScreen(Point3 p) { return Point2(p.x,p.y); }
        NullView() { worldToView.IdentityMatrix(); screenW=640.0f; screenH = 480.0f; }
};


//--- pcggui -------------------------------------------------------
pcggui::pcggui()
{
        iu = NULL;
        ip = NULL;      
        hPanel = NULL;
}

pcggui::~pcggui()
{

}

void pcggui::BeginEditParams(Interface *ip,IUtil *iu) 
{
        fopen_s(&file,"c:\\testdebug.txt","w");
        fprintf(file,"");
        fclose(file);
        fopen_s(&file,"c:\\testdebug.txt","a");
        fprintf(file,"\nFile Opened\n");
        this->iu = iu;
        this->ip = ip;
        hPanel = ip->AddRollupPage(
                hInstance,
                MAKEINTRESOURCE(IDD_PANEL),
                pcgguiDlgProc,
                GetString(IDS_PARAMS),
                0);
}
        
void pcggui::EndEditParams(Interface *ip,IUtil *iu) 
{
        this->iu = NULL;
        this->ip = NULL;
        ip->DeleteRollupPage(hPanel);
        hPanel = NULL;
        fclose(file);
}

void pcggui::Init(HWND hWnd)
{
        fprintf(file,"Init\n");
}

void pcggui::Destroy(HWND hWnd)
{
        fprintf(file,"Destroy\n");
}

void pcggui::CovertScene() {
        model::ExampleModel* em = new model::ExampleModel();
        model::ReferenceModel* rm = new model::ReferenceModel();
        TimeValue currtime = thepcggui.ip->GetTime();
        INode* node;
        BOOL needDel;
        NullView nullView;
        unsigned long offset = 0;
        unsigned long tmpOffset = 0;

        if(thepcggui.ip->GetRootNode()->NumberOfChildren() > 0) {
                for(int n=0;n<thepcggui.ip->GetRootNode()->NumberOfChildren();n++) {

                        node = thepcggui.ip->GetRootNode()->GetChildNode(n);
                        ObjectState os = node->EvalWorldState(currtime);

                        // find and export modifier data if
                        // exists for this node

                        Object* pObj = node->GetObjectRef();
                        // make sure we have a derived obj, which implies
                        // modifiers are avail, and not a base obj
                        while (pObj && pObj->SuperClassID() == GEN_DERIVOB_CLASS_ID) {
                                IDerivedObject* pDerObj = (IDerivedObject*) pObj;
                                // Iterate over all entries of the modifier stack.
                                for (int Idx = 0; Idx < pDerObj->NumModifiers(); Idx++) {
                                        Modifier* mod = pDerObj->GetModifier(Idx);
                                        DebugPrint("Mod Name: %s\n",mod->GetName());
                                        DebugPrint("Mod class ID: 0x%x - %d\n",mod->ClassID(),mod->ClassID());
                                        /*if(mod->ClassID() == 9845843) {
                                                DebugPrint("SKIN\n");
                                        }*/
                                        
                                        //if (mod->ClassID() == Class_ID(BENDOSM_CLASS_ID,0)) {
                                }
                                // get next object in stack -- could be base obj,
                                // or another derived obj
                                pObj = pDerObj->GetObjRef();
                        }


                        if(os.obj->SuperClassID()==GEOMOBJECT_CLASS_ID) {
                                if(node->GetBoneNodeOnOff()) {
                                        if(refModel) {
                                                ConvertBone(node,rm);
                                        }
                                } else {
                                        Mesh *mesh = ((GeomObject*)os.obj)->GetRenderMesh(thepcggui.ip->GetTime(),node,nullView,needDel);
                                        if (!mesh) return;

                                        mesh->buildNormals();
                                        Matrix3 tm = node->GetObjTMAfterWSM(thepcggui.ip->GetTime());
                                        for (int i=0; i<mesh->getNumVerts(); i++) {
                                                Point3 v = (tm * mesh->verts[i]);
                                                model::Vertex* vertex = new model::Vertex();
                                                vertex->setCoordinates(v.x, v.y, v.z);
                                                vertex->setNormal(mesh->getNormal(i).x,mesh->getNormal(i).y,mesh->getNormal(i).z);
                                                if(refModel) {
                                                        rm->addVertex(vertex);
                                                } else {
                                                        em->addVertex(vertex);
                                                }
                                                tmpOffset = i;
                                        }
                                        for (int i=0; i<mesh->getNumFaces(); i++) {
                                                model::Face* face = new model::Face();
                                                if(refModel) {
                                                        face->setVertices(
                                                                rm->getVertex(offset + (int)mesh->faces[i].v[0]),
                                                                rm->getVertex(offset + (int)mesh->faces[i].v[1]),
                                                                rm->getVertex(offset + (int)mesh->faces[i].v[2]));
                                                        rm->addFace(face);
                                                } else {
                                                        face->setVertices(
                                                                em->getVertex(offset + (int)mesh->faces[i].v[0]),
                                                                em->getVertex(offset + (int)mesh->faces[i].v[1]),
                                                                em->getVertex(offset + (int)mesh->faces[i].v[2]));
                                                        em->addFace(face);
                                                }
                                        }
                                        offset = tmpOffset;
                                }
                        }
                }
                for(int n=0;n<thepcggui.ip->GetRootNode()->NumberOfChildren();n++) {
                        node = thepcggui.ip->GetRootNode()->GetChildNode(n);
                        ObjectState os = node->EvalWorldState(currtime);
                        if(os.obj->SuperClassID()==GEOMOBJECT_CLASS_ID) {
                                if(!node->GetBoneNodeOnOff()) {
                                        if(refModel) {
                                                DebugPrint("Error Code: %d\n",ConvertSkin(node,rm));
                                        }
                                }
                        }
                }
                if(refModel) {
                        referenceModels.push_back(rm);
                } else {
                        exampleModels.push_back(em);
                }
        }
}

void pcggui::ConvertBone(INode* pParent, model::ReferenceModel* rm) {
        DebugPrint("Sub Named Object: \"%s\"\n",pParent->GetName());

        rm->getSkeleton()->addBone(NULL,NULL,10,pParent->GetName());

        for(int q=0;q<pParent->NumberOfChildren();q++) {
                ConvertBone(pParent->GetChildNode(q),rm);
        }
}

void pcggui::ExportAll() {
        functions::Exporter ex = functions::Exporter();
        char tmp[100];

        for(int i=0; i<exampleModels.size(); i++) {
                sprintf_s(tmp,"c:\\exampleModel%d.x3d",i);
                ex.exportModel(exampleModels[i],tmp);
        }

        for(int i=0; i<referenceModels.size(); i++) {
                sprintf_s(tmp,"c:\\referenceModel%d.x3d",i);
                ex.exportModel(referenceModels[i],tmp);
        }

}

void pcggui::SaveAll() {
        char tmp[100];

        for(int i=0; i<exampleModels.size(); i++) {
                sprintf_s(tmp,"c:\\savedExampleModel%d.pcg",i);
                exampleModels[i]->save(tmp);
        }

        for(int i=0; i<referenceModels.size(); i++) {
                sprintf_s(tmp,"c:\\savedReferenceModel%d.pcg",i);
                referenceModels[i]->save(tmp);
        }
}

void pcggui::LoadAll() {
        char tmp[100];
        int number = 10;

        exampleModels.clear();
        referenceModels.clear();

        for(int i=0; i<number; i++) {
                sprintf_s(tmp,"c:\\savedExampleModel%d.pcg",i);
                model::ExampleModel* em = new model::ExampleModel();
                if(em->load(tmp)) {
                        exampleModels.push_back(em);
                }
        }

        for(int i=0; i<number; i++) {
                sprintf_s(tmp,"c:\\savedReferenceModel%d.pcg",i);
                model::ReferenceModel* rm = new model::ReferenceModel();
                if(rm->load(tmp)) {
                        referenceModels.push_back(rm);
                }
        }
}

void pcggui::SaveAnalyzer() {
        pca.save("c:\\PCG-ANALYZER");
}

void pcggui::LoadAnalyzer() {
        pca.load("c:\\PCG-ANALYZER");
}

void pcggui::Analyze() {
        DebugPrint("*************Starting to Analyze*************\n");
        pca.mergeData(*referenceModels[0],exampleModels);
        DebugPrint("Calculating mean\n");
        pca.mean();
        DebugPrint("Adjusting data\n");
        pca.adjust();
        DebugPrint("Finding Covariance\n");
        pca.covariance();
        DebugPrint("Begin EigenVector calculations\n");
        DebugPrint("Timer Started\n");
        clock_t begin = clock();
        pca.findComponents(model::Analyzer::HOUSEHOLDER);
        clock_t end = clock();
        DebugPrint("Timer Stopped\n");
        DebugPrint("Time elapsed in seconds: %d\n", difftime(end, begin));
        DebugPrint("End EigenVector calculations\n");
        pca.computeEnergy();
        pca.selectComponents();
        pca.transformation();
}

void pcggui::Render() {
        Mesh mesh;
        model::ExampleModel* em = exampleModels[0];
        mesh.setNumVerts(em->getVertexs().size());
        mesh.setNumFaces(em->getFaces().size());
        for(int i=0;i<em->getVertexs().size();i++) {
                Vertex* v = em->getVertex(i);
                mesh.setVert(i,Point3(v->getCoordinates()->x,v->getCoordinates()->y,v->getCoordinates()->z));
                mesh.setNormal(i,Point3(v->getNormal()->x,v->getNormal()->y,v->getNormal()->z));
        }
        for(int i=0;i<em->getFaces().size();i++) {
                model::Face* f = em->getFace(i);
                mesh.faces[i].setVerts(f->getVertex(0)->getIndex(),f->getVertex(1)->getIndex(),f->getVertex(2)->getIndex());
        }

        //TriObject *obj = CreateNewTriObject();
        //RegisterEditTriObjDesc( GetEditTriObjDesc() );

        // Create a new object through the CreateInstance() API
        GeomObject *obj = (GeomObject*)ip->CreateInstance(GEOMOBJECT_CLASS_ID, Class_ID(BOXOBJ_CLASS_ID ,0));
        assert(obj);
        
        
        //((TriObject*)obj)->mesh = mesh;
        //RegisterEditTriObjDesc( GetTriObjDescriptor() );



        // Create a derived object that references the cylinder
        IDerivedObject *dobj = CreateDerivedObject(obj);

        // Create a node in the scene that references the derived object
        INode *node = ip->CreateObjectNode(dobj);

        // Name the node and make the name unique.
        TSTR name(_T("MyNode"));
        ip->MakeNameUnique(name);
        node->SetName(name);

        // Eval the node's object (exclude WSMs)
        Object *oldObj = node->GetObjectRef();
        ObjectState os = oldObj->Eval(ip->GetTime());

        // Set the result to be the node's new object (make a clone)
        Object *newobj = (Object*)os.obj->Clone();
        newobj->SetSubSelState(0); // Reset the selection level to object level
        oldObj->SetAFlag(A_LOCK_TARGET);
        node->SetObjectRef(newobj);
        node->NotifyDependents(FOREVER,0,REFMSG_SUBANIM_STRUCTURE_CHANGED);
        oldObj->ClearAFlag(A_LOCK_TARGET);
        oldObj->MaybeAutoDelete();


        // Redraw the viewports
        ip->RedrawViews(ip->GetTime());

}

/****************************************************************************/

// Get the first modifier in the pipeline of a node by its class identifier
Modifier* pcggui::getModifier (INode* pNode, Class_ID modCID)
{
        Object* pObj = pNode->GetObjectRef();

        if (!pObj)
                return NULL;

        ObjectState os = pNode->EvalWorldState(0);
        if (os.obj && (os.obj->SuperClassID() != GEOMOBJECT_CLASS_ID) && (os.obj->SuperClassID() != LIGHT_CLASS_ID) )
        {
                return NULL;
        }

        // For all derived objects (can be > 1)
        while (pObj && (pObj->SuperClassID() == GEN_DERIVOB_CLASS_ID))
        {
                IDerivedObject* pDObj = (IDerivedObject*)pObj;
                int m;
                int nNumMods = pDObj->NumModifiers();
                // Step through all modififers and verify the class id
                for (m=0; m<nNumMods; ++m) 
                {
                        Modifier* pMod = pDObj->GetModifier(m);
                        if (pMod) 
                        {
                                if (pMod->ClassID() == modCID) 
                                {
                                        // Match! Return it
                                        return pMod;
                                }
                        }
                }
                pObj = pDObj->GetObjRef();
        }

        return NULL;
}

uint pcggui::ConvertSkin(INode* node, model::ReferenceModel* rm) {
        // Return success
        uint ok=NoError;

        // Get the skin modifier
        Modifier* skin=getModifier (node, SKIN_CLASS_ID);

        // Found it ?
        if (skin)
        {
                // **********    COMSKIN EXPORT    **********

                // Get a com_skin2 interface
                ISkin *comSkinInterface=(ISkin*)skin->GetInterface (SKIN_INTERFACE);

                // Should been controled with isSkin before.
                assert (comSkinInterface);

                // Found com_skin2 ?
                if (comSkinInterface)
                {
                        // Get local data
                        ISkinContextData *localData=comSkinInterface->GetContextInterface(node);

                        // Should been controled with isSkin before.
                        assert (localData);

                        // Found ?
                        if (localData)
                        {
                                // Check same vertices count
                                uint vertCount=localData->GetNumPoints();


                                // For each vertex
                                for (uint vert=0; vert<vertCount; vert++)
                                {
                                        // Get bones count for this vertex
                                        uint boneCount=localData->GetNumAssignedBones (vert);

                                        // No bones, can't export
                                        if (boneCount==0)
                                        {
                                                // Error
                                                ok=VertexWithoutWeight;
                                                break;
                                        }

                                        // A map of float / string
                                        //std::multimap<float, uint> weightMap;
                                        std::map<float, uint> weightMap;

                                        // For each bones
                                        for (uint bone=0; bone<boneCount; bone++)
                                        {
                                                // Get the bone weight
                                                float weight=localData->GetBoneWeight (vert, bone);

                                                // Get bone number
                                                uint boneId=localData->GetAssignedBone (vert, bone);

                                                // Insert in the map
                                                weightMap.insert (std::map<float, uint>::value_type (weight, boneId));
                                        }

                                        // Sum the NL3D_MESH_SKINNING_MAX_MATRIX highest bones
                                        float sum=0.f;
                                        std::map<float, uint>::iterator ite=weightMap.begin();
                                        while (ite!=weightMap.end())
                                        {
                                                // Add to the sum
                                                sum+=ite->first;

                                                // Next value
                                                ite++;
                                        }

                                        // For each bones in the list, build the skin information
                                        uint id=0;
                                        ite=weightMap.end();
                                        while (ite!=weightMap.begin())
                                        {
                                                // Previous value
                                                ite--;

                                                // Get the bones ID
                                                Bone* bone = rm->getSkeleton()->getBone(comSkinInterface->GetBone(ite->second)->GetName());

                                                // Set the weight
                                                //DebugPrint("Bone: %s - Vertex: %d - %f\n",bone->getName().c_str(),vert,ite->first/sum);
                                                bone->addMapping(new model::Mapping(vert,ite->first/sum));

                                                // Next Id
                                                id++;
                                        }
                                        // Breaked ?
                                        if (ite!=weightMap.begin())
                                        {
                                                // break again to exit
                                                break;
                                        }
                                }
                        }
                }

                // Release the interface
                skin->ReleaseInterface (SKIN_INTERFACE, comSkinInterface);
        }
        /*else
        {
                // **********    PHYSIQUE EXPORT    **********

                // Physique mode
                Modifier* skin=getModifier (node, PHYSIQUE_CLASS_ID);

                // Must exist
                assert (skin);
                
                // Get a com_skin2 interface
                IPhysiqueExport *physiqueInterface=(IPhysiqueExport *)skin->GetInterface (I_PHYINTERFACE);

                // Should been controled with isSkin before.
                assert (physiqueInterface);

                // Found com_skin2 ?
                if (physiqueInterface)
                {
                        // Get local data
                        IPhyContextExport *localData=physiqueInterface->GetContextInterface(&node);

                        // Should been controled with isSkin before.
                        assert (localData);

                        // Found ?
                        if (localData)
                        {
                                // Use rigid export
                                localData->ConvertToRigid (TRUE);

                                // Allow blending
                                localData->AllowBlending (TRUE);

                                // Check same vertices count
                                uint vertCount=localData->GetNumberVertices();

                                // Ctrl we have the same number of vertices in the mesh and in the modifier.
                                if (rm->getVertexs().size()!=vertCount)
                                {
                                        ok=InvalidSkeleton;
                                }
                                else
                                {
                                        // If not the same count, return false (perhaps, the modifier is not in the good place in the stack..)
                                        if (rm->getVertexs().size()==vertCount)
                                        {
                                                // Rebuild the array
                                                buildMesh.SkinWeights.resize (vertCount);

                                                // For each vertex
                                                for (uint vert=0; vert<vertCount; vert++)
                                                {
                                                        // Get a vertex interface
                                                        IPhyVertexExport *vertexInterface=localData->GetVertexInterface (vert);

                                                        // Check if it is a rigid vertex or a blended vertex
                                                        IPhyRigidVertex                 *rigidInterface=NULL;
                                                        IPhyBlendedRigidVertex  *blendedInterface=NULL;
                                                        int type=vertexInterface->GetVertexType ();
                                                        if (type==RIGID_TYPE)
                                                        {
                                                                // this is a rigid vertex
                                                                rigidInterface=(IPhyRigidVertex*)vertexInterface;
                                                        }
                                                        else
                                                        {
                                                                // It must be a blendable vertex
                                                                assert (type==RIGID_BLENDED_TYPE);
                                                                blendedInterface=(IPhyBlendedRigidVertex*)vertexInterface;
                                                        }

                                                        // Get bones count for this vertex
                                                        uint boneCount;
                                                        if (blendedInterface)
                                                        {
                                                                // If blenvertex, only one bone
                                                                boneCount=blendedInterface->GetNumberNodes();
                                                        }
                                                        else
                                                        {
                                                                // If rigid vertex, only one bone
                                                                boneCount=1;
                                                        }

                                                        // No bones, can't export
                                                        if (boneCount==0)
                                                        {
                                                                // Error
                                                                ok=VertexWithoutWeight;
                                                                break;
                                                        }

                                                        // A map of float / string
                                                        //std::multimap<float, INode*> weightMap;
                                                        std::map<float, INode*> weightMap;

                                                        // For each bones
                                                        for (uint bone=0; bone<boneCount; bone++)
                                                        {
                                                                if (blendedInterface)
                                                                {
                                                                        // Get the bone weight
                                                                        float weight=blendedInterface->GetWeight(bone);

                                                                        // Get node
                                                                        INode *node=blendedInterface->GetNode(bone);
                                                                        assert (node);

                                                                        // Insert in the map
                                                                        weightMap.insert (std::map<float, INode*>::value_type (weight, node));
                                                                }
                                                                else
                                                                {
                                                                        // Get node
                                                                        INode *node=rigidInterface->GetNode();
                                                                        assert (node);

                                                                        // Insert in the map
                                                                        weightMap.insert (std::map<float, INode*>::value_type (1, node));
                                                                }
                                                        }

                                                        // Sum the NL3D_MESH_SKINNING_MAX_MATRIX highest bones
                                                        float sum=0.f;
                                                        std::map<float, INode*>::iterator ite=weightMap.begin();
                                                        while (ite!=weightMap.end())
                                                        {
                                                                // Add to the sum
                                                                sum+=ite->first;
                                                                
                                                                // Next value
                                                                ite++;
                                                        }

                                                        // For each bones in the list, build the skin information
                                                        uint id=0;
                                                        ite=weightMap.end();
                                                        while (ite!=weightMap.begin())
                                                        {
                                                                // Previous value
                                                                ite--;

                                                                // Get the bones ID
                                                                sint32 matrixId=-1;
                                                                TInodePtrInt::const_iterator itId=skeletonShape.find (ite->second);
                                                                if (itId!=skeletonShape.end())
                                                                        matrixId=itId->second;

                                                                // Find the bone ?
                                                                if (matrixId==-1)
                                                                {
                                                                        // no, error, wrong skeleton
                                                                        ok=InvalidSkeleton;
                                                                        break;
                                                                }

                                                                // Set the weight
                                                                buildMesh.SkinWeights[vert].MatrixId[id]=matrixId;
                                                                buildMesh.SkinWeights[vert].Weights[id]=ite->first/sum;
                                                                
                                                                // Next Id
                                                                id++;
                                                        }
                                                        
                                                        // Breaked ?
                                                        if (ite!=weightMap.begin())
                                                        {
                                                                // break again to exit
                                                                break;
                                                        }

                                                        // Release vertex interfaces
                                                        localData->ReleaseVertexInterface (vertexInterface);
                                                }
                                        }
                                }

                                // Release locaData interface
                                physiqueInterface->ReleaseContextInterface (localData);
                        }

                }

                // Release the interface
                skin->ReleaseInterface (I_PHYINTERFACE, physiqueInterface);
        }*/

        return ok;
}

---