@ifc-lite/renderer 4.2.0 → 6.0.0

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

@@ -7,10 +7,15 @@
  * camera projection (see `depthReconstructParams`).
  */
 /**
- * Declares `depthTex` at `@group(0) @binding(binding)` and `loadDepth(ip)`,
+ * Declares `depthTex` at `@group(group) @binding(binding)` and `loadDepth(ip)`,
  * which clamps the coordinate to the texture and reads sample 0 when the
  * attachment is multisampled.
+ *
+ * `group` must match the index of the bind-group layout that carries the
+ * depth texture in the caller's pipeline layout. The full-screen passes (AO,
+ * edges) own group 0; the selection mask draws mesh geometry, so group 0 is
+ * the mesh uniform and the depth texture sits in group 1 (#5390).
  */
-export declare function depthTextureWgsl(binding: number, multisampled: boolean): string;
+export declare function depthTextureWgsl(binding: number, multisampled: boolean, group?: number): string;
 export declare const depthReconstructWgsl = "\n        // Reverse-Z clears to 0, so anything at or below this is background.\n        const BACKGROUND_DEPTH: f32 = 1e-7;\n\n        fn viewZFromDepth(d: f32, dp: vec4<f32>) -> f32 {\n          return (dp.z - d * dp.w) / (d * dp.y - dp.x);\n        }\n\n        fn clipWFromViewZ(z: f32, dp: vec4<f32>) -> f32 {\n          return dp.y * z + dp.w;\n        }\n\n        // Pixel centre to NDC (y up), for a buffer whose texel size is invDims.\n        fn ndcFromPixel(ip: vec2<i32>, invDims: vec2<f32>) -> vec2<f32> {\n          let uv = (vec2<f32>(ip) + 0.5) * invDims;\n          return vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n        }\n\n        fn viewPositionFromDepth(ndc: vec2<f32>, d: f32, dp: vec4<f32>, xy: vec4<f32>) -> vec3<f32> {\n          let z = viewZFromDepth(d, dp);\n          let w = clipWFromViewZ(z, dp);\n          return vec3<f32>((ndc.x * w - xy.z) / xy.x, (ndc.y * w - xy.w) / xy.y, z);\n        }\n\n        // Normal facing the camera, from a position and its four pixel\n        // neighbours. On each axis it takes the neighbour with the smaller\n        // depth step, so a pixel on a silhouette or a crease uses the side\n        // on its own surface instead of averaging across the edge.\n        fn normalFromNeighbours(\n          p: vec3<f32>, right: vec3<f32>, left: vec3<f32>, down: vec3<f32>, up: vec3<f32>,\n        ) -> vec3<f32> {\n          let dxR = right - p;\n          let dxL = p - left;\n          let dx = select(dxR, dxL, abs(dxL.z) < abs(dxR.z));\n          let dyD = down - p;\n          let dyU = p - up;\n          let dy = select(dyD, dyU, abs(dyU.z) < abs(dyD.z));\n          // Pixel +x is view +x and pixel +y is view -y, so dy x dx faces +z.\n          return normalize(cross(dy, dx));\n        }\n";
 //# sourceMappingURL=depth-reconstruct.wgsl.d.ts.map

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

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

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

@@ -10,14 +10,19 @@
  * camera projection (see `depthReconstructParams`).
  */
 /**
- * Declares `depthTex` at `@group(0) @binding(binding)` and `loadDepth(ip)`,
+ * Declares `depthTex` at `@group(group) @binding(binding)` and `loadDepth(ip)`,
  * which clamps the coordinate to the texture and reads sample 0 when the
  * attachment is multisampled.
+ *
+ * `group` must match the index of the bind-group layout that carries the
+ * depth texture in the caller's pipeline layout. The full-screen passes (AO,
+ * edges) own group 0; the selection mask draws mesh geometry, so group 0 is
+ * the mesh uniform and the depth texture sits in group 1 (#5390).
  */
-export function depthTextureWgsl(binding, multisampled) {
+export function depthTextureWgsl(binding, multisampled, group = 0) {
     const type = multisampled ? 'texture_depth_multisampled_2d' : 'texture_depth_2d';
     return `
-        @group(0) @binding(${binding}) var depthTex: ${type};
+        @group(${group}) @binding(${binding}) var depthTex: ${type};
 
         fn loadDepth(ip: vec2<i32>) -> f32 {
           let dims = vec2<i32>(textureDimensions(depthTex));

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

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

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

@@ -0,0 +1,20 @@
+export declare function edgeShaderSource(multisampled: boolean): string;
+/**
+ * Selection/hover outline composite (#5390): outlines the mask the
+ * selection-mask pass wrote (`selection-mask-pass.ts`), sharing this
+ * module's fullscreen-triangle vertex stage with the geometry edge pass
+ * above (DRY, per the #5385/#5390 design note) even though the two run as
+ * separate draws with different blend states (this one is a normal
+ * alpha-over composite; the geometry pass above is darken-only).
+ *
+ * Coverage is a ring around the mask boundary: the distance to the nearest
+ * mask pixel that differs from this one, searched within
+ * `OUTLINE_SEARCH_RADIUS`, mapped through `outlineCoverage`
+ * (`outline-params.ts`): full within `OUTLINE_WIDTH_PX` of the boundary on
+ * either side, fading over the next pixel. (Averaging 4 neighbour taps
+ * instead gives a straight edge only 1/4 coverage, a 1 px line too faint to
+ * see.) No depth/normal reconstruction needed: a mask boundary is
+ * unambiguous on its own.
+ */
+export declare function outlineFragmentSource(): string;
+//# sourceMappingURL=edges.wgsl.d.ts.map

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

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

package/dist/shaders/edges.wgsl.js

@@ -0,0 +1,257 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Edge pass (#5385): a single fullscreen pass that darkens along entity-id
+ * changes, normal creases, and depth silhouettes, replacing the separation-
+ * line pass in `post-processor.ts`.
+ *
+ * View-space position and normal come from `depth-reconstruct.wgsl.ts`
+ * (shared with the ambient-occlusion pass, #5384: one reconstruction, not
+ * two). The entity-id attachment is decoded the same way the old
+ * separation-line pass did (`encodeId24`/`decodeId24` in `main.wgsl.ts`).
+ *
+ * Each of `directions` tap offsets (4 cardinal at `low`, +4 diagonal at
+ * `high`) votes 0/1 on three cues — id change, normal crease, depth
+ * silhouette — and the pass darkens by the AVERAGE vote across directions.
+ * That average is a coverage estimate, not a single hard sample, so a line
+ * that only grazes one direction fades instead of dashing on/off between
+ * frames of the same seam (the bug this pass replaces, `post-processor.ts`
+ * introduced its own version of this coverage trick for the id test alone;
+ * this generalises it to all three cues and both new tests).
+ */
+import { EDGE_CREASE_COS, EDGE_MAX_DARKEN, EDGE_SILHOUETTE_REL_THRESHOLD } from '../edge-params.js';
+import { OUTLINE_SEARCH_RADIUS, OUTLINE_WIDTH_PX, SELECTION_HIDDEN_ALPHA } from '../outline-params.js';
+import { depthReconstructWgsl, depthTextureWgsl } from './depth-reconstruct.wgsl.js';
+export function edgeShaderSource(multisampled) {
+    // Multisampled and non-multisampled `textureLoad` share this call shape:
+    // the third argument is the sample index (MS) or the mip level (non-MS),
+    // both 0, so one call site covers both declarations (`post-processor.ts`
+    // used the same trick).
+    const idTexDecl = multisampled
+        ? '@group(0) @binding(1) var idTex: texture_multisampled_2d<f32>;'
+        : '@group(0) @binding(1) var idTex: texture_2d<f32>;';
+    return `
+        struct EdgeParams {
+          depthParams: vec4<f32>,  // m10, m11, m14, m15
+          xyParams: vec4<f32>,     // m0, m5, m12, m13
+          viewport: vec4<f32>,     // full-res width, height, 1/width, 1/height
+          edge: vec4<f32>,         // tap radius px, intensity, highQuality (0/1), _pad
+        }
+
+        ${depthTextureWgsl(0, multisampled)}
+        ${idTexDecl}
+        @group(0) @binding(2) var<uniform> params: EdgeParams;
+
+        ${depthReconstructWgsl}
+
+        const EDGE_CREASE_COS: f32 = ${EDGE_CREASE_COS.toFixed(6)};
+        const EDGE_SILHOUETTE_REL: f32 = ${EDGE_SILHOUETTE_REL_THRESHOLD.toFixed(6)};
+        const EDGE_MAX_DARKEN: f32 = ${EDGE_MAX_DARKEN.toFixed(3)};
+
+        struct VsOut {
+          @builtin(position) pos: vec4<f32>,
+        }
+
+        @vertex
+        fn vs_fullscreen(@builtin(vertex_index) v: u32) -> VsOut {
+          var p = array<vec2<f32>, 3>(
+            vec2<f32>(-1.0, -3.0),
+            vec2<f32>(-1.0,  1.0),
+            vec2<f32>( 3.0,  1.0)
+          );
+          var o: VsOut;
+          o.pos = vec4<f32>(p[v], 0.0, 1.0);
+          return o;
+        }
+
+        fn decodeId24(encoded: vec4<f32>) -> u32 {
+          let r = u32(round(encoded.r * 255.0)) & 255u;
+          let g = u32(round(encoded.g * 255.0)) & 255u;
+          let b = u32(round(encoded.b * 255.0)) & 255u;
+          return (r << 16u) | (g << 8u) | b;
+        }
+
+        fn loadId(ip: vec2<i32>, dims: vec2<i32>) -> u32 {
+          let c = clamp(ip, vec2<i32>(0), dims - 1);
+          return decodeId24(textureLoad(idTex, c, 0));
+        }
+
+        fn viewPosAt(ip: vec2<i32>, d: f32) -> vec3<f32> {
+          return viewPositionFromDepth(ndcFromPixel(ip, params.viewport.zw), d, params.depthParams, params.xyParams);
+        }
+
+        // One tap direction's edge vote in [0, 1]: 1 if the id changes, the
+        // local normal creases past the angle threshold, or the view-space
+        // depth steps past the silhouette threshold.
+        fn tapVote(p: vec2<i32>, q: vec2<i32>, dims: vec2<i32>, centerId: u32, centerP: vec3<f32>, centerN: vec3<f32>) -> f32 {
+          let qc = clamp(q, vec2<i32>(0), dims - 1);
+          let dq = loadDepth(qc);
+          if (dq <= BACKGROUND_DEPTH) {
+            return 0.0;
+          }
+          let neighbourId = loadId(qc, dims);
+          let idVote = f32(neighbourId != centerId && neighbourId != 0u && centerId != 0u);
+
+          let Pq = viewPosAt(qc, dq);
+          let depthRef = max(-centerP.z, 1e-4);
+          let silhouetteVote = f32(abs(Pq.z - centerP.z) / depthRef > EDGE_SILHOUETTE_REL);
+
+          // Neighbour normal from ITS OWN neighbours (not just the two
+          // points), so a grazing coplanar surface (large positional slope,
+          // near-zero normal change) does not misread as a crease.
+          let dLeft = loadDepth(clamp(qc + vec2<i32>(-1, 0), vec2<i32>(0), dims - 1));
+          let dRight = loadDepth(clamp(qc + vec2<i32>(1, 0), vec2<i32>(0), dims - 1));
+          let dUp = loadDepth(clamp(qc + vec2<i32>(0, -1), vec2<i32>(0), dims - 1));
+          let dDown = loadDepth(clamp(qc + vec2<i32>(0, 1), vec2<i32>(0), dims - 1));
+          let Nq = normalFromNeighbours(
+            Pq,
+            select(centerP, viewPosAt(qc + vec2<i32>(1, 0), dRight), dRight > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(-1, 0), dLeft), dLeft > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(0, 1), dDown), dDown > BACKGROUND_DEPTH),
+            select(centerP, viewPosAt(qc + vec2<i32>(0, -1), dUp), dUp > BACKGROUND_DEPTH),
+          );
+          let creaseVote = f32(dot(centerN, Nq) < EDGE_CREASE_COS);
+
+          return max(idVote, max(creaseVote, silhouetteVote));
+        }
+
+        @fragment
+        fn fs_edges(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          let dims = vec2<i32>(params.viewport.xy);
+          let p = vec2<i32>(fragPos.xy);
+          let d = loadDepth(p);
+          if (d <= BACKGROUND_DEPTH) {
+            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+          }
+          let centerId = loadId(p, dims);
+          let centerP = viewPosAt(p, d);
+          let centerN = normalFromNeighbours(
+            centerP,
+            viewPosAt(clamp(p + vec2<i32>(1, 0), vec2<i32>(0), dims - 1), loadDepth(p + vec2<i32>(1, 0))),
+            viewPosAt(clamp(p - vec2<i32>(1, 0), vec2<i32>(0), dims - 1), loadDepth(p - vec2<i32>(1, 0))),
+            viewPosAt(clamp(p + vec2<i32>(0, 1), vec2<i32>(0), dims - 1), loadDepth(p + vec2<i32>(0, 1))),
+            viewPosAt(clamp(p - vec2<i32>(0, 1), vec2<i32>(0), dims - 1), loadDepth(p - vec2<i32>(0, 1))),
+          );
+
+          let r = i32(round(params.edge.x));
+          var votes = 0.0;
+          votes = votes + tapVote(p, p + vec2<i32>( r,  0), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>(-r,  0), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>( 0,  r), dims, centerId, centerP, centerN);
+          votes = votes + tapVote(p, p + vec2<i32>( 0, -r), dims, centerId, centerP, centerN);
+          var directions = 4.0;
+
+          if (params.edge.z > 0.5) {
+            votes = votes + tapVote(p, p + vec2<i32>( r,  r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>(-r,  r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>( r, -r), dims, centerId, centerP, centerN);
+            votes = votes + tapVote(p, p + vec2<i32>(-r, -r), dims, centerId, centerP, centerN);
+            directions = 8.0;
+          }
+
+          let coverage = votes / directions;
+          let darken = clamp(coverage * params.edge.y, 0.0, EDGE_MAX_DARKEN);
+          return vec4<f32>(0.0, 0.0, 0.0, darken);
+        }
+`;
+}
+/**
+ * Selection/hover outline composite (#5390): outlines the mask the
+ * selection-mask pass wrote (`selection-mask-pass.ts`), sharing this
+ * module's fullscreen-triangle vertex stage with the geometry edge pass
+ * above (DRY, per the #5385/#5390 design note) even though the two run as
+ * separate draws with different blend states (this one is a normal
+ * alpha-over composite; the geometry pass above is darken-only).
+ *
+ * Coverage is a ring around the mask boundary: the distance to the nearest
+ * mask pixel that differs from this one, searched within
+ * `OUTLINE_SEARCH_RADIUS`, mapped through `outlineCoverage`
+ * (`outline-params.ts`): full within `OUTLINE_WIDTH_PX` of the boundary on
+ * either side, fading over the next pixel. (Averaging 4 neighbour taps
+ * instead gives a straight edge only 1/4 coverage, a 1 px line too faint to
+ * see.) No depth/normal reconstruction needed: a mask boundary is
+ * unambiguous on its own.
+ */
+export function outlineFragmentSource() {
+    return `
+        struct OutlineParams {
+          viewport: vec4<f32>,       // width, height, unused, unused
+          selectionColor: vec4<f32>, // rgb, visible alpha
+          hoverColor: vec4<f32>,     // rgb, visible alpha
+        }
+
+        @group(0) @binding(0) var maskVisible: texture_2d<f32>;
+        @group(0) @binding(1) var maskAll: texture_2d<f32>;
+        @group(0) @binding(2) var<uniform> params: OutlineParams;
+
+        const SELECTION_HIDDEN_ALPHA: f32 = ${SELECTION_HIDDEN_ALPHA.toFixed(3)};
+
+        struct VsOut {
+          @builtin(position) pos: vec4<f32>,
+        }
+
+        @vertex
+        fn vs_fullscreen(@builtin(vertex_index) v: u32) -> VsOut {
+          var p = array<vec2<f32>, 3>(
+            vec2<f32>(-1.0, -3.0),
+            vec2<f32>(-1.0,  1.0),
+            vec2<f32>( 3.0,  1.0)
+          );
+          var o: VsOut;
+          o.pos = vec4<f32>(p[v], 0.0, 1.0);
+          return o;
+        }
+
+        fn loadClamped(tex: texture_2d<f32>, ip: vec2<i32>, dims: vec2<i32>) -> vec4<f32> {
+          return textureLoad(tex, clamp(ip, vec2<i32>(0), dims - 1), 0);
+        }
+
+        const OUTLINE_SEARCH_RADIUS: i32 = ${OUTLINE_SEARCH_RADIUS};
+        const OUTLINE_WIDTH_PX: f32 = ${OUTLINE_WIDTH_PX.toFixed(3)};
+
+        // Ring coverage astride the mask boundary (outline-params.ts's
+        // outlineCoverage): distance to the nearest pixel whose channel
+        // differs from this one, full within OUTLINE_WIDTH_PX, 0 one pixel on.
+        fn boundaryCoverage(tex: texture_2d<f32>, channel: u32, p: vec2<i32>, dims: vec2<i32>) -> f32 {
+          let center = loadClamped(tex, p, dims)[channel] > 0.5;
+          var nearest = 1e4;
+          for (var dy = -OUTLINE_SEARCH_RADIUS; dy <= OUTLINE_SEARCH_RADIUS; dy = dy + 1) {
+            for (var dx = -OUTLINE_SEARCH_RADIUS; dx <= OUTLINE_SEARCH_RADIUS; dx = dx + 1) {
+              if ((loadClamped(tex, p + vec2<i32>(dx, dy), dims)[channel] > 0.5) != center) {
+                nearest = min(nearest, length(vec2<f32>(f32(dx), f32(dy))));
+              }
+            }
+          }
+          return clamp(OUTLINE_WIDTH_PX + 0.5 - nearest, 0.0, 1.0);
+        }
+
+        @fragment
+        fn fs_outline(@builtin(position) fragPos: vec4<f32>) -> @location(0) vec4<f32> {
+          let dims = vec2<i32>(params.viewport.xy);
+          let p = vec2<i32>(fragPos.xy);
+
+          let visibleCoverage = boundaryCoverage(maskVisible, 0u, p, dims);
+          let allCoverage = boundaryCoverage(maskAll, 0u, p, dims);
+          let hoverCoverage = boundaryCoverage(maskVisible, 1u, p, dims);
+
+          // The "hidden" ring is the silhouette of the unoccluded shape
+          // (maskAll) wherever this pixel is not itself part of the visible
+          // selection — so it does not double up with the solid ring.
+          let centerVisible = loadClamped(maskVisible, p, dims).r;
+          let hiddenCoverage = allCoverage * (1.0 - centerVisible);
+
+          let selectionAlpha = clamp(
+            max(visibleCoverage * params.selectionColor.a, hiddenCoverage * SELECTION_HIDDEN_ALPHA),
+            0.0, 1.0,
+          );
+          if (selectionAlpha > 0.001) {
+            return vec4<f32>(params.selectionColor.rgb * selectionAlpha, selectionAlpha);
+          }
+
+          let hoverAlpha = clamp(hoverCoverage * params.hoverColor.a, 0.0, 1.0);
+          return vec4<f32>(params.hoverColor.rgb * hoverAlpha, hoverAlpha);
+        }
+`;
+}
+//# sourceMappingURL=edges.wgsl.js.map

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

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

package/dist/shaders/entity-color-table.wgsl.d.ts

@@ -0,0 +1,2 @@
+export declare const entityColorTableWgsl = "\n        @binding(5) @group(1) var<storage, read> entityColorTable: array<u32>;\n        const ENTITY_COLOR_EMPTY: u32 = 4294967295u;\n        const ENTITY_COLOR_HEADER: u32 = 4u;\n        const OVERRIDE_PAINT: u32 = 1u;\n        const OVERRIDE_EMPHASIZE: u32 = 2u;\n\n        fn entityColorSlotHash(key: u32) -> u32 {\n          var h = key;\n          h = h ^ (h >> 16u);\n          h = h * 0x85ebca6bu;\n          h = h ^ (h >> 13u);\n          h = h * 0xc2b2ae35u;\n          h = h ^ (h >> 16u);\n          return h;\n        }\n\n        // Full scene id behind a 24-bit lane, given the draw's smallest id.\n        fn resolveLaneEntityId(anchor: u32, lane: u32) -> u32 {\n          return anchor + ((lane - anchor) & 0x00FFFFFFu);\n        }\n\n        // The override colour for this fragment's entity; alpha < 0 = none.\n        fn entityOverrideColor(lane: u32) -> vec4<f32> {\n          let none = vec4<f32>(0.0, 0.0, 0.0, -1.0);\n          if ((uniforms.overrideParams.y & OVERRIDE_PAINT) == 0u || entityColorTable[2] == 0u) {\n            return none;\n          }\n          let capacity = entityColorTable[0];\n          let maxProbe = entityColorTable[1];\n          let colorBase = entityColorTable[3];\n          let id = resolveLaneEntityId(uniforms.overrideParams.x, lane);\n          let mask = capacity - 1u;\n          var slot = entityColorSlotHash(id) & mask;\n          for (var i = 0u; i <= maxProbe && i < capacity; i = i + 1u) {\n            let key = entityColorTable[ENTITY_COLOR_HEADER + slot];\n            if (key == id) {\n              let c = colorBase + slot * 4u;\n              return vec4<f32>(\n                bitcast<f32>(entityColorTable[c]),\n                bitcast<f32>(entityColorTable[c + 1u]),\n                bitcast<f32>(entityColorTable[c + 2u]),\n                bitcast<f32>(entityColorTable[c + 3u])\n              );\n            }\n            if (key == ENTITY_COLOR_EMPTY) {\n              break;\n            }\n            slot = (slot + 1u) & mask;\n          }\n          return none;\n        }\n\n        // Composite an override over the fragment's own encoded colour exactly\n        // as the retired equal-depth overlay pass blended it (src-alpha over\n        // the base draw): the override albedo lit by the same irradiance, no\n        // specular, the same roll-off and edge darkening, mixed by its alpha.\n        // Emphasized overrides are unlit, faintly faceted and opaque (#1277).\n        fn paintEntityOverride(base: vec4<f32>, ov: vec4<f32>, irradiance: vec3<f32>, N: vec3<f32>) -> vec4<f32> {\n          let albedo = srgbToLinear(ov.rgb);\n          var lit = albedo * irradiance;\n          var a = ov.a;\n          if ((uniforms.overrideParams.y & OVERRIDE_EMPHASIZE) != 0u) {\n            lit = albedo * (0.85 + 0.15 * abs(dot(N, normalize(vec3<f32>(0.3, 1.0, 0.2)))));\n            a = 1.0;\n          }\n          let encoded = linearToSrgb(clamp(neutralCompress(lit), vec3<f32>(0.0), vec3<f32>(1.0)));\n          return vec4<f32>(mix(base.rgb, encoded, a), a + (1.0 - a) * base.a);\n        }\n";
+//# sourceMappingURL=entity-color-table.wgsl.d.ts.map

package/dist/shaders/entity-color-table.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-color-table.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/entity-color-table.wgsl.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,oBAAoB,mhGAqEhC,CAAC"}

package/dist/shaders/entity-color-table.wgsl.js

@@ -0,0 +1,85 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * WGSL half of the per-entity colour table (#6076; layout, anchor rule and
+ * memory bound in `entity-color-table.ts`, whose `lookupEntityColor` and
+ * `resolveLaneEntityId` are the CPU mirrors of the functions below).
+ *
+ * Inlined into main.wgsl.ts after the Uniforms struct and the colour-transfer
+ * helpers, so it reads `uniforms.overrideParams` and reuses `srgbToLinear`,
+ * `neutralCompress` and `linearToSrgb`. The table sits at group(1) binding 5,
+ * beside the lighting environment, because it is scene-global.
+ */
+import { ENTITY_COLOR_EMPTY_KEY, ENTITY_COLOR_HEADER_WORDS, OVERRIDE_PARAM_EMPHASIZE, OVERRIDE_PARAM_PAINT } from '../entity-color-table.js';
+export const entityColorTableWgsl = `
+        @binding(5) @group(1) var<storage, read> entityColorTable: array<u32>;
+        const ENTITY_COLOR_EMPTY: u32 = ${ENTITY_COLOR_EMPTY_KEY}u;
+        const ENTITY_COLOR_HEADER: u32 = ${ENTITY_COLOR_HEADER_WORDS}u;
+        const OVERRIDE_PAINT: u32 = ${OVERRIDE_PARAM_PAINT}u;
+        const OVERRIDE_EMPHASIZE: u32 = ${OVERRIDE_PARAM_EMPHASIZE}u;
+
+        fn entityColorSlotHash(key: u32) -> u32 {
+          var h = key;
+          h = h ^ (h >> 16u);
+          h = h * 0x85ebca6bu;
+          h = h ^ (h >> 13u);
+          h = h * 0xc2b2ae35u;
+          h = h ^ (h >> 16u);
+          return h;
+        }
+
+        // Full scene id behind a 24-bit lane, given the draw's smallest id.
+        fn resolveLaneEntityId(anchor: u32, lane: u32) -> u32 {
+          return anchor + ((lane - anchor) & 0x00FFFFFFu);
+        }
+
+        // The override colour for this fragment's entity; alpha < 0 = none.
+        fn entityOverrideColor(lane: u32) -> vec4<f32> {
+          let none = vec4<f32>(0.0, 0.0, 0.0, -1.0);
+          if ((uniforms.overrideParams.y & OVERRIDE_PAINT) == 0u || entityColorTable[2] == 0u) {
+            return none;
+          }
+          let capacity = entityColorTable[0];
+          let maxProbe = entityColorTable[1];
+          let colorBase = entityColorTable[3];
+          let id = resolveLaneEntityId(uniforms.overrideParams.x, lane);
+          let mask = capacity - 1u;
+          var slot = entityColorSlotHash(id) & mask;
+          for (var i = 0u; i <= maxProbe && i < capacity; i = i + 1u) {
+            let key = entityColorTable[ENTITY_COLOR_HEADER + slot];
+            if (key == id) {
+              let c = colorBase + slot * 4u;
+              return vec4<f32>(
+                bitcast<f32>(entityColorTable[c]),
+                bitcast<f32>(entityColorTable[c + 1u]),
+                bitcast<f32>(entityColorTable[c + 2u]),
+                bitcast<f32>(entityColorTable[c + 3u])
+              );
+            }
+            if (key == ENTITY_COLOR_EMPTY) {
+              break;
+            }
+            slot = (slot + 1u) & mask;
+          }
+          return none;
+        }
+
+        // Composite an override over the fragment's own encoded colour exactly
+        // as the retired equal-depth overlay pass blended it (src-alpha over
+        // the base draw): the override albedo lit by the same irradiance, no
+        // specular, the same roll-off and edge darkening, mixed by its alpha.
+        // Emphasized overrides are unlit, faintly faceted and opaque (#1277).
+        fn paintEntityOverride(base: vec4<f32>, ov: vec4<f32>, irradiance: vec3<f32>, N: vec3<f32>) -> vec4<f32> {
+          let albedo = srgbToLinear(ov.rgb);
+          var lit = albedo * irradiance;
+          var a = ov.a;
+          if ((uniforms.overrideParams.y & OVERRIDE_EMPHASIZE) != 0u) {
+            lit = albedo * (0.85 + 0.15 * abs(dot(N, normalize(vec3<f32>(0.3, 1.0, 0.2)))));
+            a = 1.0;
+          }
+          let encoded = linearToSrgb(clamp(neutralCompress(lit), vec3<f32>(0.0), vec3<f32>(1.0)));
+          return vec4<f32>(mix(base.rgb, encoded, a), a + (1.0 - a) * base.a);
+        }
+`;
+//# sourceMappingURL=entity-color-table.wgsl.js.map

package/dist/shaders/entity-color-table.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-color-table.wgsl.js","sourceRoot":"","sources":["../../src/shaders/entity-color-table.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;GASG;AACH,OAAO,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAE7I,MAAM,CAAC,MAAM,oBAAoB,GAAG;;0CAEM,sBAAsB;2CACrB,yBAAyB;sCAC9B,oBAAoB;0CAChB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEjE,CAAC"}