import { GpuFragmentParams } from '../../gpu/contract';
import { d } from '../../gpu/kit/index';
import { GridSimConfig, GridRoot } from '../sim/grids';
import { PropRef } from '../values';

export declare const SPLAT_MIN_GRID = 8;
export declare const SPLAT_MAX_GRID = 128;
/** The effective (clamped, floored) splat grid resolution — the shader's recompile key. */
export declare const clampSplatGridSize: (v: number) => number;
/** Splat update kernel factory (grid size baked): per-cell dissipation + Gaussian cursor-velocity
 *  splat + clamp. No neighbour reads → single buffer, no ping-pong. Every cell updated. */
export declare function makeSplatUpdateKernel(gridSize: number): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
/** Splat output kernel factory (grid size baked): copy the per-cell displacement into RG. */
export declare function makeSplatOutputKernel(gridSize: number): import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
/**
 * The pointer-splat field sim: a mouse-driven grid displacement field on a single vec4 state
 * buffer (createStateBuffer; WebGPU zero-inits → flat), as the std grid pipeline:
 * cursor-velocity smoothing → settle gate → params write → the in-place update pass (dissipate +
 * splat + clamp, one fused kernel) → the output publish under `slots.output`. CHILD-INDEPENDENT
 * (no bindInputs). The grid resolution is baked per-compose from `slots.gridSize` (kernel
 * factories) — pair that prop with a `clampSplatGridSize` recompile rule.
 */
export declare function pointerSplatField(slots: {
    gridSize: PropRef;
    decay: PropRef;
    intensity: PropRef;
    radius: PropRef;
    output: string;
}): (params: GpuFragmentParams, root: GridRoot) => GridSimConfig;
/** Spring-lattice step (4 structural + 4 shear springs + return-to-rest, semi-implicit Euler,
 *  cursor impulse injection). 2D-dispatched with the interior border guard. */
export declare const springLatticeKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
/** Copy the displacement (xy) of the current buffer into the RG displacement texture. */
export declare const springLatticeOutputKernel: import('typegpu').TgpuFn<(cx: d.U32, cy: d.U32) => d.Void>;
/**
 * The spring-lattice field sim: a spring-mass cloth over two ping-pong vec4 state buffers
 * (createStateBuffer; WebGPU zero-inits → the cloth starts at rest), as the std grid pipeline:
 * cursor-impulse tracking → settle gate → params write → 2 fixed substeps (A→B, B→A — A is
 * always current, B is scratch, so the bind groups are fixed) → output publish from A under
 * `slots.output`. CHILD-INDEPENDENT → no bindInputs. NB: no childNode guard — in the analytic
 * uvRemap fold path the composer passes childNode=undefined (the child is folded, not sampled);
 * the sim must still run there so `uvRemap` can read its displacement.
 */
export declare function springLatticeField(slots: {
    stiffness: PropRef;
    damping: PropRef;
    radius: PropRef;
    output: string;
}): (params: GpuFragmentParams, root: GridRoot) => GridSimConfig;
//# sourceMappingURL=pointerFields.d.ts.map