tb_sprite.hpp

#ifndef TurtleBrains_Sprite_hpp
#define TurtleBrains_Sprite_hpp

#include <turtle_brains/graphics/tb_graphic.hpp>
#include <turtle_brains/graphics/tb_texture_manager.hpp>
#include <turtle_brains/graphics/tb_color.hpp>

namespace TurtleBrains
{
    namespace Graphics
    {

        struct SpriteFrame
        {   //TODO: TIM: Planning: These may turn into PixelSpace values, (int), that is what they are, but they are used as float.
            float x;   
            float y;   
            float w;   
            float h;   
            TexelSpace uvx; 
            TexelSpace uvy; 
            TexelSpace uvw; 
            TexelSpace uvh; 
            TextureHandle mTexture;   

            //Optimize: TurtleBrains: It might be worth doing this for both optimizing for texture lookups and
            //convenience/optimization if using a texture packing tool that rotates sprites and cuts transparency away from the sprite.
            //PixelSpace mTextureWidth;
            //PixelSpace mTextureHeight; //32bits
            //rotation byte/ (2bits) //0, 90, 180, 270
            //32bits offsets, 32bits size change


            PixelSpace GetPixelTop(void) const;

            PixelSpace GetPixelLeft(void) const;

            PixelSpace GetPixelRight(void) const;

            PixelSpace GetPixelBottom(void) const;

            PixelSpace GetPixelWidth(void) const;

            PixelSpace GetPixelHeight(void) const;

            TexelSpace GetTexelTop(void) const;

            TexelSpace GetTexelLeft(void) const;

            TexelSpace GetTexelRight(void) const;

            TexelSpace GetTexelBottom(void) const;

            TexelSpace GetTexelWidth(void) const;

            TexelSpace GetTexelHeight(void) const;

            static SpriteFrame CreateWith(const TextureHandle& textureHandle);

            static SpriteFrame CreateWith(const TextureHandle& textureHandle, const PixelSpace& frameX, const PixelSpace& frameY,
                const PixelSpace& frameWidth, const PixelSpace& frameHeight);
        };

        class Sprite : public Graphic
        {
        public:
            explicit Sprite(const SpriteFrame& spriteFrame);

            explicit Sprite(const tbCore::tbString& textureFile, const PixelSpace& frameX = 0, const PixelSpace& frameY = 0,
                const PixelSpace& frameWidth = 0, const PixelSpace& frameHeight = 0);

            explicit Sprite(const TextureHandle& textureHandle, const PixelSpace& frameX = 0, const PixelSpace& frameY = 0,
                                            const PixelSpace& frameWidth = 0, const PixelSpace& frameHeight = 0);

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

            Sprite(const Sprite& other);

            virtual ~Sprite(void);

            Sprite& operator=(const Sprite& other);

            virtual PixelSpace GetPixelWidth(void) const override;

            virtual PixelSpace GetPixelHeight(void) const override;

            void SetFlippedHorizontally(bool isFlippedHorizontally);

            void SetFlippedVertically(bool isFlippedVertically);

            bool IsFlippedHorizontally(void) const;

            bool IsFlippedVertically(void) const;

        protected:
            virtual void OnRender(void) const override;

            void SetSpriteFrame(const SpriteFrame& spriteFrame);

            const SpriteFrame& GetSpriteFrame(void) const;

        private:
            SpriteFrame mSpriteFrame;
            bool mIsFlippedHorizontally;
            bool mIsFlippedVertically;
        };

    }; /* namespace Graphics */
}; /* namespace TurtleBrains */

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* TurtleBrains_Sprite_hpp */