tests/gm/additive_advanced_blend.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 "rive/renderer.hpp"

#include "assets/nomoon.png.hpp"

using namespace rivegm;
using namespace rive;

// Interleaves additive draws (the "additiveness" paint value) with advanced
// blend modes so both features appear adjacent in draw order within one scene.
//
// In normal (synchronous shader) mode this exercises the batcher's rule that
// additive and advanced-blend draws never share a batch: the advanced draws
// force batch breaks around the additive sequences and everything renders
// correctly.
//
// Under --only_ubershaders every batch runs a fully-featured pipeline that
// compiles ENABLE_ADVANCED_BLEND, whose unmultiplied paint path does not
// decode the additive encodings. Comparing the right column (additive)
// against the left column (srcOver references with identical geometry) makes
// any ubershader divergence obvious.
//
// Layout: 2 columns x 4 rows of 300x300 cells on a gray background (gray so
// multiply visibly darkens and screen visibly brightens). The LEFT column is
// always pure srcOver and must stay bit-identical to the pre-additiveness
// master baseline forever; the RIGHT column is the additive variant.
//   Row 0: solid RGB venn circles interleaved with multiply + screen squares.
//          Left circles srcOver, right circles additive.
//   Row 1: gradient alpha-ramp overlays interleaved with a difference square,
//          plus a translucent solid on top of the advanced draw.
//   Row 2: drawImage interleaved with multiply + hardLight squares.
//   Row 3, left: additiveness must be ignored on advanced blend modes -- two
//          multiply squares with additiveness 0 and 1 must render identically
//          (and never change).
//   Row 3, right: the additiveness sweep (0, .25, .5, .75, 1) with a multiply
//          square drawn mid-sequence.
constexpr float CELL = 300.f;

static void draw_rect(
    Renderer* renderer,
    const AABB& rect,
    ColorInt color,
    BlendMode blend,
    float additiveness)
{
  Paint paint;
  paint->color(color);
  paint->blendMode(blend);
  paint->additiveness(additiveness);
  renderer->drawPath(PathBuilder::Rect(rect), paint);
}

static void draw_circle(
    Renderer* renderer,
    float cx,
    float cy,
    ColorInt color,
    float additiveness)
{
  Paint paint;
  paint->color(color);
  paint->additiveness(additiveness);
  renderer->drawPath(PathBuilder::Circle(cx, cy, 80.f), paint);
}

DEF_SIMPLE_GM_WITH_CLEAR_COLOR(
    additive_advanced_blend,
    0xff404040,
    600,
    1200,
    renderer)
{
  Factory* factory = TestingWindow::Get()->factory();
  constexpr float stops[2] = {0.f, 1.f};

  // Row 0: solid venn circles with advanced-blend squares drawn between
  // them. 'additiveness' selects srcOver (left cell) vs additive (right).
  auto vennCell = [&](float ox, float additiveness) {
    constexpr float oy = 0;
    draw_circle(renderer, ox + 150.f, oy + 110.f, 0xffff0000, additiveness);
    draw_rect(
        renderer,
        {ox + 40.f, oy + 40.f, ox + 190.f, oy + 190.f},
        0xff8080ff,
        BlendMode::multiply,
        0.f);
    draw_circle(renderer, ox + 110.f, oy + 185.f, 0xff00ff00, additiveness);
    draw_rect(
        renderer,
        {ox + 110.f, oy + 110.f, ox + 260.f, oy + 260.f},
        0xff404080,
        BlendMode::screen,
        0.f);
    draw_circle(renderer, ox + 190.f, oy + 185.f, 0xff0000ff, additiveness);
  };
  vennCell(0, 0.f);
  vennCell(CELL, 1.f);

  // Row 1: gradient overlays sandwiching a difference-blended gradient
  // square, with a translucent additive solid drawn last.
  auto gradientCell = [&](float ox, float additiveness) {
    constexpr float oy = CELL;
    AABB base = {ox + 40.f, oy + 40.f, ox + 260.f, oy + 260.f};
    ColorInt baseColors[2] = {0xff00c0ff, 0xffff8000};
    Paint basePaint;
    basePaint->shader(factory->makeLinearGradient(
        base.left(),
        0,
        base.right(),
        0,
        baseColors,
        stops,
        2));
    renderer->drawPath(PathBuilder::Rect(base), basePaint);

    AABB overlay = {ox + 70.f, oy + 70.f, ox + 170.f, oy + 230.f};
    ColorInt overlayColors[2] = {0xffff0000, 0x00ff0000};
    Paint overlayPaint;
    overlayPaint->shader(factory->makeLinearGradient(
        0,
        overlay.top(),
        0,
        overlay.bottom(),
        overlayColors,
        stops,
        2));
    overlayPaint->additiveness(additiveness);
    renderer->drawPath(PathBuilder::Rect(overlay), overlayPaint);

    AABB diff = {ox + 130.f, oy + 100.f, ox + 230.f, oy + 200.f};
    ColorInt diffColors[2] = {0xffffffff, 0xff000000};
    Paint diffPaint;
    diffPaint->shader(factory->makeLinearGradient(
        diff.left(),
        0,
        diff.right(),
        0,
        diffColors,
        stops,
        2));
    diffPaint->blendMode(BlendMode::difference);
    renderer->drawPath(PathBuilder::Rect(diff), diffPaint);

    draw_rect(
        renderer,
        {ox + 100.f, oy + 160.f, ox + 260.f, oy + 240.f},
        0x8000ff00,
        BlendMode::srcOver,
        additiveness);
  };
  gradientCell(0, 0.f);
  gradientCell(CELL, 1.f);

  // Row 2: drawImage interleaved with multiply + hardLight squares.
  auto img = LoadImage(assets::nomoon_png());
  if (img != nullptr)
  {
    auto imageCell = [&](float ox, float additiveness) {
      constexpr float oy = CELL * 2;
      auto drawImageRect =
          [&](const AABB& rect, float opacity, float imageAdditiveness) {
            renderer->save();
            renderer->translate(rect.left(), rect.top());
            renderer->scale(
                rect.width() / img->width(),
                rect.height() / img->height());
            renderer->drawImage(
                img.get(),
                ImageSampler::LinearClamp(),
                BlendMode::srcOver,
                opacity,
                imageAdditiveness);
            renderer->restore();
          };
      drawImageRect({ox + 40.f, oy + 40.f, ox + 190.f, oy + 190.f}, 1.f, 0.f);
      draw_rect(
          renderer,
          {ox + 90.f, oy + 60.f, ox + 210.f, oy + 180.f},
          0xffa0a0a0,
          BlendMode::multiply,
          0.f);
      drawImageRect(
          {ox + 110.f, oy + 110.f, ox + 260.f, oy + 260.f},
          .7f,
          additiveness);
      draw_rect(
          renderer,
          {ox + 60.f, oy + 170.f, ox + 180.f, oy + 270.f},
          0xff808040,
          BlendMode::hardLight,
          0.f);
    };
    imageCell(0, 0.f);
    imageCell(CELL, 1.f);
  }

  // Row 3, left: these two multiply squares differ only in additiveness,
  // which advanced blend modes ignore -- they must render identically, and
  // this cell must never change.
  {
    constexpr float oy = CELL * 3;
    draw_rect(
        renderer,
        {40.f, oy + 40.f, 140.f, oy + 260.f},
        0xff80c0ff,
        BlendMode::multiply,
        0.f);
    draw_rect(
        renderer,
        {160.f, oy + 40.f, 260.f, oy + 260.f},
        0xff80c0ff,
        BlendMode::multiply,
        1.f);

    // Row 3, right: the additiveness sweep with a multiply square drawn
    // in the middle of the strip sequence, forcing a batch break within
    // the sweep.
    draw_rect(
        renderer,
        {CELL + 40.f, oy + 40.f, CELL + 190.f, oy + 190.f},
        0xff00ff00,
        BlendMode::srcOver,
        0.f);
    constexpr int strips = 5;
    AABB overlay = {CELL + 110.f, oy + 110.f, CELL + 260.f, oy + 260.f};
    for (int i = 0; i < strips; ++i)
    {
      if (i == 3)
      {
        draw_rect(
            renderer,
            {overlay.left(), oy + 180.f, overlay.right(), oy + 220.f},
            0xff8080ff,
            BlendMode::multiply,
            0.f);
      }
      AABB strip = {
          overlay.left() + overlay.width() * i / strips,
          overlay.top(),
          overlay.left() + overlay.width() * (i + 1) / strips,
          overlay.bottom()};
      Paint paint;
      paint->color(0xc0ff0000);
      paint->additiveness(float(i) / (strips - 1));
      renderer->drawPath(PathBuilder::Rect(strip), paint);
    }
  }
}