tb_sprite.h

#ifndef _TurtleBrains_Sprite_h_
#define _TurtleBrains_Sprite_h_

#include "tb_graphic.h"
#include "tb_texture_manager.h"
#include "tb_color.h"
#include "../math/tb_math.h"

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;   

            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);
        };

        enum AnchorLocation
        {
            kAnchorCenter = 0,   
            kAnchorTopLeft,      
            kAnchorTopCenter,    
            kAnchorTopRight,     
            kAnchorCenterLeft,   
            kAnchorCenterRight,  
            kAnchorBottomLeft,   
            kAnchorBottomCenter, 
            kAnchorBottomRight,  
        };

        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 Sprite& other);

            virtual ~Sprite(void);

            Sprite& operator=(const Sprite& other);

            void SetOrigin(const AnchorLocation& anchor);

            inline void SetOrigin(const float originX, const float originY) { mOrigin.x = originX; mOrigin.y = originY; }

            inline void SetScale(const float scale) { mScale.x = mScale.y = scale; }

            inline void SetScale(const float scaleX, const float scaleY) { mScale.x = scaleX; mScale.y = scaleY; }

            inline void SetRotation(const float rotation) { mOrientation = rotation; }

        protected:
            virtual void OnRender(void) const override;

            void SetSpriteFrame(const SpriteFrame& spriteFrame);

            const SpriteFrame& GetSpriteFrame(void) const;

        private:
            tbMath::Vector2 mOrigin;    //0,0 = top-left, 1/2w, 1/2h = center.
            tbMath::Vector2 mScale;
            float mOrientation;
            SpriteFrame mSpriteFrame;
        };

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

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* _TurtleBrains_Sprite_h_ */