fsIAnimatingSprite.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsIAnimatingSprite.h
*
*       Purpose:        Interface for animating sprites
*
*********************************************************************/
 
#ifndef fsIAnimatingSpritehdr
#define fsIAnimatingSpritehdr
 
#include <memory>
 
#include <fsCore/fsBaseTypes.h>
 
#include "fsAnimationEvent.h"
#include "fsIRenderable.h"
#include "src/animatingSprite/fsCAnimationDataManager.h"
 
class fsCResourceName;
class fsAffineMtx2d;
class fsStr;
class fsIAnimationData;
class fsCAnimationTimeline;
class fsCSpriteFrame;
struct fsPoint;
class fsSColour;
class fsCSprite;
class fsCBrush;
 
 
class fsIAnimatingSprite : public fsIRenderable
{
        friend std::shared_ptr<fsIAnimatingSprite> const fsCAnimationDataManager::createAnimationInstance(
                std::shared_ptr<fsIAnimationData>, fsCSprite* pAnimatingRootSprt);
 
public:
 
        void animationPlay(const fsStr& pAnimation);
        void animationPlay(const fsStr& pAnimation, fsBool pLooping);
        fsBool animationQueue(const fsStr& pAnimation, fsBool pLooping);
        fsBool animationTrackPlay(fsS32 pTrackIndex, const fsStr& pAnimation, fsBool pLooping);
        fsBool animationTrackQueue(fsS32 pTrackIndex, const fsStr& pAnimation, fsBool pLooping);
        fsBool animationTrackClear(fsS32 pTrackIndex);
        void animationTracksClear();
        void animationMixDurationSet(fsS32 pDurationMs);
        fsBool skinSet(const fsStr& pSkin);
        fsBool attachmentSet(const fsStr& pSlot, const fsStr& pAttachment);
        void animationEventCallbackSet(fsTAnimationEventCallback pCallback);
 
        fsS32 currentFrameHeightGet() const;
        fsPoint currentFramePosGet() const;
 
        void stop();
 
        std::shared_ptr<fsCBrush> brushGet() const;
        fsBool hitTest(const fsPoint& pPoint, fsBool pRequireHitMap) const;
        //      fsBool pixelCollisionCheck( fsISpriteRef pTarget );
 
        fsS32 currentFrameGet() const;
 
        void update(fsS32 pDeltaMS);
 
        fsBool animatingGet() const;
        fsBool loopingGet() const;
 
 
        void reset();
 
        fsIAnimatingSprite(const fsCResourceName& pFileName, fsBool pHitMap, fsCSprite* pAnimatingSpriteRoot);
        fsIAnimatingSprite(fsCSprite* pAnimatingRootSprt);
        virtual ~fsIAnimatingSprite();
 
protected:
 
        void animationDataSet(std::shared_ptr<fsIAnimationData> pAnimData);
        void animationEventDispatch(const fsSAnimationEvent& pEvent) const;
        void colourSetDo(const fsSColour4B& pColour) override;
 
        virtual void animationPlayDo(const fsStr& pAnimation)
        {
        };
        // Providers whose runtimes choose looping at playback time can override this
        // overload. Existing providers retain their authored looping behaviour.
        virtual void animationPlayDo(const fsStr& pAnimation, fsBool)
        {
                animationPlayDo(pAnimation);
        };
        virtual fsBool animationQueueDo(const fsStr&, fsBool)
        {
                return false;
        }
        virtual fsBool animationTrackPlayDo(fsS32, const fsStr&, fsBool)
        {
                return false;
        }
        virtual fsBool animationTrackQueueDo(fsS32, const fsStr&, fsBool)
        {
                return false;
        }
        virtual fsBool animationTrackClearDo(fsS32)
        {
                return false;
        }
        virtual void animationTracksClearDo()
        {
        }
        virtual void animationMixDurationSetDo(fsS32)
        {
        }
        virtual fsBool skinSetDo(const fsStr&)
        {
                return false;
        }
        virtual fsBool attachmentSetDo(const fsStr&, const fsStr&)
        {
                return false;
        }
 
        virtual void activeSet(fsBool pVisibility) = 0;
        virtual void colourApplyToSpriteFrames(const fsSColour4B& pColour) = 0;
        virtual void animationDataSetDo(std::shared_ptr<fsIAnimationData> pAnimData) = 0;
 
        virtual fsS32 currentFrameHeightGetDo() const = 0;
        virtual fsPoint currentFramePosGetDo() const = 0;
 
        virtual std::shared_ptr<fsCBrush> brushGetDo() const;
        virtual fsBool hitTestDo(const fsPoint& pPoint, fsBool pRequireHitMap) const = 0;
        //      virtual fsBool pixelCollisionCheckDo( fsISpriteRef pTarget ) = 0;
 
        virtual fsS32 currentFrameGetDo() const = 0;
        virtual void updateDo(fsS32 pDeltaMS) = 0;
 
        virtual fsBool loopingGetDo() const = 0;
        virtual void resetDo() = 0;
 
        fsBool mActive;
        fsCSprite* mAnimationRootSprt;
 
private:
        fsTAnimationEventCallback mAnimationEventCallback;
};
 
#endif