tb_graphic.hpp

 
#ifndef TurtleBrains_Graphic_hpp
#define TurtleBrains_Graphic_hpp
 
#include <turtle_brains/graphics/tb_anchor_location.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::Graphics
{
    PixelSpace ScreenWidth(void);
 
    PixelSpace ScreenHeight(void);
 
    tbMath::Vector2 ScreenSize(void);
 
    float ScreenAspectRatio(void);
 
    tbMath::Vector2 ScreenCenter(void);
 
    class Graphic
    {
    public:
        Graphic(void);
 
        Graphic(const Graphic& other) = default;
 
        virtual ~Graphic(void) = default;
 
        Graphic& operator=(const Graphic& other) = default;
 
        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 float offsetX, const float offsetY);
 
        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 tbMath::Angle GetRotation(void) const { return mRotation; }
 
        inline void SetRotation(const tbMath::Angle& angle) { mRotation = angle; }
 
 
        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; }
 
        tbMath::Vector2 GetAnchorPosition(const tbGraphics::AnchorLocation& anchor,
            const float offsetX, const float offsetY) const;
 
        tbMath::Vector2 GetAnchorPosition(const tbGraphics::AnchorLocation& anchor,
            const tbMath::Vector2& offset = tbMath::Vector2::Zero()) const;
 
        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;
        tbMath::Angle mRotation;
        float mDepthZ;
        bool mIsActive;
        bool mIsVisible;
        bool mIsRelative;
        Color mColor;
    };
 
    tbMath::Vector2 GetAnchorPositionOfScreen(const tbGraphics::AnchorLocation& anchor, const float offsetX, const float offsetY);
 
    tbMath::Vector2 GetAnchorPositionOfScreen(const tbGraphics::AnchorLocation& anchor, const tbMath::Vector2& offset = tbMath::Vector2::Zero());
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_Graphic_hpp */