import { d } from './index';

/**
 * The standard shape-effect silhouette alpha: the D-7 inside mask (edge width `edgeSoftness·0.5`
 * floored at 0.001, clamped to ≥ 1.5 device pixels) eased with smoothstep. This exact tail —
 * `smoothstep(0, 1, insideMask(sdf, max(edgeSoftness·0.5, 0.001), pxH, 1.5))` — closes Chrome,
 * LiquidMetal, Plastic, Water, Frost, Holographic, CarbonFiber and BrushedMetal. Pure.
 */
export declare const silhouetteAlpha: import('typegpu').TgpuFn<(sdf: d.F32, edgeSoftness: d.F32, pxH: d.F32) => d.F32>;
/** A key-light frame: the light direction and its Blinn half-vector against the renderer's fixed
 *  view direction (0,0,−1). */
export declare const KeyLight: d.WgslStruct<{
    L: d.Vec3f;
    H: d.Vec3f;
}>;
/**
 * Build the key-light frame from the light's direction components: `L = normalize(lx, ly, lz)`,
 * `H = normalize(L + (0,0,−1))`. Every material picks its own `lz` (the fleet uses −0.6 … −0.9 —
 * an eye-tuned elevation, not a shared constant) and its own lobe exponents at the call site.
 * Pure.
 */
export declare const keyLight: import('typegpu').TgpuFn<(lx: d.F32, ly: d.F32, lz: d.F32) => d.WgslStruct<{
    L: d.Vec3f;
    H: d.Vec3f;
}>>;
/** Grazing-view factor for the fixed −z view: `1 − clamp(−n.z, 0, 1)` — the input every fresnel
 *  pow() rides (Plastic, Crystal, Frost, Water, Goo). Pure. */
export declare const grazingView: import('typegpu').TgpuFn<(n: d.Vec3f) => d.F32>;
/**
 * A sharpness-steered Blinn glint: `pow(ndh, mix(cfg.x, cfg.y, sharp)) · mix(cfg.z, cfg.w, sharp)`
 * — exponent and gain both slide with the material's `sharpness`. LiquidMetal passes
 * `(60, 900, 0.4, 1.4)`, Water `(40, 600, 0.3, 1.3)`; the shape is shared, the endpoints are each
 * material's look. Pure.
 */
export declare const sharpGlint: import('typegpu').TgpuFn<(ndh: d.F32, sharp: d.F32, cfg: d.Vec4f) => d.F32>;
/**
 * Clamped analytic Perlin gradient — the shared tail of the metal reliefs: `perlin12d(q).yz`
 * scaled by `gain` and clamped to ±4 (the slope bound that keeps chord-discontinuity spikes from
 * reading as bright seams). Chrome's pressed-metal waviness passes gain 1, LiquidMetal's molten
 * relief 0.62; the domain (`q`) each material warps its own way before the call. Pure.
 */
export declare const clampedPerlinGrad: import('typegpu').TgpuFn<(q: d.Vec2f, gain: d.F32) => d.Vec2f>;
/**
 * Tilt a geometric normal in-plane and renormalize: `normalize(n.x + dx, n.y + dy, n.z)` — how a
 * relief field (waviness, molten folds, crumple, frost, weave crowns) bends the base normal.
 * Callers fold their relief products into ONE dx/dy term each; a material whose tilt is a
 * multi-term sum (Water, BrushedMetal) keeps its inline form — re-associating the sum through
 * this single add would change float rounding. Pure.
 */
export declare const nudgeNormal: import('typegpu').TgpuFn<(n: d.Vec3f, dx: d.F32, dy: d.F32) => d.Vec3f>;
/**
 * The shared optical-thickness reading of the shape field: volumetric shapes use the chord
 * (`clamp(−sdf·2, 0, 1.2)`), flat shapes a rim-depth proxy (`clamp(−sdf, 0, 0.5)·2`). The
 * Frost/Water "solid body" cue; each material scales the result by its own density prop. Pure.
 */
export declare const opticalThickness: import('typegpu').TgpuFn<(sdf: d.F32, volumetric: d.F32) => d.F32>;
/** Beer–Lambert transmission per channel: `exp(−thickness · absorb)`. Frost drives it with a
 *  fixed ice absorption spectrum, Water derives absorption from the water colour. Pure. */
export declare const beerLambert: import('typegpu').TgpuFn<(thickness: d.F32, absorb: d.Vec3f) => d.Vec3f>;
/**
 * The incommensurate-frequency domain-warp offset shared verbatim by LiquidMetal's molten folds
 * and Water's wind-driven waves: two sin·cos products over `warpInput` (the pattern coords scaled
 * by 0.6) drifting with `flowT`. The constants ARE the flow character — both materials read the
 * same table. Pure.
 */
export declare const flowWarpOffset: import('typegpu').TgpuFn<(warpInput: d.Vec2f, flowT: d.F32) => d.Vec2f>;
/**
 * The shared 5-softbox studio: a floor→sky gradient plus five radial softbox banks — overhead key,
 * upper-left, right, low fill / floor bounce, lower-left — rotated into the env frame. One sample
 * for a reflection direction (rx, ry).
 *
 * BrushedMetal smears it along the brush grain (skyGain 0.38, animated `drift`); CarbonFiber's
 * clearcoat takes one crisp tap (skyGain 0.3, keyRad 0.16, drift 0). The five bank positions,
 * radius multipliers and brightnesses are byte-identical between the two — only the sky gain
 * differs, so it is the one argument. (LiquidMetal's 3-bank studio and Chrome's rounded-rect
 * softbox + flags are different arithmetic and stay in their files.) Pure.
 */
export declare const studio5Softbox: import('typegpu').TgpuFn<(rx: d.F32, ry: d.F32, envC: d.F32, envS: d.F32, keyRad: d.F32, drift: d.F32, envStr: d.F32, skyGain: d.F32) => d.F32>;
//# sourceMappingURL=materialParts.d.ts.map