@ifc-lite/renderer 3.2.0 → 5.0.0

package/dist/shaders/ao.wgsl.js

@@ -0,0 +1,234 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Screen-space ambient occlusion (#5384), SAO-style, in four fullscreen
+ * passes that share this module:
+ *
+ *  1. `fs_ao` (AO resolution): reconstruct the view-space position and
+ *     normal from depth, then take `samples` taps on a per-pixel rotated
+ *     spiral whose radius is `radius` world units projected to pixels. A tap
+ *     occludes by how far it rises above the tangent plane (cosine, minus a
+ *     bias), fading to zero at `radius` so distant geometry does not count.
+ *     Writes (occlusion, linear depth).
+ *  2. `fs_blur_h`, 3. `fs_blur_v`: separable 9-tap bilateral blur that stops
+ *     at depth discontinuities.
+ *  4. `fs_composite` (full resolution): depth-aware upsample, then output
+ *     the darkening as alpha for a multiply blend. Background pixels (clear
+ *     depth) output 0, so the sky and the clear colour are never darkened.
+ *
+ * `ao-params.ts` owns the uniform layout (`AO_UNIFORM_LAYOUT`) and the
+ * kernel; `depth-reconstruct.wgsl.ts` owns the reconstruction.
+ */
+import { AO_GAIN, AO_MAX_DARKEN } from '../ao-params.js';
+import { depthReconstructWgsl, depthTextureWgsl } from './depth-reconstruct.wgsl.js';
+export function aoShaderSource(multisampled) {
+    return `
+        struct AoParams {
+          depthParams: vec4<f32>,  // m10, m11, m14, m15
+          xyParams: vec4<f32>,     // m0, m5, m12, m13
+          viewport: vec4<f32>,     // full-res width, height, 1/width, 1/height
+          ao: vec4<f32>,           // radius (world), px per world unit at w=1, max radius px, intensity
+          misc: vec4<f32>,         // resolution divisor, samples, cosine bias, depth tolerance
+          kernel: array<vec4<f32>, 8>, // 16 unit-disk offsets, two per vec4
+        }
+
+        ${depthTextureWgsl(0, multisampled)}
+        @group(0) @binding(1) var<uniform> params: AoParams;
+        @group(0) @binding(2) var aoIn: texture_2d<f32>;
+
+        ${depthReconstructWgsl}
+
+        const TAU: f32 = 6.28318530718;
+        const AO_GAIN: f32 = ${AO_GAIN.toFixed(3)};
+        const AO_MAX_DARKEN: f32 = ${AO_MAX_DARKEN.toFixed(3)};
+
+        struct VsOut {
+          @builtin(position) pos: vec4<f32>,
+        }
+
+        @vertex
+        fn vs_fullscreen(@builtin(vertex_index) v: u32) -> VsOut {
+          var p = array<vec2<f32>, 3>(
+            vec2<f32>(-1.0, -3.0),
+            vec2<f32>(-1.0,  1.0),
+            vec2<f32>( 3.0,  1.0)
+          );
+          var o: VsOut;
+          o.pos = vec4<f32>(p[v], 0.0, 1.0);
+          return o;
+        }
+
+        fn viewPosAt(ip: vec2<i32>, d: f32) -> vec3<f32> {
+          return viewPositionFromDepth(ndcFromPixel(ip, params.viewport.zw), d, params.depthParams, params.xyParams);
+        }
+
+        // A neighbour for the normal. Background pushes it far away, so
+        // normalFromNeighbours takes the other side.
+        fn neighbourPos(ip: vec2<i32>, center: vec3<f32>) -> vec3<f32> {
+          let d = loadDepth(ip);
+          if (d <= BACKGROUND_DEPTH) {
+            return center - vec3<f32>(0.0, 0.0, 1e6);
+          }
+          return viewPosAt(ip, d);
+        }
+
+        fn kernelTap(i: u32) -> vec2<f32> {
+          let v = params.kernel[i / 2u];
+          return select(v.xy, v.zw, (i & 1u) == 1u);
+        }
+
+        // Interleaved gradient noise (Jimenez 2014): a per-pixel rotation the
+        // 9-tap blur removes without a visible pattern.
+        fn interleavedGradientNoise(p: vec2<f32>) -> f32 {
+          return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
+        }
+
+        @fragment
+        fn fs_ao(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          let divisor = i32(params.misc.x);
+          let p = vec2<i32>(fragPos.xy) * divisor;
+          let dims = vec2<i32>(params.viewport.xy);
+          let d = loadDepth(p);
+          if (d <= BACKGROUND_DEPTH) {
+            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          }
+          let P = viewPosAt(p, d);
+          let N = normalFromNeighbours(
+            P,
+            neighbourPos(p + vec2<i32>(1, 0), P),
+            neighbourPos(p - vec2<i32>(1, 0), P),
+            neighbourPos(p + vec2<i32>(0, 1), P),
+            neighbourPos(p - vec2<i32>(0, 1), P),
+          );
+          let depthKey = -P.z;
+
+          let radius = params.ao.x;
+          let w = clipWFromViewZ(P.z, params.depthParams);
+          let radiusPx = min(radius * params.ao.y / w, params.ao.z);
+          if (radiusPx < 1.0) {
+            // Smaller than a pixel: nothing to resolve at this distance.
+            return vec4<f32>(0.0, depthKey, 0.0, 0.0);
+          }
+
+          let angle = interleavedGradientNoise(fragPos.xy) * TAU;
+          let rot = vec2<f32>(cos(angle), sin(angle));
+          let invR2 = 1.0 / (radius * radius);
+          let bias = params.misc.z;
+          let samples = u32(params.misc.y);
+          var occlusion = 0.0;
+          for (var i = 0u; i < samples; i = i + 1u) {
+            let k = kernelTap(i);
+            let offset = vec2<f32>(k.x * rot.x - k.y * rot.y, k.x * rot.y + k.y * rot.x) * radiusPx;
+            let q = p + vec2<i32>(round(offset));
+            if (any(q < vec2<i32>(0)) || any(q >= dims)) {
+              continue;
+            }
+            let dq = loadDepth(q);
+            if (dq <= BACKGROUND_DEPTH) {
+              continue;
+            }
+            let v = viewPosAt(q, dq) - P;
+            let vv = dot(v, v);
+            // Range check: taps beyond the world radius do not occlude.
+            let falloff = max(1.0 - vv * invR2, 0.0);
+            let cosine = dot(v, N) * inverseSqrt(vv + 1e-8);
+            occlusion = occlusion + falloff * max(cosine - bias, 0.0);
+          }
+          occlusion = occlusion / (f32(samples) * (1.0 - bias));
+          return vec4<f32>(occlusion, depthKey, 0.0, 0.0);
+        }
+
+        // Relative depth closeness in [0, 1]: 1 on the same surface, 0 across
+        // a step larger than the tolerance.
+        fn depthWeight(key: f32, centerKey: f32) -> f32 {
+          return max(0.0, 1.0 - abs(key - centerKey) / (centerKey * params.misc.w));
+        }
+
+        fn bilateralBlur(t: vec2<i32>, dir: vec2<i32>) -> vec4<f32> {
+          let center = textureLoad(aoIn, t, 0);
+          if (center.y <= 0.0) {
+            return center;
+          }
+          let dims = vec2<i32>(textureDimensions(aoIn));
+          // Gaussian, sigma ~2 texels. A var: it is indexed at runtime.
+          var gauss = array<f32, 5>(0.2270, 0.1945, 0.1216, 0.0540, 0.0162);
+          var sum = center.x * gauss[0];
+          var wsum = gauss[0];
+          for (var i = 1; i <= 4; i = i + 1) {
+            for (var s = -1; s <= 1; s = s + 2) {
+              let q = t + dir * (i * s);
+              if (any(q < vec2<i32>(0)) || any(q >= dims)) {
+                continue;
+              }
+              let tap = textureLoad(aoIn, q, 0);
+              if (tap.y <= 0.0) {
+                continue;
+              }
+              let wgt = gauss[i] * depthWeight(tap.y, center.y);
+              sum = sum + tap.x * wgt;
+              wsum = wsum + wgt;
+            }
+          }
+          return vec4<f32>(sum / wsum, center.y, 0.0, 0.0);
+        }
+
+        @fragment
+        fn fs_blur_h(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          return bilateralBlur(vec2<i32>(fragPos.xy), vec2<i32>(1, 0));
+        }
+
+        @fragment
+        fn fs_blur_v(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          return bilateralBlur(vec2<i32>(fragPos.xy), vec2<i32>(0, 1));
+        }
+
+        // Joint bilateral upsample: the (up to) four AO texels around this
+        // pixel, weighted bilinearly and by depth closeness. When none is on
+        // this pixel's surface, the closest in depth wins.
+        fn upsampledOcclusion(p: vec2<i32>, key: f32) -> f32 {
+          let divisor = params.misc.x;
+          if (divisor <= 1.0) {
+            return textureLoad(aoIn, p, 0).x;
+          }
+          let dims = vec2<i32>(textureDimensions(aoIn));
+          // AO texel t was computed at full-res pixel t * divisor.
+          let f = vec2<f32>(p) / divisor;
+          let base = vec2<i32>(floor(f));
+          let fr = f - floor(f);
+          var sum = 0.0;
+          var wsum = 0.0;
+          var nearest = 0.0;
+          var nearestDiff = 1e30;
+          for (var j = 0; j < 4; j = j + 1) {
+            let o = vec2<i32>(j & 1, j >> 1u);
+            let q = clamp(base + o, vec2<i32>(0), dims - 1);
+            let tap = textureLoad(aoIn, q, 0);
+            let bw = select(1.0 - fr.x, fr.x, o.x == 1) * select(1.0 - fr.y, fr.y, o.y == 1);
+            let wgt = bw * depthWeight(tap.y, key);
+            sum = sum + tap.x * wgt;
+            wsum = wsum + wgt;
+            let diff = abs(tap.y - key);
+            if (diff < nearestDiff) {
+              nearestDiff = diff;
+              nearest = tap.x;
+            }
+          }
+          return select(nearest, sum / wsum, wsum > 1e-3);
+        }
+
+        @fragment
+        fn fs_composite(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          let p = vec2<i32>(fragPos.xy);
+          let d = loadDepth(p);
+          if (d <= BACKGROUND_DEPTH) {
+            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          }
+          let key = -viewZFromDepth(d, params.depthParams);
+          let occlusion = upsampledOcclusion(p, key);
+          let darken = clamp(occlusion * AO_GAIN * params.ao.w, 0.0, AO_MAX_DARKEN);
+          return vec4<f32>(0.0, 0.0, 0.0, darken);
+        }
+`;
+}
+//# sourceMappingURL=ao.wgsl.js.map

package/dist/shaders/ao.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ao.wgsl.js","sourceRoot":"","sources":["../../src/shaders/ao.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAErF,MAAM,UAAU,cAAc,CAAC,YAAqB;IAClD,OAAO;;;;;;;;;;UAUC,gBAAgB,CAAC,CAAC,EAAE,YAAY,CAAC;;;;UAIjC,oBAAoB;;;+BAGC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;qCACZ,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4L5D,CAAC;AACF,CAAC"}

package/dist/shaders/color-transfer.wgsl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Colour transfer shared by every shader that lights or tone-maps: the
+ * geometry fragment stage (`main.wgsl.ts`, and the textured variant derived
+ * from it) and the procedural sky (`sky.wgsl.ts`). One home, so the model and
+ * the sky cannot drift onto different "film stocks".
+ *
+ * The contract:
+ *
+ *  - Authored colours (IfcColourRgb, IFC5 / glTF base colours, overlay tints,
+ *    texture texels) are display-referred sRGB. `srgbToLinear` decodes them
+ *    before they are multiplied by light, because light adds and multiplies
+ *    linearly and sRGB values do not.
+ *  - `neutralCompress` rolls off highlights only. Anything whose brightest
+ *    channel is below 0.76 (about 227/255 once encoded) passes through
+ *    untouched, so a colour up to that brightness, lit at unit neutral
+ *    irradiance, renders as authored; brighter colours roll off with their
+ *    hue preserved (pure white lands at 0.88, about 241/255, leaving
+ *    headroom for sunlit highlights). It is the Khronos PBR Neutral operator
+ *    without its toe: the toe subtracts up to 0.04 to cancel the specular F0
+ *    offset a dielectric picks up under a unit-radiance environment. This
+ *    renderer's sky is far dimmer, so its specular term (specular.wgsl.ts)
+ *    lifts a dark matte surface by only about 0.01-0.02, and keeping the toe
+ *    would crush dark materials below their authored value.
+ *  - `linearToSrgb` is the exact piecewise encode. The canvas is configured
+ *    with a non-sRGB format, so the shader must encode.
+ */
+export declare const colorTransferWgsl = "\n        fn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n          let lo = c / 12.92;\n          let hi = pow((max(c, vec3<f32>(0.0)) + 0.055) / 1.055, vec3<f32>(2.4));\n          return select(hi, lo, c <= vec3<f32>(0.04045));\n        }\n\n        fn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n          let lo = c * 12.92;\n          let hi = 1.055 * pow(max(c, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;\n          return select(hi, lo, c <= vec3<f32>(0.0031308));\n        }\n\n        fn neutralCompress(cIn: vec3<f32>) -> vec3<f32> {\n          let startCompression = 0.76;\n          let desaturation = 0.15;\n          let c = max(cIn, vec3<f32>(0.0));\n          let peak = max(c.r, max(c.g, c.b));\n          if (peak < startCompression) { return c; }\n          let d = 1.0 - startCompression;\n          let newPeak = 1.0 - d * d / (peak + d - startCompression);\n          let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n          return mix(c * (newPeak / peak), vec3<f32>(newPeak), g);\n        }\n";
+//# sourceMappingURL=color-transfer.wgsl.d.ts.map

package/dist/shaders/color-transfer.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-transfer.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/color-transfer.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,8gCAwB7B,CAAC"}

package/dist/shaders/color-transfer.wgsl.js

@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Colour transfer shared by every shader that lights or tone-maps: the
+ * geometry fragment stage (`main.wgsl.ts`, and the textured variant derived
+ * from it) and the procedural sky (`sky.wgsl.ts`). One home, so the model and
+ * the sky cannot drift onto different "film stocks".
+ *
+ * The contract:
+ *
+ *  - Authored colours (IfcColourRgb, IFC5 / glTF base colours, overlay tints,
+ *    texture texels) are display-referred sRGB. `srgbToLinear` decodes them
+ *    before they are multiplied by light, because light adds and multiplies
+ *    linearly and sRGB values do not.
+ *  - `neutralCompress` rolls off highlights only. Anything whose brightest
+ *    channel is below 0.76 (about 227/255 once encoded) passes through
+ *    untouched, so a colour up to that brightness, lit at unit neutral
+ *    irradiance, renders as authored; brighter colours roll off with their
+ *    hue preserved (pure white lands at 0.88, about 241/255, leaving
+ *    headroom for sunlit highlights). It is the Khronos PBR Neutral operator
+ *    without its toe: the toe subtracts up to 0.04 to cancel the specular F0
+ *    offset a dielectric picks up under a unit-radiance environment. This
+ *    renderer's sky is far dimmer, so its specular term (specular.wgsl.ts)
+ *    lifts a dark matte surface by only about 0.01-0.02, and keeping the toe
+ *    would crush dark materials below their authored value.
+ *  - `linearToSrgb` is the exact piecewise encode. The canvas is configured
+ *    with a non-sRGB format, so the shader must encode.
+ */
+export const colorTransferWgsl = `
+        fn srgbToLinear(c: vec3<f32>) -> vec3<f32> {
+          let lo = c / 12.92;
+          let hi = pow((max(c, vec3<f32>(0.0)) + 0.055) / 1.055, vec3<f32>(2.4));
+          return select(hi, lo, c <= vec3<f32>(0.04045));
+        }
+
+        fn linearToSrgb(c: vec3<f32>) -> vec3<f32> {
+          let lo = c * 12.92;
+          let hi = 1.055 * pow(max(c, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;
+          return select(hi, lo, c <= vec3<f32>(0.0031308));
+        }
+
+        fn neutralCompress(cIn: vec3<f32>) -> vec3<f32> {
+          let startCompression = 0.76;
+          let desaturation = 0.15;
+          let c = max(cIn, vec3<f32>(0.0));
+          let peak = max(c.r, max(c.g, c.b));
+          if (peak < startCompression) { return c; }
+          let d = 1.0 - startCompression;
+          let newPeak = 1.0 - d * d / (peak + d - startCompression);
+          let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+          return mix(c * (newPeak / peak), vec3<f32>(newPeak), g);
+        }
+`;
+//# sourceMappingURL=color-transfer.wgsl.js.map

package/dist/shaders/color-transfer.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-transfer.wgsl.js","sourceRoot":"","sources":["../../src/shaders/color-transfer.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBhC,CAAC"}

package/dist/shaders/depth-reconstruct.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * WGSL twin of `depth-reconstruct.ts`: view-space position and normal from
+ * the scene's reverse-Z depth buffer, shared by the screen-space passes so
+ * each one reconstructs geometry the same way.
+ *
+ * `dp` is `[m10, m11, m14, m15]` and `xy` is `[m0, m5, m12, m13]` of the
+ * camera projection (see `depthReconstructParams`).
+ */
+/**
+ * Declares `depthTex` at `@group(0) @binding(binding)` and `loadDepth(ip)`,
+ * which clamps the coordinate to the texture and reads sample 0 when the
+ * attachment is multisampled.
+ */
+export declare function depthTextureWgsl(binding: number, multisampled: boolean): string;
+export declare const depthReconstructWgsl = "\n        // Reverse-Z clears to 0, so anything at or below this is background.\n        const BACKGROUND_DEPTH: f32 = 1e-7;\n\n        fn viewZFromDepth(d: f32, dp: vec4<f32>) -> f32 {\n          return (dp.z - d * dp.w) / (d * dp.y - dp.x);\n        }\n\n        fn clipWFromViewZ(z: f32, dp: vec4<f32>) -> f32 {\n          return dp.y * z + dp.w;\n        }\n\n        // Pixel centre to NDC (y up), for a buffer whose texel size is invDims.\n        fn ndcFromPixel(ip: vec2<i32>, invDims: vec2<f32>) -> vec2<f32> {\n          let uv = (vec2<f32>(ip) + 0.5) * invDims;\n          return vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n        }\n\n        fn viewPositionFromDepth(ndc: vec2<f32>, d: f32, dp: vec4<f32>, xy: vec4<f32>) -> vec3<f32> {\n          let z = viewZFromDepth(d, dp);\n          let w = clipWFromViewZ(z, dp);\n          return vec3<f32>((ndc.x * w - xy.z) / xy.x, (ndc.y * w - xy.w) / xy.y, z);\n        }\n\n        // Normal facing the camera, from a position and its four pixel\n        // neighbours. On each axis it takes the neighbour with the smaller\n        // depth step, so a pixel on a silhouette or a crease uses the side\n        // on its own surface instead of averaging across the edge.\n        fn normalFromNeighbours(\n          p: vec3<f32>, right: vec3<f32>, left: vec3<f32>, down: vec3<f32>, up: vec3<f32>,\n        ) -> vec3<f32> {\n          let dxR = right - p;\n          let dxL = p - left;\n          let dx = select(dxR, dxL, abs(dxL.z) < abs(dxR.z));\n          let dyD = down - p;\n          let dyU = p - up;\n          let dy = select(dyD, dyU, abs(dyU.z) < abs(dyD.z));\n          // Pixel +x is view +x and pixel +y is view -y, so dy x dx faces +z.\n          return normalize(cross(dy, dx));\n        }\n";
+//# sourceMappingURL=depth-reconstruct.wgsl.d.ts.map

package/dist/shaders/depth-reconstruct.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth-reconstruct.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/depth-reconstruct.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,MAAM,CAU/E;AAED,eAAO,MAAM,oBAAoB,+uDAwChC,CAAC"}

package/dist/shaders/depth-reconstruct.wgsl.js

@@ -0,0 +1,69 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * WGSL twin of `depth-reconstruct.ts`: view-space position and normal from
+ * the scene's reverse-Z depth buffer, shared by the screen-space passes so
+ * each one reconstructs geometry the same way.
+ *
+ * `dp` is `[m10, m11, m14, m15]` and `xy` is `[m0, m5, m12, m13]` of the
+ * camera projection (see `depthReconstructParams`).
+ */
+/**
+ * Declares `depthTex` at `@group(0) @binding(binding)` and `loadDepth(ip)`,
+ * which clamps the coordinate to the texture and reads sample 0 when the
+ * attachment is multisampled.
+ */
+export function depthTextureWgsl(binding, multisampled) {
+    const type = multisampled ? 'texture_depth_multisampled_2d' : 'texture_depth_2d';
+    return `
+        @group(0) @binding(${binding}) var depthTex: ${type};
+
+        fn loadDepth(ip: vec2<i32>) -> f32 {
+          let dims = vec2<i32>(textureDimensions(depthTex));
+          return textureLoad(depthTex, clamp(ip, vec2<i32>(0), dims - 1), 0);
+        }
+`;
+}
+export const depthReconstructWgsl = `
+        // Reverse-Z clears to 0, so anything at or below this is background.
+        const BACKGROUND_DEPTH: f32 = 1e-7;
+
+        fn viewZFromDepth(d: f32, dp: vec4<f32>) -> f32 {
+          return (dp.z - d * dp.w) / (d * dp.y - dp.x);
+        }
+
+        fn clipWFromViewZ(z: f32, dp: vec4<f32>) -> f32 {
+          return dp.y * z + dp.w;
+        }
+
+        // Pixel centre to NDC (y up), for a buffer whose texel size is invDims.
+        fn ndcFromPixel(ip: vec2<i32>, invDims: vec2<f32>) -> vec2<f32> {
+          let uv = (vec2<f32>(ip) + 0.5) * invDims;
+          return vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);
+        }
+
+        fn viewPositionFromDepth(ndc: vec2<f32>, d: f32, dp: vec4<f32>, xy: vec4<f32>) -> vec3<f32> {
+          let z = viewZFromDepth(d, dp);
+          let w = clipWFromViewZ(z, dp);
+          return vec3<f32>((ndc.x * w - xy.z) / xy.x, (ndc.y * w - xy.w) / xy.y, z);
+        }
+
+        // Normal facing the camera, from a position and its four pixel
+        // neighbours. On each axis it takes the neighbour with the smaller
+        // depth step, so a pixel on a silhouette or a crease uses the side
+        // on its own surface instead of averaging across the edge.
+        fn normalFromNeighbours(
+          p: vec3<f32>, right: vec3<f32>, left: vec3<f32>, down: vec3<f32>, up: vec3<f32>,
+        ) -> vec3<f32> {
+          let dxR = right - p;
+          let dxL = p - left;
+          let dx = select(dxR, dxL, abs(dxL.z) < abs(dxR.z));
+          let dyD = down - p;
+          let dyU = p - up;
+          let dy = select(dyD, dyU, abs(dyU.z) < abs(dyD.z));
+          // Pixel +x is view +x and pixel +y is view -y, so dy x dx faces +z.
+          return normalize(cross(dy, dx));
+        }
+`;
+//# sourceMappingURL=depth-reconstruct.wgsl.js.map

package/dist/shaders/depth-reconstruct.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth-reconstruct.wgsl.js","sourceRoot":"","sources":["../../src/shaders/depth-reconstruct.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe,EAAE,YAAqB;IACrE,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,kBAAkB,CAAC;IACjF,OAAO;6BACoB,OAAO,mBAAmB,IAAI;;;;;;CAM1D,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCnC,CAAC"}

package/dist/shaders/edges.wgsl.d.ts

@@ -0,0 +1,2 @@
+export declare function edgeShaderSource(multisampled: boolean): string;
+//# sourceMappingURL=edges.wgsl.d.ts.map

package/dist/shaders/edges.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/edges.wgsl.ts"],"names":[],"mappings":"AA0BA,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAqI9D"}

package/dist/shaders/edges.wgsl.js

@@ -0,0 +1,158 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Edge pass (#5385): a single fullscreen pass that darkens along entity-id
+ * changes, normal creases, and depth silhouettes, replacing the separation-
+ * line pass in `post-processor.ts`.
+ *
+ * View-space position and normal come from `depth-reconstruct.wgsl.ts`
+ * (shared with the ambient-occlusion pass, #5384: one reconstruction, not
+ * two). The entity-id attachment is decoded the same way the old
+ * separation-line pass did (`encodeId24`/`decodeId24` in `main.wgsl.ts`).
+ *
+ * Each of `directions` tap offsets (4 cardinal at `low`, +4 diagonal at
+ * `high`) votes 0/1 on three cues — id change, normal crease, depth
+ * silhouette — and the pass darkens by the AVERAGE vote across directions.
+ * That average is a coverage estimate, not a single hard sample, so a line
+ * that only grazes one direction fades instead of dashing on/off between
+ * frames of the same seam (the bug this pass replaces, `post-processor.ts`
+ * introduced its own version of this coverage trick for the id test alone;
+ * this generalises it to all three cues and both new tests).
+ */
+import { EDGE_CREASE_COS, EDGE_MAX_DARKEN, EDGE_SILHOUETTE_REL_THRESHOLD } from '../edge-params.js';
+import { depthReconstructWgsl, depthTextureWgsl } from './depth-reconstruct.wgsl.js';
+export function edgeShaderSource(multisampled) {
+    // Multisampled and non-multisampled `textureLoad` share this call shape:
+    // the third argument is the sample index (MS) or the mip level (non-MS),
+    // both 0, so one call site covers both declarations (`post-processor.ts`
+    // used the same trick).
+    const idTexDecl = multisampled
+        ? '@group(0) @binding(1) var idTex: texture_multisampled_2d<f32>;'
+        : '@group(0) @binding(1) var idTex: texture_2d<f32>;';
+    return `
+        struct EdgeParams {
+          depthParams: vec4<f32>,  // m10, m11, m14, m15
+          xyParams: vec4<f32>,     // m0, m5, m12, m13
+          viewport: vec4<f32>,     // full-res width, height, 1/width, 1/height
+          edge: vec4<f32>,         // tap radius px, intensity, highQuality (0/1), _pad
+        }
+
+        ${depthTextureWgsl(0, multisampled)}
+        ${idTexDecl}
+        @group(0) @binding(2) var<uniform> params: EdgeParams;
+
+        ${depthReconstructWgsl}
+
+        const EDGE_CREASE_COS: f32 = ${EDGE_CREASE_COS.toFixed(6)};
+        const EDGE_SILHOUETTE_REL: f32 = ${EDGE_SILHOUETTE_REL_THRESHOLD.toFixed(6)};
+        const EDGE_MAX_DARKEN: f32 = ${EDGE_MAX_DARKEN.toFixed(3)};
+
+        struct VsOut {
+          @builtin(position) pos: vec4<f32>,
+        }
+
+        @vertex
+        fn vs_fullscreen(@builtin(vertex_index) v: u32) -> VsOut {
+          var p = array<vec2<f32>, 3>(
+            vec2<f32>(-1.0, -3.0),
+            vec2<f32>(-1.0,  1.0),
+            vec2<f32>( 3.0,  1.0)
+          );
+          var o: VsOut;
+          o.pos = vec4<f32>(p[v], 0.0, 1.0);
+          return o;
+        }
+
+        fn decodeId24(encoded: vec4<f32>) -> u32 {
+          let r = u32(round(encoded.r * 255.0)) & 255u;
+          let g = u32(round(encoded.g * 255.0)) & 255u;
+          let b = u32(round(encoded.b * 255.0)) & 255u;
+          return (r << 16u) | (g << 8u) | b;
+        }
+
+        fn loadId(ip: vec2<i32>, dims: vec2<i32>) -> u32 {
+          let c = clamp(ip, vec2<i32>(0), dims - 1);
+          return decodeId24(textureLoad(idTex, c, 0));
+        }
+
+        fn viewPosAt(ip: vec2<i32>, d: f32) -> vec3<f32> {
+          return viewPositionFromDepth(ndcFromPixel(ip, params.viewport.zw), d, params.depthParams, params.xyParams);
+        }
+
+        // One tap direction's edge vote in [0, 1]: 1 if the id changes, the
+        // local normal creases past the angle threshold, or the view-space
+        // depth steps past the silhouette threshold.
+        fn tapVote(p: vec2<i32>, q: vec2<i32>, dims: vec2<i32>, centerId: u32, centerP: vec3<f32>, centerN: vec3<f32>) -> f32 {
+          let qc = clamp(q, vec2<i32>(0), dims - 1);
+          let dq = loadDepth(qc);
+          if (dq <= BACKGROUND_DEPTH) {
+            return 0.0;
+          }
+          let neighbourId = loadId(qc, dims);
+          let idVote = f32(neighbourId != centerId && neighbourId != 0u && centerId != 0u);
+
+          let Pq = viewPosAt(qc, dq);
+          let depthRef = max(-centerP.z, 1e-4);
+          let silhouetteVote = f32(abs(Pq.z - centerP.z) / depthRef > EDGE_SILHOUETTE_REL);
+
+          // Neighbour normal from ITS OWN neighbours (not just the two
+          // points), so a grazing coplanar surface (large positional slope,
+          // near-zero normal change) does not misread as a crease.
+          let dLeft = loadDepth(clamp(qc + vec2<i32>(-1, 0), vec2<i32>(0), dims - 1));
+          let dRight = loadDepth(clamp(qc + vec2<i32>(1, 0), vec2<i32>(0), dims - 1));
+          let dUp = loadDepth(clamp(qc + vec2<i32>(0, -1), vec2<i32>(0), dims - 1));
+          let dDown = loadDepth(clamp(qc + vec2<i32>(0, 1), vec2<i32>(0), dims - 1));
+          let Nq = normalFromNeighbours(
+            Pq,
+            select(centerP, viewPosAt(qc + vec2<i32>(1, 0), dRight), dRight > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(-1, 0), dLeft), dLeft > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(0, 1), dDown), dDown > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(0, -1), dUp), dUp > BACKGROUND_DEPTH),
+          );
+          let creaseVote = f32(dot(centerN, Nq) < EDGE_CREASE_COS);
+
+          return max(idVote, max(creaseVote, silhouetteVote));
+        }
+
+        @fragment
+        fn fs_edges(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          let dims = vec2<i32>(params.viewport.xy);
+          let p = vec2<i32>(fragPos.xy);
+          let d = loadDepth(p);
+          if (d <= BACKGROUND_DEPTH) {
+            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          }
+          let centerId = loadId(p, dims);
+          let centerP = viewPosAt(p, d);
+          let centerN = normalFromNeighbours(
+            centerP,
+            viewPosAt(clamp(p + vec2<i32>(1, 0), vec2<i32>(0), dims - 1), loadDepth(p + vec2<i32>(1, 0))),
+            viewPosAt(clamp(p - vec2<i32>(1, 0), vec2<i32>(0), dims - 1), loadDepth(p - vec2<i32>(1, 0))),
+            viewPosAt(clamp(p + vec2<i32>(0, 1), vec2<i32>(0), dims - 1), loadDepth(p + vec2<i32>(0, 1))),
+            viewPosAt(clamp(p - vec2<i32>(0, 1), vec2<i32>(0), dims - 1), loadDepth(p - vec2<i32>(0, 1))),
+          );
+
+          let r = i32(round(params.edge.x));
+          var votes = 0.0;
+          votes = votes + tapVote(p, p + vec2<i32>( r,  0), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>(-r,  0), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>( 0,  r), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>( 0, -r), dims, centerId, centerP, centerN);
+          var directions = 4.0;
+
+          if (params.edge.z > 0.5) {
+            votes = votes + tapVote(p, p + vec2<i32>( r,  r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>(-r,  r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>( r, -r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>(-r, -r), dims, centerId, centerP, centerN);
+            directions = 8.0;
+          }
+
+          let coverage = votes / directions;
+          let darken = clamp(coverage * params.edge.y, 0.0, EDGE_MAX_DARKEN);
+          return vec4<f32>(0.0, 0.0, 0.0, darken);
+        }
+`;
+}
+//# sourceMappingURL=edges.wgsl.js.map

package/dist/shaders/edges.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.wgsl.js","sourceRoot":"","sources":["../../src/shaders/edges.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAErF,MAAM,UAAU,gBAAgB,CAAC,YAAqB;IACpD,yEAAyE;IACzE,yEAAyE;IACzE,yEAAyE;IACzE,wBAAwB;IACxB,MAAM,SAAS,GAAG,YAAY;QAC5B,CAAC,CAAC,gEAAgE;QAClE,CAAC,CAAC,mDAAmD,CAAC;IAExD,OAAO;;;;;;;;UAQC,gBAAgB,CAAC,CAAC,EAAE,YAAY,CAAC;UACjC,SAAS;;;UAGT,oBAAoB;;uCAES,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;2CACtB,6BAA6B,CAAC,OAAO,CAAC,CAAC,CAAC;uCAC5C,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GhE,CAAC;AACF,CAAC"}

package/dist/shaders/main-rte-shadow.wgsl.d.ts

@@ -0,0 +1,4 @@
+/** RTE vertex reconstruction and shadow sampling composed into the main WGSL. */
+export declare const mainRteWgsl = "\n        fn rtePosition(local: vec3<f32>) -> vec4<f32> {\n          let linear = (uniforms.model * vec4<f32>(local, 0.0)).xyz;\n          return rteWorldPosition(linear, RteDrawableUniform(\n            uniforms.drawableDeltaHigh,\n            uniforms.drawableDeltaLow,\n          ));\n        }\n        fn rteInstancePosition(local: vec3<f32>, anchorHigh: vec3<f32>, anchorLow: vec3<f32>) -> vec4<f32> {\n          return rteWorldPosition(local, RteDrawableUniform(\n            vec4<f32>(anchorHigh, 0.0),\n            vec4<f32>(anchorLow, 0.0),\n          ));\n        }";
+export declare const mainShadowWgsl = "\n        @binding(1) @group(1) var shadowMap: texture_depth_2d;\n        @binding(2) @group(1) var shadowCmp: sampler_comparison;\n        struct Shadow { lightViewProj: mat4x4<f32>, params: vec4<f32>, params2: vec4<f32>, }\n        @binding(3) @group(1) var<uniform> shadowU: Shadow;\n        const SHADOW_POISSON = array<vec2<f32>, 12>(\n          vec2<f32>(-0.326, -0.406), vec2<f32>(-0.840, -0.074), vec2<f32>(-0.696,  0.457),\n          vec2<f32>(-0.203,  0.621), vec2<f32>( 0.962, -0.195), vec2<f32>( 0.473, -0.480),\n          vec2<f32>( 0.519,  0.767), vec2<f32>( 0.185, -0.893), vec2<f32>( 0.507,  0.064),\n          vec2<f32>( 0.896,  0.412), vec2<f32>(-0.322, -0.933), vec2<f32>(-0.792, -0.598),\n        );\n        fn sunShadowFactor(eyePos: vec3<f32>, N: vec3<f32>, fragCoord: vec2<f32>) -> f32 {\n          if (shadowU.params.y < 0.5) { return 1.0; }\n          let L = normalize(env.sunDirection);\n          let Ns = N * select(-1.0, 1.0, dot(N, L) >= 0.0);\n          let biased = eyePos + Ns * shadowU.params.z;\n          let clip = shadowU.lightViewProj * vec4<f32>(biased, 1.0);\n          let ndc = clip.xyz / clip.w;\n          let uv = vec2<f32>(ndc.x * 0.5 + 0.5, ndc.y * -0.5 + 0.5);\n          let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0 && ndc.z > 0.0;\n          if (!inBounds) { return 1.0; }\n          let NdotL = max(dot(Ns, L), 0.0);\n          let slope = clamp(sqrt(max(1.0 - NdotL * NdotL, 0.0)) / max(NdotL, 0.1), 1.0, 12.0);\n          let refDepth = ndc.z + shadowU.params2.x * slope * (1.0 + shadowU.params.w);\n          let radius = shadowU.params.x * shadowU.params.w;\n          let ign = fract(52.9829189 * fract(dot(fragCoord, vec2<f32>(0.06711056, 0.00583715))));\n          let ang = ign * 6.2831853;\n          let cr = cos(ang); let sr = sin(ang); var sum = 0.0;\n          for (var i = 0; i < 12; i = i + 1) {\n            let p = SHADOW_POISSON[i];\n            let off = vec2<f32>(p.x * cr - p.y * sr, p.x * sr + p.y * cr) * radius;\n            sum = sum + textureSampleCompareLevel(shadowMap, shadowCmp, uv + off, refDepth);\n          }\n          return mix(1.0, sum / 12.0, smoothstep(0.0, 0.3, NdotL));\n        }";
+//# sourceMappingURL=main-rte-shadow.wgsl.d.ts.map

package/dist/shaders/main-rte-shadow.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-rte-shadow.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/main-rte-shadow.wgsl.ts"],"names":[],"mappings":"AAIA,iFAAiF;AAEjF,eAAO,MAAM,WAAW,qkBAad,CAAC;AAEX,eAAO,MAAM,cAAc,gqEAkCjB,CAAC"}