import { d } from './index';

/**
 * The wipe tail: a coverage coordinate → an alpha multiplier in [0,1].
 *
 * `coord` is the per-pixel threshold (0 = goes first, 1 = goes last). The front is remapped by
 * ±feather so that progress 0 leaves the frame fully visible and progress 1 clears it completely,
 * feather included — without the remap a feathered wipe never finishes at either end. `invert`
 * (>0 = on, the `transformBoolean` convention) flips the coordinate, not the progress, so the
 * feather stays on the same side of the front.
 */
export declare const revealMask: import('typegpu').TgpuFn<(coord: d.F32, progress: d.F32, feather: d.F32, invert: d.F32) => d.F32>;
/**
 * Scale a STRAIGHT-alpha color's alpha by a reveal factor, RGB preserved — the pointwise
 * alpha-mask convention (no unpremultiply, no RTT). Pair with {@link revealMask}.
 */
export declare const applyReveal: import('typegpu').TgpuFn<(color: d.Vec4f, reveal: d.F32) => d.Vec4f>;
/**
 * Directional coverage: 0→1 along `angleDeg`, aspect corrected so a diagonal reads as a true
 * angle and both extremes of the frame are reached exactly (the projection is normalized by its
 * own half-extent over the aspect-corrected unit square). Consumers: LinearWipe, BarnDoors,
 * RandomBars, VenetianBlinds.
 */
export declare const directionalCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, angleDeg: d.F32) => d.F32>;
/**
 * Radial coverage: distance from `center`, normalized by the distance to the FARTHEST corner so
 * coverage 1 is reached at every pixel however off-center the origin is. `center` is
 * center-scaled (`center.x * aspect`, the canonical D-1 convention) and y-flipped (the
 * `transformPosition` convention shared with Vignette). Consumers: IrisWipe, RippleWipe.
 */
export declare const radialCornerNormCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, center: d.Vec2f) => d.F32>;
/**
 * Angular (clock-sweep) coverage around `center`, measured from `startDeg`.
 *
 * `mode` is a runtime f32 carrying a compile-time choice the caller bakes as a literal:
 * 0 = clockwise, 1 = counter-clockwise, 2 = both (two wedges meeting on the far side, so the
 * folded distance is doubled back into [0,1]). Passing it as an f32 rather than branching in JS
 * keeps this a single fn; the caller owns the string→literal mapping (the PagePeel-`corner` trap:
 * a string prop must never be given a transform).
 *
 * Aspect handling here is UV-scaled (`(uv.x - center.x) * aspect`), matching RadialWipe as
 * written — see the convention note at the top of this file. Consumer: RadialWipe.
 */
export declare const angularCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, center: d.Vec2f, startDeg: d.F32, mode: d.F32) => d.F32>;
/** Result of {@link cellGrid}: integer cell index, in-cell position, and the grid resolution. */
export declare const CellGrid: d.WgslStruct<{
    cell: d.Vec2f;
    local: d.Vec2f;
    grid: d.Vec2f;
}>;
/**
 * Dice the frame into SQUARE-ISH cells `size` wide (as a fraction of frame width), returning the
 * integer `cell` index, the `local` position inside the cell (`fract`, so [0,1)), and the `grid`
 * resolution itself (callers that need a cell's normalized position divide by it).
 *
 * Cell height is corrected by aspect and floored at one row (`max(gridX / aspect, 1)`) so a wide
 * frame gets square cells and a tall one never degenerates to zero rows. Consumers: DiamondWipe,
 * CheckerWipe, BlockDissolve.
 */
export declare const cellGrid: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, size: d.F32) => d.WgslStruct<{
    cell: d.Vec2f;
    local: d.Vec2f;
    grid: d.Vec2f;
}>>;
/**
 * Fold a [0,1] coverage coordinate about its midpoint: 0 on the center line, 1 at both ends. Turns
 * a single sweeping front into two fronts opening outward (barn doors). Consumer: BarnDoors.
 */
export declare const foldAboutCenter: import('typegpu').TgpuFn<(t: d.F32) => d.F32>;
/**
 * Tile a [0,1] coverage coordinate into `count` repeats, returning the per-tile phase in [0,1) —
 * every tile then crosses the same front in lockstep (venetian blinds). Consumer: VenetianBlinds.
 */
export declare const tilePhase: import('typegpu').TgpuFn<(t: d.F32, count: d.F32) => d.F32>;
/**
 * Quantize a [0,1] coverage coordinate into `count` bands, each band's coverage being its own
 * midpoint — whole bands then vanish one after another in coordinate order (concentric ring pops
 * over a radial coord). `count` is floored at one band. Consumer: RippleWipe.
 */
export declare const bandMidpointCoord: import('typegpu').TgpuFn<(t: d.F32, count: d.F32) => d.F32>;
/**
 * Quantize a [0,1] coverage coordinate into `count` bands and give each band a STABLE random
 * coverage from `hash11` of its index — no time dependence, so the shuffle is frozen
 * frame-to-frame and only progress moves it (the PowerPoint "Random Bars" ordering).
 * Consumer: RandomBars.
 */
export declare const bandShuffleCoord: import('typegpu').TgpuFn<(t: d.F32, count: d.F32) => d.F32>;
/**
 * Diamond-lattice coverage over the {@link cellGrid}: each pixel's coverage is its L1 (diamond)
 * distance from the cell center — 0 at the center, 1 at the corners, where neighboring cells'
 * diamonds meet and tile the plane exactly, so coverage 1 is reached everywhere.
 * Consumer: DiamondWipe.
 */
export declare const cellDiamondCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, size: d.F32) => d.F32>;
/**
 * Staggered checkerboard coverage over the {@link cellGrid}: each cell's coverage combines its
 * checkerboard parity with its normalized corner-to-corner position, so the even-parity cells
 * sweep away diagonally over the first half of coverage and the odd-parity cells over the second.
 * Consumer: CheckerWipe.
 */
export declare const cellCheckerCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, size: d.F32) => d.F32>;
/**
 * Shuffled-cell coverage over the {@link cellGrid}: each cell gets a STABLE random coverage from
 * `hash12` of its integer index — no time dependence, so the dissolve order is frozen
 * frame-to-frame and only progress moves it. Consumer: BlockDissolve.
 */
export declare const cellShuffleCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, size: d.F32) => d.F32>;
/**
 * Organic noise coverage — the classic film-dissolve field: a STABLE 3-octave Perlin fbm (no time
 * dependence) recentred onto [0,1]; `seed` shifts the noise domain with different per-octave
 * offsets so the octaves decorrelate. The fbm sum (~[-1,1], extremes rare) maps to coverage via
 * `0.5 + n * 0.9`, clamped. Consumer: NoiseDissolve.
 */
export declare const fbmCoverageCoord: import('typegpu').TgpuFn<(uv: d.Vec2f, aspect: d.F32, scale: d.F32, seed: d.F32) => d.F32>;
//# sourceMappingURL=reveal.d.ts.map