Path.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/BezierPoint.hpp"
#include "TTauri/Foundation/attributes.hpp"
#include "TTauri/Foundation/TTauriIconParser.hpp"
#include "TTauri/Foundation/ResourceView.hpp"
#include "TTauri/Foundation/exceptions.hpp"
#include "TTauri/Foundation/vec.hpp"
#include "TTauri/Foundation/aarect.hpp"
#include "TTauri/Foundation/mat.hpp"
#include "TTauri/Foundation/R16G16B16A16SFloat.hpp"
#include "TTauri/Foundation/SDF8.hpp"
#include <vector>
 
namespace tt {
 
struct BezierCurve;
template<typename T> struct PixelMap;
 
struct Path {
    std::vector<BezierPoint> points;
 
    std::vector<ssize_t> contourEndPoints;
 
    std::vector<std::pair<ssize_t,vec>> layerEndContours;
 
    void clear() noexcept {
        points.clear();
        contourEndPoints.clear();
        layerEndContours.clear();
    }
 
    [[nodiscard]] ssize_t numberOfContours() const noexcept;
 
    [[nodiscard]] ssize_t numberOfLayers() const noexcept;
 
    [[nodiscard]] bool allLayersHaveSameColor() const noexcept;
 
    [[nodiscard]] aarect boundingBox() const noexcept;
 
    void tryRemoveLayers() noexcept;
 
    [[nodiscard]] std::vector<BezierPoint>::const_iterator beginContour(ssize_t contourNr) const noexcept;
 
    /* Return and end-iterator beyond the end point of a contour.
     */
    [[nodiscard]] std::vector<BezierPoint>::const_iterator endContour(ssize_t contourNr) const noexcept;
 
    /* Return the first contour index of a layer.
     */
    [[nodiscard]] ssize_t beginLayer(ssize_t layerNr) const noexcept;
 
    /* Return beyond the last contour index of a layer.
     */
    [[nodiscard]] ssize_t endLayer(ssize_t layerNr) const noexcept;
 
    [[nodiscard]] std::vector<BezierPoint> getBezierPointsOfContour(ssize_t contourNr) const noexcept;
 
    [[nodiscard]] std::vector<BezierCurve> getBeziersOfContour(ssize_t contourNr) const noexcept;
 
    [[nodiscard]] std::vector<BezierCurve> getBeziers() const noexcept;
 
    [[nodiscard]] std::pair<Path,vec> getLayer(ssize_t layerNr) const noexcept;
 
    [[nodiscard]] vec getColorOfLayer(ssize_t layerNr) const noexcept;
 
    void setColorOfLayer(ssize_t layerNr, vec fillColor) noexcept;
 
    [[nodiscard]] bool isContourOpen() const noexcept;
 
    void closeContour() noexcept;
 
    [[nodiscard]] bool hasLayers() const noexcept;
 
    [[nodiscard]] bool isLayerOpen() const noexcept;
 
    void closeLayer(vec fillColor) noexcept;
 
    void optimizeLayers() noexcept;
 
    [[nodiscard]] vec currentPosition() const noexcept;
 
    void moveTo(vec position) noexcept;
 
    void moveRelativeTo(vec direction) noexcept;
 
    void lineTo(vec position) noexcept;
 
    void lineRelativeTo(vec direction) noexcept;
 
    void quadraticCurveTo(vec controlPosition, vec position) noexcept;
 
    void quadraticCurveRelativeTo(vec controlDirection, vec direction) noexcept;
 
    void cubicCurveTo(vec controlPosition1, vec controlPosition2, vec position) noexcept;
 
    void cubicCurveRelativeTo(vec controlDirection1, vec controlDirection2, vec direction) noexcept;
 
    void arcTo(float radius, vec position) noexcept;
 
    void addRectangle(aarect r, vec corners={0.0f, 0.0f, 0.0f, 0.0f}) noexcept;
 
    void addCircle(vec position, float radius) noexcept;
 
    void addContour(std::vector<BezierCurve> const &contour) noexcept;
 
    void addContour(std::vector<BezierPoint>::const_iterator const &begin, std::vector<BezierPoint>::const_iterator const &end) noexcept;
 
    void addContour(std::vector<BezierPoint> const &contour) noexcept;
 
    void addPath(Path const &path, vec fillColor) noexcept;
 
    void addStroke(Path const &path, vec strokeColor, float strokeWidth, LineJoinStyle lineJoinStyle=LineJoinStyle::Miter, float tolerance=0.05f) noexcept;
 
    [[nodiscard]] Path toStroke(float strokeWidth=1.0f, LineJoinStyle lineJoinStyle=LineJoinStyle::Miter, float tolerance=0.05f) const noexcept;
 
    [[nodiscard]] Path centerScale(vec extent, float padding=0.0) const noexcept;
 
    Path &operator+=(Path const &rhs) noexcept;
 
    [[nodiscard]] friend Path operator+(Path lhs, Path const &rhs) noexcept {
        return lhs += rhs;
    }
 
    template<typename M, std::enable_if_t<is_mat_v<M>, int> = 0>
    Path &operator*=(M const &rhs) noexcept {
        for (auto &&point: points) {
            point *= rhs;
        }
        return *this;
    }
 
    template<typename M, std::enable_if_t<is_mat_v<M>, int> = 0>
    friend Path operator*(M const &lhs, Path rhs) noexcept {
        return rhs *= lhs;
    }
};
 
 
 
 
 
void composit(PixelMap<R16G16B16A16SFloat>& dst, vec color, Path const &mask) noexcept;
 
void composit(PixelMap<R16G16B16A16SFloat>& dst, Path const &mask) noexcept;
 
void fill(PixelMap<SDF8> &dst, Path const &path) noexcept;
 
}
 
namespace tt {
 
template<>
inline std::unique_ptr<Path> parseResource(URL const &location)
{
    if (location.extension() == "tticon") {
        ttlet view = location.loadView();
 
        try {
            return std::make_unique<Path>(parseTTauriIcon(*view));
        } catch (error &e) {
            e.set<url_tag>(location);
            throw;
        }
 
    } else {
        TTAURI_THROW(url_error("Unknown extension")
            .set<url_tag>(location)
        );
    }
}
 
}