tests/gm/offscreen_render_target.cpp

/*
 * Copyright 2024 Rive
 */

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

#ifdef RIVE_TOOLS_NO_GL
using GLuint = uint32_t;
#else
#include "rive/renderer/gl/render_context_gl_impl.hpp"
#include "rive/renderer/gl/render_target_gl.hpp"
#endif

#include "assets/nomoon.png.hpp"

using namespace rivegm;
using namespace rive;
using namespace rive::gpu;

// Most gms render directly to the framebuffer. This GM checks that texture
// targets work in GL.
class OffscreenRenderTarget : public GM
{
public:
    OffscreenRenderTarget(BlendMode blendMode,
                          bool riveRenderable,
                          ColorInt clearColor = 0xffff00ff) :
        GM(256, 256),
        m_blendMode(blendMode),
        m_riveRenderable(riveRenderable),
        m_clearColor(clearColor)
    {}

    ColorInt clearColor() const override { return 0xffff0000; }

    void onDraw(rive::Renderer* originalRenderer) override
    {
        if (rcp<rive_tests::OffscreenRenderTarget> renderImageTarget =
                TestingWindow::Get()
                    ->makeOffscreenRenderTarget(256, 256, m_riveRenderable))
        {
            // Intercept the current frameDescriptor and end the PLS frame.
            auto renderContext = TestingWindow::Get()->renderContext();
            auto originalFrameDescriptor = renderContext->frameDescriptor();
            TestingWindow::Get()->flushPLSContext();

            // Draw to the offscreen texture. Declare the frame dimensions
            // explicitly so Rive sizes its PLS buffers for the 256x256
            // offscreen render target we are about to flush into — otherwise,
            // on backends where the testing window's main frame descriptor is
            // larger than the logical GM size (e.g. wagyu where the surface
            // exceeds 256x256), the later flushPLSContext(renderImageTarget)
            // call trips the flushResources.renderTarget->width() ==
            // m_frameDescriptor.renderTargetWidth assertion in
            // RenderContext::flush.
            auto textureFrameDescriptor = originalFrameDescriptor;
            textureFrameDescriptor.renderTargetWidth = 256;
            textureFrameDescriptor.renderTargetHeight = 256;
            textureFrameDescriptor.clearColor = m_clearColor;
            renderContext->beginFrame(std::move(textureFrameDescriptor));
            RiveRenderer renderer(renderContext);
            drawInternal(&renderer, renderImageTarget->asRenderTarget());
            TestingWindow::Get()->flushPLSContext(
                renderImageTarget->asRenderTarget());

            // Copy the offscreen texture back to the destination framebuffer.
            RenderImage* renderImage = renderImageTarget->asRenderImage();
            auto copyFrameDescriptor = originalFrameDescriptor;
            copyFrameDescriptor.loadAction =
                gpu::LoadAction::preserveRenderTarget;
            copyFrameDescriptor.clearColor = 0xffff0000;
            renderContext->beginFrame(std::move(copyFrameDescriptor));
            renderer.save();
            if (renderContext->platformFeatures().framebufferBottomUp)
            {
                renderer.translate(0, 256);
                renderer.scale(1, -1);
            }
            renderer.drawImage(renderImage,
                               {.filter = ImageFilter::nearest},
                               BlendMode::srcOver,
                               1);
            renderer.restore();
        }
        else
        {
            drawInternal(originalRenderer, nullptr);
        }
    }

    virtual void drawInternal(Renderer* renderer, RenderTarget*)
    {
        Paint paint5(0x8000ffff);
        paint5->blendMode(m_blendMode);
        drawStar5(renderer, paint5);

        Paint paint13(0x80ffff00);
        paint13->blendMode(m_blendMode);
        drawStar13(renderer, paint13);
    }

    void drawStar5(Renderer* renderer,
                   RenderPaint* paint,
                   FillRule fillRule = FillRule::nonZero)
    {
        PathBuilder builder;
        float theta = -math::PI / 7;
        builder.moveTo(cosf(theta), sinf(theta));
        for (int i = 0; i <= 7; ++i)
        {
            theta += 2 * math::PI * 2 / 7;
            builder.lineTo(cosf(theta), sinf(theta));
        }
        builder.fillRule(fillRule);
        renderer->save();
        renderer->translate(100, 100);
        renderer->scale(80, 80);
        renderer->drawPath(builder.detach(), paint);
        renderer->restore();
    }

    void drawStar13(Renderer* renderer,
                    RenderPaint* paint,
                    FillRule fillRule = FillRule::evenOdd)
    {
        PathBuilder builder;
        float theta = 0;
        for (int i = 0; i <= 13; ++i)
        {
            theta += 2 * math::PI * 3 / 13;
            builder.lineTo(cosf(theta), sinf(theta));
        }
        builder.fillRule(fillRule);
        renderer->save();
        renderer->translate(256 - 100, 256 - 100);
        renderer->scale(80, 80);
        renderer->drawPath(builder.detach(), paint);
        renderer->restore();
    }

protected:
    const BlendMode m_blendMode;
    const bool m_riveRenderable;
    const ColorInt m_clearColor;
};

GMREGISTER(offscreen_render_target,
           return new OffscreenRenderTarget(BlendMode::srcOver, true))
GMREGISTER(offscreen_render_target_nonrenderable,
           return new OffscreenRenderTarget(BlendMode::srcOver, false))
GMREGISTER(offscreen_render_target_lum,
           return new OffscreenRenderTarget(BlendMode::luminosity, true))
GMREGISTER(offscreen_render_target_lum_nonrenderable,
           return new OffscreenRenderTarget(BlendMode::luminosity, false))

GMREGISTER(offscreen_render_target_transparent_clear,
           return new OffscreenRenderTarget(BlendMode::srcOver,
                                            true,
                                            0x7fff00ff))
GMREGISTER(offscreen_render_target_nonrenderable_transparent_clear,
           return new OffscreenRenderTarget(BlendMode::srcOver,
                                            false,
                                            0x7fff00ff))
GMREGISTER(offscreen_render_target_lum_transparent_clear,
           return new OffscreenRenderTarget(BlendMode::luminosity,
                                            true,
                                            0x7fff00ff))
GMREGISTER(offscreen_render_target_lum_nonrenderable_transparent_clear,
           return new OffscreenRenderTarget(BlendMode::luminosity,
                                            false,
                                            0x7fff00ff))

// This GM checks that texture targets (including MSAA targets) work with
// LoadAction::preserveRenderTarget.
class OffscreenRenderTargetPreserve : public OffscreenRenderTarget
{
public:
    OffscreenRenderTargetPreserve(BlendMode blendMode, bool riveRenderable) :
        OffscreenRenderTarget(blendMode, riveRenderable)
    {}
    OffscreenRenderTargetPreserve(bool riveRenderable) :
        OffscreenRenderTargetPreserve(BlendMode::srcOver, riveRenderable)
    {}

    virtual void drawInternal(Renderer* renderer, RenderTarget* renderTarget)
    {
        ColorInt colors[2];
        float stops[2];
        colors[0] = 0xff000000;
        stops[0] = 0;
        colors[1] = 0xffff00ff;
        stops[1] = 1;
        Paint paint;
        paint->shader(TestingWindow::Get()
                          ->factory()
                          ->makeLinearGradient(0, 0, 250, 0, colors, stops, 2));
        renderer->drawPath(PathBuilder::Rect({0, 0, 256, 256}), paint);

        colors[0] = 0x80000000;
        stops[0] = 0;
        colors[1] = 0x8000ffff;
        stops[1] = 1;
        Paint paint2;
        paint2->shader(
            TestingWindow::Get()
                ->factory()
                ->makeLinearGradient(0, 0, 0, 250, colors, stops, 2));
        renderer->drawPath(PathBuilder::Rect({0, 0, 256, 256}), paint2);

        if (auto renderContext = TestingWindow::Get()->renderContext())
        {
            auto frameDescriptor = renderContext->frameDescriptor();
#ifndef RIVE_TOOLS_NO_GL
            if (auto plsImplGL = TestingWindow::Get()->renderContextGLImpl())
            {
                assert(renderTarget);
                TestingWindow::Get()->flushPLSContext(renderTarget);
                if (int sampleCount = frameDescriptor.msaaSampleCount)
                {
                    // If the MSAA framebuffer target is not the target texture,
                    // wipe it to red behind the scenes in order to make sure
                    // our preservation codepath works. (It shouldn't appear red
                    // in the end -- this should get preserved instead.)
                    if (!plsImplGL->capabilities()
                             .EXT_multisampled_render_to_texture)
                    {
                        auto renderTextureTargetGL =
                            static_cast<RenderTargetGL*>(renderTarget);
                        renderTextureTargetGL->bindMSAAFramebuffer(plsImplGL,
                                                                   sampleCount,
                                                                   nullptr,
                                                                   nullptr);
                        glClearColor(1, 0, 0, 1);
                        glClear(GL_COLOR_BUFFER_BIT);
                    }
                }
            }
            else
#endif
            {
                TestingWindow::Get()->flushPLSContext(renderTarget);
            }
            frameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
            renderContext->beginFrame(std::move(frameDescriptor));
        }
        Paint paint5(0x8000ffff);
        paint5->blendMode(m_blendMode);
        drawStar5(renderer, paint5);

        if (auto renderContext = TestingWindow::Get()->renderContext())
        {
            auto frameDescriptor = renderContext->frameDescriptor();
#ifndef RIVE_TOOLS_NO_GL
            if (auto plsImplGL = TestingWindow::Get()->renderContextGLImpl())
            {
                assert(renderTarget);
                TestingWindow::Get()->flushPLSContext(renderTarget);
                if (int sampleCount = frameDescriptor.msaaSampleCount)
                {
                    // If the MSAA framebuffer target is not the target texture,
                    // wipe it to red behind the scenes in order to make sure
                    // our preservation codepath works. (It shouldn't appear red
                    // in the end -- this should get preserved instead.)
                    if (!plsImplGL->capabilities()
                             .EXT_multisampled_render_to_texture)
                    {
                        auto renderTextureTargetGL =
                            static_cast<RenderTargetGL*>(renderTarget);
                        renderTextureTargetGL->bindMSAAFramebuffer(plsImplGL,
                                                                   sampleCount,
                                                                   nullptr,
                                                                   nullptr);
                        glClearColor(1, 0, 0, 1);
                        glClear(GL_COLOR_BUFFER_BIT);
                    }
                }
            }
            else
#endif
            {
                TestingWindow::Get()->flushPLSContext(renderTarget);
            }
            frameDescriptor.loadAction = gpu::LoadAction::preserveRenderTarget;
            renderContext->beginFrame(std::move(frameDescriptor));
        }
        Paint paint13(0x80ffff00);
        paint13->blendMode(m_blendMode);
        drawStar13(renderer, paint13);
    }
};
GMREGISTER(offscreen_render_target_preserve,
           return new OffscreenRenderTargetPreserve(true))
GMREGISTER(offscreen_render_target_preserve_nonrenderable,
           return new OffscreenRenderTargetPreserve(false))

// ...And verify that blend modes work on a texture target.
class OffscreenRenderTargetPreserveLum : public OffscreenRenderTargetPreserve
{
public:
    OffscreenRenderTargetPreserveLum(bool riveRenderable) :
        OffscreenRenderTargetPreserve(BlendMode::luminosity, riveRenderable)
    {}
};
GMREGISTER(offscreen_render_target_preserve_lum,
           return new OffscreenRenderTargetPreserveLum(true))
GMREGISTER(offscreen_render_target_preserve_lum_nonrenderable,
           return new OffscreenRenderTargetPreserveLum(false))

// This GM checks that virtual tiles work with various types of render targets.
class OffscreenVirtualTiles : public OffscreenRenderTarget
{
public:
    OffscreenVirtualTiles(gpu::LoadAction loadAction, BlendMode blendMode) :
        OffscreenRenderTarget(blendMode, /*riveRenderable=*/false),
        m_loadAction(loadAction)
    {}

    virtual void drawInternal(Renderer* renderer, RenderTarget* renderTarget)
    {
        ColorInt colors[2];
        float stops[2];
        colors[0] = 0xff000000;
        stops[0] = 0;
        colors[1] = 0xffff00ff;
        stops[1] = 1;
        Paint paint;
        paint->shader(TestingWindow::Get()
                          ->factory()
                          ->makeLinearGradient(0, 0, 250, 0, colors, stops, 2));
        renderer->drawPath(PathBuilder::Rect({0, 0, 256, 256}), paint);

        colors[0] = 0x80000000;
        stops[0] = 0;
        colors[1] = 0x8000ffff;
        stops[1] = 1;
        Paint paint2;
        paint2->shader(
            TestingWindow::Get()
                ->factory()
                ->makeLinearGradient(0, 0, 0, 250, colors, stops, 2));
        renderer->drawPath(PathBuilder::Rect({0, 0, 256, 256}), paint2);

        if (auto renderContext = TestingWindow::Get()->renderContext())
        {
            auto frameDescriptor = renderContext->frameDescriptor();
            TestingWindow::Get()->flushPLSContext(renderTarget);
            frameDescriptor.loadAction = m_loadAction;
            frameDescriptor.virtualTileWidth = 37;
            frameDescriptor.virtualTileHeight = 23;
            renderContext->beginFrame(std::move(frameDescriptor));
        }

        Path largePathThatUsesInteriorTriangles;
        Paint transWhite;
        transWhite->color(0x80ffffff);
        transWhite->blendMode(m_blendMode);
        largePathThatUsesInteriorTriangles->addRect(0, 0, 1000, 1000);
        renderer->drawPath(largePathThatUsesInteriorTriangles.get(),
                           transWhite.get());

        Paint paint5(0x8000ffff);
        paint5->blendMode(m_blendMode);
        drawStar5(renderer, paint5, FillRule::clockwise);

        auto img = LoadImage(assets::nomoon_png());

        {
            AutoRestore ar(renderer, true);
            renderer->translate(100, 30);
            renderer->scale(.4f, .4f);
            renderer->drawImage(img.get(),
                                ImageSampler::LinearClamp(),
                                m_blendMode,
                                .5f);
        }

        {
            Factory* factory = TestingWindow::Get()->factory();
            auto pts = factory->makeRenderBuffer(
                RenderBufferType::vertex,
                RenderBufferFlags::mappedOnceAtInitialization,
                4 * sizeof(Vec2D));
            memcpy(pts->map(),
                   std::array<Vec2D, 4>{Vec2D{110, 110},
                                        Vec2D{200, 110},
                                        Vec2D{10, 200},
                                        Vec2D{270, 270}}
                       .data(),
                   pts->sizeInBytes());
            pts->unmap();
            auto uvs = factory->makeRenderBuffer(
                RenderBufferType::vertex,
                RenderBufferFlags::mappedOnceAtInitialization,
                4 * sizeof(Vec2D));
            memcpy(uvs->map(),
                   std::array<Vec2D, 4>{Vec2D{0, 0},
                                        Vec2D{1, 0},
                                        Vec2D{0, 1},
                                        Vec2D{1, 1}}
                       .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, 2, 3}.data(),
                   indices->sizeInBytes());
            indices->unmap();
            renderer->drawImageMesh(img.get(),
                                    ImageSampler::LinearClamp(),
                                    pts,
                                    uvs,
                                    indices,
                                    4,
                                    6,
                                    m_blendMode,
                                    .7f);
        }

        Paint paint13(0x80ffff00);
        paint13->blendMode(m_blendMode);
        paint13->feather(1);
        drawStar13(renderer, paint13, FillRule::clockwise);

        Paint white(0xffffffff);
        paint13->blendMode(m_blendMode);
        uint64_t lcg = 12789;
        for (size_t i = 0; i < 2000; ++i)
        {
            AutoRestore ar(renderer, true);
            renderer->translate(lcg & 0xff, (lcg >> 8) & 0xff);
            renderer->scale(.01f, .01f);
            drawStar5(renderer, white, FillRule::clockwise);
            lcg = lcg * 6364136223846793005ULL + 1;
        }
    }

private:
    const gpu::LoadAction m_loadAction;
};
GMREGISTER(offscreen_virtual_tiles_nonrenderable,
           return new OffscreenVirtualTiles(gpu::LoadAction::clear,
                                            BlendMode::srcOver))
GMREGISTER(
    offscreen_virtual_tiles_preserve_nonrenderable,
    return new OffscreenVirtualTiles(gpu::LoadAction::preserveRenderTarget,
                                     BlendMode::srcOver))
GMREGISTER(offscreen_virtual_tiles_lum_nonrenderable,
           return new OffscreenVirtualTiles(gpu::LoadAction::clear,
                                            BlendMode::luminosity))
GMREGISTER(
    offscreen_virtual_tiles_preserve_lum_nonrenderable,
    return new OffscreenVirtualTiles(gpu::LoadAction::preserveRenderTarget,
                                     BlendMode::luminosity))