tb_animated_sprite.h

#ifndef _TurtleBrains_AnimatedSprite_h_
#define _TurtleBrains_AnimatedSprite_h_

#include "tb_sprite.h"
#include "tb_sprite_map.h"

#include <vector>
#include <map>

namespace TurtleBrains
{
    namespace 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);

            AnimatedSprite(const tbCore::tbString& spriteSheetName, const tbCore::tbString& spriteName);

            AnimatedSprite(const AnimatedSprite& other);

            AnimatedSprite& operator=(const AnimatedSprite& other);

            virtual ~AnimatedSprite(void);

            void AddSequence(const tbCore::tbString& sequenceName, const AnimationSequence& sequence);

            void AddMappedSequence(const tbCore::tbString& sequenceName, const SpriteMap& spriteMap, const std::vector<size_t> frames);

            void AddMappedSequence(const tbCore::tbString& sequenceName, const SpriteMap& spriteMap, const size_t& startFrameIndex,
                const size_t& frameCount);

            void PlayAnimation(const tbCore::tbString& sequenceName, const bool isLooping, const bool isForward = true,
                const float timePerFrame = kDefaultTimePerFrame);

            void PlayAnimation(const tbCore::tbString& sequenceName);

            void StopAnimation(void);

            bool IsAnimationPlaying(void) const;

            bool IsAnimationPlaying(const tbCore::tbString& sequenceName) const;

            size_t GetFrameIndex(void) const { return mCurrentFrameIndex; }

        protected:

            virtual void OnUpdate(const float deltaTime) override;

        private:
            typedef std::map<tbCore::tbString, 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 Graphics */
}; /* namespace TurtleBrains */

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* _TurtleBrains_AnimatedSprite_h_ */


/*

 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();
 */