tb_animated_sprite.hpp

 
#ifndef TurtleBrains_AnimatedSprite_hpp
#define TurtleBrains_AnimatedSprite_hpp
 
#include <turtle_brains/graphics/tb_sprite.hpp>
#include <turtle_brains/graphics/tb_sprite_map.hpp>
 
#include <vector>
#include <map>
 
namespace TurtleBrains::Graphics
{
 
    class AnimationSequence
    {
    public:
 
        explicit AnimationSequence(const TextureHandle& textureHandle);
 
        AnimationSequence(const SpriteMap& spriteMap, const std::vector<size_t>& frames);
 
        AnimationSequence(const SpriteMap& spriteMap, const size_t& startFrameIndex, const size_t& frameCount);
 
        ~AnimationSequence(void);
 
        void AddFrame(const SpriteFrame& frame);
 
        void AddFrame(const PixelSpace& frameX, const PixelSpace& frameY, const PixelSpace& frameWidth, const PixelSpace& frameHeight);
 
        size_t GetFrameCount(void) const;
 
        const SpriteFrame& GetFrame(const size_t& frameIndex) const;
 
    private:
        //Animation Size: 36 (bytes per frame) * frames + 8 (bytes minimum for this)
        //This could greatly reduce size by hold SpriteFrame references, but added cost of complexity and easy usage.
        TextureHandle mTexture;
        std::vector<SpriteFrame> mAnimationFrames;
    };
 
 
    class AnimatedSprite : public Sprite
    {
    public:
        static const float& kDefaultTimePerFrame;
 
        static void SetAnimationFrameRate(const int framesPerSecond);
 
        explicit AnimatedSprite(const SpriteFrame& spriteFrame);
 
        explicit AnimatedSprite(const String& textureFile, const PixelSpace& frameX = 0, const PixelSpace& frameY = 0,
            const PixelSpace& frameWidth = 0, const PixelSpace& frameHeight = 0, const size_t& frameCount = 1);
 
        AnimatedSprite(const String& spriteSheetName, const String& spriteName);
 
        AnimatedSprite(const AnimatedSprite& other);
 
        AnimatedSprite& operator=(const AnimatedSprite& other);
 
        virtual ~AnimatedSprite(void);
 
        void AddSequence(const String& sequenceName, const AnimationSequence& sequence);
 
        void AddMappedSequence(const String& sequenceName, const SpriteMap& spriteMap, const std::vector<size_t>& frames);
 
        void AddMappedSequence(const String& sequenceName, const SpriteMap& spriteMap, const size_t& startFrameIndex,
            const size_t& frameCount);
 
        void PlayAnimation(const String& sequenceName, const bool isLooping, const bool isForward = true,
            const float timePerFrame = kDefaultTimePerFrame);
 
        void PlayAnimation(const String& sequenceName);
 
        void StopAnimation(void);
 
        bool IsAnimationPlaying(void) const;
 
        bool IsAnimationPlaying(const String& sequenceName) const;
 
        size_t GetFrameIndex(void) const { return mCurrentFrameIndex; }
 
    protected:
 
        virtual void OnUpdate(const float deltaTime) override;
 
    private:
        String GetNameOfCurrentSequence(void) const;
        void SetCurrentSequenceTo(const String& sequenceName);
 
        typedef std::map<String, AnimationSequence> AnimationContainer;
        AnimationContainer mAnimationSequences;
 
        const AnimationSequence* mCurrentSequence;
        size_t mCurrentFrameIndex;
        float mTimePerFrame;
        float mFrameTimer;
        bool mIsPlaying;
        bool mIsLooping;
        bool mIsForward;
 
        //The above could become the following for implementation to save space if it ever becomes a concern, will aim
        //for mobile at some point with a few, reasonable? restrictions: Animation speed must be 1fps or faster and no
        //animation can contain more than 256 frames.
        //
        // 4 bits: playing, looping, forward, pingpong
        // 8 bits: currentFrameIndex (0-255)
        // 10 bits: timePerFrame (milliseconds)
        // 10 bits: frameTimer (milliseconds)
    };
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_AnimatedSprite_hpp */
 
 
/*
 
 The AnimatedSprite was designed for thse following usage patterns:
 
 //Essentially just load it up in a table and create an animated sprite.  (data driven, most likely use case)
 void FooSimple(void)
 //Initialization
 mPlayerSprite = tbGraphics::theSpriteManager.GetAnimatedSprite("player_sheet", "player");
 
 //Usage
 mPlayerSprite.PlayAnimation("idle"); / LoopAnimation("idle")
 mPlayerSprite.StopAnimation();
 
 
 //Must support developer creating sprite frames themeselves:
 
 void FooMinimal(void)
 //Initialization
 mPlayerSprite = tbGraphics::theSpriteManager.GetSprite("player_sheet", "player");
 AnimationSequence idleSequence();
 //idleSequence.AddFrame(locationX, locationY, width, height);
 idleSequence.AddFrame(0, 0, 32, 32);
 idleSequence.AddFrame(32, 0, 32, 32);
 idleSequence.AddFrame(64, 0, 32, 32);
 idleSequence.AddFrame(0, 32, 64, 64);  //This method allows size and location differences.
 mPlayerSprite.AddSequence("idle", idleSequence);
 
 AnimationSequence shootSequence;
 // blah blah, shootSequence.AddFrames()
 mPlayerSprite.AddSequence("shoot", shootSequence);
 
 //Usage
 mPlayerSprite.PlayAnimation("idle"); / LoopAnimation("idle")
 mPlayerSprite.StopAnimation();
 
 
 
 void FooBetterMin(void)
 //Initialization
 mPlayerSprite = GetSprite("player_sheet", "player");
 //Create a sequence of 3 - 32x32 frames starting at frame 0 on the sheet.
 
 //Too much effort
 //  AnimationSequence idleSequence();
 //  idleSequence.AddMappedFrames();
 // mPlayerSprite.AddSequence("idle", idleSequence);
 
 mPlayerSprite.AddSequence("idle", tbGraphics::CreateMappedAnimationSequence(32, 32, 0, 3));
 //mPlayerSprite.AddSequence("shoot", AnimationSequence(32, 32, { 0, 1, 3, 4 }));
 mPlayerSprite.AddMappedSequence("shoot", 32, 32, { 0, 1, 3, 4});
 
 //Usage
 mPlayerSprite.PlayAnimation("idle"); / LoopAnimation("idle")
 mPlayerSprite.StopAnimation();
 */