Skip to content

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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.ts
index 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): bo
function 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.ts
index 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 state
r.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.ts
index 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 > 0
for (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.ts
index 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
) => void
declare 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) => void
declare applyFill: (fill: Fill, node: SceneNode, graph: SceneGraph, fillIndex?: number) => boolean
declare applyGradientFill: (fill: Fill, node: SceneNode, graph: SceneGraph) => boolean
declare 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) => void
declare drawStrokeWithAlign: (
canvas: Canvas,
node: SceneNode,
- rect: Float32Array,
- hasRadius: boolean,
align: 'INSIDE' | 'CENTER' | 'OUTSIDE'
) => void
declare drawRRectStrokeWithAlign: (
@@ -409,22 +393,11 @@ export class SkiaRenderer {
) => void
declare drawIndividualSideStrokes: (canvas: Canvas, node: SceneNode, stroke: Stroke) => void
declare strokeNodeShape: (canvas: Canvas, node: SceneNode, paint: Paint) => void
- declare makeNodeShapePath: (node: SceneNode, rect: Float32Array, hasRadius: boolean) => Path
+ declare makeNodeShapePath: (node: SceneNode) => Path
declare makePolygonPath: (node: SceneNode) => Path
declare makeRRect: (node: SceneNode) => Float32Array
declare 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) => void
declare getVectorPaths: (node: SceneNode) => Path[] | null
declare getFillGeometry: (node: SceneNode) => Path[] | null
declare getStrokeGeometry: (node: SceneNode) => Path[] | null
@@ -437,13 +410,7 @@ export class SkiaRenderer {
declare getCachedBlur: (sigma: number) => ImageFilter
declare getCachedDecalBlur: (sigma: number) => ImageFilter
declare 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) => void
color4f(r: number, g: number, b: number, a: number): Float32Array {
const c = this._tmpColor
c[0] = r
diff --git a/packages/core/src/canvas/renderer/chunks/record.ts b/packages/core/src/canvas/renderer/chunks/record.ts
index 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.ts
index 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.ts
index 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) : null
const vectorPaths = node.type === 'VECTOR' ? r.getVectorPaths(node) : null
const 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.ts
index 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 0
if (!isLayerContainer(node)) return effect.spread
return 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) return
const 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.ts
index 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] + spread
if (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 = spread
r.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.offset
const 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.ts
index 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.ts
index 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 + spread
const width = right - left
const height = bottom - top
if (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)
- break
case '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[] | nu
r.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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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> = {}): SkiaR
getVectorPaths: 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.ts
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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/Punch
expect(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.ts
index 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.txt
index 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.ts
tests/engine/render/canvas/effects/edge-cases.test.ts
tests/engine/render/canvas/effects/inner-shadow.test.ts
tests/engine/render/canvas/effects/ordering.test.ts
-tests/engine/render/canvas/effects/path-shapes.test.ts
-tests/engine/render/canvas/effects/spread.test.ts
tests/engine/render/canvas/effects/text-shadow.test.ts
tests/engine/render/canvas/effects/types.test.ts
tests/engine/render/canvas/font-readiness.test.ts