---

GXKeyFrameTemplate.h

Go to the documentation of this file.

#ifndef __GXKEYFRAMETEMPLATE
#define __GXKEYFRAMETEMPLATE


#include "GXAutoArray.h"
#include "GXInteroplationTemplates.h"

#include "fastmath.h"

template<typename type>
class CGXKeyframeTemplate
{
        friend class CGXKeyframeTemplate<type>;

public:
        CGXKeyframeTemplate(){}
        ~CGXKeyframeTemplate(){}

        bool WriteToStream(IStream* pStream)
        {
                return m_Frames.WriteToStream(pStream);
        }


        bool LoadFromStream(IStream* pStream)
        {
                return m_Frames.LoadFromStream(pStream);
        }


        bool LoadFromData(type* pKeyFrames, UINT uFrameCount)
        {
                assert(0!=uFrameCount);
                assert(NULL!=pKeyFrames);

                if(!m_Frames.Init(uFrameCount))
                {
                        return false;
                }

                if(!m_Frames.CopyIn(pKeyFrames, uFrameCount))
                {
                        return false;
                }

                return true;
        }



        void GetLerpValAt(float fPos, type* pOut)
        {
                assert(NULL!=pOut);
                assert(fPos<=1.0f);
                assert(fPos>=0.0f);

                //figure out which two keyframes to get
                float fMid=(m_Frames.GetCount()-1)*fPos;

                float fFloor=(float)floor(fMid);
                float fCeil=(float)ceil(fMid);

                UINT uFloor;
                UINT uCeil;

                FloatToInt((int*)&uFloor, fFloor);
                FloatToInt((int*)&uCeil, fCeil);

                //UINT uFloor=(UINT) (floor(fMid));
                //UINT uCeil=(UINT) (ceil(fMid));
        
                float fLerpAmt=fMid-uFloor;

                assert(fLerpAmt<=1.0f);
                assert(fLerpAmt>=0.0f);

                //
                type Floor, Ceil;

                m_Frames.GetValAt(uFloor, &Floor);
                m_Frames.GetValAt(uCeil, &Ceil);

                BlakeUtilLerp(fLerpAmt, &Floor, &Ceil, pOut);
        }



        void GetQuadInterpValAt(float fPos, type* pOut)
        {
                assert(NULL!=pOut);
                assert(fPos<=1.0f);
                assert(fPos>=0.0f);

                UINT uFrameCount=m_Frames.GetCount();

                if(uFrameCount<=2)
                {
                        GetLerpValAt(fPos, pOut);
                        return;
                }

                //figure out which two keyframes to get
                float fMid=uFrameCount*fPos;

                UINT uFloor, uCeil;
                float fFloor, fCeil;

                fFloor=(float)(floor(fMid));
                fCeil=(float)(ceil(fMid));

                FloatToInt((int*)&uFloor, fFloor);
                FloatToInt((int*)&uCeil, fCeil);

                //UINT uFloor=(UINT) (floor(fMid));
                //UINT uCeil=(UINT) (ceil(fMid));

                UINT uMid;


                //Interpolation will pass through uFloor, and uCeil, so they must be even, uMid must be odd

                if((uFloor>0) && ((uFloor%2)==1))
                {
                        //uFloor is >0 and odd
                        uMid=uFloor;
                        --uFloor;
                }

                else if ((uCeil<(uFrameCount-1)) && ((uCeil%2)==1))
                {
                        uMid=uCeil;
                        ++uCeil;
                }
                else
                {
                        assert(0&&"Got to unreachable in GetQuadInterpValAt()");
                }

                
                float fInterpAmt=(fMid-uFloor)/2;

                assert(fInterpAmt<=1.0f);
                assert(fInterAmt>=0.0f);

                type Floor, Mid, Ceil;

                m_Frames.GetValAt(uFloor, &Floor);
                m_Frames.GetValAt(uMid, &Mid);
                m_Frames.GetValAt(uCeil, &Ceil);

                BlakeUtilQuaderp(fInterpAmt, &Floor, &Ceil, &Mid, pOut);
        }


        UINT GetFrameCount()
        {
                return m_Frames.GetCount();
        }

        bool LoadFromKeyframeTemplate(CGXKeyframeTemplate<type>& In)
        {
                if(!m_Frames.Init(In.GetFrameCount()))
                {
                        return false;
                }

                if(!m_Frames.CopyIn(In.m_Frames.GetPtr(), In.GetFrameCount()))
                {
                        return false;
                }

                return true;
        }
        
protected:
        CGXAutoArray<type>      m_Frames;
};







#endif

---