D:/Programming/GUI Editor (Source)/FrameAnimation.h

#ifndef FRAMEANIMATION_H
#define FRAMEANIMATION_H

#pragma once
#include "Animation.h"
#include "Timer.h"


template<class TAnimation> class CFrameAnimation : public CAnimation
{

public:
        CFrameAnimation()
        {
                SetEntityType(Entity_FrameAnimation);

                m_uipDataIndex = NULL;
                m_pAnimationData = NULL;
                m_uiFrameCount = 
                        m_uiLoopsCount = 
                        m_uiCurrentLoop = 
                        m_uiCurrentFrame = 
                        m_uiDataCount = 0;
                m_bLoop = false;
                m_bAnimationComplete = false;
                m_bPaused = false;
                m_fLastTime = 0;
        };

        virtual ~CFrameAnimation()
        {
                Destroy();
        };
        virtual int Create(UINT uiFrameCount, UINT uiDataCount)
        {
                if(!(uiFrameCount > 0 && uiDataCount > 0))
                        return 0;

                m_pAnimationData = new TAnimation*[uiFrameCount];
                m_uipDataIndex = new UINT[uiDataCount];

                for (UINT i=0; i<uiFrameCount; i++)
                        m_pAnimationData[i] = NULL;

                for (UINT j=0; j<uiDataCount; j++)
                        m_uipDataIndex[j] = 0;

                m_uiDataCount = uiDataCount;
                m_uiFrameCount = uiFrameCount;

                return 1;
        };

public:
        TAnimation *GetFrame(UINT uiFrameIndex)
        {
                if(uiFrameIndex >=0 && uiFrameIndex < m_uiDataCount)
                        return m_pAnimationData[uiFrameIndex];

                return NULL;
        };
        void SetLooping(bool bLooping)
        {
                m_bLoop = bLooping;
        };
        bool GetLooping()
        {
                return m_bLoop;
        };
        void SetLoopCount(UINT uiLoopCount)
        {
                m_uiLoopsCount = uiLoopCount;
        };
        UINT GetFrameCount()
        {
                return m_uiFrameCount;
        };
        UINT GetLoopCount()
        {
                return m_uiLoopsCount;
        };
        UINT GetLoop()
        {
                return m_uiCurrentLoop;
        };
        TAnimation *GetCurrentFrame()
        {
                return GetFrame(m_uiCurrentFrame);
        };
        UINT GetFrameIndex()
        {
                return m_uiCurrentFrame;
        };
        virtual void SetFrameTime(double fTime)
        {
                if(fTime > 0)
                        m_fFrameTime = fTime;
        };
        virtual int Animate(double fTimePerFrame = -1)
        {
                if(m_bPaused == true)
                        return 0;
                
                if(fTimePerFrame == -1 && CGlobalTimer::GetSingletonPtr() == NULL)
                        return 0;
                else if(fTimePerFrame !=-1)
                        m_fFrameTime = fTimePerFrame;

                double cur_time = CGlobalTimer::GetSingleton().GetAbsoluteTime();
                if(m_uiCurrentFrame != (m_uiFrameCount - 1))
                {
                        if((cur_time - m_fLastTime) >= m_fFrameTime)
                        {
                                m_uiCurrentFrame++;
                                m_fLastTime = cur_time;
                        }
                }
                else
                {
                        if(m_bLoop)
                        {
                                if(m_uiCurrentLoop != (m_uiLoopsCount - 1))
                                {
                                        m_uiCurrentLoop++;
                                        m_bAnimationComplete = false;
                                }
                                else
                                        m_bAnimationComplete = true;
                        }

                        m_bAnimationComplete = true;
                }

                return (int)m_bAnimationComplete;
        };
        virtual int Pause(double fPauseTime = INFINITE)
        {
        
                return 1;
        };
        virtual int Resume(double fTimeToWait = 0)
        {
        
                return 1;
        };
        virtual int Stop()
        {
        
                return 1;
        };

        public:
        virtual int LoadXML(TiXmlNode *pDataNode, CString strFilename)
        {
                return CAnimation::LoadXML(pDataNode, strFilename);
        };
        virtual int SaveXML(TiXmlNode *pDataNode, CString strFilename)
        {
                return CAnimation::SaveXML(pDataNode, strFilename);
        };

        virtual void Destroy()
        {
                SAFEDEL_ARRAY(m_pAnimationData)
                SAFEDEL_ARRAY(m_uipDataIndex)

                CAnimation::Destroy();
        };

        virtual bool IsOfType(eEntityType eType)
        {
                if(eType == Entity_FrameAnimation)
                        return true;

                return CAnimation::IsOfType(eType);
        };

protected:

        UINT *m_uipDataIndex;                   
        UINT m_uiFrameCount;                    
        UINT m_uiLoopsCount;                    
        UINT m_uiCurrentLoop;                   
        UINT m_uiCurrentFrame;                  
        double m_fLastTime;                             
        double m_fFrameTime;
        bool m_bLoop;                                   
        TAnimation      **m_pAnimationData;     
        UINT m_uiDataCount;                             
        bool m_bAnimationComplete;              
        bool m_bPaused;                                 
        CTimer m_Timer;                                 
};

#endif

---