KeyFrame.h

#pragma once

#include <vector>
#include <string>

namespace ParaEngine
{
    template <class T>
    class MovieKeyFrame
    {
    private:
        std::vector<float> times;
        std::vector<T> data;

        int m_nPos;

        int GetValidIndex(int nPos){
            if(nPos<0)
                nPos = 0;
            else if(nPos >= GetSize())
                nPos = GetSize()-1;
            return nPos;
        }
    public:
        void Clear(){
            times.clear();
            data.clear();
            m_nPos=0;
        };
        MovieKeyFrame():m_nPos(0){};
        void AppendNewKey(float fTime, const T& key)
        {
            times.push_back(fTime);
            data.push_back(key);
        }

        void InsertNewKey(float fTime, const T& key)
        {
            int nPos = GetKeyIndexByTime(fTime);
            if(nPos<0 || nPos >= GetSize() )
            {
                AppendNewKey(fTime, key);
            }
            else
            {
                times.insert(times.begin()+nPos, fTime);
                data.insert(data.begin()+nPos, key);
            }
        }

        float GetEndingTime()
        {
            int nEndIndex = times.size()-1;
            if(nEndIndex>=0)
                return times[nEndIndex];
            else
                return 0;
        }
        void UpdateKeyFrame(int nIndex, float fTime, const T& key)
        {
            nIndex = GetValidIndex(nIndex);
            times[nIndex] = fTime;
            data[nIndex] = key;
        }
        void PopKeyFrame(int nNum)
        {
            int nLen = GetSize();
            {
                std::vector<float>::iterator iterFrom, iterTo = times.end();
                if(nLen >nNum)
                    iterFrom = iterTo - nNum;
                else
                    iterFrom = times.begin();
                times.erase(iterFrom, iterTo);
            }
            {
                typename std::vector<T>::iterator iterFrom, iterTo = data.end();
                if(nLen >nNum)
                    iterFrom = iterTo - nNum;
                else
                    iterFrom = data.begin();
                data.erase(iterFrom, iterTo);
            }
        }
        T& operator [](int nIndex){
            return data[GetValidIndex(nIndex)];
        };
        float time(int nIndex){
            return times[GetValidIndex(nIndex)];
        };

        int GetPos(){return m_nPos;};

        void SetPos(int nPos){
            m_nPos = nPos;
        };

        int GetSize(){return (int)data.size();};

        T& GetRelative(int nShiftPos = 0){
            return data[GetValidIndex(m_nPos+nShiftPos)];
        }
        
        int GetKeyIndexByTime(float fTime)
        {
            int nLen = GetSize();
            int nPos = GetPos();
            bool bFound = false;
            for(int i=0;i<nLen && !bFound;i++) {
                float fFrom = time(nPos-1);
                float fTo = time(nPos);
                if(fFrom<=fTo)
                {
                    if(fFrom<= fTime && fTime<fTo)
                        bFound = true;
                    else if(fTo<=fTime){
                        if(nPos == (nLen))
                            bFound = true;
                        else
                            nPos++;
                    }
                    else if(fFrom>fTime){
                        if(nPos == 0)
                            bFound = true;
                        else
                            nPos--;
                    }
                }
                else
                {
                    // no rewinding is supported.
                    break;
                }
            }
            if(bFound)
                return nPos;
            else
                return -1;
        }
        int UpdateTime(float& fTimeElapsed){
            int nLen = GetSize();
            int nPos = GetPos();
            bool bFound = false;
            bool bRewind = false;
            for(int i=0;i<nLen && !bFound;i++) {
                float fFrom = time(nPos-1);
                float fTo = time(nPos);
                if(fFrom<=fTo)
                {
                    if(fFrom<= fTimeElapsed && fTimeElapsed<fTo)
                        bFound = true;
                    else if(fTo<=fTimeElapsed){
                        if(nPos == (nLen))
                            bFound = true;
                        else
                            nPos++;
                    }
                    else if(fFrom>fTimeElapsed){
                        if(nPos == 0)
                            bFound = true;
                        else
                            nPos--;
                    }
                }
                else if(!bRewind)
                {
                    // a rewind occurs, so to reset the time.
                    fTimeElapsed = fTo;
                    nPos = 0;
                    bRewind = true;
                }
                else
                    bFound = true;
            }
            SetPos(nPos);
            return GetPos();
        }
        int TrimToTime(float fTimeElapsed)
        {
            int nPos = UpdateTime(fTimeElapsed);
            int nEndPos = GetSize();
            if(nPos < nEndPos)
            {
                PopKeyFrame(nEndPos - nPos);
                return nEndPos - nPos;
            }
            return 0;
        }
    };
    struct PosKey
    {
        DVector3 vPos;
        float fFacing;
        PosKey(float x,float y,float z,float facing):vPos(x,y,z), fFacing(facing){};
        PosKey(const DVector3& v,float facing):vPos(v), fFacing(facing){};
    };
    struct DialogKey
    {
        string sDialog;
        DialogKey(const string& s):sDialog(s){};
        DialogKey(){};
    };
    struct CameraKey
    {
        float fRotY;
        float fLiftUpAngle;
        float fDist;
        CameraKey(float rotY, float LiftUpAngle, float Dist):fRotY(rotY), fLiftUpAngle(LiftUpAngle), fDist(Dist){};
    };
    struct EffectKey
    {
        int nEffectID;
        string sTarget;
    public:
        EffectKey(int effectid, const string& target);
        EffectKey(int effectid, const char* target);
    };
    struct ActionKey
    {
        const static int MAX_ACTIONNAME_LEN = 16;
        string sActionName;
        enum KeyID
        {
            TOGGLE_TO_WALK=0,
            TOGGLE_TO_RUN,
            JUMP,
            MOUNT, // mount on the nearest object
            NONE
        };
    public:
        ActionKey(const char* name);
        ActionKey(const std::string& name);
        ActionKey(KeyID keyID);
        ActionKey(int nAnimID);

        const char* ToString()const;

        int ToAnimID() const;

        bool IsJump() const;
        bool IsToggleToWalk() const;
        bool IsToggleToRun() const;
        bool IsMount() const;
    };

}