import { UvMapSource } from '../gpu/scaffolds/uvRemapShader';
import { ArgSpec } from './invoke';
import { GatherEffect } from './types';
import { PropRef } from './values';

/**
 * Reflect content across the line through `center` at `angle` (degrees).
 *
 * The reflection body returns a hard 0/1 side selector alongside the reflected coordinate,
 * so `selectMap` picks per pixel between the original coordinate (near side) and the
 * reflected one (far side). Selecting COORDINATES and sampling once is pixel-identical to
 * mixing two sampled colours by the same hard selector, with one texture fetch instead of
 * two, and both halves go through the same reconstruction filter so the filtering never
 * changes across the mirror line.
 */
export declare function mirrorLine(slots: {
    center: ArgSpec;
    angle: ArgSpec;
}): UvMapSource;
/**
 * Mirror content across the canvas axes. `flipX`/`flipY` bind boolean props stored as ±1
 * uniforms (transformBoolean). The map sends [0,1] onto [0,1], so pair it with
 * `edges: 'none'` — no lookup can land outside the source.
 */
export declare function flip(slots: {
    flipX: ArgSpec;
    flipY: ArgSpec;
}): UvMapSource;
/**
 * Bend the ends of the frame toward (or away from) the viewer like a curved display —
 * the inverse bent-sheet projection, under real perspective. `angle` sets the bend axis in
 * degrees; `falloff` concentrates the bend toward the ends.
 */
export declare function bend(slots: {
    strength: ArgSpec;
    falloff: ArgSpec;
    angle: ArgSpec;
}): UvMapSource;
/**
 * Magnify or pinch content around `center` — positive strength bulges out, negative
 * pinches in, with `radius`/`falloff` shaping the affected disc.
 */
export declare function bulge(slots: {
    center: ArgSpec;
    strength: ArgSpec;
    radius: ArgSpec;
    falloff: ArgSpec;
}): UvMapSource;
/** Rotate and twist content around `center`, with the twist angle growing with distance. */
export declare function twirl(slots: {
    center: ArgSpec;
    intensity: ArgSpec;
}): UvMapSource;
/** Fold content into radial mirrored segments around `center` (`angle` in degrees). */
export declare function kaleidoscope(slots: {
    center: ArgSpec;
    segments: ArgSpec;
    angle: ArgSpec;
}): UvMapSource;
/**
 * Stretch content along a direction (`angle` in degrees) away from `center`, with
 * `falloff` controlling how sharply the stretch ramps in past the center.
 */
export declare function stretch(slots: {
    center: ArgSpec;
    strength: ArgSpec;
    angle: ArgSpec;
    falloff: ArgSpec;
}): UvMapSource;
/**
 * Displace content along a direction by an animated wave. `waveType` binds a compile-time
 * prop (sine/triangle/square/sawtooth/bounce): the producer branches once per composition
 * and only the active waveform body is emitted — no runtime branch. The phase advances by
 * the definition's animated clock (declare `animatedTime: {speed: 'speed'}`), at half rate.
 */
export declare function wave(slots: {
    strength: ArgSpec;
    frequency: ArgSpec;
    angle: ArgSpec;
    waveType: PropRef;
}): UvMapSource;
/**
 * Convert rectangular coordinates to polar space around `center` (`wrap` scales the
 * angular range, `radius` the radial one), lerped toward the identity by `intensity` —
 * 0 leaves the content alone, 1 is the full coordinate-system change. `lerpToIdentity`
 * blends COORDINATES, not colours, so intermediate values are a genuine partial warp
 * rather than a cross-fade.
 */
export declare function toPolar(slots: {
    center: ArgSpec;
    wrap: ArgSpec;
    radius: ArgSpec;
    intensity: ArgSpec;
}): UvMapSource;
/**
 * Convert polar coordinates back to rectangular space around `center` (the mirror of
 * {@link toPolar}), lerped toward the identity by `intensity`.
 */
export declare function fromPolar(slots: {
    center: ArgSpec;
    scale: ArgSpec;
    intensity: ArgSpec;
}): UvMapSource;
/**
 * Pin each corner of the content to an arbitrary position — a true square→quad corner-pin
 * homography, inverted analytically. The body returns a packed `vec3f` (projected
 * coordinate in `.xy`, front-facing gate in `.z`), so the map returns the COVERAGE form:
 * the warp role applies coverage to sampled alpha on the fragment path and to the coverage
 * mask on the analytic path, clipping the folded-back region either way. `amount` blends
 * each corner toward its neutral rectangle position.
 */
export declare function cornerPin(slots: {
    topLeft: ArgSpec;
    topRight: ArgSpec;
    bottomRight: ArgSpec;
    bottomLeft: ArgSpec;
    amount: ArgSpec;
}): UvMapSource;
/**
 * Rotate the plane in 3D space with pan and tilt (degrees), `fov` controlling perspective
 * intensity and `zoom` scaling the sampled area. The map ignores `aspect` — it samples in
 * raw UV space, unlike the other warps here.
 */
export declare function perspective(slots: {
    center: ArgSpec;
    pan: ArgSpec;
    tilt: ArgSpec;
    fov: ArgSpec;
    zoom: ArgSpec;
    offset: ArgSpec;
}): UvMapSource;
/**
 * Concentric rings that each rotate the content by different amounts — per-ring hashed
 * static + animated rotation, blended between adjacent rings along the shortest angular
 * path. The ring rotation advances by the definition's animated clock (declare
 * `animatedTime: {speed: 'speed'}`).
 */
export declare function concentricRings(slots: {
    center: ArgSpec;
    intensity: ArgSpec;
    rings: ArgSpec;
    smoothness: ArgSpec;
    seed: ArgSpec;
    speedRandomness: ArgSpec;
}): UvMapSource;
/**
 * Fluid-like distortion with constant smooth motion: three noise layers drifting through a
 * 3D field, combined and normalised so the flow speed is constant and `strength` is the
 * only magnitude control. Reads TWO animated clocks — the primary flow drift and the
 * `evolution` extra clock (declare `animatedTime: {speed: ...}` plus
 * `extraAnimatedTimes: {evolution: ...}`), each at 1/10 rate. `seed` binds a prop added to
 * both clocks on the GPU, shifting the noise domain along the drift/evolution axes — a
 * different static pattern per seed value, even at speed 0.
 */
export declare function flowNoise(slots: {
    strength: ArgSpec;
    detail: ArgSpec;
    seed: PropRef;
}): UvMapSource;
/**
 * Slice the content into strips that slide away in alternating directions — the "shredder"
 * transition. At progress 1 every lookup is out of bounds, so pair it with a fixed
 * TRANSPARENT edge mode (`edges: 1`): clipping the vacated space is what makes it a wipe.
 */
export declare function slicedSlide(slots: {
    angle: ArgSpec;
    count: ArgSpec;
    progress: ArgSpec;
}): UvMapSource;
/**
 * Slice content into parallel bars, each offset independently by a hash for a fractured or
 * glitch-like look. Each bar drifts at its own hashed rate by the definition's animated
 * clock (declare `animatedTime: {speed: 'speed'}`).
 */
export declare function barOffset(slots: {
    count: ArgSpec;
    angle: ArgSpec;
    intensity: ArgSpec;
    seed: ArgSpec;
}): UvMapSource;
/**
 * Displace by this node's own compute-generated displacement field, sampled per grid cell:
 * snap the incoming UV to the centre of its `gridSize` cell, read the displacement texture
 * there, offset (±0.1 clamp), then edge-handle.
 *
 * When the compute texture is absent (GPU-free composition, or before the compute hook has
 * run) the map substitutes a zero displacement and keeps its structure identical — pair the
 * definition with `uvRemapIdentityWhen` so the analytic path returns the incoming remap
 * verbatim in that case instead.
 */
export declare function gridCellDisplace(slots: {
    gridSize: ArgSpec;
    output: string;
}): UvMapSource;
/**
 * Displace by this node's own compute-generated displacement field, sampled continuously at
 * the incoming UV and scaled by `intensity` (±0.15 clamp) — the liquid/cloth look. Same
 * absent-texture handling as {@link gridCellDisplace}: zero displacement here, with
 * `uvRemapIdentityWhen` covering the analytic path on the definition.
 */
export declare function liquidDisplace(slots: {
    intensity: ArgSpec;
    output: string;
}): UvMapSource;
/**
 * Distort the child using ANOTHER LAYER's pixels as a displacement map — the classic
 * Photoshop/AE displacement, driven cross-layer rather than by a procedural field, hence a
 * gather effect (the source arrives via `getLayerTexture`, the same shared RTT boundary
 * prop maps use, so the layer renders once even when it's also visible on canvas). An
 * animated source layer displaces live.
 *
 * `source` binds the compile-time layer prop; `channels` picks the applier at composition
 * (red/green two-axis vs luminance along `angle`); `edges` binds the compile-time edge
 * mode. No source selected (or an unresolvable id) → a sharp passthrough of the child,
 * exactly as sampled at the incoming coordinate.
 */
export declare function displaceByLayer(slots: {
    source: PropRef;
    amount: ArgSpec;
    channels: PropRef;
    angle: ArgSpec;
    edges: PropRef;
}): GatherEffect;
//# sourceMappingURL=warps.d.ts.map