@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/post/blend.js

@@ -0,0 +1,129 @@
+import { ease } from '../tween/ease.js';
+export const easeLinear = ease.linear;
+/** Smoothstep: gentle start and end. The default for `blendTo`. */
+export const easeInOut = ease.smoothstep;
+export const easeOut = ease.quadOut;
+export const easeIn = ease.quadIn;
+/**
+ * Fields that only make sense as whole values, by `section.key`: `bloom.levels` would resize
+ * mid-blend, `lut.texture` is a handle and `lut.size` must match it, `motionBlur.mode` is a
+ * choice. They switch when the blend ends (any other non-number does too).
+ */
+const SNAP_KEYS = new Set(['bloom.levels', 'lut.texture', 'lut.size', 'motionBlur.mode']);
+/**
+ * Interpolates post settings over time. Numbers and RGB triples ease from their value when
+ * `blendTo` is called; everything else switches at once (`enabled: true`, so a pass can fade
+ * in) or at the end (`enabled: false`, `tonemap`, `dither`, `levels`, so a pass can fade out).
+ * Pure: no GPU, no clock. `PostStack` advances it with the frame time.
+ */
+export class PostBlender {
+    tracks = [];
+    /** True while any value is still moving. */
+    get active() {
+        return this.tracks.length > 0;
+    }
+    blendTo(target, patch, seconds, ease) {
+        const dur = Math.max(0, Number.isFinite(seconds) ? seconds : 0);
+        for (const name of Object.keys(patch)) {
+            const src = patch[name];
+            if (!src)
+                continue;
+            const section = name;
+            const cur = target[section];
+            for (const key of Object.keys(src)) {
+                const to = src[key];
+                if (to === undefined)
+                    continue;
+                this.drop(section, key);
+                const from = cur[key];
+                const numeric = !SNAP_KEYS.has(`${section}.${key}`) &&
+                    ((typeof to === 'number' && typeof from === 'number') ||
+                        (Array.isArray(to) && Array.isArray(from) && to.length === from.length));
+                if (!numeric) {
+                    // Turning something on happens first so its values can ease in; the rest waits.
+                    if (to === true || dur === 0) {
+                        cur[key] = to;
+                        continue;
+                    }
+                }
+                if (dur === 0) {
+                    cur[key] = Array.isArray(to) ? [...to] : to;
+                    continue;
+                }
+                // Own the array we animate in place (it may be a preset object shared via `set`).
+                if (numeric && Array.isArray(from))
+                    cur[key] = [...from];
+                this.tracks.push({
+                    section,
+                    key,
+                    from: Array.isArray(from) ? [...from] : from,
+                    to: Array.isArray(to) ? [...to] : to,
+                    snap: !numeric,
+                    elapsed: 0,
+                    seconds: dur,
+                    ease,
+                });
+            }
+        }
+    }
+    /** Stop blending the given keys (e.g. after `set` overwrote them). */
+    cancel(patch) {
+        if (!this.tracks.length)
+            return;
+        for (const name of Object.keys(patch)) {
+            const src = patch[name];
+            if (!src)
+                continue;
+            for (const key of Object.keys(src))
+                this.drop(name, key);
+        }
+    }
+    /** Jump every track to its end value. */
+    finish(target) {
+        for (const t of this.tracks)
+            t.elapsed = t.seconds;
+        this.advance(target, 0);
+    }
+    /** Move every track forward by `dt` seconds and write the values into `target`. */
+    advance(target, dt) {
+        const tracks = this.tracks;
+        let w = 0;
+        for (let i = 0; i < tracks.length; i++) {
+            const t = tracks[i];
+            t.elapsed += Math.max(0, dt);
+            const p = Math.min(1, t.elapsed / t.seconds);
+            const cur = target[t.section];
+            if (t.snap) {
+                if (p >= 1)
+                    cur[t.key] = t.to;
+            }
+            else {
+                const k = t.ease(p);
+                if (typeof t.to === 'number') {
+                    const a = t.from;
+                    cur[t.key] = p >= 1 ? t.to : a + (t.to - a) * k;
+                }
+                else {
+                    const out = cur[t.key];
+                    const a = t.from;
+                    const b = t.to;
+                    for (let j = 0; j < b.length; j++)
+                        out[j] = p >= 1 ? b[j] : a[j] + (b[j] - a[j]) * k;
+                }
+            }
+            if (p < 1)
+                tracks[w++] = t;
+        }
+        tracks.length = w;
+    }
+    drop(section, key) {
+        const tracks = this.tracks;
+        let w = 0;
+        for (let i = 0; i < tracks.length; i++) {
+            const t = tracks[i];
+            if (t.section !== section || t.key !== key)
+                tracks[w++] = t;
+        }
+        tracks.length = w;
+    }
+}

package/dist/post/depth-pass.d.ts

@@ -0,0 +1,43 @@
+import type { Renderer } from '../render/renderer.js';
+/**
+ * A fullscreen pass that reads the scene's depth buffer (ws/post-depth). `FullscreenPass` binds
+ * `texture_2d<f32>` only, so the two depth passes build their own layout:
+ *
+ * - `@binding(0)` the post uniforms (`WGSL_POST_UNIFORMS`),
+ * - `@binding(1)` a nearest-clamp sampler, `@binding(2)` a linear-clamp sampler,
+ * - `@binding(3)` the depth as `texture_depth_2d`,
+ * - `@binding(4 + i)` `textures` further `texture_2d<f32>` inputs.
+ *
+ * `format` may list several targets (ws/post-5: the TAA resolve also writes its history aux);
+ * `encode` then takes the targets after the first in `extraTargets`.
+ *
+ * One uniform buffer per pass, written with `setUniforms` (or copied into on the encoder,
+ * `uniformBuffer`, when several XR eyes share one submit). Bind groups come from
+ * `createBindGroup` and are cached by the caller, as with `FullscreenPass`.
+ */
+export declare class DepthPass {
+    readonly label: string;
+    private readonly device;
+    private readonly pipeline;
+    private readonly layout;
+    private readonly uniforms;
+    private readonly nearest;
+    private readonly linear;
+    private readonly textures;
+    private readonly colorAttachments;
+    private readonly passDesc;
+    private readonly entries;
+    constructor(renderer: Renderer, desc: {
+        label: string;
+        wgsl: string;
+        format: GPUTextureFormat | readonly GPUTextureFormat[];
+        textures: number;
+    });
+    /** The pass's uniform buffer, for an encoder-ordered copy (ws/render-12: one per XR eye). */
+    get uniformBuffer(): GPUBuffer;
+    setUniforms(data: Float32Array): void;
+    /** A bind group for `depth` and `textures` further inputs (cache it; rebuild on change). */
+    createBindGroup(depth: GPUTextureView, views: readonly GPUTextureView[]): GPUBindGroup;
+    encode(encoder: GPUCommandEncoder, target: GPUTextureView, group: GPUBindGroup, timestampWrites?: GPURenderPassTimestampWrites, extraTargets?: readonly GPUTextureView[]): void;
+    destroy(): void;
+}

package/dist/post/depth-pass.js

@@ -0,0 +1,118 @@
+import { createShaderModule, WGSL_FULLSCREEN_PRELUDE } from '../render/wgsl.js';
+import { POST_UNIFORM_FLOATS } from './settings.js';
+/**
+ * A fullscreen pass that reads the scene's depth buffer (ws/post-depth). `FullscreenPass` binds
+ * `texture_2d<f32>` only, so the two depth passes build their own layout:
+ *
+ * - `@binding(0)` the post uniforms (`WGSL_POST_UNIFORMS`),
+ * - `@binding(1)` a nearest-clamp sampler, `@binding(2)` a linear-clamp sampler,
+ * - `@binding(3)` the depth as `texture_depth_2d`,
+ * - `@binding(4 + i)` `textures` further `texture_2d<f32>` inputs.
+ *
+ * `format` may list several targets (ws/post-5: the TAA resolve also writes its history aux);
+ * `encode` then takes the targets after the first in `extraTargets`.
+ *
+ * One uniform buffer per pass, written with `setUniforms` (or copied into on the encoder,
+ * `uniformBuffer`, when several XR eyes share one submit). Bind groups come from
+ * `createBindGroup` and are cached by the caller, as with `FullscreenPass`.
+ */
+export class DepthPass {
+    label;
+    device;
+    pipeline;
+    layout;
+    uniforms;
+    nearest;
+    linear;
+    textures;
+    colorAttachments;
+    passDesc;
+    entries;
+    constructor(renderer, desc) {
+        const formats = typeof desc.format === 'string' ? [desc.format] : desc.format;
+        const device = renderer.device;
+        this.device = device;
+        this.label = desc.label;
+        this.textures = desc.textures;
+        this.nearest = renderer.samplers['nearest-clamp'];
+        this.linear = renderer.samplers['linear-clamp'];
+        const frag = GPUShaderStage.FRAGMENT;
+        const entries = [
+            { binding: 0, visibility: frag, buffer: {} },
+            { binding: 1, visibility: frag, sampler: { type: 'non-filtering' } },
+            { binding: 2, visibility: frag, sampler: {} },
+            { binding: 3, visibility: frag, texture: { sampleType: 'depth' } },
+        ];
+        for (let i = 0; i < desc.textures; i++) {
+            entries.push({ binding: 4 + i, visibility: frag, texture: { sampleType: 'float' } });
+        }
+        this.layout = device.createBindGroupLayout({ label: `pass:${desc.label}`, entries });
+        this.uniforms = device.createBuffer({
+            label: `pass:${desc.label}-uniforms`,
+            size: POST_UNIFORM_FLOATS * 4,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        const code = `${WGSL_FULLSCREEN_PRELUDE}\n// ---- pass: ${desc.label} ----\n${desc.wgsl}`;
+        const module = createShaderModule(device, code, `pass:${desc.label}`);
+        this.pipeline = device.createRenderPipeline({
+            label: `pass:${desc.label}`,
+            layout: device.createPipelineLayout({ bindGroupLayouts: [this.layout] }),
+            vertex: { module, entryPoint: 'vs_fullscreen' },
+            fragment: { module, entryPoint: 'fs_main', targets: formats.map((format) => ({ format })) },
+            primitive: { topology: 'triangle-list' },
+        });
+        this.entries = [
+            { binding: 0, resource: { buffer: this.uniforms } },
+            { binding: 1, resource: this.nearest },
+            { binding: 2, resource: this.linear },
+        ];
+        this.colorAttachments = formats.map(() => ({
+            view: undefined,
+            loadOp: 'clear',
+            storeOp: 'store',
+            clearValue: { r: 1, g: 1, b: 1, a: 1 },
+        }));
+        this.passDesc = { label: `pass:${desc.label}`, colorAttachments: this.colorAttachments };
+    }
+    /** The pass's uniform buffer, for an encoder-ordered copy (ws/render-12: one per XR eye). */
+    get uniformBuffer() {
+        return this.uniforms;
+    }
+    setUniforms(data) {
+        this.device.queue.writeBuffer(this.uniforms, 0, data.buffer, data.byteOffset, data.byteLength);
+    }
+    /** A bind group for `depth` and `textures` further inputs (cache it; rebuild on change). */
+    createBindGroup(depth, views) {
+        if (views.length !== this.textures) {
+            throw new Error(`pass ${this.label}: expected ${this.textures} textures, got ${views.length}`);
+        }
+        const entries = this.entries.slice();
+        entries.push({ binding: 3, resource: depth });
+        for (let i = 0; i < views.length; i++)
+            entries.push({ binding: 4 + i, resource: views[i] });
+        return this.device.createBindGroup({
+            label: `pass:${this.label}`,
+            layout: this.layout,
+            entries,
+        });
+    }
+    encode(encoder, target, group, timestampWrites, extraTargets) {
+        const atts = this.colorAttachments;
+        atts[0].view = target;
+        for (let i = 1; i < atts.length; i++) {
+            const view = extraTargets?.[i - 1];
+            if (!view)
+                throw new Error(`pass ${this.label}: expected ${atts.length} targets`);
+            atts[i].view = view;
+        }
+        this.passDesc.timestampWrites = timestampWrites;
+        const pass = encoder.beginRenderPass(this.passDesc);
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, group);
+        pass.draw(3);
+        pass.end();
+    }
+    destroy() {
+        this.uniforms.destroy();
+    }
+}

package/dist/post/dof.d.ts

@@ -0,0 +1 @@
+export declare const DOF_WGSL = "\n\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\n@group(0) @binding(1) var nearest: sampler;\n@group(0) @binding(2) var linSamp: sampler;\n@group(0) @binding(3) var depthTex: texture_depth_2d;\n@group(0) @binding(4) var colorTex: texture_2d<f32>;\n\nfn view_pos(uv: vec2f, depth: f32) -> vec3f {\n  let ndc = vec3f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth);\n  let p = P.invProj * vec4f(ndc, 1.0);\n  return p.xyz / p.w;\n}\nfn linear_depth(uv: vec2f, depth: f32) -> f32 {\n  return -view_pos(uv, depth).z;\n}\n/** The centre of the depth texel under `uv`: positions must be rebuilt where the depth was read. */\nfn texel_uv(uv: vec2f, dim: vec2f) -> vec2f {\n  return (floor(clamp(uv, vec2f(0.0), vec2f(0.9999)) * dim) + 0.5) / dim;\n}\n\n\n/** Signed circle of confusion in uv (fraction of the width). */\nfn coc_at(uv: vec2f) -> f32 {\n  let d = textureSampleLevel(depthTex, nearest, uv, 0u);\n  var z = P.dof.y + P.dof.z * 4.0; // sky: past the far side of the range\n  if (d < 1.0) {\n    z = linear_depth(uv, d);\n  }\n  var c = clamp((z - P.dof.y) / P.dof.z, -1.0, 1.0);\n  if (P.dof2.x < 0.5) {\n    c = max(c, 0.0);\n  }\n  return c * P.dof.w;\n}\n\nfn ign(px: vec2f) -> f32 {\n  return fract(52.9829189 * fract(0.06711056 * px.x + 0.00583715 * px.y));\n}\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let uv = in.uv;\n  let aspect = P.frame.y;\n  let cc = coc_at(uv);\n  let r = abs(cc);\n  var sum = textureSampleLevel(colorTex, linSamp, uv, 0.0).rgb;\n  var wsum = 1.0;\n  let count = i32(P.dof2.y);\n  let rot = ign(in.pos.xy) * 6.2831853;\n  // Taps reach as far as the widest CoC they could meet, so blurred things behind a sharp\n  // edge still gather; each tap's own CoC decides whether it belongs.\n  let reach = max(r, P.dof.w * 0.5);\n  for (var i = 0; i < count; i++) {\n    let a = (f32(i) + 0.5) / f32(count);\n    let ang = rot + f32(i) * 2.39996323;\n    let dist = sqrt(a) * reach;\n    let suv = uv + vec2f(cos(ang), sin(ang) * aspect) * dist;\n    let sc = coc_at(suv);\n    // A sample contributes where its own circle covers this pixel (or ours covers it).\n    let cover = max(abs(sc), select(0.0, r, sc > 0.0 && cc > 0.0));\n    let w = clamp((cover - dist) / max(P.dof.w * 0.05, 1e-5) + 1.0, 0.0, 1.0);\n    sum += textureSampleLevel(colorTex, linSamp, suv, 0.0).rgb * w;\n    wsum += w;\n  }\n  return vec4f(sum / wsum, cc);\n}\n";

package/dist/post/dof.js

@@ -0,0 +1,66 @@
+/**
+ * Depth of field (ws/post-depth): a half-res gather over the scene colour weighted by the
+ * circle of confusion, which comes from linear depth. The composite blends sharp and blurred
+ * by the CoC it reads from this pass's alpha.
+ *
+ * CoC is signed: negative in front of the focus (near field), positive behind. Without
+ * `dof.nearBlur` the near side is clamped to 0. The gather takes `PostQuality.dofTaps` taps on
+ * a golden-angle disc (so the pattern has no axis), scaled by the centre's CoC and rotated per
+ * pixel by interleaved-gradient noise; each tap counts by how far its own CoC reaches the centre,
+ * so a sharp foreground does not bleed into a blurred background.
+ */
+import { WGSL_DEPTH_VIEW } from './ao.js';
+import { WGSL_POST_UNIFORMS } from './settings.js';
+export const DOF_WGSL = /* wgsl */ `
+${WGSL_POST_UNIFORMS}
+@group(0) @binding(1) var nearest: sampler;
+@group(0) @binding(2) var linSamp: sampler;
+@group(0) @binding(3) var depthTex: texture_depth_2d;
+@group(0) @binding(4) var colorTex: texture_2d<f32>;
+${WGSL_DEPTH_VIEW}
+
+/** Signed circle of confusion in uv (fraction of the width). */
+fn coc_at(uv: vec2f) -> f32 {
+  let d = textureSampleLevel(depthTex, nearest, uv, 0u);
+  var z = P.dof.y + P.dof.z * 4.0; // sky: past the far side of the range
+  if (d < 1.0) {
+    z = linear_depth(uv, d);
+  }
+  var c = clamp((z - P.dof.y) / P.dof.z, -1.0, 1.0);
+  if (P.dof2.x < 0.5) {
+    c = max(c, 0.0);
+  }
+  return c * P.dof.w;
+}
+
+fn ign(px: vec2f) -> f32 {
+  return fract(52.9829189 * fract(0.06711056 * px.x + 0.00583715 * px.y));
+}
+
+@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {
+  let uv = in.uv;
+  let aspect = P.frame.y;
+  let cc = coc_at(uv);
+  let r = abs(cc);
+  var sum = textureSampleLevel(colorTex, linSamp, uv, 0.0).rgb;
+  var wsum = 1.0;
+  let count = i32(P.dof2.y);
+  let rot = ign(in.pos.xy) * 6.2831853;
+  // Taps reach as far as the widest CoC they could meet, so blurred things behind a sharp
+  // edge still gather; each tap's own CoC decides whether it belongs.
+  let reach = max(r, P.dof.w * 0.5);
+  for (var i = 0; i < count; i++) {
+    let a = (f32(i) + 0.5) / f32(count);
+    let ang = rot + f32(i) * 2.39996323;
+    let dist = sqrt(a) * reach;
+    let suv = uv + vec2f(cos(ang), sin(ang) * aspect) * dist;
+    let sc = coc_at(suv);
+    // A sample contributes where its own circle covers this pixel (or ours covers it).
+    let cover = max(abs(sc), select(0.0, r, sc > 0.0 && cc > 0.0));
+    let w = clamp((cover - dist) / max(P.dof.w * 0.05, 1e-5) + 1.0, 0.0, 1.0);
+    sum += textureSampleLevel(colorTex, linSamp, suv, 0.0).rgb * w;
+    wsum += w;
+  }
+  return vec4f(sum / wsum, cc);
+}
+`;

package/dist/post/exposure.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Auto-exposure (ws/post-3). Two compute passes over the scene colour: `histogram` bins the
+ * log2 luminance of every texel into 64 bins over `EXPOSURE_LOG_MIN..EXPOSURE_LOG_MAX`
+ * (workgroup-shared counts, then one atomic add per bin), `average` has one thread walk the
+ * bins between the `histogramLow..histogramHigh` percentiles and write the weighted mean log
+ * luminance. The stack copies that into a mappable buffer, maps it when the previous frame's
+ * copy has landed, and eases its EV toward `exposureTarget(...)` with `adaptExposure` each
+ * frame on the CPU. `exposureHistogram` and `exposureAverage` are the same two kernels in
+ * TypeScript, for tests and for a CPU reference.
+ */
+import type { Renderer } from '../render/renderer.js';
+export declare const EXPOSURE_BINS = 64;
+/** log2 luminance of the first bin's lower edge (2^-10 ≈ 0.001). */
+export declare const EXPOSURE_LOG_MIN = -10;
+/** log2 luminance of the last bin's upper edge (2^6 = 64). */
+export declare const EXPOSURE_LOG_MAX = 6;
+/** The bin (0..63) a luminance falls in; black and anything under the range land in bin 0. */
+export declare function exposureBin(luminance: number): number;
+/** log2 luminance at the centre of bin `i`. */
+export declare function exposureBinLog(i: number): number;
+/**
+ * CPU reference of the histogram kernel: `rgba` holds `count` linear RGBA texels (any
+ * `ArrayLike`); `out` (64 entries) receives the counts (cleared first).
+ */
+export declare function exposureHistogram(rgba: ArrayLike<number>, count: number, out?: Uint32Array): Uint32Array;
+/**
+ * CPU reference of the average kernel: the mean log2 luminance of the texels between the
+ * `low` and `high` percentiles of `hist` (bins partially inside the range count partially).
+ * Returns `EXPOSURE_LOG_MIN` for an empty histogram.
+ */
+export declare function exposureAverage(hist: ArrayLike<number>, low: number, high: number): number;
+/** The EV the metered average asks for: `log2(keyValue / average)`, clamped to the range. */
+export declare function exposureTarget(averageLog: number, keyValue: number, minEv: number, maxEv: number): number;
+/**
+ * One step of the adaptation: `ev` eased toward `target` over `dt` seconds, at `speedUp`
+ * per second when rising and `speedDown` when falling (exponential, so it settles without
+ * overshoot and a long `dt` lands on the target).
+ */
+export declare function adaptExposure(ev: number, target: number, dt: number, speedUp: number, speedDown: number): number;
+/**
+ * The two compute passes and their buffers. `encode` records both (clearing the histogram
+ * first) and the copy into the readback buffer; `poll` maps it when free and stores the last
+ * average in `averageLog`. On a device without `mapAsync` (the fake one) nothing is read back.
+ */
+export declare class ExposurePasses {
+    private readonly device;
+    private readonly histogram;
+    private readonly average;
+    private readonly histLayout;
+    private readonly histBuffer;
+    private readonly resultBuffer;
+    private readonly readBuffer;
+    private readonly params;
+    private readonly paramData;
+    private readonly averageGroup;
+    private histGroup;
+    private boundColor;
+    private readonly histDesc;
+    private readonly avgDesc;
+    /** A copy into the readback buffer is in flight (the next `poll` may map it). */
+    private pending;
+    private mapping;
+    /** The last metered average log2 luminance (`EXPOSURE_LOG_MIN` until the first readback). */
+    averageLog: number;
+    /** How many readbacks have landed. */
+    readbacks: number;
+    private readonly onMapped;
+    private readonly onMapFailed;
+    constructor(renderer: Renderer);
+    /**
+     * Map the last copy if one is waiting and the buffer is free (call before `encode`, once the
+     * previous frame's work has been submitted).
+     */
+    poll(): void;
+    /** Record the histogram, the average and (when the readback buffer is free) the copy. */
+    encode(encoder: GPUCommandEncoder, color: GPUTextureView, width: number, height: number, low: number, high: number): void;
+    /** Forget a stale bind group (the colour texture was replaced). */
+    invalidate(): void;
+    destroy(): void;
+}