shaders 3.1.462 → 3.2.464

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

@@ -0,0 +1,485 @@
+import { d } from '../kit';
+import { KitComputePipeline } from '../compute';
+import { TgpuRoot } from 'typegpu';
+
+/** A 2D-dispatched cell kernel over a grid. */
+export type GridKernel = (cx: number, cy: number) => void;
+/**
+ * One kernel as a guarded compute pass. The general form of `createFluidKernelPass`: `size` is
+ * optional (a dynamically-dispatched pass passes none and drives `dispatchThreads` itself), and
+ * non-square grids are allowed.
+ */
+export declare function createGridKernelPass(root: TgpuRoot, kernel: GridKernel, opts?: {
+    size?: [number, number];
+    bindGroup?: unknown;
+}): KitComputePipeline;
+/**
+ * Per-cell drive from a sampled texture (the "style map"): the texture's luminance — shaped by
+ * contrast/threshold/invert and weighted by alpha coverage — shifts the reaction's operating point
+ * per cell. Ranges clamp the shifted point inside the caller's stable band.
+ */
+export interface ReactionDriveOptions {
+    /** Contrast slider 0..1 → luma gain 1..(1+contrastMax). */
+    contrastMax: number;
+    /** Max feed shift the drive can apply. */
+    dFeed: number;
+    /** Max kill shift the drive can apply. */
+    dKill: number;
+    feedMin: number;
+    feedMax: number;
+    killMin: number;
+    killMax: number;
+}
+export interface GrayScottOptions {
+    /** Grid resolution per axis (the kernel is dispatched 2D over n×n). */
+    n: number;
+    namePrefix: string;
+    /** Spatially bias feed/kill from a sampled drive texture (adds `driveTex` to the layout). */
+    drive?: ReactionDriveOptions;
+}
+declare const grayScottParamsSchema: () => d.WgslStruct<{
+    feed: d.F32;
+    kill: d.F32;
+    dv: d.F32;
+    brushRadSq: d.F32;
+    brushStrength: d.F32;
+    cursorX: d.F32;
+    cursorY: d.F32;
+    cursorActive: d.F32;
+    driveInfluence: d.F32;
+    driveContrast: d.F32;
+    driveThreshold: d.F32;
+    driveInvert: d.F32;
+    driveMapX: d.F32;
+    driveMapY: d.F32;
+    _pad0: d.F32;
+    _pad1: d.F32;
+}>;
+type GrayScottParamsSchema = ReturnType<typeof grayScottParamsSchema>;
+declare const makeGrayScottPlainLayout: (n: number, Params: GrayScottParamsSchema) => import('typegpu').TgpuBindGroupLayout<{
+    readBuf: {
+        storage: d.WgslArray<d.Vec2f>;
+        access: "readonly";
+    };
+    writeBuf: {
+        storage: d.WgslArray<d.Vec2f>;
+        access: "mutable";
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            feed: d.F32;
+            kill: d.F32;
+            dv: d.F32;
+            brushRadSq: d.F32;
+            brushStrength: d.F32;
+            cursorX: d.F32;
+            cursorY: d.F32;
+            cursorActive: d.F32;
+            driveInfluence: d.F32;
+            driveContrast: d.F32;
+            driveThreshold: d.F32;
+            driveInvert: d.F32;
+            driveMapX: d.F32;
+            driveMapY: d.F32;
+            _pad0: d.F32;
+            _pad1: d.F32;
+        }>;
+    };
+}>;
+declare const makeGrayScottDriveLayout: (n: number, Params: GrayScottParamsSchema) => import('typegpu').TgpuBindGroupLayout<{
+    readBuf: {
+        storage: d.WgslArray<d.Vec2f>;
+        access: "readonly";
+    };
+    writeBuf: {
+        storage: d.WgslArray<d.Vec2f>;
+        access: "mutable";
+    };
+    params: {
+        uniform: d.WgslStruct<{
+            feed: d.F32;
+            kill: d.F32;
+            dv: d.F32;
+            brushRadSq: d.F32;
+            brushStrength: d.F32;
+            cursorX: d.F32;
+            cursorY: d.F32;
+            cursorActive: d.F32;
+            driveInfluence: d.F32;
+            driveContrast: d.F32;
+            driveThreshold: d.F32;
+            driveInvert: d.F32;
+            driveMapX: d.F32;
+            driveMapY: d.F32;
+            _pad0: d.F32;
+            _pad1: d.F32;
+        }>;
+    };
+    driveTex: {
+        texture: d.WgslTexture2d<d.F32>;
+    };
+}>;
+export type GrayScottPlainLayout = ReturnType<typeof makeGrayScottPlainLayout>;
+export type GrayScottDriveLayout = ReturnType<typeof makeGrayScottDriveLayout>;
+/**
+ * The Gray-Scott reaction + brush-injection step over a vec2f (U,V) cell state.
+ *
+ * 9-point weighted Laplacian (0.2 orthogonal, 0.05 diagonal, −1 centre) with reflective NO-FLUX
+ * boundaries via clamp-to-edge neighbour fetch. Du folds to 1 (the stability ceiling for this
+ * explicit scheme), dt folds to 1 (evolution speed is the per-frame iteration count); Dv arrives
+ * as the `dv` uniform. A soft Gaussian brush ADDS V around the cursor while `cursorActive > 0`
+ * (a uniform → coherent branch, no divergence). With `drive`, the drive texture's shaped luminance
+ * shifts feed up / kill down along the density axis per cell.
+ *
+ * The uniform struct is written IN FULL each frame (16 f32 — trailing pads keep it at a multiple
+ * of 16 bytes). The drive members are dead-but-present in the driveless variant so one write path
+ * serves both.
+ */
+export declare function buildGrayScottStep(opts: GrayScottOptions & {
+    drive: ReactionDriveOptions;
+}): {
+    layout: GrayScottDriveLayout;
+    Params: GrayScottParamsSchema;
+    kernel: GridKernel;
+};
+export declare function buildGrayScottStep(opts: GrayScottOptions & {
+    drive?: undefined;
+}): {
+    layout: GrayScottPlainLayout;
+    Params: GrayScottParamsSchema;
+    kernel: GridKernel;
+};
+/**
+ * Scatter seed for a vec2f (U,V) cell state: U=1 everywhere, a hash-scattered V=1 seed at
+ * `density`. Integer bitcast hash — cell coords reach large-grid extents, where the classic
+ * sin-fract hash streaks on iOS Metal.
+ */
+export declare function buildScatterSeedKernel(opts: {
+    n: number;
+    density: number;
+    namePrefix: string;
+}): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        stateBuf: {
+            storage: d.WgslArray<d.Vec2f>;
+            access: "mutable";
+        };
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+/** Publish a vec2f cell state into a sampled texture (`.rg` = the pair) the fragment reads. */
+export declare function buildPairPublishKernel(opts: {
+    n: number;
+    format: 'rgba16float' | 'rgba32float';
+    namePrefix: string;
+}): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        srcBuf: {
+            storage: d.WgslArray<d.Vec2f>;
+            access: "readonly";
+        };
+        outTex: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+/**
+ * Aspect-corrected radial brush weight over an n-cell grid: 1 at the cursor centre → 0 past the
+ * radius, with `falloff` softening the edge. Memoized per grid size (one WGSL fn per n).
+ */
+export declare function makeAspectBrushWeight(n: number): import('typegpu').TgpuFn<(cxf: d.F32, cyf: d.F32, mouseX: d.F32, mouseY: d.F32, radius: d.F32, falloff: d.F32, aspect: d.F32) => d.F32>;
+export interface OddEvenSortOptions {
+    /** Grid resolution per axis. */
+    n: number;
+    format: 'rgba16float' | 'rgba32float';
+    namePrefix: string;
+    /** Sort along the vertical axis (columns) instead of horizontal (rows). */
+    vertical: boolean;
+    /** Sort order along the axis: +1 ascending key, −1 descending. */
+    direction: 1 | -1;
+}
+/**
+ * The odd-even transposition sort kernel set over a persistent per-cell DISPLACEMENT map.
+ *
+ * State is a per-cell f32 offset from identity along the sort axis (so `decay` can melt cells back
+ * home); the sort key is cached once per frame by the `key` prepass (input luminance, unpremultiplied)
+ * and lerped at fractional coordinates (luma is linear in RGB → lerp-of-luma == luma-of-lerp). Each
+ * compare-swap pass alternates parity; both members of a pair derive the same exchange decision from
+ * the same two cached keys → lock-free consistent swap. Swaps are gated by an aspect-corrected brush
+ * around the cursor, dithered per cell for a soft edge. The publish kernel writes the normalised
+ * source coordinate along the axis into the state texture the fragment remaps with.
+ */
+export declare function buildOddEvenSortSet(opts: OddEvenSortOptions): {
+    lumaLayout: import('typegpu').TgpuBindGroupLayout<{
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        lumaBuf: {
+            storage: d.WgslArray<d.F32>;
+            access: "mutable";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+            }>;
+        };
+    }>;
+    LumaParams: d.WgslStruct<{
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+    }>;
+    swapLayout: import('typegpu').TgpuBindGroupLayout<{
+        readBuf: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        writeBuf: {
+            storage: d.WgslArray<d.F32>;
+            access: "mutable";
+        };
+        lumaBuf: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                mouseX: d.F32;
+                mouseY: d.F32;
+                radius: d.F32;
+                falloff: d.F32;
+                decay: d.F32;
+                aspect: d.F32;
+                seed: d.F32;
+            }>;
+        };
+    }>;
+    SwapParams: d.WgslStruct<{
+        mouseX: d.F32;
+        mouseY: d.F32;
+        radius: d.F32;
+        falloff: d.F32;
+        decay: d.F32;
+        aspect: d.F32;
+        seed: d.F32;
+    }>;
+    outputLayout: import('typegpu').TgpuBindGroupLayout<{
+        srcBuf: {
+            storage: d.WgslArray<d.F32>;
+            access: "readonly";
+        };
+        stateTex: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+    }>;
+    key: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    swap0: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    swap1: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    output: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+/**
+ * Frame-difference motion mask: how much a pixel changed since last frame, smoothstepped over
+ * [threshold, 2·threshold] into a 0–1 stamp weight. Premultiplied RGB luma difference + alpha
+ * difference, so both colour motion (opaque footage) and coverage motion (moving shapes) trigger.
+ */
+export declare const frameDiffMask: import('typegpu').TgpuFn<(live: d.Vec4f, prev: d.Vec4f, threshold: d.F32) => d.F32>;
+/** Rotate an RGB colour's hue by `amount` turns (via HSL). */
+export declare const hueRotateTurns: import('typegpu').TgpuFn<(rgb: d.Vec3f, amount: d.F32) => d.Vec3f>;
+export interface FeedbackTrailOptions {
+    /** State resolution per axis. */
+    res: number;
+    format: 'rgba16float' | 'rgba32float';
+    namePrefix: string;
+    /** What sheds the trail: frame-difference motion, or the live frame's alpha coverage. */
+    source: 'motion' | 'alpha';
+    /** Rotate the decayed trail's hue a touch each frame (compounds → a spectrum down the trail). */
+    hueCycle: boolean;
+    /** Tent-blur half-offset in UV at diffusion 1 (small — it compounds every frame). */
+    diffuseHalfUv: number;
+    /** Drift prop (−1..1) → UV per second before the dt scale. */
+    driftScale: number;
+}
+/**
+ * One feedback-trail state step: advect the previous accumulation (zoom about centre + drift),
+ * soften it with a four-tap bilinear tent, fade it by `persistence`, optionally hue-cycle it, then
+ * stamp the live frame back on top (source-over alpha; screen/add RGB variants for light-painting).
+ *
+ * Motion source gates the stamp by the frame-difference mask and writes the display copy BEFORE
+ * the stamp (ghosts only — the fragment lays them over the live frame); it ping-pongs a prev-live
+ * copy through `prevLive`/`prevLiveOut`. Alpha source stamps unconditionally, publishes the
+ * stamped state, and never touches the prev-live pair (bind 1×1 stubs).
+ *
+ * Params ABI (runtime surface): persistence, diffusion, driftX, driftY, dt, zoom, hueRate,
+ * blendMode (0 normal · 1 screen · 2 add), motionThreshold.
+ */
+export declare function buildFeedbackTrailStep(opts: FeedbackTrailOptions): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        src: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        prev: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        next: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        display: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        prevLive: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        prevLiveOut: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        samp: {
+            sampler: "filtering";
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                persistence: d.F32;
+                diffusion: d.F32;
+                driftX: d.F32;
+                driftY: d.F32;
+                dt: d.F32;
+                zoom: d.F32;
+                hueRate: d.F32;
+                blendMode: d.F32;
+                motionThreshold: d.F32;
+            }>;
+        };
+    }>;
+    Params: d.WgslStruct<{
+        persistence: d.F32;
+        diffusion: d.F32;
+        driftX: d.F32;
+        driftY: d.F32;
+        dt: d.F32;
+        zoom: d.F32;
+        hueRate: d.F32;
+        blendMode: d.F32;
+        motionThreshold: d.F32;
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+export interface MacroblockAdvectOptions {
+    /** State resolution per axis. */
+    res: number;
+    format: 'rgba16float' | 'rgba32float';
+    namePrefix: string;
+    /** Coarse-lattice block scale multiplier and the hash fraction picked coarse. */
+    blockMix?: {
+        coarseScale: number;
+        coarsePick: number;
+    };
+    /** Held-pixel generation loss: quantize levels, quantize blend amount, per-frame energy decay. */
+    generationLoss?: {
+        levels: number;
+        amount: number;
+        decay: number;
+    };
+}
+/**
+ * One decode step of a macroblock hold/refresh advection — what a video decoder does when P-frame
+ * motion vectors keep arriving after the I-frame was dropped. Each state texel picks its
+ * macroblock (two mixed scales re-rolled on a slow lattice clock), advances the block's OWN
+ * hash-phased epoch clock (no global heartbeat — blocks lock, drift and recover independently),
+ * decides held vs fresh against a drifting product-wave corruption field, then either advects the
+ * previous state along the block's flow-field motion vector (bilinear, with subtle generation
+ * loss + residual re-key back toward the live source) or re-keys from the live input (bilinear).
+ * Off-canvas advection sources re-key (a clamped source would conveyor-belt the border colour).
+ *
+ * The block hash chain is a ladder of shared intermediates read by every later stage — it does not
+ * split into smaller parts without recomputing rungs. Params ABI: time, dt, seed, intensity,
+ * blockSize, drift, churn.
+ */
+export declare function buildMacroblockAdvectKernel(opts: MacroblockAdvectOptions): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        src: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        prev: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        next: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        display: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                time: d.F32;
+                dt: d.F32;
+                seed: d.F32;
+                intensity: d.F32;
+                blockSize: d.F32;
+                drift: d.F32;
+                churn: d.F32;
+            }>;
+        };
+    }>;
+    Params: d.WgslStruct<{
+        time: d.F32;
+        dt: d.F32;
+        seed: d.F32;
+        intensity: d.F32;
+        blockSize: d.F32;
+        drift: d.F32;
+        churn: d.F32;
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+};
+/**
+ * The JPEG block colour for one cell: forward separable DCT (rows→columns) over a 64-sample RGB
+ * block → IJG-table quantize at `quality` (the IJG curve `qScale = q<50 ? 5000/q : 200−2q`) →
+ * inverse DCT at `(localX, localY)`, keeping `nLuma` low-frequency luma coefficients; chroma is
+ * DC-only (a flat colour per block). Pure — the caller samples the block. Memoized per nLuma.
+ */
+export declare function makeJpegBlockRgb(nLuma: number): import('typegpu').TgpuFn<(block: d.WgslArray<d.Vec3f>, localX: d.F32, localY: d.F32, quality: d.F32) => d.Vec3f>;
+export interface BlockQuantizeOptions {
+    /** Low-frequency luma coefficients kept per channel. */
+    nLuma: number;
+    /** Device pixels per cell (the 8×8 block spans 8·scaleN px, sampled at stride scaleN). */
+    scaleN: number;
+    format: 'rgba16float' | 'rgba32float';
+    namePrefix: string;
+}
+/**
+ * The block-quantize pass: one thread per scaleN×scaleN device-pixel cell samples its 8×8 block
+ * from the input texture (point `textureLoad`, unpremultiplied), runs the DCT block colour, and
+ * writes it into the cell texture. Dispatch the active cell grid dynamically; the guarded pipeline
+ * bounds-checks. Params ABI: inputWidth, inputHeight, quality.
+ */
+export declare function buildBlockQuantizeGraph(opts: BlockQuantizeOptions): {
+    layout: import('typegpu').TgpuBindGroupLayout<{
+        input: {
+            texture: d.WgslTexture2d<d.F32>;
+        };
+        cellTex: {
+            storageTexture: d.WgslStorageTexture2d<"rgba16float" | "rgba32float", string>;
+        };
+        params: {
+            uniform: d.WgslStruct<{
+                inputWidth: d.F32;
+                inputHeight: d.F32;
+                quality: d.F32;
+            }>;
+        };
+    }>;
+    kernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
+    Params: d.WgslStruct<{
+        inputWidth: d.F32;
+        inputHeight: d.F32;
+        quality: d.F32;
+    }>;
+};
+/**
+ * Colour a packed flow field by direction: five smoothing-cross taps (r,g = flow vector, b =
+ * density) → a blend of the four per-direction colours weighted by the smoothed flow direction,
+ * faded to `base` where flow is weak and to transparent where density is low.
+ */
+export declare const flowDirectionColor: import('typegpu').TgpuFn<(s0: d.Vec4f, s1: d.Vec4f, s2: d.Vec4f, s3: d.Vec4f, s4: d.Vec4f, base: d.Vec4f, up: d.Vec4f, down: d.Vec4f, left: d.Vec4f, right: d.Vec4f) => d.Vec4f>;
+export {};
+//# sourceMappingURL=gridKernels.d.ts.map

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

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