tests/gm/uber_parity.cpp

/*
 * Copyright 2026 Rive
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

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

#include "assets/nomoon.png.hpp"

using namespace rivegm;
using namespace rive;

// Renders the same scene twice, side by side: the LEFT cell through
// fully-featured ubershader pipelines and the RIGHT cell through specialized
// pipelines (via a render pass break between the two). The cells must match:
// a few LSB of rounding difference is expected on translucent content (the
// premultiplied and unmultiplied paint paths round differently), but any
// visible or structural divergence is an ubershader bug. The golden pins
// both halves, so a regression in either flavor diffs immediately.
//
// The scene is chosen to stress where the two pipeline flavors are most
// likely to diverge: ubershaders compile ENABLE_ADVANCED_BLEND, which flips
// the entire paint path to unmultiplied colors. So the scene leans on
// content whose premultiplied vs unmultiplied evaluation differs in rounding
// and codepath:
//   - translucent gradients fading to very low alpha (premultiply rounding),
//   - an image drawn at low opacity (the unmultiplied path round-trips image
//     texels through unmultiply/premultiply),
//   - an advanced blend (multiply) overlapping srcOver content (forces the
//     dst-read machinery alongside the plain path),
//   - thin strokes over the gradient (AA edge rounding).
//
// On backends that can't switch shader compilation mode at runtime, both
// cells render specialized and trivially match.
constexpr float CELL = 300.f;

static void draw_scene(Renderer* renderer, float ox)
{
  Factory* factory = TestingWindow::Get()->factory();
  constexpr float stops[2] = {0.f, 1.f};

  renderer->save();
  renderer->translate(ox, 0);

  // Opaque horizontal gradient base.
  AABB base = {20.f, 20.f, 280.f, 280.f};
  ColorInt baseColors[2] = {0xff2060c0, 0xffc06020};
  Paint basePaint;
  basePaint->shader(factory->makeLinearGradient(
      base.left(),
      0,
      base.right(),
      0,
      baseColors,
      stops,
      2));
  renderer->drawPath(PathBuilder::Rect(base), basePaint);

  // Translucent vertical gradient fading to near-zero alpha: the
  // premultiplied path rounds rgb*a per fragment, the unmultiplied path
  // premultiplies after coverage; low-alpha texels expose the difference.
  AABB overlay = {50.f, 50.f, 250.f, 250.f};
  ColorInt overlayColors[2] = {0xccff2020, 0x0dffff20};
  Paint overlayPaint;
  overlayPaint->shader(factory->makeLinearGradient(
      0,
      overlay.top(),
      0,
      overlay.bottom(),
      overlayColors,
      stops,
      2));
  renderer->drawPath(PathBuilder::Rect(overlay), overlayPaint);

  // Multiply square overlapping both gradients: advanced blend content in
  // the same scene as plain srcOver draws.
  Paint multiplyPaint;
  multiplyPaint->color(0xff90b0d0);
  multiplyPaint->blendMode(BlendMode::multiply);
  renderer->drawPath(
      PathBuilder::Rect({140.f, 80.f, 260.f, 200.f}),
      multiplyPaint);

  // Image at low opacity: in the unmultiplied path, image texels round-trip
  // through unmultiply_rgb and a later premultiply.
  auto img = LoadImage(assets::nomoon_png());
  if (img != nullptr)
  {
    renderer->save();
    renderer->translate(60.f, 120.f);
    float scale = 140.f / std::max(img->width(), img->height());
    renderer->scale(scale, scale);
    renderer->drawImage(
        img.get(),
        ImageSampler::LinearClamp(),
        BlendMode::srcOver,
        .35f);
    renderer->restore();
  }

  // Thin translucent strokes over everything: AA edge rounding.
  for (int i = 0; i < 3; ++i)
  {
    Paint strokePaint;
    strokePaint->style(RenderPaintStyle::stroke);
    strokePaint->thickness(1.5f);
    strokePaint->color(0x8020ff80);
    renderer->drawPath(
        PathBuilder::Circle(150.f, 150.f, 60.f + 25.f * i),
        strokePaint);
  }

  renderer->restore();
}

class uber_parity_GM : public rivegm::GM
{
public:
  uber_parity_GM() : GM(600, 300) {}
  ColorInt clearColor() const override { return 0xff404040; }

  void updateFrameOptions(TestingWindow::FrameOptions* options) const override
  {
    // Makes GM::run restore the process-wide mode after endFrame(); the
    // per-half modes below override it in between.
    options->shaderCompilationMode = rive::gpu::ShaderCompilationMode::
        onlyUbershaders;
  }

  void onDraw(rive::Renderer* renderer) override
  {
    gpu::RenderContext* renderContext = TestingWindow::Get()->renderContext();
    if (renderContext == nullptr)
    {
      // No runtime mode switching on this backend; both cells render
      // the same way and trivially match.
      draw_scene(renderer, 0);
      draw_scene(renderer, CELL);
      return;
    }

    gpu::RenderContext::FrameDescriptor
        frameDescriptor = renderContext->frameDescriptor();
    frameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;

    for (int i = 0; i < 2; ++i)
    {
      // Flushes the previous half (and initially the clear) under the
      // mode that was live when its draws were recorded.
      TestingWindow::Get()->flushPLSContext();
      renderContext->impl()->testingOnly_setShaderCompilationMode(
          i == 0 ? gpu::ShaderCompilationMode::onlyUbershaders
                 : gpu::ShaderCompilationMode::alwaysSynchronous);
      renderContext->beginFrame(frameDescriptor);
      draw_scene(renderer, i * CELL);
    }
    // endFrame() flushes the right half under alwaysSynchronous, then
    // GM::run restores the process-wide mode.
  }
};
GMREGISTER(uber_parity, return new uber_parity_GM)