laAnimatedModel.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. 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.
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 ATANAS LASKOV 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.

*/

//
// FILE: laAnimatedModel.cpp
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core.h"
#include "Core.h"

// Constructor
//
laAnimatedModel::laAnimatedModel(void)
{
    _arFrames = NULL;
    _nFrameCnt = 1;
    _nCrFrame  = 0;
    _dSPF      = 1.0;
    _dTimeElapsed = 0;

    _bCycle         = M_TRUE;
    _bInterpolation = M_TRUE;
    _bTraceEffect   = M_FALSE;
}

laAnimatedModel::~laAnimatedModel(void) {
    discard();
}

void laAnimatedModel::discard() {
    if(_arFrames) delete [] _arFrames;
    _arFrames = NULL;
}

bool laAnimatedModel::load(char* strFile)
{
    ERRORLEVEL_BEGIN;
    ASSERT(strnlen(strFile, 64) < 64, "Invalid file name");
    laFileParser f;
    char strFilePath[128]=M_DIR_MODEL;
    static char junk[1024];
    static char ver[128];
    static char cr[128];
    static int nverts,ntverts,nfaces;
    static double sh;
    _pCR = ::laSystemIntegrator::getRenderer();

    // Check if the requested file is a static model
    //
    if( strstr(strFile, ".jrm") )
    {
        _arFrames  = new laStaticModel[1];
        _nFrameCnt = 1;
        _nCrFrame  = 0;
        _bInterpolation = M_FALSE;

        _arFrames[0].load(strFile);
        setTexture( _arFrames[0]._nTex, _arFrames[0]._bEmissive, _arFrames[0]._nShininess);

        return true;
    }

    MLOG("Loading animated model '%s'...", strFile);

    // Open the model file
    //
    if(!_bAddDirectoryPrefix) strFilePath[0]='\0';
    strcat(strFilePath, strFile);

    try{ f.fileOpen(strFilePath); }catch(laError& ){ throw laError("Unable to open model file '%s'", strFile); }

    // General Information
    //
    try{ f.readSectionSeparator(junk); }catch(laError& ){ throw laError("Section separator expected but not found (while parsing '%s')", strFile); }
    _strupr(junk);
    if(strcmp(junk, "GENERAL INFORMATION")) throw laError("Section [GENERAL INFORMATION] expected, [%s] found ('%s')", junk, strFile);

    try{

        f.readText(ver);
        ASSERT( !strcmp(ver, "Animated JRM 1"), "Unappropriate model format '%s' (while parsing '%s')", ver, f.getFileName());

        f.readText(cr);

        f.readInt(&nverts);
        f.readInt(&ntverts, M_FALSE);
        f.readInt(&nfaces, M_FALSE);

        ASSERT( nverts && ntverts && nverts, "Corrupted file '%s'", f.getFileName());
    }
    catch( laError& ) {
        throw laError("Section [GENERAL INFORMATION] appears to be corrupted (while parsing '%s')", f.getFileName());
    }

    // Texture
    //
    try{ f.readSectionSeparator(junk); }catch( laError& ){ throw laError("Section separator expected but not found (while parsing '%s')", strFile); }
    _strupr(junk);
    ASSERT(!strcmp(junk, "TEXTURE"), "Section [TEXTURE] expected, [%s] found ('%s')", junk, strFile);

    try{
        f.readText(_strTex);
        f.readBool(&_bEmissive);
        f.readDouble(&sh);

        _nShininess = (unsigned) (sh*100);
    }
    catch(laError& ) {
        throw laError("Section [TEXTURE] appears to be corrupted (while parsing '%s')", f.getFileName());
    }

    _nTex.load(_strTex);
    //if(!_nTex.id) throw laError("Texture map '%s' is corrupted or missing", _strTex);

    // Animation
    //
    try{ f.readSectionSeparator(junk); }catch(laError& ){ throw laError("Section separator expected but not found (while parsing '%s')", strFile); }
    ASSERT( !strcmp(_strupr(junk), "ANIMATION"), "Section [ANIMATION] expected, [%s] found ('%s')", junk, strFile);

    try{
        f.ctlSetSeparators(" f");

        f.readUnsigned(&_nFrameCnt);
        f.readDouble(&_dSPF);
        f.ctlSetSeparators(" ");
        _dSPF = 1/_dSPF;

        _arFrames = new laStaticModel[_nFrameCnt];
    }
    catch(laError& ) {
        throw laError("Section [ANIMATION] appears to be corrupted (while parsing '%s')", f.getFileName());
    }

    //Load individual frames
    //
    char strCacheFile[256];
    sprintf(strCacheFile, "%s.cache", strFilePath);
    FILE* fCache_Read = fopen(strCacheFile, "rb");

    if(fCache_Read)
    {
        for(unsigned i=0; i<_nFrameCnt; i++)
        {
            _arFrames[i].create(nfaces);
            _arFrames[i].setTexture(_nTex, _bEmissive, _nShininess);
            _arFrames[i]._cache_load(fCache_Read);
        }

        fclose(fCache_Read);
    }
    else
    {
        FILE* fCache_Write = fopen(strCacheFile, "wb");
        ASSERT(fCache_Write, "Cannot open cache for writing (%s)", strCacheFile);

        for(unsigned i=0; i<_nFrameCnt; i++)
        {
            char strExpectedTitle[128], ss[2];
            sprintf(strExpectedTitle, "FRAME %d", i+1);

            f.ctlGetSectionSep(ss);
            f.ctlSetSectionSep("##");

            try{ f.readSectionSeparator(junk); }catch(laError& ){ throw laError("Frame label expected but not found (while parsing '%s')", strFile); }
            ASSERT(! strcmp(_strupr(junk), strExpectedTitle), "Frame %d expected, #%s# found (while parsing '%s')", strExpectedTitle, junk, strFile);
            f.ctlSetSectionSep(ss);

            try{
                _arFrames[i].load(&f, nfaces, nverts, ntverts);
                _arFrames[i].setTexture(_nTex, _bEmissive, _nShininess);

                _arFrames[i]._cache_save(fCache_Write);
            }
            catch(laError&  pe) {
                throw laError("%s\n\nFrame %d appears to be corrupted (while parsing '%s')", pe.getText(), i, f.getFileName());
            }
        }
        fclose(fCache_Write);
    }

    return true;
    ERRORLEVEL_END;
}

// Make a transitional animation between two poses
//
void laAnimatedModel::blend(laStaticModel *pPose1, laStaticModel *pPose2, double dSec)
{
    ERRORLEVEL_BEGIN;
    ASSERT( pPose1->vertexCount() == pPose2->vertexCount(), "Incompatible poses");

    if( frameCount() != 2 ) {
        discard();
        _arFrames  = new laStaticModel[2];
        _nFrameCnt = 2;
    }

    _arFrames[0].instantiate( pPose1 );
    _arFrames[1].instantiate( pPose2 );

    _bInterpolation = M_TRUE;
    _bCycle         = M_FALSE;

    _dSPF         = dSec;
    _dTimeElapsed = 0;
    _nCrFrame     = 0;

    setTexture( *(pPose1->texture()), pPose1->_bEmissive, pPose1->_nShininess);

    ERRORLEVEL_END;
}

// Make a snapshot of the current state of the animation
//

struct _blend_data{
    unsigned n_first, n;
    double w1, w2;

    laPoint3 *vt, *v1,* v2;
    laPoint3 *nt, *n1, *n2;
    laPoint2 *uvt, *uv1, *uv2;
};

inline void _blend(const _blend_data &bd)
{
    for(unsigned i=bd.n_first; i < bd.n; i++) {
        bd.vt[i] = bd.w1*bd.v1[i] + bd.w2*bd.v2[i];
        bd.nt[i] = bd.w1*bd.n1[i] + bd.w2*bd.n2[i];
        //bd.uvt[i] = bd.w1*bd.uv1[i] + bd.w2*bd.uv2[i];
    }
    memcpy(bd.uvt+bd.n_first, bd.uv1+bd.n_first, sizeof(laPoint2)*bd.n);
}

/*class laSnapshotThread: public laThread
{
    public:
    _blend_data bd;
    volatile M_BOOL bDone;

    laSnapshotThread() { bDone = M_FALSE; }

    virtual void run() {
        _blend( bd );
        bDone = M_TRUE;
    }
};*/

void laAnimatedModel::snapshot(laStaticModel* pm)
{
    PROFILE_REN(laAnimatedModel_snapshot);
    ERRORLEVEL_BEGIN;
    //ASSERT(pm, "Nil snapshot destination");
    //ASSERT(_arFrames && _nFrameCnt, "Nil frameset");

    laStaticModel *pcurrent = _arFrames + _nCrFrame;
    laStaticModel *pnext        = _arFrames + ( ((_nCrFrame+1)>=_nFrameCnt) ? (_bCycle?0:_nCrFrame) : _nCrFrame+1 );

    // Ensure snapshot destionation is of the correct size
    //
    if( pm->isLightweight() || (pm->vertexCount() != pcurrent->vertexCount()) ) {
        pm->discard();
        pm->create( pcurrent->vertexCount()/3 );
    }
    pm->setTexture( *(pcurrent->texture()), pcurrent->_bEmissive, pcurrent->_nShininess );

    // Blend current and next frame into the snapshot
    //
    _blend_data bd;
    bd.w2 = M_MIN(1, _dTimeElapsed/_dSPF); bd.w1 = 1-bd.w2;
    bd.vt = pm->_arFlatVertex;  bd.v1 = pcurrent->_arFlatVertex; bd.v2 = pnext->_arFlatVertex;
    bd.nt = pm->_arFlatNormal;  bd.n1 = pcurrent->_arFlatNormal; bd.n2 = pnext->_arFlatNormal;
    bd.uvt = pm->_arFlatTex;    bd.uv1 = pcurrent->_arFlatTex;  bd.uv2 = pnext->_arFlatTex;
    bd.n_first = 0; bd.n = pm->vertexCount();

    /*laSnapshotThread thSnapshot;
    thSnapshot.bd = bd;
    laSystemIntegrator::getEnvironment()->thread(&thSnapshot);
    bd.n_first = pm->vertexCount()/2;*/

    _blend( bd );

    //while( ! thSnapshot.bDone );
    ERRORLEVEL_END;
}

// Sample a vertex in the current state of the animation
//
laPoint3 laAnimatedModel::sample(unsigned nVertexIndex)
{
    ERRORLEVEL_BEGIN;
    ASSERT(_arFrames && _nFrameCnt, "Nil frameset");

    laStaticModel *pcurrent = _arFrames+_nCrFrame;
    laStaticModel *pnext        = _arFrames + ( ((_nCrFrame+1)>=_nFrameCnt) ? (_bCycle?0:_nCrFrame) : _nCrFrame+1 );
    ASSERT(nVertexIndex < pcurrent->vertexCount(), "Requested vertex sample out of bounds", nVertexIndex);

    double w2 = M_MIN(1, _dTimeElapsed/_dSPF), w1 = 1-w2;

    return ( w1*(pcurrent->_arFlatVertex[nVertexIndex]) + w2*(pnext->_arFlatVertex[nVertexIndex]) );
    ERRORLEVEL_END;
}

//#include <GL\GL.h>

void laAnimatedModel::draw(laRenderer *pr)
{
    ERRORLEVEL_BEGIN;
    PROFILE_REN(laAnimatedModel_draw);
    ASSERT(_arFrames && _nFrameCnt,  "Nil frameset");
    ASSERT(_nCrFrame < _nFrameCnt, "Invalid frame");

    if(_nFrameCnt==1) {
        _arFrames[0].draw(pr);
        return;
    }

    /*if(_bTraceEffect)
    {
        //glPushAttrib();

        unsigned a = 0.0;

        pr->modeBlend(M_TRUE);
        pr->modeBlendFilter(0);

        //pr->modeTexture(M_FALSE);
        pr->modeLight(M_FALSE);

        glDepthMask(GL_FALSE);

        for(int i=0; i<_nCrFrame; i++)
        {
            a += 30.0/_nCrFrame;

            pr->styleSet( laColor(255,255,255,a) );
            _arFrames[i].texture()->use();
            _arFrames[i]._draw_traingles( pos );
        }

        pr->styleSet( laColor(255,255,255,255) );
        glDepthMask(GL_TRUE);

        //glPopAttrib();
    }*/

    if(_bInterpolation) { snapshot( &_snapshot ); _snapshot.draw( pr ); }
    else _arFrames[_nCrFrame].draw(pr);

    ERRORLEVEL_END;
}

void laAnimatedModel::animate(laTimer &t)
{
    if( _nFrameCnt<=1 ) return;

    if( (_nCrFrame>=(_nFrameCnt-1)) && (!_bCycle) ) {
        _nCrFrame = _nFrameCnt-1;
        return;
    }

    _dTimeElapsed += t.delta();

    while(_dTimeElapsed >= _dSPF)
    {
        _dTimeElapsed -= _dSPF;
        _nCrFrame++;

        if(_nCrFrame>=_nFrameCnt)
        {
            if(_bCycle) _nCrFrame=0;
            else
            {
                _nCrFrame = _nFrameCnt-1;
                _dTimeElapsed = 0;
                return;
            }
        }
    }

    //snapshot( &_snapshot );
}

void laAnimatedModel::buildCollisionData(class laCollisionDomain* pDomain, rpgTrap* pTrap) {
    _arFrames[0].buildCollisionData(pDomain, pTrap);
}

char* laAnimatedModel::strTexture() {
    return _arFrames[_nCrFrame].strTexture();
}

unsigned laAnimatedModel::vertexCount() {
    return _arFrames[_nCrFrame].vertexCount();
}

laPoint3 laAnimatedModel::boundaryMin() { return _arFrames[0].boundaryMin(); }
laPoint3 laAnimatedModel::boundaryMax() { return _arFrames[0].boundaryMax(); }

void laAnimatedModel::edScale(laPoint3 sz) {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edScale(sz);
}

void laAnimatedModel::edTranslate(laPoint3 pos) {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edTranslate(pos);
}

void laAnimatedModel::edNormalize() {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edNormalize();
}

void laAnimatedModel::edMinaxis() {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edMinaxis();
}

void laAnimatedModel::edMaxaxis() {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edMaxaxis();
}

void laAnimatedModel::edCentralize() {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edCentralize();
}

void laAnimatedModel::edSnap() {
    for(unsigned i=0; i<_nFrameCnt; i++) _arFrames[i].edSnap();
}

void laAnimatedModel::edInvertAnimation()
{
    laStaticModel f;

    for(unsigned i=0; i<_nFrameCnt/2; i++)
    {
        f.instantiate( _arFrames+i );
        _arFrames[i].instantiate( _arFrames + _nFrameCnt-i-1 );
        _arFrames[_nFrameCnt-i-1].instantiate( &f );
    }
}