tests/gm/ore_pipeline_switch.cpp

/*
 * Copyright 2026 Rive
 */

// Switches pipelines mid pass without rebinding the vertex buffer. The
// binding persists and the new pipeline's layout applies to it, so the
// second pipeline's stride of two structs reads structs 6, 8 and 10 for the
// right triangle. A backend that bakes the layout at bind time keeps the
// first stride and reads the zeroed structs 3 to 5 instead. Expected: a
// red/green/blue triangle on the left and a yellow/cyan/magenta one on the
// right.

#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_texture.hpp"
#include "rive/renderer/ore/ore_pipeline.hpp"
#include "rive/renderer/ore/ore_render_pass.hpp"
#endif

using namespace rivegm;
using namespace rive;
using namespace rive::gpu;
#if ORE_GM_HAS_BACKEND
using namespace rive::ore;

namespace
{
// Structs 0 to 2 are the left triangle at the single stride, structs 6, 8
// and 10 the right one at the double stride from firstVertex 3. The trailing
// struct keeps the last double stride vertex whole, since Vulkan and D3D12
// may bounds check the full stride and zero the vertex otherwise.
const ore_gm::TriVertex kVertices[12] = {
    {-0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f},
    {-0.9f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f},
    {-0.1f, -0.5f, 0.0f, 0.0f, 1.0f, 1.0f},
    {},
    {},
    {},
    {0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 1.0f},
    {},
    {0.1f, -0.5f, 0.0f, 1.0f, 1.0f, 1.0f},
    {},
    {0.9f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f},
    {},
};
} // namespace
#endif

class OrePipelineSwitchGM : public GM
{
public:
  OrePipelineSwitchGM() : GM(256, 256) {}

  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();
    auto canvas = renderContext->makeRenderCanvas(256, 256);
    if (!canvas)
      return;
    auto colorTarget = ctx.wrapCanvasTexture(canvas.get());
    if (!colorTarget)
      return;

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

    BufferDesc vboDesc{};
    vboDesc.usage = BufferUsage::vertex;
    vboDesc.size = sizeof(kVertices);
    vboDesc.data = kVertices;
    vboDesc.label = "ore_pipeline_switch_vbo";
    auto vbo = ctx.makeBuffer(vboDesc);

    ore_gm::TrianglePipeline singleDesc(
        shader,
        TextureFormat::rgba8unorm,
        "ore_pipeline_switch_1x");
    ore_gm::TrianglePipeline twiceDesc(
        shader,
        TextureFormat::rgba8unorm,
        "ore_pipeline_switch_2x",
        2 * sizeof(ore_gm::TriVertex));
    auto single = ctx.makePipeline(singleDesc.desc);
    auto twice = ctx.makePipeline(twiceDesc.desc);
    if (!single || !twice)
      return;

    m_ore.beginFrame(renderContext);

    ColorAttachment ca{};
    ca.view = colorTarget.get();
    ca.loadOp = LoadOp::clear;
    ca.storeOp = StoreOp::store;
    ca.clearColor = {0.1f, 0.1f, 0.1f, 1.0f};

    RenderPassDesc rpDesc{};
    rpDesc.colorAttachments[0] = ca;
    rpDesc.colorCount = 1;
    rpDesc.label = "ore_pipeline_switch_pass";

    auto pass = ctx.beginRenderPass(rpDesc);
    pass->setViewport(0, 0, 256, 256);
    pass->setPipeline(single.get());
    pass->setVertexBuffer(0, vbo.get());
    pass->draw(3);
    pass->setPipeline(twice.get());
    pass->draw(3, 1, 3);
    pass->finish();

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

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

private:
  ore_gm::OreGMContext m_ore;
};

GMREGISTER(ore_pipeline_switch, return new OrePipelineSwitchGM())