renderer/src/gr_inner_fan_triangulator.hpp

/*
 * Copyright 2021 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef GrInnerFanTriangulator_DEFINED
#define GrInnerFanTriangulator_DEFINED

#if !defined(SK_ENABLE_OPTIMIZE_SIZE)

#include "gr_triangulator.hpp"

#include <optional>

namespace rive
{
// Triangulates the inner polygon(s) of a path (i.e., the triangle fan for a
// Redbook rendering method). When combined with the outer curves and grout
// triangles, these produce a complete path. If a groutCollector is not
// provided, pathToPolys fails upon self intersection.
class GrInnerFanTriangulator : private GrTriangulator
{
public:
    using GroutTriangleList = GrTriangulator::BreadcrumbTriangleList;

    GrInnerFanTriangulator(const RawPath& path,
                           const AABB& pathBounds,
                           TrivialBlockAllocator* alloc) :
        GrTriangulator(
            // Sweep along the longer dimension of pathBounds so the sweep line
            // crosses fewer edges.
            pathBounds.width() > pathBounds.height()
                ? Comparator::Direction::kHorizontal
                : Comparator::Direction::kVertical,
            alloc)
    {
        fPreserveCollinearVertices = true;
        fCollectBreadcrumbTriangles = true;
        bool isLinear;
        auto [polys, success] =
            GrTriangulator::pathToPolys(path, 0, AABB{}, &isLinear);
        if (success)
        {
            m_polys = polys;
        }
    }

    // The mesh is fill-rule-independent; the fill rule only filters it at
    // output, so it's supplied per call rather than baked in. This lets one
    // triangulator be cached and reused regardless of fill rule.
    size_t maxVertexCount(FillRule fillRule) const
    {
        return m_polys != nullptr ? countMaxTriangleVertices(m_polys, fillRule)
                                  : 0;
    }

    // Emits the interior triangulation as weight-expanded retrofitted cubic
    // patches, merging into patches of up to 3 edge-adjacent triangles.
    // Returns the number of patches emitted.
    size_t polysToRetrofitCubicPatches(
        FillRule fillRule,
        gpu::WindingFaces windingFaces,
        const RetrofitCubicPatchEmitter& emitPatch) const
    {
        if (m_polys == nullptr)
        {
            return 0;
        }
        return GrTriangulator::polysToRetrofitCubicPatches(m_polys,
                                                           fillRule,
                                                           windingFaces,
                                                           emitPatch);
    }

    // Number of patches polysToRetrofitCubicPatches() emits for this
    // triangulation. Lazily computed and cached because it requires the full
    // (nontrivial) triangle traversal and shared-edge detection.
    size_t retrofitCubicPatchCount(FillRule fillRule) const
    {
        std::optional<size_t>& cached = fillRule == FillRule::evenOdd
                                            ? m_evenOddPatchCount
                                            : m_nonZeroPatchCount;
        if (!cached.has_value())
        {
            cached = polysToRetrofitCubicPatches(fillRule,
                                                 gpu::WindingFaces::all,
                                                 [](const Vec2D*, size_t) {});
        }
        return *cached;
    }

    size_t polysToTriangles(
        uint16_t pathID,
        FillRule fillRule,
        bool reverseTriangles,
        bool negateWinding,
        gpu::WindingFaces windingFaces,
        gpu::WriteOnlyMappedMemory<gpu::TriangleVertex>* mappedMemory) const
    {
        if (m_polys == nullptr)
        {
            return 0;
        }
        return GrTriangulator::polysToTriangles(m_polys,
                                                maxVertexCount(fillRule),
                                                fillRule,
                                                pathID,
                                                reverseTriangles,
                                                negateWinding,
                                                windingFaces,
                                                mappedMemory);
    }

    const GroutTriangleList& groutList() const { return fBreadcrumbList; }

private:
    Poly* m_polys = nullptr;

    // Lazily-computed retrofitCubicPatchCount() cache: one slot per fill rule
    // the triangulator sees (nonZero -- which clockwise maps to -- and
    // evenOdd).
    mutable std::optional<size_t> m_nonZeroPatchCount;
    mutable std::optional<size_t> m_evenOddPatchCount;
};
} // namespace rive

#else

// Stub out GrInnerFanTriangulator::GroutTriangleList for function declarations.
namespace GrInnerFanTriangulator
{
struct GroutTriangleList
{
    GroutTriangleList() = delete;
};
}; // namespace GrInnerFanTriangulator

#endif // SK_ENABLE_OPTIMIZE_SIZE

#endif // GrInnerFanTriangulator_DEFINED