@ifc-lite/renderer 5.0.0 → 6.0.1

package/dist/shaders/main.wgsl.js

@@ -5,14 +5,15 @@
  * Main rendering shader for IFC geometry.
  * Features: linear-space lighting of sRGB-authored colours with a GGX
  * specular term (specular.wgsl.ts), section plane clipping, selection
- * highlight, glass, hue-preserving highlight roll-off, screen-space edge
- * enhancement.
+ * highlight, glass, hue-preserving highlight roll-off. Edges come from the
+ * screen-space edge pass (edge-pass.ts), not from this shader (#5746).
  */
-import { MESH_FLAG_RTE_DRAWABLE } from '../mesh-rte-uniforms.js';
 import { colorTransferWgsl } from './color-transfer.wgsl.js';
 import { mainRteWgsl, mainShadowWgsl } from './main-rte-shadow.wgsl.js';
+import { meshUniformsWgsl } from './mesh-uniforms.wgsl.js';
 import { relativeToEyeWgsl } from './relative-to-eye.wgsl.js';
 import { specularWgsl } from './specular.wgsl.js';
+import { entityColorTableWgsl } from './entity-color-table.wgsl.js';
 /**
  * Translucent surfaces draw at this fraction of their alpha, so interiors
  * read through windows and X-Ray ghosts stay faint. A viewer choice that
@@ -37,25 +38,7 @@ const TRANSLUCENT_OPACITY_SCALE = 0.7;
  */
 const IRRADIANCE_CALIBRATION = 1.82;
 export const mainShaderSource = `
-        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 = edgeEnabled, w = edgeIntensityMilli
-          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>,
-        }
-        @binding(0) @group(0) var<uniform> uniforms: Uniforms;
-        const RTE_DRAWABLE_FLAG: u32 = ${MESH_FLAG_RTE_DRAWABLE}u;
+        ${meshUniformsWgsl}
         ${relativeToEyeWgsl}
         ${mainRteWgsl}
         // Shared group(1) lighting; packing matches packEnvironmentUniforms().
@@ -83,6 +66,7 @@ export const mainShaderSource = `
         const TRANSLUCENT_OPACITY_SCALE: f32 = ${TRANSLUCENT_OPACITY_SCALE};
         ${colorTransferWgsl}
         ${specularWgsl}
+        ${entityColorTableWgsl}
 
         ${mainShadowWgsl}
 
@@ -97,10 +81,9 @@ export const mainShaderSource = `
           @location(0) worldPos: vec3<f32>,
           @location(1) normal: vec3<f32>,
           @location(2) @interpolate(flat) entityId: u32,
-          @location(3) viewPos: vec3<f32>,  // For edge detection
           // Per-draw albedo carried from the vertex stage so the fragment shader
           // is shared by the flat path (vs_main writes uniforms.baseColor — the
-          // per-batch / overlay-override colour) AND the instanced path
+          // per-batch colour) AND the instanced path
           // (vs_instanced writes the per-occurrence colour from the instance
           // buffer). For the flat path this is identical to reading
           // uniforms.baseColor directly (the value is constant across the draw).
@@ -182,7 +165,6 @@ export const mainShaderSource = `
           output.color = uniforms.baseColor;
           output.instSelected = 0u;
           output.eyePos = eyePos;
-          output.viewPos = select((uniforms.viewProj * worldPos).xyz, (uniforms.rteViewProj * vec4<f32>(eyePos, 1.0)).xyz, rte);
           return output;
         }
 
@@ -210,12 +192,10 @@ export const mainShaderSource = `
           // an 8-bit MATERIAL-COLOUR salt that mergeGeometry/interleaveTextured
           // baked into the HIGH 8 bits of the entityId lane (low 24 = picking id,
           // masked off by encodeId24). Crucially the salt comes from the mesh's
-          // OWN colour, NOT the per-draw baseColor uniform — so the base opaque
-          // pass and the lens/IDS/compare/4D OVERLAY pass (which redraws the same
-          // geometry with a DIFFERENT draw colour) compute the SAME nudge, and
-          // the overlay pipeline's depthCompare:'equal' matches instead of
-          // rejecting every fragment. At 1e-6 per step the max world-space offset
-          // is <3mm at 10m — invisible.
+          // OWN colour, NOT the per-draw baseColor uniform — so every redraw of
+          // the same geometry with a different draw colour (the selection
+          // highlight's greater-equal pass) computes the SAME nudge as its
+          // batch. At 1e-6 per step the max world-space offset is <3mm at 10m.
           let colorSalt = (input.entityId >> 24u) * 2654435761u;
           let zHash = (((input.entityId & 0x00FFFFFFu) ^ colorSalt) * 2654435761u) & 255u;
           output.position.z *= 1.0 + f32(zHash) * 1e-6;
@@ -225,8 +205,6 @@ export const mainShaderSource = `
           output.color = uniforms.baseColor;
           output.instSelected = 0u;  // flat path selects via uniforms.flags.x
           output.eyePos = eyePos;
-          // Store view-space position for edge detection
-          output.viewPos = select((uniforms.viewProj * worldPos).xyz, (uniforms.rteViewProj * vec4<f32>(eyePos, 1.0)).xyz, rte);
           return output;
         }
 
@@ -245,8 +223,8 @@ export const mainShaderSource = `
           let eyePos = rteInstancePosition(linearLocal, inst.anchorHigh.xyz, inst.anchorLow.xyz).xyz;
           output.position = uniforms.rteViewProj * vec4<f32>(eyePos, 1.0);
           // Same per-entity depth nudge as vs_main. No colour salt here: the
-          // instanced path has no base-vs-overlay coincident redraw (yet), so the
-          // raw picking id is enough to separate coplanar entities.
+          // instanced path never redraws an occurrence with a second draw
+          // colour, so the raw picking id is enough to separate coplanar entities.
           let zHash = ((inst.instEntityId & 0x00FFFFFFu) * 2654435761u) & 255u;
           output.position.z *= 1.0 + f32(zHash) * 1e-6;
           output.worldPos = worldPos.xyz;
@@ -255,7 +233,6 @@ export const mainShaderSource = `
           output.color = inst.instColor;
           output.instSelected = inst.instSelected;
           output.eyePos = eyePos;
-          output.viewPos = (uniforms.rteViewProj * vec4<f32>(eyePos, 1.0)).xyz;
           return output;
         }
 
@@ -278,7 +255,7 @@ export const mainShaderSource = `
           // that frame; otherwise the RTE vertex precision is thrown away at
           // section/crop/derivative ingress. Instanced geometry is not yet
           // anchored, so its worldPos remains the authoritative input.
-          let fragmentPos = select(input.worldPos, input.eyePos, (uniforms.flags.x & RTE_DRAWABLE_FLAG) != 0u);
+          let fragmentPos = clipSpacePos(input.worldPos, input.eyePos);
           // Per-instance hide/isolate: bit 1 of the instance flags lane marks a hidden
           // occurrence. Discard it so it neither draws nor writes depth (and the pick
           // pass applies the same discard, so it isn't pickable). vs_main writes
@@ -300,27 +277,9 @@ export const mainShaderSource = `
               if (!occOpaque) { discard; }
             }
           }
-          // Section plane clipping - discard fragments ABOVE the plane.
-          // flags.y packs two bits: bit 0 = enabled, bit 1 = flipped.
-          let sectionEnabled = (uniforms.flags.y & 1u) == 1u;
-          if (sectionEnabled) {
-            let planeNormal = uniforms.sectionPlane.xyz;
-            let planeDistance = uniforms.sectionPlane.w;
-            let flipped = (uniforms.flags.y & 2u) == 2u;
-            let side = select(1.0, -1.0, flipped);
-            let distToPlane = (dot(fragmentPos, planeNormal) - planeDistance) * side;
-            if (distToPlane > 0.0) {
-              discard;
-            }
-          }
-          // Clip box (section / crop box): discard fragments OUTSIDE the AABB.
-          // flags.y bit 2 = clip-box enabled.
-          if ((uniforms.flags.y & 4u) != 0u) {
-            let p = fragmentPos;
-            if (any(p < uniforms.clipBoxMin.xyz) || any(p > uniforms.clipBoxMax.xyz)) {
-              discard;
-            }
-          }
+          // Section plane / clip box (mesh-uniforms.wgsl.ts, shared with the
+          // selection mask so an outline is cut where its surface is).
+          if (sectionClipped(fragmentPos)) { discard; }
 
           // Compute normal via derivative-based flat shading.
           //
@@ -432,15 +391,9 @@ export const mainShaderSource = `
           let irradiance = lightTerm * (env.exposure * IRRADIANCE_CALIBRATION);
           var color = baseColor * irradiance;
 
-          // flags.x is a bitfield:
-          //   bit 0 (value 1) = isSelected  → selection-highlight + force opaque
-          //   bit 1 (value 2) = isOverlay   → color-override pass; preserve
-          //                                    baseColor.a (overlay pipeline has
-          //                                    src-alpha blending) AND skip the
-          //                                    specular term, so an override
-          //                                    paints its colour, lit, and a
-          //                                    low-alpha ghost tint does not
-          //                                    pick up glass reflections.
+          // flags.x bit 0 (value 1) = isSelected → selection highlight, forced opaque.
+          // bit 1 (value 2) = isOverlay → legacy overlay pipeline callers;
+          // preserve alpha and skip specular for their blended draw.
           // Selected via the per-draw flag (flat path) OR the per-occurrence flag
           // (instanced path — vs_instanced reads it from the instance buffer).
           let isSelected = ((uniforms.flags.x & 1u) == 1u) || ((input.instSelected & 1u) == 1u);
@@ -480,28 +433,22 @@ export const mainShaderSource = `
             color = selectionColor.rgb * shade;
           }
 
-          // flags.x bit 5 (value 32) = EMPHASIZE overlay: render the colour
-          // override FULLY UNLIT and saturated (no lighting attenuation, no
-          // wash-to-white) so the focused clash pair reads as a solid, vivid,
-          // distinct colour that pops against the lit model — like a clash tool.
-          // A faint normal-based shade keeps the silhouette from going flat. (#1277)
+          // Public getOverlayPipeline() callers can still use the emphasized
+          // overlay bit even though internal colour overrides now use a table.
           let emphasizedOverlay = isOverlay && (uniforms.flags.x & 32u) != 0u;
           if (emphasizedOverlay) {
             let facet = 0.85 + 0.15 * abs(dot(N, normalize(vec3<f32>(0.3, 1.0, 0.2))));
             color = baseColor * facet;
           }
 
-          // Force alpha to 1.0 for selected objects so the highlight is fully
-          // opaque (the selection pipeline has no alpha blending). Emphasized
-          // clash overlay paints a SOLID vivid fill (force opaque) so it isn't
-          // blended down to a pale tint against the geometry beneath.
+          // Selected objects and emphasized overlays draw fully opaque.
           var finalAlpha = select(input.color.a, 1.0, isSelected || emphasizedOverlay);
 
           // Specular (#5386; specular.wgsl.ts), after the diffuse above. Not
-          // on the selection highlight (it would wash the blue out) nor on a
-          // colour-override overlay. The sun lobe is scaled exactly like the
-          // diffuse sun term, and both terms like irradiance, so a preset's
-          // highlights and its diffuse light move together.
+          // on the selection highlight or legacy overlay (it would wash out
+          // their colours); a table override is composited without it below. The
+          // sun lobe is scaled exactly like the diffuse sun term, and both
+          // terms like irradiance, so a preset's highlights and diffuse move together.
           if (!isSelected && !isOverlay) {
             // Glass is an authored translucent material (mesh-material.ts
             // also gives it its smooth roughness). An X-Ray or compare fade
@@ -511,13 +458,23 @@ export const mainShaderSource = `
             let instancedPass = (uniforms.flags.x & 4u) != 0u;
             let translucent = finalAlpha < 0.99;
             let glass = translucent && uniforms.transmission.x > 0.5 && !instancedPass;
-            let metallic = clamp(uniforms.metallicRoughness.x, 0.0, 1.0);
+            // #5984: an instanced occurrence's own authored finish rides its
+            // flags lane (instanced-render.ts packInstanceFinish); the pass's
+            // uniform row is the shared default.
+            var metallicRoughness = vec2<f32>(uniforms.metallicRoughness.x, uniforms.metallicRoughness.y);
+            if (instancedPass && (input.instSelected & 4u) != 0u) {
+              metallicRoughness.x = f32((input.instSelected >> 16u) & 255u) / 255.0;
+            }
+            if (instancedPass && (input.instSelected & 8u) != 0u) {
+              metallicRoughness.y = f32((input.instSelected >> 24u) & 255u) / 255.0;
+            }
+            let metallic = clamp(metallicRoughness.x, 0.0, 1.0);
             let spec = surfaceSpecular(
               N,
               normalize(-input.eyePos),
               baseColor,
               metallic,
-              uniforms.metallicRoughness.y,
+              metallicRoughness.y,
               env.sunColor * (env.sunIntensity * sunShadow),
             );
             // What the lobe reflects is not there to diffuse; a metal has no
@@ -552,41 +509,16 @@ export const mainShaderSource = `
           // the roll-off threshold.
           color = neutralCompress(color);
 
-          // Subtle edge enhancement using screen-space derivatives.
-          //
-          // Use the SHADED normal (face normal from dpdx/dpdy above)
-          // for the normal-gradient term, not the interpolated vertex
-          // normal — otherwise we get spurious dark stripes on flat
-          // surfaces whose vertex normals carry numerical noise from
-          // CSG output (the visible scar-line symptom would just
-          // resurface here even after the lit-normal fix). With the
-          // face normal, coplanar adjacent triangles agree exactly →
-          // zero normal gradient → no false edge; only the genuine
-          // creases between perpendicular faces produce a real
-          // gradient and get the intended outline.
-          let depthGradient = length(vec2<f32>(
-            dpdx(input.viewPos.z),
-            dpdy(input.viewPos.z)
-          ));
-          let normalGradient = length(vec2<f32>(
-            length(dpdx(N)),
-            length(dpdy(N))
-          ));
-
-          if (uniforms.flags.z == 1u) {
-            // Threshold filters subtle normal discontinuities at internal
-            // triangle edges between coplanar entities in the same batch.
-            let edgeFactor = smoothstep(0.02, 0.12, depthGradient * 10.0 + normalGradient * 5.0);
-            let edgeIntensity = f32(uniforms.flags.w) / 1000.0;
-            let edgeDarkenStrength = clamp(0.25 * edgeIntensity, 0.0, 0.85);
-            let edgeDarken = mix(1.0, 1.0 - edgeDarkenStrength, edgeFactor);
-            color *= edgeDarken;
-          }
-
           color = linearToSrgb(clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)));
 
           var out: FragmentOutput;
           out.color = vec4<f32>(color, finalAlpha);
+          // Colour override from the per-entity table (#6076): only draws the
+          // renderer marks (overrideParams.y), i.e. depth-writing opaque ones.
+          let entityOverride = entityOverrideColor(input.entityId);
+          if (entityOverride.a >= 0.0 && !isSelected) {
+            out.color = paintEntityOverride(out.color, entityOverride, irradiance, N);
+          }
           out.objectIdEncoded = encodeId24(input.entityId);
           return out;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;GAMG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;GAIG;AACH,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;yCAmBS,sBAAsB;UACrD,iBAAiB;UACjB,WAAW;;;;;;;;;;;;;;;;;;;;;;8CAsByB,sBAAsB;iDACnB,yBAAyB;UAChE,iBAAiB;UACjB,YAAY;;UAEZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0fjB,CAAC"}
+{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;GAMG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;GAIG;AACH,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC,MAAM,CAAC,MAAM,gBAAgB,GAAG;UACtB,gBAAgB;UAChB,iBAAiB;UACjB,WAAW;;;;;;;;;;;;;;;;;;;;;;8CAsByB,sBAAsB;iDACnB,yBAAyB;UAChE,iBAAiB;UACjB,YAAY;UACZ,oBAAoB;;UAEpB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAscjB,CAAC"}

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>,
         }