perf(runtime, performance): preserve path geometry on rigid transform (#14315) 4c824e6f05
* perf(runtime): keep a shape's local path across a rigid move

A shape's local path is each path's geometry mapped by inverseWorld *
pathTransform -- the path's transform relative to the shape. That survives any
rigid move: an ancestor translating, rotating or scaling moves the shape and
its paths together, so the local path the composer rebuilds is the one it
already holds. It rebuilt anyway, because a world transform change routes
through Path::onDirty -> Shape::pathChanged() as plain Path dirt.

The copy was never the expensive part. Rebuilding rewinds the ShapePaintPath,
which rewinds the RenderPath, which bumps a monotonic mutation id -- so the
cached inner-fan triangulation is dropped and rebuilt for geometry that did not
change. Worse, building one is charged against TriangulationController's frame
budget, and once that is spent every remaining path in the frame falls back to
midpoint fans; cache hits cost nothing.

So snapshot what the local path is built from -- each path's geometry version
and its transform relative to the shape -- and skip the rebuild when none of it
moved. Measured on a rigidly moving artboard: car_widgets 20.8 -> 15.1 us/frame
in the update pass (-27%, the same for rotation as for translation), zombie
skins 104 -> 90 us/frame, and re-triangulating those files' paths costs 41 and
140 us/frame respectively, which the retained cache now avoids entirely.

The comparison cannot be exact. Recomposing inverseWorld * pathTransform after
a move is an A^-1 * A round trip, so it lands a rounding step from the matrix
the buffer was built with -- under translation only in the translation, under
rotation in the linear part too. The tolerance is derived from the terms that
produce the value, and is compared against the last built transform rather than
the last frame, so the error is bounded rather than accumulating: at most a few
ULPs of the coordinates involved, measured at 3.7e-04 artboard units across
twelve real files. A sweep from 1 to 1024 ULPs moves the skip rate by under 3
points, so the constant is not load bearing.

Skinned paths rebuild their raw geometry every frame (the skin bakes world
space bone transforms into the vertices), so they keep rebuilding; making skins
shape relative would extend this to them.

Note this changes the silver command streams, which record the rewind and
addRawPath calls that no longer happen. 69 of them need rebaselining; nothing
else in the suite moves.

* test(runtime): render a tarnished silver next to its baseline

A silver fails on any byte difference in the recorded command stream, which is
stricter than "the frame changed": dropping a redundant rewind and addRawPath
pair moves those bytes without moving a pixel. Until now the only thing a
failure told you was the size of the stream, so a rebaseline came down to
trust.

Everything needed to do better was already in the binary. The SRIV stream
records at the Factory and Renderer level and carries its image bytes and mesh
buffers inline, so replaySerializedCommands can replay it with no .riv file or
fonts; unit_tests already links rive_cg_renderer and tools_common, so it can
replay into a CoreGraphics bitmap and write PNGs. Both sides go through that
same CPU renderer, so the comparison is exact even where the rasterizer is
approximate -- there is no golden to disagree with.

Hashes the frames first and only keeps pixels for the frames that differ (a
2370x1680 stream is 16MB a frame), then writes the baseline, the tarnished
render, a map of the differing pixels and a padded close-up of the region they
fall in, because the evidence is usually a handful of pixels on an
anti-aliased edge.

Hidden behind a dot tag, and deliberately run against the built binary rather
than through test.sh, which wipes silvers/tarnished on startup:

    ./out/release/unit_tests "[.silverdiff]"

* rebased tests

* fix(runtime): address review on the rigid transform path skip

- Do not run the snapshot for a shape with no local path. A clip source or a
  world stroke was paying for an inverse, a scratch vector and a per path
  compare whose result the world branch never reads. A shape that gains a
  local flag later still arrives here with no snapshot, which reads as
  changed, so it still builds.

- Release a CGRenderer before the context it draws into. ~CGRenderer restores
  a graphics state on its context, so releasing the context first left that
  restore reading through freed memory -- on the frame size change and again
  on the size probe.

- Fail when a tarnished silver has no readable baseline. It only counted the
  file as unreadable and carried on, so a run could report success having
  validated nothing, which is the one thing a rebaseline check must not do.

- clang-format (19.1.7, matching CI).

Drops silvers/super_ultra_mega_rig_bound_v002.sriv, which was picked up by the
rebaseline rather than authored: it is the only added silver in the set, and
its .riv lives outside the repo.

Co-authored-by: hernan <hernan@rive.app>