tb_basic_shapes.hpp

 
#ifndef TurtleBrains_BasicShapes_hpp
#define TurtleBrains_BasicShapes_hpp
 
#include <turtle_brains/graphics/tb_graphic.hpp>
#include <turtle_brains/math/tb_vector.hpp>
 
#include <array>
#include <vector>
#include <memory>
 
namespace TurtleBrains::Graphics
{
    namespace Implementation
    {
        struct PolygonShapeData;
        struct QuadShapeData;
    };
 
    class OutlinedPolygonShape;
 
    class PolygonShape : public Graphic
    {
    public:
 
        PolygonShape(void);
 
        PolygonShape(const PolygonShape& other);
 
        PolygonShape(PolygonShape&& other) noexcept;
 
        virtual ~PolygonShape(void);
 
        PolygonShape& operator=(const PolygonShape& other);
 
        PolygonShape& operator=(PolygonShape&& other) noexcept;
 
        virtual void SetColor(const tbGraphics::Color& newColor) override;
 
        virtual PixelSpace GetPixelWidth(void) const override;
 
        virtual PixelSpace GetPixelHeight(void) const override;
 
        virtual void ClearVertices(void);
 
        virtual void AddVertex(const tbMath::Vector2& position, const Color& color = ColorPalette::White,
            const tbMath::Vector2& uv = tbMath::Vector2::Zero());
 
        void SetAsTriangles(void);
 
        void SetAsTriangleFan(void);
 
        void SetAsTriangleStrip(void);
 
        void SetAsLines(void);
 
        void SetAsLineStrip(void);
 
        void SetAsLineLoop(void);
 
        void SetVertexPosition(size_t vertexIndex, const tbMath::Vector2& position);
 
        void RecomputeBounds(void);
 
    protected:
        virtual void OnRender(void) const override;
 
    private:
        friend class OutlinedPolygonShape;
 
        std::unique_ptr<Implementation::PolygonShapeData> mData;
    };
 
 
    class OutlinedPolygonShape : public PolygonShape
    {
    public:
        OutlinedPolygonShape(void);
 
        OutlinedPolygonShape(const OutlinedPolygonShape& other);
 
        virtual ~OutlinedPolygonShape(void);
 
        virtual void ClearVertices(void) override;
 
        void SetFillColor(const tbGraphics::Color& fillColor);
 
        void SetOutlineColor(const tbGraphics::Color& outlineColor);
 
    protected:
        void AddOutlineVertex(const tbMath::Vector2& position, const tbMath::Vector2& uv = tbMath::Vector2::Zero());
 
        void AddShapeVertex(const tbMath::Vector2& position, const tbMath::Vector2& uv = tbMath::Vector2::Zero());
 
        void AddShapeAndOutlineVertex(const tbMath::Vector2& position, const tbMath::Vector2& uv = tbMath::Vector2::Zero());
 
        virtual void OnRender(void) const override;
 
    private:
        //Privately overridden to protect from ambiguous SetColor() mistakes, use SetFillColor() or SetOutlineColor().
        virtual void SetColor(const tbGraphics::Color& color) override;
 
        //Privately overridden to protect from ambiguous AddVertex() mistakes, use AddOutlinedVertex(), AddShapeVertex()
        //  or AddShapeAndOutlineVertex() for clarity.
        virtual void AddVertex(const tbMath::Vector2& position, const tbGraphics::Color& color = tbGraphics::ColorPalette::White,
            const tbMath::Vector2& uv = tbMath::Vector2::Zero()) override;
 
        PolygonShape mOutline;
    };
 
 
    class BoxShape : public PolygonShape
    {
    public:
        explicit BoxShape(const float width = 64.0f, const float height = 64.0f, const tbGraphics::Color& color = tbGraphics::ColorPalette::White,
            const tbMath::Vector2& position = tbMath::Vector2::Zero());
 
        BoxShape(const BoxShape& other) = default;
 
        virtual ~BoxShape(void) = default;
 
        BoxShape& operator=(const BoxShape& other) = default;
 
        void SetSize(const float width, const float height);
    };
 
 
    class QuadShape : public Graphic
    {
    public:
        enum QuadVertex { kTopLeft, kTopRight, kBottomLeft, kBottomRight };
 
        QuadShape(const float width, const float height, const tbGraphics::Color& color = tbGraphics::ColorPalette::White,
            const tbMath::Vector2& position = tbMath::Vector2::Zero());
 
        QuadShape(const QuadShape& other) noexcept;
        QuadShape(QuadShape&& other) noexcept;
 
        virtual ~QuadShape(void);
 
        QuadShape& operator=(const QuadShape& other) noexcept;
        QuadShape& operator=(QuadShape&& other) noexcept;
 
        virtual void SetColor(const tbGraphics::Color& newColor) override;
 
        virtual void SetColor(const tbGraphics::Color& topLeftColor, const tbGraphics::Color& topRightColor,
            const tbGraphics::Color& bottomLeftColor, const tbGraphics::Color& bottomRightColor);
 
        void SetPosition(const float x, const float y) { Graphic::SetPosition(x, y); }
        void SetPosition(const tbMath::Vector2& position) { Graphic::SetPosition(position); }
        void SetPosition(const QuadVertex vertexIndex, const tbMath::Vector2& position);
 
        const tbMath::Vector2& GetPosition(void) const { return Graphic::GetPosition(); }
        tbMath::Vector2 GetPosition(const QuadVertex vertexPosition) const;
 
        void SetSize(const float width, const float height);
 
        virtual PixelSpace GetPixelWidth(void) const override;
 
        virtual PixelSpace GetPixelHeight(void) const override;
 
        virtual void OnRender(void) const override;
 
    private:
        std::unique_ptr<Implementation::QuadShapeData> mData;
    };
 
 
    class OutlinedBoxShape : public OutlinedPolygonShape
    {
    public:
        explicit OutlinedBoxShape(const float width = 64.0f, const float height = 64.0f, const tbGraphics::Color& fillColor = tbGraphics::ColorPalette::White,
            const tbGraphics::Color& outlineColor = tbGraphics::ColorPalette::Black, const tbMath::Vector2& position = tbMath::Vector2::Zero());
 
        virtual ~OutlinedBoxShape(void);
    };
 
 
    class FullScreenQuad : public BoxShape
    {
    public:
        explicit FullScreenQuad(const tbGraphics::Color& color);
 
        virtual ~FullScreenQuad(void);
    };
 
 
    class CircleShape : public PolygonShape
    {
    public:
        explicit CircleShape(const float radius = 64.0f, const tbGraphics::Color& color = tbGraphics::ColorPalette::White,
            const tbMath::Vector2& position = tbMath::Vector2::Zero(), const int sectionCount = 30);
 
        virtual ~CircleShape(void);
 
        void SetSize(const float radius, const int sectionCount = 30);
    };
 
 
    class OutlinedCircleShape : public OutlinedPolygonShape
    {
    public:
        explicit OutlinedCircleShape(const float radius = 64.0f, const tbGraphics::Color& fillColor = tbGraphics::ColorPalette::White,
            const tbGraphics::Color& outlineColor = tbGraphics::ColorPalette::Black, const tbMath::Vector2& position = tbMath::Vector2::Zero(),
            const int sectionCount = 30);
 
        virtual ~OutlinedCircleShape(void);
    };
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_BasicShapes_hpp */