tb_graphic.hpp

#ifndef TurtleBrains_Graphic_hpp
#define TurtleBrains_Graphic_hpp

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

#include <turtle_brains/math/tb_vector.hpp>

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

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

            void SetOrigin(const AnchorLocation& anchor, const tbMath::Vector2& offset = tbMath::Vector2::Zero());

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

            inline void SetOrigin(const tbMath::Vector2& origin) { mOrigin = origin; }

            float GetDepth(void) const;

            void SetDepth(const float newDepth);

            inline const tbMath::Vector2& GetScale(void) const { return mScale; }

            void SetScale(const float scale);

            void SetScale(const tbMath::Vector2& scale);

            void SetScale(const float scaleX, const float scaleY);

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

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

            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: TurtleBrains: Implementation: Currently this is unimplemented and undocumented, all Graphics
            //    are currently relative.
            //
            //void SetRelative(const bool isRelative);

            const Color& GetColor(void) const;

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

            float GetScaledWidth(void) const { return GetWidth() * GetScale().x; }

            float GetScaledHeight(void) const { return GetHeight() * GetScale().y; }

            bool UnstableIsPointContained(const tbMath::Vector2& point) const;

        protected:
            virtual void OnUpdate(const float deltaTime);

            virtual void OnRender(void) const = 0;

            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_hpp */