Skip to content

AI-native design editor. Open-source Figma alternative.

6.0 KB
Raw Blame
import type { Canvas, ImageFilter, MaskFilter, Path } from 'canvaskit-wasm'

import { readEffectiveFigmaRawField } from '@open-pencil/fig'
import type { SceneNode } from '@open-pencil/scene-graph'
import type { Color, Vector } from '@open-pencil/scene-graph/primitives'

import { ResourceCache } from '#core/cache/resource'
import { BLACK } from '#core/constants'

import type { SkiaRenderer } from './renderer'

/**
 * Filters a renderer keeps between frames, by their parameters: shadows and blurs reuse one across
 * every node and frame that shares them. Bounded, so a slider dragged through hundreds of values
 * frees the ones it passed rather than keeping them for the session.
 */
const MAX_CACHED_FILTERS = 256

export type ImageFilterCache = ResourceCache<string, ImageFilter>
export type MaskFilterCache = ResourceCache<number, MaskFilter>

export function createImageFilterCache(): ImageFilterCache {
  return new ResourceCache({ maxEntries: MAX_CACHED_FILTERS, dispose: (filter) => filter.delete() })
}

export function createMaskFilterCache(): MaskFilterCache {
  return new ResourceCache({ maxEntries: MAX_CACHED_FILTERS, dispose: (filter) => filter.delete() })
}

export function getCachedDropShadow(
  r: SkiaRenderer,
  dx: number,
  dy: number,
  sigma: number,
  color: Float32Array
): ImageFilter | null {
  const key = `ds:${dx},${dy},${sigma},${color[0]},${color[1]},${color[2]},${color[3]}`
  return cachedImageFilter(r, key, () =>
    r.ck.ImageFilter.MakeDropShadowOnly(dx, dy, sigma, sigma, color, null)
  )
}

export function getCachedBlur(r: SkiaRenderer, sigma: number): ImageFilter | null {
  return cachedImageFilter(r, `blur:${sigma}`, () =>
    r.ck.ImageFilter.MakeBlur(sigma, sigma, r.ck.TileMode.Clamp, null)
  )
}

export function getCachedDecalBlur(r: SkiaRenderer, sigma: number): ImageFilter | null {
  return cachedImageFilter(r, `dblur:${sigma}`, () =>
    r.ck.ImageFilter.MakeBlur(sigma, sigma, r.ck.TileMode.Decal, null)
  )
}

/** CanvasKit makes no filter for a blur too small to draw; a paint takes null as none. */
export function getCachedMaskBlur(r: SkiaRenderer, sigma: number): MaskFilter | null {
  const cached = r.maskFilterCache.get(sigma)
  if (cached) return cached
  // Typed as always made; at runtime a sigma too small to blur makes none.
  const filter = r.ck.MaskFilter.MakeBlur(r.ck.BlurStyle.Normal, sigma, true) as MaskFilter | null
  if (filter) r.maskFilterCache.set(sigma, filter)
  return filter
}

function cachedImageFilter(
  r: SkiaRenderer,
  key: string,
  make: () => ImageFilter | null
): ImageFilter | null {
  const cached = r.imageFilterCache.get(key)
  if (cached) return cached
  const filter = make()
  if (filter) r.imageFilterCache.set(key, filter)
  return filter
}

/**
 * Blurs what lies behind the layer, inside its outline, or inside `shape` when the layer's outline
 * is not its box, as with a boolean's result.
 */
export function applyClippedBlur(
  r: SkiaRenderer,
  canvas: Canvas,
  node: SceneNode,
  sigma: number,
  shape: Path | null = null
): 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()
  if (shape) canvas.clipPath(shape, r.ck.ClipOp.Intersect, true)
  else 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
  r.effectLayerPaint.setImageFilter(null)
  r.effectLayerPaint.setColorFilter(null)
  r.effectLayerPaint.setBlendMode(r.ck.BlendMode.SrcOver)
  canvas.restore()
}

const MAX_RAW_NOISE_CELLS = 12_000

interface RawNoiseEffect {
  type: 'NOISE'
  visible?: boolean
  color?: Color
  secondaryColor?: Color
  opacity?: number
  density?: number
  noiseSize?: Vector
  noiseType?: 'MONOTONE' | 'DUOTONE' | 'MULTITONE'
}

function rawNoiseEffects(node: SceneNode): RawNoiseEffect[] {
  const source = (node as Partial<SceneNode>).source
  const effects = source ? readEffectiveFigmaRawField(node, 'effects') : undefined
  if (!Array.isArray(effects)) return []
  return effects.filter(
    (effect): effect is RawNoiseEffect =>
      effect !== null &&
      typeof effect === 'object' &&
      'type' in effect &&
      effect.type === 'NOISE' &&
      ('visible' in effect ? effect.visible !== false : true)
  )
}

function seededNoise(seed: number): number {
  const x = Math.sin(seed * 12.9898) * 43758.5453
  return x - Math.floor(x)
}

function renderNoiseEffect(
  r: SkiaRenderer,
  canvas: Canvas,
  node: SceneNode,
  effect: RawNoiseEffect
): void {
  const density = Math.max(0, Math.min(1, effect.density ?? 0.3))
  const requestedStep = Math.max(2, Math.round((effect.noiseSize?.x ?? 0.5) * 8))
  const boundedStep = Math.ceil(Math.sqrt((node.width * node.height) / MAX_RAW_NOISE_CELLS))
  const step = Math.max(requestedStep, boundedStep)
  const color = effect.color ?? BLACK
  const opacity = effect.opacity ?? color.a
  const paint = new r.ck.Paint()
  try {
    paint.setAntiAlias(false)
    canvas.save()
    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)
        if (value > density) continue
        const alpha = Math.max(0, Math.min(1, opacity * (0.35 + value * 0.65)))
        paint.setColorComponents(color.r, color.g, color.b, alpha)
        canvas.drawRect(
          r.ck.LTRBRect(x, y, Math.min(node.width, x + 1), Math.min(node.height, y + 1)),
          paint
        )
      }
    }
    canvas.restore()
  } finally {
    paint.delete()
  }
}

/** 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): void {
  for (const effect of rawNoiseEffects(node)) {
    renderNoiseEffect(r, canvas, node, effect)
  }
}