tests/gm/ore_mip_render_target.cpp

/*
 * Copyright 2026 Rive
 *
 * Renders into every mip level of one texture through a per level view, with
 * colour and depth attached and no explicit viewport, then shows each level
 * in its own quadrant. A pass sized from the texture instead of the attached
 * level draws the triangle scaled and shifted in the smaller quadrants. Level
 * one is then loaded back and gets a second, flipped triangle. Each quadrant
 * picks its level with a sampler lod clamp, since GL cannot sample a mip view.
 */

#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_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"
#endif

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

class OreMipRenderTargetGM : public GM
{
public:
  OreMipRenderTargetGM() : 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();
    constexpr uint32_t kSize = 64;
    constexpr uint32_t kLevels = 4;

    TextureDesc colorDesc{};
    colorDesc.width = kSize;
    colorDesc.height = kSize;
    colorDesc.format = TextureFormat::rgba8unorm;
    colorDesc.renderTarget = true;
    colorDesc.numMipmaps = kLevels;
    colorDesc.label = "ore_mip_render_target_color";
    auto colorTex = ctx.makeTexture(colorDesc);
    TextureDesc depthDesc = colorDesc;
    depthDesc.format = TextureFormat::depth32float;
    depthDesc.label = "ore_mip_render_target_depth";
    auto depthTex = ctx.makeTexture(depthDesc);
    if (!colorTex || !depthTex)
      return;

    rcp<TextureView> colorViews[kLevels];
    rcp<TextureView> depthViews[kLevels];
    for (uint32_t i = 0; i < kLevels; ++i)
    {
      TextureViewDesc vd{};
      vd.texture = colorTex.get();
      vd.dimension = TextureViewDimension::texture2D;
      vd.baseMipLevel = i;
      vd.mipCount = 1;
      vd.baseLayer = 0;
      vd.layerCount = 1;
      colorViews[i] = ctx.makeTextureView(vd);
      vd.texture = depthTex.get();
      depthViews[i] = ctx.makeTextureView(vd);
      if (!colorViews[i] || !depthViews[i])
        return;
    }

    BufferDesc bd{};
    bd.usage = BufferUsage::vertex;
    bd.size = sizeof(ore_gm::kTriVertices);
    bd.data = ore_gm::kTriVertices;
    bd.label = "ore_mip_render_target_vb";
    auto vb = ctx.makeBuffer(bd);
    ore_gm::TriVertex flipped[3];
    for (int i = 0; i < 3; ++i)
    {
      flipped[i] = ore_gm::kTriVertices[i];
      flipped[i].y = -flipped[i].y;
    }
    bd.data = flipped;
    bd.label = "ore_mip_render_target_vb_flipped";
    auto vbFlipped = ctx.makeBuffer(bd);
    if (!vb || !vbFlipped)
      return;

    auto triShader = ore_gm::loadShader(ctx, ore_gm::kTriangle);
    if (!triShader.vsModule)
      return;
    ore_gm::TrianglePipeline tri(
        triShader,
        TextureFormat::rgba8unorm,
        "ore_mip_render_target_tri");
    tri.desc.depthStencil.format = TextureFormat::depth32float;
    tri.desc.depthStencil.depthCompare = CompareFunction::always;
    tri.desc.depthStencil.depthWriteEnabled = true;
    auto triPipeline = ctx.makePipeline(tri.desc);
    if (!triPipeline)
    {
      fprintf(
          stderr,
          "[ore_mip_render_target] tri pipeline failed: %s\n",
          ctx.lastError().c_str());
      return;
    }

    auto canvas = renderContext->makeRenderCanvas(256, 256);
    if (!canvas)
      return;
    auto canvasTarget = ctx.wrapCanvasTexture(canvas.get());
    if (!canvasTarget)
      return;

    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 = canvasTarget->texture()->format();
    imgPd.colorCount = 1;
    imgPd.depthStencil.depthCompare = CompareFunction::always;
    imgPd.depthStencil.depthWriteEnabled = false;
    imgPd.bindGroupLayouts = layouts;
    imgPd.bindGroupLayoutCount = 3;
    imgPd.label = "ore_mip_render_target_img";
    auto imgPipeline = ctx.makePipeline(imgPd);
    if (!imgPipeline)
    {
      fprintf(
          stderr,
          "[ore_mip_render_target] img pipeline failed: %s\n",
          ctx.lastError().c_str());
      return;
    }

    TextureViewDesc chainDesc{};
    chainDesc.texture = colorTex.get();
    chainDesc.dimension = TextureViewDimension::texture2D;
    chainDesc.baseMipLevel = 0;
    chainDesc.mipCount = kLevels;
    chainDesc.baseLayer = 0;
    chainDesc.layerCount = 1;
    auto chainView = ctx.makeTextureView(chainDesc);
    if (!chainView)
      return;
    BindGroupDesc texBGDesc{};
    texBGDesc.layout = layout1.get();
    BindGroupDesc::TexEntry texEntry{};
    texEntry.slot = 0;
    texEntry.view = chainView.get();
    texBGDesc.textures = &texEntry;
    texBGDesc.textureCount = 1;
    auto texBG = ctx.makeBindGroup(texBGDesc);

    rcp<Sampler> samplers[kLevels];
    rcp<BindGroup> sampBGs[kLevels];
    for (uint32_t i = 0; i < kLevels; ++i)
    {
      SamplerDesc sampDesc{};
      sampDesc.minFilter = Filter::nearest;
      sampDesc.magFilter = Filter::nearest;
      sampDesc.mipmapFilter = Filter::nearest;
      sampDesc.minLod = static_cast<float>(i);
      sampDesc.maxLod = static_cast<float>(i);
      samplers[i] = ctx.makeSampler(sampDesc);
      BindGroupDesc sampBGDesc{};
      sampBGDesc.layout = layout2.get();
      BindGroupDesc::SampEntry sampEntry{};
      sampEntry.slot = 0;
      sampEntry.sampler = samplers[i].get();
      sampBGDesc.samplers = &sampEntry;
      sampBGDesc.samplerCount = 1;
      sampBGs[i] = ctx.makeBindGroup(sampBGDesc);
    }

    m_ore.beginFrame(renderContext);

    static constexpr float kClears[kLevels][4] = {
        {0.10f, 0.10f, 0.15f, 1.0f},
        {0.35f, 0.10f, 0.10f, 1.0f},
        {0.10f, 0.35f, 0.10f, 1.0f},
        {0.10f, 0.10f, 0.35f, 1.0f},
    };
    for (uint32_t i = 0; i < kLevels; ++i)
    {
      RenderPassDesc rp{};
      rp.colorAttachments[0].view = colorViews[i].get();
      rp.colorAttachments[0].loadOp = LoadOp::clear;
      rp.colorAttachments[0].storeOp = StoreOp::store;
      rp.colorAttachments[0].clearColor =
          {kClears[i][0], kClears[i][1], kClears[i][2], kClears[i][3]};
      rp.colorCount = 1;
      rp.depthStencil.view = depthViews[i].get();
      rp.depthStencil.depthLoadOp = LoadOp::clear;
      rp.depthStencil.depthStoreOp = StoreOp::store;
      rp.label = "ore_mip_render_target_level";
      auto pass = ctx.beginRenderPass(rp);
      pass->setPipeline(triPipeline.get());
      pass->setVertexBuffer(0, vb.get());
      pass->draw(3);
      pass->finish();
    }

    {
      RenderPassDesc rp{};
      rp.colorAttachments[0].view = colorViews[1].get();
      rp.colorAttachments[0].loadOp = LoadOp::load;
      rp.colorAttachments[0].storeOp = StoreOp::store;
      rp.colorCount = 1;
      rp.depthStencil.view = depthViews[1].get();
      rp.depthStencil.depthLoadOp = LoadOp::load;
      rp.depthStencil.depthStoreOp = StoreOp::store;
      rp.label = "ore_mip_render_target_reload";
      auto pass = ctx.beginRenderPass(rp);
      pass->setPipeline(triPipeline.get());
      pass->setVertexBuffer(0, vbFlipped.get());
      pass->draw(3);
      pass->finish();
    }

    RenderPassDesc rpShow{};
    rpShow.colorAttachments[0].view = canvasTarget.get();
    rpShow.colorAttachments[0].loadOp = LoadOp::clear;
    rpShow.colorAttachments[0].storeOp = StoreOp::store;
    rpShow.colorAttachments[0].clearColor = {0, 0, 0, 1};
    rpShow.colorCount = 1;
    rpShow.label = "ore_mip_render_target_show";
    auto show = ctx.beginRenderPass(rpShow);
    show->setPipeline(imgPipeline.get());
    show->setBindGroup(1, texBG.get());
    for (uint32_t i = 0; i < kLevels; ++i)
    {
      show->setViewport((i % 2) * 128.0f, (i / 2) * 128.0f, 128, 128);
      show->setBindGroup(2, sampBGs[i].get());
      show->draw(6);
    }
    show->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_mip_render_target, return new OreMipRenderTargetGM)