@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/post/settings.js

@@ -0,0 +1,416 @@
+/** Post-stack settings. All colours are linear RGB. Mutate in place at runtime; read each frame. */
+import { mat4 } from '../core/math.js';
+import { whiteBalanceMatrix } from './white-balance.js';
+/**
+ * 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 function cinematicPostSettings() {
+    return {
+        bloom: {
+            enabled: true,
+            intensity: 0.9,
+            threshold: 1.2,
+            knee: 0.5,
+            emissiveWeight: 1,
+            scatter: 0.75,
+            levels: 6,
+        },
+        mist: {
+            enabled: true,
+            color: [0.11, 0.13, 0.19],
+            density: 0.65,
+            top: 0.55,
+            bottom: 1.0,
+            falloff: 1.6,
+            noiseScale: 3.0,
+            speed: 0.04,
+            lightScatter: 0.6,
+        },
+        godRays: {
+            enabled: true,
+            x: 960,
+            y: -80,
+            intensity: 0.45,
+            decay: 0.965,
+            density: 0.85,
+            weight: 0.035,
+            color: [0.7, 0.85, 1.0],
+            sourceRadius: 160,
+            sourceIntensity: 1.0,
+            bloomSource: 0.35,
+        },
+        vignette: { enabled: true, intensity: 0.65, radius: 0.55, softness: 0.55, color: [0, 0, 0] },
+        grade: {
+            enabled: true,
+            exposure: 1,
+            tonemap: 'aces',
+            lift: [0, 0, 0],
+            gamma: [1, 1, 1],
+            gain: [1, 1, 1],
+            saturation: 1.1,
+            contrast: 1.05,
+            dither: true,
+        },
+        ao: { enabled: false, radius: 0.5, intensity: 1, bias: 0.02, power: 1.5 },
+        dof: { enabled: false, focusDistance: 10, focusRange: 6, maxBlur: 8, nearBlur: true },
+        fxaa: { enabled: false, subpixel: 0.75, edgeThreshold: 0.125 },
+        lut: { texture: null, size: 32, intensity: 1 },
+        grain: { intensity: 0, size: 1, luminanceResponse: 0.5, animated: true },
+        aberration: { intensity: 0, radialOnly: true },
+        sharpen: { amount: 0 },
+        outline: {
+            enabled: false,
+            color: [0, 0, 0],
+            thickness: 1.5,
+            depthThreshold: 0.03,
+            normalThreshold: 0.4,
+            intensity: 1,
+        },
+        taa: {
+            enabled: false,
+            feedback: 0.9,
+            sharpen: 0.2,
+            clampMode: 'aabb',
+            reprojection: 'velocity',
+            depthReject: 0.1,
+            velocityReject: 2,
+            historyFilter: 'catmull-rom',
+        },
+        ssr: {
+            enabled: false,
+            maxSteps: 32,
+            thickness: 0.5,
+            maxDistance: 20,
+            roughnessCutoff: 0.6,
+            intensity: 1,
+            fadeEdges: 0.15,
+        },
+        exposure: {
+            mode: 'manual',
+            minEv: -4,
+            maxEv: 4,
+            speedUp: 3,
+            speedDown: 1,
+            keyValue: 0.18,
+            histogramLow: 0.4,
+            histogramHigh: 0.95,
+        },
+        whiteBalance: { temperature: 6500, tint: 0 },
+        motionBlur: { enabled: false, mode: 'object', intensity: 1, maxSamples: 8 },
+    };
+}
+/**
+ * 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 function neutralPostSettings() {
+    const s = cinematicPostSettings();
+    s.bloom.enabled = false;
+    s.mist.enabled = false;
+    s.godRays.enabled = false;
+    s.vignette.enabled = false;
+    s.grade.saturation = 1;
+    s.grade.contrast = 1;
+    return s;
+}
+/**
+ * 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 function clonePostSettings(s) {
+    const out = {};
+    for (const key of Object.keys(s))
+        out[key] = cloneValue(s[key]);
+    return out;
+}
+function cloneValue(v) {
+    if (Array.isArray(v))
+        return v.map(cloneValue);
+    if (v === null || typeof v !== 'object')
+        return v;
+    const out = {};
+    // `texture` fields are GPU handles: shared, never copied.
+    for (const [k, x] of Object.entries(v))
+        out[k] = k === 'texture' ? x : cloneValue(x);
+    return out;
+}
+/** Shallow-per-section merge of `patch` into `target` (mutates target). */
+export function applyPostPatch(target, patch) {
+    for (const key of Object.keys(patch)) {
+        const section = patch[key];
+        if (section)
+            Object.assign(target[key], section);
+    }
+    return target;
+}
+export function defaultPostQuality() {
+    return {
+        maxBloomLevels: 8,
+        raySamples: 64,
+        fogOctaves: 5,
+        compositeAtScene: false,
+        aoSamples: 12,
+        dofTaps: 24,
+        fxaa: true,
+        outline: true,
+        taa: true,
+        ssr: true,
+        autoExposure: true,
+        motionBlur: true,
+    };
+}
+/**
+ * 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 function lowPostQuality() {
+    return {
+        maxBloomLevels: 4,
+        raySamples: 24,
+        fogOctaves: 3,
+        compositeAtScene: true,
+        aoSamples: 6,
+        dofTaps: 12,
+        fxaa: false,
+        outline: false,
+        taa: true,
+        ssr: false,
+        autoExposure: true,
+        motionBlur: false,
+    };
+}
+/**
+ * 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 function postQualityFor(tier) {
+    switch (tier) {
+        case 'phone':
+            return lowPostQuality();
+        case 'tablet':
+            return {
+                ...defaultPostQuality(),
+                maxBloomLevels: 6,
+                raySamples: 48,
+                aoSamples: 8,
+                dofTaps: 16,
+                ssr: false,
+            };
+        case 'xr':
+            return { ...defaultPostQuality(), taa: false, ssr: false, motionBlur: false };
+        default:
+            return defaultPostQuality();
+    }
+}
+/**
+ * Uniform layout shared by all post shaders: 22 × vec4f + mat4x4f + 17 × vec4f + mat4x4f +
+ * vec4f.
+ */
+export const POST_UNIFORM_FLOATS = 192;
+export const WGSL_POST_UNIFORMS = /* wgsl */ `
+struct PostUniforms {
+  frame: vec4f,      // time, aspect, 1/width, 1/height
+  enables: vec4f,    // bloom, fog, rays, vignette
+  enables2: vec4f,   // grade, tonemap (0 none, 1 aces, 2 reinhard), dither, exposure
+  bloom: vec4f,      // intensity, threshold, knee, emissiveWeight
+  bloom2: vec4f,     // scatter, -, -, -
+  fogColor: vec4f,   // rgb, density
+  fog: vec4f,        // top, bottom, noiseScale, speed
+  fog2: vec4f,       // lightScatter, falloff, -, -
+  rays: vec4f,       // light uv x, y, intensity, decay
+  rays2: vec4f,      // density, weight, source radius (uv-y units), source intensity
+  raysColor: vec4f,  // rgb, bloomSource
+  vignette: vec4f,   // intensity, radius, softness, -
+  vignetteColor: vec4f,
+  lift: vec4f,
+  gamma: vec4f,
+  gain: vec4f,
+  grade: vec4f,      // saturation, contrast, -, -
+  quality: vec4f,    // ray samples, fog octaves, ortho projection (1, ws/post-4), -
+  ao: vec4f,         // enabled (0 without depth), radius, intensity, bias
+  ao2: vec4f,        // power, samples, proj x scale, proj y scale
+  dof: vec4f,        // enabled (0 without depth), focus distance, focus range, max blur (uv of width)
+  dof2: vec4f,       // near blur, taps, near plane, far plane
+  invProj: mat4x4f,  // clip -> view
+  fxaa: vec4f,       // enabled, subpixel, edgeThreshold, -
+  lut: vec4f,        // enabled, (size-1)/size, intensity, 0.5/size
+  grain: vec4f,      // intensity, cell size (px), luminanceResponse, seed
+  aberration: vec4f, // intensity (px), radialOnly, -, -
+  sharpen: vec4f,    // amount, -, -, -
+  outline: vec4f,    // enabled (0 without depth), thickness (scene px), depthThreshold, normalThreshold
+  outlineColor: vec4f, // rgb, intensity
+  // Post 3 (ws/post-3).
+  taa: vec4f,        // enabled (0 without depth), feedback, sharpen, clampMode (0 aabb, 1 variance)
+  taa2: vec4f,       // view jitter x (uv), view jitter y (uv), reset (1 = copy the current frame), velocity reprojection (1, ws/post-5)
+  ssr: vec4f,        // enabled (0 without depth), maxSteps, thickness, maxDistance
+  ssr2: vec4f,       // roughnessCutoff, intensity, fadeEdges (uv), rough-metal target (1)
+  exposure: vec4f,   // auto (1), histogramLow, histogramHigh, keyValue
+  wb0: vec4f,        // white-balance matrix row 0 (rgb weights), enabled
+  wb1: vec4f,        // row 1
+  wb2: vec4f,        // row 2
+  motionBlur: vec4f, // enabled (0 without depth), intensity, samples, velocity target (1 = object)
+  dirt: vec4f,       // enabled, intensity, -, -
+  reproj: mat4x4f,   // current clip -> previous frame's clip (identity on a reset)
+  // Post 5 (ws/post-5).
+  taa3: vec4f,       // depthReject (fraction), velocityReject (px), history filter (1 = Catmull-Rom, ws/post-6), -
+};
+@group(0) @binding(0) var<uniform> P: PostUniforms;
+`;
+const TONEMAP_ID = { none: 0, aces: 1, reinhard: 2 };
+/**
+ * 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 function godRaySource(viewProj, direction, width, height, out) {
+    const x = -(direction[0] ?? 0);
+    const y = -(direction[1] ?? 0);
+    const z = -(direction[2] ?? 0);
+    const m = viewProj;
+    const w = m[3] * x + m[7] * y + m[11] * z;
+    if (!(w > 1e-6))
+        return 0;
+    const cx = (m[0] * x + m[4] * y + m[8] * z) / w;
+    const cy = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[0] = ((cx + 1) / 2) * width;
+    out[1] = ((1 - cy) / 2) * height;
+    return 1;
+}
+/**
+ * The god-ray source for this frame: `x`/`y`, or `godRaySource` of `direction` through `view`.
+ * Writes x, y and visibility into `out`.
+ */
+export function resolveGodRays(r, viewProj, logicalWidth, logicalHeight, out) {
+    out[0] = r.x;
+    out[1] = r.y;
+    out[2] = 1;
+    if (r.direction && viewProj) {
+        out[2] = godRaySource(viewProj, r.direction, logicalWidth, logicalHeight, out);
+    }
+}
+/** Pack settings into the uniform array (no allocation). */
+export function packPostUniforms(out, s, time, width, height, logicalWidth, logicalHeight, quality = DEFAULT_QUALITY, depth = null, grainSeed = 0, frame = null, rays = null) {
+    const b = s.bloom;
+    const f = s.mist;
+    const r = s.godRays;
+    const v = s.vignette;
+    const g = s.grade;
+    const auto = s.exposure.mode === 'auto' && quality.autoExposure && frame !== null;
+    let o = 0;
+    o = put(out, o, time, width / height, 1 / width, 1 / height);
+    o = put(out, o, +b.enabled, +f.enabled, +r.enabled, +v.enabled);
+    o = put(out, o, +g.enabled, g.enabled ? TONEMAP_ID[g.tonemap] : 1, +g.dither, auto ? frame.autoExposure : g.exposure);
+    o = put(out, o, b.intensity, b.threshold, b.knee, b.emissiveWeight);
+    o = put(out, o, b.scatter, 0, 0, 0);
+    o = put(out, o, f.color[0], f.color[1], f.color[2], f.density);
+    o = put(out, o, f.top, f.bottom, f.noiseScale, f.speed);
+    o = put(out, o, f.lightScatter, f.falloff, 0, 0);
+    // `rays` (x, y, visibility) is the resolved source when the stack placed it from `direction`.
+    const rx = rays ? rays[0] : r.x;
+    const ry = rays ? rays[1] : r.y;
+    const rv = rays ? rays[2] : 1;
+    o = put(out, o, rx / logicalWidth, ry / logicalHeight, r.intensity * rv, r.decay);
+    o = put(out, o, r.density, r.weight, r.sourceRadius / logicalHeight, r.sourceIntensity * rv);
+    o = put(out, o, r.color[0], r.color[1], r.color[2], r.bloomSource);
+    o = put(out, o, v.intensity, v.radius, v.softness, 0);
+    o = put(out, o, v.color[0], v.color[1], v.color[2], 0);
+    o = put(out, o, g.lift[0], g.lift[1], g.lift[2], 0);
+    o = put(out, o, g.gamma[0], g.gamma[1], g.gamma[2], 0);
+    o = put(out, o, g.gain[0], g.gain[1], g.gain[2], 0);
+    o = put(out, o, g.saturation, g.contrast, 0, 0);
+    o = put(out, o, Math.round(Math.min(64, Math.max(8, quality.raySamples))), Math.round(Math.min(5, Math.max(2, quality.fogOctaves))), depth?.ortho ? 1 : 0, 0);
+    const a = s.ao;
+    const d = s.dof;
+    const ao = depth !== null && a.enabled ? 1 : 0;
+    const dof = depth !== null && d.enabled ? 1 : 0;
+    o = put(out, o, ao, a.radius, a.intensity, a.bias);
+    o = put(out, o, a.power, Math.round(Math.min(16, Math.max(4, quality.aoSamples))), depth?.projX ?? 1, depth?.projY ?? 1);
+    const blurUv = depth ? d.maxBlur / Math.max(1, depth.outputWidth) : 0;
+    o = put(out, o, dof, d.focusDistance, Math.max(1e-3, d.focusRange), blurUv);
+    o = put(out, o, +d.nearBlur, Math.round(Math.min(32, Math.max(8, quality.dofTaps))), depth?.near ?? 0, depth?.far ?? 0);
+    if (depth) {
+        for (let i = 0; i < 16; i++)
+            out[o + i] = depth.invProj[i];
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            out[o + i] = 0;
+    }
+    o += 16;
+    // Finishing passes (ws/post-2).
+    const x = s.fxaa;
+    const l = s.lut;
+    const gr = s.grain;
+    const ab = s.aberration;
+    const ol = s.outline;
+    o = put(out, o, x.enabled && quality.fxaa ? 1 : 0, x.subpixel, x.edgeThreshold, 0);
+    const n = Math.max(2, l.size);
+    o = put(out, o, l.texture !== null ? 1 : 0, (n - 1) / n, l.intensity, 0.5 / n);
+    o = put(out, o, gr.intensity, Math.max(1, gr.size), gr.luminanceResponse, gr.animated ? grainSeed : 0);
+    o = put(out, o, ab.intensity, +ab.radialOnly, 0, 0);
+    o = put(out, o, s.sharpen.amount, 0, 0, 0);
+    const outline = depth !== null && ol.enabled && quality.outline ? 1 : 0;
+    // `thickness` is in output px; the outline pass runs at the scene size.
+    const thick = depth ? (ol.thickness * width) / Math.max(1, depth.outputWidth) : ol.thickness;
+    o = put(out, o, outline, thick, ol.depthThreshold, ol.normalThreshold);
+    o = put(out, o, ol.color[0], ol.color[1], ol.color[2], ol.intensity);
+    // Post 3 (ws/post-3). The temporal passes need depth and a frame state (a view matrix).
+    const temporal = depth !== null && frame !== null;
+    const t = s.taa;
+    const taa = temporal && t.enabled && quality.taa ? 1 : 0;
+    o = put(out, o, taa, Math.min(0.98, Math.max(0, t.feedback)), Math.max(0, t.sharpen), t.clampMode === 'variance' ? 1 : 0);
+    o = put(out, o, frame?.jitterX ?? 0, frame?.jitterY ?? 0, frame?.reset ?? 1, taa ? (frame?.taaVelocity ?? 0) : 0);
+    const sr = s.ssr;
+    const ssr = depth !== null && sr.enabled && quality.ssr ? 1 : 0;
+    o = put(out, o, ssr, Math.round(Math.min(64, Math.max(8, sr.maxSteps))), Math.max(1e-3, sr.thickness), Math.max(1e-3, sr.maxDistance));
+    o = put(out, o, sr.roughnessCutoff, sr.intensity, Math.max(0, sr.fadeEdges), ssr ? (frame?.roughMetal ?? 0) : 0);
+    const ex = s.exposure;
+    o = put(out, o, auto ? 1 : 0, ex.histogramLow, ex.histogramHigh, ex.keyValue);
+    const wb = s.whiteBalance;
+    const wbOn = wb.temperature !== 6500 || wb.tint !== 0;
+    if (wbOn) {
+        whiteBalanceMatrix(WB, wb.temperature, wb.tint);
+        o = put(out, o, WB[0], WB[1], WB[2], 1);
+        o = put(out, o, WB[3], WB[4], WB[5], 0);
+        o = put(out, o, WB[6], WB[7], WB[8], 0);
+    }
+    else {
+        o = put(out, o, 1, 0, 0, 0);
+        o = put(out, o, 0, 1, 0, 0);
+        o = put(out, o, 0, 0, 1, 0);
+    }
+    const mb = s.motionBlur;
+    const mblur = temporal && mb.enabled && quality.motionBlur ? 1 : 0;
+    o = put(out, o, mblur, mb.intensity, Math.round(Math.min(16, Math.max(2, mb.maxSamples))), mblur ? (frame?.objectVelocity ?? 0) : 0);
+    const dirt = b.dirt;
+    o = put(out, o, dirt && dirt.texture !== null ? 1 : 0, dirt?.intensity ?? 0, 0, 0);
+    if (frame) {
+        for (let i = 0; i < 16; i++)
+            out[o + i] = frame.reproj[i];
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            out[o + i] = IDENTITY[i];
+    }
+    o += 16;
+    put(out, o, Math.max(0, t.depthReject), Math.max(0, t.velocityReject), t.historyFilter === 'bilinear' ? 0 : 1, 0);
+}
+const DEFAULT_QUALITY = defaultPostQuality();
+const WB = new Float32Array(9);
+const IDENTITY = mat4.create();
+function put(out, o, x, y, z, w) {
+    out[o] = x;
+    out[o + 1] = y;
+    out[o + 2] = z;
+    out[o + 3] = w;
+    return o + 4;
+}

package/dist/post/shaders.d.ts

@@ -0,0 +1,25 @@
+/** Bright-pass + 2× downsample into bloom mip 0. Karis-weighted to tame fireflies. */
+export declare const PREFILTER_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 samp: sampler;\n@group(0) @binding(2) var colorTex: texture_2d<f32>;\n@group(0) @binding(3) var emissiveTex: texture_2d<f32>;\n\nfn soft_threshold(c: vec3f) -> vec3f {\n  let br = max(c.r, max(c.g, c.b));\n  let knee = max(P.bloom.z, 1e-4);\n  var rq = clamp(br - P.bloom.y + knee, 0.0, 2.0 * knee);\n  rq = rq * rq / (4.0 * knee);\n  let w = max(rq, br - P.bloom.y) / max(br, 1e-4);\n  return c * w;\n}\n\nfn tap(uv: vec2f) -> vec3f {\n  let c = textureSampleLevel(colorTex, samp, uv, 0.0).rgb;\n  let e = textureSampleLevel(emissiveTex, samp, uv, 0.0).rgb;\n  return min(e * P.bloom.w + soft_threshold(c), vec3f(64.0));\n}\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let t = 1.0 / vec2f(textureDimensions(colorTex));\n  let a = tap(in.uv + t * vec2f(-1.0, -1.0));\n  let b = tap(in.uv + t * vec2f(1.0, -1.0));\n  let c = tap(in.uv + t * vec2f(-1.0, 1.0));\n  let d = tap(in.uv + t * vec2f(1.0, 1.0));\n  let wa = 1.0 / (1.0 + engine_luma(a));\n  let wb = 1.0 / (1.0 + engine_luma(b));\n  let wc = 1.0 / (1.0 + engine_luma(c));\n  let wd = 1.0 / (1.0 + engine_luma(d));\n  let sum = (a * wa + b * wb + c * wc + d * wd) / max(wa + wb + wc + wd, 1e-4);\n  return vec4f(sum, 1.0);\n}\n";
+/** 13-tap downsample (Jimenez 2014). */
+export declare const DOWN_WGSL = "\n@group(0) @binding(1) var samp: sampler;\n@group(0) @binding(2) var src: texture_2d<f32>;\n\nfn s(uv: vec2f) -> vec3f { return textureSampleLevel(src, samp, uv, 0.0).rgb; }\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let t = 1.0 / vec2f(textureDimensions(src));\n  let uv = in.uv;\n  let a = s(uv + t * vec2f(-2.0, -2.0));\n  let b = s(uv + t * vec2f(0.0, -2.0));\n  let c = s(uv + t * vec2f(2.0, -2.0));\n  let d = s(uv + t * vec2f(-1.0, -1.0));\n  let e = s(uv + t * vec2f(1.0, -1.0));\n  let f = s(uv + t * vec2f(-2.0, 0.0));\n  let g = s(uv);\n  let h = s(uv + t * vec2f(2.0, 0.0));\n  let i = s(uv + t * vec2f(-1.0, 1.0));\n  let j = s(uv + t * vec2f(1.0, 1.0));\n  let k = s(uv + t * vec2f(-2.0, 2.0));\n  let l = s(uv + t * vec2f(0.0, 2.0));\n  let m = s(uv + t * vec2f(2.0, 2.0));\n  var o = (d + e + i + j) * 0.125;\n  o += (a + b + g + f) * 0.03125;\n  o += (b + c + h + g) * 0.03125;\n  o += (f + g + l + k) * 0.03125;\n  o += (g + h + m + l) * 0.03125;\n  return vec4f(o, 1.0);\n}\n";
+/** 9-tap tent upsample; additively blended (× blend constant) onto the finer level. */
+export declare const UP_WGSL = "\n@group(0) @binding(1) var samp: sampler;\n@group(0) @binding(2) var src: texture_2d<f32>;\n\nfn s(uv: vec2f) -> vec3f { return textureSampleLevel(src, samp, uv, 0.0).rgb; }\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let t = 1.0 / vec2f(textureDimensions(src));\n  let uv = in.uv;\n  var o = s(uv) * 4.0;\n  o += (s(uv + vec2f(-t.x, 0.0)) + s(uv + vec2f(t.x, 0.0)) + s(uv + vec2f(0.0, -t.y)) + s(uv + vec2f(0.0, t.y))) * 2.0;\n  o += s(uv + vec2f(-t.x, -t.y)) + s(uv + vec2f(t.x, -t.y)) + s(uv + vec2f(-t.x, t.y)) + s(uv + vec2f(t.x, t.y));\n  return vec4f(o / 16.0, 1.0);\n}\n";
+/** Screen-space god rays: radial march towards the light over bloom + a light disc. */
+export declare const RAYS_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 samp: sampler;\n@group(0) @binding(2) var bloomTex: texture_2d<f32>;\n\n// Reference sample count: decay and weight are tuned per step at 64 samples. With fewer\n// samples (P.quality.x) each step covers more distance, so decay and weight are rescaled.\nconst REF_SAMPLES: f32 = 64.0;\n\nfn source(uv: vec2f) -> vec3f {\n  let aspect = P.frame.y;\n  var s = textureSampleLevel(bloomTex, samp, uv, 0.0).rgb * P.raysColor.w;\n  let d = length((uv - P.rays.xy) * vec2f(aspect, 1.0));\n  let r = max(P.rays2.z, 1e-4);\n  let disc = 1.0 - smoothstep(0.0, r, d);\n  s += vec3f(disc * disc * P.rays2.w);\n  // Outside the screen there is no bloom; keep the disc (light can sit off-screen).\n  return s * P.raysColor.rgb;\n}\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  var coord = in.uv;\n  // Small per-pixel jitter hides the step pattern.\n  let jitter = engine_hash21(in.pos.xy + fract(P.frame.x) * 61.0);\n  let n = i32(clamp(P.quality.x, 8.0, 64.0));\n  let k = REF_SAMPLES / f32(n);\n  let delta = (coord - P.rays.xy) * (P.rays2.x / f32(n));\n  coord -= delta * jitter;\n  let decay = pow(P.rays.w, k);\n  let weight = P.rays2.y * k;\n  var illum = 1.0;\n  var acc = vec3f(0.0);\n  for (var i = 0; i < n; i++) {\n    coord -= delta;\n    acc += source(coord) * illum * weight;\n    illum *= decay;\n  }\n  return vec4f(acc * P.rays.z, 1.0);\n}\n";
+/** Final pass: combine, SSR, mist, bloom (× dirt), rays, white balance, exposure, tonemap, grade, vignette, dither, sRGB. */
+export declare const COMPOSITE_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 samp: sampler;\n@group(0) @binding(2) var colorTex: texture_2d<f32>;\n@group(0) @binding(3) var emissiveTex: texture_2d<f32>;\n@group(0) @binding(4) var bloomTex: texture_2d<f32>;\n@group(0) @binding(5) var raysTex: texture_2d<f32>;\n// Depth passes (ws/post-depth); bound to a placeholder and ignored while P.ao.x / P.dof.x are 0.\n@group(0) @binding(6) var aoTex: texture_2d<f32>;\n@group(0) @binding(7) var dofTex: texture_2d<f32>;\n// Finishing (ws/post-2): the outline mask (placeholder while P.outline.x is 0) and the 3D LUT\n// (a 1\u00D71\u00D71 placeholder while P.lut.x is 0).\n@group(0) @binding(8) var outlineTex: texture_2d<f32>;\n@group(0) @binding(9) var lutTex: texture_3d<f32>;\n// Post 3 (ws/post-3): the half-res SSR term (placeholder while P.ssr.x is 0) and the lens-dirt\n// map (placeholder while P.dirt.x is 0). TAA and motion blur replace colorTex with their result.\n@group(0) @binding(10) var ssrTex: texture_2d<f32>;\n@group(0) @binding(11) var dirtTex: texture_2d<f32>;\n\n/** The scene term: colour \u00D7 AO, blended toward the DoF result by CoC, plus emissive. */\nfn scene_at(uv: vec2f) -> vec3f {\n  var scene = textureSampleLevel(colorTex, samp, uv, 0.0).rgb;\n  if (P.ao.x > 0.5) {\n    scene *= textureSampleLevel(aoTex, samp, uv, 0.0).r;\n  }\n  if (P.dof.x > 0.5) {\n    // Alpha holds the signed CoC in uv of the width; blend in the blur from half a scene px up.\n    let blur = textureSampleLevel(dofTex, samp, uv, 0.0);\n    let px = abs(blur.a) / P.frame.z;\n    scene = mix(scene, blur.rgb, smoothstep(0.5, 2.0, px));\n  }\n  if (P.ssr.x > 0.5) {\n    // Premultiplied by its fade and intensity in the SSR pass.\n    scene += textureSampleLevel(ssrTex, samp, uv, 0.0).rgb;\n  }\n  return scene + textureSampleLevel(emissiveTex, samp, uv, 0.0).rgb;\n}\n\nfn aces(x: vec3f) -> vec3f {\n  let a = 2.51;\n  let b = 0.03;\n  let c = 2.43;\n  let d = 0.59;\n  let e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3f(0.0), vec3f(1.0));\n}\n\nfn to_srgb(c: vec3f) -> vec3f {\n  let lo = c * 12.92;\n  let hi = 1.055 * pow(c, vec3f(1.0 / 2.4)) - 0.055;\n  return select(hi, lo, c <= vec3f(0.0031308));\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 time = P.frame.x;\n  let texel = vec2f(P.frame.z, P.frame.w);\n  var c: vec3f;\n  if (P.aberration.x > 0.0) {\n    // Red and blue sampled either side of green along the radius, in scene px.\n    let d = (uv - 0.5) * vec2f(aspect, 1.0);\n    let r = length(d) / length(vec2f(aspect, 1.0) * 0.5);\n    let dir = d / max(length(d), 1e-4);\n    let amount = P.aberration.x * select(1.0, r * r, P.aberration.y > 0.5);\n    let o = dir * amount * texel;\n    c = vec3f(scene_at(uv + o).r, scene_at(uv).g, scene_at(uv - o).b);\n  } else {\n    c = scene_at(uv);\n  }\n  if (P.sharpen.x > 0.0) {\n    // Unsharp mask: the pixel minus its 4-neighbour mean, clamped so dark rims never go negative.\n    let blur = (scene_at(uv + vec2f(texel.x, 0.0)) + scene_at(uv - vec2f(texel.x, 0.0))\n      + scene_at(uv + vec2f(0.0, texel.y)) + scene_at(uv - vec2f(0.0, texel.y))) * 0.25;\n    c = max(c + (c - blur) * P.sharpen.x, vec3f(0.0));\n  }\n  if (P.outline.x > 0.5) {\n    let edge = textureSampleLevel(outlineTex, samp, uv, 0.0).r;\n    c = mix(c, P.outlineColor.rgb, clamp(edge * P.outlineColor.w, 0.0, 1.0));\n  }\n\n  var bloom = vec3f(0.0);\n  if (P.enables.x > 0.5) {\n    bloom = textureSampleLevel(bloomTex, samp, uv, 0.0).rgb;\n    if (P.dirt.x > 0.5) {\n      bloom *= 1.0 + textureSampleLevel(dirtTex, samp, uv, 0.0).rgb * P.dirt.y;\n    }\n  }\n\n  // Floor mist: height mask \u00D7 two drifting fbm layers, lit by nearby glow.\n  if (P.enables.y > 0.5) {\n    let span = max(P.fog.y - P.fog.x, 1e-3);\n    let h = pow(clamp((uv.y - P.fog.x) / span, 0.0, 1.0), P.fog2.y);\n    if (h > 0.0) {\n      let p = vec2f(uv.x * aspect, uv.y * 2.2) * P.fog.z;\n      let t = time * P.fog.w;\n      // Fewer octaves (P.quality.y < 5) lose fine wisps; add back the dropped octaves' mean\n      // (0.5 each) so the mist keeps its density.\n      let o1 = i32(clamp(P.quality.y, 2.0, 5.0));\n      let o2 = max(o1 - 1, 1);\n      let m1 = 0.5 * (pow(0.5, f32(o1)) - pow(0.5, 5.0));\n      let m2 = 0.5 * (pow(0.5, f32(o2)) - pow(0.5, 4.0));\n      let n1 = engine_fbm(p + vec2f(t * 6.0, t * 0.7), o1) + m1;\n      let n2 = engine_fbm(p * 1.9 + vec2f(-t * 9.0, t * 1.3) + vec2f(13.7, 4.1), o2) + m2;\n      let wisps = smoothstep(0.2, 0.85, n1 * 0.6 + n2 * 0.55);\n      let amount = clamp(h * P.fogColor.w * (0.3 + 1.1 * wisps), 0.0, 1.0);\n      let lit = P.fogColor.rgb * (0.6 + 0.8 * wisps) + bloom * P.fog2.x;\n      c = mix(c, lit, amount);\n    }\n  }\n\n  c += bloom * P.bloom.x;\n  if (P.enables.z > 0.5) {\n    c += textureSampleLevel(raysTex, samp, uv, 0.0).rgb;\n  }\n\n  if (P.wb0.w > 0.5) {\n    // White balance: a 3\u00D73 matrix on the linear colour (ws/post-3).\n    c = max(vec3f(dot(P.wb0.rgb, c), dot(P.wb1.rgb, c), dot(P.wb2.rgb, c)), vec3f(0.0));\n  }\n  c *= P.enables2.w;\n  let tm = P.enables2.y;\n  if (tm > 0.5 && tm < 1.5) {\n    c = aces(c);\n  } else if (tm > 1.5) {\n    c = c / (1.0 + c);\n  }\n  c = clamp(c, vec3f(0.0), vec3f(1.0));\n\n  if (P.enables2.x > 0.5) {\n    c = c * P.gain.rgb + P.lift.rgb * (1.0 - c);\n    c = pow(max(c, vec3f(0.0)), 1.0 / max(P.gamma.rgb, vec3f(1e-3)));\n    let l = engine_luma(c);\n    c = mix(vec3f(l), c, P.grade.x);\n    c = (c - 0.5) * P.grade.y + 0.5;\n    c = clamp(c, vec3f(0.0), vec3f(1.0));\n  }\n\n  if (P.lut.x > 0.5) {\n    // Texel centres: the LUT's first and last texels sit half a texel in from 0 and 1.\n    let looked = textureSampleLevel(lutTex, samp, c * P.lut.y + P.lut.w, 0.0).rgb;\n    c = clamp(mix(c, looked, P.lut.z), vec3f(0.0), vec3f(1.0));\n  }\n  if (P.grain.x > 0.0) {\n    let cell = floor(in.pos.xy / P.grain.y);\n    let n = engine_hash21(cell + vec2f(P.grain.w * 61.0, P.grain.w * 29.0)) - 0.5;\n    let response = 1.0 - P.grain.z * engine_luma(c);\n    c = clamp(c + n * P.grain.x * response, vec3f(0.0), vec3f(1.0));\n  }\n\n  if (P.enables.w > 0.5) {\n    let d = length((uv - 0.5) * vec2f(aspect, 1.0)) / length(vec2f(aspect, 1.0) * 0.5);\n    let v = smoothstep(P.vignette.y, P.vignette.y + P.vignette.z, d) * P.vignette.x;\n    c = mix(c, P.vignetteColor.rgb, v);\n  }\n\n  var outc = to_srgb(c);\n  if (P.enables2.z > 0.5) {\n    outc += (engine_hash21(in.pos.xy) - 0.5) / 255.0;\n  }\n  return vec4f(outc, 1.0);\n}\n";
+/**
+ * FXAA 3.11, console preset (ws/post-2): one full-res pass over the composite's display-encoded
+ * output. Luma from the four texel-corner taps and the centre; the blend direction from their
+ * gradient, two taps half a px out and two more up to two px out along it, the longer pair
+ * dropped when its luma leaves the local range. `P.fxaa.y` (subpixel) scales the blend;
+ * `P.fxaa.z` (edgeThreshold) is the relative contrast below which the pixel is left alone.
+ */
+export declare const FXAA_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 samp: sampler;\n@group(0) @binding(2) var src: texture_2d<f32>;\n\nconst EDGE_SHARPNESS: f32 = 8.0;\nconst EDGE_THRESHOLD_MIN: f32 = 0.05;\n\nfn tap(uv: vec2f) -> vec3f { return textureSampleLevel(src, samp, uv, 0.0).rgb; }\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let t = 1.0 / vec2f(textureDimensions(src));\n  let uv = in.uv;\n  let rgbM = tap(uv);\n  let lumaM = engine_luma(rgbM);\n  let lumaNw = engine_luma(tap(uv + vec2f(-0.5, -0.5) * t)) + 1.0 / 384.0;\n  let lumaNe = engine_luma(tap(uv + vec2f(0.5, -0.5) * t));\n  let lumaSw = engine_luma(tap(uv + vec2f(-0.5, 0.5) * t));\n  let lumaSe = engine_luma(tap(uv + vec2f(0.5, 0.5) * t));\n  let lumaMax = max(max(lumaNw, lumaNe), max(lumaSw, lumaSe));\n  let lumaMin = min(min(lumaNw, lumaNe), min(lumaSw, lumaSe));\n  let range = max(lumaMax, lumaM) - min(lumaMin, lumaM);\n  if (range < max(EDGE_THRESHOLD_MIN, lumaMax * P.fxaa.z)) {\n    return vec4f(rgbM, 1.0);\n  }\n  var dir = vec2f(-((lumaNw + lumaNe) - (lumaSw + lumaSe)), (lumaNw + lumaSw) - (lumaNe + lumaSe));\n  let dir1 = dir / max(length(dir), 1e-5);\n  let rgbN1 = tap(uv - dir1 * 0.5 * t);\n  let rgbP1 = tap(uv + dir1 * 0.5 * t);\n  let dirAbsMinTimesC = min(abs(dir1.x), abs(dir1.y)) * EDGE_SHARPNESS;\n  let dir2 = clamp(dir1 / max(dirAbsMinTimesC, 1e-5), vec2f(-2.0), vec2f(2.0));\n  let rgbN2 = tap(uv - dir2 * 2.0 * t);\n  let rgbP2 = tap(uv + dir2 * 2.0 * t);\n  let rgbA = (rgbN1 + rgbP1) * 0.5;\n  let rgbB = (rgbN2 + rgbP2) * 0.25 + rgbA * 0.5;\n  let lumaB = engine_luma(rgbB);\n  let outside = lumaB < lumaMin || lumaB > lumaMax;\n  let aa = select(rgbB, rgbA, outside);\n  return vec4f(mix(rgbM, aa, clamp(P.fxaa.y, 0.0, 1.0)), 1.0);\n}\n";
+/**
+ * Outline mask (ws/post-2): a Roberts cross over the linear depth and the normals from depth,
+ * at the scene size, written as an edge strength 0..1 (r8unorm) the composite mixes toward
+ * `outline.color` before fog. The cross is sampled `P.outline.y` scene px from the pixel.
+ * Sky (depth 1) counts as very far, so silhouettes against it are edges.
+ */
+export declare const OUTLINE_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\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\nconst SKY_Z: f32 = 1.0e6;\n\n/** View position of the texel under `uv` (w = raw depth). */\nfn fetch(uv: vec2f, dim: vec2f) -> vec4f {\n  let tuv = texel_uv(uv, dim);\n  let d = textureSampleLevel(depthTex, nearest, tuv, 0u);\n  return vec4f(view_pos(tuv, d), d);\n}\n\nfn zof(s: vec4f) -> f32 {\n  return select(-s.z, SKY_Z, s.w >= 1.0);\n}\n\n/** Normal at the texel under `uv` from its +x and +y neighbours (a zero vector in the sky). */\nfn normal_at(uv: vec2f, dim: vec2f, t: vec2f) -> vec3f {\n  let p = fetch(uv, dim);\n  let px = fetch(uv + vec2f(t.x, 0.0), dim);\n  let py = fetch(uv + vec2f(0.0, t.y), dim);\n  if (p.w >= 1.0 || px.w >= 1.0 || py.w >= 1.0) {\n    return vec3f(0.0);\n  }\n  return normalize(cross(px.xyz - p.xyz, py.xyz - p.xyz));\n}\n\n@fragment fn fs_main(in: FullscreenIn) -> @location(0) vec4f {\n  let dim = vec2f(textureDimensions(depthTex));\n  let uv = texel_uv(in.uv, dim);\n  let t = vec2f(max(P.outline.y, 0.5)) / dim;\n  let a = fetch(uv - t, dim);\n  let b = fetch(uv + t, dim);\n  let c = fetch(uv + vec2f(t.x, -t.y), dim);\n  let d = fetch(uv + vec2f(-t.x, t.y), dim);\n  let za = zof(a);\n  let zb = zof(b);\n  let zc = zof(c);\n  let zd = zof(d);\n  let zmin = min(min(za, zb), min(zc, zd));\n  if (zmin >= SKY_Z) {\n    return vec4f(0.0, 0.0, 0.0, 1.0);\n  }\n  // Depth: the cross's two differences relative to the nearest tap (so far edges count less).\n  let dz = length(vec2f(za - zb, zc - zd)) / max(zmin, 1e-3);\n  let th = max(P.outline.z, 1e-4);\n  let edgeDepth = smoothstep(th, th * 2.0, dz);\n  // Normals: the cross over the four taps' normals, in 1 - cos.\n  let one = 1.0 / dim;\n  let na = normal_at(uv - t, dim, one);\n  let nb = normal_at(uv + t, dim, one);\n  let nc = normal_at(uv + vec2f(t.x, -t.y), dim, one);\n  let nd = normal_at(uv + vec2f(-t.x, t.y), dim, one);\n  var dn = 0.0;\n  if (dot(na, na) > 0.5 && dot(nb, nb) > 0.5) { dn = max(dn, 1.0 - dot(na, nb)); }\n  if (dot(nc, nc) > 0.5 && dot(nd, nd) > 0.5) { dn = max(dn, 1.0 - dot(nc, nd)); }\n  let tn = max(P.outline.w, 1e-4);\n  let edgeNormal = smoothstep(tn, tn * 1.5, dn);\n  let edge = max(edgeDepth, edgeNormal);\n  return vec4f(edge, edge, edge, 1.0);\n}\n";