import { Expr, GpuFragmentParams } from '../../gpu/contract';

export type Layer = Expr | {
    paint: Expr;
    /** 'add' (default) sums light; 'screen' folds it in with 1−(1−a)(1−b). */
    blend?: 'add' | 'screen';
    /** Scales the layer's contribution. */
    opacity?: Expr | number;
    /** A transmittance the layer is seen through (content behind a medium). */
    behind?: Expr;
};
/**
 * Weighted layering: build N variations of the same thing from a plain-data layer list and
 * accumulate them — `weightedSum = Σ value·weight` and `totalWeight = Σ weight`, both in
 * list order. The caller owns the blend (usually a guarded weighted mean:
 * `weightedSum / (totalWeight + ε)`), because the guard and the remap are look decisions.
 * Cheap depth by stacking: aurora curtains, cloud banks, echo/ghost trails. Compile-time
 * layer counts are just `list.slice(0, n)` — disabled layers aren't emitted.
 */
export declare function layered<T>(layerData: readonly T[], build: (layer: T, index: number) => {
    value: Expr;
    weight: Expr;
}): {
    weightedSum: Expr;
    totalWeight: Expr;
};
/** Composite a stack of paint contributions, first entry at the back. */
export declare function layers(entries: Layer[]): Expr;
/**
 * `emissiveAlpha` — light as straight-alpha rgba: alpha is the peak channel and the colour is
 * the light divided by it, so the layer composites over black exactly as the additive light it
 * is, and over anything else as a translucent tint. The output step of any emissive paint drawn
 * over transparency (glows, spills, flares) — never for opaque bodies.
 */
export declare function emissiveAlpha(rgb: Expr, hint?: string): Expr;
/**
 * `dithered` — the always-on ±0.002 output dither on a final rgba (hides banding on long soft
 * ramps). Apply to the COLOR, never to a ramp coordinate. Reads the composed UV and the
 * definition's clock.
 */
export declare function dithered(color: Expr, params: GpuFragmentParams): Expr;
//# sourceMappingURL=compose.d.ts.map