tests/gm/uber_parity_srcover.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;

// Companion to uber_parity: the same left-uber / right-specialized layout,
// but with a srcOver-only scene and dithering disabled. Where uber_parity
// checks that the features an ubershader *uses* match specialized rendering,
// this GM checks that the features an ubershader compiles but does NOT use
// are true no-ops:
//
//   - ENABLE_DITHER: specialized pipelines omit the feature entirely; the
//     ubershader still runs the dither math and must neutralize it via
//     0-value uniforms (ditherMode == none zeroes ditherScale/ditherBias).
//     This zero-uniform path has no other test coverage.
//   - ENABLE_ADVANCED_BLEND: compiled in the ubershader (flipping the whole
//     paint path to unmultiplied colors), but every draw here is srcOver.
//   - ENABLE_EVEN_ODD, ENABLE_CLIP_RECT, ENABLE_CLIPPING: compiled in the
//     ubershader; the scene contains no even-odd fills, no clipRect, and no
//     clipping.
//
// The specialized half compiles none of the above. The halves must match
// within a few LSB of premult/unmult rounding on translucent content; any
// structural divergence means an enabled-but-unused ubershader feature is
// not a no-op.
//
// 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_srcover_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. Banding on this smooth ramp must be
  // identical in both halves: neither half may dither (the ubershader half
  // has the dither code compiled and must no-op it).
  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);

  // 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_srcover_GM : public rivegm::GM
{
public:
  uber_parity_srcover_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_srcover_scene(renderer, 0);
      draw_srcover_scene(renderer, CELL);
      return;
    }

    gpu::RenderContext::FrameDescriptor
        frameDescriptor = renderContext->frameDescriptor();
    frameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
    // Dither off: the specialized half drops ENABLE_DITHER from its
    // pipelines; the ubershader half keeps the feature compiled and must
    // neutralize it through the zeroed dither uniforms.
    frameDescriptor.ditherMode = gpu::DitherMode::none;

    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_srcover_scene(renderer, i * CELL);
    }
    // endFrame() flushes the right half under alwaysSynchronous, then
    // GM::run restores the process-wide mode.
  }
};
GMREGISTER(uber_parity_srcover, return new uber_parity_srcover_GM)