tests/gm/additive_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"

#include <array>

using namespace rivegm;
using namespace rive;

// Exercises the additiveness paint value (a Rive extension), which
// interpolates the srcOver composite toward additive: 0 is normal srcOver,
// 1 is fully additive (result.rgb = src + dst, destination alpha preserved).
//
// Layout: 2 columns x 6 rows of 300x300 cells on a black background.
//
// Left column (srcOver references):
//   Row 0: opaque green square overlaid by a red square whose alpha ramps
//          from 1 at the top to 0 at the bottom.
//   Row 1: stroked variants of row 0.
//   Row 2: opaque gradient square overlaid by a gradient square whose alpha
//          ramps from 1 at the top to 0 at the bottom.
//   Row 3: image mesh overlaid by an image mesh whose opacity ramps from 1
//          at the top to 0 at the bottom (drawn as horizontal strips).
//   Row 4: drawImage (image paint on a path): base image at full opacity
//          under an overlapping image at 60% opacity.
//
// Right column (additive):
//   Row 0: filled RGB venn circles; overlaps accumulate to
//          yellow/cyan/magenta/white.
//   Row 1: stroked rings (additive applies to strokes independently).
//   Rows 2 & 3: same geometry as the left column, with the overlay drawn
//          additively, so left vs right isolates srcOver vs additive.
//
// Row 5: the additiveness slider (0 = srcOver, 1 = fully additive). An opaque
//        green square under five red strips with additiveness 0, .25, .5,
//        .75, 1 (srcOver to fully additive, left to right). Left column solid
//        color, right column gradient.
constexpr float CELL = 300.f;

// Draws one quad (2 triangles) of an image as a mesh.
static void draw_image_mesh_quad(Renderer* renderer,
                                 RenderImage* img,
                                 const AABB& dst,
                                 const AABB& uv,
                                 float additiveness,
                                 float opacity)
{
    Factory* factory = TestingWindow::Get()->factory();
    auto pts =
        factory->makeRenderBuffer(RenderBufferType::vertex,
                                  RenderBufferFlags::mappedOnceAtInitialization,
                                  4 * sizeof(Vec2D));
    memcpy(pts->map(),
           std::array<Vec2D, 4>{Vec2D{dst.left(), dst.top()},
                                Vec2D{dst.right(), dst.top()},
                                Vec2D{dst.left(), dst.bottom()},
                                Vec2D{dst.right(), dst.bottom()}}
               .data(),
           pts->sizeInBytes());
    pts->unmap();
    auto uvs =
        factory->makeRenderBuffer(RenderBufferType::vertex,
                                  RenderBufferFlags::mappedOnceAtInitialization,
                                  4 * sizeof(Vec2D));
    memcpy(uvs->map(),
           std::array<Vec2D, 4>{Vec2D{uv.left(), uv.top()},
                                Vec2D{uv.right(), uv.top()},
                                Vec2D{uv.left(), uv.bottom()},
                                Vec2D{uv.right(), uv.bottom()}}
               .data(),
           uvs->sizeInBytes());
    uvs->unmap();
    auto indices =
        factory->makeRenderBuffer(RenderBufferType::index,
                                  RenderBufferFlags::mappedOnceAtInitialization,
                                  6 * sizeof(uint16_t));
    memcpy(indices->map(),
           std::array<uint16_t, 6>{0, 1, 2, 1, 3, 2}.data(),
           indices->sizeInBytes());
    indices->unmap();
    renderer->drawImageMesh(img,
                            ImageSampler::LinearClamp(),
                            pts,
                            uvs,
                            indices,
                            4,
                            6,
                            BlendMode::srcOver,
                            opacity,
                            additiveness);
}

// Approximates a vertical opacity ramp (1 at the top, 0 at the bottom) by
// drawing the image as a stack of mesh strips with stepped opacity.
static void draw_image_mesh_alpha_ramp(Renderer* renderer,
                                       RenderImage* img,
                                       const AABB& dst,
                                       float additiveness)
{
    constexpr int strips = 256;
    for (int i = 0; i < strips; ++i)
    {
        float t0 = float(i) / strips;
        float t1 = float(i + 1) / strips;
        AABB stripDst = {dst.left(),
                         dst.top() + t0 * dst.height(),
                         dst.right(),
                         dst.top() + t1 * dst.height()};
        AABB stripUV = {0.f, t0, 1.f, t1};
        draw_image_mesh_quad(renderer,
                             img,
                             stripDst,
                             stripUV,
                             additiveness,
                             1.f - (t0 + t1) * .5f);
    }
}

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

    // Base square and overlapping overlay square within a cell at (ox, oy).
    auto baseRect = [](float ox, float oy) {
        return AABB{ox + 40.f, oy + 40.f, ox + 190.f, oy + 190.f};
    };
    auto overlayRect = [](float ox, float oy) {
        return AABB{ox + 110.f, oy + 110.f, ox + 260.f, oy + 260.f};
    };

    // Rows 0 & 1, left: opaque green square under a red square whose alpha
    // ramps 1 -> 0 top to bottom (via a gradient that only varies alpha).
    auto squaresCell = [&](float ox,
                           float oy,
                           RenderPaintStyle style,
                           float thickness,
                           BlendMode overlayBlend) {
        AABB base = baseRect(ox, oy);
        Paint basePaint;
        basePaint->style(style);
        if (style == RenderPaintStyle::stroke)
        {
            basePaint->thickness(thickness);
        }
        basePaint->color(0xff00ff00);
        renderer->drawPath(PathBuilder::Rect(base), basePaint);

        AABB overlay = overlayRect(ox, oy);
        ColorInt overlayColors[2] = {0xffff0000, 0x00ff0000};
        Paint overlayPaint;
        overlayPaint->style(style);
        if (style == RenderPaintStyle::stroke)
        {
            overlayPaint->thickness(thickness);
        }
        overlayPaint->shader(factory->makeLinearGradient(0,
                                                         overlay.top(),
                                                         0,
                                                         overlay.bottom(),
                                                         overlayColors,
                                                         stops,
                                                         2));
        overlayPaint->blendMode(overlayBlend);
        renderer->drawPath(PathBuilder::Rect(overlay), overlayPaint);
    };
    squaresCell(0, 0, RenderPaintStyle::fill, 0.f, BlendMode::srcOver);
    squaresCell(0, CELL, RenderPaintStyle::stroke, 20.f, BlendMode::srcOver);

    // Rows 0 & 1, right: classic RGB venn arrangement, all circles additive.
    // Two-circle overlaps accumulate to yellow/cyan/magenta, all three to
    // white.
    auto vennCell =
        [&](float ox, float oy, RenderPaintStyle style, float thickness) {
            struct Circle
            {
                float cx, cy;
                ColorInt color;
            };
            constexpr float radius = 80.f;
            const Circle circles[] = {
                {ox + 150.f, oy + 110.f, 0xffff0000}, // red, top
                {ox + 110.f, oy + 185.f, 0xff00ff00}, // green, bottom-left
                {ox + 190.f, oy + 185.f, 0xff0000ff}, // blue, bottom-right
            };
            for (const Circle& c : circles)
            {
                Paint paint;
                paint->style(style);
                if (style == RenderPaintStyle::stroke)
                {
                    paint->thickness(thickness);
                }
                paint->color(c.color);
                paint->additiveness(1.f);
                renderer->drawPath(PathBuilder::Circle(c.cx, c.cy, radius),
                                   paint);
            }
        };
    vennCell(CELL, 0, RenderPaintStyle::fill, 0.f);
    vennCell(CELL, CELL, RenderPaintStyle::stroke, 40.f);

    // Row 2: opaque horizontal gradient square under a vertical gradient
    // square that fades opaque red -> transparent yellow. Left srcOver,
    // right additive.
    auto gradientCell = [&](float ox, float overlayAdditiveness) {
        constexpr float oy = CELL * 2;
        AABB base = baseRect(ox, oy);
        ColorInt baseColors[2] = {0xff00ff00, 0xff0000ff};
        Paint basePaint;
        basePaint->shader(factory->makeLinearGradient(base.left(),
                                                      0,
                                                      base.right(),
                                                      0,
                                                      baseColors,
                                                      stops,
                                                      2));
        renderer->drawPath(PathBuilder::Rect(base), basePaint);

        AABB overlay = overlayRect(ox, oy);
        ColorInt overlayColors[2] = {0xffff0000, 0x00ffff00};
        Paint overlayPaint;
        overlayPaint->shader(factory->makeLinearGradient(0,
                                                         overlay.top(),
                                                         0,
                                                         overlay.bottom(),
                                                         overlayColors,
                                                         stops,
                                                         2));
        overlayPaint->additiveness(overlayAdditiveness);
        renderer->drawPath(PathBuilder::Rect(overlay), overlayPaint);
    };
    gradientCell(0, /*overlayAdditiveness =*/0.f);
    gradientCell(CELL, /*overlayAdditiveness =*/1.f);

    // Row 3: image mesh under an overlapping image mesh whose opacity ramps
    // 1 -> 0 top to bottom. Left srcOver, right additive.
    auto img = LoadImage(assets::nomoon_png());
    if (img != nullptr)
    {
        auto imageCell = [&](float ox, float overlayAdditiveness) {
            constexpr float oy = CELL * 3;
            draw_image_mesh_quad(renderer,
                                 img.get(),
                                 baseRect(ox, oy),
                                 {0.f, 0.f, 1.f, 1.f},
                                 /*additiveness =*/0.f,
                                 1.f);
            draw_image_mesh_alpha_ramp(renderer,
                                       img.get(),
                                       overlayRect(ox, oy),
                                       overlayAdditiveness);
        };
        imageCell(0, /*overlayAdditiveness =*/0.f);
        imageCell(CELL, /*overlayAdditiveness =*/1.f);

        // Row 4: drawImage (image paint on a path): base image at full
        // opacity under an overlapping image at 60% opacity. Left srcOver,
        // right additive.
        auto drawImageRect =
            [&](const AABB& rect, float additiveness, float opacity) {
                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,
                                    additiveness);
                renderer->restore();
            };
        auto drawImageCell = [&](float ox, float overlayAdditiveness) {
            constexpr float oy = CELL * 4;
            drawImageRect(baseRect(ox, oy), /*additiveness =*/0.f, 1.f);
            drawImageRect(overlayRect(ox, oy), overlayAdditiveness, .6f);
        };
        drawImageCell(0, /*overlayAdditiveness =*/0.f);
        drawImageCell(CELL, /*overlayAdditiveness =*/1.f);
    }

    // Row 5: the additiveness slider. An opaque green square under five red
    // strips with additiveness 0, .25, .5, .75, 1 (srcOver to fully additive,
    // left to right). Left cell solid color, right cell gradient.
    auto additivenessSweepCell = [&](float ox, bool gradient) {
        constexpr float oy = CELL * 5;
        AABB base = baseRect(ox, oy);
        Paint basePaint;
        basePaint->color(0xff00ff00);
        renderer->drawPath(PathBuilder::Rect(base), basePaint);

        AABB overlay = overlayRect(ox, oy);
        constexpr int strips = 5;
        for (int i = 0; i < strips; ++i)
        {
            AABB strip = {overlay.left() + overlay.width() * i / strips,
                          overlay.top(),
                          overlay.left() + overlay.width() * (i + 1) / strips,
                          overlay.bottom()};
            Paint paint;
            if (gradient)
            {
                // Opaque red -> half-transparent red, top to bottom.
                ColorInt colors[2] = {0xffff0000, 0x80ff0000};
                paint->shader(factory->makeLinearGradient(0,
                                                          strip.top(),
                                                          0,
                                                          strip.bottom(),
                                                          colors,
                                                          stops,
                                                          2));
            }
            else
            {
                paint->color(0xc0ff0000);
            }
            paint->additiveness(float(i) / (strips - 1));
            renderer->drawPath(PathBuilder::Rect(strip), paint);
        }
    };
    additivenessSweepCell(0, /*gradient =*/false);
    additivenessSweepCell(CELL, /*gradient =*/true);
}