@ifc-lite/renderer 3.2.0 → 5.0.0

package/dist/shaders/relative-to-eye.wgsl.js

@@ -0,0 +1,40 @@
+/* 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/. */
+/**
+ * Shared WGSL half of the renderer RTE contract.
+ *
+ * A pass owns its binding declarations, but imports this verbatim into its
+ * shader source and uses `rteWorldPosition` before projection.  The layouts
+ * match `RelativeToEyeFrame.packUniforms` and `packRteOrigin` exactly: a
+ * translation-free `viewProj` per frame, then two vec4 drawable-camera delta
+ * lanes per draw. Origins are world/source f64 values on the CPU; `local` is
+ * the element-local f32 vertex already resident in a vertex buffer.
+ */
+export const relativeToEyeWgsl = `
+struct RteFrameUniform {
+  // Camera translation is intentionally absent. This projects positions
+  // returned by rteWorldPosition, which are already relative to the eye.
+  viewProj: mat4x4<f32>,
+}
+
+struct RteDrawableUniform {
+  // CPU computes (drawable origin - camera origin) in f64 and splits it.
+  // This data must be refreshed whenever the RTE camera frame changes.
+  drawableDeltaHigh: vec4<f32>,
+  drawableDeltaLow: vec4<f32>,
+}
+
+fn rteWorldPosition(
+  local: vec3<f32>,
+  drawable: RteDrawableUniform,
+) -> vec4<f32> {
+  // Do not subtract a camera origin here: this delta was formed in CPU f64.
+  let highDelta = drawable.drawableDeltaHigh.xyz;
+  let lowDelta = drawable.drawableDeltaLow.xyz;
+  // A drawable template can span kilometres. Keep local with high first;
+  // The local-plus-(high-plus-low) association is not equivalent in f32.
+  return vec4<f32>((local + highDelta) + lowDelta, 1.0);
+}
+`;
+//# sourceMappingURL=relative-to-eye.wgsl.js.map

package/dist/shaders/relative-to-eye.wgsl.js.map

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

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

@@ -36,20 +36,25 @@ export declare const SECTION_2D_UNIFORM_SLOTS: {
     readonly params2: 32;
     /** vec4<f32> overlay / section-cut line colour — floats 36..39 (bytes 144..159) */
     readonly lineColor: 36;
+    /** mat4 camera-relative projection for opt-in anchored overlays. */
+    readonly rteViewProj: 40;
+    /** split f64-like (origin - eye) delta; w = 1 enables RTE. */
+    readonly originDeltaHigh: 56;
+    readonly originDeltaLow: 60;
 };
 /** Total float count of one uniform record (40 floats = 160 bytes). */
-export declare const SECTION_2D_UNIFORM_FLOATS = 40;
+export declare const SECTION_2D_UNIFORM_FLOATS = 64;
 /** Total byte size of one uniform record. */
 export declare const SECTION_2D_UNIFORM_BYTES: number;
 /**
  * One uniform slot per draw site.
  *
- * The overlay renderer issues up to six draws into a **single** render pass —
- * the section cut cap plus five world-space line families — and every one of
+ * The overlay renderer issues up to seven draw sites into a **single** render pass —
+ * the section cut cap plus six world-space line families — and every one of
  * them needs a different `lineColor` (and, for the cap, a different
  * `planeOffset` and the whole cap-style tail). With one record shared between
  * them the last `queue.writeBuffer` before submit is what the GPU sees for all
- * six: `writeBuffer` is a *queue* operation, so it is applied before the
+ * seven: `writeBuffer` is a *queue* operation, so it is applied before the
  * command buffer that references it executes, no matter where in the encoding
  * it was issued. Every earlier draw therefore rendered with the last draw's
  * uniforms — most visibly, the clash box's colour bleeding onto the annotation,
@@ -57,21 +62,32 @@ export declare const SECTION_2D_UNIFORM_BYTES: number;
  * hatch to the zeroed tail the line draws write.
  *
  * Each site owning a fixed slot, addressed with a dynamic bind-group offset,
- * is what makes the six draws independent while keeping the buffer, the layout
+ * is what makes the seven draw sites independent while keeping the buffer, the layout
  * and the bind group under the single owner issue #2456 insisted on. A slot per
  * site (rather than a bump allocator) needs no per-frame reset hook: each site
  * draws at most once per pass.
  */
+/**
+ * Max independently-anchored line partitions per channel in one pass.
+ *
+ * Spatial batching normally keeps this close to one.  The explicit 256-record
+ * ceiling still bounds the shared dynamic-uniform allocation (384 KiB at the
+ * WebGPU-guaranteed 256-byte stride) while accepting genuinely disjoint survey
+ * features instead of making the old 32-record implementation throw midway
+ * through a render submission.
+ */
+export declare const SECTION_2D_MAX_LINE_PARTITIONS = 256;
 export declare const SECTION_2D_UNIFORM_SLOT_INDEX: {
     /** The section cut cap: fill + outline, which share one record by design. */
     readonly sectionCut: 0;
     readonly annotation: 1;
-    readonly alignment: 2;
-    readonly grid: 3;
-    readonly dxf: 4;
-    readonly clashBox: 5;
+    readonly alignment: number;
+    readonly grid: number;
+    readonly dxf: number;
+    readonly terrain: number;
+    readonly clashBox: number;
 };
-/** How many uniform records the shared buffer holds — one per entry above. */
+/** One cap record plus a partition range for every line family. */
 export declare const SECTION_2D_UNIFORM_SLOT_COUNT: number;
 /**
  * Byte stride between uniform slots for `device`.
@@ -93,10 +109,10 @@ export declare function sectionUniformSlotStride(device: GPUDevice): number;
  * cap style, so single-material cuts read as one architectural section exactly
  * as before. Hatch + stroke apply over either base.
  */
-export declare const SECTION_2D_CAP_FILL_WGSL = "\n        struct Uniforms {\n          viewProj:       mat4x4<f32>,\n          planeOffset:    vec4<f32>,    // Small offset to render slightly in front of section plane\n          capFillColor:   vec4<f32>,\n          capStrokeColor: vec4<f32>,\n          // x=patternId, y=spacingPx, z=angleRad, w=widthPx\n          params:         vec4<f32>,\n          // x=secondaryAngleRad, y,z,w reserved\n          params2:        vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n          @location(1) color:    vec4<f32>,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0)       color:    vec4<f32>,\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput) -> VertexOutput {\n          var output: VertexOutput;\n          let offsetPos = input.position + uniforms.planeOffset.xyz;\n          output.position = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);\n          output.color = input.color;\n          return output;\n        }\n\n        // Screen-space hatch pattern helpers (ported from section-cap.wgsl).\n        fn lineMask(u: f32, s: f32, w: f32) -> f32 {\n          let f = fract(u / s) * s;\n          let d = min(f, s - f);\n          return 1.0 - smoothstep(w * 0.5, w * 0.5 + 1.0, d);\n        }\n        fn rotate(p: vec2<f32>, a: f32) -> vec2<f32> {\n          let c = cos(a);\n          let s = sin(a);\n          return vec2<f32>(c * p.x - s * p.y, s * p.x + c * p.y);\n        }\n        fn hatchIntensity(fragCoord: vec2<f32>, patternId: u32, spacing: f32, angle: f32, width: f32, angle2: f32) -> f32 {\n          let p = fragCoord;\n          if (patternId == 0u) { return 0.0; }          // solid\n          if (patternId == 1u) {                         // diagonal\n            let r = rotate(p, angle);\n            return lineMask(r.x, spacing, width);\n          }\n          if (patternId == 2u) {                         // cross-hatch\n            let r  = rotate(p, angle);\n            let r2 = rotate(p, angle2);\n            return max(lineMask(r.x, spacing, width), lineMask(r2.x, spacing, width));\n          }\n          if (patternId == 3u) { return lineMask(p.y, spacing, width); }    // horizontal\n          if (patternId == 4u) { return lineMask(p.x, spacing, width); }    // vertical\n          if (patternId == 5u) {\n            // Concrete (ISO 128-50): clean regular dot grid. The previous\n            // version layered dashes on top which looked noisy and broken.\n            // Dots sit at every grid intersection; radius scales with\n            // stroke width so the user's width slider works consistently.\n            let gx = p.x - round(p.x / spacing) * spacing;\n            let gy = p.y - round(p.y / spacing) * spacing;\n            let d = sqrt(gx * gx + gy * gy);\n            let radius = max(1.0, width * 1.2);\n            return 1.0 - smoothstep(radius, radius + 1.0, d);\n          }\n          if (patternId == 6u) {                         // brick\n            let bandH = spacing;\n            let band = floor(p.y / bandH);\n            // Signed parity. p is @builtin(position) today, so it is a\n            // framebuffer coordinate and never negative \u2014 but u32() of a\n            // negative float is an out-of-range conversion in WGSL, and the\n            // moment this hatch is fed anything but fragCoord (a world- or\n            // drawing-space variant) the running bond would break across\n            // y = 0 in a backend-dependent way. i32(-1) & 1 is 1, so the\n            // parity alternates correctly in both directions.\n            let offset = select(0.0, bandH, (i32(band) & 1) == 1);\n            let horiz = lineMask(p.y, bandH, width);\n            let vertPos = p.x + offset * 0.5;\n            let vert = step(fract(vertPos / (bandH * 2.0)), 0.02);\n            return max(horiz, vert);\n          }\n          if (patternId == 7u) {                         // insulation\n            let y = spacing * 0.5 * sin(p.x * 6.2831853 / spacing) + p.y;\n            return lineMask(y, spacing, width);\n          }\n          return 0.0;\n        }\n\n        struct FragOut {\n          @location(0) color:    vec4<f32>,\n          @location(1) objectId: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragOut {\n          let patternId = u32(uniforms.params.x + 0.5);\n          let spacing   = max(2.0, uniforms.params.y);\n          let angle     = uniforms.params.z;\n          let width     = max(1.0, uniforms.params.w);\n          let angle2    = uniforms.params2.x;\n\n          let h = hatchIntensity(input.position.xy, patternId, spacing, angle, width, angle2);\n          // Per-polygon colour (a material-layer slab fills with its own\n          // IfcMaterial RGBA) overrides the uniform cap fill when present.\n          // Polygons without a colour carry the sentinel alpha -1 and fall back\n          // to the user's cap style, byte-identically. Hatch + stroke apply over\n          // whichever base is chosen, so the architectural hatch still works.\n          let useVertex = input.color.a >= 0.0;\n          let baseFill = select(uniforms.capFillColor, input.color, useVertex);\n          let rgb = mix(baseFill.rgb, uniforms.capStrokeColor.rgb, h * uniforms.capStrokeColor.a);\n          let a   = max(baseFill.a, h * uniforms.capStrokeColor.a);\n\n          var out: FragOut;\n          out.color    = vec4<f32>(rgb, a);\n          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
+export declare const SECTION_2D_CAP_FILL_WGSL = "\n        struct Uniforms {\n          viewProj:       mat4x4<f32>,\n          planeOffset:    vec4<f32>,    // Small offset to render slightly in front of section plane\n          capFillColor:   vec4<f32>,\n          capStrokeColor: vec4<f32>,\n          // x=patternId, y=spacingPx, z=angleRad, w=widthPx\n          params:         vec4<f32>,\n          // x=secondaryAngleRad, y,z,w reserved\n          params2:        vec4<f32>,\n          lineColor:       vec4<f32>,\n          rteViewProj:     mat4x4<f32>,\n          originDeltaHigh: vec4<f32>,\n          originDeltaLow:  vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n          @location(1) color:    vec4<f32>,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0)       color:    vec4<f32>,\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput) -> VertexOutput {\n          var output: VertexOutput;\n          let offsetPos = input.position + uniforms.planeOffset.xyz;\n          let global = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);\n          let relative = (offsetPos + uniforms.originDeltaHigh.xyz) + uniforms.originDeltaLow.xyz;\n          output.position = select(global, uniforms.rteViewProj * vec4<f32>(relative, 1.0), uniforms.originDeltaHigh.w == 1.0);\n          output.color = input.color;\n          return output;\n        }\n\n        // Screen-space hatch pattern helpers (ported from section-cap.wgsl).\n        fn lineMask(u: f32, s: f32, w: f32) -> f32 {\n          let f = fract(u / s) * s;\n          let d = min(f, s - f);\n          return 1.0 - smoothstep(w * 0.5, w * 0.5 + 1.0, d);\n        }\n        fn rotate(p: vec2<f32>, a: f32) -> vec2<f32> {\n          let c = cos(a);\n          let s = sin(a);\n          return vec2<f32>(c * p.x - s * p.y, s * p.x + c * p.y);\n        }\n        fn hatchIntensity(fragCoord: vec2<f32>, patternId: u32, spacing: f32, angle: f32, width: f32, angle2: f32) -> f32 {\n          let p = fragCoord;\n          if (patternId == 0u) { return 0.0; }          // solid\n          if (patternId == 1u) {                         // diagonal\n            let r = rotate(p, angle);\n            return lineMask(r.x, spacing, width);\n          }\n          if (patternId == 2u) {                         // cross-hatch\n            let r  = rotate(p, angle);\n            let r2 = rotate(p, angle2);\n            return max(lineMask(r.x, spacing, width), lineMask(r2.x, spacing, width));\n          }\n          if (patternId == 3u) { return lineMask(p.y, spacing, width); }    // horizontal\n          if (patternId == 4u) { return lineMask(p.x, spacing, width); }    // vertical\n          if (patternId == 5u) {\n            // Concrete (ISO 128-50): clean regular dot grid. The previous\n            // version layered dashes on top which looked noisy and broken.\n            // Dots sit at every grid intersection; radius scales with\n            // stroke width so the user's width slider works consistently.\n            let gx = p.x - round(p.x / spacing) * spacing;\n            let gy = p.y - round(p.y / spacing) * spacing;\n            let d = sqrt(gx * gx + gy * gy);\n            let radius = max(1.0, width * 1.2);\n            return 1.0 - smoothstep(radius, radius + 1.0, d);\n          }\n          if (patternId == 6u) {                         // brick\n            let bandH = spacing;\n            let band = floor(p.y / bandH);\n            // Signed parity. p is @builtin(position) today, so it is a\n            // framebuffer coordinate and never negative \u2014 but u32() of a\n            // negative float is an out-of-range conversion in WGSL, and the\n            // moment this hatch is fed anything but fragCoord (a world- or\n            // drawing-space variant) the running bond would break across\n            // y = 0 in a backend-dependent way. i32(-1) & 1 is 1, so the\n            // parity alternates correctly in both directions.\n            let offset = select(0.0, bandH, (i32(band) & 1) == 1);\n            let horiz = lineMask(p.y, bandH, width);\n            let vertPos = p.x + offset * 0.5;\n            let vert = step(fract(vertPos / (bandH * 2.0)), 0.02);\n            return max(horiz, vert);\n          }\n          if (patternId == 7u) {                         // insulation\n            let y = spacing * 0.5 * sin(p.x * 6.2831853 / spacing) + p.y;\n            return lineMask(y, spacing, width);\n          }\n          return 0.0;\n        }\n\n        struct FragOut {\n          @location(0) color:    vec4<f32>,\n          @location(1) objectId: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragOut {\n          let patternId = u32(uniforms.params.x + 0.5);\n          let spacing   = max(2.0, uniforms.params.y);\n          let angle     = uniforms.params.z;\n          let width     = max(1.0, uniforms.params.w);\n          let angle2    = uniforms.params2.x;\n\n          let h = hatchIntensity(input.position.xy, patternId, spacing, angle, width, angle2);\n          // Per-polygon colour (a material-layer slab fills with its own\n          // IfcMaterial RGBA) overrides the uniform cap fill when present.\n          // Polygons without a colour carry the sentinel alpha -1 and fall back\n          // to the user's cap style, byte-identically. Hatch + stroke apply over\n          // whichever base is chosen, so the architectural hatch still works.\n          let useVertex = input.color.a >= 0.0;\n          let baseFill = select(uniforms.capFillColor, input.color, useVertex);\n          let rgb = mix(baseFill.rgb, uniforms.capStrokeColor.rgb, h * uniforms.capStrokeColor.a);\n          let a   = max(baseFill.a, h * uniforms.capStrokeColor.a);\n\n          var out: FragOut;\n          out.color    = vec4<f32>(rgb, a);\n          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
 /**
  * Line shader for the section-cut outline and the standalone world-space line
  * overlays (annotation / alignment / grid / DXF / clash box).
  */
-export declare const SECTION_2D_OVERLAY_LINE_WGSL = "\n        // Mirrors the fill shader's uniform layout so both pipelines can share\n        // one buffer; the line shader only reads viewProj, planeOffset and the\n        // appended lineColor (byte offset 144). capFillColor/\u2026 are unused here but\n        // declared for correct field offsets.\n        struct Uniforms {\n          viewProj: mat4x4<f32>,\n          planeOffset: vec4<f32>,\n          capFillColor: vec4<f32>,\n          capStrokeColor: vec4<f32>,\n          params: vec4<f32>,\n          params2: vec4<f32>,\n          lineColor: vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput) -> VertexOutput {\n          var output: VertexOutput;\n          let offsetPos = input.position + uniforms.planeOffset.xyz;\n          let clip = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);\n          // Reverse-Z decal nudge for lines coplanar with model faces\n          // (issue #812). WebGPU forbids depthStencil.depthBias on non-\n          // triangle topologies, so we do the equivalent in clip space:\n          // adding a small positive multiple of clip.w raises NDC z by a\n          // constant after the w-divide, which under reverse-Z means\n          // \"slightly closer\" \u2014 enough to beat MSAA jitter on annotation\n          // lines that ride exactly on a wall/floor.\n          output.position = vec4<f32>(clip.x, clip.y, clip.z + 5e-5 * clip.w, clip.w);\n          return output;\n        }\n\n        struct FragOutLine {\n          @location(0) color:    vec4<f32>,\n          @location(1) objectId: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragOutLine {\n          var out: FragOutLine;\n          out.color    = uniforms.lineColor;  // consumer-themeable (defaults black)\n          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
+export declare const SECTION_2D_OVERLAY_LINE_WGSL = "\n        // Mirrors the fill shader's uniform layout so both pipelines can share\n        // one buffer; the line shader only reads viewProj, planeOffset and the\n        // appended lineColor (byte offset 144). capFillColor/\u2026 are unused here but\n        // declared for correct field offsets.\n        struct Uniforms {\n          viewProj: mat4x4<f32>,\n          planeOffset: vec4<f32>,\n          capFillColor: vec4<f32>,\n          capStrokeColor: vec4<f32>,\n          params: vec4<f32>,\n          params2: vec4<f32>,\n          lineColor: vec4<f32>,\n          rteViewProj: mat4x4<f32>,\n          originDeltaHigh: vec4<f32>,\n          originDeltaLow: vec4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput) -> VertexOutput {\n          var output: VertexOutput;\n          let offsetPos = input.position + uniforms.planeOffset.xyz;\n          let global = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);\n          let relative = (offsetPos + uniforms.originDeltaHigh.xyz) + uniforms.originDeltaLow.xyz;\n          let clip = select(global, uniforms.rteViewProj * vec4<f32>(relative, 1.0), uniforms.originDeltaHigh.w == 1.0);\n          // Reverse-Z decal nudge for lines coplanar with model faces\n          // (issue #812). WebGPU forbids depthStencil.depthBias on non-\n          // triangle topologies, so we do the equivalent in clip space:\n          // adding a small positive multiple of clip.w raises NDC z by a\n          // constant after the w-divide, which under reverse-Z means\n          // \"slightly closer\" \u2014 enough to beat MSAA jitter on annotation\n          // lines that ride exactly on a wall/floor.\n          output.position = vec4<f32>(clip.x, clip.y, clip.z + 5e-5 * clip.w, clip.w);\n          return output;\n        }\n\n        struct FragOutLine {\n          @location(0) color:    vec4<f32>,\n          @location(1) objectId: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragOutLine {\n          var out: FragOutLine;\n          out.color    = uniforms.lineColor;  // consumer-themeable (defaults black)\n          out.objectId = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
 //# sourceMappingURL=section-2d-overlay.wgsl.d.ts.map

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;;CAE3E,CAAC;AAEX,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,6CAA6C;AAC7C,eAAO,MAAM,wBAAwB,QAAgC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,6BAA6B;IACxC,6EAA6E;;;;;;;CAOrE,CAAC;AAEX,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B,QAAoD,CAAC;AAE/F;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAIlE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,ojLAwH9B,CAAC;AAER;;;GAGG;AACH,eAAO,MAAM,4BAA4B,0lEAoDlC,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;;;;;;;;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"}

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

@@ -39,20 +39,25 @@ export const SECTION_2D_UNIFORM_SLOTS = {
     params2: 32,
     /** vec4<f32> overlay / section-cut line colour — floats 36..39 (bytes 144..159) */
     lineColor: 36,
+    /** mat4 camera-relative projection for opt-in anchored overlays. */
+    rteViewProj: 40,
+    /** split f64-like (origin - eye) delta; w = 1 enables RTE. */
+    originDeltaHigh: 56,
+    originDeltaLow: 60,
 };
 /** Total float count of one uniform record (40 floats = 160 bytes). */
-export const SECTION_2D_UNIFORM_FLOATS = 40;
+export const SECTION_2D_UNIFORM_FLOATS = 64;
 /** Total byte size of one uniform record. */
 export const SECTION_2D_UNIFORM_BYTES = SECTION_2D_UNIFORM_FLOATS * 4;
 /**
  * One uniform slot per draw site.
  *
- * The overlay renderer issues up to six draws into a **single** render pass —
- * the section cut cap plus five world-space line families — and every one of
+ * The overlay renderer issues up to seven draw sites into a **single** render pass —
+ * the section cut cap plus six world-space line families — and every one of
  * them needs a different `lineColor` (and, for the cap, a different
  * `planeOffset` and the whole cap-style tail). With one record shared between
  * them the last `queue.writeBuffer` before submit is what the GPU sees for all
- * six: `writeBuffer` is a *queue* operation, so it is applied before the
+ * seven: `writeBuffer` is a *queue* operation, so it is applied before the
  * command buffer that references it executes, no matter where in the encoding
  * it was issued. Every earlier draw therefore rendered with the last draw's
  * uniforms — most visibly, the clash box's colour bleeding onto the annotation,
@@ -60,22 +65,33 @@ export const SECTION_2D_UNIFORM_BYTES = SECTION_2D_UNIFORM_FLOATS * 4;
  * hatch to the zeroed tail the line draws write.
  *
  * Each site owning a fixed slot, addressed with a dynamic bind-group offset,
- * is what makes the six draws independent while keeping the buffer, the layout
+ * is what makes the seven draw sites independent while keeping the buffer, the layout
  * and the bind group under the single owner issue #2456 insisted on. A slot per
  * site (rather than a bump allocator) needs no per-frame reset hook: each site
  * draws at most once per pass.
  */
+/**
+ * Max independently-anchored line partitions per channel in one pass.
+ *
+ * Spatial batching normally keeps this close to one.  The explicit 256-record
+ * ceiling still bounds the shared dynamic-uniform allocation (384 KiB at the
+ * WebGPU-guaranteed 256-byte stride) while accepting genuinely disjoint survey
+ * features instead of making the old 32-record implementation throw midway
+ * through a render submission.
+ */
+export const SECTION_2D_MAX_LINE_PARTITIONS = 256;
 export const SECTION_2D_UNIFORM_SLOT_INDEX = {
     /** The section cut cap: fill + outline, which share one record by design. */
     sectionCut: 0,
     annotation: 1,
-    alignment: 2,
-    grid: 3,
-    dxf: 4,
-    clashBox: 5,
+    alignment: 1 + SECTION_2D_MAX_LINE_PARTITIONS,
+    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,
 };
-/** How many uniform records the shared buffer holds — one per entry above. */
-export const SECTION_2D_UNIFORM_SLOT_COUNT = Object.keys(SECTION_2D_UNIFORM_SLOT_INDEX).length;
+/** 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;
 /**
  * Byte stride between uniform slots for `device`.
  *
@@ -110,6 +126,10 @@ export const SECTION_2D_CAP_FILL_WGSL = /* wgsl */ `
           params:         vec4<f32>,
           // x=secondaryAngleRad, y,z,w reserved
           params2:        vec4<f32>,
+          lineColor:       vec4<f32>,
+          rteViewProj:     mat4x4<f32>,
+          originDeltaHigh: vec4<f32>,
+          originDeltaLow:  vec4<f32>,
         }
         @binding(0) @group(0) var<uniform> uniforms: Uniforms;
 
@@ -127,7 +147,9 @@ export const SECTION_2D_CAP_FILL_WGSL = /* wgsl */ `
         fn vs_main(input: VertexInput) -> VertexOutput {
           var output: VertexOutput;
           let offsetPos = input.position + uniforms.planeOffset.xyz;
-          output.position = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          let global = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          let relative = (offsetPos + uniforms.originDeltaHigh.xyz) + uniforms.originDeltaLow.xyz;
+          output.position = select(global, uniforms.rteViewProj * vec4<f32>(relative, 1.0), uniforms.originDeltaHigh.w == 1.0);
           output.color = input.color;
           return output;
         }
@@ -238,6 +260,9 @@ export const SECTION_2D_OVERLAY_LINE_WGSL = /* wgsl */ `
           params: vec4<f32>,
           params2: vec4<f32>,
           lineColor: vec4<f32>,
+          rteViewProj: mat4x4<f32>,
+          originDeltaHigh: vec4<f32>,
+          originDeltaLow: vec4<f32>,
         }
         @binding(0) @group(0) var<uniform> uniforms: Uniforms;
 
@@ -253,7 +278,9 @@ export const SECTION_2D_OVERLAY_LINE_WGSL = /* wgsl */ `
         fn vs_main(input: VertexInput) -> VertexOutput {
           var output: VertexOutput;
           let offsetPos = input.position + uniforms.planeOffset.xyz;
-          let clip = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          let global = uniforms.viewProj * vec4<f32>(offsetPos, 1.0);
+          let relative = (offsetPos + uniforms.originDeltaHigh.xyz) + uniforms.originDeltaLow.xyz;
+          let clip = select(global, uniforms.rteViewProj * vec4<f32>(relative, 1.0), uniforms.originDeltaHigh.w == 1.0);
           // Reverse-Z decal nudge for lines coplanar with model faces
           // (issue #812). WebGPU forbids depthStencil.depthBias on non-
           // triangle topologies, so we do the equivalent in clip space:

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;CACL,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,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,6EAA6E;IAC7E,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC;IACZ,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,CAAC;IACN,QAAQ,EAAE,CAAC;CACH,CAAC;AAEX,8EAA8E;AAC9E,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC,MAAM,CAAC;AAE/F;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwH5C,CAAC;AAER;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDhD,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,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/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        struct Light {\n          lightViewProj: mat4x4<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        }\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        }\n\n        struct ShadowOut {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n        }\n\n        fn emit(worldPos: vec4<f32>) -> ShadowOut {\n          var out: ShadowOut;\n          out.position = light.lightViewProj * worldPos;\n          out.worldPos = worldPos.xyz;\n          return out;\n        }\n\n        @vertex\n        fn vs_shadow_flat(input: FlatIn) -> ShadowOut {\n          return emit(draw.model * vec4<f32>(input.position, 1.0));\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          return emit(draw.model * vec4<f32>(p, 1.0));\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          return emit(instMat * vec4<f32>(input.position, 1.0));\n        }\n\n        @vertex\n        fn vs_shadow_textured(input: FlatIn) -> ShadowOut {\n          return emit(draw.model * vec4<f32>(input.position, 1.0));\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 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";
 //# 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":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,4hIA2G9B,CAAC"}
+{"version":3,"file":"shadow.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,+6LA4H9B,CAAC"}

package/dist/shaders/shadow.wgsl.js

@@ -1,6 +1,7 @@
 /* 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/. */
+import { relativeToEyeWgsl } from './relative-to-eye.wgsl.js';
 /**
  * Sun shadow-map depth pre-pass shaders (issue #2670, Phase 2).
  *
@@ -31,8 +32,11 @@
  * shader stage.
  */
 export const shadowShaderSource = `
+        ${relativeToEyeWgsl}
         struct Light {
           lightViewProj: mat4x4<f32>,
+          cameraHigh: vec4<f32>,
+          cameraLow: vec4<f32>,
         }
         @binding(0) @group(0) var<uniform> light: Light;
 
@@ -41,6 +45,8 @@ export const shadowShaderSource = `
           // xyz = lattice-aligned quantMin (batch-origin-relative), w = step.
           // Read only by vs_shadow_quantized; zero for the other paths.
           quantParams: vec4<f32>,
+          originHigh: vec4<f32>,
+          originLow: vec4<f32>,
         }
         @binding(1) @group(0) var<uniform> draw: Draw;
 
@@ -72,6 +78,9 @@ export const shadowShaderSource = `
           // colour pass reads. Locations 7 (entityId) and 8 (rgba) are unused by
           // the depth pass and left unbound.
           @location(9) flags: u32,
+          // V2 split drawable-minus-camera delta, byte offsets 88 and 104.
+          @location(10) anchorHigh: vec4<f32>,
+          @location(11) anchorLow: vec4<f32>,
         }
 
         struct ShadowOut {
@@ -79,23 +88,25 @@ export const shadowShaderSource = `
           @location(0) worldPos: vec3<f32>,
         }
 
-        fn emit(worldPos: vec4<f32>) -> ShadowOut {
+        fn emit(eyePos: vec4<f32>) -> ShadowOut {
           var out: ShadowOut;
-          out.position = light.lightViewProj * worldPos;
-          out.worldPos = worldPos.xyz;
+          out.position = light.lightViewProj * eyePos;
+          out.worldPos = eyePos.xyz;
           return out;
         }
 
         @vertex
         fn vs_shadow_flat(input: FlatIn) -> ShadowOut {
-          return emit(draw.model * vec4<f32>(input.position, 1.0));
+          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;
+          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));
         }
 
         @vertex
         fn vs_shadow_quantized(input: QuantIn) -> ShadowOut {
           let p = draw.quantParams.xyz
             + vec3<f32>(f32(input.q.x), f32(input.q.y), f32(input.q.z)) * draw.quantParams.w;
-          return emit(draw.model * vec4<f32>(p, 1.0));
+          let linear = (draw.model * vec4<f32>(p, 0.0)).xyz;
+          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));
         }
 
         @vertex
@@ -111,12 +122,19 @@ export const shadowShaderSource = `
             return out;
           }
           let instMat = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);
-          return emit(instMat * vec4<f32>(input.position, 1.0));
+          // Keep the local placement from the V1 matrix and add the shared
+          // CPU-packed drawable-minus-camera delta. The light projection uses
+          // the same RTE frame as the colour and picker submissions.
+          let linear = (instMat * vec4<f32>(input.position, 0.0)).xyz;
+          return emit(rteWorldPosition(linear, RteDrawableUniform(
+            inst.anchorHigh, inst.anchorLow,
+          )));
         }
 
         @vertex
         fn vs_shadow_textured(input: FlatIn) -> ShadowOut {
-          return emit(draw.model * vec4<f32>(input.position, 1.0));
+          let linear = (draw.model * vec4<f32>(input.position, 0.0)).xyz;
+          return emit(rteWorldPosition(linear, RteDrawableUniform(draw.originHigh, draw.originLow)));
         }
 
         // Clipped variant: discard before the depth write, so a clipped-away

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

@@ -1 +1 @@
-{"version":3,"file":"shadow.wgsl.js","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GjC,CAAC"}
+{"version":3,"file":"shadow.wgsl.js","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;UACxB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2H1B,CAAC"}

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

@@ -1,12 +1,2 @@
-/**
- * Procedural sky background — a single fullscreen triangle drawn at the far
- * plane (reverse-Z: z = 0) before any geometry. Analytic zenith/horizon/
- * ground gradient plus a sun disc + glow, driven by the same sun direction
- * the geometry lighting uses.
- *
- * Tonemapping note: the geometry shader applies ACES + gamma at the end of
- * its fragment stage (not in a post pass), so the sky must apply the same
- * curve here or it would read as a different "film stock" than the model.
- */
-export declare const skyShaderSource = "\n        struct SkyUniforms {\n          camRight: vec3<f32>,\n          tanHalfFovX: f32,\n          camUp: vec3<f32>,\n          tanHalfFovY: f32,\n          camForward: vec3<f32>,\n          exposure: f32,\n          sunDirection: vec3<f32>,\n          sunIntensity: f32,\n          zenithColor: vec3<f32>,\n          _pad0: f32,\n          horizonColor: vec3<f32>,\n          _pad1: f32,\n          groundColor: vec3<f32>,\n          _pad2: f32,\n        }\n        @binding(0) @group(0) var<uniform> sky: SkyUniforms;\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0) ndc: vec2<f32>,\n        }\n\n        @vertex\n        fn vs_main(@builtin(vertex_index) vi: u32) -> VertexOutput {\n          // Fullscreen triangle: (-1,-1), (3,-1), (-1,3).\n          let x = f32((vi << 1u) & 2u) * 2.0 - 1.0;\n          let y = f32(vi & 2u) * 2.0 - 1.0;\n          var out: VertexOutput;\n          // z = 0 is the far plane under reverse-Z, so any geometry drawn\n          // later wins the depth test without the sky writing depth.\n          out.position = vec4<f32>(x, y, 0.0, 1.0);\n          out.ndc = vec2<f32>(x, y);\n          return out;\n        }\n\n        // Same ACES filmic curve as the geometry fragment shader.\n        fn acesTonemap(c: vec3<f32>) -> vec3<f32> {\n          let a = 2.51;\n          let b = 0.03;\n          let cc = 2.43;\n          let d = 0.59;\n          let e = 0.14;\n          return clamp((c * (a * c + b)) / (c * (cc * c + d) + e), vec3<f32>(0.0), vec3<f32>(1.0));\n        }\n\n        struct FragmentOutput {\n          @location(0) color: vec4<f32>,\n          // Matches the pass's object-id attachment clear value so the sky\n          // never registers as a pickable entity.\n          @location(1) objectIdEncoded: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragmentOutput {\n          // Per-pixel view ray from the camera basis. Used for orthographic\n          // cameras too \u2014 parallel rays would collapse the sky to a single\n          // colour, so a perspective-style fan reads better in both modes.\n          let dir = normalize(\n            sky.camForward\n            + input.ndc.x * sky.tanHalfFovX * sky.camRight\n            + input.ndc.y * sky.tanHalfFovY * sky.camUp\n          );\n          let elevation = dir.y;\n\n          // Horizon \u2192 zenith gradient with a slow falloff near the horizon.\n          let zenithMix = pow(clamp(elevation, 0.0, 1.0), 0.45);\n          var color = mix(sky.horizonColor, sky.zenithColor, zenithMix);\n\n          // Below the horizon: fade quickly into the ground colour.\n          // WGSL requires smoothstep's low < high, so express the\n          // downward ramp (0 at the horizon \u2192 1 at elevation -0.1) as the\n          // complement of an ascending smoothstep rather than passing\n          // reversed edges, which Tint rejects as a shader-compile error\n          // (low 0.0 not less than high -0.1) \u2014 that invalidated the whole\n          // sky pipeline and blanked the frame on strict drivers.\n          let groundMix = 1.0 - smoothstep(-0.1, 0.0, elevation);\n          color = mix(color, sky.groundColor, groundMix);\n\n          // Sun disc + glow. The disc is slightly oversized vs the real\n          // ~0.53\u00B0 sun so it stays visible at typical canvas resolutions.\n          let cosSun = dot(dir, sky.sunDirection);\n          let disc = smoothstep(0.99985, 0.99995, cosSun);\n          let glow = pow(max(cosSun, 0.0), 350.0) * 0.5\n                   + pow(max(cosSun, 0.0), 24.0) * 0.12;\n          // Hide the disc once the sun sets, and never draw it on the ground.\n          let sunVisible = smoothstep(-0.06, 0.02, sky.sunDirection.y) * (1.0 - groundMix);\n          let sunTint = vec3<f32>(1.0, 0.92, 0.78);\n          color += (disc * 6.0 + glow) * max(sky.sunIntensity, 0.0) * sunVisible * sunTint;\n\n          // Match the geometry pipeline: exposure \u2192 ACES \u2192 gamma.\n          color *= sky.exposure;\n          color = acesTonemap(color);\n          color = pow(color, vec3<f32>(1.0 / 2.2));\n\n          var out: FragmentOutput;\n          out.color = vec4<f32>(color, 1.0);\n          out.objectIdEncoded = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
+export declare const skyShaderSource = "\n        struct SkyUniforms {\n          camRight: vec3<f32>,\n          tanHalfFovX: f32,\n          camUp: vec3<f32>,\n          tanHalfFovY: f32,\n          camForward: vec3<f32>,\n          exposure: f32,\n          sunDirection: vec3<f32>,\n          sunIntensity: f32,\n          zenithColor: vec3<f32>,\n          _pad0: f32,\n          horizonColor: vec3<f32>,\n          _pad1: f32,\n          groundColor: vec3<f32>,\n          _pad2: f32,\n        }\n        @binding(0) @group(0) var<uniform> sky: SkyUniforms;\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0) ndc: vec2<f32>,\n        }\n\n        @vertex\n        fn vs_main(@builtin(vertex_index) vi: u32) -> VertexOutput {\n          // Fullscreen triangle: (-1,-1), (3,-1), (-1,3).\n          let x = f32((vi << 1u) & 2u) * 2.0 - 1.0;\n          let y = f32(vi & 2u) * 2.0 - 1.0;\n          var out: VertexOutput;\n          // z = 0 is the far plane under reverse-Z, so any geometry drawn\n          // later wins the depth test without the sky writing depth.\n          out.position = vec4<f32>(x, y, 0.0, 1.0);\n          out.ndc = vec2<f32>(x, y);\n          return out;\n        }\n\n        \n        fn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n          let lo = c / 12.92;\n          let hi = pow((max(c, vec3<f32>(0.0)) + 0.055) / 1.055, vec3<f32>(2.4));\n          return select(hi, lo, c <= vec3<f32>(0.04045));\n        }\n\n        fn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n          let lo = c * 12.92;\n          let hi = 1.055 * pow(max(c, vec3<f32>(0.0)), vec3<f32>(1.0 / 2.4)) - 0.055;\n          return select(hi, lo, c <= vec3<f32>(0.0031308));\n        }\n\n        fn neutralCompress(cIn: vec3<f32>) -> vec3<f32> {\n          let startCompression = 0.76;\n          let desaturation = 0.15;\n          let c = max(cIn, vec3<f32>(0.0));\n          let peak = max(c.r, max(c.g, c.b));\n          if (peak < startCompression) { return c; }\n          let d = 1.0 - startCompression;\n          let newPeak = 1.0 - d * d / (peak + d - startCompression);\n          let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n          return mix(c * (newPeak / peak), vec3<f32>(newPeak), g);\n        }\n\n\n        struct FragmentOutput {\n          @location(0) color: vec4<f32>,\n          // Matches the pass's object-id attachment clear value so the sky\n          // never registers as a pickable entity.\n          @location(1) objectIdEncoded: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragmentOutput {\n          // Per-pixel view ray from the camera basis. Used for orthographic\n          // cameras too \u2014 parallel rays would collapse the sky to a single\n          // colour, so a perspective-style fan reads better in both modes.\n          let dir = normalize(\n            sky.camForward\n            + input.ndc.x * sky.tanHalfFovX * sky.camRight\n            + input.ndc.y * sky.tanHalfFovY * sky.camUp\n          );\n          let elevation = dir.y;\n\n          // Horizon \u2192 zenith gradient with a slow falloff near the horizon.\n          let zenithMix = pow(clamp(elevation, 0.0, 1.0), 0.45);\n          var color = mix(sky.horizonColor, sky.zenithColor, zenithMix);\n\n          // Below the horizon: fade gradually into the ground colour. The\n          // falloff spans elevation -0.5..0 (rather than a near-instant\n          // -0.1..0) so the ordinary downward-pitched BIM camera sees a\n          // gradient from the horizon tone into the ground tone instead of\n          // an abrupt flat-colour wall a few degrees below the horizon\n          // (#5583); only a near-vertical look-down reaches pure groundColor.\n          // WGSL requires smoothstep's low < high, so express the\n          // downward ramp (0 at the horizon \u2192 1 at elevation -0.5) as the\n          // complement of an ascending smoothstep rather than passing\n          // reversed edges, which Tint rejects as a shader-compile error\n          // (low 0.0 not less than high -0.5) \u2014 that invalidated the whole\n          // sky pipeline and blanked the frame on strict drivers.\n          let groundMix = 1.0 - smoothstep(-0.5, 0.0, elevation);\n          color = mix(color, sky.groundColor, groundMix);\n\n          // Sun disc + glow. The disc is slightly oversized vs the real\n          // ~0.53\u00B0 sun so it stays visible at typical canvas resolutions.\n          let cosSun = dot(dir, sky.sunDirection);\n          let disc = smoothstep(0.99985, 0.99995, cosSun);\n          let glow = pow(max(cosSun, 0.0), 350.0) * 0.5\n                   + pow(max(cosSun, 0.0), 24.0) * 0.12;\n          // Hide the disc once the sun sets, and never draw it on the ground.\n          let sunVisible = smoothstep(-0.06, 0.02, sky.sunDirection.y) * (1.0 - groundMix);\n          let sunTint = vec3<f32>(1.0, 0.92, 0.78);\n          color += (disc * 6.0 + glow) * max(sky.sunIntensity, 0.0) * sunVisible * sunTint;\n\n          // Match the geometry pipeline: exposure \u2192 highlight roll-off \u2192 sRGB.\n          color *= sky.exposure;\n          color = linearToSrgb(clamp(neutralCompress(color), vec3<f32>(0.0), vec3<f32>(1.0)));\n\n          var out: FragmentOutput;\n          out.color = vec4<f32>(color, 1.0);\n          out.objectIdEncoded = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n          return out;\n        }\n      ";
 //# sourceMappingURL=sky.wgsl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sky.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/sky.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,swIAqGrB,CAAC"}
+{"version":3,"file":"sky.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/sky.wgsl.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,eAAe,m0KAiGrB,CAAC"}

package/dist/shaders/sky.wgsl.js

@@ -7,10 +7,12 @@
  * ground gradient plus a sun disc + glow, driven by the same sun direction
  * the geometry lighting uses.
  *
- * Tonemapping note: the geometry shader applies ACES + gamma at the end of
- * its fragment stage (not in a post pass), so the sky must apply the same
- * curve here or it would read as a different "film stock" than the model.
+ * Tonemapping note: the geometry shader applies its highlight roll-off and
+ * sRGB encode at the end of its fragment stage (not in a post pass), so the
+ * sky runs the same shared functions or it would read as a different "film
+ * stock" than the model. The gradient colours are linear radiance.
  */
+import { colorTransferWgsl } from './color-transfer.wgsl.js';
 export const skyShaderSource = `
         struct SkyUniforms {
           camRight: vec3<f32>,
@@ -48,15 +50,7 @@ export const skyShaderSource = `
           return out;
         }
 
-        // Same ACES filmic curve as the geometry fragment shader.
-        fn acesTonemap(c: vec3<f32>) -> vec3<f32> {
-          let a = 2.51;
-          let b = 0.03;
-          let cc = 2.43;
-          let d = 0.59;
-          let e = 0.14;
-          return clamp((c * (a * c + b)) / (c * (cc * c + d) + e), vec3<f32>(0.0), vec3<f32>(1.0));
-        }
+        ${colorTransferWgsl}
 
         struct FragmentOutput {
           @location(0) color: vec4<f32>,
@@ -81,14 +75,19 @@ export const skyShaderSource = `
           let zenithMix = pow(clamp(elevation, 0.0, 1.0), 0.45);
           var color = mix(sky.horizonColor, sky.zenithColor, zenithMix);
 
-          // Below the horizon: fade quickly into the ground colour.
+          // Below the horizon: fade gradually into the ground colour. The
+          // falloff spans elevation -0.5..0 (rather than a near-instant
+          // -0.1..0) so the ordinary downward-pitched BIM camera sees a
+          // gradient from the horizon tone into the ground tone instead of
+          // an abrupt flat-colour wall a few degrees below the horizon
+          // (#5583); only a near-vertical look-down reaches pure groundColor.
           // WGSL requires smoothstep's low < high, so express the
-          // downward ramp (0 at the horizon → 1 at elevation -0.1) as the
+          // downward ramp (0 at the horizon → 1 at elevation -0.5) as the
           // complement of an ascending smoothstep rather than passing
           // reversed edges, which Tint rejects as a shader-compile error
-          // (low 0.0 not less than high -0.1) — that invalidated the whole
+          // (low 0.0 not less than high -0.5) — that invalidated the whole
           // sky pipeline and blanked the frame on strict drivers.
-          let groundMix = 1.0 - smoothstep(-0.1, 0.0, elevation);
+          let groundMix = 1.0 - smoothstep(-0.5, 0.0, elevation);
           color = mix(color, sky.groundColor, groundMix);
 
           // Sun disc + glow. The disc is slightly oversized vs the real
@@ -102,10 +101,9 @@ export const skyShaderSource = `
           let sunTint = vec3<f32>(1.0, 0.92, 0.78);
           color += (disc * 6.0 + glow) * max(sky.sunIntensity, 0.0) * sunVisible * sunTint;
 
-          // Match the geometry pipeline: exposure → ACES → gamma.
+          // Match the geometry pipeline: exposure → highlight roll-off → sRGB.
           color *= sky.exposure;
-          color = acesTonemap(color);
-          color = pow(color, vec3<f32>(1.0 / 2.2));
+          color = linearToSrgb(clamp(neutralCompress(color), vec3<f32>(0.0), vec3<f32>(1.0)));
 
           var out: FragmentOutput;
           out.color = vec4<f32>(color, 1.0);

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

@@ -1 +1 @@
-{"version":3,"file":"sky.wgsl.js","sourceRoot":"","sources":["../../src/shaders/sky.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqGxB,CAAC"}
+{"version":3,"file":"sky.wgsl.js","sourceRoot":"","sources":["../../src/shaders/sky.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;GAUG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCrB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4DpB,CAAC"}

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