AI-native design editor. Open-source Figma alternative.
fix(canvas): draw every shape from one outline (#1376)
Danila Poyarkov4e07954bae4e
diff --git a/changes/1376/breaking.md b/changes/1376/breaking.mdnew file mode 100644index 000000000..cbf3e1748--- /dev/null+++ b/changes/1376/breaking.md@@ -0,0 +1 @@+- `SkiaRenderer` drops the box and corner arguments from `drawNodeFill`, `drawNodeStroke`, `drawStrokeWithAlign`, `clipNodeShape`, `makeNodeShapePath`, `renderEffects`, and `applyClippedBlur`, and removes `drawArc` and `makeRRectWithOffset`: the renderer works out the outline itself.diff --git a/changes/1376/fixed.md b/changes/1376/fixed.mdnew file mode 100644index 000000000..12a92aae3--- /dev/null+++ b/changes/1376/fixed.md@@ -0,0 +1,2 @@+- An inside or outside stroke on a star, polygon, or arc follows its outline, as in Figma, instead of showing on both sides of a star or polygon and across an arc's flat edge.+- Shadows on stars, polygons, and vectors ignore their spread, as in Figma.diff --git a/packages/core/src/canvas/boolean.ts b/packages/core/src/canvas/boolean.tsindex 016bdfac5..10787547e 100644--- a/packages/core/src/canvas/boolean.ts+++ b/packages/core/src/canvas/boolean.ts@@ -4,9 +4,7 @@ import type { GroupFitOptions, SceneGraph, SceneNode } from '@open-pencil/scene-import { getTextOutlineSupport } from '#core/text/outlines'-import { makeArcPath } from './fills'import type { SkiaRenderer } from './renderer'-import { nodeHasRadius } from './shapes'import { makeLineStrokeOutline } from './strokes/line'import { textNodeToOutlinePath } from './text/outlines'@@ -66,10 +64,7 @@ export function canMakeBooleanSourceNode(node: SceneNode, graph: SceneGraph): bofunction baseShapePath(r: SkiaRenderer, node: SceneNode): Path | null {if (node.type === 'TEXT') return textNodeToOutlinePath(r, node)if (node.type === 'LINE') return makeLineStrokeOutline(r, node)- if (node.type === 'ELLIPSE' && node.arcData) return makeArcPath(r, node)-- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)- return r.makeNodeShapePath(node, rect, nodeHasRadius(node))+ return r.makeNodeShapePath(node)}function nodeHasVisibleFill(node: SceneNode): boolean {@@ -353,10 +348,7 @@ export function renderBooleanOperation(node: SceneNode,graph: SceneGraph): void {- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)- r.renderEffects(canvas, node, graph, rect, false, 'behind')- paintBooleanOperation(r, canvas, node, graph, () =>- r.renderEffects(canvas, node, graph, rect, false, 'inner')- )- r.renderEffects(canvas, node, graph, rect, false, 'front')+ r.renderEffects(canvas, node, graph, 'behind')+ paintBooleanOperation(r, canvas, node, graph, () => r.renderEffects(canvas, node, graph, 'inner'))+ r.renderEffects(canvas, node, graph, 'front')}diff --git a/packages/core/src/canvas/effects.ts b/packages/core/src/canvas/effects.tsindex cac044482..71d487c9a 100644--- a/packages/core/src/canvas/effects.ts+++ b/packages/core/src/canvas/effects.ts@@ -66,17 +66,16 @@ export function applyClippedBlur(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,sigma: number): void {+ const rect = r.ck.LTRBRect(0, 0, node.width, node.height)// Entry guard: reset shared paint to known stater.effectLayerPaint.setImageFilter(null)r.effectLayerPaint.setColorFilter(null)r.effectLayerPaint.setBlendMode(r.ck.BlendMode.SrcOver)canvas.save()- r.clipNodeShape(canvas, node, rect, hasRadius)+ r.clipNodeShape(canvas, node)canvas.saveLayer(undefined, rect, r.getCachedBlur(sigma), undefined, r.ck.TileMode.Clamp)canvas.restore()// Exit guard: ensure shared paint is in clean state@@ -122,8 +121,6 @@ function renderNoiseEffect(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,effect: RawNoiseEffect): void {const density = Math.max(0, Math.min(1, effect.density ?? 0.3))@@ -136,7 +133,7 @@ function renderNoiseEffect(try {paint.setAntiAlias(false)canvas.save()- r.clipNodeShape(canvas, node, rect, hasRadius)+ r.clipNodeShape(canvas, node)for (let y = 0; y < node.height; y += step) {for (let x = 0; x < node.width; x += step) {const value = seededNoise((x + 1) * 73856093 + (y + 1) * 19349663)@@ -156,14 +153,8 @@ function renderNoiseEffect(}/** Draws the raw Figma noise effects a node carries, which the scene graph does not model. */-export function renderNoiseEffects(- r: SkiaRenderer,- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean-): void {+export function renderNoiseEffects(r: SkiaRenderer, canvas: Canvas, node: SceneNode): void {for (const effect of rawNoiseEffects(node)) {- renderNoiseEffect(r, canvas, node, rect, hasRadius, effect)+ renderNoiseEffect(r, canvas, node, effect)}}diff --git a/packages/core/src/canvas/fills.ts b/packages/core/src/canvas/fills.tsindex d7de4c2e9..c39028628 100644--- a/packages/core/src/canvas/fills.ts+++ b/packages/core/src/canvas/fills.ts@@ -5,13 +5,11 @@ import { invertGradientTransform } from '@open-pencil/scene-graph/gradient'import Matrix from '@open-pencil/scene-graph/matrix'import type { Color, Rect, Vector } from '@open-pencil/scene-graph/primitives'-import { isWholeArc } from '#core/geometry'-import { figmaBlendModeToSkia } from './blend'import { makeDiamondGradient } from './gradients/diamond'import { previewEdge } from './images/previews'import type { SkiaRenderer } from './renderer'-import { makeSmoothRRectPath, nodeHasSmoothCorners } from './shapes'+import { drawOutline, withNodeOutline } from './shapes'interface PaintFillsOptions {readonly bindToNodeFills?: boolean@@ -71,62 +69,10 @@ export function drawVectorMultiStyleFills(return true}-export function drawNodeFill(- r: SkiaRenderer,- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean,- fill?: Fill-): void {- switch (node.type) {- case 'VECTOR': {- const fg = r.getFillGeometry(node)- if (fg) {- for (const p of fg) canvas.drawPath(p, r.fillPaint)- } else {- const vps = r.getVectorPaths(node)- if (vps) {- for (const vp of vps) canvas.drawPath(vp, r.fillPaint)- }- }- break- }- case 'ELLIPSE': {- const fg = r.getFillGeometry(node)- if (fg) {- for (const p of fg) canvas.drawPath(p, r.fillPaint)- } else if (node.arcData) {- r.drawArc(canvas, node, r.fillPaint)- } else {- canvas.drawOval(rect, r.fillPaint)- }- break- }- case 'TEXT':- r.renderText(canvas, node, fill)- break- case 'LINE':- canvas.drawLine(0, 0, node.width, node.height, r.fillPaint)- break- case 'POLYGON':- case 'STAR':- case 'SHAPE_WITH_TEXT': {- const path = r.makePolygonPath(node)- canvas.drawPath(path, r.fillPaint)- path.delete()- break- }- default:- if (nodeHasSmoothCorners(node)) {- const path = makeSmoothRRectPath(r, node)- canvas.drawPath(path, r.fillPaint)- path.delete()- } else if (hasRadius) {- canvas.drawRRect(r.makeRRect(node), r.fillPaint)- } else {- canvas.drawRect(rect, r.fillPaint)- }+export function drawNodeFill(r: SkiaRenderer, canvas: Canvas, node: SceneNode, fill?: Fill): void {+ if (node.type === 'TEXT') r.renderText(canvas, node, fill)+ else if (node.type !== 'LINE') {+ withNodeOutline(r, node, (outline) => drawOutline(canvas, outline, r.fillPaint))}}@@ -214,8 +160,6 @@ function recordPatternSource(const bounds = r.ck.LTRBRect(0, 0, layout.rect.width, layout.rect.height)const recorder = new r.ck.PictureRecorder()const canvas = recorder.beginRecording(bounds)- const rect = r.ck.LTRBRect(0, 0, source.width, source.height)- const hasRadius = nodeHasSmoothCorners(source) || source.cornerRadius > 0for (const position of layout.positions) {canvas.save()@@ -227,7 +171,7 @@ function recordPatternSource(source.fills,source,graph,- (sourceFill) => drawNodeFill(r, canvas, source, rect, hasRadius, sourceFill),+ (sourceFill) => drawNodeFill(r, canvas, source, sourceFill),{ patternStack })}@@ -522,55 +466,3 @@ export function applyImageFill(if (temporary) img.delete()}}--export function makeArcPath(r: SkiaRenderer, node: SceneNode) {- const arc = node.arcData- if (!arc) return null- const cx = node.width / 2- const cy = node.height / 2- const rx = node.width / 2- const ry = node.height / 2- const innerRx = rx * arc.innerRadius- const innerRy = ry * arc.innerRadius-- const startDeg = arc.startingAngle * (180 / Math.PI)- const endDeg = arc.endingAngle * (180 / Math.PI)- const sweepDeg = endDeg - startDeg-- const path = new r.ck.PathBuilder()- const oval = r.ck.LTRBRect(0, 0, node.width, node.height)-- const isFullCircle = isWholeArc(arc)- if (arc.innerRadius > 0) {- const innerOval = r.ck.LTRBRect(cx - innerRx, cy - innerRy, cx + innerRx, cy + innerRy)- if (isFullCircle) {- // Two loops wound in opposite directions, so the hole stays empty under nonzero fill. A- // full-turn `addArc` from an angle off the axes draws nothing.- path.addOval(oval, false)- path.addOval(innerOval, true)- } else {- // One outline whose ends run straight across the ring; `addArc` would start a new contour- // for each edge and close them on their chords.- path.arcToOval(oval, startDeg, sweepDeg, true)- path.arcToOval(innerOval, startDeg + sweepDeg, -sweepDeg, false)- }- path.close()- return path.detachAndDelete()- }-- if (isFullCircle) {- path.addOval(oval)- } else {- path.moveTo(cx, cy)- path.arcToOval(oval, startDeg, sweepDeg, false)- path.close()- }- return path.detachAndDelete()-}--export function drawArc(r: SkiaRenderer, canvas: Canvas, node: SceneNode, paint: Paint): void {- const path = makeArcPath(r, node)- if (!path) return- canvas.drawPath(path, paint)- path.delete()-}diff --git a/packages/core/src/canvas/renderer.ts b/packages/core/src/canvas/renderer.tsindex 0ff7d070b..1981f71c8 100644--- a/packages/core/src/canvas/renderer.ts+++ b/packages/core/src/canvas/renderer.ts@@ -372,33 +372,17 @@ export class SkiaRenderer {canvas: Canvas,node: SceneNode,graph: SceneGraph,- rect: Float32Array,- hasRadius: boolean,pass: EffectPass) => voiddeclare renderText: (canvas: Canvas, node: SceneNode, fill?: Fill) => void- declare drawNodeFill: (- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean,- fill?: Fill- ) => void+ declare drawNodeFill: (canvas: Canvas, node: SceneNode, fill?: Fill) => voiddeclare applyFill: (fill: Fill, node: SceneNode, graph: SceneGraph, fillIndex?: number) => booleandeclare applyGradientFill: (fill: Fill, node: SceneNode, graph: SceneGraph) => booleandeclare applyImageFill: (fill: Fill, node: SceneNode, graph: SceneGraph) => boolean- declare drawArc: (canvas: Canvas, node: SceneNode, paint: Paint) => void- declare drawNodeStroke: (- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean- ) => void+ declare drawNodeStroke: (canvas: Canvas, node: SceneNode) => voiddeclare drawStrokeWithAlign: (canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,align: 'INSIDE' | 'CENTER' | 'OUTSIDE') => voiddeclare drawRRectStrokeWithAlign: (@@ -409,22 +393,11 @@ export class SkiaRenderer {) => voiddeclare drawIndividualSideStrokes: (canvas: Canvas, node: SceneNode, stroke: Stroke) => voiddeclare strokeNodeShape: (canvas: Canvas, node: SceneNode, paint: Paint) => void- declare makeNodeShapePath: (node: SceneNode, rect: Float32Array, hasRadius: boolean) => Path+ declare makeNodeShapePath: (node: SceneNode) => Pathdeclare makePolygonPath: (node: SceneNode) => Pathdeclare makeRRect: (node: SceneNode) => Float32Arraydeclare makeRRectWithSpread: (node: SceneNode, spread: number) => Float32Array- declare makeRRectWithOffset: (- node: SceneNode,- ox: number,- oy: number,- spread: number- ) => Float32Array- declare clipNodeShape: (- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean- ) => void+ declare clipNodeShape: (canvas: Canvas, node: SceneNode) => voiddeclare getVectorPaths: (node: SceneNode) => Path[] | nulldeclare getFillGeometry: (node: SceneNode) => Path[] | nulldeclare getStrokeGeometry: (node: SceneNode) => Path[] | null@@ -437,13 +410,7 @@ export class SkiaRenderer {declare getCachedBlur: (sigma: number) => ImageFilterdeclare getCachedDecalBlur: (sigma: number) => ImageFilterdeclare getCachedMaskBlur: (sigma: number) => MaskFilter- declare applyClippedBlur: (- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean,- sigma: number- ) => void+ declare applyClippedBlur: (canvas: Canvas, node: SceneNode, sigma: number) => voidcolor4f(r: number, g: number, b: number, a: number): Float32Array {const c = this._tmpColorc[0] = rdiff --git a/packages/core/src/canvas/renderer/chunks/record.ts b/packages/core/src/canvas/renderer/chunks/record.tsindex ddda1edd7..97be83847 100644--- a/packages/core/src/canvas/renderer/chunks/record.ts+++ b/packages/core/src/canvas/renderer/chunks/record.ts@@ -6,7 +6,7 @@ import Matrix from '@open-pencil/scene-graph/matrix'import type { SkiaRenderer } from '#core/canvas/renderer'import { recordWorldPicture, withWorldViewport } from '#core/canvas/renderer/picture'-import { clipNodeShape, nodeHasRadius } from '#core/canvas/shapes'+import { clipNodeShape } from '#core/canvas/shapes'import type { RenderChunk } from './index'@@ -17,7 +17,7 @@ export interface RecordedRenderChunk {function clipAncestor(r: SkiaRenderer, canvas: Canvas, graph: SceneGraph, node: SceneNode): void {canvas.concat(getWorldMatrix(node, graph))- clipNodeShape(r, canvas, node, r.ck.LTRBRect(0, 0, node.width, node.height), nodeHasRadius(node))+ clipNodeShape(r, canvas, node)const inverse = Matrix.invert(getWorldMatrix(node, graph))if (inverse) canvas.concat(inverse)}diff --git a/packages/core/src/canvas/renderer/methods.ts b/packages/core/src/canvas/renderer/methods.tsindex e1fea9549..cb7b17bb0 100644--- a/packages/core/src/canvas/renderer/methods.ts+++ b/packages/core/src/canvas/renderer/methods.ts@@ -251,29 +251,16 @@ const rendererMethods: ThisType<SkiaRenderer> = {SceneRender.paintShapeContent(this, canvas, node, graph)},- renderEffects(- canvas: Canvas,- node: SceneNode,- graph: SceneGraph,- rect: Float32Array,- hasRadius: boolean,- pass: EffectPass- ): void {- renderShadowEffects(this, canvas, node, graph, rect, hasRadius, pass)+ renderEffects(canvas: Canvas, node: SceneNode, graph: SceneGraph, pass: EffectPass): void {+ renderShadowEffects(this, canvas, node, graph, pass)},renderText(canvas: Canvas, node: SceneNode, fill?: Fill): void {SceneRender.renderText(this, canvas, node, fill)},- drawNodeFill(- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean,- fill?: Fill- ): void {- Fills.drawNodeFill(this, canvas, node, rect, hasRadius, fill)+ drawNodeFill(canvas: Canvas, node: SceneNode, fill?: Fill): void {+ Fills.drawNodeFill(this, canvas, node, fill)},applyFill(fill: Fill, node: SceneNode, graph: SceneGraph, fillIndex = 0): boolean {@@ -288,22 +275,16 @@ const rendererMethods: ThisType<SkiaRenderer> = {return Fills.applyImageFill(this, fill, node, graph)},- drawArc(canvas: Canvas, node: SceneNode, paint: Paint): void {- Fills.drawArc(this, canvas, node, paint)- },-- drawNodeStroke(canvas: Canvas, node: SceneNode, rect: Float32Array, hasRadius: boolean): void {- Strokes.drawNodeStroke(this, canvas, node, rect, hasRadius)+ drawNodeStroke(canvas: Canvas, node: SceneNode): void {+ Strokes.drawNodeStroke(this, canvas, node)},drawStrokeWithAlign(canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,align: 'INSIDE' | 'CENTER' | 'OUTSIDE'): void {- Strokes.drawStrokeWithAlign(this, canvas, node, rect, hasRadius, align)+ Strokes.drawStrokeWithAlign(this, canvas, node, align)},drawRRectStrokeWithAlign(@@ -323,8 +304,8 @@ const rendererMethods: ThisType<SkiaRenderer> = {Strokes.strokeNodeShape(this, canvas, node, paint)},- makeNodeShapePath(node: SceneNode, rect: Float32Array, hasRadius: boolean): Path {- return Shapes.makeNodeShapePath(this, node, rect, hasRadius)+ makeNodeShapePath(node: SceneNode): Path {+ return Shapes.makeNodeShapePath(this, node)},makePolygonPath(node: SceneNode): Path {@@ -339,12 +320,8 @@ const rendererMethods: ThisType<SkiaRenderer> = {return Shapes.makeRRectWithSpread(this, node, spread)},- makeRRectWithOffset(node: SceneNode, ox: number, oy: number, spread: number): Float32Array {- return Shapes.makeRRectWithOffset(this, node, ox, oy, spread)- },-- clipNodeShape(canvas: Canvas, node: SceneNode, rect: Float32Array, hasRadius: boolean): void {- Shapes.clipNodeShape(this, canvas, node, rect, hasRadius)+ clipNodeShape(canvas: Canvas, node: SceneNode): void {+ Shapes.clipNodeShape(this, canvas, node)},getVectorPaths(node: SceneNode): Path[] | null {@@ -375,14 +352,8 @@ const rendererMethods: ThisType<SkiaRenderer> = {return Effects.getCachedMaskBlur(this, sigma)},- applyClippedBlur(- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean,- sigma: number- ): void {- Effects.applyClippedBlur(this, canvas, node, rect, hasRadius, sigma)+ applyClippedBlur(canvas: Canvas, node: SceneNode, sigma: number): void {+ Effects.applyClippedBlur(this, canvas, node, sigma)}}diff --git a/packages/core/src/canvas/scene.ts b/packages/core/src/canvas/scene.tsindex 2156327bd..cd8cb7008 100644--- a/packages/core/src/canvas/scene.ts+++ b/packages/core/src/canvas/scene.ts@@ -37,7 +37,6 @@ import {import { mapVisualBounds, subtreeVisualBounds } from './renderer/visual-bounds'import { renderLayerShadows } from './shadows'import { isLayerContainer } from './shadows/silhouette'-import { makeSmoothRRectPath, nodeHasRadius, nodeHasSmoothCorners } from './shapes'import {configureStrokePaint,drawArrowHeads,@@ -239,15 +238,7 @@ function renderChildren(node.type === 'FRAME' || node.type === 'COMPONENT' || node.type === 'INSTANCE'if (isClippableContainer && node.clipsContent && node.childIds.length > 0) {canvas.save()- if (nodeHasSmoothCorners(node)) {- const clipPath = makeSmoothRRectPath(r, node)- canvas.clipPath(clipPath, r.ck.ClipOp.Intersect, true)- clipPath.delete()- } else if (nodeHasRadius(node)) {- canvas.clipRRect(r.makeRRect(node), r.ck.ClipOp.Intersect, true)- } else {- canvas.clipRect(r.ck.LTRBRect(0, 0, node.width, node.height), r.ck.ClipOp.Intersect, true)- }+ r.clipNodeShape(canvas, node)renderChildIds(r, canvas, graph, node.childIds, overlays, absX, absY, hasTransformedAncestor)canvas.restore()} else {@@ -753,8 +744,6 @@ function drawRegularStroke(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,stroke: SceneNode['strokes'][0],sc: Color): void {@@ -765,7 +754,7 @@ function drawRegularStroke(if (node.independentStrokeWeights && r.isRectangularType(node.type)) {r.drawIndividualSideStrokes(canvas, node, stroke)} else if (!r.isRectangularType(node.type) || !drawFigmaDashes(r, canvas, node, stroke)) {- r.drawStrokeWithAlign(canvas, node, rect, hasRadius, stroke.align)+ r.drawStrokeWithAlign(canvas, node, stroke.align)}}@@ -773,8 +762,6 @@ function drawNodeStroke(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,stroke: SceneNode['strokes'][0],sc: Color,sg: Path[] | null,@@ -796,13 +783,13 @@ function drawNodeStroke(if (vectorPaths) {const outlineKey = strokeOutlineKey(node, stroke, 'regions')drawVectorPathStrokes(r, canvas, vectorPaths, stroke, sc, node.strokeMiterLimit, outlineKey)- } else drawRegularStroke(r, canvas, node, rect, hasRadius, stroke, sc)+ } else drawRegularStroke(r, canvas, node, stroke, sc)return}if (stroke.align !== 'INSIDE') {if (node.type === 'VECTOR' || node.type === 'TEXT') {drawVectorStrokeGeometry(r, canvas, sg, sc, stroke.opacity)- } else drawRegularStroke(r, canvas, node, rect, hasRadius, stroke, sc)+ } else drawRegularStroke(r, canvas, node, stroke, sc)return}@@ -816,7 +803,7 @@ function drawNodeStroke(if (clipPaths) {for (const path of clipPaths) canvas.clipPath(path, r.ck.ClipOp.Intersect, true)} else {- r.clipNodeShape(canvas, node, rect, hasRadius)+ r.clipNodeShape(canvas, node)}drawVectorStrokeGeometry(r, canvas, sg, sc, stroke.opacity)canvas.restore()@@ -855,8 +842,6 @@ function paintNodeStrokes(canvas: Canvas,node: SceneNode,graph: SceneGraph,- rect: Float32Array,- hasRadius: boolean,sg: Path[] | null,vectorPaths: Path[] | null,vectorStroke: Path[] | null@@ -895,7 +880,7 @@ function paintNodeStrokes(drawNodeArrowHeads(r, canvas, node, stroke, color)return}- drawNodeStroke(r, canvas, node, rect, hasRadius, stroke, color, sg, vectorPaths, vectorStroke)+ drawNodeStroke(r, canvas, node, stroke, color, sg, vectorPaths, vectorStroke)drawNodeArrowHeads(r, canvas, node, stroke, color)})}@@ -907,13 +892,9 @@ export function renderShapeUncached(node: SceneNode,graph: SceneGraph): void {- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)- const hasRadius = nodeHasRadius(node)- r.renderEffects(canvas, node, graph, rect, hasRadius, 'behind')- paintShapeContent(r, canvas, node, graph, () =>- r.renderEffects(canvas, node, graph, rect, hasRadius, 'inner')- )- r.renderEffects(canvas, node, graph, rect, hasRadius, 'front')+ r.renderEffects(canvas, node, graph, 'behind')+ paintShapeContent(r, canvas, node, graph, () => r.renderEffects(canvas, node, graph, 'inner'))+ r.renderEffects(canvas, node, graph, 'front')}/** Draws a shape's fills and strokes without its effects; `afterFills` runs between the two. */@@ -924,8 +905,6 @@ export function paintShapeContent(graph: SceneGraph,afterFills?: () => void): void {- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)- const hasRadius = nodeHasRadius(node)const sg = node.strokeGeometry.length > 0 ? r.getStrokeGeometry(node) : nullconst vectorPaths = node.type === 'VECTOR' ? r.getVectorPaths(node) : nullconst vectorStroke = node.type === 'VECTOR' ? vectorStrokePaths(r, node) : null@@ -933,7 +912,7 @@ export function paintShapeContent(const reflowedPathText = isReflowedPathText(node)if (pathTextStrokeFirst) {- paintNodeStrokes(r, canvas, node, graph, rect, hasRadius, sg, vectorPaths, vectorStroke)+ paintNodeStrokes(r, canvas, node, graph, sg, vectorPaths, vectorStroke)}if (reflowedPathText) {forVisibleStrokes(r, node, graph, (stroke, color) =>@@ -942,13 +921,13 @@ export function paintShapeContent(}if (!drawVectorMultiStyleFills(r, canvas, node, graph)) {- drawVisibleFills(r, node, graph, (fill) => r.drawNodeFill(canvas, node, rect, hasRadius, fill))+ drawVisibleFills(r, node, graph, (fill) => r.drawNodeFill(canvas, node, fill))}if (node.type === 'TEXT') drawTextEmoji(r, canvas, node)afterFills?.()if (!pathTextStrokeFirst && !reflowedPathText) {- paintNodeStrokes(r, canvas, node, graph, rect, hasRadius, sg, vectorPaths, vectorStroke)+ paintNodeStrokes(r, canvas, node, graph, sg, vectorPaths, vectorStroke)}}diff --git a/packages/core/src/canvas/shadows.ts b/packages/core/src/canvas/shadows.tsindex b25c49746..aee1237a0 100644--- a/packages/core/src/canvas/shadows.ts+++ b/packages/core/src/canvas/shadows.ts@@ -29,7 +29,6 @@ import {silhouetteBounds,separateShadowChildren} from './shadows/silhouette'-import { nodeHasRadius } from './shapes'function resetEffectLayerPaint(r: SkiaRenderer): void {r.effectLayerPaint.setImageFilter(null)r.effectLayerPaint.setColorFilter(null)@@ -39,13 +38,30 @@ function resetEffectLayerPaint(r: SkiaRenderer): void {/** `behind` draws drop shadows and background blur, `inner` inner shadows over fills, `front` noise. */export type EffectPass = 'behind' | 'inner' | 'front'+/**+ * Layers whose shadows Figma 126 never spreads: only boxes and ellipses, arcs among them, take a+ * spread, for drop and inner shadows alike.+ */+const UNSPREAD_TYPES: ReadonlySet<SceneNode['type']> = new Set<SceneNode['type']>([+ 'TEXT',+ 'BOOLEAN_OPERATION',+ 'STAR',+ 'POLYGON',+ 'VECTOR'+])+/** Figma spreads a shadow only where it follows the layer's own outline: shapes and filled frames that clip. */function shadowSpread(node: SceneNode, effect: Effect): number {- if (node.type === 'TEXT' || node.type === 'BOOLEAN_OPERATION') return 0+ if (UNSPREAD_TYPES.has(node.type)) return 0if (!isLayerContainer(node)) return effect.spreadreturn node.clipsContent && fillsCastShadow(node) ? effect.spread : 0}+/** The spread an inner shadow takes, inside any layer whose type Figma spreads. */+function innerShadowSpread(node: SceneNode, effect: Effect): number {+ return UNSPREAD_TYPES.has(node.type) ? 0 : effect.spread+}+function shadowLayerBounds(r: SkiaRenderer,graph: SceneGraph,@@ -144,15 +160,14 @@ function drawOwnShapeDropShadow(): boolean {const outline = regularStrokeOutline(node, spread)if (!outline && !castsFromOwnShape(node)) return false- const hasRadius = nodeHasRadius(node)const castsFill = fillsCastShadow(node)canvas.save()try {- if (knockout) clipOutShapeKnockout(r, canvas, node, hasRadius, outline)+ if (knockout) clipOutShapeKnockout(r, canvas, node, outline)if (castsFill && outline && strokeGrowsOutline(outline)) {drawOutlineDropShadow(r, canvas, node, effect, outline, spread, blendMode)} else if (castsFill) {- drawShapeDropShadow(r, canvas, node, effect, hasRadius, spread, blendMode)+ drawShapeDropShadow(r, canvas, node, effect, spread, blendMode)} else if (outline) {drawRingDropShadow(r, canvas, node, effect, outline, spread, blendMode)}@@ -328,9 +343,7 @@ function renderInnerShadow(canvas: Canvas,graph: SceneGraph,node: SceneNode,- rect: Float32Array,effect: Effect,- hasRadius: boolean,includeChildren: boolean): void {if (!includeChildren && !paintsCastShadow(node)) return@@ -340,20 +353,13 @@ function renderInnerShadow(if (children?.every(castsFromOwnShape)) {for (const child of children) {withChildCoordinates(canvas, child, effect, (local) =>- drawShapeInnerShadow(- r,- canvas,- child,- r.ck.LTRBRect(0, 0, child.width, child.height),- local,- nodeHasRadius(child)- )+ drawShapeInnerShadow(r, canvas, child, local, innerShadowSpread(child, local)))}return}if (!includeChildren && castsFromOwnShape(node)) {- drawShapeInnerShadow(r, canvas, node, rect, effect, hasRadius)+ drawShapeInnerShadow(r, canvas, node, effect, innerShadowSpread(node, effect))return}const bounds = shadowLayerBounds(r, graph, node, effect, 0, includeChildren)@@ -371,11 +377,9 @@ export function renderEffects(canvas: Canvas,node: SceneNode,graph: SceneGraph,- rect: Float32Array,- hasRadius: boolean,pass: EffectPass): void {- if (pass === 'front') renderNoiseEffects(r, canvas, node, rect, hasRadius)+ if (pass === 'front') renderNoiseEffects(r, canvas, node)const ownShadows = !isLayerContainer(node)for (const effect of node.effects) {@@ -386,11 +390,11 @@ export function renderEffects(}if (pass === 'behind' && effect.type === 'BACKGROUND_BLUR') {- r.applyClippedBlur(canvas, node, rect, hasRadius, blurSigma(effect.radius))+ r.applyClippedBlur(canvas, node, blurSigma(effect.radius))}if (pass === 'inner' && effect.type === 'INNER_SHADOW' && ownShadows) {- renderInnerShadow(r, canvas, graph, node, rect, effect, hasRadius, false)+ renderInnerShadow(r, canvas, graph, node, effect, false)}}}@@ -411,10 +415,8 @@ export function renderLayerShadows(const effects = node.effects.filter((effect) => effect.visible && effect.type === type)if (effects.length === 0) returnconst includeChildren = shadowIncludesChildren(graph, node)- const hasRadius = nodeHasRadius(node)- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)for (const effect of effects) {if (pass === 'behind') renderDropShadow(r, canvas, graph, node, effect, includeChildren)- else renderInnerShadow(r, canvas, graph, node, rect, effect, hasRadius, includeChildren)+ else renderInnerShadow(r, canvas, graph, node, effect, includeChildren)}}diff --git a/packages/core/src/canvas/shadows/shape.ts b/packages/core/src/canvas/shadows/shape.tsindex d1c5dd47b..2f2113639 100644--- a/packages/core/src/canvas/shadows/shape.ts+++ b/packages/core/src/canvas/shadows/shape.ts@@ -5,20 +5,11 @@ import type { Effect, SceneNode, Stroke } from '@open-pencil/scene-graph'import { figmaBlendModeToSkia } from '#core/canvas/blend'import { blurSigma } from '#core/canvas/effects'import type { SkiaRenderer } from '#core/canvas/renderer'-import {- makeNodeShapePath,- makeSmoothRRectPath,- nodeHasRadius,- nodeHasSmoothCorners-} from '#core/canvas/shapes'+import { drawOutline, makeNodeShapePath, nodeHasRadius, withNodeOutline } from '#core/canvas/shapes'import { sideStrokeRRects, strokeAlignShare } from '#core/canvas/strokes/sides'import { fillsCastShadow, paintCastsShadow } from './silhouette'-function isPathShape(node: SceneNode): boolean {- return node.type === 'POLYGON' || node.type === 'STAR' || node.type === 'VECTOR'-}-/** Whether the node's fill outline is its whole shadow: it casts from a fill and no stroke reaches past it. */export function castsFromOwnShape(node: SceneNode): boolean {return (@@ -113,19 +104,6 @@ function evenOutline(weight: number, align: Stroke['align']): StrokeOutline {return { outset: evenSides(outset), inset: evenSides(weight - outset), even: true, align }}-/** The node's rectangle, rounded rectangle, or ellipse grown by `offset`, or shrunk when negative. */-function grownShapePath(r: SkiaRenderer, node: SceneNode, offset: number): Path {- if (node.type !== 'ELLIPSE' && nodeHasSmoothCorners(node)) {- return makeSmoothRRectPath(r, node, offset)- }- const builder = new r.ck.PathBuilder()- const rect = r.ltrb(-offset, -offset, node.width + offset, node.height + offset)- if (node.type === 'ELLIPSE') builder.addOval(rect)- else if (nodeHasRadius(node)) builder.addRRect(r.makeRRectWithSpread(node, offset))- else builder.addRect(rect)- return builder.detachAndDelete()-}-/** The outline the node's stroke gives it, grown further by `spread`. */function strokeOutlinePath(r: SkiaRenderer,@@ -133,57 +111,12 @@ function strokeOutlinePath(outline: StrokeOutline,spread: number): Path {- if (outline.even) return grownShapePath(r, node, outline.outset[0] + spread)+ if (outline.even) return makeNodeShapePath(r, node, outline.outset[0] + spread)const builder = new r.ck.PathBuilder()builder.addRRect(sideStrokeRRects(node, outline.align, spread).outer)return builder.detachAndDelete()}-function pathWithSpread(r: SkiaRenderer, path: Path, spread: number): Path | null {- if (spread === 0) return path.copy()- const ring = path.makeStroked({ width: Math.abs(spread) * 2, join: r.ck.StrokeJoin.Round })- if (!ring) return null- const result = r.ck.Path.MakeFromOp(- path,- ring,- spread > 0 ? r.ck.PathOp.Union : r.ck.PathOp.Difference- )- ring.delete()- return result-}--function drawPathShape(- r: SkiaRenderer,- canvas: Canvas,- node: SceneNode,- hasRadius: boolean,- spread = 0-): void {- const path = makeNodeShapePath(r, node, r.ltrb(0, 0, node.width, node.height), hasRadius)- const spreadPath = pathWithSpread(r, path, spread)- path.delete()- if (!spreadPath) return- try {- canvas.drawPath(spreadPath, r.auxFill)- } finally {- spreadPath.delete()- }-}--function drawShadowGeometryPath(r: SkiaRenderer, canvas: Canvas, path: Path, spread: number): void {- if (spread === 0) {- canvas.drawPath(path, r.auxFill)- return- }- const spreadPath = pathWithSpread(r, path, spread)- if (!spreadPath) return- try {- canvas.drawPath(spreadPath, r.auxFill)- } finally {- spreadPath.delete()- }-}-/*** Draws what `draw` paints with `r.auxFill` as a shadow, offset and blurred as a mask, which lets* Skia blur rectangles and rounded rectangles analytically.@@ -216,29 +149,12 @@ export function drawShapeDropShadow(canvas: Canvas,node: SceneNode,effect: Effect,- hasRadius: boolean,spread: number,blendMode: BlendMode): void {- const sp = spread- const geometryShadow = r.getFillGeometry(node)- drawMaskShadow(r, canvas, effect, blendMode, () => {- if (geometryShadow) {- for (const path of geometryShadow) drawShadowGeometryPath(r, canvas, path, sp)- } else if (node.type === 'ELLIPSE') {- canvas.drawOval(r.ltrb(-sp, -sp, node.width + sp, node.height + sp), r.auxFill)- } else if (isPathShape(node)) {- drawPathShape(r, canvas, node, hasRadius, sp)- } else if (nodeHasSmoothCorners(node)) {- const path = makeSmoothRRectPath(r, node, sp)- canvas.drawPath(path, r.auxFill)- path.delete()- } else if (hasRadius) {- canvas.drawRRect(r.makeRRectWithSpread(node, sp), r.auxFill)- } else {- canvas.drawRect(r.ltrb(-sp, -sp, node.width + sp, node.height + sp), r.auxFill)- }- })+ drawMaskShadow(r, canvas, effect, blendMode, () =>+ withNodeOutline(r, node, (outline) => drawOutline(canvas, outline, r.auxFill), spread)+ )}/** Whether the stroke reaches past the shape on any side, so it grows the shadow. */@@ -257,17 +173,10 @@ export function drawOutlineDropShadow(blendMode: BlendMode): void {drawMaskShadow(r, canvas, effect, blendMode, () => {- const offset = outline.outset[0] + spread- const rect = r.ltrb(-offset, -offset, node.width + offset, node.height + offset)- if (!outline.even) {- canvas.drawRRect(sideStrokeRRects(node, outline.align, spread).outer, r.auxFill)- } else if (node.type !== 'ELLIPSE' && nodeHasSmoothCorners(node)) {- const path = strokeOutlinePath(r, node, outline, spread)- canvas.drawPath(path, r.auxFill)- path.delete()- } else if (node.type === 'ELLIPSE') canvas.drawOval(rect, r.auxFill)- else if (nodeHasRadius(node)) canvas.drawRRect(r.makeRRectWithSpread(node, offset), r.auxFill)- else canvas.drawRect(rect, r.auxFill)+ if (outline.even) {+ const grow = outline.outset[0] + spread+ withNodeOutline(r, node, (shape) => drawOutline(canvas, shape, r.auxFill), grow)+ } else canvas.drawRRect(sideStrokeRRects(node, outline.align, spread).outer, r.auxFill)})}@@ -288,7 +197,7 @@ export function drawRingDropShadow(outer.delete()const inset = outline.inset[0] + spreadif (inset * 2 < Math.min(node.width, node.height)) {- const inner = grownShapePath(r, node, -inset)+ const inner = makeNodeShapePath(r, node, -inset)builder.addPath(inner)inner.delete()}@@ -311,122 +220,53 @@ export function clipOutShapeKnockout(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- hasRadius: boolean,outline: StrokeOutline | null): void {- const geometry = outline ? null : r.getFillGeometry(node)- if (geometry) {- for (const path of geometry) canvas.clipPath(path, r.ck.ClipOp.Difference, true)- return- }- const path = outline- ? strokeOutlinePath(r, node, outline, 0)- : makeNodeShapePath(r, node, r.ltrb(0, 0, node.width, node.height), hasRadius)+ const path = outline ? strokeOutlinePath(r, node, outline, 0) : makeNodeShapePath(r, node)canvas.clipPath(path, r.ck.ClipOp.Difference, true)path.delete()}+/**+ * Draws an inner shadow: everything outside the shape, moved by the shadow's offset and grown+ * into the shape by its spread, blurred and clipped to the shape.+ */export function drawShapeInnerShadow(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,effect: Effect,- hasRadius: boolean+ spread: number): void {- const sp = effect.spread- const shapeNode = node+ const sp = spreadr.auxFill.setColor(r.ck.Color4f(effect.color.r, effect.color.g, effect.color.b, effect.color.a))r.auxFill.setImageFilter(r.getCachedDecalBlur(blurSigma(effect.radius)))r.auxFill.setBlendMode(figmaBlendModeToSkia(r.ck, effect.blendMode))- const shapeRect = rect- const shapeHasRadius = hasRadius-canvas.save()try {- if (shapeNode.type === 'ELLIPSE') {- const builder = new r.ck.PathBuilder()- builder.addOval(shapeRect)- const path = builder.detachAndDelete()- try {- canvas.clipPath(path, r.ck.ClipOp.Intersect, true)- } finally {- path.delete()- }- } else if (isPathShape(shapeNode)) {- const path = makeNodeShapePath(r, shapeNode, shapeRect, shapeHasRadius)- try {- canvas.clipPath(path, r.ck.ClipOp.Intersect, true)- } finally {- path.delete()- }- } else if (nodeHasSmoothCorners(shapeNode)) {- const path = makeSmoothRRectPath(r, shapeNode)- canvas.clipPath(path, r.ck.ClipOp.Intersect, true)- path.delete()- } else if (shapeHasRadius) {- canvas.clipRRect(r.makeRRect(shapeNode), r.ck.ClipOp.Intersect, true)- } else {- canvas.clipRect(shapeRect, r.ck.ClipOp.Intersect, true)- }-+ r.clipNodeShape(canvas, node)const expand = effect.radius * 2- const { x: localOffsetX, y: localOffsetY } = effect.offset-+ const { x: offsetX, y: offsetY } = effect.offsetconst spreadPadding = sp < 0 ? -sp : 0- const big = r.ck.LTRBRect(- Math.min(-expand, -expand + localOffsetX - spreadPadding),- Math.min(-expand, -expand + localOffsetY - spreadPadding),- Math.max(shapeNode.width + expand, shapeNode.width + expand + localOffsetX + spreadPadding),- Math.max(shapeNode.height + expand, shapeNode.height + expand + localOffsetY + spreadPadding)- )- const bigPathBuilder = new r.ck.PathBuilder()- bigPathBuilder.addRect(big)- const bigPath = bigPathBuilder.detachAndDelete()- let innerPath: Path | null = null- if (shapeNode.type === 'ELLIPSE') {- const builder = new r.ck.PathBuilder()- const offsetRect = r.ck.LTRBRect(- localOffsetX + sp,- localOffsetY + sp,- shapeNode.width + localOffsetX - sp,- shapeNode.height + localOffsetY - sp- )- builder.addOval(offsetRect)- innerPath = builder.detachAndDelete()- } else if (isPathShape(shapeNode)) {- const sourcePath = makeNodeShapePath(r, shapeNode, shapeRect, shapeHasRadius)- const transformedBuilder = new r.ck.PathBuilder()- transformedBuilder.addPath(sourcePath, r.ck.Matrix.translated(localOffsetX, localOffsetY))- sourcePath.delete()- const transformed = transformedBuilder.detachAndDelete()- innerPath = pathWithSpread(r, transformed, -sp)- transformed.delete()- } else if (nodeHasSmoothCorners(shapeNode)) {- innerPath = makeSmoothRRectPath(r, shapeNode, -sp, localOffsetX, localOffsetY)- } else if (shapeHasRadius) {- const builder = new r.ck.PathBuilder()- builder.addRRect(r.makeRRectWithOffset(shapeNode, localOffsetX, localOffsetY, sp))- innerPath = builder.detachAndDelete()- } else {- const builder = new r.ck.PathBuilder()- builder.addRect(- r.ck.LTRBRect(- localOffsetX + sp,- localOffsetY + sp,- shapeNode.width + localOffsetX - sp,- shapeNode.height + localOffsetY - sp- )+ const area = new r.ck.PathBuilder()+ area.addRect(+ r.ck.LTRBRect(+ Math.min(-expand, -expand + offsetX - spreadPadding),+ Math.min(-expand, -expand + offsetY - spreadPadding),+ Math.max(node.width + expand, node.width + expand + offsetX + spreadPadding),+ Math.max(node.height + expand, node.height + expand + offsetY + spreadPadding))- innerPath = builder.detachAndDelete()- }-- const shadowPath = innerPath- ? r.ck.Path.MakeFromOp(bigPath, innerPath, r.ck.PathOp.Difference)- : null- innerPath?.delete()- bigPath.delete()+ )+ const shrunk = makeNodeShapePath(r, node, -sp)+ const moved = new r.ck.PathBuilder()+ moved.addPath(shrunk, r.ck.Matrix.translated(offsetX, offsetY))+ shrunk.delete()+ const areaPath = area.detachAndDelete()+ const shapePath = moved.detachAndDelete()+ const shadowPath = r.ck.Path.MakeFromOp(areaPath, shapePath, r.ck.PathOp.Difference)+ areaPath.delete()+ shapePath.delete()if (shadowPath) {canvas.drawPath(shadowPath, r.auxFill)shadowPath.delete()diff --git a/packages/core/src/canvas/shadows/silhouette.ts b/packages/core/src/canvas/shadows/silhouette.tsindex c9ebf9904..ff95ab1a2 100644--- a/packages/core/src/canvas/shadows/silhouette.ts+++ b/packages/core/src/canvas/shadows/silhouette.ts@@ -143,12 +143,7 @@ function drawChildSilhouettes(canvas.save()try {if (clipsChildren(node)) {- r.clipNodeShape(- canvas,- node,- r.ck.LTRBRect(0, 0, node.width, node.height),- nodeHasRadius(node)- )+ r.clipNodeShape(canvas, node)}renderMaskedChildIds(r,diff --git a/packages/core/src/canvas/shapes.ts b/packages/core/src/canvas/shapes.tsindex d99fa80c8..032400e5f 100644--- a/packages/core/src/canvas/shapes.ts+++ b/packages/core/src/canvas/shapes.ts@@ -1,9 +1,10 @@-import type { Canvas, Path } from 'canvaskit-wasm'+import type { Canvas, Paint, Path } from 'canvaskit-wasm'import type { SceneNode } from '@open-pencil/scene-graph'import { polygonOutline, type PolygonOutlineCommand } from '@open-pencil/scene-graph/polygon'import { shapeWithTextGeometry } from '@open-pencil/scene-graph/shape-with-text'+import { isWholeArc } from '#core/geometry'import { vectorNetworkToPath, geometryBlobToPath } from '#core/vector'import { traceSmoothRect } from './paths/smooth-corners'@@ -33,18 +34,12 @@ export function nodeHasSmoothCorners(node: SceneNode): boolean {return node.cornerRadius > 0}-export function makeSmoothRRectPath(- r: SkiaRenderer,- node: SceneNode,- spread = 0,- offsetX = 0,- offsetY = 0-): Path {+export function makeSmoothRRectPath(r: SkiaRenderer, node: SceneNode, spread = 0): Path {const path = new r.ck.PathBuilder()- const left = offsetX - spread- const top = offsetY - spread- const right = offsetX + node.width + spread- const bottom = offsetY + node.height + spread+ const left = 0 - spread+ const top = 0 - spread+ const right = node.width + spread+ const bottom = node.height + spreadconst width = right - leftconst height = bottom - topif (width <= 0 || height <= 0) {@@ -58,46 +53,126 @@ export function makeSmoothRRectPath(return path.detachAndDelete()}-export function makeNodeShapePath(+/**+ * A layer's outline as Skia draws it fastest: its box, its rounded box, its oval, or paths. Paths+ * the renderer caches are borrowed; the rest are `owned` and freed by `withNodeOutline`.+ */+export type NodeOutline =+ | { kind: 'rect'; rect: Float32Array }+ | { kind: 'rrect'; rrect: Float32Array }+ | { kind: 'oval'; rect: Float32Array }+ | { kind: 'paths'; paths: readonly Path[]; owned: boolean }++/**+ * `path` grown by `spread`, or shrunk when it is negative, by a round-joined ring around it. Null+ * when Skia cannot build the ring.+ */+function pathWithSpread(r: SkiaRenderer, path: Path, spread: number): Path | null {+ if (spread === 0) return path.copy()+ const ring = path.makeStroked({ width: Math.abs(spread) * 2, join: r.ck.StrokeJoin.Round })+ if (!ring) return null+ const result = r.ck.Path.MakeFromOp(+ path,+ ring,+ spread > 0 ? r.ck.PathOp.Union : r.ck.PathOp.Difference+ )+ ring.delete()+ return result+}++/** `paths` grown by `spread` as an outline that owns them: borrowed ones are copied. */+function pathsOutline(r: SkiaRenderer,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean-): Path {- const path = new r.ck.PathBuilder()+ paths: readonly (Path | null)[],+ spread: number,+ owned: boolean+): NodeOutline {+ const present = paths.filter((path): path is Path => path !== null)+ if (spread === 0) return { kind: 'paths', paths: present, owned }+ const grown = present.map((path) => pathWithSpread(r, path, spread))+ if (owned) for (const path of present) path.delete()+ return { kind: 'paths', paths: grown.filter((path): path is Path => path !== null), owned: true }+}++/**+ * The outline a layer fills and clips to, grown by `spread`: saved fill geometry first, as Figma+ * gave it, then an arc, a polygon, star, or shape with text, a vector's paths, and a box with its+ * corners. Boxes and ovals grow as boxes and ovals; paths grow by a round-joined ring.+ */+function nodeOutline(r: SkiaRenderer, node: SceneNode, spread: number): NodeOutline {+ // `0 - spread` rather than `-spread`: a spread of 0 must not put -0 into flattened geometry.+ const rect = r.ck.LTRBRect(0 - spread, 0 - spread, node.width + spread, node.height + spread)switch (node.type) {- case 'ELLIPSE':- path.addOval(rect)- breakcase 'VECTOR': {- const vps = r.getVectorPaths(node)- if (vps) {- for (const vp of vps) path.addPath(vp)- }- break+ const paths = r.getFillGeometry(node) ?? r.getVectorPaths(node) ?? []+ return pathsOutline(r, paths, spread, false)+ }+ case 'ELLIPSE': {+ const geometry = r.getFillGeometry(node)+ if (geometry) return pathsOutline(r, geometry, spread, false)+ if (node.arcData) return pathsOutline(r, [makeArcPath(r, node)], spread, true)+ return { kind: 'oval', rect }}case 'POLYGON':case 'STAR':- case 'SHAPE_WITH_TEXT': {- const polyPath = r.makePolygonPath(node)- path.addPath(polyPath)- polyPath.delete()- break- }+ case 'SHAPE_WITH_TEXT':+ return pathsOutline(r, [makePolygonPath(r, node)], spread, true)default:if (nodeHasSmoothCorners(node)) {- const smoothPath = makeSmoothRRectPath(r, node)- path.addPath(smoothPath)- smoothPath.delete()- } else if (hasRadius) {- path.addRRect(r.makeRRect(node))- } else {- path.addRect(rect)+ return { kind: 'paths', paths: [makeSmoothRRectPath(r, node, spread)], owned: true }}+ if (nodeHasRadius(node)) return { kind: 'rrect', rrect: makeRRectWithSpread(r, node, spread) }+ return { kind: 'rect', rect }+ }+}++/** Runs `use` with the layer's outline grown by `spread`, then frees the paths it built for it. */+export function withNodeOutline<T>(+ r: SkiaRenderer,+ node: SceneNode,+ use: (outline: NodeOutline) => T,+ spread = 0+): T {+ const outline = nodeOutline(r, node, spread)+ try {+ return use(outline)+ } finally {+ if (outline.kind === 'paths' && outline.owned) for (const path of outline.paths) path.delete()}+}++export function drawOutline(canvas: Canvas, outline: NodeOutline, paint: Paint): void {+ switch (outline.kind) {+ case 'rect':+ canvas.drawRect(outline.rect, paint)+ return+ case 'rrect':+ canvas.drawRRect(outline.rrect, paint)+ return+ case 'oval':+ canvas.drawOval(outline.rect, paint)+ return+ case 'paths':+ for (const path of outline.paths) canvas.drawPath(path, paint)+ }+}++/** `outline` as one path the caller owns. */+function outlineToPath(r: SkiaRenderer, outline: NodeOutline): Path {+ if (outline.kind === 'paths' && outline.paths.length === 1) return outline.paths[0].copy()+ const path = new r.ck.PathBuilder()+ if (outline.kind === 'rect') path.addRect(outline.rect)+ else if (outline.kind === 'rrect') path.addRRect(outline.rrect)+ else if (outline.kind === 'oval') path.addOval(outline.rect)+ else for (const source of outline.paths) path.addPath(source)return path.detachAndDelete()}+/** The layer's outline grown by `spread`, as one path the caller owns. */+export function makeNodeShapePath(r: SkiaRenderer, node: SceneNode, spread = 0): Path {+ return withNodeOutline(r, node, (outline) => outlineToPath(r, outline), spread)+}+function outlinePath(r: SkiaRenderer, commands: PolygonOutlineCommand[]): Path {const path = new r.ck.PathBuilder()for (const command of commands) {@@ -163,8 +238,8 @@ export function makeRRectWithSpread(): Float32Array {if (node.independentCorners) {return new Float32Array([- -spread,- -spread,+ 0 - spread,+ 0 - spread,node.width + spread,node.height + spread,Math.max(0, node.topLeftRadius + spread),@@ -178,70 +253,25 @@ export function makeRRectWithSpread(])}return r.ck.RRectXY(- r.ck.LTRBRect(-spread, -spread, node.width + spread, node.height + spread),+ r.ck.LTRBRect(0 - spread, 0 - spread, node.width + spread, node.height + spread),Math.max(0, node.cornerRadius + spread),Math.max(0, node.cornerRadius + spread))}-export function makeRRectWithOffset(- r: SkiaRenderer,- node: SceneNode,- ox: number,- oy: number,- spread: number-): Float32Array {- const s = spread- if (node.independentCorners) {- return new Float32Array([- ox + s,- oy + s,- node.width + ox - s,- node.height + oy - s,- Math.max(0, node.topLeftRadius - s),- Math.max(0, node.topLeftRadius - s),- Math.max(0, node.topRightRadius - s),- Math.max(0, node.topRightRadius - s),- Math.max(0, node.bottomRightRadius - s),- Math.max(0, node.bottomRightRadius - s),- Math.max(0, node.bottomLeftRadius - s),- Math.max(0, node.bottomLeftRadius - s)- ])- }- return r.ck.RRectXY(- r.ck.LTRBRect(ox + s, oy + s, node.width + ox - s, node.height + oy - s),- Math.max(0, node.cornerRadius - s),- Math.max(0, node.cornerRadius - s)- )-}--export function clipNodeShape(- r: SkiaRenderer,- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean-): void {- if (node.type === 'SHAPE_WITH_TEXT') {- // Clipped by its kind's outline, so an inside stroke follows it rather than the box.- const clipPath = r.makePolygonPath(node)- canvas.clipPath(clipPath, r.ck.ClipOp.Intersect, true)- clipPath.delete()- } else if (node.type === 'ELLIPSE') {- const clipPath = new r.ck.PathBuilder()- clipPath.addOval(rect)- const immutableClipPath = clipPath.detachAndDelete()- canvas.clipPath(immutableClipPath, r.ck.ClipOp.Intersect, true)- immutableClipPath.delete()- } else if (nodeHasSmoothCorners(node)) {- const clipPath = makeSmoothRRectPath(r, node)- canvas.clipPath(clipPath, r.ck.ClipOp.Intersect, true)- clipPath.delete()- } else if (hasRadius) {- canvas.clipRRect(r.makeRRect(node), r.ck.ClipOp.Intersect, true)- } else {- canvas.clipRect(rect, r.ck.ClipOp.Intersect, true)- }+export function clipNodeShape(r: SkiaRenderer, canvas: Canvas, node: SceneNode): void {+ withNodeOutline(r, node, (outline) => {+ const op = r.ck.ClipOp.Intersect+ if (outline.kind === 'rect') canvas.clipRect(outline.rect, op, true)+ else if (outline.kind === 'rrect') canvas.clipRRect(outline.rrect, op, true)+ else if (outline.kind === 'paths' && outline.paths.length === 1) {+ canvas.clipPath(outline.paths[0], op, true)+ } else {+ const path = outlineToPath(r, outline)+ canvas.clipPath(path, op, true)+ path.delete()+ }+ })}export function getVectorPaths(r: SkiaRenderer, node: SceneNode): Path[] | null {@@ -274,3 +304,48 @@ export function getStrokeGeometry(r: SkiaRenderer, node: SceneNode): Path[] | nur.nodePaths.store(r.nodePaths.strokeGeometry, node.id, paths)return paths}++export function makeArcPath(r: SkiaRenderer, node: SceneNode) {+ const arc = node.arcData+ if (!arc) return null+ const cx = node.width / 2+ const cy = node.height / 2+ const rx = node.width / 2+ const ry = node.height / 2+ const innerRx = rx * arc.innerRadius+ const innerRy = ry * arc.innerRadius++ const startDeg = arc.startingAngle * (180 / Math.PI)+ const endDeg = arc.endingAngle * (180 / Math.PI)+ const sweepDeg = endDeg - startDeg++ const path = new r.ck.PathBuilder()+ const oval = r.ck.LTRBRect(0, 0, node.width, node.height)++ const isFullCircle = isWholeArc(arc)+ if (arc.innerRadius > 0) {+ const innerOval = r.ck.LTRBRect(cx - innerRx, cy - innerRy, cx + innerRx, cy + innerRy)+ if (isFullCircle) {+ // Two loops wound in opposite directions, so the hole stays empty under nonzero fill. A+ // full-turn `addArc` from an angle off the axes draws nothing.+ path.addOval(oval, false)+ path.addOval(innerOval, true)+ } else {+ // One outline whose ends run straight across the ring; `addArc` would start a new contour+ // for each edge and close them on their chords.+ path.arcToOval(oval, startDeg, sweepDeg, true)+ path.arcToOval(innerOval, startDeg + sweepDeg, -sweepDeg, false)+ }+ path.close()+ return path.detachAndDelete()+ }++ if (isFullCircle) {+ path.addOval(oval)+ } else {+ path.moveTo(cx, cy)+ path.arcToOval(oval, startDeg, sweepDeg, false)+ path.close()+ }+ return path.detachAndDelete()+}diff --git a/packages/core/src/canvas/strokes.ts b/packages/core/src/canvas/strokes.tsindex 9c430fcba..cd94fe3f7 100644--- a/packages/core/src/canvas/strokes.ts+++ b/packages/core/src/canvas/strokes.ts@@ -13,7 +13,12 @@ import type { Color, Vector } from '@open-pencil/scene-graph/primitives'import { applyGradientFill, applyImageFill } from './fills'import type { SkiaRenderer } from './renderer'-import { makeShapeWithTextDetailsPath, makeSmoothRRectPath, nodeHasSmoothCorners } from './shapes'+import {+ drawOutline,+ makeShapeWithTextDetailsPath,+ nodeHasSmoothCorners,+ withNodeOutline+} from './shapes'export function getStrokeCapEntity(r: SkiaRenderer, cap: string | undefined): EmbindEnumEntity {switch (cap) {@@ -313,72 +318,23 @@ export function drawStyledRRectStroke(r.strokePaint.setPathEffect(null)}-export function drawNodeStroke(- r: SkiaRenderer,- canvas: Canvas,- node: SceneNode,- rect: Float32Array,- hasRadius: boolean-): void {- switch (node.type) {- case 'VECTOR': {- const vps = r.getVectorPaths(node)- if (vps) {- for (const vp of vps) canvas.drawPath(vp, r.strokePaint)- }- break- }- case 'ELLIPSE': {- const fg = r.getFillGeometry(node)- if (fg) {- for (const p of fg) canvas.drawPath(p, r.strokePaint)- } else if (node.arcData) {- r.drawArc(canvas, node, r.strokePaint)- } else {- canvas.drawOval(rect, r.strokePaint)- }- break- }- case 'POLYGON':- case 'STAR': {- const path = r.makePolygonPath(node)- canvas.drawPath(path, r.strokePaint)- path.delete()- break- }- case 'SHAPE_WITH_TEXT': {- const path = r.makePolygonPath(node)- canvas.drawPath(path, r.strokePaint)- path.delete()- break- }- default:- if (nodeHasSmoothCorners(node)) {- const path = makeSmoothRRectPath(r, node)- canvas.drawPath(path, r.strokePaint)- path.delete()- } else if (hasRadius) {- canvas.drawRRect(r.makeRRect(node), r.strokePaint)- } else {- canvas.drawRect(rect, r.strokePaint)- }- }+/** Strokes a layer's outline, or a vector's own paths, open ones included. */+export function drawNodeStroke(r: SkiaRenderer, canvas: Canvas, node: SceneNode): void {+ strokeNodeShape(r, canvas, node, r.strokePaint)}export function drawStrokeWithAlign(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- rect: Float32Array,- hasRadius: boolean,align: 'INSIDE' | 'CENTER' | 'OUTSIDE'): void {if (align === 'INSIDE') {canvas.save()- r.clipNodeShape(canvas, node, rect, hasRadius)+ r.clipNodeShape(canvas, node)const origWidth = r.strokePaint.getStrokeWidth()r.strokePaint.setStrokeWidth(origWidth * 2)- r.drawNodeStroke(canvas, node, rect, hasRadius)+ r.drawNodeStroke(canvas, node)r.strokePaint.setStrokeWidth(origWidth)canvas.restore()} else if (align === 'OUTSIDE') {@@ -386,7 +342,7 @@ export function drawStrokeWithAlign(const bigRect = r.ck.LTRBRect(-node.width, -node.height, node.width * 2, node.height * 2)const outerPath = new r.ck.PathBuilder()outerPath.addRect(bigRect)- const innerPath = r.makeNodeShapePath(node, rect, hasRadius)+ const innerPath = r.makeNodeShapePath(node)const immutableOuterPath = outerPath.detachAndDelete()const clipPath = r.ck.Path.MakeFromOp(immutableOuterPath, innerPath, r.ck.PathOp.Difference)immutableOuterPath.delete()@@ -399,18 +355,18 @@ export function drawStrokeWithAlign(clipPath.delete()const origWidth = r.strokePaint.getStrokeWidth()r.strokePaint.setStrokeWidth(origWidth * 2)- r.drawNodeStroke(canvas, node, rect, hasRadius)+ r.drawNodeStroke(canvas, node)r.strokePaint.setStrokeWidth(origWidth)canvas.restore()} else {- r.drawNodeStroke(canvas, node, rect, hasRadius)+ r.drawNodeStroke(canvas, node)}// Inner lines, such as a database's front rim, lie inside the outline: they keep the stroke's// own weight whatever its alignment, and end where the outline does.const details = makeShapeWithTextDetailsPath(r, node)if (details) {canvas.save()- r.clipNodeShape(canvas, node, rect, hasRadius)+ r.clipNodeShape(canvas, node)canvas.drawPath(details, r.strokePaint)canvas.restore()details.delete()@@ -425,14 +381,7 @@ export function drawRRectStrokeWithAlign(stroke: Stroke): void {if (nodeHasSmoothCorners(node)) {- drawStrokeWithAlign(- r,- canvas,- node,- r.ck.LTRBRect(0, 0, node.width, node.height),- true,- stroke.align- )+ drawStrokeWithAlign(r, canvas, node, stroke.align)return}@@ -473,67 +422,18 @@ export function drawRRectStrokeWithAlign(}}+/** Strokes a layer's outline with `paint`: a vector's own paths, open ones included, and a line. */export function strokeNodeShape(r: SkiaRenderer,canvas: Canvas,node: SceneNode,paint: Paint): void {- const rect = r.ck.LTRBRect(0, 0, node.width, node.height)-- switch (node.type) {- case 'ELLIPSE':- canvas.drawOval(rect, paint)- return- case 'VECTOR': {- const vps = r.getVectorPaths(node)- if (vps) {- for (const vp of vps) canvas.drawPath(vp, paint)- }- return- }- case 'LINE':- canvas.drawLine(0, 0, node.width, node.height, paint)- return- case 'POLYGON':- case 'STAR':- case 'SHAPE_WITH_TEXT': {- const path = r.makePolygonPath(node)- canvas.drawPath(path, paint)- path.delete()- return- }- }-- const hasRadius =- node.cornerRadius > 0 ||- (node.independentCorners &&- (node.topLeftRadius > 0 ||- node.topRightRadius > 0 ||- node.bottomRightRadius > 0 ||- node.bottomLeftRadius > 0))-- if (hasRadius) {- if (node.independentCorners) {- const rrect = new Float32Array([- 0,- 0,- node.width,- node.height,- node.topLeftRadius,- node.topLeftRadius,- node.topRightRadius,- node.topRightRadius,- node.bottomRightRadius,- node.bottomRightRadius,- node.bottomLeftRadius,- node.bottomLeftRadius- ])- canvas.drawRRect(rrect, paint)- } else {- canvas.drawRRect(r.ck.RRectXY(rect, node.cornerRadius, node.cornerRadius), paint)- }+ if (node.type === 'VECTOR') {+ for (const path of r.getVectorPaths(node) ?? []) canvas.drawPath(path, paint)+ } else if (node.type === 'LINE') {+ canvas.drawLine(0, 0, node.width, node.height, paint)} else {- canvas.drawRect(rect, paint)+ withNodeOutline(r, node, (outline) => drawOutline(canvas, outline, paint))}}diff --git a/packages/core/tests/canvas/shadows.test.ts b/packages/core/tests/canvas/shadows.test.tsindex ccd2445f3..4ac2f9b8d 100644--- a/packages/core/tests/canvas/shadows.test.ts+++ b/packages/core/tests/canvas/shadows.test.ts@@ -127,6 +127,9 @@ const FIGMA: Record<string, number[]> = {128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 223, 209, 161, 104, 56,21, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ "star-drop-spread": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 159, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ "rounded-inner-spread": [0, 0, 0, 0, 32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255],+ "polygon-inner-spread": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 159, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],"separate-children-inner": [0, 0, 0, 0, 0, 1, 10, 43, 100, 164, 212, 237, 244, 245, 246, 247, 246, 247, 246, 247, 246,246, 246, 246, 246, 247, 246, 246, 247, 246, 246, 247, 246, 247, 246, 247, 246, 247, 246, 247,@@ -374,6 +377,63 @@ describe('arcs cast from the arc, not the whole ellipse', () => {})})+// Figma 126 grows or shrinks the shadow of a box or an ellipse by its spread, and ignores the spread+// of a star, polygon, or vector, drop or inner: their exports match the same shadow without one.+describe('only boxes and ellipses take a spread, as in Figma', () => {+ const sharp = { radius: 0, spread: 6 }++ test('a rounded rectangle shrinks the hole of its inner shadow by the spread (red channel)', () => {+ const values = row(+ (graph, hostId) =>+ graph.createNode('RECTANGLE', hostId, {+ ...square,+ fills: [RED],+ cornerRadius: 40,+ effects: [shadow('INNER_SHADOW', sharp)]+ }),+ 100,+ 130,+ 270,+ 0+ )+ expectFigmaRow(values, FIGMA['rounded-inner-spread'])+ })++ test('a star casts its drop shadow without the spread', () => {+ const values = row(+ (graph, hostId) =>+ graph.createNode('STAR', hostId, {+ ...square,+ fills: [RED],+ pointCount: 5,+ starInnerRadius: 0.4,+ effects: [shadow('DROP_SHADOW', sharp)]+ }),+ 170,+ 100,+ 330+ )+ expectFigmaRow(values, FIGMA['star-drop-spread'])+ })++ test('a polygon takes its inner shadow without the spread (red channel)', () => {+ const values = row(+ (graph, hostId) =>+ graph.createNode('POLYGON', hostId, {+ ...square,+ fills: [RED],+ pointCount: 3,+ effects: [shadow('INNER_SHADOW', sharp)]+ }),+ 160,+ 120,+ 280,+ 0+ )+ expectFigmaRow(values, FIGMA['polygon-inner-spread'])+ })+})+describe('inner shadows sit where Figma draws them', () => {test('a shape takes its inner shadow under its strokes (blue channel)', () => {const values = row(diff --git a/packages/core/tests/canvas/shapes.test.ts b/packages/core/tests/canvas/shapes.test.tsnew file mode 100644index 000000000..bdab343d5--- /dev/null+++ b/packages/core/tests/canvas/shapes.test.ts@@ -0,0 +1,70 @@+import { afterAll, describe, test } from 'bun:test'++import { SkiaRenderer } from '@open-pencil/core'+import { initCanvasKit } from '@open-pencil/core/io'+import type { SceneGraph, SceneNode, Stroke } from '@open-pencil/scene-graph'++import { expectDefined } from '#core-tests/helpers/assert'+import { expectFigmaRow, renderRow } from '#core-tests/helpers/figma-rows'++const ck = await initCanvasKit()+const renderer = new SkiaRenderer(ck, expectDefined(ck.MakeSurface(1, 1)))+afterAll(() => renderer.destroy())++/** Rows of alpha from Figma 126 exports of a 12 px blue stroke on the shapes below. */+const FIGMA = {+ starInside: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 191, 0, 0, 223, 255, 255, 255, 255, 255, 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ starOutside: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ polygonInside: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ polygonOutside: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255, 255, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ arcInside: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],+ arcOutside: [0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0]+}++/** A 160 px shape at (120, 70) without a fill, stroked 12 px blue with `align`. */+function stroked(type: SceneNode['type'], props: Partial<SceneNode>, align: Stroke['align']) {+ return (graph: SceneGraph, hostId: string) => {+ graph.createNode(type, hostId, {+ x: 120,+ y: 70,+ width: 160,+ height: 160,+ fills: [],+ strokeWeight: 12,+ strokes: [+ {+ type: 'SOLID',+ color: { r: 0, g: 0, b: 1, a: 1 },+ opacity: 1,+ visible: true,+ weight: 12,+ align+ }+ ],+ ...props+ })+ }+}++const STAR = { pointCount: 5, starInnerRadius: 0.4 }+const TRIANGLE = { pointCount: 3 }+const HALF_PIE = { arcData: { startingAngle: 0, endingAngle: Math.PI, innerRadius: 0 } }++// An inside stroke stays within the shape and an outside one around it, as Figma draws them; an+// inside stroke used to be clipped to the layer's box, so a star or polygon showed it both ways.+describe('a stroke inside or outside a shape follows its outline', () => {+ test('on a star', () => {+ expectFigmaRow(renderRow(ck, renderer, stroked('STAR', STAR, 'INSIDE'), 180, 100, 300), FIGMA.starInside)+ expectFigmaRow(renderRow(ck, renderer, stroked('STAR', STAR, 'OUTSIDE'), 180, 100, 300), FIGMA.starOutside)+ })++ test('on a polygon', () => {+ expectFigmaRow(renderRow(ck, renderer, stroked('POLYGON', TRIANGLE, 'INSIDE'), 150, 100, 300), FIGMA.polygonInside)+ expectFigmaRow(renderRow(ck, renderer, stroked('POLYGON', TRIANGLE, 'OUTSIDE'), 150, 100, 300), FIGMA.polygonOutside)+ })++ test('on an arc', () => {+ expectFigmaRow(renderRow(ck, renderer, stroked('ELLIPSE', HALF_PIE, 'INSIDE'), 145, 100, 300), FIGMA.arcInside)+ expectFigmaRow(renderRow(ck, renderer, stroked('ELLIPSE', HALF_PIE, 'OUTSIDE'), 145, 100, 300), FIGMA.arcOutside)+ })+})diff --git a/tests/engine/render/canvas/boolean.test.ts b/tests/engine/render/canvas/boolean.test.tsindex 8bdff8b67..a1e21715b 100644--- a/tests/engine/render/canvas/boolean.test.ts+++ b/tests/engine/render/canvas/boolean.test.ts@@ -16,8 +16,8 @@ async function createRenderer(): Promise<SkiaRenderer> {const ck = await initCanvasKit()const renderer = {ck,- makeNodeShapePath(node, rect, hasRadius) {- return makeNodeShapePath(asRenderer(this), node, rect, hasRadius)+ makeNodeShapePath(node) {+ return makeNodeShapePath(asRenderer(this), node)},makePolygonPath(node) {return makePolygonPath(asRenderer(this), node)@@ -27,6 +27,9 @@ async function createRenderer(): Promise<SkiaRenderer> {},getVectorPaths() {return null+ },+ getFillGeometry() {+ return null}} satisfies Partial<SkiaRenderer>return asRenderer(renderer)diff --git a/tests/engine/render/canvas/corner-smoothing.test.ts b/tests/engine/render/canvas/corner-smoothing.test.tsindex 65ab50b8a..da2ddd18f 100644--- a/tests/engine/render/canvas/corner-smoothing.test.ts+++ b/tests/engine/render/canvas/corner-smoothing.test.ts@@ -112,7 +112,7 @@ describe('canvas corner smoothing', () => {const { renderer } = createRenderer()const canvas = createCanvas()- drawNodeFill(renderer, asCanvas(canvas), node, new Float32Array([0, 0, 120, 80]), true)+ drawNodeFill(renderer, asCanvas(canvas), node)expect(canvas.drawPath).toHaveBeenCalled()expect(canvas.drawRRect).not.toHaveBeenCalled()diff --git a/tests/engine/render/canvas/effects/edge-cases.test.ts b/tests/engine/render/canvas/effects/edge-cases.test.tsindex 7e569e5ed..23c3d9820 100644--- a/tests/engine/render/canvas/effects/edge-cases.test.ts+++ b/tests/engine/render/canvas/effects/edge-cases.test.ts@@ -48,7 +48,7 @@ describe('Edge cases and bug fixes', () => {childIds: []})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(r.getCachedDropShadow).toHaveBeenCalled()expect(r.paintShapeContent).toHaveBeenCalledWith(@@ -85,7 +85,7 @@ describe('Edge cases and bug fixes', () => {childIds: []})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(canvas.drawRect).not.toHaveBeenCalled()expect(canvas.drawPath).not.toHaveBeenCalled()@@ -111,15 +111,7 @@ describe('Edge cases and bug fixes', () => {]})- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 100, 100]),- false,- 'inner'- )+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')// Expect LTRBRect for 'big' to encompass both the shape (0 to 100) and the offset hole (200 to 300)// with expand (20) padding: min(-20, -20+200) = -20, max(100+20, 100+20+200) = 320@@ -132,42 +124,6 @@ describe('Edge cases and bug fixes', () => {expect(canvas.drawPath).toHaveBeenCalled()})- test('INNER_SHADOW with spread on rounded rect shrinks hole concentrically', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- type: 'RECTANGLE',- width: 100,- height: 100,- cornerRadius: 10,- fills: [OPAQUE_FILL],- effects: [- {- type: 'INNER_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 1 },- offset: { x: 5, y: 5 },- radius: 10,- spread: 4- }- ]- })-- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 100, 100]),- true,- 'inner'- )-- // makeRRectWithOffset should receive (node, localOffsetX, localOffsetY, spread)- // localOffsetX = 5, localOffsetY = 5, spread = 4- expect(r.makeRRectWithOffset).toHaveBeenCalledWith(node, 5, 5, 4)- })-test('drop shadow restores canvas and paint state when drawing throws', () => {const r = createMockRenderer()const canvas = createMockCanvas()@@ -193,9 +149,9 @@ describe('Edge cases and bug fixes', () => {childIds: []})- expect(() =>- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')- ).toThrow('draw failed')+ expect(() => renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')).toThrow(+ 'draw failed'+ )expect(canvas.restore).toHaveBeenCalled()expect(r.auxFill.setMaskFilter).toHaveBeenCalledWith(null)@@ -225,9 +181,9 @@ describe('Edge cases and bug fixes', () => {]})- expect(() =>- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'inner')- ).toThrow('text failed')+ expect(() => renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')).toThrow(+ 'text failed'+ )expect(mockCalls(canvas.restore).length).toBe(1)expect(r.effectLayerPaint.setColorFilter).toHaveBeenCalledWith(null)diff --git a/tests/engine/render/canvas/effects/helpers.ts b/tests/engine/render/canvas/effects/helpers.tsindex 056e7ff56..31a1bc066 100644--- a/tests/engine/render/canvas/effects/helpers.ts+++ b/tests/engine/render/canvas/effects/helpers.ts@@ -159,7 +159,6 @@ export function createMockRenderer(overrides: Partial<SkiaRenderer> = {}): SkiaRgetVectorPaths: mock(() => null),makeRRect: mock(() => new Float32Array(12)),makeRRectWithSpread: mock(() => new Float32Array(12)),- makeRRectWithOffset: mock(() => new Float32Array(12)),makePolygonPath: mock(function (this: SkiaRenderer) {return new this.ck.Path()}),diff --git a/tests/engine/render/canvas/effects/inner-shadow.test.ts b/tests/engine/render/canvas/effects/inner-shadow.test.tsindex feb8facd7..4edacd4de 100644--- a/tests/engine/render/canvas/effects/inner-shadow.test.ts+++ b/tests/engine/render/canvas/effects/inner-shadow.test.ts@@ -33,7 +33,7 @@ describe('INNER_SHADOW bug proofs', () => {]})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'inner')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')// PROOF: ColorFilter.MakeBlend(black, SrcIn) on DstOut layer paint// forces the silhouette to solid black without mutating fillPaint.diff --git a/tests/engine/render/canvas/effects/ordering.test.ts b/tests/engine/render/canvas/effects/ordering.test.tsindex b1d3a84b5..966ffe75c 100644--- a/tests/engine/render/canvas/effects/ordering.test.ts+++ b/tests/engine/render/canvas/effects/ordering.test.ts@@ -33,7 +33,7 @@ describe('Renderer effect ordering (Behavioral)', () => {}const callOrder: string[] = []- r.renderEffects = mock((_c, _n, _g, _r, _h, pass) => {+ r.renderEffects = mock((_c, _n, _g, pass) => {callOrder.push(`renderEffects:${pass}`)})r.drawNodeFill = mock(() => {@@ -84,7 +84,7 @@ describe('Renderer effect ordering (Behavioral)', () => {}const callOrder: string[] = []- r.renderEffects = mock((_c, _n, _g, _r, _h, pass) => {+ r.renderEffects = mock((_c, _n, _g, pass) => {callOrder.push(`renderEffects:${pass}`)})r.drawStrokeWithAlign = mock(() => {diff --git a/tests/engine/render/canvas/effects/path-shapes.test.ts b/tests/engine/render/canvas/effects/path-shapes.test.tsdeleted file mode 100644index 15e040023..000000000--- a/tests/engine/render/canvas/effects/path-shapes.test.ts+++ /dev/null@@ -1,119 +0,0 @@-import { describe, expect, mock, test } from 'bun:test'--import { renderEffects } from '#core/canvas/shadows'--import { asCanvas } from '../helpers'-import {- createMockCanvas,- createMockRenderer,- effectNode,- mockCalls,- OPAQUE_FILL,- TEST_GRAPH-} from './helpers'--const requiredNodeFields = { childIds: [] as string[], strokeGeometry: [] }--describe('path shape shadows', () => {- test('drop shadow for a star without imported geometry uses the star path', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- ...requiredNodeFields,- type: 'STAR',- width: 100,- height: 100,- fills: [OPAQUE_FILL],- effects: [- {- type: 'DROP_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 1 },- offset: { x: 0, y: 0 },- radius: 10,- spread: 5- }- ]- })-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')-- expect(r.makePolygonPath).toHaveBeenCalled()- expect(canvas.drawPath).toHaveBeenCalled()- expect(canvas.drawRect).not.toHaveBeenCalled()- })-- test('drop shadow spread combines and deletes a detached stroked ring', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const cachedPath = new r.ck.Path()- const ringPath = new r.ck.Path()- const combinedPath = new r.ck.Path()- cachedPath.makeStroked = mock(() => ringPath)- r.ck.Path.MakeFromOp = mock(() => combinedPath)- r.getFillGeometry = mock(() => [cachedPath])-- const node = effectNode({- ...requiredNodeFields,- type: 'STAR',- width: 100,- height: 100,- fills: [{ visible: true, type: 'SOLID', color: { r: 1, g: 1, b: 1, a: 1 }, opacity: 1 }],- effects: [- {- type: 'DROP_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 1 },- offset: { x: 0, y: 0 },- radius: 10,- spread: 10- }- ]- })-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')-- const makeFromOp = r.ck.Path.MakeFromOp as ReturnType<typeof mock>- expect(makeFromOp).toHaveBeenCalledWith(cachedPath, ringPath, r.ck.PathOp.Union)- expect(ringPath.delete).toHaveBeenCalledTimes(1)- expect(combinedPath.delete).toHaveBeenCalledTimes(1)- expect(cachedPath.delete).not.toHaveBeenCalled()- })-- test('inner shadow for a polygon clips and cuts out with polygon paths', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- ...requiredNodeFields,- type: 'POLYGON',- width: 100,- height: 100,- fills: [OPAQUE_FILL],- effects: [- {- type: 'INNER_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 1 },- offset: { x: 5, y: 5 },- radius: 10,- spread: 3- }- ]- })-- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 100, 100]),- false,- 'inner'- )-- expect(mockCalls(r.makePolygonPath).length).toBeGreaterThanOrEqual(2)- expect(canvas.clipPath).toHaveBeenCalled()- expect(canvas.drawPath).toHaveBeenCalled()- expect(canvas.clipRect).not.toHaveBeenCalled()- })-})diff --git a/tests/engine/render/canvas/effects/spread.test.ts b/tests/engine/render/canvas/effects/spread.test.tsdeleted file mode 100644index 85f668de7..000000000--- a/tests/engine/render/canvas/effects/spread.test.ts+++ /dev/null@@ -1,99 +0,0 @@-import { describe, expect, test } from 'bun:test'--import { renderEffects } from '#core/canvas/shadows'--import { asCanvas } from '../helpers'-import {- createMockCanvas,- createMockRenderer,- effectNode,- OPAQUE_FILL,- TEST_GRAPH-} from './helpers'--describe('Shadow spread support (Behavioral)', () => {- test('drop shadow uses spread for shape expansion', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- type: 'RECTANGLE',- width: 100,- height: 100,- fills: [{ visible: true, type: 'SOLID', color: { r: 1, g: 0, b: 0, a: 1 }, opacity: 1 }],- effects: [- {- type: 'DROP_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 0.5 },- offset: { x: 5, y: 5 },- radius: 10,- spread: 4- }- ],- strokeGeometry: []- })- const rect = new Float32Array([0, 0, 100, 100])-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, false, 'behind')-- expect(canvas.drawRect).toHaveBeenCalled()- expect(r.ltrb).toHaveBeenCalledWith(-4, -4, 104, 104)- })-- test('drop shadow uses makeRRectWithSpread when node has radius', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- type: 'RECTANGLE',- width: 100,- height: 100,- cornerRadius: 8,- fills: [{ visible: true, type: 'SOLID', color: { r: 1, g: 0, b: 0, a: 1 }, opacity: 1 }],- effects: [- {- type: 'DROP_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 0.5 },- offset: { x: 5, y: 5 },- radius: 10,- spread: 4- }- ],- strokeGeometry: []- })- const rect = new Float32Array([0, 0, 100, 100])-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, true, 'behind')-- expect(r.makeRRectWithSpread).toHaveBeenCalledWith(node, 4)- expect(canvas.drawRRect).toHaveBeenCalled()- })-- test('inner shadow uses spread for cutout contraction', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- type: 'RECTANGLE',- width: 100,- height: 100,- fills: [OPAQUE_FILL],- childIds: [],- effects: [- {- type: 'INNER_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 0.5 },- offset: { x: 5, y: 5 },- radius: 10,- spread: 4- }- ]- })- const rect = new Float32Array([0, 0, 100, 100])-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, false, 'inner')-- expect(r.ck.LTRBRect).toHaveBeenCalledWith(9, 9, 101, 101)- expect(canvas.drawPath).toHaveBeenCalled()- })-})diff --git a/tests/engine/render/canvas/effects/text-shadow.test.ts b/tests/engine/render/canvas/effects/text-shadow.test.tsindex d9e94fcd2..e98ff4f88 100644--- a/tests/engine/render/canvas/effects/text-shadow.test.ts+++ b/tests/engine/render/canvas/effects/text-shadow.test.ts@@ -33,9 +33,8 @@ describe('Text shadows follow the glyphs, not the bounding box (Behavioral)', ()}]})- const rect = new Float32Array([0, 0, 100, 100])- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(r.getCachedDropShadow).toHaveBeenCalled()expect(canvas.saveLayer).toHaveBeenCalledWith(expect.anything(), expect.any(Float32Array))@@ -63,9 +62,8 @@ describe('Text shadows follow the glyphs, not the bounding box (Behavioral)', ()}]})- const rect = new Float32Array([0, 0, 100, 100])- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, false, 'inner')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')// 4-layer saveLayer stack: Master, SrcIn/Tint, Blur, DstOut/Punchexpect(canvas.saveLayer).toHaveBeenCalledTimes(4)@@ -103,9 +101,8 @@ describe('Text shadows follow the glyphs, not the bounding box (Behavioral)', ()}]})- const rect = new Float32Array([0, 0, 100, 100])- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, rect, false, 'inner')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')const calls = mockCalls(r.effectLayerPaint.setColorFilter)// The final call must be null (exit guard cleans up)diff --git a/tests/engine/render/canvas/effects/types.test.ts b/tests/engine/render/canvas/effects/types.test.tsindex 5ba96ab4e..776e998be 100644--- a/tests/engine/render/canvas/effects/types.test.ts+++ b/tests/engine/render/canvas/effects/types.test.ts@@ -41,44 +41,10 @@ describe('Renderer handles all effect types (Behavioral)', () => {}]})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(canvas.drawRect).toHaveBeenCalled()})- test('a stroke without a fill casts a ring and clips its shape out of the shadow', () => {- const r = createMockRenderer()- const canvas = createMockCanvas()- const node = effectNode({- type: 'RECTANGLE',- width: 100,- height: 100,- fills: [],- strokes: [{ ...OPAQUE_FILL, opacity: 0.5, weight: 4, align: 'CENTER' }],- effects: [- {- type: 'DROP_SHADOW',- visible: true,- color: { r: 0, g: 0, b: 0, a: 0.5 },- offset: { x: 0, y: 3 },- radius: 3,- spread: 0,- showShadowBehindNode: false- }- ]- })-- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')-- expect(r.ltrb).toHaveBeenCalledWith(-2, -2, 102, 102)- expect(r.ltrb).toHaveBeenCalledWith(2, 2, 98, 98)- const [ring] = mockCalls(canvas.drawPath).find(([, paint]) => paint === r.auxFill) ?? []- if (typeof ring !== 'object' || ring === null) throw new Error('expected the ring path')- expect(mockCalls(Reflect.get(ring, 'setFillType'))).toContainEqual([r.ck.FillType.EvenOdd])- expect(canvas.clipPath).toHaveBeenCalledWith(expect.anything(), r.ck.ClipOp.Difference, true)- expect(canvas.drawPath).toHaveBeenCalledWith(expect.anything(), r.auxFill)- expect(r.paintShapeContent).not.toHaveBeenCalled()- })-test('applies effect blend modes to rendered shadow paint', () => {const r = createMockRenderer()const canvas = createMockCanvas()@@ -102,7 +68,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {]})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(r.auxFill.setBlendMode).toHaveBeenCalledWith(r.ck.BlendMode.Screen)expect(r.auxFill.setBlendMode).toHaveBeenLastCalledWith(r.ck.BlendMode.SrcOver)@@ -128,15 +94,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {}]})- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 100, 100]),- false,- 'inner'- )+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'inner')expect(canvas.drawPath).toHaveBeenCalled()})@@ -180,15 +138,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {}})- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 20, 20]),- false,- 'front'- )+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'front')expect(r.clipNodeShape).toHaveBeenCalled()expect(canvas.drawRect).toHaveBeenCalled()@@ -233,15 +183,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {}})- renderEffects(- r,- asCanvas(canvas),- node,- TEST_GRAPH,- new Float32Array([0, 0, 1000, 1000]),- false,- 'front'- )+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'front')expect(mockCalls(canvas.drawRect).length).toBeLessThanOrEqual(12_000)})@@ -264,7 +206,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {}]})- renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, new Float32Array(4), false, 'behind')+ renderEffects(r, asCanvas(canvas), node, TEST_GRAPH, 'behind')expect(r.applyClippedBlur).toHaveBeenCalled()})@@ -285,7 +227,7 @@ describe('Renderer handles all effect types (Behavioral)', () => {effects: []})- applyClippedBlur(r, asCanvas(canvas), node, rect, false, 5)+ applyClippedBlur(r, asCanvas(canvas), node, 5)expect(r.effectLayerPaint.setImageFilter).toHaveBeenCalledWith(null)expect(canvas.saveLayer).toHaveBeenCalledWith(diff --git a/tools/checks/test-homes/engine-baseline.txt b/tools/checks/test-homes/engine-baseline.txtindex 41c7ede56..29a2cd3c2 100644--- a/tools/checks/test-homes/engine-baseline.txt+++ b/tools/checks/test-homes/engine-baseline.txt@@ -355,8 +355,6 @@ tests/engine/render/canvas/effect-raster-integration.test.tstests/engine/render/canvas/effects/edge-cases.test.tstests/engine/render/canvas/effects/inner-shadow.test.tstests/engine/render/canvas/effects/ordering.test.ts-tests/engine/render/canvas/effects/path-shapes.test.ts-tests/engine/render/canvas/effects/spread.test.tstests/engine/render/canvas/effects/text-shadow.test.tstests/engine/render/canvas/effects/types.test.tstests/engine/render/canvas/font-readiness.test.ts