@pixerate/editor 0.107.0 → 0.109.0

package/dist/{compositor-Kt_M4ruo.d.ts → render-OLIMk_v0.d.ts}

@@ -832,4 +832,138 @@ declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S ex
 /** Tiles that differ between two surfaces (by tile identity), as tile keys. */
 declare function changedTiles(a: TiledSurface, b: TiledSurface): TileKey[];
 
-export { TransformTooLargeError as $, type GradientColorStop as A, type BevelContour as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectPattern as E, type GradientOpacityStop as F, type GroupBlendMode as G, type GradientOverlayEffect as H, type Interpolation as I, type GradientStyle as J, INTERPOLATIONS as K, type LayerLocks as L, type InnerGlowEffect as M, type InnerShadowEffect as N, LAYER_EFFECT_KINDS as O, LayerEffectError as P, MAX_EFFECT_REACH as Q, type RasterLayer as R, MAX_TRANSFORM_PIXELS as S, type OuterGlowEffect as T, type PatternOverlayEffect as U, PatternPlacement as V, PatternTile as W, type ResampleOptions as X, type SatinEffect as Y, type StrokeEffect as Z, type StrokePosition as _, type RasterGroupLayer as a, blendTile as a0, builtinPattern as a1, builtinPatternIds as a2, changedTiles as a3, compositeSurfaceOver as a4, defaultEffectGradient as a5, defaultLayerEffect as a6, effectColorHex as a7, effectReach as a8, effectsFingerprint as a9, type CompositorProfile as aA, type GroupIn as aB, type PixelFilterSpec as aC, type RasterNode as aD, effectsMargin as aa, effectsScale as ab, findLayer as ac, flattenLayers as ad, hasActiveEffects as ae, hashNoise as af, insertLayer as ag, isInterpolation as ah, isLayerEffectKind as ai, isLayerLocked as aj, keysWeight as ak, layerEffectFields as al, layerEffectLabel as am, mapLayer as an, mergeLayerEffect as ao, newEffectId as ap, normalizeLayerEffects as aq, parseEffectColor as ar, reduceSurface as as, scaleLayerEffect as at, transformSurface as au, transformedBounds as av, validateEffectGradient as aw, validateLayerEffect as ax, validateLayerEffects as ay, warpSurface as az, type RasterPixelLayer as b, RasterCompositor as c, type RasterSources as d, type RasterLayerBase as e, type RasterMask as f, type GlobalLight as g, type LayerLocation as h, type LayerEffect as i, type LayerEffects as j, type CompositorOptions as k, type LayerEffectKind as l, type BevelEmbossEffect as m, type BevelStyle as n, type BevelTechnique as o, type BevelTexture as p, type ColorOverlayEffect as q, type CompositeCallOptions as r, type CompositeStats as s, type ContourPoint as t, type DropShadowEffect as u, type EffectContour as v, type EffectFill as w, type EffectGradient as x, type EffectPatternRef as y, type GlowTechnique as z };
+/**
+ * CPU renderer for layer effects.
+ *
+ * Render order, bottom to top (Photoshop's layer-style stack read upwards): drop shadows, outer
+ * glows, then the layer itself (content at fill opacity) with pattern, gradient and colour
+ * overlays, satin, inner glows, inner shadows, the inside part of strokes and inner bevels on
+ * top. The outside part of strokes and outer bevels go beneath the layer, onto the backdrop.
+ * Exterior effects blend straight into the backdrop with their own modes; the layer blends with
+ * its mode and, in a mode other than Normal, is merged into the backdrop before the interior
+ * effects paint over it (Photoshop's "Blend Interior Effects as Group" off). Emboss and pillow
+ * emboss then shade the composited result. Layer opacity applies to the whole stack; fill
+ * opacity only to the layer's own pixels.
+ *
+ * Every map depends only on the layer's shape (its alpha after the mask), the effect settings
+ * and the global light, never on the backdrop. {@link buildEffectMaps} computes them once over the
+ * layer's whole region; {@link compositeLayerEffects} paints any part of that region (a tile) from
+ * them, pixel by pixel, so a tiled render equals a whole-image render.
+ *
+ * Distances: a stroke's outer edge uses the 5 × 5 chamfer below 20 px and an exact Euclidean
+ * transform from there (the chamfer's octagonal level sets facet wide strokes); inside strokes and
+ * spread / choke keep the chamfer; precise glows and chiselled bevels use the exact transform.
+ * Soft falloffs are two box blurs (a tent).
+ */
+
+interface EffectRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Outside stroke width from which the outer edge uses the exact Euclidean transform. */
+declare const STROKE_CHAMFER_MAX = 20;
+/** A contour as a 0..1 LUT (corner points split the spline), or `null` for linear. */
+declare function contourLut(c: EffectContour | undefined): Float32Array | null;
+/** Where a bevel paints: inside the shape, outside it, or both (emboss styles). */
+type BevelPaint = 'inner' | 'outer' | 'both';
+interface EffectContext {
+    light: GlobalLight;
+    /** A pattern tile by id, or `null` when missing (pattern effects then paint nothing). */
+    pattern(id: string): PatternTile | null;
+}
+/** Effect maps of one layer over its region: see {@link buildEffectMaps}. */
+interface EffectMaps {
+    /** The region the maps cover (document space). */
+    rect: EffectRect;
+    /** The enabled effects, Scale Effects applied, in list order. */
+    items: LayerEffect[];
+    /** Pixel bounds of the shape (alpha above half a step), or `null` when the shape is empty. */
+    bounds: EffectRect | null;
+    shape: Float32Array;
+    /** Per item: the maps it paints through. */
+    per: Float32Array[][];
+    bevelPaint: (BevelPaint | null)[];
+    din: Float32Array | null;
+    dout: Float32Array | null;
+    doutExact: Float32Array | null;
+    /** Frames of gradient strokes by item index. */
+    frames: Map<number, EffectRect>;
+    /** Approximate size in bytes (cache budgeting). */
+    bytes: number;
+}
+/** The enabled effects of `effects` with Scale Effects applied (empty when the master switch is off). */
+declare function activeEffectItems(effects: LayerEffects | undefined | null): LayerEffect[];
+/**
+ * Whether every map pixel of `items` depends only on the shape within the effects' margin, so a
+ * tile is unchanged while the layer is unchanged within its margin. Not local: anything laid out
+ * over the layer's bounds (aligned gradient overlays, gradient strokes, linked patterns) and noise
+ * (it speckles any coverage above zero, which picks up the blur's float noise from far away).
+ */
+declare function effectsAreLocal(items: readonly LayerEffect[]): boolean;
+/**
+ * Builds every map `items` paints through from the layer's alpha `shape` (0..1) over `rect`.
+ * `rect` should cover the layer's shape plus the effects' margin.
+ */
+declare function buildEffectMaps(items: LayerEffect[], shape: Float32Array, rect: EffectRect, ctx: EffectContext): EffectMaps;
+/**
+ * `prev` brought up to date for a shape over `rect` that differs from the one it was built from only
+ * inside `changed` (document rects), or `null` when a full {@link buildEffectMaps} is the better
+ * deal (the change covers much of the region) or the effects are not local
+ * ({@link effectsAreLocal}). `items` must be the ones `prev` was built with, reaching at most
+ * `margin` px, and `shapeOver(r)` returns the new shape over `r`.
+ *
+ * Every map pixel within `margin` of a change, or outside `prev.rect`, is rebuilt from the shape
+ * within `margin` of it (a window of the change grown by twice the margin) and pasted in; the rest
+ * is kept. A local map pixel depends only on the shape within the margin and the blur sums exactly,
+ * so the result paints exactly what a full build over `rect` would. `prev`'s buffers are reused
+ * when `rect` is unchanged.
+ */
+declare function patchEffectMaps(prev: EffectMaps, items: LayerEffect[], rect: EffectRect, changed: readonly EffectRect[], margin: number, shapeOver: (r: EffectRect) => Float32Array, ctx: EffectContext): EffectMaps | null;
+/** Gradient parameter `t` (0..1) at pixel centre `(x, y)` of a gradient laid out in `frame`. */
+declare function gradientT(style: GradientStyle, angle: number, scale: number, reverse: boolean, offset: {
+    x: number;
+    y: number;
+}, frame: EffectRect, x: number, y: number): number;
+/**
+ * The colours an effect fill paints over `rect`, as straight float RGBA (0..1, `width × height`
+ * pixels, row by row): a solid colour, a gradient laid out in `frame` (when aligned with the layer)
+ * or `canvas`, or a pattern tiled from `anchor` (when linked). Shape layers paint with it, so their
+ * fills and strokes match the overlays of layer effects.
+ */
+declare function effectFillColors(fill: EffectFill, rect: EffectRect, frame: EffectRect, canvas: EffectRect, anchor: {
+    x: number;
+    y: number;
+}, ctx: EffectContext): Float32Array;
+interface EffectCompositeInput {
+    /** The accumulator (straight RGBA over `rect`); receives the layer and its effects. */
+    backdrop: Uint8ClampedArray;
+    /** The layer's pixels over `rect` (straight RGBA, mask applied to alpha, clipped layers applied). */
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    maps: EffectMaps;
+    blend: BlendMode;
+    /** Layer opacity: the whole stack. */
+    opacity: number;
+    /** Fill opacity: the layer's own pixels only. */
+    fillOpacity: number;
+    /** The canvas (unaligned gradients span it). */
+    canvas: EffectRect;
+    ctx: EffectContext;
+}
+/** Composites a layer's content and its effects onto `backdrop` in place (see the module comment for the order). */
+declare function compositeLayerEffects(input: EffectCompositeInput): void;
+/**
+ * Renders one layer with its effects over a whole region in one pass (no tiles): the reference
+ * the per-tile compositor is checked against, and a convenience for one-off renders.
+ */
+declare function renderLayerEffects(effects: LayerEffects, layer: {
+    content: Uint8ClampedArray;
+    rect: EffectRect;
+    blend: BlendMode;
+    opacity: number;
+    fillOpacity?: number;
+}, backdrop: Uint8ClampedArray, canvas: EffectRect, ctx: EffectContext): void;
+
+export { type StrokeEffect as $, type EffectRect as A, type BevelContour as B, type CompositorLayer as C, DEFAULT_GLOBAL_LIGHT as D, type EffectFill as E, type GlowTechnique as F, type GroupBlendMode as G, type GradientColorStop as H, type Interpolation as I, type GradientOpacityStop as J, type GradientOverlayEffect as K, type LayerLocks as L, type GradientStyle as M, INTERPOLATIONS as N, type InnerGlowEffect as O, type InnerShadowEffect as P, LAYER_EFFECT_KINDS as Q, type RasterLayer as R, LayerEffectError as S, MAX_EFFECT_REACH as T, MAX_TRANSFORM_PIXELS as U, type OuterGlowEffect as V, type PatternOverlayEffect as W, PatternPlacement as X, PatternTile as Y, type ResampleOptions as Z, type SatinEffect as _, type RasterGroupLayer as a, type StrokePosition as a0, TransformTooLargeError as a1, blendTile as a2, builtinPattern as a3, builtinPatternIds as a4, changedTiles as a5, compositeSurfaceOver as a6, defaultEffectGradient as a7, defaultLayerEffect as a8, effectColorHex as a9, validateLayerEffect as aA, validateLayerEffects as aB, warpSurface as aC, type CompositorProfile as aD, type EffectCompositeInput as aE, type EffectMaps as aF, type GroupIn as aG, type PixelFilterSpec as aH, type RasterNode as aI, STROKE_CHAMFER_MAX as aJ, activeEffectItems as aK, buildEffectMaps as aL, compositeLayerEffects as aM, contourLut as aN, effectFillColors as aO, effectsAreLocal as aP, gradientT as aQ, patchEffectMaps as aR, effectReach as aa, effectsFingerprint as ab, effectsMargin as ac, effectsScale as ad, findLayer as ae, flattenLayers as af, hasActiveEffects as ag, hashNoise as ah, insertLayer as ai, isInterpolation as aj, isLayerEffectKind as ak, isLayerLocked as al, keysWeight as am, layerEffectFields as an, layerEffectLabel as ao, mapLayer as ap, mergeLayerEffect as aq, newEffectId as ar, normalizeLayerEffects as as, parseEffectColor as at, reduceSurface as au, renderLayerEffects as av, scaleLayerEffect as aw, transformSurface as ax, transformedBounds as ay, validateEffectGradient as az, type RasterPixelLayer as b, RasterCompositor as c, type RasterSources as d, type RasterLayerBase as e, type RasterMask as f, type GlobalLight as g, type EffectPattern as h, type LayerLocation as i, type LayerEffect as j, type LayerEffects as k, type CompositorOptions as l, type LayerEffectKind as m, type EffectContext as n, type BevelEmbossEffect as o, type BevelStyle as p, type BevelTechnique as q, type BevelTexture as r, type ColorOverlayEffect as s, type CompositeCallOptions as t, type CompositeStats as u, type ContourPoint as v, type DropShadowEffect as w, type EffectContour as x, type EffectGradient as y, type EffectPatternRef as z };