tests/gm/negative_interior_triangles.cpp

/*
 * Copyright 2025 Rive
 */

#include "gm.hpp"
#include "gmutils.hpp"

using namespace rivegm;
using namespace rive;

constexpr int SIZE = 1600;

// Tests that interior triangulations with negative coverage render correctly
// with clockwise fill, both as paths and as clips.
static void draw_test(Renderer* renderer, bool asClip)
{
    PathBuilder checkerboard;
    checkerboard.fillRule(FillRule::clockwise);
    constexpr static int GRID_COUNT = 50;
    constexpr static float CELL_SIZE = (float)SIZE / GRID_COUNT;
    for (int y = 0; y < GRID_COUNT; y += 1)
    {
        checkerboard.addRect(AABB(0, y * CELL_SIZE, SIZE, (y + 1) * CELL_SIZE),
                             (y & 1) ? rivegm::PathDirection::cw
                                     : rivegm::PathDirection::ccw);
    }
    for (int x = 0; x < GRID_COUNT; x += 1)
    {
        checkerboard.addRect(AABB(x * CELL_SIZE, 0, (x + 1) * CELL_SIZE, SIZE),
                             (x & 1) ? rivegm::PathDirection::cw
                                     : rivegm::PathDirection::ccw);
    }
    renderer->clipPath(checkerboard.detach());

    for (bool negativeDeterminant : {false, true})
    {
        AutoRestore ar(renderer, true);
        if (negativeDeterminant)
        {
            renderer->translate(SIZE - 7, 207);
            renderer->scale(-1, 1);
        }
        else
        {
            renderer->translate(29, -100);
        }

        Path path;
        path->fillRule(FillRule::clockwise);
        // Add a negative rectangle.
        path->addRect(SIZE, 0, -SIZE, SIZE);

        // The first path will be completely erased by the negative rectangle.
        // It will only show if we draw it over itself twice.
        for (float x : {SIZE / 2.f, .0f, SIZE / 2.f})
        {
            path->moveTo(x + 50, SIZE / 2.5f);
            path->cubicTo(x + 50,
                          0,
                          x + SIZE / 2.f - 50,
                          0,
                          x + SIZE / 2.f - 50,
                          SIZE / 2.5f);
            path->cubicTo(x + SIZE / 2.f - 50,
                          SIZE,
                          x + 50,
                          SIZE,
                          x + 50,
                          SIZE / 2.5f);
        }

        Paint paint;
        if (asClip)
        {
            paint->color(negativeDeterminant ? 0xd0900000 : 0xffff0000);
            renderer->clipPath(path.get());
            renderer->drawPath(PathBuilder::Rect({0, 0, SIZE, SIZE}).get(),
                               paint.get());
        }
        else
        {
            paint->color(negativeDeterminant ? 0xc0700070 : 0xffff00ff);
            renderer->drawPath(path.get(), paint.get());
        }
    }
}

DEF_SIMPLE_GM_WITH_CLEAR_COLOR(negative_interior_triangles,
                               0xff00ffff,
                               SIZE,
                               SIZE,
                               renderer)
{
    draw_test(renderer, /*asClip=*/false);
}

DEF_SIMPLE_GM_WITH_CLEAR_COLOR(negative_interior_triangles_as_clip,
                               0xff00ffff,
                               SIZE,
                               SIZE,
                               renderer)
{
    draw_test(renderer, /*asClip=*/true);
}