tests/gm/render_canvas.cpp

/*
 * Copyright 2025 Rive
 */

#include "gm.hpp"
#include "gmutils.hpp"
#include "common/testing_window.hpp"
#include "rive/renderer/render_canvas.hpp"
#include "rive/renderer/render_context.hpp"
#include "rive/renderer/rive_renderer.hpp"

using namespace rivegm;
using namespace rive;
using namespace rive::gpu;

// Renders Rive 2D content into a RenderCanvas and composites the result into
// the main framebuffer. Verifies the basic render-to-texture lifecycle:
// makeRenderCanvas() -> renderTarget() -> beginFrame/flush -> renderImage() ->
// drawImage.
class RenderCanvasBasic : public GM
{
public:
    RenderCanvasBasic() : GM(256, 256) {}

    ColorInt clearColor() const override { return 0xffff0000; } // red

    void onDraw(rive::Renderer* originalRenderer) override
    {
        auto renderContext = TestingWindow::Get()->renderContext();
        if (!renderContext)
            return;

        auto canvas = renderContext->makeRenderCanvas(256, 256);
        if (!canvas)
            return;

        // Intercept the current frame and flush.
        auto originalFrameDescriptor = renderContext->frameDescriptor();
        TestingWindow::Get()->flushPLSContext();

        // Begin a new frame targeting the canvas. Declare the frame
        // dimensions explicitly so Rive sizes its PLS buffers for the
        // canvas render target we are about to flush into. Without this,
        // backends whose main frame descriptor is larger than the canvas
        // (e.g. wagyu where the surface exceeds the GM size) trip the
        // flushResources.renderTarget->width() ==
        // m_frameDescriptor.renderTargetWidth assertion in
        // RenderContext::flush.
        auto canvasFrameDescriptor = originalFrameDescriptor;
        canvasFrameDescriptor.renderTargetWidth = canvas->width();
        canvasFrameDescriptor.renderTargetHeight = canvas->height();
        canvasFrameDescriptor.clearColor = 0xff0000ff; // blue
        renderContext->beginFrame(std::move(canvasFrameDescriptor));

        // Draw a green circle into the canvas.
        RiveRenderer renderer(renderContext);
        Paint green(0xff00ff00);
        PathBuilder builder;
        int nsegs = 40;
        float r = 80;
        float cx = 128, cy = 128;
        for (int i = 0; i <= nsegs; ++i)
        {
            float theta = 2 * math::PI * i / nsegs;
            float x = cx + r * cosf(theta);
            float y = cy + r * sinf(theta);
            if (i == 0)
                builder.moveTo(x, y);
            else
                builder.lineTo(x, y);
        }
        renderer.drawPath(builder.detach(), green);

        // Flush to the canvas's render target.
        TestingWindow::Get()->flushPLSContext(canvas->renderTarget());

        // Resume the main frame and composite the canvas.
        auto mainFrameDescriptor = originalFrameDescriptor;
        mainFrameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
        renderContext->beginFrame(std::move(mainFrameDescriptor));
        renderer.drawImage(canvas->renderImage(),
                           {.filter = ImageFilter::nearest},
                           BlendMode::srcOver,
                           1);
    }
};
GMREGISTER(render_canvas_basic, return new RenderCanvasBasic())

// Composites a RenderCanvas through drawImageMesh, whose UVs come straight
// from the mesh buffers instead of an image matrix. The circle sits high so a
// vertically mirrored composite is visible.
class RenderCanvasMesh : public GM
{
public:
    RenderCanvasMesh() : GM(256, 256) {}

    ColorInt clearColor() const override { return 0xffff0000; } // red

    void onDraw(rive::Renderer* originalRenderer) override
    {
        auto renderContext = TestingWindow::Get()->renderContext();
        if (!renderContext)
            return;

        auto canvas = renderContext->makeRenderCanvas(256, 256);
        if (!canvas)
            return;

        auto originalFrameDescriptor = renderContext->frameDescriptor();
        TestingWindow::Get()->flushPLSContext();

        auto canvasFrameDescriptor = originalFrameDescriptor;
        canvasFrameDescriptor.renderTargetWidth = canvas->width();
        canvasFrameDescriptor.renderTargetHeight = canvas->height();
        canvasFrameDescriptor.clearColor = 0xff0000ff; // blue
        renderContext->beginFrame(std::move(canvasFrameDescriptor));

        RiveRenderer renderer(renderContext);
        Paint green(0xff00ff00);
        PathBuilder builder;
        int nsegs = 40;
        float r = 60;
        float cx = 128, cy = 80;
        for (int i = 0; i <= nsegs; ++i)
        {
            float theta = 2 * math::PI * i / nsegs;
            float x = cx + r * cosf(theta);
            float y = cy + r * sinf(theta);
            if (i == 0)
                builder.moveTo(x, y);
            else
                builder.lineTo(x, y);
        }
        renderer.drawPath(builder.detach(), green);
        TestingWindow::Get()->flushPLSContext(canvas->renderTarget());

        auto mainFrameDescriptor = originalFrameDescriptor;
        mainFrameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
        renderContext->beginFrame(std::move(mainFrameDescriptor));

        Factory* factory = TestingWindow::Get()->factory();
        auto pts = factory->makeRenderBuffer(
            RenderBufferType::vertex,
            RenderBufferFlags::mappedOnceAtInitialization,
            4 * sizeof(Vec2D));
        memcpy(pts->map(),
               std::array<Vec2D, 4>{Vec2D{0, 0},
                                    Vec2D{256, 0},
                                    Vec2D{0, 256},
                                    Vec2D{256, 256}}
                   .data(),
               pts->sizeInBytes());
        pts->unmap();
        auto uvs = factory->makeRenderBuffer(
            RenderBufferType::vertex,
            RenderBufferFlags::mappedOnceAtInitialization,
            4 * sizeof(Vec2D));
        memcpy(uvs->map(),
               std::array<Vec2D, 4>{Vec2D{0, 0},
                                    Vec2D{1, 0},
                                    Vec2D{0, 1},
                                    Vec2D{1, 1}}
                   .data(),
               uvs->sizeInBytes());
        uvs->unmap();
        auto indices = factory->makeRenderBuffer(
            RenderBufferType::index,
            RenderBufferFlags::mappedOnceAtInitialization,
            6 * sizeof(uint16_t));
        memcpy(indices->map(),
               std::array<uint16_t, 6>{0, 1, 2, 1, 2, 3}.data(),
               indices->sizeInBytes());
        indices->unmap();
        renderer.drawImageMesh(canvas->renderImage(),
                               {.filter = ImageFilter::nearest},
                               pts,
                               uvs,
                               indices,
                               4,
                               6,
                               BlendMode::srcOver,
                               1);
    }
};
GMREGISTER(render_canvas_mesh, return new RenderCanvasMesh())

// Winding sensitive content inside a canvas: a clockwise fill rule keeps the
// clockwise square and drops the counter clockwise one, under a circular clip.
// A target whose rows run the other way from the window inverts winding, so
// the squares swap if the front face is not set per target.
class RenderCanvasWinding : public GM
{
public:
    RenderCanvasWinding() : GM(256, 256) {}

    ColorInt clearColor() const override { return 0xffff0000; } // red

    void onDraw(rive::Renderer* originalRenderer) override
    {
        auto renderContext = TestingWindow::Get()->renderContext();
        if (!renderContext)
            return;

        auto canvas = renderContext->makeRenderCanvas(256, 256);
        if (!canvas)
            return;

        auto originalFrameDescriptor = renderContext->frameDescriptor();
        TestingWindow::Get()->flushPLSContext();

        auto canvasFrameDescriptor = originalFrameDescriptor;
        canvasFrameDescriptor.renderTargetWidth = canvas->width();
        canvasFrameDescriptor.renderTargetHeight = canvas->height();
        canvasFrameDescriptor.clearColor = 0xff0000ff; // blue
        renderContext->beginFrame(std::move(canvasFrameDescriptor));

        RiveRenderer renderer(renderContext);
        // The clip stack outlives the flush, so keep it out of the composite.
        renderer.save();
        Path clip = PathBuilder::Circle(128, 128, 110);
        renderer.clipPath(clip.get());
        Paint green(0xff00ff00);
        renderer.drawPath(PathBuilder(FillRule::clockwise)
                              .moveTo(24, 24)
                              .lineTo(120, 24)
                              .lineTo(120, 120)
                              .lineTo(24, 120)
                              .close()
                              .detach(),
                          green);
        Paint yellow(0xffffff00);
        renderer.drawPath(PathBuilder(FillRule::clockwise)
                              .moveTo(136, 136)
                              .lineTo(136, 232)
                              .lineTo(232, 232)
                              .lineTo(232, 136)
                              .close()
                              .detach(),
                          yellow);
        renderer.restore();
        TestingWindow::Get()->flushPLSContext(canvas->renderTarget());

        auto mainFrameDescriptor = originalFrameDescriptor;
        mainFrameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
        renderContext->beginFrame(std::move(mainFrameDescriptor));
        renderer.drawImage(canvas->renderImage(),
                           {.filter = ImageFilter::nearest},
                           BlendMode::srcOver,
                           1);
    }
};
GMREGISTER(render_canvas_winding, return new RenderCanvasWinding())

// Verifies that RenderCanvas content persists across frames. Renders a green
// circle into the canvas on the first frame, then on the second frame only
// composites the canvas (without re-rendering into it).
class RenderCanvasPersistence : public GM
{
public:
    RenderCanvasPersistence() : GM(256, 256) {}

    ColorInt clearColor() const override { return 0xffff0000; } // red

    void onDraw(rive::Renderer* originalRenderer) override
    {
        auto renderContext = TestingWindow::Get()->renderContext();
        if (!renderContext)
            return;

        if (!m_canvas)
        {
            m_canvas = renderContext->makeRenderCanvas(256, 256);
            if (!m_canvas)
                return;

            // Render green circle into the canvas on first call.
            auto originalFrameDescriptor = renderContext->frameDescriptor();
            TestingWindow::Get()->flushPLSContext();

            auto canvasFD = originalFrameDescriptor;
            canvasFD.renderTargetWidth = m_canvas->width();
            canvasFD.renderTargetHeight = m_canvas->height();
            canvasFD.clearColor = 0xff0000ff; // blue
            renderContext->beginFrame(std::move(canvasFD));
            RiveRenderer renderer(renderContext);
            Paint green(0xff00ff00);
            PathBuilder builder;
            int nsegs = 40;
            float r = 80;
            float cx = 128, cy = 128;
            for (int i = 0; i <= nsegs; ++i)
            {
                float theta = 2 * math::PI * i / nsegs;
                float x = cx + r * cosf(theta);
                float y = cy + r * sinf(theta);
                if (i == 0)
                    builder.moveTo(x, y);
                else
                    builder.lineTo(x, y);
            }
            renderer.drawPath(builder.detach(), green);
            TestingWindow::Get()->flushPLSContext(m_canvas->renderTarget());

            // Resume main frame.
            auto mainFD = originalFrameDescriptor;
            mainFD.loadAction = gpu::LoadAction::preserveRenderTarget;
            renderContext->beginFrame(std::move(mainFD));
        }

        // Composite the canvas (rendered on first frame, persisted on later
        // frames).
        RiveRenderer renderer(renderContext);
        renderer.drawImage(m_canvas->renderImage(),
                           {.filter = ImageFilter::nearest},
                           BlendMode::srcOver,
                           1);
    }

private:
    rcp<RenderCanvas> m_canvas;
};
GMREGISTER(render_canvas_persistence, return new RenderCanvasPersistence())