@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/post/settings.d.ts

@@ -0,0 +1,485 @@
+export type RGB = [number, number, number];
+export interface BloomSettings {
+    enabled: boolean;
+    /** Strength of the bloom added to the image. */
+    intensity: number;
+    /** Scene-colour brightness above which non-emissive pixels also bloom. */
+    threshold: number;
+    /** Soft knee width around the threshold. */
+    knee: number;
+    /** Multiplier on the emissive target (the main bloom source). */
+    emissiveWeight: number;
+    /** 0..1: how much each coarser level is added back on the way up (bigger = wider glow). */
+    scatter: number;
+    /** Mip levels (2..8). Changing it takes effect on next resize. */
+    levels: number;
+    /**
+     * Lens dirt (ws/post-3): a texture multiplied into the bloom term at the composite
+     * (`bloom × (1 + dirt × intensity)`), so glow shows the smudges. `createLensDirtTexture`
+     * paints a procedural one; `texture: null` (or no `dirt`) is off and costs nothing.
+     */
+    dirt?: LensDirtSettings;
+}
+/** The lens-dirt texture and its strength (ws/post-3). See `BloomSettings.dirt`. */
+export interface LensDirtSettings {
+    /** An `rgba8unorm` 2D texture sampled over the whole screen, or `null` for none. */
+    texture: GPUTexture | null;
+    /** How much the dirt brightens the bloom where it is white (0 = none). */
+    intensity: number;
+}
+/**
+ * The screen-space floor mist (ws/api-render: `PostSettings.mist`, formerly `fog`): a noisy
+ * haze rising from the bottom of the screen, composited after bloom. It is not distance fog;
+ * `Lights.fog` (render) fades 3D surfaces with their distance inside the materials. The two
+ * stack: the distance fog is already in the scene colour when the mist goes on top.
+ */
+export interface MistSettings {
+    enabled: boolean;
+    /** Mist colour (linear, HDR ok). */
+    color: RGB;
+    /** Max opacity of the mist at the bottom (0..1). */
+    density: number;
+    /** Screen height (0 = top, 1 = bottom) where mist starts. */
+    top: number;
+    /** Screen height where mist reaches full density. */
+    bottom: number;
+    /** Shape curve of the height falloff (>1 hugs the floor). */
+    falloff: number;
+    /** Noise frequency (bigger = smaller wisps). */
+    noiseScale: number;
+    /** Drift speed. */
+    speed: number;
+    /** How much nearby glow (bloom) lights the mist. */
+    lightScatter: number;
+}
+export interface GodRaySettings {
+    enabled: boolean;
+    /**
+     * Light position in logical coordinates (may be off-screen): the 2D placement, used unless
+     * `direction` is set and the frame has a 3D view.
+     */
+    x: number;
+    y: number;
+    /**
+     * World-space direction the light travels, like `Lights.sun.direction` (ws/api-render). When
+     * set and the frame has a 3D view (`PostInputs.view`), the rays come from where that
+     * direction's source sits on screen each frame (`godRaySource`) instead of `x`/`y`, and they
+     * go out while the sun is behind the camera. `null` or absent: `x`/`y`.
+     */
+    direction?: RGB | null;
+    intensity: number;
+    /** Per-sample falloff (0.9..0.99). */
+    decay: number;
+    /** Ray length as a fraction of the distance to the light (0..1). */
+    density: number;
+    /** Per-sample weight. */
+    weight: number;
+    color: RGB;
+    /** Radius (logical px) of the bright disc at the light position. 0 disables it. */
+    sourceRadius: number;
+    /** Brightness of the disc. */
+    sourceIntensity: number;
+    /** How much the scene's bloom also casts rays (glowing things shed shafts). */
+    bloomSource: number;
+}
+export interface VignetteSettings {
+    enabled: boolean;
+    intensity: number;
+    /** Distance from centre (0..1, 1 = corner) where darkening starts. */
+    radius: number;
+    softness: number;
+    color: RGB;
+}
+export type Tonemap = 'aces' | 'reinhard' | 'none';
+export interface GradeSettings {
+    enabled: boolean;
+    /** Linear exposure multiplier before tonemapping. */
+    exposure: number;
+    tonemap: Tonemap;
+    lift: RGB;
+    gamma: RGB;
+    gain: RGB;
+    saturation: number;
+    contrast: number;
+    /** Ordered-noise dither to kill banding in dark gradients. */
+    dither: boolean;
+}
+/**
+ * Screen-space ambient occlusion over the scene depth (ws/post-depth). Needs a frame with a
+ * depth buffer (`PostInputs.depth`); the 2D path has none and the pass is skipped.
+ */
+export interface AoSettings {
+    enabled: boolean;
+    /** Sample radius in world units. */
+    radius: number;
+    /** Strength of the darkening (0 = none). */
+    intensity: number;
+    /** Depth tolerance (world units along the normal) before a sample counts as occluding. */
+    bias: number;
+    /** Contrast of the occlusion term (>1 deepens creases). */
+    power: number;
+}
+/** Depth of field from linear depth (ws/post-depth): sharp at `focusDistance`, blurred by CoC. */
+export interface DofSettings {
+    enabled: boolean;
+    /** Distance from the eye (world units) in sharp focus. */
+    focusDistance: number;
+    /** Depth either side of the focus distance over which the blur ramps to `maxBlur`. */
+    focusRange: number;
+    /** Largest circle of confusion, in px at the output resolution. */
+    maxBlur: number;
+    /** Blur what is closer than the focus too (off: only the far side blurs). */
+    nearBlur: boolean;
+}
+/**
+ * FXAA 3.11 (console preset) over the composite's output (ws/post-2): one extra full-res pass,
+ * recorded only while enabled.
+ */
+export interface FxaaSettings {
+    enabled: boolean;
+    /** How much of the anti-aliased result replaces the pixel (0..1). */
+    subpixel: number;
+    /** Local contrast (0..1 of the brightest luma) below which a pixel is left alone. */
+    edgeThreshold: number;
+}
+/** A 3D colour lookup applied after the grade (ws/post-2). `texture: null` means off. */
+export interface LutSettings {
+    /** A `size`³ `rgba8unorm` 3D texture (`createLutTexture`, `identityLut`), or `null` for none. */
+    texture: GPUTexture | null;
+    /** Texels per axis of `texture`. */
+    size: 16 | 32;
+    /** Blend between the graded colour (0) and the looked-up colour (1). */
+    intensity: number;
+}
+/** Film grain after the grade (ws/post-2). `intensity` 0 is off. */
+export interface GrainSettings {
+    /** Peak noise amplitude (display units, 0..1). */
+    intensity: number;
+    /** Grain cell size in output px (1 = per pixel). */
+    size: number;
+    /** 0..1: how much less grain bright pixels get (1 = none in white). */
+    luminanceResponse: number;
+    /** Re-seed every frame; off, the grain is a fixed pattern. */
+    animated: boolean;
+}
+/** Chromatic aberration: red and blue sampled radially either side of green (ws/post-2). */
+export interface AberrationSettings {
+    /** Largest channel offset in output px (reached at the corners when `radialOnly`). 0 is off. */
+    intensity: number;
+    /** Grow the offset with the squared distance from the centre, so the centre stays clean. */
+    radialOnly: boolean;
+}
+/** Unsharp mask on the scene colour (ws/post-2). `amount` 0 is off. */
+export interface SharpenSettings {
+    /** Strength of the 5-tap unsharp mask (0..2 is sensible). */
+    amount: number;
+}
+/**
+ * A depth and normal outline for toon looks (ws/post-2): a Roberts cross over the linear depth
+ * and the normals from depth, mixed into the scene colour before fog. Needs the scene depth;
+ * without one the pass is off (one warning).
+ */
+export interface OutlineSettings {
+    enabled: boolean;
+    /** Line colour (linear). */
+    color: RGB;
+    /** Line width in output px (the cross is sampled at this distance). */
+    thickness: number;
+    /** Relative depth step (fraction of the nearer depth) that counts as an edge. */
+    depthThreshold: number;
+    /** Normal difference (1 - cos of the angle) that counts as an edge. */
+    normalThreshold: number;
+    /** Opacity of the line (0..1). */
+    intensity: number;
+}
+/**
+ * Temporal anti-aliasing (ws/post-3): the stack keeps a history colour texture at scene res,
+ * reprojects it by the previous frame's view-projection against the current depth, clamps it to
+ * the current pixel's 3×3 neighbourhood and blends it in by `feedback`. Needs the scene depth
+ * and a frame with a view (3D path); when on, FXAA is skipped. Resize and the first frame
+ * reset the history. `PostStack.taa.jitter(frame)` gives the frame's sub-pixel offset.
+ *
+ * Reprojection (ws/post-5): with a velocity target (`PostInputs.velocity`) and `reprojection`
+ * `'velocity'` (the default) each pixel finds its history at `uv - velocity` (the velocity of
+ * the nearest depth in its 3×3, so a moving or skinned object's edge follows it), falling back
+ * to the camera matrix where nothing wrote a velocity; the history is dropped where its depth
+ * or velocity disagree with the pixel's by more than `depthReject` / `velocityReject`.
+ * Without the target, or in `'camera'`, the camera matrix alone reprojects, as before.
+ */
+export interface TaaSettings {
+    enabled: boolean;
+    /** Weight of the (clamped) history in the blend, 0..0.98 (0.9 = ~10 frames of memory). */
+    feedback: number;
+    /** Unsharp amount on the resolved colour, undoing the blend's softness (0 = none). */
+    sharpen: number;
+    /** `'aabb'`: clamp the history to the neighbourhood min/max; `'variance'`: to mean ± 1 σ. */
+    clampMode: 'aabb' | 'variance';
+    /**
+     * What finds a pixel's history (ws/post-5): `'velocity'` the velocity target where the frame
+     * has one (else the camera), `'camera'` the camera's previous view-projection only.
+     */
+    reprojection: TaaReprojection;
+    /**
+     * `'velocity'` only: drop the history where its linear depth differs from the pixel's by more
+     * than this fraction of the nearer one (0.1 = 10 %).
+     */
+    depthReject: number;
+    /** `'velocity'` only: drop the history where its velocity differs by more than this, in px. */
+    velocityReject: number;
+    /**
+     * How the resolve reads the history between texels (ws/post-6): `'catmull-rom'` (the
+     * default) a 5-tap Catmull-Rom sample, which keeps a slowly moving surface sharp;
+     * `'bilinear'` one bilinear tap, which softens it a little more every frame it moves by a
+     * fraction of a pixel. Either is clamped to the 3×3 neighbourhood.
+     */
+    historyFilter: TaaHistoryFilter;
+}
+/** What TAA reprojects its history by (ws/post-5). See `TaaSettings.reprojection`. */
+export type TaaReprojection = 'camera' | 'velocity';
+/** How TAA samples its history (ws/post-6). See `TaaSettings.historyFilter`. */
+export type TaaHistoryFilter = 'bilinear' | 'catmull-rom';
+/**
+ * Screen-space reflections (ws/post-3): a half-res view-space ray march over the scene depth
+ * from normals derived from it (the AO pass's helper), sampling the scene colour where the ray
+ * meets the depth, faded at the screen edges and composited into the scene before bloom.
+ * Needs the scene depth. Per surface (ws/post-4): with a rough-metal target
+ * (`PostInputs.roughMetal`) each pixel fades by its own roughness against `roughnessCutoff` and
+ * is weighted by its metalness (Schlick Fresnel from F0 0.04 for a dielectric, 1 for a metal);
+ * without it every surface reads as a smooth mirror at full weight, as before.
+ */
+export interface SsrSettings {
+    enabled: boolean;
+    /** Ray-march steps (8..64); `maxDistance / maxSteps` is the step length. */
+    maxSteps: number;
+    /** Depth thickness (view units) a ray point may sit behind the surface and still hit. */
+    thickness: number;
+    /** Longest reflected ray in view units. */
+    maxDistance: number;
+    /** Roughness at and above which no reflection shows (0..1); below it the term fades in. */
+    roughnessCutoff: number;
+    /** Strength of the reflection added to the scene. */
+    intensity: number;
+    /** Width of the screen-edge fade in uv (0 = hard cut at the border). */
+    fadeEdges: number;
+}
+/**
+ * Exposure (ws/post-3). `'manual'`: `grade.exposure` is the multiplier, as before. `'auto'`:
+ * a compute pass builds a 64-bin log-luminance histogram of the scene colour, a second averages
+ * the bins between the percentile bounds, and the EV eases toward `log2(keyValue / average)`
+ * clamped to `minEv..maxEv` at `speedUp` / `speedDown` per second (`PostInputs.dt`).
+ * `PostStack.exposure` reads the current EV (the multiplier is `2^EV`).
+ */
+export interface ExposureSettings {
+    mode: 'manual' | 'auto';
+    /** Lowest EV auto mode may settle at (a negative EV darkens). */
+    minEv: number;
+    /** Highest EV auto mode may settle at. */
+    maxEv: number;
+    /** Rate (1/s) at which the EV rises toward a brighter target (a dark scene brightening). */
+    speedUp: number;
+    /** Rate (1/s) at which the EV falls toward a darker target. */
+    speedDown: number;
+    /** Middle-grey the metered average is mapped to (0.18 = photographic 18 %). */
+    keyValue: number;
+    /** Lower percentile (0..1) of the histogram the average ignores (dark outliers). */
+    histogramLow: number;
+    /** Upper percentile (0..1) of the histogram the average ignores (highlights). */
+    histogramHigh: number;
+}
+/**
+ * White balance (ws/post-3): a 3×3 colour matrix before the exposure and grade that tints the
+ * image toward the colour of a black body at `temperature` (lower = warmer, 6500 K = none),
+ * shifted by `tint` (positive toward magenta, negative toward green). Bradford chromatic
+ * adaptation from the 6500 K white to the target white, in linear sRGB; see `white-balance.ts`.
+ */
+export interface WhiteBalanceSettings {
+    /** Colour temperature in kelvin (1667..25000); 6500 is the identity. */
+    temperature: number;
+    /** Green–magenta shift (-1..1); 0 is the identity. */
+    tint: number;
+}
+/**
+ * Camera motion blur (ws/post-3): per-pixel velocity from the current depth reprojected by the
+ * previous frame's view-projection (the matrix TAA keeps), the scene colour sampled along it
+ * before bloom. Needs the scene depth. Objects moving on their own do not blur (no velocity
+ * target yet; see the README's wish list).
+ */
+/** What a motion-blur pixel moves by (ws/post-4). See `MotionBlurSettings.mode`. */
+export type MotionBlurMode = 'camera' | 'object';
+export interface MotionBlurSettings {
+    enabled: boolean;
+    /**
+     * `'object'` (the default): with a velocity target (`PostInputs.velocity`) each pixel blurs
+     * along the velocity the renderer wrote for it, so moving and skinned objects smear under a
+     * still camera; pixels with no velocity fall back to the camera's reprojection. Without the
+     * target, and in `'camera'`, only the camera's movement blurs (the depth reprojected by the
+     * previous view-projection).
+     */
+    mode: MotionBlurMode;
+    /** Scale on the frame-to-frame velocity (1 = the full frame's movement). */
+    intensity: number;
+    /** Taps along the velocity (2..16). */
+    maxSamples: number;
+}
+export interface PostSettings {
+    bloom: BloomSettings;
+    /** The screen-space floor mist (not `Lights.fog`, the distance fog). */
+    mist: MistSettings;
+    godRays: GodRaySettings;
+    vignette: VignetteSettings;
+    grade: GradeSettings;
+    ao: AoSettings;
+    dof: DofSettings;
+    fxaa: FxaaSettings;
+    lut: LutSettings;
+    grain: GrainSettings;
+    aberration: AberrationSettings;
+    sharpen: SharpenSettings;
+    outline: OutlineSettings;
+    taa: TaaSettings;
+    ssr: SsrSettings;
+    exposure: ExposureSettings;
+    whiteBalance: WhiteBalanceSettings;
+    motionBlur: MotionBlurSettings;
+}
+/**
+ * The tuned look the engine shipped with (ws/api-render names it): bloom, a cool floor mist,
+ * god rays from the top centre of a 1920×1080 design, a vignette and a slight saturation and
+ * contrast lift. `PostStack` and `createGame` start from it. A new settings object each call.
+ */
+export declare function cinematicPostSettings(): PostSettings;
+/**
+ * A neutral preset (ws/api-render): every pass off but the tone map (ACES, exposure 1, no
+ * lift, gamma, gain, saturation or contrast change, dithered), so the image is the scene and
+ * nothing else. Start here and turn on what the game wants. A new settings object each call.
+ */
+export declare function neutralPostSettings(): PostSettings;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? Partial<T[K]> : T[K];
+};
+export type PostSettingsPatch = DeepPartial<PostSettings>;
+/**
+ * A deep copy of `s` (ws/post-4): every section and every array (`RGB`) is new, so mutating
+ * the copy or blending it never touches the original. GPU handles (`lut.texture`,
+ * `bloom.dirt.texture`) are shared, not copied.
+ */
+export declare function clonePostSettings(s: PostSettings): PostSettings;
+/** Shallow-per-section merge of `patch` into `target` (mutates target). */
+export declare function applyPostPatch(target: PostSettings, patch: PostSettingsPatch): PostSettings;
+/**
+ * Cost caps, separate from the look settings so presets and `blendTo` never undo them.
+ * Defaults are full quality. See `PostStack.quality`.
+ */
+export interface PostQuality {
+    /** Upper bound on `bloom.levels` (2..8). Fewer levels = less wide halo, fewer passes. */
+    maxBloomLevels: number;
+    /** God-ray march samples (8..64). Fewer samples are re-weighted to keep the same reach. */
+    raySamples: number;
+    /** Floor-mist fbm octaves for the main layer (2..5); the second layer uses one fewer. */
+    fogOctaves: number;
+    /**
+     * Run the composite (mist, tonemap, grade, dither) at the scene's resolution and upscale
+     * the result with one bilinear fetch, instead of compositing every output pixel. Only acts
+     * when the scene is smaller than the output (reduced resolution). Softer mist and dither;
+     * saves most of the composite's fill at high DPR.
+     */
+    compositeAtScene: boolean;
+    /** Ambient-occlusion spiral samples per pixel (4..16). */
+    aoSamples: number;
+    /** Depth-of-field gather taps per pixel (8..32). */
+    dofTaps: number;
+    /** Allow the FXAA pass; `false` (the low tier) keeps `fxaa.enabled` from adding a pass. */
+    fxaa: boolean;
+    /** Allow the outline pass; `false` (the low tier) keeps it off. */
+    outline: boolean;
+    /** Allow TAA (ws/post-3); `false` (the XR tier) keeps `taa.enabled` from adding the pass. */
+    taa: boolean;
+    /** Allow SSR; `false` (the low and XR tiers) keeps it off. */
+    ssr: boolean;
+    /** Allow the auto-exposure compute passes; `false` leaves `exposure.mode` reading as manual. */
+    autoExposure: boolean;
+    /** Allow camera motion blur; `false` (the low and XR tiers) keeps it off. */
+    motionBlur: boolean;
+}
+export declare function defaultPostQuality(): PostQuality;
+/**
+ * The low tier's caps: fewer bloom levels, samples and octaves; no FXAA, outline, SSR or
+ * motion-blur pass. TAA and auto-exposure stay (cheap, and TAA replaces FXAA).
+ */
+export declare function lowPostQuality(): PostQuality;
+/** A device class for `postQualityFor` (ws/post-3). */
+export type PostQualityTier = 'phone' | 'tablet' | 'desktop' | 'xr';
+/**
+ * The cost caps for a device class (ws/post-3): `'phone'` is `lowPostQuality()`; `'tablet'`
+ * trims the samples and skips SSR; `'desktop'` is everything; `'xr'` is full quality with
+ * TAA, SSR and motion blur off: frame budget and comfort first (SSR costs a march per eye;
+ * motion blur in a headset reads as lag). TAA keeps one history per eye since ws/xr-taa, so a
+ * game may opt in with `{ ...postQualityFor('xr'), taa: true }` and `taa.enabled`.
+ */
+export declare function postQualityFor(tier: PostQualityTier): PostQuality;
+/**
+ * What the depth passes need from the frame's projection (ws/post-depth): the clip → view
+ * inverse, the clip planes and the output width (`dof.maxBlur` is in output px). `null` when
+ * the frame rendered no depth; the packed uniforms then turn AO and DoF off.
+ */
+export interface PostDepthInfo {
+    near: number;
+    far: number;
+    /** Inverse of the projection, column-major. */
+    invProj: ArrayLike<number>;
+    /** The projection's own x/y scale (`proj[0]`, `proj[5]`), to project a world radius. */
+    projX: number;
+    projY: number;
+    outputWidth: number;
+    /**
+     * The projection is orthographic (`proj[11] === 0`, ws/post-4): AO and SSR project a view
+     * point without the divide by depth, and SSR's eye ray is the view axis.
+     */
+    ortho?: boolean;
+}
+/**
+ * Per-frame state the temporal passes need (ws/post-3), kept by `PostStack`: the sub-pixel
+ * jitter in uv, whether this frame resets the history, the matrix from this frame's clip space
+ * to the previous frame's (`prevViewProj × invViewProj`) and the auto-exposure multiplier.
+ */
+export interface PostFrameState {
+    jitterX: number;
+    jitterY: number;
+    /** 1 on a frame whose history is invalid (first frame, resize): TAA copies the current colour. */
+    reset: number;
+    /** Current clip → previous clip, column-major. */
+    reproj: ArrayLike<number>;
+    /** Linear exposure multiplier used while `exposure.mode` is `'auto'` (`2^EV`). */
+    autoExposure: number;
+    /** 1 when SSR reads the frame's rough-metal target (ws/post-4), else 0 (the constant path). */
+    roughMetal?: number;
+    /** 1 when motion blur gathers along the frame's velocity target (ws/post-4), else 0. */
+    objectVelocity?: number;
+    /** 1 when TAA reprojects by the frame's velocity target (ws/post-5), else 0. */
+    taaVelocity?: number;
+}
+/**
+ * Uniform layout shared by all post shaders: 22 × vec4f + mat4x4f + 17 × vec4f + mat4x4f +
+ * vec4f.
+ */
+export declare const POST_UNIFORM_FLOATS = 192;
+export declare const WGSL_POST_UNIFORMS = "\nstruct PostUniforms {\n  frame: vec4f,      // time, aspect, 1/width, 1/height\n  enables: vec4f,    // bloom, fog, rays, vignette\n  enables2: vec4f,   // grade, tonemap (0 none, 1 aces, 2 reinhard), dither, exposure\n  bloom: vec4f,      // intensity, threshold, knee, emissiveWeight\n  bloom2: vec4f,     // scatter, -, -, -\n  fogColor: vec4f,   // rgb, density\n  fog: vec4f,        // top, bottom, noiseScale, speed\n  fog2: vec4f,       // lightScatter, falloff, -, -\n  rays: vec4f,       // light uv x, y, intensity, decay\n  rays2: vec4f,      // density, weight, source radius (uv-y units), source intensity\n  raysColor: vec4f,  // rgb, bloomSource\n  vignette: vec4f,   // intensity, radius, softness, -\n  vignetteColor: vec4f,\n  lift: vec4f,\n  gamma: vec4f,\n  gain: vec4f,\n  grade: vec4f,      // saturation, contrast, -, -\n  quality: vec4f,    // ray samples, fog octaves, ortho projection (1, ws/post-4), -\n  ao: vec4f,         // enabled (0 without depth), radius, intensity, bias\n  ao2: vec4f,        // power, samples, proj x scale, proj y scale\n  dof: vec4f,        // enabled (0 without depth), focus distance, focus range, max blur (uv of width)\n  dof2: vec4f,       // near blur, taps, near plane, far plane\n  invProj: mat4x4f,  // clip -> view\n  fxaa: vec4f,       // enabled, subpixel, edgeThreshold, -\n  lut: vec4f,        // enabled, (size-1)/size, intensity, 0.5/size\n  grain: vec4f,      // intensity, cell size (px), luminanceResponse, seed\n  aberration: vec4f, // intensity (px), radialOnly, -, -\n  sharpen: vec4f,    // amount, -, -, -\n  outline: vec4f,    // enabled (0 without depth), thickness (scene px), depthThreshold, normalThreshold\n  outlineColor: vec4f, // rgb, intensity\n  // Post 3 (ws/post-3).\n  taa: vec4f,        // enabled (0 without depth), feedback, sharpen, clampMode (0 aabb, 1 variance)\n  taa2: vec4f,       // view jitter x (uv), view jitter y (uv), reset (1 = copy the current frame), velocity reprojection (1, ws/post-5)\n  ssr: vec4f,        // enabled (0 without depth), maxSteps, thickness, maxDistance\n  ssr2: vec4f,       // roughnessCutoff, intensity, fadeEdges (uv), rough-metal target (1)\n  exposure: vec4f,   // auto (1), histogramLow, histogramHigh, keyValue\n  wb0: vec4f,        // white-balance matrix row 0 (rgb weights), enabled\n  wb1: vec4f,        // row 1\n  wb2: vec4f,        // row 2\n  motionBlur: vec4f, // enabled (0 without depth), intensity, samples, velocity target (1 = object)\n  dirt: vec4f,       // enabled, intensity, -, -\n  reproj: mat4x4f,   // current clip -> previous frame's clip (identity on a reset)\n  // Post 5 (ws/post-5).\n  taa3: vec4f,       // depthReject (fraction), velocityReject (px), history filter (1 = Catmull-Rom, ws/post-6), -\n};\n@group(0) @binding(0) var<uniform> P: PostUniforms;\n";
+/**
+ * Where a directional light's source sits on screen (ws/api-render): the point at infinity
+ * opposite `direction` (the way the light travels) through `viewProj` (column-major), in
+ * logical px of a `width × height` view, written to `out` as x, y. Returns 1 when the source is
+ * in front of the camera and 0 when it is behind (or the projection is orthographic, which has
+ * no point at infinity); `out` is left alone then. No allocation.
+ */
+export declare function godRaySource(viewProj: ArrayLike<number>, direction: ArrayLike<number>, width: number, height: number, out: {
+    0: number;
+    1: number;
+} | number[] | Float32Array): number;
+/**
+ * The god-ray source for this frame: `x`/`y`, or `godRaySource` of `direction` through `view`.
+ * Writes x, y and visibility into `out`.
+ */
+export declare function resolveGodRays(r: GodRaySettings, viewProj: ArrayLike<number> | null, logicalWidth: number, logicalHeight: number, out: Float32Array): void;
+/** Pack settings into the uniform array (no allocation). */
+export declare function packPostUniforms(out: Float32Array, s: PostSettings, time: number, width: number, height: number, logicalWidth: number, logicalHeight: number, quality?: PostQuality, depth?: PostDepthInfo | null, grainSeed?: number, frame?: PostFrameState | null, rays?: Float32Array | null): void;
+export {};