shaders 3.1.463 → 3.2.464

package/dist/core/gpu/kit/blur.d.ts

@@ -484,5 +484,460 @@ export declare function composeBlurredOverSharp(params: GpuFragmentParams, compo
     blurredKey?: string;
     sharpKey?: string;
 }): Expr;
+/**
+ * Blur intensity (UI 0–200) → Gaussian pixel radius. The separable Gaussian derives its per-pass
+ * sigma from this radius (sigmaH = radius × 0.5). The factor is `intensity × 0.36` — shared by
+ * Blur, ProgressiveBlur, and TiltShift (their intensity props are all 0–100/0–200 UI scales over
+ * the same pixel-radius mapping).
+ */
+export declare const INTENSITY_TO_RADIUS = 0.36;
+export declare const intensityToRadius: (intensity: number) => number;
+/**
+ * ChannelBlur's per-channel UI intensity (0–100) → Gaussian pixel radius via the `× 0.1` factor. A
+ * single fixed Gaussian runs at the MAX per-channel radius; the fragment then mixes each channel
+ * between the sharp source and that one blurred buffer by `channelRadius / maxRadius` (an
+ * approximation that avoids 6 dispatches / 6 storage textures).
+ */
+export declare const CHANNEL_INTENSITY_TO_RADIUS = 0.1;
+export declare const channelIntensityToRadius: (intensity: number) => number;
+/**
+ * Blur's map-driven fill graph: per compute pixel, sample the map-source RTT at the corresponding
+ * canvas pixel, extract the driving scalar from a channel, run the SAME remap `resolveMapForProp`
+ * uses in the fragment path, scale to a pixel radius (× 0.36), and write it into the variable
+ * blur's radius map. GPU-free (resolvable without a device). `channel` is a build-time constant —
+ * the channel branch is comptime-folded, so each channel emits its own specialised WGSL.
+ */
+export declare function buildFillBlurMapGraph(computeWidth: number, computeHeight: number, channel: BlurMapChannel): {
+    layout: TgpuBindGroupLayout<{
+        source: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputMin: d.F32;
+                inputMax: d.F32;
+                outputMin: d.F32;
+                outputMax: d.F32;
+                curve: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputMin: d.F32;
+        inputMax: d.F32;
+        outputMin: d.F32;
+        outputMax: d.F32;
+        curve: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+    }>;
+};
+/**
+ * ChannelBlur's fragment composite: per-channel `mix(sharp, blurred, channelRadius / maxRadius)`.
+ * The blur ran at `maxRadius = max(r, g, b, 0.01)`, so the max-intensity channel takes the full
+ * blur, a zero channel stays exactly sharp, and intermediate channels linearly interpolate. Alpha
+ * comes from the sharp child.
+ */
+export declare const channelBlurCompose: TgpuFn<(sharp: d.Vec4f, blurred: d.Vec4f, redIntensity: d.F32, greenIntensity: d.F32, blueIntensity: d.F32) => d.Vec4f>;
+/**
+ * ProgressiveBlur's directional blur amount at a UV: project the vector from the center onto the
+ * (aspect-corrected) blur direction, clamp to the forward half-plane, and ramp it over `falloff`.
+ * `center` is the TRANSFORMED position (transformPosition stores `(x, 1 - y)`), so `1.0 - centerY`
+ * recovers the authored y. Pure float; used by the fill kernel to build the per-pixel radius map.
+ */
+export declare const progressiveBlurAmount: TgpuFn<(angleDeg: d.F32, centerX: d.F32, centerY: d.F32, falloff: d.F32, uv: d.Vec2f, aspect: d.F32) => d.F32>;
+/**
+ * ProgressiveBlur's fill graph: the kernel writes `blurAmount × maxRadius` (input pixels) into the
+ * variable blur's radius map. GPU-free.
+ */
+export declare function buildProgressiveBlurFillGraph(computeWidth: number, computeHeight: number): {
+    layout: TgpuBindGroupLayout<{
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                angle: d.F32;
+                centerX: d.F32;
+                centerY: d.F32;
+                falloff: d.F32;
+                aspect: d.F32;
+                maxRadius: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        angle: d.F32;
+        centerX: d.F32;
+        centerY: d.F32;
+        falloff: d.F32;
+        aspect: d.F32;
+        maxRadius: d.F32;
+    }>;
+};
+/**
+ * ProgressiveBlur's MAP-DRIVEN fill graph. The per-pixel max radius is sampled from the map SOURCE
+ * (canvas-resolution RTT), remapped through the same window `resolveMapForProp` uses in the
+ * fragment path, scaled `× 0.36`, then multiplied by the directional blur amount. Bind-group adds
+ * the `source` texture (bound late — its RTT is allocated after composition).
+ */
+export declare function buildProgressiveBlurFillMapGraph(computeWidth: number, computeHeight: number, channel: BlurMapChannel): {
+    layout: TgpuBindGroupLayout<{
+        source: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputMin: d.F32;
+                inputMax: d.F32;
+                outputMin: d.F32;
+                outputMax: d.F32;
+                curve: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                angle: d.F32;
+                centerX: d.F32;
+                centerY: d.F32;
+                falloff: d.F32;
+                aspect: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputMin: d.F32;
+        inputMax: d.F32;
+        outputMin: d.F32;
+        outputMax: d.F32;
+        curve: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        angle: d.F32;
+        centerX: d.F32;
+        centerY: d.F32;
+        falloff: d.F32;
+        aspect: d.F32;
+    }>;
+};
+/**
+ * TiltShift's blur amount at a UV: perpendicular distance from the (aspect-corrected) focus line,
+ * ramped from the sharp band (`focusWidth = width × 0.5`) out over `falloff`. `center` is the
+ * TRANSFORMED position (transformPosition stores `(x, 1 - y)`), so `1.0 - center.y` recovers the
+ * authored y. Pure float. Shared by BOTH the fill kernel (to build the per-pixel radius map) AND
+ * the fragment (to keep in-focus pixels crisp), so the two can never drift.
+ */
+export declare const tiltShiftBlurAmount: TgpuFn<(angleDeg: d.F32, center: d.Vec2f, width: d.F32, falloff: d.F32, uv: d.Vec2f, aspect: d.F32) => d.F32>;
+/**
+ * TiltShift's fill graph: the kernel writes `blurAmount × maxRadius` (input pixels) into the
+ * variable blur's radius map. GPU-free.
+ */
+export declare function buildTiltShiftFillGraph(computeWidth: number, computeHeight: number): {
+    layout: TgpuBindGroupLayout<{
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                angle: d.F32;
+                centerX: d.F32;
+                centerY: d.F32;
+                width: d.F32;
+                falloff: d.F32;
+                aspect: d.F32;
+                maxRadius: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        angle: d.F32;
+        centerX: d.F32;
+        centerY: d.F32;
+        width: d.F32;
+        falloff: d.F32;
+        aspect: d.F32;
+        maxRadius: d.F32;
+    }>;
+};
+/**
+ * TiltShift's MAP-DRIVEN fill graph. The per-pixel max radius is sampled from the map SOURCE,
+ * remapped through the fragment path's window, scaled `× 0.36`, then multiplied by the tilt-shift
+ * blur amount. Bind-group adds the `source` texture (bound late).
+ */
+export declare function buildTiltShiftFillMapGraph(computeWidth: number, computeHeight: number, channel: BlurMapChannel): {
+    layout: TgpuBindGroupLayout<{
+        source: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputMin: d.F32;
+                inputMax: d.F32;
+                outputMin: d.F32;
+                outputMax: d.F32;
+                curve: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                angle: d.F32;
+                centerX: d.F32;
+                centerY: d.F32;
+                width: d.F32;
+                falloff: d.F32;
+                aspect: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputMin: d.F32;
+        inputMax: d.F32;
+        outputMin: d.F32;
+        outputMax: d.F32;
+        curve: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        angle: d.F32;
+        centerX: d.F32;
+        centerY: d.F32;
+        width: d.F32;
+        falloff: d.F32;
+        aspect: d.F32;
+    }>;
+};
+/**
+ * Glow's bloom composite: original colour plus the intensity-scaled blurred bloom, with the glow
+ * aura extending into transparent areas (composite the blurred coverage OVER the child's alpha so
+ * the halo isn't clipped to `original.a`). Pure float.
+ */
+export declare const glowCompose: TgpuFn<(original: d.Vec4f, bloom: d.Vec4f, intensity: d.F32) => d.Vec4f>;
+/** Glow's combined bright-extract + blur-map fill pre-pass (uniform static size). GPU-free. */
+export declare const buildGlowPrepassGraph: (computeWidth: number, computeHeight: number) => {
+    layout: TgpuBindGroupLayout<{
+        childTexture: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        brightMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                threshold: d.F32;
+                size: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        threshold: d.F32;
+        size: d.F32;
+    }>;
+};
+/** Glow's MAP-DRIVEN pre-pass: bright extraction is identical; the blur radius per pixel is sampled
+ *  from the size-map SOURCE and remapped through the same window the fragment path uses. No
+ *  `× 0.36` — Glow's size is already in pixels. */
+export declare const buildGlowPrepassMapGraph: (computeWidth: number, computeHeight: number, channel: BlurMapChannel) => {
+    layout: TgpuBindGroupLayout<{
+        childTexture: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        source: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        brightMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        blurMap: {
+            storageTexture: d.WgslStorageTexture2d<"rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputMin: d.F32;
+                inputMax: d.F32;
+                outputMin: d.F32;
+                outputMax: d.F32;
+                curve: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                threshold: d.F32;
+            }>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputMin: d.F32;
+        inputMax: d.F32;
+        outputMin: d.F32;
+        outputMax: d.F32;
+        curve: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        threshold: d.F32;
+    }>;
+};
+/** Radius UI (0–100) → gather radius in input/canvas pixels. Max ~80px disc — creamy but bounded so
+ *  the fixed tap comb stays dense enough to keep discs clean. */
+export declare const BOKEH_RADIUS_SCALE = 0.8;
+export declare const bokehRadiusToPixels: (radius: number) => number;
+/** Fixed gather tap count. Bokeh isn't separable (a shaped disc can't split into two 1D passes),
+ *  so taps cost linearly — but the gather runs at the kit blurs' capped compute resolution and the
+ *  taps carry NO per-tap trig (positions are CPU-precomputed), so 100 taps lands in the same cost
+ *  ballpark as the kit's fixed 2×49-tap separable Gaussian. One tier, no quality knob. */
+export declare const BOKEH_TAP_COUNT = 100;
+export interface BokehTap {
+    x: number;
+    y: number;
+    rim: number;
+}
+export declare const BOKEH_SHAPES: readonly ["blades", "circle", "star", "heart", "flower", "cross", "ring"];
+export type BokehShape = (typeof BOKEH_SHAPES)[number];
+/** Polygon aperture radius along direction `theta` for a regular `sides`-gon inscribed in the unit
+ *  circle (vertices at r=1); `sides < 3` → circle. CPU mirror of the old GPU helper. */
+export declare const bokehPolygonRadius: (theta: number, sides: number) => number;
+/**
+ * Precompute `tapCount` gather offsets inside the chosen aperture shape (unit-radius space,
+ * unrotated) plus each tap's rim-brightening weight. Circle/blades use the exact Vogel-spiral +
+ * polygon-radius math the kernel used to run per tap (pixel-identical look); the other shapes
+ * rejection-sample a Halton sequence against the CPU SDF mirrors. Offsets are NEGATED so the
+ * VISIBLE disc (a bright point spreads to pixels at `point − offset`) matches the shape's screen
+ * orientation — hearts upright, star tips up. Deterministic: same inputs → same table.
+ */
+export declare function generateBokehTaps(shape: string, bladeCount: number, tapCount: number): BokehTap[];
+/** Map-driven channel (the driving scalar the radius-map source contributes per pixel). Same four
+ *  channels the fragment map path supports; a build-time constant so the branch is comptime-folded
+ *  (Blur's `BlurMapChannel` precedent). */
+export type BokehMapChannel = BlurMapChannel;
+/**
+ * Highlight-weighting stage (the bokeh trick): weight bright taps up so they dominate the gather
+ * and form discs instead of washing out. Soft-knee smoothstep above `threshold`; `rim` carries the
+ * tap's precomputed rim-brightening lift. Separable from the gather (pure per-tap math), shared by
+ * the uniform-radius and map-driven kernels.
+ */
+export declare const bokehHighlightWeight: TgpuFn<(base: d.Vec4f, threshold: d.F32, gain: d.F32, rim: d.F32) => d.F32>;
+/**
+ * GPU-free construction of the single-pass bokeh gather node graph (bind-group layout + kernel fn).
+ * Bokeh is NOT separable, so unlike the kit's 2-pass Gaussian this scatters-as-gather over the
+ * precomputed aperture tap table in ONE pass: for each output pixel it walks `tapCount` taps (unit
+ * aperture offsets, rotated by the uniform cos/sin and scaled by the gather radius), boosts bright
+ * taps via the highlight-weighting stage, brightens the rim via each tap's precomputed weight, and
+ * optionally fringes the R/B channels for a lens look. Mirrors kit/blur's `buildFixedBlurGraph`
+ * style (GPU-free, 2D dispatch — no manual bounds guard, SAMPLED `textureLoad` with a mip level
+ * for the input, STORAGE `textureStore` for the output).
+ *
+ * The tap loop itself is an ATOMIC gather core — irreducible: one gather integral whose taps
+ * accumulate into shared colour/alpha/weight sums, with the chromatic-fringe taps bound to this
+ * graph's layout (conditional textureLoads can't leave the kernel) — so the loop does not
+ * decompose past the weighting stage above.
+ */
+export declare function buildBokehGraph(computeWidth: number, computeHeight: number, tapCount: number): {
+    layout: TgpuBindGroupLayout<{
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        output: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                radius: d.F32;
+                highlightGain: d.F32;
+                highlightThreshold: d.F32;
+                rotCos: d.F32;
+                rotSin: d.F32;
+                chromaticFringe: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+            }>;
+        };
+        taps: {
+            uniform: d.WgslArray<d.Vec4f>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        radius: d.F32;
+        highlightGain: d.F32;
+        highlightThreshold: d.F32;
+        rotCos: d.F32;
+        rotSin: d.F32;
+        chromaticFringe: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+    }>;
+    TapArray: d.WgslArray<d.Vec4f>;
+};
+/**
+ * GPU-free construction of the MAP-DRIVEN gather graph. Identical gather to `buildBokehGraph`, but the
+ * per-pixel radius is sampled from the radius-map SOURCE (canvas-resolution RTT), remapped through the
+ * same window `resolveMapForProp` uses in the fragment path, then scaled × RADIUS_SCALE. The `source`
+ * texture is bound late (its RTT is allocated after composition). Mirrors Glow's map-prepass remap math.
+ */
+export declare function buildBokehMapGraph(computeWidth: number, computeHeight: number, tapCount: number, channel: BokehMapChannel): {
+    layout: TgpuBindGroupLayout<{
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        source: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        output: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputMin: d.F32;
+                inputMax: d.F32;
+                outputMin: d.F32;
+                outputMax: d.F32;
+                curve: d.F32;
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                highlightGain: d.F32;
+                highlightThreshold: d.F32;
+                rotCos: d.F32;
+                rotSin: d.F32;
+                chromaticFringe: d.F32;
+            }>;
+        };
+        taps: {
+            uniform: d.WgslArray<d.Vec4f>;
+        };
+    }>;
+    kernel: TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputMin: d.F32;
+        inputMax: d.F32;
+        outputMin: d.F32;
+        outputMax: d.F32;
+        curve: d.F32;
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        highlightGain: d.F32;
+        highlightThreshold: d.F32;
+        rotCos: d.F32;
+        rotSin: d.F32;
+        chromaticFringe: d.F32;
+    }>;
+    TapArray: d.WgslArray<d.Vec4f>;
+};
 export {};
 //# sourceMappingURL=blur.d.ts.map

package/dist/core/gpu/kit/blur.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/blur.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/blur.ts"],"names":[],"mappings":"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"}

package/dist/core/gpu/kit/colorMixing.d.ts

@@ -109,4 +109,10 @@ export declare const mixPreconvertedColors: (convA: d.v3f, convB: d.v3f, alphaA:
  * · 5 LCH). Mode 0 needs no conversion — keep using mixColors directly for linear RGB.
  */
 export declare const convertP3ToMixSpaceCPU: (r: number, g: number, b: number, colorSpaceMode: number) => [number, number, number];
+/**
+ * Mix a color's rgb toward a target color by a scalar amount, preserving the source alpha —
+ * the GPU body behind std's `tintToward` colorOp (linear-RGB; the colorSpace-aware path is
+ * `mixColorsVariants`). Pure — CPU-executable as a DualFn for golden tests.
+ */
+export declare const mixToward: import('typegpu').TgpuFn<(color: d.Vec4f, target: d.Vec4f, amount: d.F32) => d.Vec4f>;
 //# sourceMappingURL=colorMixing.d.ts.map

package/dist/core/gpu/kit/colorMixing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colorMixing.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/colorMixing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAC,CAAC,EAAY,MAAM,SAAS,CAAA;AAepC,qCAAqC;AACrC,eAAO,MAAM,QAAQ,oDAMnB,CAAA;AAEF,qDAAqD;AACrD,eAAO,MAAM,QAAQ,sDAMnB,CAAA;AAIF,0FAA0F;AAC1F,eAAO,MAAM,UAAU,qDAoBrB,CAAA;AAEF,2BAA2B;AAC3B,eAAO,MAAM,UAAU,qDAmBrB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,YAAY,qDAQvB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,YAAY,qDAMvB,CAAA;AAIF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,0EAyB5B,CAAA;AAIF,iDAAiD;AACjD,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,qDAsBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,6BAA6B;AAC7B,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAQnB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,QAAQ,qDAMnB,CAAA;AAUF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,mFAQ1B,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,yGAAyG;AACzG,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,SAAS,WAAY,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,KAAK,MAAM,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAG7F,CAAA;AAOD,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB,OAAQ,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GASzE,CAAA;AAED,kGAAkG;AAClG,eAAO,MAAM,mBAAmB,UAAW,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAS5E,CAAA;AAID,6FAA6F;AAC7F,eAAO,MAAM,OAAO;;;EAA0C,CAAA;AAE9D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;GASlC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,+GAUjC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;CAO1B,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,qBAAqB,UACvB,CAAC,CAAC,GAAG,SACL,CAAC,CAAC,GAAG,UACJ,MAAM,UACN,MAAM,KACX,MAAM,kBACO,MAAM,KACvB,CAAC,CAAC,GAGJ,CAAA;AA6DD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAC5B,MAAM,KAAK,MAAM,KAAK,MAAM,kBAAkB,MAAM,KACxD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAgBzB,CAAA"}
+{"version":3,"file":"colorMixing.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/colorMixing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAC,CAAC,EAAY,MAAM,SAAS,CAAA;AAepC,qCAAqC;AACrC,eAAO,MAAM,QAAQ,oDAMnB,CAAA;AAEF,qDAAqD;AACrD,eAAO,MAAM,QAAQ,sDAMnB,CAAA;AAIF,0FAA0F;AAC1F,eAAO,MAAM,UAAU,qDAoBrB,CAAA;AAEF,2BAA2B;AAC3B,eAAO,MAAM,UAAU,qDAmBrB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,YAAY,qDAQvB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,YAAY,qDAMvB,CAAA;AAIF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,0EAyB5B,CAAA;AAIF,iDAAiD;AACjD,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,qDAsBnB,CAAA;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,qDAYnB,CAAA;AAIF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,6BAA6B;AAC7B,eAAO,MAAM,QAAQ,qDAyBnB,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,QAAQ,qDAQnB,CAAA;AAEF,qBAAqB;AACrB,eAAO,MAAM,QAAQ,qDAMnB,CAAA;AAUF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,mFAQ1B,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,cAAc,mFAWzB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,eAAO,MAAM,YAAY,mFAWvB,CAAA;AAEF,yGAAyG;AACzG,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,SAAS,WAAY,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,KAAK,MAAM,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAG7F,CAAA;AAOD,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB,OAAQ,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GASzE,CAAA;AAED,kGAAkG;AAClG,eAAO,MAAM,mBAAmB,UAAW,CAAC,CAAC,GAAG,kBAAkB,MAAM,KAAG,CAAC,CAAC,GAS5E,CAAA;AAID,6FAA6F;AAC7F,eAAO,MAAM,OAAO;;;EAA0C,CAAA;AAE9D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;GASlC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,+GAUjC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,oBAAoB,+GAUhC,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,kBAAkB,+GAU9B,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;CAO1B,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,qBAAqB,UACvB,CAAC,CAAC,GAAG,SACL,CAAC,CAAC,GAAG,UACJ,MAAM,UACN,MAAM,KACX,MAAM,kBACO,MAAM,KACvB,CAAC,CAAC,GAGJ,CAAA;AA6DD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAC5B,MAAM,KAAK,MAAM,KAAK,MAAM,kBAAkB,MAAM,KACxD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAgBzB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,uFAMpB,CAAA"}

package/dist/core/gpu/kit/colorOps.d.ts

@@ -0,0 +1,102 @@
+import { d } from './index';
+
+/**
+ * Hue rotation via Rodrigues' rotation of RGB around the (1,1,1) achromatic axis. Takes RAW
+ * DEGREES (the deg→rad conversion is folded here, full-precision constants).
+ */
+export declare const hueRotate: import('typegpu').TgpuFn<(color: d.Vec4f, shiftDeg: d.F32) => d.Vec4f>;
+/**
+ * Rec.709 luminance-weighted desaturate/saturate: intensity 0 = grayscale, 1 = unchanged,
+ * >1 oversaturates. The scalar mix factor is wrapped `d.vec3f(intensity)` for the vector mix.
+ */
+export declare const saturate: import('typegpu').TgpuFn<(color: d.Vec4f, intensity: d.F32) => d.Vec4f>;
+/**
+ * Vibrance: selective saturation that protects already-saturated pixels. An ADJUSTMENT around
+ * zero (0 = unchanged), unlike saturate's multiplier.
+ */
+export declare const vibrance: import('typegpu').TgpuFn<(color: d.Vec4f, adjustment: d.F32) => d.Vec4f>;
+/**
+ * Contrast around the midpoint, then additive brightness offset:
+ * `(rgb - 0.5) * (contrast + 1) + 0.5 + brightness`. Takes the RAW [-1, 1] contrast slider
+ * value — the `+ 1` is folded here, so raw 0 is the identity for both params.
+ */
+export declare const brightnessContrast: import('typegpu').TgpuFn<(color: d.Vec4f, brightness: d.F32, contrastRaw: d.F32) => d.Vec4f>;
+/**
+ * Pure scalar gain. Multiplication leaves 0 at 0 (blacks stay black) and is intentionally NOT
+ * clamped — values above 1.0 survive to the renderer's tone-mapping shoulder.
+ */
+export declare const exposure: import('typegpu').TgpuFn<(color: d.Vec4f, gain: d.F32) => d.Vec4f>;
+/** Luminance-weighted desaturation (ITU-R BT.709), alpha preserved. */
+export declare const grayscale: import('typegpu').TgpuFn<(color: d.Vec4f) => d.Vec4f>;
+/** Invert RGB directly (1 - rgb), preserve alpha. */
+export declare const invert: import('typegpu').TgpuFn<(color: d.Vec4f) => d.Vec4f>;
+/**
+ * Invert tones above a Rec.601 luminance threshold, blended by strength.
+ * std.select(f, t, cond) returns t when cond is true: select(rgb, inverted, lum > threshold) →
+ * true=inverted, false=rgb.
+ */
+export declare const solarize: import('typegpu').TgpuFn<(color: d.Vec4f, threshold: d.F32, strength: d.F32) => d.Vec4f>;
+/** Quantise each channel to `steps` levels: floor(c * steps) / steps. */
+export declare const posterize: import('typegpu').TgpuFn<(color: d.Vec4f, steps: d.F32) => d.Vec4f>;
+/** Plain tint: mix child rgb toward the tint rgb by amount. */
+export declare const tintPlain: import('typegpu').TgpuFn<(color: d.Vec4f, tintColor: d.Vec4f, amount: d.F32) => d.Vec4f>;
+/**
+ * Luminosity-preserving tint: scale the tinted output back to the original brightness (Rec.601
+ * weights) so the tint shifts hue without darkening. `max(tintedLum, 0.0001)` guards
+ * divide-by-zero.
+ */
+export declare const tintPreserveLuma: import('typegpu').TgpuFn<(color: d.Vec4f, tintColor: d.Vec4f, amount: d.F32) => d.Vec4f>;
+/**
+ * Duotone blend factor from the child's Rec.601 luminance — lower favours the dark colour,
+ * higher the bright one. The two-colour mix happens at builder level (compile-time colour space).
+ */
+export declare const duotoneT: import('typegpu').TgpuFn<(color: d.Vec4f, blend: d.F32) => d.F32>;
+/**
+ * Tritone blend factors from the child's Rec.601 luminance: (shadow→mid, mid→highlight,
+ * lower↔upper). The three colour mixes happen at builder level (compile-time colour space).
+ */
+export declare const tritoneFactors: import('typegpu').TgpuFn<(color: d.Vec4f, blendMid: d.F32) => d.Vec3f>;
+/**
+ * Rec.709 luminance → levels remap (black/white points) + contrast around the midpoint. Pure
+ * scalar. Shared by the gradient map's cosine-palette and custom-colour paths.
+ */
+export declare const gradientMapT: import('typegpu').TgpuFn<(color: d.Vec4f, black: d.F32, white: d.F32, contrast: d.F32) => d.F32>;
+/**
+ * Cosine palette: color(t) = clamp(a + b*cos(2π*(c*t + d + phase)), 0, 1). phase is a scalar
+ * broadcast into the vec3 argument (seamless loop — cos is 2π-periodic).
+ */
+export declare const gradientMapCosine: import('typegpu').TgpuFn<(t: d.F32, phase: d.F32, pa: d.Vec3f, pb: d.Vec3f, pc: d.Vec3f, pd: d.Vec3f) => d.Vec3f>;
+/**
+ * Custom cyclic ramp phase: t → (segmentFraction, segmentIndex) for the low→mid→high→low cycle,
+ * scrolled by phase. The per-segment colour blends happen at builder level.
+ */
+export declare const gradientMapCustomPhase: import('typegpu').TgpuFn<(t: d.F32, phase: d.F32) => d.Vec2f>;
+/**
+ * Pick the active segment colour: i<1 → seg0, i<2 → seg1, else seg2. std.select is (ifFalse,
+ * ifTrue, cond); nested to express `i<1 ? seg0 : (i<2 ? seg1 : seg2)`.
+ */
+export declare const gradientMapSelect: import('typegpu').TgpuFn<(seg0: d.Vec4f, seg1: d.Vec4f, seg2: d.Vec4f, i: d.F32) => d.Vec4f>;
+/** Final gradient-map compose: blend original child rgb ↔ mapped by strength, alpha preserved. */
+export declare const gradientMapCompose: import('typegpu').TgpuFn<(color: d.Vec4f, mapped: d.Vec3f, strength: d.F32) => d.Vec4f>;
+/**
+ * Film grain weighted toward darker areas. `pixelCoord = uv * viewport` is device-pixel space; a
+ * full-screen hash, so any Y-orientation difference only shifts the speckle — statistically
+ * identical. `animTime` is the CPU-accumulated frame drift (0 when not animated), folded into the
+ * hash input. BT.709 luminance, clamp, pow with the 1e-6 guard, strength×0.1 scale. Alpha
+ * preserved.
+ */
+export declare const filmGrain: import('typegpu').TgpuFn<(color: d.Vec4f, uv: d.Vec2f, viewport: d.Vec2f, strength: d.F32, bias: d.F32, animTime: d.F32) => d.Vec4f>;
+/**
+ * Anti-aliased contour-line mask from a source value: invert → gamma → banded fract → fwidth AA.
+ * Bakes in the isolines' own softness/lineWidth semantics (pixel-width lines, an inner-edge
+ * ramp). `invert` is the runtime boolean uniform (1 true / -1 false). fwidth is fragment-only,
+ * so it lives in this body.
+ */
+export declare const contourLineMask: import('typegpu').TgpuFn<(sourceValue: d.F32, levels: d.F32, lineWidth: d.F32, softness: d.F32, gamma: d.F32, invert: d.F32) => d.F32>;
+/** Isoline mask over the child's Rec.709 luminance (compile-time source variant). */
+export declare const isolinesFromLuma: import('typegpu').TgpuFn<(color: d.Vec4f, levels: d.F32, lineWidth: d.F32, softness: d.F32, gamma: d.F32, invert: d.F32) => d.F32>;
+/** Isoline mask over the child's alpha channel (compile-time source variant). */
+export declare const isolinesFromAlpha: import('typegpu').TgpuFn<(color: d.Vec4f, levels: d.F32, lineWidth: d.F32, softness: d.F32, gamma: d.F32, invert: d.F32) => d.F32>;
+/** Mix background → line by the line mask (rgb + alpha). */
+export declare const contourCompose: import('typegpu').TgpuFn<(bg: d.Vec4f, line: d.Vec4f, mask: d.F32) => d.Vec4f>;
+//# sourceMappingURL=colorOps.d.ts.map

package/dist/core/gpu/kit/colorOps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorOps.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/colorOps.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAOpC;;;GAGG;AACH,eAAO,MAAM,SAAS,wEAiCpB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,yEASnB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,0EAenB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,8FAQ7B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,oEAInB,CAAA;AAEF,uEAAuE;AACvE,eAAO,MAAM,SAAS,uDAIpB,CAAA;AAEF,qDAAqD;AACrD,eAAO,MAAM,MAAM,uDAGjB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,0FAUnB,CAAA;AAEF,yEAAyE;AACzE,eAAO,MAAM,SAAS,qEASpB,CAAA;AAEF,+DAA+D;AAC/D,eAAO,MAAM,SAAS,0FAKpB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,0FAS3B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,mEAKnB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,wEAOzB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,kGAOvB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,mHAO7B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,+DAKjC,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,8FAI5B,CAAA;AAEF,kGAAkG;AAClG,eAAO,MAAM,kBAAkB,yFAI7B,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,sIAqBhB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,eAAe,wIAatB,CAAA;AAEN,qFAAqF;AACrF,eAAO,MAAM,gBAAgB,oIAIvB,CAAA;AAEN,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,oIAIxB,CAAA;AAEN,4DAA4D;AAC5D,eAAO,MAAM,cAAc,gFAKzB,CAAA"}

package/dist/core/gpu/kit/displace.d.ts

@@ -0,0 +1,14 @@
+import { d } from './index';
+
+/**
+ * Per-channel sample UVs from a displacement vector with chromatic split. `strength` is the UI
+ * 0–20 range (×0.1 into UV space); displacement is clamped to ±0.15 UV so a driver-fed spike can't
+ * fling samples across the frame; `chromaticSplit` spreads the R/B taps ±10% around G. Pure —
+ * CPU-executable as a DualFn for golden tests.
+ */
+export declare const chromaticDisplaceUVs: import('typegpu').TgpuFn<(uv: d.Vec2f, disp: d.Vec2f, strength: d.F32, chromaticSplit: d.F32) => d.WgslStruct<{
+    rUV: d.Vec2f;
+    gUV: d.Vec2f;
+    bUV: d.Vec2f;
+}>>;
+//# sourceMappingURL=displace.d.ts.map

package/dist/core/gpu/kit/displace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displace.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/displace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAKpC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;GAYhC,CAAA"}

package/dist/core/gpu/kit/fields.d.ts

@@ -140,4 +140,12 @@ export declare function domainWarp2(fieldFn: Warp3Field, options?: DomainWarp2Op
 export type Warp3Field = (p: d.v3f) => number;
 /** {@link domainWarp2}'s output: `(pos, t, warpAmount) → final sampling position`. */
 export type Warp3Fn = (pos: d.v3f, t: number, warpAmount: number) => d.v3f;
+/**
+ * Radial falloff coverage mask — the GPU body behind std's `radialMask` noun (Vignette's
+ * lattice-free radial field). Aspect-corrected so the falloff is circular, not oval. `center`
+ * takes the transformPosition STORED value `(x, 1 - y)`; the `1.0 - center.y` here recovers the
+ * authored y (the standard center double-flip). Returns 0 inside `radius` (clear) rising to 1 at
+ * `radius + falloff` (full coverage). Pure — CPU-executable as a DualFn for golden tests.
+ */
+export declare const radialFalloffMask: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, center: d.Vec2f, radius: d.F32, falloff: d.F32) => d.F32>;
 //# sourceMappingURL=fields.d.ts.map