@ifc-lite/renderer 3.1.0 → 4.2.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,26 @@
+/**
+ * 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 a specular F0
+ *    offset, and this renderer has no specular term, so keeping it would only
+ *    crush dark materials.
+ *  - `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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,8gCAwB7B,CAAC"}

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

@@ -0,0 +1,53 @@
+/* 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 a specular F0
+ *    offset, and this renderer has no specular term, so keeping it would only
+ *    crush dark materials.
+ *  - `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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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/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"}

package/dist/shaders/main-rte-shadow.wgsl.js

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

package/dist/shaders/main-rte-shadow.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-rte-shadow.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main-rte-shadow.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,iFAAiF;AAEjF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;UAajB,CAAC;AAEX,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCpB,CAAC"}