import { d } from './index';

/** Aspect-corrected screen plane: `vec2(uv.x · aspect, uv.y)` (guarded divide). */
export declare const aspectPlane: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f) => d.Vec2f>;
/**
 * The RAW-divide exponential-scale framing (Scratches' historical domain): like
 * `fields.aspectScaledDomain` but with an unguarded `viewport.x / viewport.y`, preserving the
 * shader's exact arithmetic.
 */
export declare const rawAspectScaledDomain: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, scale: d.F32, seed: d.F32) => d.Vec2f>;
/**
 * The rotated fractal framing: aspect-correct, centre on the canvas midpoint, rotate by
 * `angle` (degrees).
 */
export declare const rotatedCenteredDomain: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, angle: d.F32) => d.Vec2f>;
/**
 * Flow-speed magnitude of the divergence-free 2D curl field, √2-normalized
 * (`length(curl22z(pos, z)) / 1.414`) so it reads as a [0,1]-ish swirling intensity. `z` is the
 * evolution phase (a scaled time). Hash-based → GPU-only.
 */
export declare const curlMagnitude: import('typegpu').TgpuFn<(pos: d.Vec2f, z: d.F32) => d.F32>;
/**
 * The fBm accumulation stage: run the gated golden-angle octave sum over MaterialX simplex at
 * base frequency 2, returning `vec2(accumulated, totalWeight)`. `detail` is the lacunarity and
 * `contrast` the persistence; the seed offsets the two axes differently (`seed`, `seed · 0.7`)
 * so re-rolling re-mixes rather than translating. GPU-only via the hash.
 */
export declare const fractalSum: import('typegpu').TgpuFn<(pos: d.Vec2f, detail: d.F32, contrast: d.F32, animTime: d.F32, seed: d.F32, octaveCount: d.F32) => d.Vec2f>;
/**
 * Normalize an fBm sum to the unit range: divide by the accumulated weight, remap the [-1,1]
 * result to [0,1], clamp.
 */
export declare const fbmNormalize: import('typegpu').TgpuFn<(sum: d.Vec2f) => d.F32>;
/** The shared legacy sin-fract cell hash, under WorleyNoise's historical name. */
export declare const worleyHash: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec2f>;
/** One Worley octave: the nearest-2 cellular fold + the selectable mode reduction. */
export declare const worleyEvalOctave: import('typegpu').TgpuFn<(oUV: d.Vec2f, animT: d.F32, seedOff: d.F32, jitter: d.F32, distNum: d.F32, modeNum: d.F32) => d.F32>;
/**
 * The Worley accumulation stage: the gated cellular octave sum over an aspect-plane position,
 * returning `vec2(accumulated, totalWeight)`. `scale` is the base cell frequency; jitter, the
 * distance metric, and the field reduction ride the per-octave `extra` bundle.
 */
export declare const worleyCells: import('typegpu').TgpuFn<(pos: d.Vec2f, scale: d.F32, seed: d.F32, jitter: d.F32, lacunarity: d.F32, persistence: d.F32, animTime: d.F32, octaves: d.F32, distNum: d.F32, modeNum: d.F32) => d.Vec2f>;
/** Normalize a Worley sum: guarded weight divide, scaled by the per-mode normalization. */
export declare const worleyNormalize: import('typegpu').TgpuFn<(sum: d.Vec2f, modeScale: d.F32) => d.F32>;
/**
 * Worley's tone tail: balance (shift) + contrast (scale about 0.5), remapped to [0,1] — the
 * multiplicative, non-inverted tone variant (see `kit/tone.ts`; `contrast` is a gain here,
 * 1 = identity). Pure float (CPU golden-testable).
 */
export declare const worleyTone: import('./tone').ToneRemapFn;
/** Enum transform for the Worley `mode` prop (applied by the uniform bridge). */
export declare const transformWorleyMode: (value: string) => number;
/** Enum transform for the Worley `distance` prop (applied by the uniform bridge). */
export declare const transformWorleyDistance: (value: string) => number;
/** `mode` as its mapped number, robust to a raw string arriving untransformed. */
export declare function worleyModeNum(raw: unknown): number;
/** `distance` as its mapped number, robust to a raw string arriving untransformed. */
export declare function worleyDistNum(raw: unknown): number;
/**
 * Per-mode normalization so default contrast=1 lands the result in roughly [0,1]. The distance
 * metric also affects scale: Manhattan distances run larger than Euclidean, Chebyshev smaller.
 */
export declare function worleyModeScale(modeNum: number, distNum: number): number;
/**
 * The 3×3 nearest-two-features fold, returning `vec2(d1, d2)`. Plain Euclidean distance per tap
 * (a ratio reduction needs real distances, not squared ones) and no jitter control — the cells
 * are always fully random. The drifting cell points hash per-neighbour → GPU-only.
 */
export declare const voronoiCells: import('./cellular').Nearest2Fn;
/**
 * Fill gradient from the F1/F2 ratio, so cell size does not change the tonal range.
 * `edgeIntensity` inverts into the ratio's exponent: high intensity = low power = the edge
 * colour reaches further into each cell.
 */
export declare const cellFill: import('typegpu').TgpuFn<(dd: d.Vec2f, edgeIntensity: d.F32) => d.F32>;
/**
 * Boundary-line mask between cells, with `softness` compensated for the cell count so the line
 * width reads constant as `scale` changes. 0 on a boundary, 1 inside a cell.
 */
export declare const cellBorders: import('typegpu').TgpuFn<(dd: d.Vec2f, softness: d.F32, scale: d.F32) => d.F32>;
/** The gentle `pow(rgb, 0.85)` tone lift on a final P3-linear rgb. GPU-only. */
export declare const toneLift: import('typegpu').TgpuFn<(rgb: d.Vec3f) => d.Vec3f>;
/**
 * The strands path frame — everything about the start→end path that is loop-invariant across
 * strands: `vec4(progress, perpDist, pinch, edgeFade)`. Progress runs 0→1 start→end; perpDist is
 * the signed distance from the path; pinch/edgeFade converge and fade the strands at the endpoints
 * when pinning is on (`pinFlag` is the transformBoolean scalar: on = > 0). Start/end are
 * aspect-corrected and Y-flipped here (transformPosition stores (x, 1-y) → `1 - .y` = authored).
 */
export declare const ribbonPathFrame: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, start: d.Vec2f, end: d.Vec2f, pinFlag: d.F32) => d.Vec4f>;
/**
 * The flowing ribbons field (the ribbons genre primitive). A runtime loop over the ACTIVE ribbon count accumulates each strand's
 * WORKING-SPACE gradient color (via {@link gradientStopsInSpace} — a preconverted, alpha-weighted
 * per-segment mix) weighted by coverage. Returns `vec4(workingColorRGB, alpha)`; the caller does
 * the single back-conversion + tone-pow at the compile-time colorSpace mode. Scalars are packed
 * into vec4 params (tgpu.fn 15-arg cap). Loop is hash-free but nested → GPU-only. `packed3`
 * carries pinEdges (transformBoolean: on = > 0), the two animated clocks, and the runtime stop
 * count.
 *
 * ATOMIC (deliberately): the per-strand gradient lookup and coverage weighting live inside a
 * runtime-count reduce — splitting them would hoist a loop-carried dependency. The separable
 * pieces already live outside: the loop-invariant path geometry in {@link ribbonPathFrame}, the
 * tails (tone-pow, back-conversion) in the noun.
 */
export declare const ribbonsField: import('typegpu').TgpuFn<(uv: d.Vec2f, viewport: d.Vec2f, start: d.Vec2f, end: d.Vec2f, packed1: d.Vec4f, packed2: d.Vec4f, packed3: d.Vec4f, colors: d.WgslArray<d.Vec4f>, positions: d.WgslArray<d.Vec4f>, converted: d.WgslArray<d.Vec3f>) => d.Vec4f>;
/**
 * Paper surface (displaced sample UV + grain brightness). Packs the two per-pixel derivations
 * Paper needs into one `vec3f` so the grain UV is computed once: `.xy` is the child sample UV
 * shifted along the divergence-free curl flow (fiber-direction micro-roughness), `.z` is the
 * fibrous-grain brightness. `curl22`/`paper12` are hash-based → GPU-only (the u32-hash rule); the
 * math: grain freq `grainScale*6`, disp `curl22 * displacement * 0.0025`, brightness centred on
 * paper12's ~0.7 mid.
 *
 * ATOMIC (deliberately): the shared grain UV feeds BOTH outputs — splitting into a displacement
 * part and a brightness part would re-derive it.
 */
export declare const paperSurface: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, grainScale: d.F32, seed: d.F32, displacement: d.F32, roughness: d.F32) => d.Vec3f>;
//# sourceMappingURL=noisePaints.d.ts.map