AnimInstanceBase.h

#pragma once
#include "IAttributeFields.h"
#include <map>

namespace ParaEngine
{
    struct SceneState;
    class ShadowVolume;
    struct LightParams;
    using namespace std;

    struct AnimIndex
    {
    public:
        AnimIndex():nIndex(-1), Provider(0), nCurrentFrame(0), nStartFrame(0), nEndFrame(0),loopType(0),nAnimID(0),nFramePlayed(0) {}
        AnimIndex(int nIndex_):nIndex(nIndex_), Provider(0), nCurrentFrame(0), nStartFrame(0), nEndFrame(0),loopType(0),nAnimID(0),nFramePlayed(0){}
        AnimIndex(int nIndex_, byte nProvider_):nIndex(nIndex_), Provider(nProvider_), nCurrentFrame(0), nStartFrame(0), nEndFrame(0),loopType(0),nAnimID(0),nFramePlayed(0){}
        AnimIndex(int nIndex_, byte nProvider_, int nStartFrame_, int nEndFrame_, byte loopType_):nIndex(nIndex_),  Provider(nProvider_), nCurrentFrame(nStartFrame_), nStartFrame(nStartFrame_), nEndFrame(nEndFrame_),loopType(loopType_),nAnimID(0),nFramePlayed(0){}
        AnimIndex(int nIndex_, byte nProvider_, int nStartFrame_, int nEndFrame_, byte loopType_, int nAnimID):nIndex(nIndex_),  Provider(nProvider_), nCurrentFrame(nStartFrame_), nStartFrame(nStartFrame_), nEndFrame(nEndFrame_),loopType(loopType_),nAnimID(nAnimID),nFramePlayed(0){}

        bool IsValid() const {return nIndex != -1;}

        bool operator==(const AnimIndex& right) const {return (this->nIndex == right.nIndex) && (this->Provider == right.Provider) && (this->loopType == right.loopType);}
        bool operator!=(const AnimIndex& right) const {return (this->nIndex != right.nIndex) || (this->Provider != right.Provider) || ((this->loopType != right.loopType));}

        bool IsLooping() const {return loopType==0;};

        bool IsUndetermined() const {return loopType==2;};

        void Reset() {nCurrentFrame = nStartFrame;nFramePlayed=0;};

        void MakeInvalid() {nIndex = -1;Provider=0;};

        void AddCycle(){ nFramePlayed += (nEndFrame-nStartFrame);}
    public:
        // bone animation provider: 0 for local model bone animation pool; 1 for global bone animation provider
        byte Provider;
        // 0 for looping, 1 for non-looping, 2 for undeterminted(the animation needs to be refreshed upon finish, such as during async-loading). 
        byte loopType;
        // current index, -1 if invalid
        int nIndex;
        // the animation ID as seen by outsiders
        int nAnimID;
        // current frame
        int nCurrentFrame;
        // start frame
        int nStartFrame;
        // end frame
        int nEndFrame;
        // total number of frames played
        int nFramePlayed;
    };

    class CAnimInstanceBase : public IAttributeFields
    {
    public:
        CAnimInstanceBase();
        virtual ~CAnimInstanceBase(){};

        ATTRIBUTE_DEFINE_CLASS(CAnimInstanceBase);

        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CAnimInstanceBase, GetRenderCount_s, int*)        { *p1 = cls->GetRenderCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, SetRenderCount_s, int)     { cls->SetRenderCount(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, IsAnimIDMapEnabled_s, bool*)       { *p1 = cls->IsAnimIDMapEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, EnableAnimIDMap_s, bool)       { cls->EnableAnimIDMap(p1); return S_OK; }

        ATTRIBUTE_METHOD(CAnimInstanceBase, ResetAnimation_s)       { cls->ResetAnimation(); return S_OK; }
        
        ATTRIBUTE_METHOD1(CAnimInstanceBase, GetCurrentAnimation_s, int*)       { *p1 = cls->GetCurrentAnimation(); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, ShowMesh_s, DWORD)     { cls->ShowMesh(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CAnimInstanceBase, GetSizeScale_s, float*)        { *p1 = cls->GetSizeScale(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, SetSizeScale_s, float)     { cls->SetSizeScale(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, GetSpeedScale_s, float*)       { *p1 = cls->GetSpeedScale(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, SetSpeedScale_s, float)        { cls->SetSpeedScale(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, IsUseGlobalTime_s, bool*)      { *p1 = cls->IsUseGlobalTime(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, SetUseGlobalTime_s, bool)      { cls->SetUseGlobalTime(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, GetAnimFrame_s, int*)      { *p1 = cls->GetAnimFrame(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, SetAnimFrame_s, int)       { cls->SetAnimFrame(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CAnimInstanceBase, IsAnimationEnabled_s, bool*)       { *p1 = cls->IsAnimationEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CAnimInstanceBase, EnableAnimation_s, bool)       { cls->EnableAnimation(p1); return S_OK; }
        
    protected:
        // object status primitive
        LinearColor         m_modelColor;               
        //bool              m_bLoopAnim;
        //DWORD             m_dwLoiterIndex;
        
        // type specific informations
        Matrix4            m_mxLocalTransform;           
        float   m_fSizeScale;
        float   m_fSpeedScale;
        int m_nRenderCount;

        map<int, int> m_mapAnimIDs;

        bool m_bEnableAnimIDMap;
        bool m_bEnableAnimation;
        
    public:
        virtual int GetRenderCount();
        virtual void SetRenderCount(int nCount);

        void EnableAnimIDMap(bool bEnable);

        bool IsAnimIDMapEnabled();

        map<int, int>* GetAnimIDMap();

        void ApplyLocalTransformToVec3( Vector3 *pOut,const Vector3 *pV);
        void ApplyLocalTransformToVec1( float *pOut,float* pV);
            
        virtual void LoadAnimation(const char * sName, float * fSpeed, bool bAppend = false);
        virtual void LoadAnimation(int nAnimID, float * fSpeed,bool bAppend = false);
        virtual void LoadDefaultStandAnim(float * fSpeed);
        virtual void LoadDefaultWalkAnim(float * fSpeed);

        virtual bool HasAnimId(int nAnimID);

        virtual int GetCurrentAnimation();

        virtual void ResetAnimation();

        virtual void SetModelColor(LinearColor modelColor);
        virtual void ShowMesh(BOOL bShow, int nIndex);
        virtual void ShowMesh(DWORD dwBitfields);
        virtual void SetLocalTransform(Matrix4 mXForm);
        
        virtual void AdvanceTime( double dTimeDelta );

        virtual void Animate( double dTimeDelta, int nRenderNumber=0 );

        //Add third parameter, pass per instance material parameters   --clayman 2012.7.4
        virtual HRESULT Draw( SceneState * sceneState, const Matrix4* mxWorld,CParameterBlock* paramBlock = NULL);

        virtual void BuildShadowVolume(SceneState * sceneState, ShadowVolume * pShadowVolume, LightParams* pLight, Matrix4* mxWorld);

        /* new set */
        virtual void SetSizeScale(float fScale);
        virtual float GetSizeScale();

        virtual void GetCurrentRadius(float* fRadius){};
        virtual void GetCurrentSize(float * fWidth, float * fDepth);
        virtual void SetSpeedScale( float fScale );
        virtual float GetSpeedScale();
        virtual void GetCurrentSpeed (float* fSpeed);
        virtual void GetSpeedOf(const char * sName, float * fSpeed);

        virtual void SetUseGlobalTime(bool bUseGlobalTime);

        virtual bool IsUseGlobalTime();

        virtual void SetAnimFrame(int nFrame);

        virtual int GetAnimFrame();

        virtual void SetBlendingFactor(float fBlendingFactor);

        virtual bool HasAnimation(int nAnimID);

        virtual bool HasAlphaBlendedObjects();

        virtual int GetValidAnimID(int nAnimID);

        void EnableAnimation(bool bAnimated);
        bool IsAnimationEnabled() const;
    };
}