tests/common/testing_window_canvas2d.cpp

/*
 * Copyright 2022 Rive
 */
#include "testing_window.hpp"

#if !defined(RIVE_CANVAS_2D)

TestingWindow* TestingWindow::MakeCanvas2D() { return nullptr; }

#else

#include "utils/factory_utils.hpp"

#include <string>
#include <vector>

#include <emscripten/emscripten.h>
#include <emscripten/html5.h>
#include <emscripten/val.h>

namespace rive::gpu
{

EM_ASYNC_JS(void, testingWindowCanvas2dImportCanvasAdvanced, (), {
    // The import itself is async, and then we need to call the "default"
    // function to get the module, which is also async.
    // clang-format off
    if (globalThis.canvasAdvancedModule === undefined)
    {
        const result = await import("./canvas_advanced.mjs");
        globalThis.canvasAdvancedModule = await result.default();
    }
    // clang-format on
});

// Resets the canvas and fills it with `color` (0xAARRGGBB). The fill has to
// happen here rather than through the renderer: a drawPath composites over the
// existing pixels, which cannot produce a transparent clear color.
EM_JS(void, testingWindowCanvas2dResetCanvas, (uint32_t color), {
    var canvas = document["getElementById"]("canvas");
    var ctx = canvas["getContext"]("2d");
    ctx["reset"]();
    // reset() leaves the canvas transparent, so compositing the clear color
    // over it yields exactly that color, alpha included.
    ctx["fillStyle"] = "rgba(" + ((0x00ff0000 & color) >>> 16) + "," +
                       ((0x0000ff00 & color) >>> 8) + "," +
                       ((0x000000ff & color) >>> 0) + "," +
                       ((0xff000000 & color) >>> 24) / 0xff + ")";
    ctx["fillRect"](0, 0, canvas["width"], canvas["height"]);
});

EM_JS(bool,
      testingWindowCanvas2dGetCanvasPixels,
      (uint8_t* outBuffer, int width, int height),
      {
          var canvas = document["getElementById"]("canvas");
          var ctx = canvas["getContext"]("2d");
          var imageData =
              ctx["getImageData"](0, 0, canvas.width, canvas.height);
          var pixelArray = imageData["data"];
          if (pixelArray.length != width * height * 4)
          {
              return false;
          }

          // TestHarness::savePNG() flips vertically on the way out, since every
          // other backend fills this buffer bottom-up (the GL convention).
          // getImageData() hands back rows top-down, so reverse them here and
          // let the two cancel.
          var stride = width * 4;
          for (var y = 0; y < height; ++y)
          {
              Module['HEAPU8']['set'](
                  pixelArray['subarray']((height - 1 - y) * stride,
                                         (height - y) * stride),
                  outBuffer + y * stride);
          }
          return true;
      });

// Image decoding is asynchronous: renderer.js hands the bytes to an <img>
// element through a blob URL and only fills in the result on its load event.
//
// Note this goes through Module.decodeImage rather than the more obvious
// renderFactory.makeRenderImage(). The latter's onDecode callback closes over
// renderer.js's loadContext, which is only non-null inside Module.load(), and
// this harness draws images directly without ever loading a .riv file, so that
// path would dereference null on the first decode.
EM_ASYNC_JS(emscripten::EM_VAL,
            testingWindowCanvas2dDecodeImage,
            (const uint8_t* bytes, int size),
            {
                // Copy out of our heap up front just to be extra safe
                // (renderer.js's `decode` function also makes a Blob copy).
                var copy = Module['HEAPU8']['slice'](bytes, bytes + size);
                var image = await new Promise(function(resolve) {
                    globalThis.canvasAdvancedModule["decodeImage"](copy,
                                                                   resolve);
                });
                return Emval.toHandle(image);
            });

// Resolved on first use rather than at static-init time, since the module isn't
// on globalThis until testingWindowCanvas2dImportCanvasAdvanced() has finished.
static emscripten::val& canvasAdvancedModule()
{
    static emscripten::val module =
        emscripten::val::global("canvasAdvancedModule");
    return module;
}

// embind exposes C++ enums to JS as value objects, not plain numbers, and
// renderer.js compares them by identity. This class maps the C++ int-based
// enums to the objects stored in canvas_advanced's heap (which is different
// from this wasm module's heap!).
//
// embind stores the reverse map on the enum's JS constructor as
// `.values[rawValue]` (see _embind_register_enum_value in libembind.js), which
// lets us build the table without naming every enumerator here.
class JSEnum
{
public:
    // Must not be constructed until canvas_advanced.mjs has finished loading.
    explicit JSEnum(const char* enumName)
    {
        emscripten::val values = canvasAdvancedModule()[enumName]["values"];
        assert(!values.isUndefined()); // Not an embind enum?

        // Index the table by raw value. Some of these enums are sparse, so the
        // gaps stay undefined and are caught by the assert in operator().
        emscripten::val keys =
            emscripten::val::global("Object").call<emscripten::val>("keys",
                                                                    values);
        size_t keyCount = keys["length"].as<size_t>();
        for (size_t i = 0; i < keyCount; i++)
        {
            int rawValue = std::stoi(keys[i].as<std::string>());
            assert(rawValue >= 0);

            // We're storing the enum mapping in a vector rather than a sparse
            // data structure, like a map. If we ever try to register an enum
            // with really high values, it might indicate that this enum is
            // meant to be used as a bit-mask, and the vector will become huge.
            // If that happens, this assert will trigger and we can switch to
            // something more appropriate.
            assert(rawValue < 1024);

            if (static_cast<size_t>(rawValue) >= m_values.size())
            {
                m_values.resize(rawValue + 1, emscripten::val::undefined());
            }
            m_values[rawValue] = values[rawValue];
        }
    }

    template <typename T> const emscripten::val& operator()(T value) const
    {
        size_t rawValue = static_cast<size_t>(value);
        assert(rawValue < m_values.size());
        assert(!m_values[rawValue].isUndefined());
        return m_values[rawValue];
    }

private:
    std::vector<emscripten::val> m_values;
};

// The names here are the ones canvas_advanced registers in
// EMSCRIPTEN_BINDINGS(RiveWASM_C2D); they are not the C++ type names.
struct JSEnums
{
    JSEnum blendMode{"BlendMode"};
    JSEnum fillRule{"FillRule"};
    JSEnum paintStyle{"RenderPaintStyle"};
    JSEnum strokeCap{"StrokeCap"};
    JSEnum strokeJoin{"StrokeJoin"};
};

// Built on first use, which must be after the import wait loop in
// TestingWindowCanvas2D's constructor.
static const JSEnums& jsEnums()
{
    static JSEnums enums;
    return enums;
}

// The classes below let this module drive the canvas2d renderer that lives in
// canvas_advanced.mjs.
//
// This harness and canvas_advanced are separately linked Emscripten modules:
// two WebAssembly.Memory instances, two C++ runtimes, two embind type
// registries. A pointer is only an offset into one module's linear memory, so
// nothing that is or contains one -- a rive::Renderer*, an rcp<>, a vtable --
// can be handed across. JS objects can, since there is only one JavaScript
// realm; that includes TypedArrays, which are ordinary JS objects that happen
// to view a particular module's heap.
//
// So each class holds the emscripten::val of its canvas_advanced counterpart
// and forwards to it, either directly for simple cases (e.g.
// m_jsPath.call<void>("moveTo", x, y)), or through Canvas2DTestUtilities, where
// that wrapper has logic worth exercising rather than duplicating.
//
// Ownership runs opposite to bindings_c2d.cpp: there the factory adopts the C++
// object out of the JS handle, whereas here the handle stays the sole owner,
// and embind never reclaims raw pointer handles by itself. So each destructor
// releases explicitly, via deleteLater() rather than delete() because
// renderer.js captures paths and paints in deferred draw-list closures that
// must outlive us until endFrame() flushes them.
//
// Every renderer object we see originates from JSRenderFactory, so a failed
// downcast is a bug rather than a legitimate "some other subclass" case --
// hence lite_rtti_cast_or_assert<> rather than the silent LITE_RTTI_CAST_OR_*
// macros.

// Gradients have no JS-side object to wrap, so there is no handle for
// makeLinearGradient() to return. Instead we hold the parameters and replay
// them onto the paint when JSRenderPaint::shader() is called, mirroring
// GradientShader in bindings_c2d.cpp.
class JSGradientShader
    : public LITE_RTTI_OVERRIDE(RenderShader, JSGradientShader)
{
public:
    JSGradientShader(const ColorInt colors[],
                     const float stops[],
                     size_t count) :
        m_stops(stops, stops + count), m_colors(colors, colors + count)
    {}

    virtual void applyToPaint(const emscripten::val& jsPaint) const = 0;

protected:
    void applyStopsToPaint(const emscripten::val& jsPaint) const
    {
        for (size_t i = 0; i < m_stops.size(); ++i)
        {
            jsPaint.call<void>("addStop", m_colors[i], m_stops[i]);
        }
    }

private:
    std::vector<float> m_stops;
    std::vector<ColorInt> m_colors;
};

class JSLinearGradientShader : public JSGradientShader
{
public:
    JSLinearGradientShader(const ColorInt colors[],
                           const float stops[],
                           size_t count,
                           float sx,
                           float sy,
                           float ex,
                           float ey) :
        JSGradientShader(colors, stops, count),
        m_startX(sx),
        m_startY(sy),
        m_endX(ex),
        m_endY(ey)
    {}

    void applyToPaint(const emscripten::val& jsPaint) const override
    {
        jsPaint.call<void>("linearGradient",
                           m_startX,
                           m_startY,
                           m_endX,
                           m_endY);
        applyStopsToPaint(jsPaint);
    }

private:
    float m_startX;
    float m_startY;
    float m_endX;
    float m_endY;
};

class JSRadialGradientShader : public JSGradientShader
{
public:
    JSRadialGradientShader(const ColorInt colors[],
                           const float stops[],
                           size_t count,
                           float cx,
                           float cy,
                           float radius) :
        JSGradientShader(colors, stops, count),
        m_centerX(cx),
        m_centerY(cy),
        m_radius(radius)
    {}

    void applyToPaint(const emscripten::val& jsPaint) const override
    {
        // renderer.js wants the radius expressed as a second point rather than
        // a scalar. Matches RadialGradientShader::passToJS in bindings_c2d.cpp.
        jsPaint.call<void>("radialGradient",
                           m_centerX,
                           m_centerY,
                           m_centerX + m_radius,
                           m_centerY);
        applyStopsToPaint(jsPaint);
    }

private:
    float m_centerX;
    float m_centerY;
    float m_radius;
};

class JSRenderPath : public LITE_RTTI_OVERRIDE(RenderPath, JSRenderPath)
{
public:
    JSRenderPath(emscripten::val&& jsPath) :
        m_jsPath(std::forward<emscripten::val>(jsPath))
    {}

    // Queued rather than deleted outright: renderer.js's _drawPath/_clipPath
    // capture the path in deferred draw-list closures, so it has to outlive us
    // until TestingWindowCanvas2D::endFrame() flushes them. See the comment on
    // flushPendingDeletes() there.
    ~JSRenderPath() override { m_jsPath.call<void>("deleteLater"); }

    void rewind() override { m_jsPath.call<void>("rewind"); }

    void fillRule(FillRule value) override
    {
        m_jsPath.call<void>("fillRule", jsEnums().fillRule(value));
    }

    void moveTo(float x, float y) override
    {
        m_jsPath.call<void>("moveTo", x, y);
    }

    void lineTo(float x, float y) override
    {
        m_jsPath.call<void>("lineTo", x, y);
    }

    void cubicTo(float ox, float oy, float ix, float iy, float x, float y)
        override
    {
        m_jsPath.call<void>("cubicTo", ox, oy, ix, iy, x, y);
    }

    void close() override { m_jsPath.call<void>("close"); }

    void addRenderPath(const RenderPath* path, const Mat2D& transform) override
    {
        float xx = transform.xx();
        float xy = transform.xy();
        float yx = transform.yx();
        float yy = transform.yy();
        float tx = transform.tx();
        float ty = transform.ty();
        auto* jsPath =
            rive::lite_rtti_cast_or_assert<const JSRenderPath*>(path);
        m_jsPath.call<void>("addPath", jsPath->js(), xx, xy, yx, yy, tx, ty);
    }

    void addRawPath(const RawPath& path) override
    {
        const rive::Vec2D* pts = path.points().data();
        for (auto v : path.verbs())
        {
            switch ((rive::PathVerb)v)
            {
                case rive::PathVerb::move:
                    move(*pts++);
                    break;
                case rive::PathVerb::line:
                    line(*pts++);
                    break;
                case rive::PathVerb::cubic:
                    cubic(pts[0], pts[1], pts[2]);
                    pts += 3;
                    break;
                case rive::PathVerb::close:
                    close();
                    break;
                default:
                    assert(false); // unexpected verb
            }
        }
        assert(pts - path.points().data() == path.points().size());
    }

    emscripten::val& js() { return m_jsPath; }
    const emscripten::val& js() const { return m_jsPath; }

private:
    emscripten::val m_jsPath;
};

class JSRenderPaint : public LITE_RTTI_OVERRIDE(RenderPaint, JSRenderPaint)
{
public:
    JSRenderPaint(emscripten::val&& jsPaint) :
        m_jsPaint(std::forward<emscripten::val>(jsPaint))
    {}

    ~JSRenderPaint() override { m_jsPaint.call<void>("deleteLater"); }

    void style(RenderPaintStyle style) override
    {
        m_jsPaint.call<void>("style", jsEnums().paintStyle(style));
    }

    void color(ColorInt value) override
    {
        m_jsPaint.call<void>("color", value);
    }

    void thickness(float value) override
    {
        m_jsPaint.call<void>("thickness", value);
    }

    void join(StrokeJoin value) override
    {
        m_jsPaint.call<void>("join", jsEnums().strokeJoin(value));
    }

    void cap(StrokeCap value) override
    {
        m_jsPaint.call<void>("cap", jsEnums().strokeCap(value));
    }

    void feather(float value) override
    {
        // Not currently implemented (yet)
    }

    void blendMode(BlendMode value) override
    {
        m_jsPaint.call<void>("blendMode", jsEnums().blendMode(value));
    }

    void shader(rcp<RenderShader> shader) override
    {
        if (shader == nullptr)
        {
            m_jsPaint.call<void>("clearGradient");
            return;
        }

        rive::lite_rtti_cast_or_assert<JSGradientShader*>(shader.get())
            ->applyToPaint(m_jsPaint);
    }

    void invalidateStroke() override {}

    emscripten::val& js() { return m_jsPaint; }
    const emscripten::val& js() const { return m_jsPaint; }

private:
    emscripten::val m_jsPaint;
};

class JSRenderImage : public LITE_RTTI_OVERRIDE(RenderImage, JSRenderImage)
{
public:
    JSRenderImage(emscripten::val&& jsImage) :
        m_jsImage(std::forward<emscripten::val>(jsImage))
    {
        // On load, renderer.js calls size() on the RenderImage it created,
        // which sets the dimensions on the wrapper in canvas_advanced's heap.
        // Ours is a separate rive::RenderImage with its own m_Width/m_Height,
        // and rive core reads those, so copy them across.
        emscripten::val testUtils =
            canvasAdvancedModule()["Canvas2DTestUtilities"];
        m_Width = testUtils.call<int>("imageWidth", m_jsImage);
        m_Height = testUtils.call<int>("imageHeight", m_jsImage);
    }

    ~JSRenderImage() override { m_jsImage.call<void>("deleteLater"); }

    emscripten::val& js() { return m_jsImage; }
    const emscripten::val& js() const { return m_jsImage; }

private:
    emscripten::val m_jsImage;
};

class JSRenderFactory : public rive::Factory
{
public:
    JSRenderFactory() : m_jsFactory(canvasAdvancedModule()["renderFactory"]) {}

    rcp<RenderBuffer> makeRenderBuffer(RenderBufferType type,
                                       RenderBufferFlags flags,
                                       size_t sizeInBytes) override
    {
        // These never cross the module boundary: rive core maps and fills them
        // here, and JSRenderer::drawImageMesh() copies the contents over when
        // it hands off. Must be a DataRenderBuffer for the LITE_RTTI casts
        // there to succeed.
        return make_rcp<DataRenderBuffer>(type, flags, sizeInBytes);
    }

    rcp<RenderShader> makeLinearGradient(float sx,
                                         float sy,
                                         float ex,
                                         float ey,
                                         const ColorInt colors[],
                                         const float stops[],
                                         size_t count) override
    {
        return rcp<RenderShader>(
            new JSLinearGradientShader(colors, stops, count, sx, sy, ex, ey));
    }

    rcp<RenderShader> makeRadialGradient(float cx,
                                         float cy,
                                         float radius,
                                         const ColorInt colors[],
                                         const float stops[],
                                         size_t count) override
    {
        return rcp<RenderShader>(
            new JSRadialGradientShader(colors, stops, count, cx, cy, radius));
    }

    rcp<RenderPath> makeRenderPath(RawPath& rawPath, FillRule fillRule) override
    {
        rcp<RenderPath> renderPath = makeEmptyRenderPath();
        renderPath->addRawPath(rawPath);
        renderPath->fillRule(fillRule);
        return renderPath;
    }

    rcp<RenderPath> makeEmptyRenderPath() override
    {
        return make_rcp<JSRenderPath>(
            m_jsFactory.call<emscripten::val>("makeRenderPath"));
    }

    rcp<RenderPaint> makeRenderPaint() override
    {
        return make_rcp<JSRenderPaint>(
            m_jsFactory.call<emscripten::val>("makeRenderPaint"));
    }

    rcp<RenderImage> decodeImage(Span<const uint8_t> bytes) override
    {
        if (bytes.empty())
        {
            return nullptr;
        }

        // Blocks until the <img> load event fires.
        return make_rcp<JSRenderImage>(emscripten::val::take_ownership(
            testingWindowCanvas2dDecodeImage(bytes.data(),
                                             static_cast<int>(bytes.size()))));
    }

private:
    emscripten::val m_jsFactory;
};

class JSRenderer : public rive::Renderer
{
public:
    JSRenderer() :
        m_jsRenderer(canvasAdvancedModule().call<emscripten::val>(
            "makeRenderer",
            emscripten::val::global("document")
                .call<emscripten::val>("getElementById",
                                       std::string("canvas"))))
    {}

    // Queued, not deleted: renderer.js holds us in _pendingCanvasRenderers
    // until the draw list is flushed.
    ~JSRenderer() override { m_jsRenderer.call<void>("deleteLater"); }

    void beginFrame(bool clear)
    {
        m_jsRenderer.call<void>("beginFrame", clear);
    }

    void save() override { m_jsRenderer.call<void>("save"); }
    void restore() override { m_jsRenderer.call<void>("restore"); }

    void transform(const Mat2D& matrix) override
    {
        m_jsRenderer.call<void>("transform",
                                matrix.xx(),
                                matrix.xy(),
                                matrix.yx(),
                                matrix.yy(),
                                matrix.tx(),
                                matrix.ty());
    }

    void drawPath(RenderPath* path, RenderPaint* paint) override
    {
        auto* jsPath = rive::lite_rtti_cast_or_assert<JSRenderPath*>(path);
        auto* jsPaint = rive::lite_rtti_cast_or_assert<JSRenderPaint*>(paint);
        m_jsRenderer.call<void>("_drawPath", jsPath->js(), jsPaint->js());
    }

    void clipPath(RenderPath* path) override
    {
        auto* jsPath = rive::lite_rtti_cast_or_assert<JSRenderPath*>(path);
        m_jsRenderer.call<void>("_clipPath", jsPath->js());
    }

    void drawImage(const RenderImage* image,
                   ImageSampler sampler,
                   BlendMode blendMode,
                   float opacity) override
    {
        auto* jsImage =
            rive::lite_rtti_cast_or_assert<const JSRenderImage*>(image);
        m_jsRenderer.call<void>("_drawRiveImage",
                                jsImage->js(),
                                jsEnums().blendMode(blendMode),
                                opacity);
    }

    void drawImageMesh(const RenderImage* image,
                       ImageSampler sampler,
                       rcp<RenderBuffer> vertices_f32,
                       rcp<RenderBuffer> uvCoords_f32,
                       rcp<RenderBuffer> indices_u16,
                       uint32_t vertexCount,
                       uint32_t indexCount,
                       BlendMode blendMode,
                       float opacity) override
    {
        auto* vtx = rive::lite_rtti_cast_or_assert<rive::DataRenderBuffer*>(
            vertices_f32.get());
        auto* uv = rive::lite_rtti_cast_or_assert<rive::DataRenderBuffer*>(
            uvCoords_f32.get());
        auto* indices = rive::lite_rtti_cast_or_assert<rive::DataRenderBuffer*>(
            indices_u16.get());

        uint32_t f32Count = vertexCount * 2;
        assert(vtx->sizeInBytes() == f32Count * sizeof(float));
        assert(uv->sizeInBytes() == f32Count * sizeof(float));
        assert(indices->sizeInBytes() == indexCount * sizeof(uint16_t));

        if (f32Count == 0 || indexCount == 0)
        {
            return;
        }

        // Unlike the rest of the shims, this one hands off to the C++ side of
        // canvas_advanced rather than to renderer.js, so that the real
        // RendererWrapper::drawImageMesh() runs -- it owns the mesh bounding
        // box computation and the atlas packing, and we'd otherwise have to
        // duplicate them here (and leave them untested).
        //
        // The typed_memory_views below are over our heap. A TypedArray is a
        // plain JS object, so canvas_advanced can read it even though it wraps
        // a different ArrayBuffer; it copies into its own DataRenderBuffers.
        // Nothing between here and the call allocates locally, so our memory
        // can't grow and detach them in the meantime.
        auto* jsImage =
            rive::lite_rtti_cast_or_assert<const JSRenderImage*>(image);
        canvasAdvancedModule()["Canvas2DTestUtilities"].call<void>(
            "drawImageMesh",
            m_jsRenderer,
            jsImage->js(),
            emscripten::val{
                emscripten::typed_memory_view(f32Count, vtx->f32s())},
            emscripten::val{
                emscripten::typed_memory_view(f32Count, uv->f32s())},
            emscripten::val{
                emscripten::typed_memory_view(indexCount, indices->u16s())},
            jsEnums().blendMode(blendMode),
            opacity);
    }

    void modulateOpacity(float opacity) override
    {
        m_jsRenderer.call<void>("modulateOpacity", opacity);
    }

private:
    emscripten::val m_jsRenderer;
};

class TestingWindowCanvas2D : public TestingWindow
{
public:
    TestingWindowCanvas2D()
    {
        testingWindowCanvas2dImportCanvasAdvanced();

        int w, h;
        emscripten_get_canvas_element_size("#canvas", &w, &h);
        m_width = w;
        m_height = h;

        m_factory = std::make_unique<JSRenderFactory>();
    }

    rive::Factory* factory() override { return m_factory.get(); }

    void resize(int width, int height) override
    {
        if (m_width != width || m_height != height)
        {
            TestingWindow::resize(width, height);
            emscripten_set_canvas_element_size("#canvas", width, height);
        }
    }

    std::unique_ptr<rive::Renderer> beginFrame(
        const FrameOptions& options) override
    {
        if (options.doClear)
        {
            testingWindowCanvas2dResetCanvas(options.clearColor);
        }

        auto renderer = std::make_unique<JSRenderer>();
        renderer->beginFrame(false);

        return renderer;
    }

    void endFrame(std::vector<uint8_t>* pixelData) override
    {
        // Flush commands so that we can read pixel data from the canvas.
        canvasAdvancedModule().call<void>("resolveAnimationFrame");

        // Now that the deferred draw list has run, nothing on the JS side is
        // still holding the objects our shims queued via deleteLater(). Embind
        // never reclaims these on its own -- class handles created from JS own
        // their C++ instance outright, and no finalizer is attached to raw
        // pointer handles -- so without this every path, paint and renderer
        // would accumulate in canvas_advanced's heap for the whole run.
        canvasAdvancedModule().call<void>("flushPendingDeletes");

        if (!pixelData)
        {
            return;
        }

        pixelData->resize(m_width * m_height * 4);
        if (!testingWindowCanvas2dGetCanvasPixels(pixelData->data(),
                                                  m_width,
                                                  m_height))
        {
            printf("Canvas size mismatch, read failed\n");
            pixelData->assign(pixelData->size(), 0);
            return;
        }

        // getImageData() hands back unpremultiplied RGBA. Multiply by alpha to
        // match the other backends.
        for (size_t i = 0; i < pixelData->size(); i += 4)
        {
            uint32_t a = (*pixelData)[i + 3];
            for (size_t c = 0; c < 3; ++c)
            {
                (*pixelData)[i + c] =
                    static_cast<uint8_t>(((*pixelData)[i + c] * a + 127) / 255);
            }
        }
    }

private:
    std::unique_ptr<JSRenderFactory> m_factory;
};
}; // namespace rive::gpu

TestingWindow* TestingWindow::MakeCanvas2D()
{
    return new rive::gpu::TestingWindowCanvas2D();
}

#endif