anonymous

// mesh.cpp

#include "engine.h"
#include "dxhierarchy.h"

void ANIMATION::Load(const char* file){
    MeshHierarchy alloc;
    D3DXLoadMeshHierarchyFromX(file, D3DXMESH_MANAGED, ENGINE::dxdev, &alloc, 0, &root, &ctrl);

    firstmesh = 0;
    iBone = 0;

    SetupBones((Frame*)root, 0);
    matBone = new D3DXMATRIX[iBone];
    memset(matBone, 0, sizeof(D3DXMATRIX)*iBone);
}

void ANIMATION::Play(float elapsedTime, ANIMATION::INSTANCE* inst){
    D3DXMATRIX matWorld;
    ENGINE::effect->e->GetMatrix("matWorld", &matWorld);
    if(inst->ctrl) inst->ctrl->AdvanceTime(elapsedTime, 0);
    UpdateFrames(root, &matWorld);

    MeshContainer* mesh = firstmesh;
    if(mesh && mesh->pSkinInfo){
        unsigned Bones = mesh->pSkinInfo->GetNumBones();

        for (unsigned i = 0; i < Bones; ++i) D3DXMatrixMultiply(&matBone[i],&mesh->boneoff[i], mesh->matCombined[i]);

        void *srcPtr = 0, *destPtr = 0;
        mesh->MeshData.pMesh->LockVertexBuffer(D3DLOCK_READONLY, (void**)&srcPtr);
        mesh->mesh->LockVertexBuffer(0, (void**)&destPtr);

        mesh->pSkinInfo->UpdateSkinnedMesh(matBone, 0, srcPtr, destPtr);

        mesh->mesh->UnlockVertexBuffer();
        mesh->MeshData.pMesh->UnlockVertexBuffer();
    }
}

void ANIMATION::Draw(){
    DrawFrame(root);
}

void ANIMATION::Release(){
    ctrl->Release();
    MeshHierarchy alloc;
    D3DXFrameDestroy(root, &alloc);
    delete []matBone;
}

void ANIMATION::SetupBones(Frame *frame, D3DXMATRIX* matParent){
    MeshContainer* mesh = (MeshContainer*)frame->pMeshContainer;

    if(mesh){
        if(!firstmesh) firstmesh = mesh;

        if(mesh->pSkinInfo && mesh->MeshData.pMesh){
            D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE];
            mesh->MeshData.pMesh->GetDeclaration(Declaration);

            mesh->MeshData.pMesh->CloneMesh(D3DXMESH_MANAGED, Declaration, ENGINE::dxdev, &mesh->mesh);
            iBone = max(iBone, (int)mesh->pSkinInfo->GetNumBones());

            for(unsigned i = 0; i < mesh->pSkinInfo->GetNumBones(); i++){
                Frame* tframe = (Frame*)D3DXFrameFind(root, mesh->pSkinInfo->GetBoneName(i));
                mesh->matCombined[i] = &tframe->matCombined;
            }

        }
    }
    if(frame->pFrameSibling) SetupBones((Frame*)frame->pFrameSibling, matParent);
    if(frame->pFrameFirstChild) SetupBones((Frame*)frame->pFrameFirstChild, &frame->matCombined);
}

void ANIMATION::UpdateFrames(const D3DXFRAME *frame, const D3DXMATRIX *matParent){
    Frame* cframe = (Frame*)frame;

    if(matParent) D3DXMatrixMultiply(&cframe->matCombined, &cframe->TransformationMatrix, matParent);
    else cframe->matCombined = cframe->TransformationMatrix;

    if (cframe->pFrameSibling) UpdateFrames(cframe->pFrameSibling, matParent);
    if (cframe->pFrameFirstChild) UpdateFrames(cframe->pFrameFirstChild, &cframe->matCombined);
}


void ANIMATION::DrawMeshContainer(D3DXMESHCONTAINER* inmesh, D3DXFRAME* inframe){
    Frame* frame = (Frame*)inframe;
    MeshContainer* mesh = (MeshContainer*)inmesh;

    ENGINE::effect->e->SetMatrix("matWorld", &frame->matCombined);

    for(unsigned i = 0; i < mesh->NumMaterials; i++){
        ENGINE::dxdev->SetMaterial(&mesh->mat[i]);
        ENGINE::dxdev->SetTexture(0, mesh->tex[i]);

        ENGINE::effect->Begin();
        if(mesh->pSkinInfo) mesh->mesh->DrawSubset(i);
        else mesh->MeshData.pMesh->DrawSubset(i);
        ENGINE::effect->End();
    }
}

void ANIMATION::DrawFrame(D3DXFRAME* frame){
    D3DXMESHCONTAINER* mesh = frame->pMeshContainer;
    while(mesh){
        DrawMeshContainer(mesh, frame);
        mesh = mesh->pNextMeshContainer;
    }
    if (frame->pFrameSibling) DrawFrame(frame->pFrameSibling);
    if (frame->pFrameFirstChild) DrawFrame(frame->pFrameFirstChild);
}

ANIMATION::INSTANCE::INSTANCE(){
    ctrl = 0; track = 0;
}

void ANIMATION::INSTANCE::Create(ANIMATION* a){
    a->ctrl->CloneAnimationController(a->ctrl->GetMaxNumAnimationOutputs(), a->ctrl->GetMaxNumAnimationSets(),
        a->ctrl->GetMaxNumTracks(), a->ctrl->GetMaxNumEvents(), &ctrl);
    track = 0;
}
void ANIMATION::INSTANCE::ChangeSet(DWORD index){
    if(ctrl == 0) return;
    if(index >= ctrl->GetMaxNumAnimationSets()) index = 0;

    LPD3DXANIMATIONSET set;
    ctrl->GetAnimationSet(index, &set);
    ctrl->SetTrackAnimationSet(track, set);
    set->Release();
}