The stroker builds each run of segments as its own outline (inner edges cut where they
cross, through the bend's point where they can't) and unites the loops, so the
renderers' sum of signed areas is the stroke's true coverage: no pixel is darker where
pieces overlapped (it was up to about half a pixel at round joins, caps and the joints
of wide curves). The GPU stage draws the oracle's polygons, so it follows.
Fourteen corpus goldens change, all at stroke edges (lighter; the dark knots at
corners go). Measured, median of 80 renders, before -> after: 2,000 stroked shapes at
1080p 9.3 -> 9.0 ms; the demo 2.5 -> 2.6 ms; 300 self-crossing scribbles at 720p
5.9 -> 6.4 ms; edges handed to the rasterizers down 3 to 4 times.
Zoomed in on a wide dashed or profiled curve (from about 2000 %), the direction
of a join's gap, the difference of two nearly equal unit vectors, was noisier
than the join's sweep, and the join became a whole disc. The gap's middle is now
only consulted where the path nearly turns back; elsewhere the short way between
the two normals is the outside of the bend. Found while checking Convert Lines
to Fills against the stroker's polygons at 2400 %.
Text keeps its filters next to its styled runs. In HTML export, static text in several colours
with filters is one item of pieces (pp), so the pieces share one filtered group as evaluate
draws them; the page's player draws such items piece by piece.
* The page's player draws text with filters in a filtered group of its own,
as evaluate does (fx/fm on static text and fields); typed text in an input
field is the browser's and is reported.
* XFL: a text field's <filters> come in on the text instead of being
reported as skipped.
* GPU parity on filtered text: max 1/255, mean 0.003-0.005 (RTX 5090, Vulkan).
Model and commands (ADR 0099):
* FilterParam gains a colour's channels (color, shadow_color, highlight_color,
stop_<n>; red, green, blue 0-255, alpha in percent, as the tint) and the
stepped quality, inner, knockout and hide_object, whose keys hold.
* Classic tweens of lists that differ pair the kinds they share in order;
a filter without a partner fades to or from itself doing nothing.
* TextBlock carries a filter list; evaluate draws text with filters in a
filtered group, as a movie clip.
* filter.* commands and element.set_filters act on text; motion.set_key
keys a whole colour; eight built-in presets that can only be hidden
(filter.preset_hide).
Exercise Math.max/min ties between rounded negative zero and positive zero in both argument orders. Require reciprocal traces Infinity Infinity -Infinity -Infinity through the existing Rust/exported-JavaScript comparison fixture. Not run locally because Rust is unavailable; required hosted workflows await maintainer approval.
Keep the HTML player aligned with the Rust evaluator: zero-sign ties select +0 for max and -0 for min in any argument order. Exact helper comparison against native Math.min/max and Object.is passed 1,644 cases; the previous helper mismatched 28. Added integration trace coverage follows in the same PR.
A filter list entry carries an enabled switch (FilterEntry, flattened into the filter's
own object, so older files open unchanged); evaluate and the HTML export leave switched-off
filters out, so every renderer and export draws them as absent. New filter.* commands:
move, enable, remove, copy, paste, and presets (list, save, apply, rename, delete, export,
import) kept in the session like brushes. XFL import keeps disabled filters, switched off.
Classic tweens pair lists that include switched-off filters.
Animated values are written as Lottie keyframes instead of a hold key per
frame: holds where a value stays, eased keys where an ease of the document
(linear, Classic, Bezier, custom curves, Quad/Cubic/Back/Bounce) draws it,
one key per cubic piece, each span checked at every frame. Artwork that
moves keeps its outline in its own space under an animated group transform
(position, rotation, skew, scale); a track continues across keyframes that
hold their own copy of the object. LottieKeys::Frames keeps the old keying.
- doc: Classic Ease and nine families (Quad, Cubic, Quart, Quint, Sine, Back,
Circ, Bounce, Elastic) In/Out/InOut as pure functions of t; CustomEase of
up to 64 Bezier points, always valid (x monotonic, ends pinned, values
bounded), with exact split, move, handle, smooth/corner and delete edits;
saved eases in the document; classic tweens ease position, rotation,
scale, colour and filters separately; instance filters now tween.
- engine: ease.* commands (info, set, add/move/delete/convert point, move
handle, separate, save, delete, rename, list, copy, paste); saved eases and
custom curves in timeline.set_easing and motion.set_ease; plug-in policy.
- xfl: multi-segment and per-property custom eases import exactly; corpus
gains a per-property layer, goldens and probes updated.
- shell: ease menu with curve thumbnails and saved eases in the timeline,
Properties and Motion Editor; Custom Ease window (graph, keyboard, typed
values, save, copy/paste, property groups).
- tests: preset values, fits, monotonic x after random edits, hostile
curves, fuzz, file round trip, HTML runtime parity, Lottie bake.
paint.transform_fill no longer re-merges a raw fill: re-merging gave the shape
a new id after the first step of a drag, so the Gradient Transform tool lost
it in the editor's default (merge) drawing mode. The stop bar's edits are pure
functions now (add, move, remove, widest gap), tested; the tool's drags run
through real frames for linear, radial and bitmap fills; HTML canvas and SVG
export of spread, focal point, ellipse and linear RGB are checked.
Paint::Linear and Paint::Radial gain optional spread (extend/reflect/repeat)
and linear_rgb; radial gradients gain a focal point and a matrix (any
ellipse). All default and are skipped when unset, so older files and plain
gradients are stored as before. The CPU oracle, the GPU stage (and its
emulator), SVG and HTML export, and SVG and XFL import handle them exactly;
Lottie reports what it can't show. Fill frames (Paint::frame/with_frame/
fitted) are the basis of the Gradient Transform tool.
A group element kind holding its members as a one-layer, one-frame timeline
(serde default; older files unchanged), evaluated like an instance on its
layer; every walker (Library uses, sounds, player, HTML export, explorer,
clipboard, Library deletion) sees inside groups. symbol.edit opens a group in
place; the editing stack levels are symbols or groups. modify.group (Ctrl+G),
modify.ungroup (Ctrl+Shift+G), Break Apart on groups, and modify.combine
(Union, Intersect, Punch, Crop) on the planar map. Reserves ADR 0073.
Refs #206, #229
canvas.js combines both: soft-mask artwork draws on the mask's layer, which
has the place and size of the layer it masks (so inside a filtered group it
reaches past the canvas too); the filtering trail records mask modes. New
parity test: filters under and inside alpha and luminance masks against the
oracle's frame (largest difference 4e-7).
Found in a headless Chrome check of an exported page: the page script lacked
filters.js, so a movie with filters didn't start. The page test now checks
that the script holds all three sources in order.
The page runs every filter as the CPU renderer does: filters.js ports
filters.rs (box-blur passes, shadow, glow, bevel, gradient ramps, colour
matrices, knockout, inner, hide object) over a layer that reaches past the
canvas by the filters' reach, cut to the artwork plus that reach. Subtract
and Invert are composited per pixel with the renderer's formula. Filtered
groups are kept by what was drawn in them, so an unchanged group is
filtered once.
Parity in Boa against the oracle's own layers: 35 filter cases (every kind,
side, knockout and switch, and stacks) at view scales 1, 1.5 and 2, largest
difference 9.3e-4; box widths and offsets equal over 4160 resolutions.
node 24, 1080p: the demo's two filtered groups 3.4 ms a frame when both
change (0 when cached); a full-frame 1920x1080 glow 51 ms, drop shadow and
bevel 92 ms, blur 20 quality 3 146 ms; Subtract over 1080p 6 ms.