shaders 3.1.463 → 3.2.465

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

@@ -82,6 +82,75 @@ export declare function makeAgentWeightFn(shape: string): import('typegpu').Tgpu
  * ignored. Consumers with a runtime softness uniform must keep using `makeAgentWeightFn`.
  */
 export declare function makeAgentTexelWeightFn(shape: string): import('typegpu').TgpuFn<(q: d.F32, _t: d.F32, _n: d.F32, bodyR: d.F32, _aaW: d.F32) => d.F32>;
+/** Shape metadata the oriented splat consumers bake: the comet consumers stretch the round
+ *  registry glow into a ±1·bodyR segment and widen its reject by one bodyR. */
+export declare function orientedShapeProfile(shape: string, opts?: {
+    comet?: boolean;
+}): {
+    name: "square" | "arrow" | "streak" | "dot" | "glow";
+    soft: 0 | 1;
+    hl: number;
+    ext: number;
+    /** A zero-half-length round shape needs no heading-space rotation (and no comet). */
+    symmetric: boolean;
+};
+/**
+ * Bake one oriented shape into the per-texel weight the velocity-heading splat consumers share
+ * (Boids, ParticleFlow): the fast baked weight fn wrapped with the glow comet treatment — the
+ * along-heading coordinate collapsed over a ±hl segment and a head-bright tail fade. For hard
+ * shapes (SOFT = 0) both fold to the identity. Signature `(t, n, bodyR, aaW) → w`.
+ */
+export declare function makeOrientedCometWeightFn(shape: string): import('typegpu').TgpuFn<(t: d.F32, n: d.F32, bodyR: d.F32, aaW: d.F32) => d.F32>;
+/** Reynolds steering: desired = normalize(dir)·maxSpeed, steer = desired − vel, clamped to maxForce.
+ *  Zero-length `dir` yields zero steer (the caller only passes it when a neighbour was found). */
+export declare const reynoldsSteer: import('typegpu').TgpuFn<(dir: d.Vec2f, vel: d.Vec2f, maxSpeed: d.F32, maxForce: d.F32) => d.Vec2f>;
+/** Per-agent cruise-speed variation (hash of index) so a flock isn't robotic. */
+export declare const cruiseVariation: import('typegpu').TgpuFn<(fi: d.F32) => d.F32>;
+/** Per-agent "presence" factor in [0.55, 1.25] (hash of index) — one shared depth-ish cascade
+ *  that consumers scale both size and brightness by, so near-reading agents are bigger AND
+ *  brighter together (the multi-layer parallax read from a single hash). */
+export declare const presenceVariation: import('typegpu').TgpuFn<(fi: d.F32) => d.F32>;
+/** Straight-alpha OVER composite of a resolved agent field onto a backdrop colour — the plain
+ *  un-premultiplied Porter-Duff over, for consumers that layer their field without an RTT. */
+export declare const straightAlphaOver: import('typegpu').TgpuFn<(p: d.Vec4f, c: d.Vec4f) => d.Vec4f>;
+/** Field-line direction at r̂ from the source: 2D magnetic dipole B ∝ 2(m·r̂)r̂ − m (fieldType 0)
+ *  or radial monopole spokes B ∝ r̂ (fieldType 1). */
+export declare const dipoleOrRadialField: import('typegpu').TgpuFn<(rhat: d.Vec2f, axis: d.Vec2f, fieldType: d.F32) => d.Vec2f>;
+/**
+ * Nematic restoring torque: `k · sin(2·(target − θ))`. π-periodic, so a director (θ ≡ θ+π) always
+ * takes the SHORT way onto the target line — its stable equilibria sit exactly at the two
+ * line-aligned angles, no wrap, no wrong-way spins.
+ */
+export declare const nematicTorque: import('typegpu').TgpuFn<(k: d.F32, target: d.F32, theta: d.F32) => d.F32>;
+/**
+ * The trail canvas composite the trail-bearing consumers share: a max-with-decay — the crisp new
+ * head wins where the agent is now, a fading copy persists where it was. Never saturates, and
+ * collapses to the plain splat at `trails` = 0.
+ */
+export declare const trailMaxDecay: import('typegpu').TgpuFn<(col: d.Vec4f, curA: d.F32, prev: d.Vec4f, trails: d.F32) => d.Vec4f>;
+/** Rotate a world position by the camera matrix rows (built on the CPU, w unused). */
+export declare const applyCameraRows: import('typegpu').TgpuFn<(pw: d.Vec3f, rowX: d.Vec4f, rowY: d.Vec4f, rowZ: d.Vec4f) => d.Vec3f>;
+/** Rotate a view-space vector back into world space by Rᵀ (rows are orthonormal). */
+export declare const applyCameraRowsTransposed: import('typegpu').TgpuFn<(v: d.Vec3f, rowX: d.Vec4f, rowY: d.Vec4f, rowZ: d.Vec4f) => d.Vec3f>;
+/** Clamped bilinear tap geometry over a texel grid: corner indices + fractional weights. */
+export declare const BilinearFrame: d.WgslStruct<{
+    x0: d.U32;
+    x1: d.U32;
+    y0: d.U32;
+    y1: d.U32;
+    fx: d.F32;
+    fy: d.F32;
+}>;
+/** The clamped index/frac setup every per-agent bilinear textureLoad shares (`uv01` in [0,1] per
+ *  axis, `dims` the texture size). The caller owns the four loads (layout access) and the mixes. */
+export declare const bilinearTexelFrame: import('typegpu').TgpuFn<(uv01: d.Vec2f, dims: d.Vec2f) => d.WgslStruct<{
+    x0: d.U32;
+    x1: d.U32;
+    y0: d.U32;
+    y1: d.U32;
+    fx: d.F32;
+    fy: d.F32;
+}>>;
 /** Gaussian falloff of a cursor field at offset `delta` (any 2D space), radius² `radSq`. */
 export declare const cursorFalloff: import('typegpu').TgpuFn<(delta: d.Vec2f, radSq: d.F32) => d.F32>;
 /**
@@ -91,4 +160,98 @@ export declare const cursorFalloff: import('typegpu').TgpuFn<(delta: d.Vec2f, ra
  * rendering a displaced fisheye.
  */
 export declare const cursorMagnet: import('typegpu').TgpuFn<(delta: d.Vec2f, radSq: d.F32, force: d.F32) => d.Vec2f>;
+/**
+ * Uniform-scatter spawn: agents distributed evenly across the aspect-corrected screen
+ * domain at rest (hash-decorrelated with irrational per-axis strides). Layout ABI:
+ * `agents` (vec4f state, xy = position) and `params.aspect`.
+ */
+export declare function makeUniformScatterInit(layout: {
+    readonly $: {
+        agents: d.v4f[];
+        params: {
+            readonly aspect: number;
+        };
+    };
+}, name: string): import('typegpu').TgpuFn<(i: d.U32) => d.Void>;
+/**
+ * Ball-cloud spawn for a 3D swarm: agents on hash directions at cube-root-distributed radii
+ * (volume-uniform inside the ball), at rest, each carrying a hash seed in pos.w. Irrational
+ * per-axis strides decorrelate consecutive indices (linear strides through the fract-based
+ * hash leave visible filament alignments). Layout ABI: `pos`/`vel` vec4f state arrays;
+ * state written as pos = (xyz, seed), vel = 0.
+ */
+export declare function makeBallCloudInit(layout: {
+    readonly $: {
+        pos: d.v4f[];
+        vel: d.v4f[];
+    };
+}, name: string, cfg?: {
+    radius?: number;
+    zSquash?: number;
+}): import('typegpu').TgpuFn<(i: d.U32) => d.Void>;
+/**
+ * Clustered-formation spawn for a steering swarm: K elongated clusters (one per
+ * `agentsPerCluster` agents, at least `minClusters`), each with a shared heading and cruise
+ * velocity, jittered per agent — frame one reads as an already-organised flock instead of a
+ * uniform scatter that takes seconds to self-organise (pre-running the sim would cost O(N²)
+ * per warm-up step). `params.seed` re-rolls the layout at runtime. Layout ABI: `agents`
+ * (vec4f = posX, posY, velX, velY), `agit` (f32, zeroed), `params.{count, seed, domainX,
+ * maxSpeed}`.
+ */
+export declare function makeClusterFormationInit(layout: {
+    readonly $: {
+        agents: d.v4f[];
+        agit: number[];
+        readonly params: {
+            readonly count: number;
+            readonly seed: number;
+            readonly domainX: number;
+            readonly maxSpeed: number;
+        };
+    };
+}, name: string, cfg?: {
+    agentsPerCluster?: number;
+    minClusters?: number;
+}): import('typegpu').TgpuFn<(i: d.U32) => d.Void>;
+/**
+ * Resting-director spawn for an orientation swarm: every agent parked at its home (zero
+ * offset), a hash-scattered starting angle over the [0, π) director line, zero spin, calm.
+ * Layout ABI: `agents` (vec4f = offX, offY, θ, ω), `agit` (f32, zeroed).
+ */
+export declare function makeRestingDirectorInit(layout: {
+    readonly $: {
+        agents: d.v4f[];
+        agit: number[];
+    };
+}, name: string): import('typegpu').TgpuFn<(i: d.U32) => d.Void>;
+/**
+ * Bake a per-pixel scan of a recorded stroke polyline as a SMOOTH capsule chain:
+ * `(pointsTex, uv, aspect, radius, shrink, softness, viewportH) → vec2(age, coverage)`.
+ *
+ * The polyline arrives as a `maxPoints`×1 data texture, texel i = (x, y, age∈[0,1),
+ * signedWidth); age ≥ 1 marks a dead slot. |w| is the per-point width scale (the pen-pressure
+ * analogue) and its SIGN is the link flag — positive = linked to texel i−1, negative = stroke
+ * start; the recorder appends a duplicate of the live head so the curve reaches the tip.
+ *
+ * The spine is the classic midpoint quadratic-Bézier chain: each linked point P_i draws the
+ * quadratic around joint P_{i−1} — from mid(P_{i−2},P_{i−1}) to mid(P_{i−1},P_i) with P_{i−1}
+ * as control (falling back to the raw endpoint at a stroke start). C1-continuous through the
+ * whole path, so a drawn arc reads as a curve, not a chain of chords. Each quadratic is
+ * evaluated as `subdivisions` sub-capsules (round-cones with age-shrunk radii); an unlinked
+ * survivor is a plain dot.
+ *
+ * Two accumulators, both chosen for CONTINUITY:
+ *   - `minSdf` — plain min-union (adjacent pieces share endpoints/radii, so the union is
+ *                already smooth; smooth-min would bulge every overlap into a scallop).
+ *   - `age`    — exponentially depth-weighted blend of each joint's age at its closest point:
+ *                the stroke a pixel is deepest inside dominates (newest-on-top in spirit at
+ *                crossings) but the handoff is a smooth band ~r/4 wide, never a seam.
+ * `softness` widens the edge band in radius units on top of the ~1.5px AA floor; a late-life
+ * fade (age 0.8→1) removes the pop when a piece is culled.
+ */
+export declare function makeStrokePolylineScan(cfg: {
+    maxPoints: number;
+    subdivisions: number;
+    name: string;
+}): import('typegpu').TgpuFn<(pointsTex: d.WgslTexture2d<d.F32>, uv: d.Vec2f, aspect: d.F32, radius: d.F32, shrink: d.F32, softness: d.F32, viewportH: d.F32) => d.Vec2f>;
 //# sourceMappingURL=agents.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,SAAS,CAAA;AAIpC;+FAC+F;AAC/F,eAAO,MAAM,QAAQ,+EAgBI,CAAA;AAEzB;0CAC0C;AAC1C,eAAO,MAAM,UAAU,8EAII,CAAA;AAE3B,uFAAuF;AACvF,eAAO,MAAM,MAAM,+EAOI,CAAA;AAOvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUf,CAAA;AACV,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,YAAY,CAAA;AAEtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,cAAc,CAEzF;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB;;;GAMhC,CAAA;AACD,uEAAuE;AACvE,eAAO,MAAM,iBAAiB;;;GAI7B,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,kGAa9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,kGAiCnD;AAID,4FAA4F;AAC5F,eAAO,MAAM,aAAa,mEAII,CAAA;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,mFAII,CAAA"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/gpu/kit/agents.ts"],"names":[],"mappings":"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"}

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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"}