tb_basic_shapes.hpp

#ifndef TurtleBrains_BasicShapes_hpp
#define TurtleBrains_BasicShapes_hpp

#include <turtle_brains/graphics/implementation/tbi_renderer.hpp>
#include <turtle_brains/graphics/tb_graphic.hpp>
#include <turtle_brains/math/tb_vector.hpp>

#include <vector>

namespace TurtleBrains
{
    namespace Graphics
    {
        class OutlinedPolygonShape;

        class PolygonShape : public Graphic
        {
        public:

            PolygonShape(void);

            PolygonShape(const PolygonShape& other);

            virtual ~PolygonShape(void);

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

            virtual PixelSpace GetPixelWidth(void) const override;

            virtual PixelSpace GetPixelHeight(void) const override;

        protected:
            virtual void OnRender(void) const override;

            virtual void ClearVertices(void);

            virtual void AddVertex(const tbMath::Vector2& position);

            void SetAsTriangles(void) { mPrimitiveType = tbImplementation::Renderer::kTriangles; }

            void SetAsTriangleFan(void) { mPrimitiveType = tbImplementation::Renderer::kTriangleFan; }

            void SetAsTriangleStrip(void) { mPrimitiveType = tbImplementation::Renderer::kTriangleStrip; }

            void SetAsLines(void) { mPrimitiveType = tbImplementation::Renderer::kLines; }

            void SetAsLineStrip(void) { mPrimitiveType = tbImplementation::Renderer::kLineStrip; }

            void SetAsLineLoop(void) { mPrimitiveType = tbImplementation::Renderer::kLineLoop; }

            void SetVertexPosition(size_t vertexIndex, const tbMath::Vector2& position);

            void RecomputeBounds(void);

        private:
            friend class OutlinedPolygonShape;

            std::vector<tbImplementation::Renderer::Vertex2D> mVertices;
            tbImplementation::Renderer::PrimitiveType mPrimitiveType;
            tbMath::Vector2 mMinimumBounds;
            tbMath::Vector2 mMaximumBounds;
        };


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

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

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

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

            void SetSize(const float width, const float height);

            virtual ~BoxShape(void);
        };


        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 Graphics */
}; /* namespace TurtleBrains */

namespace tbGraphics = TurtleBrains::Graphics;

#endif /* TurtleBrains_BasicShapes_hpp */