Shape.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "BezierPath.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/Container/Deque.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Color.hpp"
 
namespace CeresEngine {
 
    class BezierPath;
 
    class Paint {
    public:
        struct LinearGradient {
            Color startingColor;
 
            Color endingColor;
 
            Point2 startingPosition;
 
            Point2 endingPosition;
        };
 
        struct BoxGradient {
            Color startingColor;
 
            Color endingColor;
 
            Rect2 box;
 
            double radius;
 
            double feather;
        };
 
        struct RadialGradient {
            Color startingColor;
 
            Color endingColor;
 
            Point2 center;
 
            double innerRadius;
 
            double outerRadius;
        };
 
    private:
        using Variant = Variant<Color, LinearGradient, BoxGradient, RadialGradient>;
 
        Variant mData;
 
    public:
        Paint() : Paint(Color()) {}
 
        CE_EXPLICIT(false) Paint(const Color& solidColor) : mData(solidColor) {}
 
        Paint(const Color& startingColor, const Color& endingColor, const Point2& startingPosition = {0, 0}, const Point2& endingPosition = {1, 1})
                : mData(LinearGradient{startingColor, endingColor, startingPosition, endingPosition}) {}
 
        Paint(const Color& startingColor, const Color& endingColor, const Rect2& box = {0, 0, 1, 1}, double radius = 0.0, double feather = 1.0)
                : mData(BoxGradient{startingColor, endingColor, box, radius, feather}) {}
 
        Paint(const Color& startingColor, const Color& endingColor, const Point2& center = {0, 0}, double innerRadius = 0.0, double outerRadius = 1.0)
                : mData(RadialGradient{startingColor, endingColor, center, innerRadius, outerRadius}) {}
 
        Paint(const Paint&) = default;
 
        Paint& operator=(const Paint&) = default;
 
    public:
        [[nodiscard]] bool isColor() const noexcept { return mData.is<Color>(); }
 
        [[nodiscard]] const Color& asColor() const { return mData.as<Color>(); }
 
        [[nodiscard]] bool isLinearGradient() const noexcept { return mData.is<LinearGradient>(); }
 
        [[nodiscard]] const LinearGradient& asLinearGradient() const { return mData.as<LinearGradient>(); }
 
        [[nodiscard]] bool isBoxGradient() const noexcept { return mData.is<BoxGradient>(); }
 
        [[nodiscard]] const BoxGradient& asBoxGradient() const { return mData.as<BoxGradient>(); }
 
        [[nodiscard]] bool isRadialGradient() const noexcept { return mData.is<RadialGradient>(); }
 
        [[nodiscard]] const RadialGradient& asRadialGradient() const { return mData.as<RadialGradient>(); }
 
    public:
        void transform(const AffineTransform& aTransform);
 
        [[nodiscard]] Paint transformed(const AffineTransform& aTransform) const {
            Paint copy = *this;
            copy.transform(aTransform);
            return copy;
        }
 
    public:
        Paint& tint(const Color& color, double factor = 0.5);
 
        [[nodiscard]] Paint tinted(const Color& color, const double factor = 0.5) const {
            Paint copy = *this;
            return copy.tint(color, factor);
        }
 
        Paint& operator*=(const Color& color) { return tint(color); }
 
        [[nodiscard]] Paint operator*(const Color& color) const { return tinted(color); }
    };
 
    class Shape {
    public:
        enum class LineCapStyle {
            Butt,
 
            Round,
 
            Square
        };
 
        enum class LineJoinStyle {
            Miter,
 
            Round,
 
            Bevel
        };
 
        enum class BlendMode {
            Normal,
 
            Multiply,
 
            Screen,
 
            Overlay,
 
            Darken,
 
            Lighten,
 
            ColorDodge,
 
            ColorBurn,
 
            SoftLight,
 
            HardLight,
 
            Difference,
 
            Exclusion,
 
            Hue,
 
            Saturation,
 
            Color,
 
            Luminosity,
 
            Clear,
 
            Copy,
 
            SourceIn,
 
            SourceOut,
 
            SourceAtop,
 
            DestinationOver,
 
            DestinationIn,
 
            DestinationOut,
 
            DestinationAtop,
 
            XorOp,
 
            PlusDarker,
 
            PlusLighter
        };
 
        enum class ElementType {
            Fill,
            Stroke
        };
 
        struct Element {
            const ElementType type;
 
            const BezierPath& path;
 
            Paint paint;
 
            BlendMode blendMode = BlendMode::Normal;
 
            LineCapStyle lineCapStyle = LineCapStyle::Butt;
 
            LineJoinStyle lineJoinStyle = LineJoinStyle::Miter;
 
            double lineWidth = 1.0;
 
            double miterLimit = 10.0;
 
            Element(const ElementType type, const BezierPath& path) : type(type), path(path) {}
        };
 
        using ElementIterator = typename Deque<Element>::const_iterator;
 
    private:
        Deque<BezierPath, AnyAllocator> mPaths{gDefaultAllocator()};
 
        Deque<Element, AnyAllocator> mElements{gDefaultAllocator()};
 
    public:
        explicit Shape();
 
        explicit Shape(AnyAllocatorReference allocator);
 
        Shape(const Shape& other);
        Shape& operator=(const Shape& other);
 
        Shape(const Shape& other, AnyAllocatorReference allocator);
 
        Shape(Shape&& other) noexcept;
        Shape& operator=(Shape&& other) noexcept;
 
        ~Shape() = default;
 
        using allocator_type = AnyStdAllocator<Shape>;
 
        template<typename Allocator> explicit Shape(std::allocator_arg_t, const Allocator& allocator) : Shape(allocator.get_allocator()) {}
 
        template<typename Allocator>
        explicit Shape(std::allocator_arg_t, const Allocator& allocator, const Shape& other) : Shape(other, allocator.get_allocator()) {}
 
    public:
        void stroke(const BezierPath& path, const Paint& paint, double lineWidth = 1.0, BlendMode blendMode = BlendMode::Normal,
            LineCapStyle lineCapStyle = LineCapStyle::Butt, LineJoinStyle lineJoinStyle = LineJoinStyle::Miter, double miterLimit = 10.0);
 
        void stroke(BezierPath&& path, const Paint& paint, double lineWidth = 1.0, BlendMode blendMode = BlendMode::Normal,
            LineCapStyle lineCapStyle = LineCapStyle::Butt, LineJoinStyle lineJoinStyle = LineJoinStyle::Miter, double miterLimit = 10.0);
 
        void fill(const BezierPath& path, const Paint& paint, BlendMode blendMode = BlendMode::Normal);
 
        void fill(BezierPath&& path, const Paint& paint, BlendMode blendMode = BlendMode::Normal);
 
    private:
        [[nodiscard]] const BezierPath& appendPath(const BezierPath& path);
 
        [[nodiscard]] const BezierPath& appendPath(BezierPath&& path);
 
        [[nodiscard]] Element& appendElement(ElementType type, const BezierPath& path);
 
        [[nodiscard]] Element& appendElement(ElementType type, BezierPath&& path);
 
    public:
        void append(const Shape& aShape);
 
        void append(Shape&& aShape);
 
        Shape& operator+=(const Shape& aShape) {
            append(aShape);
            return *this;
        }
 
        Shape& operator+=(Shape&& aShape) {
            append(std::move(aShape));
            return *this;
        }
 
        [[nodiscard]] Shape operator+(const Shape& aShape) const {
            Shape copy = *this;
            copy += aShape;
            return copy;
        }
 
        [[nodiscard]] Shape operator+(Shape&& aShape) const {
            Shape copy = *this;
            copy += std::move(aShape);
            return copy;
        }
 
    public: // Applying Transformations
        void transform(const AffineTransform& aTransform);
 
        [[nodiscard]] Shape transformed(const AffineTransform& aTransform) const&;
 
        [[nodiscard]] Shape&& transformed(const AffineTransform& aTransform) && {
            transform(aTransform);
            return std::move(*this);
        }
 
    public: // Performing Hit-Testing
        [[nodiscard]] bool contains(const Point2& aPoint) const;
 
        [[nodiscard]] bool operator&(const Point2& aPoint) const { return contains(aPoint); }
 
    public: // Transformations
        void flatten();
 
        [[nodiscard]] Shape flattened() const&;
 
        [[nodiscard]] Shape&& flattened() && {
            flatten();
            return std::move(*this);
        }
 
        void reverse();
 
        [[nodiscard]] Shape reversed() const&;
 
        [[nodiscard]] Shape&& reversed() && {
            reverse();
            return std::move(*this);
        }
 
    public: // Querying a Shape
        [[nodiscard]] Rect2 getBounds() const;
 
        [[nodiscard]] Rect2 getControlPointBounds() const;
 
        [[nodiscard]] Rect2 getBoundsAccurate() const;
 
        [[nodiscard]] bool isEmpty() const;
 
    public: // Accessing Elements of a Shape
        [[nodiscard]] UInt32 getElementCount() const;
 
        [[nodiscard]] const Element& getElement(UInt32 index) const;
 
        [[nodiscard]] const Element& operator[](const UInt32 index) const { return getElement(index); }
 
        [[nodiscard]] ElementIterator cbegin() const { return mElements.cbegin(); }
 
        [[nodiscard]] ElementIterator begin() const { return cbegin(); }
 
        [[nodiscard]] ElementIterator cend() const { return mElements.cend(); }
 
        [[nodiscard]] ElementIterator end() const { return cend(); }
 
    public:
        AnyAllocatorReference getAllocator() const noexcept { return mElements.get_allocator().get_allocator(); }
    };
 
} // namespace CeresEngine
 
template<typename Alloc> struct std::uses_allocator<CeresEngine::Shape, Alloc> : std::true_type {};