BezierPath.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 "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Deque.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Angle.hpp"
#include "CeresEngine/Math/Rect.hpp"
 
#include <cstddef>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace CeresEngine {
 
    class BezierPath {
    public:
        enum class WindingRule : UInt8 {
            NonZero,
 
            EvenOdd
        };
 
        enum class ElementType : UInt8 {
            MoveTo,
 
            LineTo,
 
            CurveTo,
 
            ClosePath
        };
 
        struct Element {
            ElementType type;
 
            Point2 points[3];
        };
 
        using ElementIterator = typename Deque<Element, AnyAllocator>::const_iterator;
 
        using ElementReverseIterator = typename Deque<Element, AnyAllocator>::const_reverse_iterator;
 
        struct SubPath {
            bool closed = false;
 
            UInt32 firstIndex;
 
            UInt32 lastIndex;
        };
 
    private:
        WindingRule mWindingRule = WindingRule::NonZero;
 
        double mFlatness = 0.6;
 
        Deque<Element, AnyAllocator> mElements{gDefaultAllocator()};
 
    public:
        explicit BezierPath();
 
        explicit BezierPath(AnyAllocatorReference allocator);
 
        BezierPath(const BezierPath&) = default;
        BezierPath& operator=(const BezierPath&) = default;
        BezierPath(const BezierPath&, AnyAllocatorReference allocator);
 
        BezierPath(BezierPath&&) noexcept = default;
        BezierPath& operator=(BezierPath&&) noexcept = default;
 
        ~BezierPath() = default;
 
        using allocator_type = AnyStdAllocator<BezierPath>;
 
        template<typename Allocator> explicit BezierPath(std::allocator_arg_t, const Allocator& allocator) : BezierPath(allocator.get_allocator()) {}
 
        template<typename Allocator>
        explicit BezierPath(std::allocator_arg_t, const Allocator& allocator, const BezierPath& other) : BezierPath(other, allocator.get_allocator()) {}
 
    public: // Constructing a Path
        void move(const Point2& aPoint);
 
        void move(double x, double y) { move({x, y}); }
 
        void line(const Point2& aPoint);
 
        void line(double x, double y) { line({x, y}); }
 
        void curve(const Point2& aPoint, const Point2& controlPoint1, const Point2& controlPoint2);
 
        void curve(double x, double y, double c1x, double c1y, double c2x, double c2y) { curve({x, y}, {c1x, c1y}, {c2x, c2y}); }
 
        void close();
 
        void relativeMove(const Point2& aPoint);
 
        void relativeLine(const Point2& aPoint);
 
        void relativeCurve(const Point2& aPoint, const Point2& controlPoint1, const Point2& controlPoint2);
 
    public: // Appending Common Shapes to a Path
        void append(const BezierPath& aPath);
 
        BezierPath& operator+=(const BezierPath& aPath) {
            append(aPath);
            return *this;
        }
 
        BezierPath operator+(const BezierPath& aPath) const {
            BezierPath copy = *this;
            copy += aPath;
            return copy;
        }
 
        void appendOval(const Rect2& aRect);
 
        void appendRect(const Rect2& aRect);
 
        void appendRoundedRect(const Rect2& aRect, double xRadius, double yRadius);
 
        void appendArc(const Point2& fromPoint, const Point2& toPoint, double radius);
 
        void appendArc(const Point2& center, double radius, const Degree& startAngle, const Degree& endAngle, bool clockwise = false);
 
    public: // Applying Transformations
        void transform(const AffineTransform& aTransform);
 
        [[nodiscard]] BezierPath transformed(const AffineTransform& aTransform) const;
 
    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]] BezierPath flattened() const;
 
        void reverse();
 
        [[nodiscard]] BezierPath reversed() const;
 
        [[nodiscard]] BezierPath expandedStrokeAsFan(const double innerWidth, const double outerWidth) const {
            return expandedStrokeInternal(innerWidth, outerWidth, true);
        }
 
        [[nodiscard]] BezierPath expandedStrokeAsStrip(const double width) const { return expandedStrokeAsFan(width / 2.0, width / 2.0); }
 
        [[nodiscard]] BezierPath expandedStroke(const double innerWidth, const double outerWidth) const { return expandedStrokeInternal(innerWidth, outerWidth, false); }
 
        [[nodiscard]] BezierPath expandedStroke(const double width) const { return expandedStroke(width / 2.0, width / 2.0); }
 
    private:
        [[nodiscard]] BezierPath expandedStrokeInternal(double innerWidth, double outerWidth, bool asTriangleFan) const;
 
    public: // Querying a Path
        [[nodiscard]] Rect2 getBounds() const;
 
        [[nodiscard]] Rect2 getControlPointBounds() const;
 
        [[nodiscard]] Rect2 getBoundsAccurate() const;
 
        [[nodiscard]] Point2 getCurrentPoint() const;
 
        [[nodiscard]] bool isEmpty() const;
 
        [[nodiscard]] bool isOpen() const;
 
        [[nodiscard]] bool isFlat() const;
 
    public: // Accessing Elements of a Path
        [[nodiscard]] UInt32 getElementCount() const;
 
        [[nodiscard]] const Element& getElement(UInt32 index) const;
 
        [[nodiscard]] ElementType getElement(UInt32 index, Point2& aPoint0, Point2& aPoint1, Point2& aPoint2) const;
 
        const Element& operator[](const UInt32 index) const { return getElement(index); }
 
        void removeAllPoints();
 
        void clear() { return removeAllPoints(); }
 
        [[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(); }
 
        [[nodiscard]] ElementReverseIterator crbegin() const { return mElements.crbegin(); }
 
        [[nodiscard]] ElementReverseIterator rbegin() const { return crbegin(); }
 
        [[nodiscard]] ElementReverseIterator crend() const { return mElements.crend(); }
 
        [[nodiscard]] ElementReverseIterator rend() const { return crend(); }
 
        [[nodiscard]] Vector<SubPath> getSubPaths() const;
 
    public:
        [[nodiscard]] WindingRule getWindingRule() const { return mWindingRule; }
 
        void setWindingRule(WindingRule windingRule);
 
        [[nodiscard]] double getFlatness() const { return mFlatness; }
 
        void setFlatness(double flatness);
 
    public: // SVG
        String toSVG() const;
 
    public:
        [[nodiscard]] static BezierPath oval(const Rect2& aRect) { return oval(gDefaultAllocator(), aRect); }
 
        [[nodiscard]] static BezierPath oval(AnyAllocatorReference allocator, const Rect2& aRect);
 
        [[nodiscard]] static BezierPath rect(const Rect2& aRect) { return rect(gDefaultAllocator(), aRect); }
 
        [[nodiscard]] static BezierPath rect(AnyAllocatorReference allocator, const Rect2& aRect);
 
        [[nodiscard]] static BezierPath roundedRect(const Rect2& aRect, const double xRadius, const double yRadius) {
            return roundedRect(gDefaultAllocator(), aRect, xRadius, yRadius);
        }
 
        [[nodiscard]] static BezierPath roundedRect(AnyAllocatorReference allocator, const Rect2& aRect, double xRadius, double yRadius);
 
        [[nodiscard]] static BezierPath arc(const Point2& fromPoint, const Point2& toPoint, const double radius) {
            return arc(gDefaultAllocator(), fromPoint, toPoint, radius);
        }
 
        [[nodiscard]] static BezierPath arc(AnyAllocatorReference allocator, const Point2& fromPoint, const Point2& toPoint, double radius);
 
        [[nodiscard]] static BezierPath arc(const Point2& center, const double radius, const Degree& startAngle, const Degree& endAngle, const bool clockwise = false) {
            return arc(gDefaultAllocator(), center, radius, startAngle, endAngle, clockwise);
        }
 
        [[nodiscard]] static BezierPath arc(AnyAllocatorReference allocator, const Point2& center, double radius, const Degree& startAngle,
            const Degree& endAngle, bool clockwise = false);
 
    public:
        friend bool operator==(const BezierPath& lhs, const BezierPath& rhs) noexcept;
        friend bool operator!=(const BezierPath& lhs, const BezierPath& rhs) noexcept;
 
    public:
        AnyAllocatorReference getAllocator() const noexcept { return mElements.get_allocator().get_allocator(); }
    };
 
    template<std::size_t I> decltype(auto) get(BezierPath::Element& element) noexcept {
        static_assert(I <= 3);
        if constexpr(I == 0) {
            return element.type;
        } else if constexpr(I == 1) {
            return element.points[I - 1];
        }
    }
 
    template<std::size_t I> decltype(auto) get(const BezierPath::Element& element) noexcept {
        static_assert(I <= 3);
        if constexpr(I == 0) {
            return element.type;
        } else {
            return element.points[I - 1];
        }
    }
} // namespace CeresEngine
 
template<typename Alloc> struct std::uses_allocator<CeresEngine::BezierPath, Alloc> : std::true_type {};
 
template<> struct std::tuple_size<CeresEngine::BezierPath::Element> : std::integral_constant<std::size_t, 4> {};
 
template<std::size_t N> struct std::tuple_element<N, CeresEngine::BezierPath::Element> {
    using type = decltype(get<N>(std::declval<CeresEngine::BezierPath::Element>()));
};
 
template<> struct std::tuple_size<const CeresEngine::BezierPath::Element> : std::integral_constant<std::size_t, 4> {};
 
template<std::size_t N> struct std::tuple_element<N, const CeresEngine::BezierPath::Element> {
    using type = decltype(get<N>(std::declval<const CeresEngine::BezierPath::Element>()));
};