@ifc-lite/renderer 4.2.0 → 6.0.0

package/dist/shaders/mesh-uniforms.wgsl.d.ts

@@ -0,0 +1,2 @@
+export declare const meshUniformsWgsl = "\n        struct Uniforms {\n          viewProj: mat4x4<f32>,\n          model: mat4x4<f32>,\n          baseColor: vec4<f32>,\n          metallicRoughness: vec2<f32>, // x = metallic, y = roughness (mesh-material.ts)\n          transmission: vec2<f32>,      // x = 1: authored translucent, drawn as glass; y = pad\n          sectionPlane: vec4<f32>,      // xyz = plane normal, w = plane distance\n          flags: vec4<u32>,             // x = isSelected, y = section/clip bits; z, w unused (0) since #5746 dropped the derivative edges\n          clipBoxMin: vec4<f32>,        // xyz = clip-box min corner (world), w = pad\n          clipBoxMax: vec4<f32>,        // xyz = clip-box max corner (world), w = pad\n          quantParams: vec4<f32>, // local min xyz, lattice step w\n          rteViewProj: mat4x4<f32>, // appended frame; bit 16 selects it\n          drawableDeltaHigh: vec4<f32>,\n          drawableDeltaLow: vec4<f32>,\n          rteCameraHigh: vec4<f32>,\n          rteCameraLow: vec4<f32>,\n          overrideParams: vec4<u32>, // x = draw's id anchor, y = OVERRIDE_* bits (entity-color-table.ts, #6076)\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n        const RTE_DRAWABLE_FLAG: u32 = 65536u;\n\n        // The fragment position the section/crop tests run in: camera-relative\n        // for RTE drawables (the packer writes plane and box in that frame),\n        // world space otherwise.\n        fn clipSpacePos(worldPos: vec3<f32>, eyePos: vec3<f32>) -> vec3<f32> {\n          return select(worldPos, eyePos, (uniforms.flags.x & RTE_DRAWABLE_FLAG) != 0u);\n        }\n\n        // True when p is cut away: ABOVE the section plane (flags.y bit 0 =\n        // enabled, bit 1 = flipped) or OUTSIDE the clip box (bit 2).\n        fn sectionClipped(p: vec3<f32>) -> bool {\n          if ((uniforms.flags.y & 1u) == 1u) {\n            let side = select(1.0, -1.0, (uniforms.flags.y & 2u) == 2u);\n            if ((dot(p, uniforms.sectionPlane.xyz) - uniforms.sectionPlane.w) * side > 0.0) { return true; }\n          }\n          if ((uniforms.flags.y & 4u) != 0u) {\n            if (any(p < uniforms.clipBoxMin.xyz) || any(p > uniforms.clipBoxMax.xyz)) { return true; }\n          }\n          return false;\n        }\n";
+//# sourceMappingURL=mesh-uniforms.wgsl.d.ts.map

package/dist/shaders/mesh-uniforms.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-uniforms.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/mesh-uniforms.wgsl.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,gBAAgB,ouEAyC5B,CAAC"}

package/dist/shaders/mesh-uniforms.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/. */
+/**
+ * The per-mesh uniform block (`@group(0) @binding(0)`) and the section /
+ * clip-box test that reads it, shared by `main.wgsl.ts` and the selection
+ * mask fragment stage (#5390) so an outline is cut exactly where the
+ * surface it traces is. Packing: `mesh-rte-uniforms.ts` / `index.ts`.
+ */
+import { MESH_FLAG_RTE_DRAWABLE } from '../mesh-rte-uniforms.js';
+export const meshUniformsWgsl = `
+        struct Uniforms {
+          viewProj: mat4x4<f32>,
+          model: mat4x4<f32>,
+          baseColor: vec4<f32>,
+          metallicRoughness: vec2<f32>, // x = metallic, y = roughness (mesh-material.ts)
+          transmission: vec2<f32>,      // x = 1: authored translucent, drawn as glass; y = pad
+          sectionPlane: vec4<f32>,      // xyz = plane normal, w = plane distance
+          flags: vec4<u32>,             // x = isSelected, y = section/clip bits; z, w unused (0) since #5746 dropped the derivative edges
+          clipBoxMin: vec4<f32>,        // xyz = clip-box min corner (world), w = pad
+          clipBoxMax: vec4<f32>,        // xyz = clip-box max corner (world), w = pad
+          quantParams: vec4<f32>, // local min xyz, lattice step w
+          rteViewProj: mat4x4<f32>, // appended frame; bit 16 selects it
+          drawableDeltaHigh: vec4<f32>,
+          drawableDeltaLow: vec4<f32>,
+          rteCameraHigh: vec4<f32>,
+          rteCameraLow: vec4<f32>,
+          overrideParams: vec4<u32>, // x = draw's id anchor, y = OVERRIDE_* bits (entity-color-table.ts, #6076)
+        }
+        @binding(0) @group(0) var<uniform> uniforms: Uniforms;
+        const RTE_DRAWABLE_FLAG: u32 = ${MESH_FLAG_RTE_DRAWABLE}u;
+
+        // The fragment position the section/crop tests run in: camera-relative
+        // for RTE drawables (the packer writes plane and box in that frame),
+        // world space otherwise.
+        fn clipSpacePos(worldPos: vec3<f32>, eyePos: vec3<f32>) -> vec3<f32> {
+          return select(worldPos, eyePos, (uniforms.flags.x & RTE_DRAWABLE_FLAG) != 0u);
+        }
+
+        // True when p is cut away: ABOVE the section plane (flags.y bit 0 =
+        // enabled, bit 1 = flipped) or OUTSIDE the clip box (bit 2).
+        fn sectionClipped(p: vec3<f32>) -> bool {
+          if ((uniforms.flags.y & 1u) == 1u) {
+            let side = select(1.0, -1.0, (uniforms.flags.y & 2u) == 2u);
+            if ((dot(p, uniforms.sectionPlane.xyz) - uniforms.sectionPlane.w) * side > 0.0) { return true; }
+          }
+          if ((uniforms.flags.y & 4u) != 0u) {
+            if (any(p < uniforms.clipBoxMin.xyz) || any(p > uniforms.clipBoxMax.xyz)) { return true; }
+          }
+          return false;
+        }
+`;
+//# sourceMappingURL=mesh-uniforms.wgsl.js.map

package/dist/shaders/mesh-uniforms.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-uniforms.wgsl.js","sourceRoot":"","sources":["../../src/shaders/mesh-uniforms.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;GAKG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;yCAoBS,sBAAsB;;;;;;;;;;;;;;;;;;;;;CAqB9D,CAAC"}

package/dist/shaders/section-2d-overlay.wgsl.d.ts

@@ -85,6 +85,7 @@ export declare const SECTION_2D_UNIFORM_SLOT_INDEX: {
     readonly grid: number;
     readonly dxf: number;
     readonly terrain: number;
+    readonly centreline: number;
     readonly clashBox: number;
 };
 /** One cap record plus a partition range for every line family. */

package/dist/shaders/section-2d-overlay.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"section-2d-overlay.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/section-2d-overlay.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;IACnC,+CAA+C;;IAE/C,+CAA+C;;IAE/C,+CAA+C;;IAE/C,gDAAgD;;IAEhD,gFAAgF;;IAEhF,oEAAoE;;IAEpE,mFAAmF;;IAEnF,oEAAoE;;IAEpE,8DAA8D;;;CAGtD,CAAC;AAEX,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,6CAA6C;AAC7C,eAAO,MAAM,wBAAwB,QAAgC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD,eAAO,MAAM,6BAA6B;IACxC,6EAA6E;;;;;;;;CAQrE,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,6BAA6B,QAAyC,CAAC;AAEpF;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAIlE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,k7LA8H9B,CAAC;AAER;;;GAGG;AACH,eAAO,MAAM,4BAA4B,46EAyDlC,CAAC"}
+{"version":3,"file":"section-2d-overlay.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/section-2d-overlay.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;IACnC,+CAA+C;;IAE/C,+CAA+C;;IAE/C,+CAA+C;;IAE/C,gDAAgD;;IAEhD,gFAAgF;;IAEhF,oEAAoE;;IAEpE,mFAAmF;;IAEnF,oEAAoE;;IAEpE,8DAA8D;;;CAGtD,CAAC;AAEX,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,6CAA6C;AAC7C,eAAO,MAAM,wBAAwB,QAAgC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD,eAAO,MAAM,6BAA6B;IACxC,6EAA6E;;;;;;;;;CASrE,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,6BAA6B,QAAyC,CAAC;AAEpF;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAIlE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,k7LA8H9B,CAAC;AAER;;;GAGG;AACH,eAAO,MAAM,4BAA4B,46EAyDlC,CAAC"}

package/dist/shaders/section-2d-overlay.wgsl.js

@@ -88,10 +88,11 @@ export const SECTION_2D_UNIFORM_SLOT_INDEX = {
     grid: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 2,
     dxf: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 3,
     terrain: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 4,
-    clashBox: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 5,
+    centreline: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 5,
+    clashBox: 1 + SECTION_2D_MAX_LINE_PARTITIONS * 6,
 };
 /** One cap record plus a partition range for every line family. */
-export const SECTION_2D_UNIFORM_SLOT_COUNT = 1 + SECTION_2D_MAX_LINE_PARTITIONS * 6;
+export const SECTION_2D_UNIFORM_SLOT_COUNT = 1 + SECTION_2D_MAX_LINE_PARTITIONS * 7;
 /**
  * Byte stride between uniform slots for `device`.
  *

package/dist/shaders/section-2d-overlay.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"section-2d-overlay.wgsl.js","sourceRoot":"","sources":["../../src/shaders/section-2d-overlay.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,+CAA+C;IAC/C,QAAQ,EAAE,CAAC;IACX,+CAA+C;IAC/C,WAAW,EAAE,EAAE;IACf,+CAA+C;IAC/C,YAAY,EAAE,EAAE;IAChB,gDAAgD;IAChD,cAAc,EAAE,EAAE;IAClB,gFAAgF;IAChF,MAAM,EAAE,EAAE;IACV,oEAAoE;IACpE,OAAO,EAAE,EAAE;IACX,mFAAmF;IACnF,SAAS,EAAE,EAAE;IACb,oEAAoE;IACpE,WAAW,EAAE,EAAE;IACf,8DAA8D;IAC9D,eAAe,EAAE,EAAE;IACnB,cAAc,EAAE,EAAE;CACV,CAAC;AAEX,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C,6CAA6C;AAC7C,MAAM,CAAC,MAAM,wBAAwB,GAAG,yBAAyB,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAG,CAAC;AAElD,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,6EAA6E;IAC7E,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC,GAAG,8BAA8B;IAC7C,IAAI,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC5C,GAAG,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC3C,OAAO,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC/C,QAAQ,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;CACxC,CAAC;AAEX,mEAAmE;AACnE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,GAAG,8BAA8B,GAAG,CAAC,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAiB;IACxD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,+BAA+B,IAAI,GAAG,CAAC;IACxE,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC;IAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8H5C,CAAC;AAER;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyDhD,CAAC"}
+{"version":3,"file":"section-2d-overlay.wgsl.js","sourceRoot":"","sources":["../../src/shaders/section-2d-overlay.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,+CAA+C;IAC/C,QAAQ,EAAE,CAAC;IACX,+CAA+C;IAC/C,WAAW,EAAE,EAAE;IACf,+CAA+C;IAC/C,YAAY,EAAE,EAAE;IAChB,gDAAgD;IAChD,cAAc,EAAE,EAAE;IAClB,gFAAgF;IAChF,MAAM,EAAE,EAAE;IACV,oEAAoE;IACpE,OAAO,EAAE,EAAE;IACX,mFAAmF;IACnF,SAAS,EAAE,EAAE;IACb,oEAAoE;IACpE,WAAW,EAAE,EAAE;IACf,8DAA8D;IAC9D,eAAe,EAAE,EAAE;IACnB,cAAc,EAAE,EAAE;CACV,CAAC;AAEX,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C,6CAA6C;AAC7C,MAAM,CAAC,MAAM,wBAAwB,GAAG,yBAAyB,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAG,CAAC;AAElD,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,6EAA6E;IAC7E,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC,GAAG,8BAA8B;IAC7C,IAAI,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC5C,GAAG,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC3C,OAAO,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAC/C,UAAU,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;IAClD,QAAQ,EAAE,CAAC,GAAG,8BAA8B,GAAG,CAAC;CACxC,CAAC;AAEX,mEAAmE;AACnE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,GAAG,8BAA8B,GAAG,CAAC,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAiB;IACxD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,+BAA+B,IAAI,GAAG,CAAC;IACxE,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC;IAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8H5C,CAAC;AAER;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyDhD,CAAC"}

package/dist/shaders/selection-mask.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bind-group index of the scene depth texture in the mask pipeline layout:
+ * group 0 is the mesh uniform that `vs_main` reads, so depth is group 1.
+ * `selection-mask-pass.ts` builds its layout from this same constant.
+ */
+export declare const SELECTION_MASK_DEPTH_GROUP = 1;
+/**
+ * Bind-group index of the hovered-entity uniform (`vec4<u32>`, x = id) in the
+ * INSTANCED mask pipeline layout only (#5745). The non-instanced variant
+ * selects its meshes on the CPU and declares no such binding.
+ */
+export declare const SELECTION_MASK_HOVER_GROUP = 2;
+/** Relative depth slack for "the same surface" (reverse-Z: ~0.2 % of the distance). */
+export declare const MASK_DEPTH_REL_TOLERANCE = 0.002;
+export declare function selectionMaskFragmentSource(multisampled: boolean, instanced?: boolean): string;
+//# sourceMappingURL=selection-mask.wgsl.d.ts.map

package/dist/shaders/selection-mask.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-mask.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/selection-mask.wgsl.ts"],"names":[],"mappings":"AAqDA;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,uFAAuF;AACvF,eAAO,MAAM,wBAAwB,QAAO,CAAC;AAuB7C,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,MAAM,CAmD5F"}

package/dist/shaders/selection-mask.wgsl.js

@@ -0,0 +1,138 @@
+/* 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/. */
+/**
+ * Fragment stage for the selection/hover mask pass (#5390). The vertex
+ * stage is `mainShaderSource`'s `vs_main` (recompiled as its own
+ * `GPUShaderModule`, reusing the exact same RTE/section-plane/transform
+ * math the selection highlight draw already uses) — this module supplies
+ * only the fragment side, so the two can be mixed in one pipeline: a
+ * fragment entry point with no declared inputs is interface-compatible
+ * with any vertex stage, since `@builtin(position)` is always available.
+ *
+ * Manual depth test instead of a real depth-stencil attachment: comparing
+ * `@builtin(position).z` (this fragment's own device depth) against the
+ * scene depth texture (`depth-reconstruct.wgsl.ts`'s `loadDepth`, same
+ * sample-0 convention as the AO/edge passes) means the mask targets stay
+ * single-sample regardless of the scene's MSAA sample count, with no
+ * resolve step of their own.
+ *
+ * Every output first drops fragments the section plane or clip box cuts
+ * away (`sectionClipped`, shared with `fs_main`), so an outline never traces
+ * geometry the section tool removed. That reads the mesh uniform at group 0
+ * and the `worldPos` / `eyePos` varyings `vs_main` already emits.
+ *
+ * Three outputs, at most one per pipeline:
+ *  - `fs_mask_selected_visible` / `fs_mask_hover_visible`: pass only where
+ *    this fragment is at least as close as the stored scene depth
+ *    (reverse-Z: `>=`), i.e. not occluded. `discard` otherwise, so the
+ *    additive blend leaves the target at 0 there. The comparison is NOT
+ *    exact: the stored depth is sample 0 of an MSAA attachment (not the
+ *    pixel centre) and was usually written by the batch draw, whose
+ *    positions may be quantized, so the same surface lands a slope-sized
+ *    step away. `isVisible` therefore allows this fragment's own depth
+ *    slope (`fwidth`, taken before any branch so it stays in uniform
+ *    control flow) plus `MASK_DEPTH_REL_TOLERANCE` of its depth; reverse-Z
+ *    depth is proportional to 1/distance, so that is a relative distance
+ *    tolerance. A fixed 1e-7 epsilon failed on every pixel of a real
+ *    WebGPU frame, leaving the visible mask empty.
+ *  - `fs_mask_selected_all`: always passes (drawn "through occluders").
+ *
+ * Instanced variant (#5745, `instanced = true`): the vertex stage is
+ * `vs_instanced` instead, so one draw covers every occurrence of a template.
+ * The same entry points then also keep only the occurrences they are for:
+ * selected ones (instance flag bit 0) for the selected outputs, and the one
+ * whose entity id is the hovered id (a small uniform at
+ * `SELECTION_MASK_HOVER_GROUP`) for the hover output. Hidden occurrences
+ * (flag bit 1) are dropped, as `fs_main` drops them. The section/clip cut and
+ * the depth test are the same code as the non-instanced variant.
+ */
+import { depthTextureWgsl } from './depth-reconstruct.wgsl.js';
+import { meshUniformsWgsl } from './mesh-uniforms.wgsl.js';
+/**
+ * Bind-group index of the scene depth texture in the mask pipeline layout:
+ * group 0 is the mesh uniform that `vs_main` reads, so depth is group 1.
+ * `selection-mask-pass.ts` builds its layout from this same constant.
+ */
+export const SELECTION_MASK_DEPTH_GROUP = 1;
+/**
+ * Bind-group index of the hovered-entity uniform (`vec4<u32>`, x = id) in the
+ * INSTANCED mask pipeline layout only (#5745). The non-instanced variant
+ * selects its meshes on the CPU and declares no such binding.
+ */
+export const SELECTION_MASK_HOVER_GROUP = 2;
+/** Relative depth slack for "the same surface" (reverse-Z: ~0.2 % of the distance). */
+export const MASK_DEPTH_REL_TOLERANCE = 2e-3;
+/**
+ * Which occurrences each output keeps. The non-instanced pass is handed only
+ * the meshes it should draw, so every fragment qualifies; the instanced pass
+ * draws whole templates and filters per occurrence off the flat varyings
+ * `vs_instanced` emits (`VertexOutput.entityId` / `.instSelected`).
+ */
+function occurrenceFilterWgsl(instanced) {
+    if (!instanced) {
+        return `
+        fn isSelectedOccurrence(input: MaskInput) -> bool { return true; }
+        fn isHoveredOccurrence(input: MaskInput) -> bool { return true; }`;
+    }
+    return `
+        @group(${SELECTION_MASK_HOVER_GROUP}) @binding(0) var<uniform> maskHover: vec4<u32>;
+        // bit 0 = selected, bit 1 = hidden (instanced-vertex-layout.ts).
+        fn isSelectedOccurrence(input: MaskInput) -> bool { return (input.instSelected & 3u) == 1u; }
+        fn isHoveredOccurrence(input: MaskInput) -> bool {
+          return (input.instSelected & 2u) == 0u && input.entityId == maskHover.x;
+        }`;
+}
+export function selectionMaskFragmentSource(multisampled, instanced = false) {
+    const instanceVaryings = instanced
+        ? `
+          @location(2) @interpolate(flat) entityId: u32,
+          @location(5) @interpolate(flat) instSelected: u32,`
+        : '';
+    return `
+        ${meshUniformsWgsl}
+        ${depthTextureWgsl(0, multisampled, SELECTION_MASK_DEPTH_GROUP)}
+
+        // The subset of the vertex stage's VertexOutput the mask reads (locations match).
+        struct MaskInput {
+          @builtin(position) fragPos: vec4<f32>,
+          @location(0) worldPos: vec3<f32>,
+          @location(6) eyePos: vec3<f32>,${instanceVaryings}
+        }
+        ${occurrenceFilterWgsl(instanced)}
+
+        fn isCut(input: MaskInput) -> bool {
+          return sectionClipped(clipSpacePos(input.worldPos, input.eyePos));
+        }
+
+        const MASK_DEPTH_REL_TOLERANCE: f32 = ${MASK_DEPTH_REL_TOLERANCE};
+
+        // depthSlope = fwidth(fragPos.z), taken by the caller in uniform control flow.
+        fn isVisible(fragPos: vec4<f32>, depthSlope: f32) -> bool {
+          let ip = vec2<i32>(fragPos.xy);
+          let slack = depthSlope + fragPos.z * MASK_DEPTH_REL_TOLERANCE;
+          return fragPos.z >= loadDepth(ip) - slack;
+        }
+
+        @fragment
+        fn fs_mask_selected_visible(input: MaskInput) -> @location(0) vec4<f32> {
+          let depthSlope = fwidth(input.fragPos.z);
+          if (!isSelectedOccurrence(input) || isCut(input) || !isVisible(input.fragPos, depthSlope)) { discard; }
+          return vec4<f32>(1.0, 0.0, 0.0, 0.0);
+        }
+
+        @fragment
+        fn fs_mask_hover_visible(input: MaskInput) -> @location(0) vec4<f32> {
+          let depthSlope = fwidth(input.fragPos.z);
+          if (!isHoveredOccurrence(input) || isCut(input) || !isVisible(input.fragPos, depthSlope)) { discard; }
+          return vec4<f32>(0.0, 1.0, 0.0, 0.0);
+        }
+
+        @fragment
+        fn fs_mask_selected_all(input: MaskInput) -> @location(0) vec4<f32> {
+          if (!isSelectedOccurrence(input) || isCut(input)) { discard; }
+          return vec4<f32>(1.0, 0.0, 0.0, 0.0);
+        }
+`;
+}
+//# sourceMappingURL=selection-mask.wgsl.js.map

package/dist/shaders/selection-mask.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-mask.wgsl.js","sourceRoot":"","sources":["../../src/shaders/selection-mask.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C,uFAAuF;AACvF,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAE7C;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,SAAkB;IAC9C,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO;;0EAE+D,CAAC;IACzE,CAAC;IACD,OAAO;iBACQ,0BAA0B;;;;;UAKjC,CAAC;AACX,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,YAAqB,EAAE,SAAS,GAAG,KAAK;IAClF,MAAM,gBAAgB,GAAG,SAAS;QAChC,CAAC,CAAC;;6DAEuD;QACzD,CAAC,CAAC,EAAE,CAAC;IACP,OAAO;UACC,gBAAgB;UAChB,gBAAgB,CAAC,CAAC,EAAE,YAAY,EAAE,0BAA0B,CAAC;;;;;;2CAM5B,gBAAgB;;UAEjD,oBAAoB,CAAC,SAAS,CAAC;;;;;;gDAMO,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvE,CAAC;AACF,CAAC"}

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

@@ -27,5 +27,5 @@
  * the unused `worldPos` output on those pipelines costs an interpolator, not a
  * shader stage.
  */
-export declare const shadowShaderSource = "\n        \nstruct RteFrameUniform {\n  // Camera translation is intentionally absent. This projects positions\n  // returned by rteWorldPosition, which are already relative to the eye.\n  viewProj: mat4x4<f32>,\n}\n\nstruct RteDrawableUniform {\n  // CPU computes (drawable origin - camera origin) in f64 and splits it.\n  // This data must be refreshed whenever the RTE camera frame changes.\n  drawableDeltaHigh: vec4<f32>,\n  drawableDeltaLow: vec4<f32>,\n}\n\nfn rteWorldPosition(\n  local: vec3<f32>,\n  drawable: RteDrawableUniform,\n) -> vec4<f32> {\n  // Do not subtract a camera origin here: this delta was formed in CPU f64.\n  let highDelta = drawable.drawableDeltaHigh.xyz;\n  let lowDelta = drawable.drawableDeltaLow.xyz;\n  // A drawable template can span kilometres. Keep local with high first;\n  // The local-plus-(high-plus-low) association is not equivalent in f32.\n  return vec4<f32>((local + highDelta) + lowDelta, 1.0);\n}\n\n        struct Light {\n          lightViewProj: mat4x4<f32>,\n          cameraHigh: vec4<f32>,\n          cameraLow: vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> light: Light;\n\n        struct Draw {\n          model: mat4x4<f32>,\n          // xyz = lattice-aligned quantMin (batch-origin-relative), w = step.\n          // Read only by vs_shadow_quantized; zero for the other paths.\n          quantParams: vec4<f32>,\n          originHigh: vec4<f32>,\n          originLow: vec4<f32>,\n        }\n        @binding(1) @group(0) var<uniform> draw: Draw;\n\n        struct Clip {\n          // xyz = plane normal, w = plane distance (world space).\n          sectionPlane: vec4<f32>,\n          clipBoxMin: vec4<f32>,\n          clipBoxMax: vec4<f32>,\n          // x packs: bit 0 = section enabled, bit 1 = section flipped,\n          //          bit 2 = clip box enabled. Mirrors main.wgsl's flags.y.\n          flags: vec4<u32>,\n        }\n        @binding(2) @group(0) var<uniform> clip: Clip;\n\n        struct FlatIn {\n          @location(0) position: vec3<f32>,\n        }\n\n        struct QuantIn {\n          @location(0) q: vec4<u32>,   // uint16x4: lattice x, y, z, packedOct\n        }\n\n        struct InstanceIn {\n          @location(3) m0: vec4<f32>,\n          @location(4) m1: vec4<f32>,\n          @location(5) m2: vec4<f32>,\n          @location(6) m3: vec4<f32>,\n          // Per-occurrence flags lane (bit 1 = hidden), same instance buffer the\n          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are unused by\n          // the depth pass and left unbound.\n          @location(9) flags: u32,\n          // V2 split drawable-minus-camera delta, byte offsets 88 and 104.\n          @location(10) anchorHigh: vec4<f32>,\n          @location(11) anchorLow: vec4<f32>,\n        }\n\n        struct ShadowOut {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n        }\n\n        fn emit(eyePos: vec4<f32>) -> ShadowOut {\n          var out: ShadowOut;\n          out.position = light.lightViewProj * eyePos;\n          out.worldPos = eyePos.xyz;\n          return out;\n        }\n\n        @vertex\n        fn vs_shadow_flat(input: FlatIn) -> ShadowOut {\n          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        @vertex\n        fn vs_shadow_quantized(input: QuantIn) -> ShadowOut {\n          let p = draw.quantParams.xyz\n            + vec3<f32>(f32(input.q.x), f32(input.q.y), f32(input.q.z)) * draw.quantParams.w;\n          let linear = (draw.model * vec4<f32>(p, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        @vertex\n        fn vs_shadow_instanced(input: FlatIn, inst: InstanceIn) -> ShadowOut {\n          // A hidden / isolation-excluded occurrence (flags bit 1) must not cast:\n          // the colour pass discards it in fs_main, so collapse it to a zero-area\n          // triangle here (every vertex to one clip point) \u2014 the rasterizer drops\n          // it and it writes no depth. Mirrors main.wgsl's instSelected & 2u check.\n          if ((inst.flags & 2u) != 0u) {\n            var out: ShadowOut;\n            out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n            out.worldPos = vec3<f32>(0.0, 0.0, 0.0);\n            return out;\n          }\n          let instMat = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);\n          // Keep the local placement from the V1 matrix and add the shared\n          // CPU-packed drawable-minus-camera delta. The light projection uses\n          // the same RTE frame as the colour and picker submissions.\n          let linear = (instMat * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(\n            inst.anchorHigh, inst.anchorLow,\n          )));\n        }\n\n        @vertex\n        fn vs_shadow_textured(input: FlatIn) -> ShadowOut {\n          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        // Clipped variant: discard before the depth write, so a clipped-away\n        // occluder leaves the shadow map untouched. Kept byte-for-byte in step\n        // with the fs_main section/clip-box branches.\n        @fragment\n        fn fs_shadow_clip(@location(0) worldPos: vec3<f32>) {\n          if ((clip.flags.x & 1u) == 1u) {\n            let side = select(1.0, -1.0, (clip.flags.x & 2u) == 2u);\n            let distToPlane = (dot(worldPos, clip.sectionPlane.xyz) - clip.sectionPlane.w) * side;\n            if (distToPlane > 0.0) {\n              discard;\n            }\n          }\n          if ((clip.flags.x & 4u) != 0u) {\n            if (any(worldPos < clip.clipBoxMin.xyz) || any(worldPos > clip.clipBoxMax.xyz)) {\n              discard;\n            }\n          }\n        }\n";
+export declare const shadowShaderSource = "\n        \nstruct RteFrameUniform {\n  // Camera translation is intentionally absent. This projects positions\n  // returned by rteWorldPosition, which are already relative to the eye.\n  viewProj: mat4x4<f32>,\n}\n\nstruct RteDrawableUniform {\n  // CPU computes (drawable origin - camera origin) in f64 and splits it.\n  // This data must be refreshed whenever the RTE camera frame changes.\n  drawableDeltaHigh: vec4<f32>,\n  drawableDeltaLow: vec4<f32>,\n}\n\nfn rteWorldPosition(\n  local: vec3<f32>,\n  drawable: RteDrawableUniform,\n) -> vec4<f32> {\n  // Do not subtract a camera origin here: this delta was formed in CPU f64.\n  let highDelta = drawable.drawableDeltaHigh.xyz;\n  let lowDelta = drawable.drawableDeltaLow.xyz;\n  // A drawable template can span kilometres. Keep local with high first;\n  // The local-plus-(high-plus-low) association is not equivalent in f32.\n  return vec4<f32>((local + highDelta) + lowDelta, 1.0);\n}\n\n        struct Light {\n          lightViewProj: mat4x4<f32>,\n          cameraHigh: vec4<f32>,\n          cameraLow: vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> light: Light;\n\n        struct Draw {\n          model: mat4x4<f32>,\n          // xyz = lattice-aligned quantMin (batch-origin-relative), w = step.\n          // Read only by vs_shadow_quantized; zero for the other paths.\n          quantParams: vec4<f32>,\n          originHigh: vec4<f32>,\n          originLow: vec4<f32>,\n        }\n        @binding(1) @group(0) var<uniform> draw: Draw;\n\n        struct Clip {\n          // xyz = plane normal, w = plane distance (world space).\n          sectionPlane: vec4<f32>,\n          clipBoxMin: vec4<f32>,\n          clipBoxMax: vec4<f32>,\n          // x packs: bit 0 = section enabled, bit 1 = section flipped,\n          //          bit 2 = clip box enabled. Mirrors main.wgsl's flags.y.\n          flags: vec4<u32>,\n        }\n        @binding(2) @group(0) var<uniform> clip: Clip;\n\n        struct FlatIn {\n          @location(0) position: vec3<f32>,\n        }\n\n        struct QuantIn {\n          @location(0) q: vec4<u32>,   // uint16x4: lattice x, y, z, packedOct\n        }\n\n        struct InstanceIn {\n          @location(3) m0: vec4<f32>,\n          @location(4) m1: vec4<f32>,\n          @location(5) m2: vec4<f32>,\n          @location(6) m3: vec4<f32>,\n          // Per-occurrence flags lane (bit 1 = hidden), same instance buffer the\n          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are in the\n          // shared layout but unused by the depth pass.\n          @location(9) flags: u32,\n          // Split drawable-minus-camera delta from the slot-2 delta stream.\n          @location(10) anchorHigh: vec4<f32>,\n          @location(11) anchorLow: vec4<f32>,\n        }\n\n        struct ShadowOut {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n        }\n\n        fn emit(eyePos: vec4<f32>) -> ShadowOut {\n          var out: ShadowOut;\n          out.position = light.lightViewProj * eyePos;\n          out.worldPos = eyePos.xyz;\n          return out;\n        }\n\n        @vertex\n        fn vs_shadow_flat(input: FlatIn) -> ShadowOut {\n          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        @vertex\n        fn vs_shadow_quantized(input: QuantIn) -> ShadowOut {\n          let p = draw.quantParams.xyz\n            + vec3<f32>(f32(input.q.x), f32(input.q.y), f32(input.q.z)) * draw.quantParams.w;\n          let linear = (draw.model * vec4<f32>(p, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        @vertex\n        fn vs_shadow_instanced(input: FlatIn, inst: InstanceIn) -> ShadowOut {\n          // A hidden / isolation-excluded occurrence (flags bit 1) must not cast:\n          // the colour pass discards it in fs_main, so collapse it to a zero-area\n          // triangle here (every vertex to one clip point) \u2014 the rasterizer drops\n          // it and it writes no depth. Mirrors main.wgsl's instSelected & 2u check.\n          if ((inst.flags & 2u) != 0u) {\n            var out: ShadowOut;\n            out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n            out.worldPos = vec3<f32>(0.0, 0.0, 0.0);\n            return out;\n          }\n          let instMat = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);\n          // Keep the local placement from the V1 matrix and add the shared\n          // CPU-packed drawable-minus-camera delta. The light projection uses\n          // the same RTE frame as the colour and picker submissions.\n          let linear = (instMat * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(\n            inst.anchorHigh, inst.anchorLow,\n          )));\n        }\n\n        @vertex\n        fn vs_shadow_textured(input: FlatIn) -> ShadowOut {\n          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;\n          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));\n        }\n\n        // Clipped variant: discard before the depth write, so a clipped-away\n        // occluder leaves the shadow map untouched. Kept byte-for-byte in step\n        // with the fs_main section/clip-box branches.\n        @fragment\n        fn fs_shadow_clip(@location(0) worldPos: vec3<f32>) {\n          if ((clip.flags.x & 1u) == 1u) {\n            let side = select(1.0, -1.0, (clip.flags.x & 2u) == 2u);\n            let distToPlane = (dot(worldPos, clip.sectionPlane.xyz) - clip.sectionPlane.w) * side;\n            if (distToPlane > 0.0) {\n              discard;\n            }\n          }\n          if ((clip.flags.x & 4u) != 0u) {\n            if (any(worldPos < clip.clipBoxMin.xyz) || any(worldPos > clip.clipBoxMax.xyz)) {\n              discard;\n            }\n          }\n        }\n";
 //# sourceMappingURL=shadow.wgsl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shadow.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,+6LA4H9B,CAAC"}
+{"version":3,"file":"shadow.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,w7LA4H9B,CAAC"}

package/dist/shaders/shadow.wgsl.js

@@ -75,10 +75,10 @@ export const shadowShaderSource = `
           @location(5) m2: vec4<f32>,
           @location(6) m3: vec4<f32>,
           // Per-occurrence flags lane (bit 1 = hidden), same instance buffer the
-          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are unused by
-          // the depth pass and left unbound.
+          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are in the
+          // shared layout but unused by the depth pass.
           @location(9) flags: u32,
-          // V2 split drawable-minus-camera delta, byte offsets 88 and 104.
+          // Split drawable-minus-camera delta from the slot-2 delta stream.
           @location(10) anchorHigh: vec4<f32>,
           @location(11) anchorLow: vec4<f32>,
         }

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

@@ -0,0 +1,34 @@
+/**
+ * Specular reflection for the geometry fragment stage (#5386).
+ *
+ * Two terms, both in the units of `fs_main`'s `lightTerm`, so the caller
+ * scales them by the same exposure and `IRRADIANCE_CALIBRATION` as the
+ * diffuse light and every preset stays consistent:
+ *
+ *  - the sun: a Cook-Torrance lobe (GGX distribution, Smith-Schlick
+ *    visibility, Schlick Fresnel). `fs_main` lights a Lambertian albedo as
+ *    `albedo * intensity`, i.e. the sun's irradiance is `pi * intensity`, so
+ *    the lobe is scaled by the same `pi` and a white dielectric reflects no
+ *    more than physics allows next to its diffuse.
+ *  - the environment: the same two-colour hemisphere that lights the diffuse
+ *    ambient, read along the reflection vector and weighted by the
+ *    split-sum environment BRDF (Karis's analytic fit, "Physically Based
+ *    Shading on Mobile", 2014). The fit already accounts for the lobe's
+ *    shadowing, so a rough surface picks up almost nothing at grazing angles
+ *    while a smooth one (glass) turns into a mirror there.
+ *
+ * `reflectance` is that directional albedo of the specular lobe. The caller
+ * takes it off the diffuse (`1 - reflectance`), so a highlight never adds
+ * energy on top of a full diffuse, and glass uses it as the light it no
+ * longer transmits.
+ *
+ * Reads the `env` lighting uniform, like `sunShadowFactor`.
+ */
+/**
+ * Smallest roughness the lobe is evaluated at. Below this the GGX peak is a
+ * sub-pixel spike that flickers from frame to frame. The value is Filament's
+ * `MIN_PERCEPTUAL_ROUGHNESS` for 32-bit floats.
+ */
+export declare const MIN_SPECULAR_ROUGHNESS = 0.045;
+export declare const specularWgsl = "\n        const MIN_SPECULAR_ROUGHNESS: f32 = 0.045;\n        const DIELECTRIC_F0: f32 = 0.04;\n        const PI: f32 = 3.14159265;\n\n        fn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {\n          return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\n        }\n\n        fn distributionGGX(NdotH: f32, roughness: f32) -> f32 {\n          let a = roughness * roughness;\n          let a2 = a * a;\n          let NdotH2 = NdotH * NdotH;\n          let denomBase = (NdotH2 * (a2 - 1.0) + 1.0);\n          return a2 / max(PI * denomBase * denomBase, 0.0000001);\n        }\n\n        fn geometrySchlickGGX(NdotV: f32, roughness: f32) -> f32 {\n          let r = (roughness + 1.0);\n          let k = (r * r) / 8.0;\n          return NdotV / max(NdotV * (1.0 - k) + k, 0.0000001);\n        }\n\n        fn geometrySmith(NdotV: f32, NdotL: f32, roughness: f32) -> f32 {\n          return geometrySchlickGGX(NdotL, roughness) * geometrySchlickGGX(NdotV, roughness);\n        }\n\n        // Split-sum environment BRDF, analytic fit (Karis 2014).\n        fn envBrdfApprox(F0: vec3<f32>, roughness: f32, NdotV: f32) -> vec3<f32> {\n          let r = roughness * vec4<f32>(-1.0, -0.0275, -0.572, 0.022) + vec4<f32>(1.0, 0.0425, 1.04, -0.04);\n          let a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;\n          let ab = vec2<f32>(-1.04, 1.04) * a004 + r.zw;\n          return F0 * ab.x + ab.y;\n        }\n\n        struct SurfaceSpecular {\n          // Reflected light, in lightTerm units (unexposed, uncalibrated).\n          light: vec3<f32>,\n          // Directional albedo of the specular lobe for this view.\n          reflectance: vec3<f32>,\n        }\n\n        // N and V are unit vectors; V points from the surface to the eye.\n        // sunLight is the sun's diffuse-equivalent intensity: sunColor *\n        // sunIntensity * sunShadow, exactly what scales the diffuse sun term.\n        fn surfaceSpecular(\n          N: vec3<f32>,\n          V: vec3<f32>,\n          albedo: vec3<f32>,\n          metallic: f32,\n          roughnessIn: f32,\n          sunLight: vec3<f32>,\n        ) -> SurfaceSpecular {\n          var out: SurfaceSpecular;\n          let NdotV = dot(N, V);\n          // A face turned away from the eye is its back side: nothing it\n          // reflects can reach the eye, and its diffuse keeps full weight.\n          if (NdotV <= 0.0) {\n            out.light = vec3<f32>(0.0);\n            out.reflectance = vec3<f32>(0.0);\n            return out;\n          }\n          let roughness = clamp(roughnessIn, MIN_SPECULAR_ROUGHNESS, 1.0);\n          let F0 = mix(vec3<f32>(DIELECTRIC_F0), albedo, metallic);\n\n          let L = env.sunDirection;\n          let rawNdotL = dot(N, L);\n          let NdotL = max(rawNdotL, 0.0);\n          // A face the sun is behind (rawNdotL <= 0) contributes nothing to\n          // the direct lobe anyway (NdotL clamps it to 0 below), but V + L\n          // can be exactly zero there \u2014 the sun exactly opposite the eye\n          // reflection, e.g. N = V = (0,-1,0), sun = (0,1,0), both satisfy\n          // NdotV > 0 above. normalize(vec3(0)) is NaN in WGSL, and NaN * 0\n          // is NaN, not 0, so it would poison sun and everything summed with\n          // it instead of being multiplied away. Skip the half-vector\n          // entirely in that case rather than relying on the NdotL factor.\n          var sun = vec3<f32>(0.0);\n          if (rawNdotL > 0.0) {\n            let H = normalize(V + L);\n            let D = distributionGGX(max(dot(N, H), 0.0), roughness);\n            let G = geometrySmith(NdotV, NdotL, roughness);\n            let F = fresnelSchlick(max(dot(V, H), 0.0), F0);\n            // BRDF * NdotL * (pi * intensity); the NdotL cancels the BRDF's.\n            sun = F * (D * G * PI / (4.0 * NdotV)) * sunLight;\n          }\n\n          // The hemisphere ambient, looked up along the reflection. A rough\n          // lobe gathers from around the normal, so lean the lookup toward N.\n          let R = reflect(-V, N);\n          let Rd = normalize(mix(R, N, roughness * roughness));\n          let sky = mix(env.groundColor, env.skyColor, Rd.y * 0.5 + 0.5) * env.ambientIntensity;\n          let reflectance = envBrdfApprox(F0, roughness, NdotV);\n\n          out.light = sun + sky * reflectance;\n          out.reflectance = reflectance;\n          return out;\n        }\n";
+//# sourceMappingURL=specular.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specular.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/specular.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAE5C,eAAO,MAAM,YAAY,u1IAiGxB,CAAC"}

package/dist/shaders/specular.wgsl.js

@@ -0,0 +1,134 @@
+/* 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/. */
+/**
+ * Specular reflection for the geometry fragment stage (#5386).
+ *
+ * Two terms, both in the units of `fs_main`'s `lightTerm`, so the caller
+ * scales them by the same exposure and `IRRADIANCE_CALIBRATION` as the
+ * diffuse light and every preset stays consistent:
+ *
+ *  - the sun: a Cook-Torrance lobe (GGX distribution, Smith-Schlick
+ *    visibility, Schlick Fresnel). `fs_main` lights a Lambertian albedo as
+ *    `albedo * intensity`, i.e. the sun's irradiance is `pi * intensity`, so
+ *    the lobe is scaled by the same `pi` and a white dielectric reflects no
+ *    more than physics allows next to its diffuse.
+ *  - the environment: the same two-colour hemisphere that lights the diffuse
+ *    ambient, read along the reflection vector and weighted by the
+ *    split-sum environment BRDF (Karis's analytic fit, "Physically Based
+ *    Shading on Mobile", 2014). The fit already accounts for the lobe's
+ *    shadowing, so a rough surface picks up almost nothing at grazing angles
+ *    while a smooth one (glass) turns into a mirror there.
+ *
+ * `reflectance` is that directional albedo of the specular lobe. The caller
+ * takes it off the diffuse (`1 - reflectance`), so a highlight never adds
+ * energy on top of a full diffuse, and glass uses it as the light it no
+ * longer transmits.
+ *
+ * Reads the `env` lighting uniform, like `sunShadowFactor`.
+ */
+/**
+ * Smallest roughness the lobe is evaluated at. Below this the GGX peak is a
+ * sub-pixel spike that flickers from frame to frame. The value is Filament's
+ * `MIN_PERCEPTUAL_ROUGHNESS` for 32-bit floats.
+ */
+export const MIN_SPECULAR_ROUGHNESS = 0.045;
+export const specularWgsl = `
+        const MIN_SPECULAR_ROUGHNESS: f32 = ${MIN_SPECULAR_ROUGHNESS};
+        const DIELECTRIC_F0: f32 = 0.04;
+        const PI: f32 = 3.14159265;
+
+        fn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
+          return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
+        }
+
+        fn distributionGGX(NdotH: f32, roughness: f32) -> f32 {
+          let a = roughness * roughness;
+          let a2 = a * a;
+          let NdotH2 = NdotH * NdotH;
+          let denomBase = (NdotH2 * (a2 - 1.0) + 1.0);
+          return a2 / max(PI * denomBase * denomBase, 0.0000001);
+        }
+
+        fn geometrySchlickGGX(NdotV: f32, roughness: f32) -> f32 {
+          let r = (roughness + 1.0);
+          let k = (r * r) / 8.0;
+          return NdotV / max(NdotV * (1.0 - k) + k, 0.0000001);
+        }
+
+        fn geometrySmith(NdotV: f32, NdotL: f32, roughness: f32) -> f32 {
+          return geometrySchlickGGX(NdotL, roughness) * geometrySchlickGGX(NdotV, roughness);
+        }
+
+        // Split-sum environment BRDF, analytic fit (Karis 2014).
+        fn envBrdfApprox(F0: vec3<f32>, roughness: f32, NdotV: f32) -> vec3<f32> {
+          let r = roughness * vec4<f32>(-1.0, -0.0275, -0.572, 0.022) + vec4<f32>(1.0, 0.0425, 1.04, -0.04);
+          let a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;
+          let ab = vec2<f32>(-1.04, 1.04) * a004 + r.zw;
+          return F0 * ab.x + ab.y;
+        }
+
+        struct SurfaceSpecular {
+          // Reflected light, in lightTerm units (unexposed, uncalibrated).
+          light: vec3<f32>,
+          // Directional albedo of the specular lobe for this view.
+          reflectance: vec3<f32>,
+        }
+
+        // N and V are unit vectors; V points from the surface to the eye.
+        // sunLight is the sun's diffuse-equivalent intensity: sunColor *
+        // sunIntensity * sunShadow, exactly what scales the diffuse sun term.
+        fn surfaceSpecular(
+          N: vec3<f32>,
+          V: vec3<f32>,
+          albedo: vec3<f32>,
+          metallic: f32,
+          roughnessIn: f32,
+          sunLight: vec3<f32>,
+        ) -> SurfaceSpecular {
+          var out: SurfaceSpecular;
+          let NdotV = dot(N, V);
+          // A face turned away from the eye is its back side: nothing it
+          // reflects can reach the eye, and its diffuse keeps full weight.
+          if (NdotV <= 0.0) {
+            out.light = vec3<f32>(0.0);
+            out.reflectance = vec3<f32>(0.0);
+            return out;
+          }
+          let roughness = clamp(roughnessIn, MIN_SPECULAR_ROUGHNESS, 1.0);
+          let F0 = mix(vec3<f32>(DIELECTRIC_F0), albedo, metallic);
+
+          let L = env.sunDirection;
+          let rawNdotL = dot(N, L);
+          let NdotL = max(rawNdotL, 0.0);
+          // A face the sun is behind (rawNdotL <= 0) contributes nothing to
+          // the direct lobe anyway (NdotL clamps it to 0 below), but V + L
+          // can be exactly zero there — the sun exactly opposite the eye
+          // reflection, e.g. N = V = (0,-1,0), sun = (0,1,0), both satisfy
+          // NdotV > 0 above. normalize(vec3(0)) is NaN in WGSL, and NaN * 0
+          // is NaN, not 0, so it would poison sun and everything summed with
+          // it instead of being multiplied away. Skip the half-vector
+          // entirely in that case rather than relying on the NdotL factor.
+          var sun = vec3<f32>(0.0);
+          if (rawNdotL > 0.0) {
+            let H = normalize(V + L);
+            let D = distributionGGX(max(dot(N, H), 0.0), roughness);
+            let G = geometrySmith(NdotV, NdotL, roughness);
+            let F = fresnelSchlick(max(dot(V, H), 0.0), F0);
+            // BRDF * NdotL * (pi * intensity); the NdotL cancels the BRDF's.
+            sun = F * (D * G * PI / (4.0 * NdotV)) * sunLight;
+          }
+
+          // The hemisphere ambient, looked up along the reflection. A rough
+          // lobe gathers from around the normal, so lean the lookup toward N.
+          let R = reflect(-V, N);
+          let Rd = normalize(mix(R, N, roughness * roughness));
+          let sky = mix(env.groundColor, env.skyColor, Rd.y * 0.5 + 0.5) * env.ambientIntensity;
+          let reflectance = envBrdfApprox(F0, roughness, NdotV);
+
+          out.light = sun + sky * reflectance;
+          out.reflectance = reflectance;
+          return out;
+        }
+`;
+//# sourceMappingURL=specular.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specular.wgsl.js","sourceRoot":"","sources":["../../src/shaders/specular.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,CAAC;AAE5C,MAAM,CAAC,MAAM,YAAY,GAAG;8CACkB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGnE,CAAC"}

package/dist/shadow-occluders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow-occluders.d.ts","sourceRoot":"","sources":["../src/shadow-occluders.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3D,qEAAqE;AACrE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,SAAS,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC3C,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAClC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;CAC1B;AAED,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,iDAAiD;AACjD,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACrD,GAAG,GAAE,YAAmC,GACvC,YAAY,CASd;AAsBD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEjD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,EACjD,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAClD,oBAAoB,CAYtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,CAAC,EAAE,gBAAgB,EAC7B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,kBAAkB,EAAE,CAoEtB"}
+{"version":3,"file":"shadow-occluders.d.ts","sourceRoot":"","sources":["../src/shadow-occluders.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3D,qEAAqE;AACrE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,SAAS,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC3C,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAClC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;CAC1B;AAED,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,iDAAiD;AACjD,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACrD,GAAG,GAAE,YAAmC,GACvC,YAAY,CASd;AAsBD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEjD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,EACjD,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAClD,oBAAoB,CAYtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,CAAC,EAAE,gBAAgB,EAC7B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,kBAAkB,EAAE,CAqEtB"}

package/dist/shadow-occluders.js

@@ -119,6 +119,7 @@ export function collectShadowOccluders(sources, visibility, options) {
             instanceBuffer: it.instanceBuffer,
             instanceCount: it.instanceCount,
             canonicalAnchors: it.canonicalAnchors,
+            rteDeltas: it.rteDeltas,
         });
     }
     for (const tm of sources.textured) {

package/dist/shadow-occluders.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow-occluders.js","sourceRoot":"","sources":["../src/shadow-occluders.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"shadow-occluders.js","sourceRoot":"","sources":["../src/shadow-occluders.ts"],"names":[],"mappings":"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"}

package/dist/shadow-pass.d.ts

@@ -80,7 +80,6 @@ export declare class ShadowPass {
     private createDrawBindGroup;
     private posBuffer;
     private quantBuffer;
-    private instanceBuffer;
     private createPipeline;
 }
 //# sourceMappingURL=shadow-pass.d.ts.map

package/dist/shadow-pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow-pass.d.ts","sourceRoot":"","sources":["../src/shadow-pass.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAKvC,OAAO,KAAK,EACV,UAAU,EAEV,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAWxG,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,gBAAgB,CAAiB;IAEzC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,SAAS,CAA4C;IAC7D;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA0D;IAC/E,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,cAAc,CAAoB;IAE1C,OAAO,CAAC,WAAW,CAAY;IAC/B,8EAA8E;IAC9E,OAAO,CAAC,YAAY,CAAwB;IAE5C,+EAA+E;IAC/E,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,SAAS,CAA4C;IAE7D,yEAAyE;IACzE,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,WAAW,CAAe;IAElC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM;IAoDjD,mFAAmF;IACnF,OAAO,CAAC,iBAAiB;IAWzB,wDAAwD;IACxD,mBAAmB,IAAI,cAAc;IAIrC,aAAa,IAAI,MAAM;IAIvB,8EAA8E;IAC9E,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC;;;;;;;OAOG;IACH,MAAM,CACJ,OAAO,EAAE,iBAAiB,EAC1B,aAAa,EAAE,IAAI,EACnB,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,EACxB,GAAG,CAAC,EAAE,cAAc,GAAG,IAAI,GAC1B,IAAI;IAmGP,OAAO,IAAI,IAAI;IASf;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,cAAc;CA2CvB"}
+{"version":3,"file":"shadow-pass.d.ts","sourceRoot":"","sources":["../src/shadow-pass.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAMvC,OAAO,KAAK,EACV,UAAU,EAEV,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAWxG,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,gBAAgB,CAAiB;IAEzC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,SAAS,CAA4C;IAC7D;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA0D;IAC/E,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,cAAc,CAAoB;IAE1C,OAAO,CAAC,WAAW,CAAY;IAC/B,8EAA8E;IAC9E,OAAO,CAAC,YAAY,CAAwB;IAE5C,+EAA+E;IAC/E,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,SAAS,CAA4C;IAE7D,yEAAyE;IACzE,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,WAAW,CAAe;IAElC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM;IAoDjD,mFAAmF;IACnF,OAAO,CAAC,iBAAiB;IAWzB,wDAAwD;IACxD,mBAAmB,IAAI,cAAc;IAIrC,aAAa,IAAI,MAAM;IAIvB,8EAA8E;IAC9E,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC;;;;;;;OAOG;IACH,MAAM,CACJ,OAAO,EAAE,iBAAiB,EAC1B,aAAa,EAAE,IAAI,EACnB,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,EACxB,GAAG,CAAC,EAAE,cAAc,GAAG,IAAI,GAC1B,IAAI;IAgHP,OAAO,IAAI,IAAI;IASf;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,cAAc;CA2CvB"}