@ifc-lite/renderer 1.16.0 → 1.18.0

package/dist/pointcloud/point-shader.wgsl.js

@@ -0,0 +1,212 @@
+/* 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 for the point cloud splat pipeline.
+ *
+ * Draws each point as an instanced quad (6 verts per point, triangle-list
+ * topology) so we can give it a real on-screen size — `point-list` has
+ * no `gl_PointSize` equivalent in WebGPU, which is why a 1-px point cloud
+ * looks like a halftone screen as you zoom in.
+ *
+ * Three size modes (uniforms.sizing.x):
+ *   0 = fixed-px         — every point renders at `pointSizePx` pixels
+ *   1 = adaptive-world   — splat covers `worldRadius` metres, projected
+ *   2 = attenuated       — adaptive but clamped to [1, pointSizePx] px
+ *
+ * Color modes (uniforms.colorModeAndExtras.x):
+ *   0 = per-vertex RGB,  1 = classification,  2 = intensity ramp,
+ *   3 = height ramp,     4 = fixed override.
+ *
+ * Round shape: fragment discards corners outside the unit disc, so
+ * splats render as circles (not squares) at any size > ~3 px.
+ */
+export const pointShaderSource = `
+    struct PointUniforms {
+      viewProj: mat4x4<f32>,
+      model: mat4x4<f32>,
+      colorOverride: vec4<f32>,
+      // x = colorMode, y = pointSizePx, z = heightMin, w = heightMax
+      colorModeAndExtras: vec4<f32>,
+      // x = sizeMode, y = worldRadius (m), z = viewportWidth, w = viewportHeight
+      sizing: vec4<f32>,
+      sectionPlane: vec4<f32>,
+      // x = assetExpressId (federation-aware globalId), y = sectionEnabled,
+      // z = roundShape, w = unused
+      flags: vec4<u32>,
+    }
+    @binding(0) @group(0) var<uniform> uniforms: PointUniforms;
+
+    struct VertexInput {
+      @location(0) position: vec3<f32>,
+      @location(1) rgbAndClass: vec4<f32>,   // unorm8x4 → 0..1 each
+      @location(2) intensityPacked: u32,     // low 16 bits = intensity
+      @location(3) entityId: u32,
+    }
+
+    struct VertexOutput {
+      @builtin(position) position: vec4<f32>,
+      @location(0) color: vec4<f32>,
+      @location(1) worldPos: vec3<f32>,
+      @location(2) @interpolate(flat) entityId: u32,
+      @location(3) quadUv: vec2<f32>,
+    }
+
+    fn classification_color(class_id: u32) -> vec3<f32> {
+      switch (class_id) {
+        case 0u, 1u: { return vec3<f32>(0.65, 0.65, 0.65); }
+        case 2u:     { return vec3<f32>(0.55, 0.40, 0.25); }
+        case 3u:     { return vec3<f32>(0.55, 0.85, 0.45); }
+        case 4u:     { return vec3<f32>(0.30, 0.75, 0.30); }
+        case 5u:     { return vec3<f32>(0.10, 0.45, 0.15); }
+        case 6u:     { return vec3<f32>(0.95, 0.55, 0.20); }
+        case 7u:     { return vec3<f32>(0.95, 0.20, 0.20); }
+        case 8u:     { return vec3<f32>(0.20, 0.85, 0.95); }
+        case 9u:     { return vec3<f32>(0.20, 0.40, 0.95); }
+        case 10u:    { return vec3<f32>(0.55, 0.20, 0.85); }
+        case 11u:    { return vec3<f32>(0.30, 0.30, 0.30); }
+        case 13u:    { return vec3<f32>(0.95, 0.85, 0.20); }
+        case 14u:    { return vec3<f32>(0.95, 0.95, 0.50); }
+        case 15u:    { return vec3<f32>(0.20, 0.20, 0.55); }
+        case 16u:    { return vec3<f32>(0.30, 0.65, 0.65); }
+        case 17u:    { return vec3<f32>(0.85, 0.70, 0.50); }
+        case 18u:    { return vec3<f32>(0.95, 0.20, 0.20); }
+        default:     { return vec3<f32>(0.65, 0.65, 0.65); }
+      }
+    }
+
+    fn height_ramp(t: f32) -> vec3<f32> {
+      let s = clamp(t, 0.0, 1.0);
+      if (s < 0.25) {
+        let k = s / 0.25;
+        return mix(vec3<f32>(0.10, 0.20, 0.85), vec3<f32>(0.10, 0.85, 0.85), k);
+      } else if (s < 0.5) {
+        let k = (s - 0.25) / 0.25;
+        return mix(vec3<f32>(0.10, 0.85, 0.85), vec3<f32>(0.20, 0.85, 0.20), k);
+      } else if (s < 0.75) {
+        let k = (s - 0.5) / 0.25;
+        return mix(vec3<f32>(0.20, 0.85, 0.20), vec3<f32>(0.95, 0.95, 0.20), k);
+      } else {
+        let k = (s - 0.75) / 0.25;
+        return mix(vec3<f32>(0.95, 0.95, 0.20), vec3<f32>(0.95, 0.20, 0.10), k);
+      }
+    }
+
+    @vertex
+    fn vs_main(input: VertexInput, @builtin(vertex_index) vId: u32) -> VertexOutput {
+      // Quad corners (two triangles, CCW) in unit disc coords:
+      //   tri 1: (-1,-1)(1,-1)(1,1)
+      //   tri 2: (-1,-1)(1, 1)(-1,1)
+      var corners = array<vec2<f32>, 6>(
+        vec2<f32>(-1.0, -1.0),
+        vec2<f32>( 1.0, -1.0),
+        vec2<f32>( 1.0,  1.0),
+        vec2<f32>(-1.0, -1.0),
+        vec2<f32>( 1.0,  1.0),
+        vec2<f32>(-1.0,  1.0),
+      );
+      let corner = corners[vId];
+
+      let worldPos4 = uniforms.model * vec4<f32>(input.position, 1.0);
+      var clipPos = uniforms.viewProj * worldPos4;
+
+      // Compute splat half-extent in pixels for the active size mode.
+      let sizeMode = u32(uniforms.sizing.x);
+      let worldRadius = uniforms.sizing.y;
+      let viewport = uniforms.sizing.zw;
+      let pointSizePx = uniforms.colorModeAndExtras.y;
+
+      // halfPx is the splat RADIUS in pixels. The user-facing
+      // pointSizePx is the diameter ("8 px point"), so divide by 2
+      // when feeding it to the pipeline. Without this the fixed and
+      // attenuated branches render splats at ~2x their requested size.
+      var halfPx: f32;
+      if (sizeMode == 0u) {
+        halfPx = max(0.5, pointSizePx * 0.5);
+      } else {
+        // Project a world-radius offset to clip space, take pixel delta.
+        // worldRadius is already a radius — no /2 needed here.
+        let edgePos = uniforms.viewProj * (worldPos4 + vec4<f32>(worldRadius, 0.0, 0.0, 0.0));
+        let centerNdcX = clipPos.x / max(abs(clipPos.w), 1e-6);
+        let edgeNdcX = edgePos.x / max(abs(edgePos.w), 1e-6);
+        let projectedPx = abs(edgeNdcX - centerNdcX) * 0.5 * viewport.x;
+        if (sizeMode == 2u) {
+          halfPx = clamp(projectedPx, 0.5, max(0.5, pointSizePx * 0.5));
+        } else {
+          halfPx = max(0.5, projectedPx);
+        }
+      }
+
+      // Convert pixel offset to clip-space offset. Multiply by clipPos.w
+      // because the GPU divides by w during the perspective divide.
+      let halfClip = vec2<f32>(halfPx) / max(viewport, vec2<f32>(1.0)) * 2.0 * abs(clipPos.w);
+      clipPos.x = clipPos.x + corner.x * halfClip.x;
+      clipPos.y = clipPos.y + corner.y * halfClip.y;
+
+      // Color selection
+      let mode = u32(uniforms.colorModeAndExtras.x);
+      let intensity01 = f32(input.intensityPacked & 0xffffu) / 65535.0;
+      let classId = u32(round(input.rgbAndClass.a * 255.0));
+      let heightT =
+        (worldPos4.y - uniforms.colorModeAndExtras.z) /
+        max(1e-6, uniforms.colorModeAndExtras.w - uniforms.colorModeAndExtras.z);
+
+      var rgb: vec3<f32>;
+      switch (mode) {
+        case 0u: { rgb = input.rgbAndClass.rgb; }
+        case 1u: { rgb = classification_color(classId); }
+        case 2u: { rgb = vec3<f32>(intensity01, intensity01, intensity01); }
+        case 3u: { rgb = height_ramp(heightT); }
+        case 4u: { rgb = uniforms.colorOverride.rgb; }
+        default: { rgb = input.rgbAndClass.rgb; }
+      }
+
+      var output: VertexOutput;
+      output.position = clipPos;
+      output.color = vec4<f32>(rgb, 1.0);
+      output.worldPos = worldPos4.xyz;
+      output.entityId = input.entityId;
+      output.quadUv = corner;
+      return output;
+    }
+
+    struct FragmentOutput {
+      @location(0) color: vec4<f32>,
+      @location(1) objectId: vec4<f32>,
+    }
+
+    @fragment
+    fn fs_main(input: VertexOutput) -> FragmentOutput {
+      // Round shape — discard corners outside the unit disc.
+      if (uniforms.flags.z == 1u) {
+        if (dot(input.quadUv, input.quadUv) > 1.0) {
+          discard;
+        }
+      }
+
+      // Section-plane clipping
+      if (uniforms.flags.y == 1u) {
+        let d = dot(uniforms.sectionPlane.xyz, input.worldPos) - uniforms.sectionPlane.w;
+        if (d > 0.0) {
+          discard;
+        }
+      }
+
+      var output: FragmentOutput;
+      output.color = input.color;
+      // Prefer the asset-level expressId from the uniform when it's set
+      // (federation needs to relabel post-stream, so we can't rely on
+      // the per-vertex attribute that was baked at upload time).
+      // flags.x == 0 → fall back to per-vertex value to preserve the
+      // legacy contract during the upload-only rendering window.
+      let id = select(input.entityId, uniforms.flags.x, uniforms.flags.x != 0u);
+      output.objectId = vec4<f32>(
+        f32((id >> 0u) & 0xffu) / 255.0,
+        f32((id >> 8u) & 0xffu) / 255.0,
+        f32((id >> 16u) & 0xffu) / 255.0,
+        f32((id >> 24u) & 0xffu) / 255.0,
+      );
+      return output;
+    }
+`;
+//# sourceMappingURL=point-shader.wgsl.js.map

package/dist/pointcloud/point-shader.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"point-shader.wgsl.js","sourceRoot":"","sources":["../../src/pointcloud/point-shader.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2LhC,CAAC"}

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

@@ -3,5 +3,5 @@
  * Features: PBR lighting, section plane clipping, selection highlight,
  * glass fresnel, ACES tone mapping, screen-space edge enhancement.
  */
-export declare const mainShaderSource = "\n        struct Uniforms {\n          viewProj: mat4x4<f32>,\n          model: mat4x4<f32>,\n          baseColor: vec4<f32>,\n          metallicRoughness: vec2<f32>, // x = metallic, y = roughness\n          _padding1: vec2<f32>,\n          sectionPlane: vec4<f32>,      // xyz = plane normal, w = plane distance\n          flags: vec4<u32>,             // x = isSelected, y = sectionEnabled, z = edgeEnabled, w = edgeIntensityMilli\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n          @location(1) normal: vec3<f32>,\n          @location(2) entityId: u32,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n          @location(1) normal: vec3<f32>,\n          @location(2) @interpolate(flat) entityId: u32,\n          @location(3) viewPos: vec3<f32>,  // For edge detection\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> VertexOutput {\n          var output: VertexOutput;\n          let worldPos = uniforms.model * vec4<f32>(input.position, 1.0);\n          output.position = uniforms.viewProj * worldPos;\n          // Anti z-fighting: deterministic depth nudge per entity.\n          // Knuth multiplicative hash spreads sequential IDs across 0-255\n          // so coplanar faces from different entities always get distinct depths.\n          // At 1e-6 per step the max world-space offset is <3mm at 10m \u2014 invisible.\n          let zHash = (input.entityId * 2654435761u) & 255u;\n          output.position.z *= 1.0 + f32(zHash) * 1e-6;\n          output.worldPos = worldPos.xyz;\n          output.normal = normalize((uniforms.model * vec4<f32>(input.normal, 0.0)).xyz);\n          output.entityId = input.entityId;\n          // Store view-space position for edge detection\n          output.viewPos = (uniforms.viewProj * worldPos).xyz;\n          return output;\n        }\n\n        // PBR helper functions\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 num = a2;\n          let denomBase = (NdotH2 * (a2 - 1.0) + 1.0);\n          let denom = 3.14159265 * denomBase * denomBase;\n          return num / max(denom, 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          let num = NdotV;\n          let denom = NdotV * (1.0 - k) + k;\n          return num / max(denom, 0.0000001);\n        }\n\n        fn geometrySmith(NdotV: f32, NdotL: f32, roughness: f32) -> f32 {\n          let ggx2 = geometrySchlickGGX(NdotV, roughness);\n          let ggx1 = geometrySchlickGGX(NdotL, roughness);\n          return ggx1 * ggx2;\n        }\n\n        fn encodeId24(id: u32) -> vec4<f32> {\n          let r = f32((id >> 16u) & 255u) / 255.0;\n          let g = f32((id >> 8u) & 255u) / 255.0;\n          let b = f32(id & 255u) / 255.0;\n          return vec4<f32>(r, g, b, 1.0);\n        }\n\n        struct FragmentOutput {\n          @location(0) color: vec4<f32>,\n          @location(1) objectIdEncoded: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragmentOutput {\n          // Section plane clipping - discard fragments ABOVE the plane.\n          // flags.y packs two bits: bit 0 = enabled, bit 1 = flipped.\n          let sectionEnabled = (uniforms.flags.y & 1u) == 1u;\n          if (sectionEnabled) {\n            let planeNormal = uniforms.sectionPlane.xyz;\n            let planeDistance = uniforms.sectionPlane.w;\n            let flipped = (uniforms.flags.y & 2u) == 2u;\n            let side = select(1.0, -1.0, flipped);\n            let distToPlane = (dot(input.worldPos, planeNormal) - planeDistance) * side;\n            if (distToPlane > 0.0) {\n              discard;\n            }\n          }\n\n          // Compute normal \u2014 with fallback for zero normals\n          // dpdx/dpdy must be called outside non-uniform control flow (WGSL spec),\n          // so we compute the flat normal unconditionally and select below.\n          let faceN = cross(dpdx(input.worldPos), dpdy(input.worldPos));\n          var N = input.normal;\n          let nLen2 = dot(N, N);\n          if (nLen2 < 0.0001) {\n            // Fallback: use flat normal from screen-space derivatives\n            let fLen2 = dot(faceN, faceN);\n            N = select(vec3<f32>(0.0, 1.0, 0.0), faceN * inverseSqrt(fLen2), fLen2 > 1e-10);\n          } else {\n            N = N * inverseSqrt(nLen2);\n          }\n\n          // Enhanced lighting with multiple sources\n          let sunLight = normalize(vec3<f32>(0.5, 1.0, 0.3));  // Main directional light\n          let fillLight = normalize(vec3<f32>(-0.5, 0.3, -0.3));  // Fill light\n          let rimLight = normalize(vec3<f32>(0.0, 0.2, -1.0));  // Rim light for edge definition\n\n          // Hemisphere ambient - reduced for less washed-out look\n          let skyColor = vec3<f32>(0.3, 0.35, 0.4);  // Darker sky\n          let groundColor = vec3<f32>(0.15, 0.1, 0.08);  // Darker ground\n          let hemisphereFactor = N.y * 0.5 + 0.5;\n          let ambient = mix(groundColor, skyColor, hemisphereFactor) * 0.25;\n\n          // Two-sided sun light so inner faces (I-beam channels) stay visible\n          let NdotL = abs(dot(N, sunLight));\n          let wrap = 0.3;\n          let diffuseSun = max((NdotL + wrap) / (1.0 + wrap), 0.0) * 0.55;\n\n          // Fill light - two-sided\n          let NdotFill = abs(dot(N, fillLight));\n          let diffuseFill = NdotFill * 0.15;\n\n          // Rim light for edge definition\n          let NdotRim = max(dot(N, rimLight), 0.0);\n          let rim = pow(NdotRim, 4.0) * 0.15;\n\n          var baseColor = uniforms.baseColor.rgb;\n\n          // Detect if the color is close to white/gray (low saturation)\n          let baseGray = dot(baseColor, vec3<f32>(0.299, 0.587, 0.114));\n          let baseSaturation = length(baseColor - vec3<f32>(baseGray)) / max(baseGray, 0.001);\n          let isWhiteish = 1.0 - smoothstep(0.0, 0.3, baseSaturation);\n\n          // Darken whites/grays more to reduce washed-out appearance\n          baseColor = mix(baseColor, baseColor * 0.7, isWhiteish * 0.4);\n\n          // Combine all lighting\n          var color = baseColor * (ambient + diffuseSun + diffuseFill + rim);\n\n          // Selection highlight - add glow/fresnel effect\n          if (uniforms.flags.x == 1u) {\n            let V = normalize(-input.worldPos);\n            let NdotV = max(dot(N, V), 0.0);\n            let fresnel = pow(1.0 - NdotV, 2.0);\n            let highlightColor = vec3<f32>(0.3, 0.6, 1.0);\n            color = mix(color, highlightColor, fresnel * 0.5 + 0.2);\n          }\n\n          // Beautiful fresnel effect for transparent materials (glass)\n          // Skip when selected \u2014 the glass shine and desaturation wash out the\n          // blue highlight, making it appear white instead of blue.\n          // Also force alpha to 1.0 for selected objects so the highlight is\n          // fully opaque (the selection pipeline has no alpha blending).\n          var finalAlpha = select(uniforms.baseColor.a, 1.0, uniforms.flags.x == 1u);\n          if (finalAlpha < 0.99 && uniforms.flags.x != 1u) {\n            // Calculate view direction for fresnel\n            let V = normalize(-input.worldPos);\n            let NdotV = max(dot(N, V), 0.0);\n\n            // Enhanced fresnel effect - stronger at edges (grazing angles)\n            // Using Schlick's approximation for realistic glass reflection\n            let fresnelPower = 1.5; // Higher = softer edge reflections\n            let fresnel = pow(1.0 - NdotV, fresnelPower);\n\n            // Glass reflection tint (sky/environment reflection at edges)\n            let reflectionTint = vec3<f32>(0.92, 0.96, 1.0);  // Cool sky reflection\n            let reflectionStrength = fresnel * 0.6;  // Strong edge reflections\n\n            // Mix in reflection tint at edges\n            color = mix(color, color * reflectionTint, reflectionStrength);\n\n            // Add realistic glass shine - brighter at edges where light reflects\n            let glassShine = fresnel * 0.12;\n            color += glassShine;\n\n            // Slight desaturation at edges (glass reflects environment, not just color)\n            let edgeDesaturation = fresnel * 0.25;\n            let gray = dot(color, vec3<f32>(0.299, 0.587, 0.114));\n            color = mix(color, vec3<f32>(gray), edgeDesaturation);\n\n            // Make glass more transparent (reduce opacity by 30%)\n            finalAlpha = finalAlpha * 0.7;\n          }\n\n          // Exposure adjustment - darken overall\n          color *= 0.85;\n\n          // Contrast enhancement\n          color = (color - 0.5) * 1.15 + 0.5;\n          color = max(color, vec3<f32>(0.0));\n\n          // Saturation boost - stronger for colored surfaces, less for whites\n          let gray = dot(color, vec3<f32>(0.299, 0.587, 0.114));\n          let satBoost = mix(1.4, 1.1, isWhiteish);  // More saturation for colored surfaces\n          color = mix(vec3<f32>(gray), color, satBoost);\n\n          // ACES filmic tone mapping\n          let a = 2.51;\n          let b = 0.03;\n          let c = 2.43;\n          let d = 0.59;\n          let e = 0.14;\n          color = clamp((color * (a * color + b)) / (color * (c * color + d) + e), vec3<f32>(0.0), vec3<f32>(1.0));\n\n          // Subtle edge enhancement using screen-space derivatives\n          let depthGradient = length(vec2<f32>(\n            dpdx(input.viewPos.z),\n            dpdy(input.viewPos.z)\n          ));\n          let normalGradient = length(vec2<f32>(\n            length(dpdx(input.normal)),\n            length(dpdy(input.normal))\n          ));\n\n          if (uniforms.flags.z == 1u) {\n            // Threshold filters subtle normal discontinuities at internal\n            // triangle edges between coplanar entities in the same batch.\n            let edgeFactor = smoothstep(0.02, 0.12, depthGradient * 10.0 + normalGradient * 5.0);\n            let edgeIntensity = f32(uniforms.flags.w) / 1000.0;\n            let edgeDarkenStrength = clamp(0.25 * edgeIntensity, 0.0, 0.85);\n            let edgeDarken = mix(1.0, 1.0 - edgeDarkenStrength, edgeFactor);\n            color *= edgeDarken;\n          }\n\n          // Gamma correction\n          color = pow(color, vec3<f32>(1.0 / 2.2));\n\n          var out: FragmentOutput;\n          out.color = vec4<f32>(color, finalAlpha);\n          out.objectIdEncoded = encodeId24(input.entityId);\n          return out;\n        }\n      ";
+export declare const mainShaderSource = "\n        struct Uniforms {\n          viewProj: mat4x4<f32>,\n          model: mat4x4<f32>,\n          baseColor: vec4<f32>,\n          metallicRoughness: vec2<f32>, // x = metallic, y = roughness\n          _padding1: vec2<f32>,\n          sectionPlane: vec4<f32>,      // xyz = plane normal, w = plane distance\n          flags: vec4<u32>,             // x = isSelected, y = sectionEnabled, z = edgeEnabled, w = edgeIntensityMilli\n        }\n        @binding(0) @group(0) var<uniform> uniforms: Uniforms;\n\n        struct VertexInput {\n          @location(0) position: vec3<f32>,\n          @location(1) normal: vec3<f32>,\n          @location(2) entityId: u32,\n        }\n\n        struct VertexOutput {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n          @location(1) normal: vec3<f32>,\n          @location(2) @interpolate(flat) entityId: u32,\n          @location(3) viewPos: vec3<f32>,  // For edge detection\n        }\n\n        @vertex\n        fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> VertexOutput {\n          var output: VertexOutput;\n          let worldPos = uniforms.model * vec4<f32>(input.position, 1.0);\n          output.position = uniforms.viewProj * worldPos;\n          // Anti z-fighting: deterministic depth nudge per entity.\n          // Knuth multiplicative hash spreads sequential IDs across 0-255\n          // so coplanar faces from different entities always get distinct depths.\n          // At 1e-6 per step the max world-space offset is <3mm at 10m \u2014 invisible.\n          let zHash = (input.entityId * 2654435761u) & 255u;\n          output.position.z *= 1.0 + f32(zHash) * 1e-6;\n          output.worldPos = worldPos.xyz;\n          output.normal = normalize((uniforms.model * vec4<f32>(input.normal, 0.0)).xyz);\n          output.entityId = input.entityId;\n          // Store view-space position for edge detection\n          output.viewPos = (uniforms.viewProj * worldPos).xyz;\n          return output;\n        }\n\n        // PBR helper functions\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 num = a2;\n          let denomBase = (NdotH2 * (a2 - 1.0) + 1.0);\n          let denom = 3.14159265 * denomBase * denomBase;\n          return num / max(denom, 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          let num = NdotV;\n          let denom = NdotV * (1.0 - k) + k;\n          return num / max(denom, 0.0000001);\n        }\n\n        fn geometrySmith(NdotV: f32, NdotL: f32, roughness: f32) -> f32 {\n          let ggx2 = geometrySchlickGGX(NdotV, roughness);\n          let ggx1 = geometrySchlickGGX(NdotL, roughness);\n          return ggx1 * ggx2;\n        }\n\n        fn encodeId24(id: u32) -> vec4<f32> {\n          let r = f32((id >> 16u) & 255u) / 255.0;\n          let g = f32((id >> 8u) & 255u) / 255.0;\n          let b = f32(id & 255u) / 255.0;\n          return vec4<f32>(r, g, b, 1.0);\n        }\n\n        struct FragmentOutput {\n          @location(0) color: vec4<f32>,\n          @location(1) objectIdEncoded: vec4<f32>,\n        }\n\n        @fragment\n        fn fs_main(input: VertexOutput) -> FragmentOutput {\n          // Section plane clipping - discard fragments ABOVE the plane.\n          // flags.y packs two bits: bit 0 = enabled, bit 1 = flipped.\n          let sectionEnabled = (uniforms.flags.y & 1u) == 1u;\n          if (sectionEnabled) {\n            let planeNormal = uniforms.sectionPlane.xyz;\n            let planeDistance = uniforms.sectionPlane.w;\n            let flipped = (uniforms.flags.y & 2u) == 2u;\n            let side = select(1.0, -1.0, flipped);\n            let distToPlane = (dot(input.worldPos, planeNormal) - planeDistance) * side;\n            if (distToPlane > 0.0) {\n              discard;\n            }\n          }\n\n          // Compute normal \u2014 with fallback for zero normals\n          // dpdx/dpdy must be called outside non-uniform control flow (WGSL spec),\n          // so we compute the flat normal unconditionally and select below.\n          let faceN = cross(dpdx(input.worldPos), dpdy(input.worldPos));\n          var N = input.normal;\n          let nLen2 = dot(N, N);\n          if (nLen2 < 0.0001) {\n            // Fallback: use flat normal from screen-space derivatives\n            let fLen2 = dot(faceN, faceN);\n            N = select(vec3<f32>(0.0, 1.0, 0.0), faceN * inverseSqrt(fLen2), fLen2 > 1e-10);\n          } else {\n            N = N * inverseSqrt(nLen2);\n          }\n\n          // Enhanced lighting with multiple sources\n          let sunLight = normalize(vec3<f32>(0.5, 1.0, 0.3));  // Main directional light\n          let fillLight = normalize(vec3<f32>(-0.5, 0.3, -0.3));  // Fill light\n          let rimLight = normalize(vec3<f32>(0.0, 0.2, -1.0));  // Rim light for edge definition\n\n          // Hemisphere ambient - reduced for less washed-out look\n          let skyColor = vec3<f32>(0.3, 0.35, 0.4);  // Darker sky\n          let groundColor = vec3<f32>(0.15, 0.1, 0.08);  // Darker ground\n          let hemisphereFactor = N.y * 0.5 + 0.5;\n          let ambient = mix(groundColor, skyColor, hemisphereFactor) * 0.25;\n\n          // Two-sided sun light so inner faces (I-beam channels) stay visible\n          let NdotL = abs(dot(N, sunLight));\n          let wrap = 0.3;\n          let diffuseSun = max((NdotL + wrap) / (1.0 + wrap), 0.0) * 0.55;\n\n          // Fill light - two-sided\n          let NdotFill = abs(dot(N, fillLight));\n          let diffuseFill = NdotFill * 0.15;\n\n          // Rim light for edge definition\n          let NdotRim = max(dot(N, rimLight), 0.0);\n          let rim = pow(NdotRim, 4.0) * 0.15;\n\n          var baseColor = uniforms.baseColor.rgb;\n\n          // Detect if the color is close to white/gray (low saturation)\n          let baseGray = dot(baseColor, vec3<f32>(0.299, 0.587, 0.114));\n          let baseSaturation = length(baseColor - vec3<f32>(baseGray)) / max(baseGray, 0.001);\n          let isWhiteish = 1.0 - smoothstep(0.0, 0.3, baseSaturation);\n\n          // Darken whites/grays more to reduce washed-out appearance\n          baseColor = mix(baseColor, baseColor * 0.7, isWhiteish * 0.4);\n\n          // Combine all lighting\n          var color = baseColor * (ambient + diffuseSun + diffuseFill + rim);\n\n          // flags.x is a bitfield:\n          //   bit 0 (value 1) = isSelected  \u2192 selection-highlight + force opaque\n          //   bit 1 (value 2) = isOverlay   \u2192 color-override pass; preserve\n          //                                    baseColor.a (overlay pipeline has\n          //                                    src-alpha blending) AND skip the\n          //                                    glass-fresnel branch so low-alpha\n          //                                    ghost tints don't pick up the\n          //                                    near-white reflection tint meant\n          //                                    for real glass materials.\n          let isSelected = (uniforms.flags.x & 1u) == 1u;\n          let isOverlay = (uniforms.flags.x & 2u) == 2u;\n\n          // Selection highlight - add glow/fresnel effect\n          if (isSelected) {\n            let V = normalize(-input.worldPos);\n            let NdotV = max(dot(N, V), 0.0);\n            let fresnel = pow(1.0 - NdotV, 2.0);\n            let highlightColor = vec3<f32>(0.3, 0.6, 1.0);\n            color = mix(color, highlightColor, fresnel * 0.5 + 0.2);\n          }\n\n          // Beautiful fresnel effect for transparent materials (glass)\n          // Skip when selected \u2014 the glass shine and desaturation wash out the\n          // blue highlight, making it appear white instead of blue.\n          // Also force alpha to 1.0 for selected objects so the highlight is\n          // fully opaque (the selection pipeline has no alpha blending).\n          var finalAlpha = select(uniforms.baseColor.a, 1.0, isSelected);\n          if (finalAlpha < 0.99 && !isSelected && !isOverlay) {\n            // Calculate view direction for fresnel\n            let V = normalize(-input.worldPos);\n            let NdotV = max(dot(N, V), 0.0);\n\n            // Enhanced fresnel effect - stronger at edges (grazing angles)\n            // Using Schlick's approximation for realistic glass reflection\n            let fresnelPower = 1.5; // Higher = softer edge reflections\n            let fresnel = pow(1.0 - NdotV, fresnelPower);\n\n            // Glass reflection tint (sky/environment reflection at edges)\n            let reflectionTint = vec3<f32>(0.92, 0.96, 1.0);  // Cool sky reflection\n            let reflectionStrength = fresnel * 0.6;  // Strong edge reflections\n\n            // Mix in reflection tint at edges\n            color = mix(color, color * reflectionTint, reflectionStrength);\n\n            // Add realistic glass shine - brighter at edges where light reflects\n            let glassShine = fresnel * 0.12;\n            color += glassShine;\n\n            // Slight desaturation at edges (glass reflects environment, not just color)\n            let edgeDesaturation = fresnel * 0.25;\n            let gray = dot(color, vec3<f32>(0.299, 0.587, 0.114));\n            color = mix(color, vec3<f32>(gray), edgeDesaturation);\n\n            // Make glass more transparent (reduce opacity by 30%)\n            finalAlpha = finalAlpha * 0.7;\n          }\n\n          // Exposure adjustment - darken overall\n          color *= 0.85;\n\n          // Contrast enhancement\n          color = (color - 0.5) * 1.15 + 0.5;\n          color = max(color, vec3<f32>(0.0));\n\n          // Saturation boost - stronger for colored surfaces, less for whites\n          let gray = dot(color, vec3<f32>(0.299, 0.587, 0.114));\n          let satBoost = mix(1.4, 1.1, isWhiteish);  // More saturation for colored surfaces\n          color = mix(vec3<f32>(gray), color, satBoost);\n\n          // ACES filmic tone mapping\n          let a = 2.51;\n          let b = 0.03;\n          let c = 2.43;\n          let d = 0.59;\n          let e = 0.14;\n          color = clamp((color * (a * color + b)) / (color * (c * color + d) + e), vec3<f32>(0.0), vec3<f32>(1.0));\n\n          // Subtle edge enhancement using screen-space derivatives\n          let depthGradient = length(vec2<f32>(\n            dpdx(input.viewPos.z),\n            dpdy(input.viewPos.z)\n          ));\n          let normalGradient = length(vec2<f32>(\n            length(dpdx(input.normal)),\n            length(dpdy(input.normal))\n          ));\n\n          if (uniforms.flags.z == 1u) {\n            // Threshold filters subtle normal discontinuities at internal\n            // triangle edges between coplanar entities in the same batch.\n            let edgeFactor = smoothstep(0.02, 0.12, depthGradient * 10.0 + normalGradient * 5.0);\n            let edgeIntensity = f32(uniforms.flags.w) / 1000.0;\n            let edgeDarkenStrength = clamp(0.25 * edgeIntensity, 0.0, 0.85);\n            let edgeDarken = mix(1.0, 1.0 - edgeDarkenStrength, edgeFactor);\n            color *= edgeDarken;\n          }\n\n          // Gamma correction\n          color = pow(color, vec3<f32>(1.0 / 2.2));\n\n          var out: FragmentOutput;\n          out.color = vec4<f32>(color, finalAlpha);\n          out.objectIdEncoded = encodeId24(input.entityId);\n          return out;\n        }\n      ";
 //# sourceMappingURL=main.wgsl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"main.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,mzVAsPtB,CAAC"}
+{"version":3,"file":"main.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,ykXAkQtB,CAAC"}

package/dist/shaders/main.wgsl.js

@@ -159,8 +159,20 @@ export const mainShaderSource = `
           // Combine all lighting
           var color = baseColor * (ambient + diffuseSun + diffuseFill + rim);
 
+          // flags.x is a bitfield:
+          //   bit 0 (value 1) = isSelected  → selection-highlight + force opaque
+          //   bit 1 (value 2) = isOverlay   → color-override pass; preserve
+          //                                    baseColor.a (overlay pipeline has
+          //                                    src-alpha blending) AND skip the
+          //                                    glass-fresnel branch so low-alpha
+          //                                    ghost tints don't pick up the
+          //                                    near-white reflection tint meant
+          //                                    for real glass materials.
+          let isSelected = (uniforms.flags.x & 1u) == 1u;
+          let isOverlay = (uniforms.flags.x & 2u) == 2u;
+
           // Selection highlight - add glow/fresnel effect
-          if (uniforms.flags.x == 1u) {
+          if (isSelected) {
             let V = normalize(-input.worldPos);
             let NdotV = max(dot(N, V), 0.0);
             let fresnel = pow(1.0 - NdotV, 2.0);
@@ -173,8 +185,8 @@ export const mainShaderSource = `
           // blue highlight, making it appear white instead of blue.
           // Also force alpha to 1.0 for selected objects so the highlight is
           // fully opaque (the selection pipeline has no alpha blending).
-          var finalAlpha = select(uniforms.baseColor.a, 1.0, uniforms.flags.x == 1u);
-          if (finalAlpha < 0.99 && uniforms.flags.x != 1u) {
+          var finalAlpha = select(uniforms.baseColor.a, 1.0, isSelected);
+          if (finalAlpha < 0.99 && !isSelected && !isOverlay) {
             // Calculate view direction for fresnel
             let V = normalize(-input.worldPos);
             let NdotV = max(dot(N, V), 0.0);

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

@@ -1 +1 @@
-{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsPzB,CAAC"}
+{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkQzB,CAAC"}

package/dist/types.d.ts

@@ -146,6 +146,26 @@ export interface RenderOptions {
     isolatedIds?: Set<number> | null;
     selectedId?: number | null;
     selectedIds?: Set<number>;
+    /**
+     * Per-frame alpha overrides — primary use case is X-Ray mode.
+     *
+     * Map<expressId, alpha 0..1>. Non-selected meshes/batches whose expressId
+     * appears in this map render at the override alpha through the transparent
+     * pipeline. Selected meshes (`selectedId` / `selectedIds`) are exempt at
+     * every site, so highlights always paint with their own alpha.
+     *
+     * Mixed batches (some entries overridden, some not) take the minimum
+     * override alpha across non-selected ids; selected meshes in the batch
+     * are then redrawn on top by the highlight pass.
+     *
+     * The renderer snapshots this map at frame start, so callers may freely
+     * mutate or recycle their copy after `render()` returns.
+     *
+     * Note: alphas `>= 0.99` are treated as opaque (the cutoff for switching to
+     * the transparent pipeline). Entries at or above that threshold are no-ops
+     * — keep them out of the map to avoid unnecessary work.
+     */
+    transparencyOverrides?: Map<number, number> | null;
     buildingRotation?: number;
     selectedModelIndex?: number;
     sectionPlane?: SectionPlane;

package/dist/types.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/renderer",
-  "version": "1.16.0",
+  "version": "1.18.0",
   "description": "WebGPU renderer for IFC-Lite",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,9 +12,9 @@
     }
   },
   "dependencies": {
-    "@ifc-lite/geometry": "^1.16.5",
+    "@ifc-lite/geometry": "^1.17.0",
     "@ifc-lite/spatial": "^1.14.5",
-    "@ifc-lite/wasm": "^1.16.6"
+    "@ifc-lite/wasm": "^1.16.8"
   },
   "devDependencies": {
     "@webgpu/types": "^0.1.69",