blob: d1c93a5dcf3d0033b3094655b5d51a5c7b657bf0 [file]
/*
* Copyright 2026 Rive
*/
// RiveRenderer::copyClipTo: a fresh renderer issuing a draw on behalf of one
// whose frame was interrupted (WebGL's offscreen composites) has to be clipped
// as the original would have been.
#include "common/render_context_null.hpp"
#include "rive/renderer/rive_renderer.hpp"
#include <catch.hpp>
using namespace rive;
using namespace rive::gpu;
namespace
{
RenderContext::FrameDescriptor s_frameDescriptor = {
.renderTargetWidth = 100,
.renderTargetHeight = 100,
};
void flushFrame(RenderContext* ctx)
{
auto renderTarget = ctx->static_impl_cast<RenderContextNULL>()
->makeRenderTarget(
s_frameDescriptor.renderTargetWidth,
s_frameDescriptor.renderTargetHeight);
ctx->flush({.renderTarget = renderTarget.get()});
}
rcp<RenderPath> makeOval(RenderContext* ctx, const AABB& bounds)
{
RawPath path;
path.addOval(bounds);
return ctx->makeRenderPath(path, FillRule::nonZero);
}
rcp<RenderPath> makeRect(RenderContext* ctx, const AABB& bounds)
{
RawPath path;
path.addRect(bounds);
return ctx->makeRenderPath(path, FillRule::nonZero);
}
} // namespace
TEST_CASE("a copied clip path clips the copy's draws", "[RiveRenderer][clip]")
{
auto ctx = RenderContextNULL::MakeContext();
ctx->beginFrame(s_frameDescriptor);
auto clip = makeOval(ctx.get(), {10, 10, 60, 60});
auto shape = makeRect(ctx.get(), {0, 0, 100, 100});
auto paint = ctx->makeRenderPaint();
paint->color(0xffffffff);
RiveRenderer original(ctx.get());
original.save();
original.translate(5, 5);
original.clipPath(clip.get());
// Gives the element a clip ID in this flush.
original.drawPath(shape.get(), paint.get());
REQUIRE(ctx->getClipContentID() != 0);
// What an offscreen raster does to the frame in the middle of a draw.
flushFrame(ctx.get());
ctx->beginFrame(s_frameDescriptor);
REQUIRE(ctx->getClipContentID() == 0);
RiveRenderer unclipped(ctx.get());
unclipped.drawPath(shape.get(), paint.get());
CHECK(ctx->getClipContentID() == 0);
RiveRenderer fresh(ctx.get());
fresh.save();
original.copyClipTo(&fresh);
Mat2D ctm;
REQUIRE(fresh.currentTransform(&ctm));
CHECK(ctm == Mat2D());
fresh.drawPath(shape.get(), paint.get());
// The copy drew its own clip element rather than trusting the stale ID.
CHECK(ctx->getClipContentID() != 0);
fresh.restore();
original.restore();
flushFrame(ctx.get());
}
TEST_CASE(
"a copied clip rect keeps its rect and matrix",
"[RiveRenderer][clip]")
{
auto ctx = RenderContextNULL::MakeContext();
ctx->beginFrame(s_frameDescriptor);
REQUIRE(ctx->frameSupportsClipRects());
auto rect = makeRect(ctx.get(), {10, 20, 30, 40});
RiveRenderer original(ctx.get());
original.scale(2, 2);
original.clipPath(rect.get());
REQUIRE(original.hasClipRect());
flushFrame(ctx.get());
ctx->beginFrame(s_frameDescriptor);
RiveRenderer fresh(ctx.get());
original.copyClipTo(&fresh);
REQUIRE(fresh.hasClipRect());
CHECK(fresh.getClipRect() == original.getClipRect());
CHECK(fresh.getClipRectMatrix() == Mat2D::fromScale(2, 2));
flushFrame(ctx.get());
}
// The interrupted renderer itself keeps drawing after the composite, so its
// own per-flush clip state has to go stale with the flush rather than alias
// whatever the resumed frame puts in the same place.
TEST_CASE(
"a clip ID from an earlier flush is not trusted",
"[RiveRenderer][clip]")
{
auto ctx = RenderContextNULL::MakeContext();
ctx->beginFrame(s_frameDescriptor);
auto clipA = makeOval(ctx.get(), {10, 10, 60, 60});
auto clipB = makeOval(ctx.get(), {40, 40, 90, 90});
auto shape = makeRect(ctx.get(), {0, 0, 100, 100});
auto paint = ctx->makeRenderPaint();
paint->color(0xffffffff);
RiveRenderer interrupted(ctx.get());
interrupted.clipPath(clipA.get());
interrupted.drawPath(shape.get(), paint.get());
const uint32_t staleID = ctx->getClipContentID();
REQUIRE(staleID != 0);
flushFrame(ctx.get());
ctx->beginFrame(s_frameDescriptor);
// Another clip takes the same ID in the new flush.
RiveRenderer other(ctx.get());
other.clipPath(clipB.get());
other.drawPath(shape.get(), paint.get());
REQUIRE(ctx->getClipContentID() == staleID);
// Matching it would draw under clipB; clipA has to be drawn again.
interrupted.drawPath(shape.get(), paint.get());
CHECK(ctx->getClipContentID() != staleID);
flushFrame(ctx.get());
}
TEST_CASE("a clip rect from an earlier frame is remade", "[RiveRenderer][clip]")
{
auto ctx = RenderContextNULL::MakeContext();
ctx->beginFrame(s_frameDescriptor);
REQUIRE(ctx->frameSupportsClipRects());
auto rectA = makeRect(ctx.get(), {10, 20, 30, 40});
auto rectB = makeRect(ctx.get(), {50, 50, 90, 70});
auto shape = makeRect(ctx.get(), {0, 0, 100, 100});
auto paint = ctx->makeRenderPaint();
paint->color(0xffffffff);
RiveRenderer interrupted(ctx.get());
interrupted.clipPath(rectA.get());
REQUIRE(interrupted.hasClipRect());
const Mat2D expected = gpu::ClipRectInverseMatrix(Mat2D(), {10, 20, 30, 40})
.inverseMatrix();
flushFrame(ctx.get());
ctx->beginFrame(s_frameDescriptor);
// Allocates from the recycled per-frame memory.
RiveRenderer other(ctx.get());
other.clipPath(rectB.get());
other.drawPath(shape.get(), paint.get());
interrupted.drawPath(shape.get(), paint.get());
REQUIRE(interrupted.getClipRectInverseMatrix() != nullptr);
CHECK(interrupted.getClipRectInverseMatrix()->inverseMatrix() == expected);
flushFrame(ctx.get());
}