shaders 3.1.463 → 3.2.465

package/dist/core/gpu/scaffolds/heightField.d.ts

@@ -0,0 +1,224 @@
+import { d } from '../kit';
+import { KitComputePipeline, GuardedComputeOptions } from '../compute';
+import { TgpuRoot } from 'typegpu';
+
+export declare const WAVE_GRID = 256;
+export declare const WAVE_CELLS: number;
+/** World half-extent the wave grid spans: world uv ±WAVE_HALFEXTENT maps onto the grid 0..1. */
+export declare const WAVE_HALFEXTENT = 3;
+/** Working bound on |wave snapshot| — the slab widening budget while a ripple is live. */
+export declare const CURSOR_WAVE_BOUND = 6;
+export declare const WAVE_DECAY = 10;
+export declare const WAVE_DECAY_PER_STEP = 0.004;
+/** Wave-field settle time implied by the decay: ms after the last injection at which the
+ *  propagation has damped below 1e-6 and can no longer move the surface. */
+export declare const WAVE_SETTLE_MS: number;
+/** Far cap on the ray parameter — also the range near/far cutoff props map onto. */
+export declare const MARCH_FAR = 15;
+/** Slack added to the height slab so a zero-amplitude (perfectly flat) surface still has a
+ *  crossable slab, and bilinear wave taps at the slab boundary can't fall outside it. */
+export declare const HEIGHT_SLAB_PAD = 0.02;
+export declare const HEIGHT_FIELD_STATE_FORMAT: "rgba16float";
+export declare const HeightFieldParams: d.WgslStruct<{
+    amp: d.F32;
+    freq: d.F32;
+    seed: d.F32;
+    edgePin: d.F32;
+    cursorIntensity: d.F32;
+    t: d.F32;
+    aspect: d.F32;
+    focal: d.F32;
+    camPos: d.Vec3f;
+    camForward: d.Vec3f;
+    camRight: d.Vec3f;
+    camUp: d.Vec3f;
+    lighting: d.F32;
+    glossiness: d.F32;
+    highlights: d.F32;
+    lightX: d.F32;
+    lightY: d.F32;
+    lightZ: d.F32;
+    lightColor: d.Vec3f;
+    nearCutoff: d.F32;
+    farCutoff: d.F32;
+    cursorWaveX: d.F32;
+    cursorWaveY: d.F32;
+    mouseSpeed: d.F32;
+    dt: d.F32;
+    decay: d.F32;
+    radius: d.F32;
+    waveSpeed: d.F32;
+    heightEnvelope: d.F32;
+    cursorActive: d.F32;
+}>;
+/** Everything in {@link HeightFieldParams}, as plain numbers / number-triples. */
+export interface HeightFieldParamsInput {
+    amp: number;
+    freq: number;
+    seed: number;
+    edgePin: number;
+    cursorIntensity: number;
+    t: number;
+    aspect: number;
+    focal: number;
+    camPos: [number, number, number];
+    camForward: [number, number, number];
+    camRight: [number, number, number];
+    camUp: [number, number, number];
+    lighting: number;
+    glossiness: number;
+    highlights: number;
+    lightX: number;
+    lightY: number;
+    lightZ: number;
+    lightColor: [number, number, number];
+    nearCutoff: number;
+    farCutoff: number;
+    cursorWaveX: number;
+    cursorWaveY: number;
+    mouseSpeed: number;
+    dt: number;
+    decay: number;
+    radius: number;
+    waveSpeed: number;
+    heightEnvelope: number;
+    cursorActive: number;
+}
+export interface HeightFieldParamsUniform {
+    /** The GPU buffer — pass as the `params` entry of the exported layouts' bind groups. */
+    buffer: unknown;
+    write(p: HeightFieldParamsInput): void;
+}
+/** Create the params uniform + a plain-number write helper (the d.vec3f packing lives here). */
+export declare function createHeightFieldParamsUniform(root: TgpuRoot): HeightFieldParamsUniform;
+export declare const waveEquationLayout: import('typegpu').TgpuBindGroupLayout<{
+    readSrc: {
+        storage: d.WgslArray<d.F32>;
+        access: "readonly";
+    };
+    writeBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    readBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            amp: d.F32;
+            freq: d.F32;
+            seed: d.F32;
+            edgePin: d.F32;
+            cursorIntensity: d.F32;
+            t: d.F32;
+            aspect: d.F32;
+            focal: d.F32;
+            camPos: d.Vec3f;
+            camForward: d.Vec3f;
+            camRight: d.Vec3f;
+            camUp: d.Vec3f;
+            lighting: d.F32;
+            glossiness: d.F32;
+            highlights: d.F32;
+            lightX: d.F32;
+            lightY: d.F32;
+            lightZ: d.F32;
+            lightColor: d.Vec3f;
+            nearCutoff: d.F32;
+            farCutoff: d.F32;
+            cursorWaveX: d.F32;
+            cursorWaveY: d.F32;
+            mouseSpeed: d.F32;
+            dt: d.F32;
+            decay: d.F32;
+            radius: d.F32;
+            waveSpeed: d.F32;
+            heightEnvelope: d.F32;
+            cursorActive: d.F32;
+        }>;
+    };
+}>;
+export declare const heightFieldMarchLayout: import('typegpu').TgpuBindGroupLayout<{
+    readBuf: {
+        storage: d.WgslArray<d.F32>;
+        access: "readonly";
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            amp: d.F32;
+            freq: d.F32;
+            seed: d.F32;
+            edgePin: d.F32;
+            cursorIntensity: d.F32;
+            t: d.F32;
+            aspect: d.F32;
+            focal: d.F32;
+            camPos: d.Vec3f;
+            camForward: d.Vec3f;
+            camRight: d.Vec3f;
+            camUp: d.Vec3f;
+            lighting: d.F32;
+            glossiness: d.F32;
+            highlights: d.F32;
+            lightX: d.F32;
+            lightY: d.F32;
+            lightZ: d.F32;
+            lightColor: d.Vec3f;
+            nearCutoff: d.F32;
+            farCutoff: d.F32;
+            cursorWaveX: d.F32;
+            cursorWaveY: d.F32;
+            mouseSpeed: d.F32;
+            dt: d.F32;
+            decay: d.F32;
+            radius: d.F32;
+            waveSpeed: d.F32;
+            heightEnvelope: d.F32;
+            cursorActive: d.F32;
+        }>;
+    };
+    uvMaskTex: {
+        storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+    litTex: {
+        storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+/** Allocate the three f32 wave-field state buffers (ping A, pong B, stable snapshot). */
+export declare function createWaveStateBuffers(root: TgpuRoot): {
+    bufferA: import('typegpu').TgpuBuffer<d.WgslArray<d.F32>> & import('typegpu').StorageFlag;
+    bufferB: import('typegpu').TgpuBuffer<d.WgslArray<d.F32>> & import('typegpu').StorageFlag;
+    readBuf: import('typegpu').TgpuBuffer<d.WgslArray<d.F32>> & import('typegpu').StorageFlag;
+};
+/** Global heightfield (any u,v). waveType (0 fractal / 1 sine / 2 ridge) + octaveCount +
+ *  cursorEnabled baked. Reads params + (when cursorEnabled) the wave snapshot via manual bilinear. */
+export declare function buildSpectralHeightField(waveType: number, octaveCount: number, cursorEnabled: boolean): import('typegpu').TgpuFn<(uv: d.Vec2f) => d.F32>;
+/** Damped wave-equation propagation kernel factory (per ping-pong direction): a stencil step +
+ *  Gaussian injection at the CPU-projected cursor grid position.
+ *
+ *  ATOMIC (irreducible): a serial stencil algorithm — each texel's next value is one coupled
+ *  expression over its 4-neighbour Laplacian, the previous ping-pong state, the damping and the
+ *  injection, with the CFL-bound clamp applied to the SAME intermediate; there is no separable
+ *  stage that two consumers could share without re-deriving the recurrence. */
+export declare function makeWaveEquationKernel(): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+export interface HeightFieldMarchOptions {
+    /** Spectral family: 0 warped fractal, 1 sine banks, 2 ridge. */
+    waveType: number;
+    octaveCount: number;
+    /** kit/edges routing on the hit UV: 0 clamp, 1 transparent, 2 mirror, 3 wrap. */
+    edgeMode: number;
+    lightingEnabled: boolean;
+    cursorEnabled: boolean;
+    /** Fixed march steps across the height slab + bisection refinements. */
+    marchSteps: number;
+    marchRefine: number;
+    /** Compute-grid dimensions (baked — the grid is sized once at composition). */
+    computeW: number;
+    computeH: number;
+}
+/** Raymarch kernel factory. All options are baked compile-time config. */
+export declare function makeHeightFieldMarchKernel(opts: HeightFieldMarchOptions): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/** Wrap a `(cx, cy)` kernel into a guarded compute pass (the `'use gpu'` dispatch wrapper). */
+export declare function createKernelPass(root: TgpuRoot, kernel: unknown, opts?: GuardedComputeOptions): KitComputePipeline;
+//# sourceMappingURL=heightField.d.ts.map

package/dist/core/gpu/scaffolds/heightField.d.ts.map

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

package/dist/core/gpu/scaffolds/pointwiseFilter.d.ts

@@ -44,7 +44,9 @@ export interface PointwiseFilterConfig<T extends ComponentProps = ComponentProps
      * (Tint's plain/preserve-luminosity variants). Only the picked body emits into the WGSL, so the
      * selecting prop MUST be `compileTime: true`.
      */
-    body: FilterBody | ((propValues: Record<string, unknown>) => FilterBody);
+    body?: FilterBody | ((propValues: Record<string, unknown>) => FilterBody);
+    /** Pure-Expr alternative to `body`: build the filtered colour from `params.childNode`. */
+    build?: (params: FilterParams) => Expr;
     /**
      * The body's arguments AFTER the child colour (which is always first). Gets the whole builder
      * params so a filter can read `ctx` (Vignette's `ctx.uv`/`ctx.aspect`, FilmGrain's viewport)

package/dist/core/gpu/scaffolds/pointwiseFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointwiseFilter.d.ts","sourceRoot":"","sources":["../../../src/gpu/scaffolds/pointwiseFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,aAAa,CAAA;AAE7E;;;GAGG;AACH,MAAM,WAAW,UAAU;IACvB,iGAAiG;IACjG,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,cAAc;IAC3B,gFAAgF;IAChF,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,oEAAoE;IACpE,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;CACzD;AAED,kFAAkF;AAClF,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACnD,SAAS,EAAE,IAAI,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,CAC5E,SAAQ,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,UAAU,GAAG,aAAa,GAAG,eAAe,GAAG,SAAS,CAAC;IAC9F;;;;OAIG;IACH,IAAI,EAAE,UAAU,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,UAAU,CAAC,CAAA;IACxE;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,EAAE,CAAA;IACvC,mGAAmG;IACnG,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;IACtD,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;CACzC;AAED,iGAAiG;AACjG,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EAC3E,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,mBAAmB,CAAC,CAAC,CAAC,CAkBxB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAMzG"}
+{"version":3,"file":"pointwiseFilter.d.ts","sourceRoot":"","sources":["../../../src/gpu/scaffolds/pointwiseFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,aAAa,CAAA;AAE7E;;;GAGG;AACH,MAAM,WAAW,UAAU;IACvB,iGAAiG;IACjG,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,cAAc;IAC3B,gFAAgF;IAChF,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,oEAAoE;IACpE,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;CACzD;AAED,kFAAkF;AAClF,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACnD,SAAS,EAAE,IAAI,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,CAC5E,SAAQ,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,UAAU,GAAG,aAAa,GAAG,eAAe,GAAG,SAAS,CAAC;IAC9F;;;;OAIG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,UAAU,CAAC,CAAA;IACzE,0FAA0F;IAC1F,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;IACtC;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,EAAE,CAAA;IACvC,mGAAmG;IACnG,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;IACtD,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;CACzC;AAED,iGAAiG;AACjG,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EAC3E,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,mBAAmB,CAAC,CAAC,CAAC,CAwBxB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAMzG"}

package/dist/core/gpu/scaffolds/radiance.d.ts

@@ -0,0 +1,347 @@
+import { d } from '../kit/index';
+import { TgpuRoot } from 'typegpu';
+import { KitComputePipeline } from '../compute';
+
+/** The irradiance texture format — filterable, so the fragment samples it bilinearly. */
+export declare const IRRADIANCE_FORMAT: "rgba16float";
+/** The fixed capacity of the light list in the params ABI (a list prop's `maxItems` must not exceed it). */
+export declare const MAX_LIGHTS = 8;
+/** The per-frame params ABI the gather kernels read. */
+export declare const IrradianceParams: d.WgslStruct<{
+    /** Shape placement (transformPosition-stored center). */
+    center: d.Vec2f;
+    /** The lights: position lanes in PLACEMENT (sdfUV) space, colour lanes (linear rgb, intensity in .w), live count. */
+    lightPos: d.WgslArray<d.Vec4f>;
+    lightColor: d.WgslArray<d.Vec4f>;
+    lightCount: d.F32;
+    scale: d.F32;
+    rotation: d.F32;
+    aspect: d.F32;
+    /** Gather controls. */
+    reach: d.F32;
+    wrap: d.F32;
+    lightRange: d.F32;
+    shadowSoftness: d.F32;
+    /** One device pixel in field units (hit threshold, minimum step). */
+    eps: d.F32;
+    /** Texels per side of the (square) irradiance texture. */
+    res: d.F32;
+    /** Progressive sample index (0 on a fresh scene, +1 per accumulated frame). */
+    frame: d.F32;
+    /** Rays cast per texel THIS frame (a per-frame budget: burst on a change, fewer while refining). */
+    rays: d.F32;
+    /** Analytic SDF sub-props (the `_sa*` bundle). */
+    saRadius: d.F32;
+    saSides: d.F32;
+    saRounding: d.F32;
+    saInnerRatio: d.F32;
+    saRotation: d.F32;
+    saHeight: d.F32;
+    saOffset: d.F32;
+    saAperture: d.F32;
+    /** Volumetric field domain (the `_vf*` bundle). */
+    vfOriginX: d.F32;
+    vfOriginY: d.F32;
+    vfSpanX: d.F32;
+    vfSpanY: d.F32;
+    vfActiveRes: d.F32;
+    vfRBound: d.F32;
+}>;
+export declare const irradianceAnalyticLayout: import('typegpu').TgpuBindGroupLayout<{
+    params: {
+        uniform: d.WgslStruct<{
+            /** Shape placement (transformPosition-stored center). */
+            center: d.Vec2f;
+            /** The lights: position lanes in PLACEMENT (sdfUV) space, colour lanes (linear rgb, intensity in .w), live count. */
+            lightPos: d.WgslArray<d.Vec4f>;
+            lightColor: d.WgslArray<d.Vec4f>;
+            lightCount: d.F32;
+            scale: d.F32;
+            rotation: d.F32;
+            aspect: d.F32;
+            /** Gather controls. */
+            reach: d.F32;
+            wrap: d.F32;
+            lightRange: d.F32;
+            shadowSoftness: d.F32;
+            /** One device pixel in field units (hit threshold, minimum step). */
+            eps: d.F32;
+            /** Texels per side of the (square) irradiance texture. */
+            res: d.F32;
+            /** Progressive sample index (0 on a fresh scene, +1 per accumulated frame). */
+            frame: d.F32;
+            /** Rays cast per texel THIS frame (a per-frame budget: burst on a change, fewer while refining). */
+            rays: d.F32;
+            /** Analytic SDF sub-props (the `_sa*` bundle). */
+            saRadius: d.F32;
+            saSides: d.F32;
+            saRounding: d.F32;
+            saInnerRatio: d.F32;
+            saRotation: d.F32;
+            saHeight: d.F32;
+            saOffset: d.F32;
+            saAperture: d.F32;
+            /** Volumetric field domain (the `_vf*` bundle). */
+            vfOriginX: d.F32;
+            vfOriginY: d.F32;
+            vfSpanX: d.F32;
+            vfSpanY: d.F32;
+            vfActiveRes: d.F32;
+            vfRBound: d.F32;
+        }>;
+    };
+    outTex: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+export declare const irradianceSvgLayout: import('typegpu').TgpuBindGroupLayout<{
+    params: {
+        uniform: d.WgslStruct<{
+            /** Shape placement (transformPosition-stored center). */
+            center: d.Vec2f;
+            /** The lights: position lanes in PLACEMENT (sdfUV) space, colour lanes (linear rgb, intensity in .w), live count. */
+            lightPos: d.WgslArray<d.Vec4f>;
+            lightColor: d.WgslArray<d.Vec4f>;
+            lightCount: d.F32;
+            scale: d.F32;
+            rotation: d.F32;
+            aspect: d.F32;
+            /** Gather controls. */
+            reach: d.F32;
+            wrap: d.F32;
+            lightRange: d.F32;
+            shadowSoftness: d.F32;
+            /** One device pixel in field units (hit threshold, minimum step). */
+            eps: d.F32;
+            /** Texels per side of the (square) irradiance texture. */
+            res: d.F32;
+            /** Progressive sample index (0 on a fresh scene, +1 per accumulated frame). */
+            frame: d.F32;
+            /** Rays cast per texel THIS frame (a per-frame budget: burst on a change, fewer while refining). */
+            rays: d.F32;
+            /** Analytic SDF sub-props (the `_sa*` bundle). */
+            saRadius: d.F32;
+            saSides: d.F32;
+            saRounding: d.F32;
+            saInnerRatio: d.F32;
+            saRotation: d.F32;
+            saHeight: d.F32;
+            saOffset: d.F32;
+            saAperture: d.F32;
+            /** Volumetric field domain (the `_vf*` bundle). */
+            vfOriginX: d.F32;
+            vfOriginY: d.F32;
+            vfSpanX: d.F32;
+            vfSpanY: d.F32;
+            vfActiveRes: d.F32;
+            vfRBound: d.F32;
+        }>;
+    };
+    outTex: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+    sdfSource: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    samp: {
+        sampler: "filtering";
+    };
+}>;
+export declare const irradianceFieldLayout: import('typegpu').TgpuBindGroupLayout<{
+    params: {
+        uniform: d.WgslStruct<{
+            /** Shape placement (transformPosition-stored center). */
+            center: d.Vec2f;
+            /** The lights: position lanes in PLACEMENT (sdfUV) space, colour lanes (linear rgb, intensity in .w), live count. */
+            lightPos: d.WgslArray<d.Vec4f>;
+            lightColor: d.WgslArray<d.Vec4f>;
+            lightCount: d.F32;
+            scale: d.F32;
+            rotation: d.F32;
+            aspect: d.F32;
+            /** Gather controls. */
+            reach: d.F32;
+            wrap: d.F32;
+            lightRange: d.F32;
+            shadowSoftness: d.F32;
+            /** One device pixel in field units (hit threshold, minimum step). */
+            eps: d.F32;
+            /** Texels per side of the (square) irradiance texture. */
+            res: d.F32;
+            /** Progressive sample index (0 on a fresh scene, +1 per accumulated frame). */
+            frame: d.F32;
+            /** Rays cast per texel THIS frame (a per-frame budget: burst on a change, fewer while refining). */
+            rays: d.F32;
+            /** Analytic SDF sub-props (the `_sa*` bundle). */
+            saRadius: d.F32;
+            saSides: d.F32;
+            saRounding: d.F32;
+            saInnerRatio: d.F32;
+            saRotation: d.F32;
+            saHeight: d.F32;
+            saOffset: d.F32;
+            saAperture: d.F32;
+            /** Volumetric field domain (the `_vf*` bundle). */
+            vfOriginX: d.F32;
+            vfOriginY: d.F32;
+            vfSpanX: d.F32;
+            vfSpanY: d.F32;
+            vfActiveRes: d.F32;
+            vfRBound: d.F32;
+        }>;
+    };
+    outTex: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+    silhouetteTex: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    samp: {
+        sampler: "filtering";
+    };
+}>;
+type Layout = typeof irradianceAnalyticLayout | typeof irradianceSvgLayout | typeof irradianceFieldLayout;
+/** A signed-distance source in placement (sdfUV) space. */
+type FieldFn = (uv: d.v2f) => number;
+/** Analytic source: the baked SDF fn for `shapeType`, sub-props from params. */
+export declare function analyticField(shapeType: string): FieldFn;
+/**
+ * SVG source: hardware-bilinear sample of the SDF data texture (exact inside its unit square),
+ * continued beyond it with a sphere-trace-safe LOWER bound. `border + beyond` — the obvious
+ * continuation — is an UPPER bound (triangle inequality), and a march through an upper bound
+ * overshoots and skips the shape, differently on each side of the square's edge lines. The shape
+ * lives inside the square, so `beyond` (distance to the square) is a lower bound, and so is
+ * `border − beyond` (reverse triangle inequality); their max is tight where the border is far from
+ * the outline and safe where it touches it.
+ */
+export declare const svgField: FieldFn;
+/**
+ * Volumetric source: the shape's SILHOUETTE distance field — the exact 2D signed distance to the
+ * marched outline, jump-flooded over the marched domain (see below) — sampled bilinearly, and
+ * outside the domain the largest of three sphere-trace-safe lower bounds (distance to the domain,
+ * distance to the bounding circle, the border's silhouette distance less the distance to it).
+ *
+ * Why not the marched field's own `.r`: outside the silhouette it holds the minimum 3D distance
+ * met along the view ray, which is ≥ the projected 2D distance — an UPPER bound that a 2D march
+ * overshoots through (accurate beside the shape where the ray samples densely at its depth, badly
+ * inflated toward the domain edges where the ray misses the bounding sphere).
+ */
+export declare const volumetricField: FieldFn;
+export declare const SilhouetteParams: d.WgslStruct<{
+    vfOriginX: d.F32;
+    vfOriginY: d.F32;
+    vfSpanX: d.F32;
+    vfSpanY: d.F32;
+    vfActiveRes: d.F32;
+    vfRBound: d.F32;
+    /** Texels per side of the silhouette texture. */
+    res: d.F32;
+    /** Jump-flood step for this pass, in texels. */
+    step: d.F32;
+}>;
+export declare const silhouetteSeedLayout: import('typegpu').TgpuBindGroupLayout<{
+    params: {
+        uniform: d.WgslStruct<{
+            vfOriginX: d.F32;
+            vfOriginY: d.F32;
+            vfSpanX: d.F32;
+            vfSpanY: d.F32;
+            vfActiveRes: d.F32;
+            vfRBound: d.F32;
+            /** Texels per side of the silhouette texture. */
+            res: d.F32;
+            /** Jump-flood step for this pass, in texels. */
+            step: d.F32;
+        }>;
+    };
+    fieldTex: {
+        texture: d.WgslTexture2d<d.F32>;
+        sampleType: string;
+    };
+    out: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+export declare const silhouetteStepLayout: import('typegpu').TgpuBindGroupLayout<{
+    params: {
+        uniform: d.WgslStruct<{
+            vfOriginX: d.F32;
+            vfOriginY: d.F32;
+            vfSpanX: d.F32;
+            vfSpanY: d.F32;
+            vfActiveRes: d.F32;
+            vfRBound: d.F32;
+            /** Texels per side of the silhouette texture. */
+            res: d.F32;
+            /** Jump-flood step for this pass, in texels. */
+            step: d.F32;
+        }>;
+    };
+    src: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    out: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+/** Seed: boundary texels seed themselves (distance 0); others start "no seed" (x < 0, far). */
+export declare const silhouetteSeedKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/** One jump-flood pass: adopt the nearest seed among the 3×3 neighbours at `step` texels. */
+export declare const silhouetteStepKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+export interface IrradianceKernelOptions {
+    /** Sphere-trace step cap per ray. */
+    steps: number;
+    /** Shadow-ray step cap (0 = no shadow rays). */
+    shadowSteps: number;
+    namePrefix: string;
+}
+/**
+ * The gather kernel over `layout`, reading the field through `fieldAt`. Per texel: map to screen
+ * UV → placement UV; texels inside the shape are pushed to just outside the boundary so bilinear
+ * upsampling across the silhouette has valid neighbours; then the stratified ray fan (see the module
+ * header) with the point light's Lambert × inverse-square × shadow-ray visibility at each hit; the
+ * mean (rgb — every light's colour lands where it falls), faded toward `reach`, is stored
+ * premultiplied by the outside mask (`.rgb` = E·m, `.a` = m). The estimate is noisy per texel by
+ * design — read the result through the denoise blur, never raw, and divide `.rgb` by `.a`.
+ */
+export declare function buildIrradianceKernel(layout: Layout, fieldAt: FieldFn, opts: IrradianceKernelOptions): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+/** The gather kernel as a guarded 2D compute pass over the res×res irradiance texture. */
+export declare function createIrradiancePass(root: TgpuRoot, kernel: (cx: number, cy: number) => void, opts: {
+    res: number;
+    bindGroup: unknown;
+}): KitComputePipeline;
+export declare const AccumulateParams: d.WgslStruct<{
+    /** Blend weight of the new sample: 1 replaces, 1/(n+1) is the running mean. */
+    weight: d.F32;
+}>;
+export declare const accumulateLayout: import('typegpu').TgpuBindGroupLayout<{
+    sample: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    prev: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    out: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            /** Blend weight of the new sample: 1 replaces, 1/(n+1) is the running mean. */
+            weight: d.F32;
+        }>;
+    };
+}>;
+/** `out = prev + (sample − prev) · weight` — the running mean of a progressive estimate. */
+export declare const accumulateKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+export declare const copyLayout: import('typegpu').TgpuBindGroupLayout<{
+    src: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+    out: {
+        readonly storageTexture: d.WgslStorageTexture2d<"rgba16float", string>;
+    };
+}>;
+/** Texture copy (the accumulation's write target back to its read source for the next frame). */
+export declare const copyKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+export {};
+//# sourceMappingURL=radiance.d.ts.map

package/dist/core/gpu/scaffolds/radiance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radiance.d.ts","sourceRoot":"","sources":["../../../src/gpu/scaffolds/radiance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAO,CAAC,EAAe,MAAM,cAAc,CAAA;AAIlD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAA;AACrC,OAAO,EAAuB,KAAK,kBAAkB,EAAC,MAAM,YAAY,CAAA;AAIxE,yFAAyF;AACzF,eAAO,MAAM,iBAAiB,EAAG,aAAsB,CAAA;AAEvD,4GAA4G;AAC5G,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,wDAAwD;AACxD,eAAO,MAAM,gBAAgB;IACzB,yDAAyD;;IAEzD,qHAAqH;;;;;;;IAOrH,uBAAuB;;;;;IAKvB,qEAAqE;;IAErE,0DAA0D;;IAE1D,+EAA+E;;IAE/E,oGAAoG;;IAEpG,kDAAkD;;;;;;;;;IAGlD,mDAAmD;;;;;;;EAErD,CAAA;AAIF,eAAO,MAAM,wBAAwB;;;YA/BjC,yDAAyD;;YAEzD,qHAAqH;;;;;;;YAOrH,uBAAuB;;;;;YAKvB,qEAAqE;;YAErE,0DAA0D;;YAE1D,+EAA+E;;YAE/E,oGAAoG;;YAEpG,kDAAkD;;;;;;;;;YAGlD,mDAAmD;;;;;;;;;;;;EASrD,CAAA;AACF,eAAO,MAAM,mBAAmB;;;YAnC5B,yDAAyD;;YAEzD,qHAAqH;;;;;;;YAOrH,uBAAuB;;;;;YAKvB,qEAAqE;;YAErE,0DAA0D;;YAE1D,+EAA+E;;YAE/E,oGAAoG;;YAEpG,kDAAkD;;;;;;;;;YAGlD,mDAAmD;;;;;;;;;;;;;;;;;;EAerD,CAAA;AACF,eAAO,MAAM,qBAAqB;;;YAzC9B,yDAAyD;;YAEzD,qHAAqH;;;;;;;YAOrH,uBAAuB;;;;;YAKvB,qEAAqE;;YAErE,0DAA0D;;YAE1D,+EAA+E;;YAE/E,oGAAoG;;YAEpG,kDAAkD;;;;;;;;;YAGlD,mDAAmD;;;;;;;;;;;;;;;;;;EAwBrD,CAAA;AAEF,KAAK,MAAM,GAAG,OAAO,wBAAwB,GAAG,OAAO,mBAAmB,GAAG,OAAO,qBAAqB,CAAA;AAEzG,2DAA2D;AAC3D,KAAK,OAAO,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,MAAM,CAAA;AAsBpC,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAOxD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,OAK6B,CAAA;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,OAoB6B,CAAA;AAW3D,eAAO,MAAM,gBAAgB;;;;;;;IAEzB,iDAAiD;;IAEjD,gDAAgD;;EAElD,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;YAN7B,iDAAiD;;YAEjD,gDAAgD;;;;;;;;;;;EAQlD,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;YAZ7B,iDAAiD;;YAEjD,gDAAgD;;;;;;;;;;EAclD,CAAA;AAaF,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,4DAmBP,CAAA;AAE1B,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,4DAuBP,CAAA;AAE1B,MAAM,WAAW,uBAAuB;IACpC,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,uBAAuB,8DAoHpG;AAED,0FAA0F;AAC1F,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,EACxC,IAAI,EAAE;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC,GACxC,kBAAkB,CAEpB;AAID,eAAO,MAAM,gBAAgB;IACzB,+EAA+E;;EAEjF,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;YAJzB,+EAA+E;;;;EASjF,CAAA;AAEF,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,4DAQG,CAAA;AAEhC,eAAO,MAAM,UAAU;;;;;;;EAGrB,CAAA;AAEF,iGAAiG;AACjG,eAAO,MAAM,UAAU,4DAIG,CAAA"}

package/dist/core/gpu/scaffolds/sdfShape.d.ts

@@ -1,4 +1,4 @@
-import { GpuShaderDefinition } from '../contract';
+import { Expr, GpuShaderDefinition } from '../contract';
 import { BoundingBoxBindingType, BoundingBoxDeclaration, ComponentProps, PropConfig } from '../../types';
 import { shapeStrokeProps } from '../../utilities/propConfigs';
 
@@ -39,22 +39,14 @@ export interface SdfShapeShaderSpec {
     /** Defaults to `'Shapes'`. */
     category?: string;
     /**
-     * The `'use gpu'` mask body fn, defined in the shader file (see the file header for the
-     * template and the argument-order contract). Returns a `sdf.ShapeMask`.
+     * The shape's geometry, as algebra over the shape-local frame (aspect-corrected, centered,
+     * rotated — y grows downward like the SDF kit). `u(name)` reads a prop uniform. Returns the
+     * signed distance; the factory applies the fill/stroke/softness mask.
      */
-    shapeFn: unknown;
-    /**
-     * The `call` hint for `shapeFn` — must stay equal to the fn's emitted WGSL name (`'starShape'`),
-     * because that name appears in the WGSL snapshots.
-     */
-    shapeFnName: string;
-    /**
-     * The uniform prop names `shapeFn` takes between `center` and `softness`, in BODY order —
-     * including `rotation` for a rotatable shape. This is a separate list from `shapeProps` because
-     * the two orders can differ (Trapezoid declares `bottomWidth, topWidth, height` but its body
-     * takes `topWidth, bottomWidth, height`).
-     */
-    bodyArgs: string[];
+    distance: (local: {
+        x: Expr;
+        y: Expr;
+    }, u: (name: string) => Expr) => Expr;
     /** The `color` prop's description ("Fill color of the star"). */
     colorDescription: string;
     /** The `center` prop's description ("Center position of the star"). */

package/dist/core/gpu/scaffolds/sdfShape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdfShape.d.ts","sourceRoot":"","sources":["../../../src/gpu/scaffolds/sdfShape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,OAAO,KAAK,EAA0B,mBAAmB,EAAC,MAAM,aAAa,CAAA;AAG7E,OAAO,KAAK,EACR,sBAAsB,EACtB,sBAAsB,EAEtB,cAAc,EACd,UAAU,EACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EAIH,gBAAgB,EACnB,MAAM,6BAA6B,CAAA;AAEpC;;;;;GAKG;AAEH,KAAK,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GACpB;IAAC,IAAI,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,sBAAsB,CAAA;KAAC,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAC,GACpF;IAAC,MAAM,EAAE,sBAAsB,CAAC;IAAC,IAAI,CAAC,EAAE,KAAK,CAAA;CAAC,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAA;IAElB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,CAAA;IACxB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,CAAA;IACzB,yFAAyF;IACzF,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAEzC,4GAA4G;IAC5G,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,6EAA6E;IAC7E,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B,MAAM,EAAE,cAAc,CAAA;IAEtB,sFAAsF;IACtF,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/C,6DAA6D;IAC7D,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAE9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC7C;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAuDD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EAC1E,IAAI,EAAE,kBAAkB,GACzB,mBAAmB,CAAC,CAAC,CAAC,CA8CxB"}
+{"version":3,"file":"sdfShape.d.ts","sourceRoot":"","sources":["../../../src/gpu/scaffolds/sdfShape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAC,IAAI,EAAqB,mBAAmB,EAAC,MAAM,aAAa,CAAA;AAG7E,OAAO,KAAK,EACR,sBAAsB,EACtB,sBAAsB,EAEtB,cAAc,EACd,UAAU,EACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EAIH,gBAAgB,EACnB,MAAM,6BAA6B,CAAA;AAEpC;;;;;GAKG;AAEH,KAAK,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;AAEpC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GACpB;IAAC,IAAI,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,sBAAsB,CAAA;KAAC,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAC,GACpF;IAAC,MAAM,EAAE,sBAAsB,CAAC;IAAC,IAAI,CAAC,EAAE,KAAK,CAAA;CAAC,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;OAIG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAC,CAAC,EAAE,IAAI,CAAC;QAAC,CAAC,EAAE,IAAI,CAAA;KAAC,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,IAAI,CAAA;IAExE,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,CAAA;IACxB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,CAAA;IACzB,yFAAyF;IACzF,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAEzC,4GAA4G;IAC5G,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,6EAA6E;IAC7E,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B,MAAM,EAAE,cAAc,CAAA;IAEtB,sFAAsF;IACtF,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/C,6DAA6D;IAC7D,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAE9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC7C;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAuDD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EAC1E,IAAI,EAAE,kBAAkB,GACzB,mBAAmB,CAAC,CAAC,CAAC,CA8CxB"}

package/dist/core/gpu/transforms.d.ts

@@ -1,8 +1,9 @@
 import { transformBoolean, transformAngle, transformEdges, transformColorSpace, transformStrokePosition, PositionAxisInput } from '../utilities/transformations';
 import { colorStopsTransform } from '../utilities/colorStops';
+import { listPropTransform } from '../utilities/listProps';
 import * as d from 'typegpu/data';
 export { transformBoolean, transformAngle, transformEdges, transformColorSpace, transformStrokePosition };
-export { colorStopsTransform };
+export { colorStopsTransform, listPropTransform };
 export type { PositionAxisInput };
 export declare function setColorSpaceModeGpu(mode: 'p3-linear' | 'srgb'): void;
 export declare function getColorSpaceModeGpu(): 'p3-linear' | 'srgb';