MercuryLoadableModel.cpp

Go to the documentation of this file.

#include "MercuryShapes.h"
#include "MercuryLoadableModel.h"
#include "MercuryPoly.h"
#include "MercuryLog.h"


void MercuryLoadableModel::Update( const float dTime )
{
    static MQuaternion NoRot( 1,0,0,0 );
    unsigned i;

    //First, run through and update where all the animations are on their cycle.
    for ( i = 0; i < m_vAnimationInfos.size(); ++i )
        m_vAnimationInfos[i].fPlace += dTime * m_vAnimationInfos[i].fRate;

    for ( i = 0; i < m_vBones.size(); ++i )
    {
        if ( m_vAnimationInfos.empty() )
            ResetBoneMatrix( i );
        else
        {
            //Generate all info for the bone.
            MercuryPoint Pos;
            MQuaternion Rot;

            Pos = m_vBones[i].Pos;
            Rot = m_vBones[i].Rot;

            float fTotalPercent = 0;
            
            for ( unsigned j = 0; j < m_vAnimationInfos.size(); ++j )
            {
                float fPercent = m_vAnimationInfos[j].fPercent;
                fTotalPercent += fPercent;
                float fPlace = m_vAnimationInfos[j].fPlace;
                float fStart, fEnd;
                bool bHadToForceExit = false;

                MLBoneAnimation * pMLP = m_vBones[i].m_mAnimations.get( m_vAnimationInfos[j].sAnimationName );

                if( !pMLP )
                    continue;

                bool bDoTween = false;
                float fTweenLocation;
                MVector<MLAnimationKey> * pAnim = &pMLP->vKeys;

                int iStartPlace = pMLP->iCurrentPlace;
                int iEndPlace;


                //Tricky: When we're over the current animation's end, 
                //  we have to start over at the beginning.
                //  if we've gone multiple animations without a cycle, don't screw up!
                // NOTE: This has to be run in its own if statement because the next one
                //  may or may not be run depending on what goes on here.
                float fDuration = pMLP->fAnimationLength;
                if ( pMLP->vKeys.size() != 0 && m_vAnimationInfos[j].bRunning )
                {
                    while( fDuration < fPlace )
                    {
                        fPlace = fPlace - fDuration;
                        if( !m_vAnimationInfos[j].bLoop )
                            m_vAnimationInfos[j].bRunning = false;
                    }
                }

                
                if ( pMLP->vKeys.size() != 0 && m_vAnimationInfos[j].bRunning )
                {

                    //Next, see where to start and end the tweening.
                    int iKeyMax = pMLP->vKeys.size();

                    //We keep the original start, just so we know if we'll get stuck in the loop that's comming up
                    int iOriginalStart = iStartPlace;

                    //iEndPlace is the logical next place after iStartPlace.
                    iEndPlace = ( iStartPlace + 1 )%iKeyMax;

                    while (!( (*pAnim)[iStartPlace].fSeconds < fPlace  && (*pAnim)[iEndPlace].fSeconds >= fPlace ))
                    {
                        iStartPlace = ( iStartPlace + 1 )%iKeyMax;
                        iEndPlace = ( iStartPlace + 1 )%iKeyMax;

                        //Something's pretty wrong if this happens...
                        if ( iStartPlace == iOriginalStart )
                        {
                            bHadToForceExit = true;
                            break;
                        }
                    }

                    if ( !bHadToForceExit )
                    {
                        //End place could be the beginning, after the start.
                        iEndPlace = ( iStartPlace + 1 )%iKeyMax;
                        pMLP->iCurrentPlace = iStartPlace;

                        //Now we've located the start and end places.
                        fStart = (*pAnim)[iStartPlace].fSeconds;
                        fEnd = (*pAnim)[iEndPlace].fSeconds;

                        if ( fEnd < fStart )
                            fEnd+=fDuration;

                        fTweenLocation = ( fPlace-fStart ) / ( fEnd-fStart );
                    } else
                        fTweenLocation = 0;

                    m_vAnimationInfos[j].fPlace = fPlace;
                    bDoTween = true;
                }

                if ( bDoTween )
                {
                    if ( !m_vAnimationInfos[j].bLoop )
                    {
                        //Hmm... we need to figure out a way to smoothly tween back to the nothing
                        //state by using fPercent.  How to do it, I'm not sure yet.
                        if ( iStartPlace == 0 )
                            fPercent = fTweenLocation;
                        if ( iEndPlace == (int)pMLP->vKeys.size() - 1 )
                            fPercent = ( 1-fTweenLocation );
                    }

                    Pos += (*pAnim)[iStartPlace].Pos * fPercent * (1-fTweenLocation);
                    Pos += (*pAnim)[iEndPlace].Pos * fPercent * fTweenLocation;
                    Rot = Rot * SLERP( 
                        NoRot,
                        SLERP( (*pAnim)[iStartPlace].Rot, (*pAnim)[iEndPlace].Rot, fTweenLocation ),
                        fPercent );
                }
            }
            
            MakeBoneMatrix( i, Pos, Rot );
        }

        MercuryPoint out;
        VectorMultiply( m_vBones[i].mXF, gpZero, out );

        for ( unsigned int iVert = 0; iVert < m_vBones[i].m_vDissassembledVerts.size(); iVert++ )
        {
            //Ok, this is kind of a nasty line. 
            //We take the completed bone matrix, and input the disassembled position
            //The output goes into the packet vert's x,y, and z directly.
            if (  m_vBones[i].mXF, m_vBones[i].m_vDissassembledVerts[iVert].fPercent > 0.5 )
                VectorMultiply( m_vBones[i].mXF, m_vBones[i].m_vDissassembledVerts[iVert].pos, 
                    m_meshes[ m_vBones[i].m_vDissassembledVerts[iVert].iMappedMesh ]->
                    GetVertex(m_vBones[i].m_vDissassembledVerts[iVert].iMappedVert)->GetPointHandle() );
        }

//      m_vVisualJoints[i]->SetPosition( out );

        if ( m_vBones[i].iExclusiveMesh != -1 )
        {
            m_meshes[m_vBones[i].iExclusiveMesh]->SetRotationMode( RM_MATRIX );
            m_meshes[m_vBones[i].iExclusiveMesh]->SetPosition( MercuryPoint( 0,0,0 ) );
            m_meshes[m_vBones[i].iExclusiveMesh]->SetAfterMatrix( m_vBones[i].mXF.Ptr() );
        }
    }

    for ( i = 0; i < m_meshes.size(); ++i )
        if ( m_meshes[i]->IsAnimated() )
            m_meshes[i]->CalculateVertexNormals();

    MercuryModel::Update( dTime );
}

void MercuryLoadableModel::LoadModel()
{
    int sType;
    unsigned int i;
    unsigned int iVersion;
    unsigned int iNumMeshes;
    unsigned int iNumBones;
    unsigned int iNumAnimations;
    unsigned int iNumMaterials;

    m_file->Read( &sType, 4 );
    TO_ENDIAN(sType);
    if (sType != 0x464d424d)
    {
        LOG.Warn(ssprintf( "%s is not a valid HGMDL file. It has headder %08X", m_file->GetName().c_str(),sType));
        return;
    }

    m_file->Read( &iVersion, 4 );
    TO_ENDIAN(iVersion);

    m_file->Read( &iNumMeshes, 4 );
    TO_ENDIAN(iNumMeshes);

    m_meshes.resize( 0 );
    m_vMeshMaterialAssignments.resize( iNumMeshes );
    for ( i = 0; i < iNumMeshes; ++i )
    {
        LoadMesh( i );
        m_meshes[i]->CalculateVertexNormals();
        m_meshes[i]->BuildVBO();
    }

    m_file->Read( &iNumBones, 4 );
    TO_ENDIAN(iNumBones);
//  m_vVisualJoints.resize( iNumBones );
    m_vBones.resize( iNumBones );
    for ( i = 0; i < iNumBones; ++i )
        LoadBone( i );

    m_file->Read( &iNumAnimations, 4 );
    TO_ENDIAN(iNumAnimations);
    for ( i = 0; i < iNumAnimations; ++i )
        LoadAnimation( i );

    m_file->Read( &iNumMaterials, 4 );
    TO_ENDIAN(iNumMaterials);
    m_materials.resize( iNumMaterials );
    for ( i = 0; i < iNumMaterials; ++i )
        LoadMaterial( i );

    //Set up materials
    for( i = 0; i < iNumMeshes; ++i )
        if( m_vMeshMaterialAssignments[i] >= 0 )
            m_meshes[i]->SetMaterial( m_materials[m_vMeshMaterialAssignments[i]] );

    m_vMeshMaterialAssignments.resize(0);
    SAFE_DELETE( m_file );
}

bool MercuryLoadableModel::LoadMesh( int iMesh )
{
    unsigned int    iNameLen;
    char *          sName;
    unsigned int    iNumVerts;
    unsigned int    iNumStrips;
    unsigned int    iNumFans;
    unsigned int    iNumTriangles;
    bool            bCache;
    unsigned int    i;

    m_file->Read( &iNameLen, 4 );
    TO_ENDIAN(iNameLen);
    sName = new char[iNameLen+1];
    m_file->Read( sName, iNameLen );
    sName[iNameLen] = 0; //Null terminate

    MString sFullName = GetName() + sName + ssprintf("%d", iMesh);
    SAFE_DELETE(sName);

    m_file->Read( &iNumVerts, 4 );
    TO_ENDIAN(iNumVerts);
    m_file->Read( &iNumStrips, 4 );
    TO_ENDIAN(iNumStrips);
    m_file->Read( &iNumFans, 4 );
    TO_ENDIAN(iNumFans);
    m_file->Read( &iNumTriangles, 4 );
    TO_ENDIAN(iNumTriangles);
    m_file->Read( &m_vMeshMaterialAssignments[iMesh], 4 );
    TO_ENDIAN(m_vMeshMaterialAssignments[iMesh]);
    m_file->Read( &bCache, 1 );

    MercuryMesh * m = new MercuryMesh;
    if( MESHMAN.RegMesh( m, sFullName, bCache ) )
    {
//      AddMesh( m );
//      return true;
    }

    m->SetIsAnimated( !( bCache || m_vMeshMaterialAssignments[iMesh] == 0 ));
    m->ToggleUseVBOs( bCache );

    m->SetNumVertices(iNumVerts);

    //Tricky! Looks like we're doing something really nasty here, however we're doing
    //something equivelant to &something[0], to acquire the address of all of the data
    m_file->Read( m->GetVerticePtr(), iNumVerts * 32 );

    for( i = 0; i < m->NumVertices(); ++i )
    {
        TO_ENDIAN( *( (unsigned*) & (*m)[i].x ) );
        TO_ENDIAN( *( (unsigned*) & (*m)[i].y ) );
        TO_ENDIAN( *( (unsigned*) & (*m)[i].z ) );
        TO_ENDIAN( *( (unsigned*) & (*m)[i].m_uv[0] ) );
        TO_ENDIAN( *( (unsigned*) & (*m)[i].m_uv[1] ) );

        if( m_fVisRadius < (*m)[i].GetPointHandle().Magnitude() )
            m_fVisRadius = (*m)[i].GetPointHandle().Magnitude();
    }

    for ( i = 0; i < iNumStrips; ++i)
    {
        unsigned int length;
        m_file->Read( &length, 4 );
        TO_ENDIAN( length );
        m->SetDrawType(MGL_STRIP);
        m->SetNumIndices( length );
        m_file->Read( m->GetIndicesPtr(), length*4 );
        for( unsigned j = 0; j < length; j++ )
            TO_ENDIAN( m->GetIndicesPtr()[j] );
    }

    for ( i = 0; i < iNumFans; ++i)
    {
        unsigned int length;
        m_file->Read( &length, 4 );
        TO_ENDIAN( length );
        m->SetDrawType(MGL_FAN);
        m->SetNumIndices( length );
        m_file->Read( m->GetIndicesPtr(), length*4 );
        for( unsigned j = 0; j < length; j++ )
            TO_ENDIAN( m->GetIndicesPtr()[j] );
    }

    if ( iNumTriangles > 0)
    {
        m->SetDrawType(MGL_TRIANGLE);
        m->SetNumIndices( iNumTriangles*3 );
        m_file->Read( m->GetIndicesPtr(), m->NumIndices()*4 );
        for( unsigned j = 0; j < m->NumIndices(); j++ )
            TO_ENDIAN( m->GetIndicesPtr()[j] );
    }

    if ( iNumStrips != 0 || iNumFans != 0 )
        LOG.Warn( "Cannot load model.  Model has fans and strips.  They are not yet supported." );


    AddMesh( m );
    return true;
}

void MercuryLoadableModel::LoadBone( int iBone )
{
//  bool bHide = false;
    unsigned int iTmp;
    unsigned i;
    m_file->Read( &iTmp, 4 );
    TO_ENDIAN( iTmp );
    char * sName = new char[iTmp+1];
    m_file->Read( sName, iTmp );
    sName[iTmp] = 0;

    m_file->Read( &m_vBones[iBone].iParent, 4 );
    TO_ENDIAN( m_vBones[iBone].iParent );
    m_file->Read( &m_vBones[iBone].iExclusiveMesh, 4 );
    TO_ENDIAN( m_vBones[iBone].iExclusiveMesh );
    m_file->Read( &m_vBones[iBone].Pos, 4 * 3 );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Pos.x ) );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Pos.y ) );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Pos.z ) );
    m_file->Read( &m_vBones[iBone].Rot, 4 * 4 );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Rot.w ) );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Rot.x ) );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Rot.y ) );
    TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].Rot.z ) );
    m_file->Read( &iTmp, 4 );
    TO_ENDIAN( iTmp );

    ResetBoneMatrix( iBone );

    //We now have the bone's xform matrix

    m_vBones[iBone].m_vDissassembledVerts.resize( iTmp );

    for ( i = 0; i < iTmp; i++ )
    {
        MLQVert * tVert = &m_vBones[iBone].m_vDissassembledVerts[i];
        m_file->Read( &tVert->iMappedMesh, 4 );
        TO_ENDIAN( tVert->iMappedMesh );
        m_file->Read( &tVert->iMappedVert, 4 );
        TO_ENDIAN( tVert->iMappedVert );
        m_file->Read( &tVert->fPercent, 4 );
        TO_ENDIAN( *( (unsigned*) & (tVert->fPercent) ) );

        MercuryPoint G = m_meshes[tVert->iMappedMesh]->GetVertex(tVert->iMappedVert)->GetPointHandle();
        MercuryMatrix P;
        InvertMatrix( m_vBones[iBone].mXF, P );

        VectorMultiply( P, G, tVert->pos );
    }

    SAFE_DELETE(sName);

/*  m_vVisualJoints[iBone] = new MercuryShape;
    m_vVisualJoints[iBone]->SetName( ssprintf( "BONE:%s:%d", GetName().c_str(), iBone ) );
    m_vVisualJoints[iBone]->MakeSphere();
    m_vVisualJoints[iBone]->SetScale( MercuryPoint( 20,20,20 ) );
    m_vVisualJoints[iBone]->SetHide( true );
    AddObject( m_vVisualJoints[iBone], true );*/
}

void MercuryLoadableModel::LoadAnimation( int iAnimation )
{
    unsigned int    iTmp = 0;
    unsigned int    iNumBones = 0;
    char *          sAnimationName;
    float           fDuration = 0.0f;
    m_file->Read( &iTmp, 4 );
    TO_ENDIAN( iTmp );
    sAnimationName = new char [iTmp + 1];
    m_file->Read( sAnimationName, iTmp );
    sAnimationName[iTmp] = '\0';

    m_file->Read( &fDuration,4);
    TO_ENDIAN( *( (unsigned*) & (fDuration) ) );
    m_file->Read( &iNumBones, 4 );
    TO_ENDIAN( iNumBones );
    
    for ( unsigned int i = 0; i < iNumBones; ++i )
    {
        int iBone;
        int iNumKeys;
        m_file->Read( &iBone, 4 );
        TO_ENDIAN( iBone );
        m_file->Read( &iNumKeys, 4 );
        TO_ENDIAN( iNumKeys );

        m_vBones[iBone].m_mAnimations[sAnimationName].fAnimationLength = fDuration;
        m_vBones[iBone].m_mAnimations[sAnimationName].vKeys.resize( iNumKeys );
        m_vBones[iBone].m_mAnimations[sAnimationName].iCurrentPlace = 0;

        for ( int j = 0; j < iNumKeys; ++j )
        {
            m_file->Read( &m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].fSeconds, 4 );
            m_file->Read( &m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Pos, 4 * 3 );
            m_file->Read( &m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Rot, 4 * 4 );
            TO_ENDIAN( *( (unsigned*) & (m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].fSeconds) ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Pos.x ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Pos.y ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Pos.z ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Rot.w ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Rot.x ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Rot.y ) );
            TO_ENDIAN( *( (unsigned*) & m_vBones[iBone].m_mAnimations[sAnimationName].vKeys[j].Rot.z ) );
        }
    }

    SAFE_DELETE( sAnimationName );
}

void MercuryLoadableModel::LoadMaterial( int iMaterial )
{
    unsigned int    iNameLen;
    char *          sName;
    m_file->Read( &iNameLen, 4 );
    TO_ENDIAN( iNameLen );
    sName = new char[iNameLen+1];
    m_file->Read( sName, iNameLen );
    sName[iNameLen] = 0;
    MercuryMaterial * m = new MercuryMaterial;
    m->LoadMaterial( MString( sName, iNameLen ), m_path );
    SAFE_DELETE(sName);
    m_materials[iMaterial] = m;
}



//Now, for the embedded functions

void MercuryLoadableModel::ResetBoneMatrix( int iBone )
{
    MercuryMatrix m,n,o;
    MLBone * thisbone = &m_vBones[iBone];

    (thisbone->Rot).toMatrix4( o );
    o[0][3] = thisbone->Pos.x;
    o[1][3] = thisbone->Pos.y;
    o[2][3] = thisbone->Pos.z;

    if ( thisbone->iParent >= 0 )
    {
        m = m_vBones[m_vBones[iBone].iParent].mXF * o;
        Copy16f( &thisbone->mXF, &m);
    }
    else
        Copy16f(&thisbone->mXF, &o);
}

void MercuryLoadableModel::MakeBoneMatrix( int iBone, const MercuryPoint & Pos, const MQuaternion & Rot )
{
    MercuryMatrix m,n,o;
    MLBone * thisbone = &m_vBones[iBone];

    Rot.toMatrix4( o );
    o[0][3] = Pos.x;
    o[1][3] = Pos.y;
    o[2][3] = Pos.z;

    if ( thisbone->iParent >= 0 )
    {
        m = m_vBones[m_vBones[iBone].iParent].mXF * o;
        Copy16f( &thisbone->mXF, &m );
    }
    else
        Copy16f( &thisbone->mXF, &o );
}

#include "MercuryObjectFactory.h"
REGISTER_OBJECT_TYPE( MercuryLoadableModel );


/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by