tb_graphic.h

#ifndef _TurtleBrains_Graphic_h_
#define _TurtleBrains_Graphic_h_

#include "tb_color.h"
#include "tb_texture_manager.h"

#include "../math/tb_vector.h"

namespace TurtleBrains
{
    namespace Graphics
    {
        PixelSpace ScreenWidth(void);

        PixelSpace ScreenHeight(void);

        float ScreenAspectRatio(void);

        tbMath::Vector2 ScreenCenter(void);

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

        class Graphic
        {
        public:
            Graphic(void);

            Graphic(const Graphic& other);

            virtual ~Graphic(void);

            bool IsActive(void) const;

            void SetActive(const bool isActive);

            void Update(const float deltaTime);

            bool IsVisible(void) const;

            void SetVisible(const bool isVisible);

            void Render(void) const;

            const tbMath::Vector2& GetPosition(void) const;

            void SetPosition(const float x, const float y);

            void SetPosition(const tbMath::Vector2& position);

            void SetOrigin(const AnchorLocation& anchor);

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

            float GetDepth(void) const;

            void SetDepth(const float newDepth);

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

            inline float GetRotation(void) const { return mOrientation; }

            inline void SetScroll(const float scroll) { mScroll.x = scroll; mScroll.y = scroll; }

            inline void SetScroll(const float scrollX, const float scrollY) { mScroll.x = scrollX; mScroll.y = scrollY; }

            bool IsRelative(void) const;

            //
            //  @details TODO: TIM: Implementation: Currently this is unimplemented and undocumented, all Graphics
            //    are currently relative.
            //
            //void SetRelative(const bool isRelative);

            virtual void SetColor(const tbGraphics::Color& newColor);

            virtual PixelSpace GetPixelWidth(void) const { return 0; }

            virtual PixelSpace GetPixelHeight(void) const { return 0;  }

            float GetWidth(void) const { return static_cast<float>(GetPixelWidth()); }

            float GetHeight(void) const { return static_cast<float>(GetPixelHeight()); }

        protected:
            virtual void OnUpdate(const float deltaTime);

            virtual void OnRender(void) const = 0;

            const Color& GetColor(void) const;

            virtual void ApplyTransform(void) const;

            virtual void PopTransform(void) const;

        private:
            tbMath::Vector2 mPosition;
            tbMath::Vector2 mScroll;
            tbMath::Vector2 mOrigin;    //0,0 = top-left, 1/2w, 1/2h = center.
            tbMath::Vector2 mScale;
            float mOrientation;
            float mDepthZ;
            bool mIsActive;
            bool mIsVisible;
            bool mIsRelative;
            Color mColor;
        };

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

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* _TurtleBrains_Graphic_h_ */