tests/gm/ore_nested_pass.cpp

/*
 * Copyright 2026 Rive
 *
 * A pass begun inside another. Canvas B's pass opens first, the pass that
 * draws the triangle into canvas A begins and finishes inside it, then B
 * samples A. The nested pass has to run ahead of B for B to see this frame's
 * triangle, so every variant must match drawing A then B in order.
 */

#include "gm.hpp"
#include "gmutils.hpp"
#include "ore_gm_helper.hpp"
#if ORE_GM_HAS_BACKEND
#include "rive/renderer/render_canvas.hpp"
#include "rive/renderer/ore/ore_buffer.hpp"
#include "rive/renderer/ore/ore_sampler.hpp"
#include "rive/renderer/ore/ore_bind_group.hpp"
#include "rive/renderer/ore/ore_pipeline.hpp"
#include "rive/renderer/ore/ore_render_pass.hpp"
#include "rive/renderer/ore/cmd/ore_command_buffer.hpp"
#include "rive/renderer/ore/cmd/ore_deferred_render_pass.hpp"
#include "rive/renderer/ore/cmd/ore_render_pass_recording.hpp"
#include "rive/renderer/ore/cmd/ore_replay.hpp"
#endif

using namespace rivegm;
using namespace rive;
using namespace rive::gpu;
#if ORE_GM_HAS_BACKEND
using namespace rive::ore;
// Disambiguates from rive::cmd.
#endif

enum class NestMode
{
  kImmediate, // A then B, the reference
  kInline,    // nested through the script entry point on the live context
  kRecorded,  // nested into one recording, then replayed
};

class OreNestedPassGM : public GM
{
public:
  OreNestedPassGM(NestMode mode) : GM(256, 256), m_mode(mode) {}

  ColorInt clearColor() const override { return 0xff000000; }

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

#if ORE_GM_HAS_BACKEND
    auto& ctx = *renderContext->getOreContext();

    // Canvas A is the producer and B the consumer.
    auto canvasA = renderContext->makeRenderCanvas(256, 256);
    auto canvasB = renderContext->makeRenderCanvas(256, 256);
    if (!canvasA || !canvasB)
      return;
    auto targetA = ctx.wrapCanvasTexture(canvasA.get());
    auto targetB = ctx.wrapCanvasTexture(canvasB.get());
    if (!targetA || !targetB)
      return;

    BufferDesc bd{};
    bd.usage = BufferUsage::vertex;
    bd.size = sizeof(ore_gm::kTriVertices);
    bd.data = ore_gm::kTriVertices;
    bd.label = "ore_nested_pass_vb";
    auto vb = ctx.makeBuffer(bd);
    if (!vb)
      return;

    auto triShader = ore_gm::loadShader(ctx, ore_gm::kTriangle);
    if (!triShader.vsModule)
      return;

    ore_gm::TrianglePipeline tri(
        triShader,
        targetA->texture()->format(),
        "ore_nested_pass_tri");
    auto triPipeline = ctx.makePipeline(tri.desc);
    if (!triPipeline)
    {
      fprintf(
          stderr,
          "[ore_nested_pass] tri pipeline failed: %s\n",
          ctx.lastError().c_str());
      return;
    }

    SamplerDesc sampDesc{};
    sampDesc.minFilter = Filter::nearest;
    sampDesc.magFilter = Filter::nearest;
    auto sampler = ctx.makeSampler(sampDesc);

    auto imgShader = ore_gm::loadShader(ctx, ore_gm::kImageView);
    if (!imgShader.vsModule)
      return;
    auto layout1 = ore_gm::makeLayoutFromShader(
        ctx,
        imgShader.vsModule.get(),
        1);
    auto layout2 = ore_gm::makeLayoutFromShader(
        ctx,
        imgShader.vsModule.get(),
        2);
    BindGroupLayout* layouts[] = {nullptr, layout1.get(), layout2.get()};

    PipelineDesc imgPd{};
    imgPd.vertexModule = imgShader.vsModule.get();
    imgPd.fragmentModule = imgShader.psModule.get();
    imgPd.vertexEntryPoint = imgShader.vsEntryPoint;
    imgPd.fragmentEntryPoint = imgShader.fsEntryPoint;
    imgPd.vertexBufferCount = 0;
    imgPd.topology = PrimitiveTopology::triangleList;
    imgPd.colorTargets[0].format = targetB->texture()->format();
    imgPd.colorCount = 1;
    imgPd.depthStencil.depthCompare = CompareFunction::always;
    imgPd.depthStencil.depthWriteEnabled = false;
    imgPd.bindGroupLayouts = layouts;
    imgPd.bindGroupLayoutCount = 3;
    imgPd.label = "ore_nested_pass_img";
    auto imgPipeline = ctx.makePipeline(imgPd);
    if (!imgPipeline)
    {
      fprintf(
          stderr,
          "[ore_nested_pass] img pipeline failed: %s\n",
          ctx.lastError().c_str());
      return;
    }

    BindGroupDesc texBGDesc{};
    texBGDesc.layout = layout1.get();
    BindGroupDesc::TexEntry texEntry{};
    texEntry.slot = 0;
    texEntry.view = targetA.get();
    texBGDesc.textures = &texEntry;
    texBGDesc.textureCount = 1;
    auto texBG = ctx.makeBindGroup(texBGDesc);

    BindGroupDesc sampBGDesc{};
    sampBGDesc.layout = layout2.get();
    BindGroupDesc::SampEntry sampEntry{};
    sampEntry.slot = 0;
    sampEntry.sampler = sampler.get();
    sampBGDesc.samplers = &sampEntry;
    sampBGDesc.samplerCount = 1;
    auto sampBG = ctx.makeBindGroup(sampBGDesc);

    ColorAttachment caA{};
    caA.view = targetA.get();
    caA.loadOp = LoadOp::clear;
    caA.storeOp = StoreOp::store;
    caA.clearColor = {0.1f, 0.1f, 0.15f, 1.0f};
    RenderPassDesc rpA{};
    rpA.colorAttachments[0] = caA;
    rpA.colorCount = 1;
    rpA.label = "ore_nested_pass_passA";

    ColorAttachment caB{};
    caB.view = targetB.get();
    caB.loadOp = LoadOp::clear;
    caB.storeOp = StoreOp::store;
    caB.clearColor = {0, 0, 0, 1};
    RenderPassDesc rpB{};
    rpB.colorAttachments[0] = caB;
    rpB.colorCount = 1;
    rpB.label = "ore_nested_pass_passB";

    auto drawA = [&](RenderPass& pass) {
      pass.setPipeline(triPipeline.get());
      pass.setVertexBuffer(0, vb.get());
      pass.setViewport(0, 0, 256, 256);
      pass.draw(3);
      pass.finish();
    };
    auto sampleA = [&](RenderPass& pass) {
      pass.setBindGroup(1, texBG.get());
      pass.setBindGroup(2, sampBG.get());
      pass.draw(6);
      pass.finish();
    };

    m_ore.beginFrame(renderContext);

    if (m_mode == NestMode::kImmediate)
    {
      drawA(*ctx.beginRenderPass(rpA));
      auto pB = ctx.beginRenderPass(rpB);
      pB->setPipeline(imgPipeline.get());
      pB->setViewport(0, 0, 256, 256);
      sampleA(*pB);
    }
    else if (m_mode == NestMode::kInline)
    {
      auto pB = ore::cmd::beginRecordedRenderPass(ctx, rpB);
      pB->setPipeline(imgPipeline.get());
      pB->setViewport(0, 0, 256, 256);
      drawA(*ore::cmd::beginRecordedRenderPass(ctx, rpA));
      sampleA(*pB);
    }
    else
    {
      ore::cmd::OreCommandBuffer cmdBuf;
      {
        ore::cmd::RenderPassRecording pB(&ctx, &cmdBuf, rpB);
        pB.setPipeline(imgPipeline.get());
        pB.setViewport(0, 0, 256, 256);
        ore::cmd::RenderPassRecording pA(&ctx, &cmdBuf, rpA);
        drawA(pA);
        sampleA(pB);
      }
      ore::cmd::replayCommandBuffer(ctx, cmdBuf);
    }

    m_ore.endFrame(renderContext);
    ore_gm::invalidateGLStateAfterOre(renderContext);

    originalRenderer->save();
    originalRenderer->drawImage(
        canvasB->renderImage(),
        {.filter = ImageFilter::nearest},
        BlendMode::srcOver,
        1);
    originalRenderer->restore();
#endif
  }

private:
  NestMode m_mode;
  ore_gm::OreGMContext m_ore;
};

GMREGISTER(
    ore_nested_pass_immediate,
    return new OreNestedPassGM(NestMode::kImmediate))
GMREGISTER(ore_nested_pass, return new OreNestedPassGM(NestMode::kInline))
GMREGISTER(
    ore_nested_pass_recorded,
    return new OreNestedPassGM(NestMode::kRecorded))