include/rive/shapes/shape_paint_path.hpp

#ifndef _RIVE_SHAPE_PAINT_PATH_HPP_
#define _RIVE_SHAPE_PAINT_PATH_HPP_

#include "rive/math/raw_path.hpp"
#include "rive/renderer.hpp"

namespace rive
{
class Component;
class Factory;
class ShapePaintPath
{
public:
    ShapePaintPath(bool isLocal = true);
    ShapePaintPath(bool isLocal, FillRule fillRule);
    RenderPath* renderPath(const Component* component);
    RenderPath* renderPath(Factory* factory);
    const RawPath* rawPath() const { return &m_rawPath; }
    RawPath* mutableRawPath() { return &m_rawPath; }
    bool isLocal() const { return m_isLocal; }
    FillRule fillRule() const { return m_fillRule; }
    bool empty() const { return m_rawPath.empty(); }

    void rewind();
    void rewind(bool isLocal, FillRule fillRule)
    {
        m_isLocal = isLocal;
        m_fillRule = fillRule;
        rewind();
    }
    void rewind(bool isLocal)
    {
        m_isLocal = isLocal;
        rewind();
    }
    void addPath(const RawPath& rawPath, const Mat2D* transform = nullptr);
    void addPathBackwards(const RawPath& rawPath,
                          const Mat2D* transform = nullptr);

    // Determines winding of the rawPath and adds in the clockwise order.
    void addPathClockwise(const RawPath& rawPath,
                          const Mat2D* transform = nullptr);

    void addPath(const ShapePaintPath* path, const Mat2D* transform = nullptr)
    {
        return addPath(*path->rawPath(), transform);
    }
    void addPathBackwards(const ShapePaintPath* path,
                          const Mat2D* transform = nullptr)
    {
        return addPathBackwards(*path->rawPath(), transform);
    }

    void addRect(const AABB& aabb, PathDirection dir = PathDirection::cw)
    {
        m_rawPath.addRect(aabb, dir);
    }

    const bool hasRenderPath() const
    {
        return m_renderPath != nullptr && !m_isRenderPathDirty;
    }

#ifdef TESTING
    size_t numContours()
    {
        size_t contours = 0;
        for (auto verb : m_rawPath.verbs())
        {
            if (verb == PathVerb::move)
            {
                contours++;
            }
        }
        return contours;
    }
#endif
private:
    bool m_isRenderPathDirty = true;
    rcp<RenderPath> m_renderPath;
    RawPath m_rawPath;
    bool m_isLocal;
    FillRule m_fillRule = FillRule::clockwise;
};
} // namespace rive
#endif