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::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 String& 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 String& spriteSheetName, const String& 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 TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_Sprite_hpp */