@ifc-lite/renderer 4.2.0 → 5.0.0

package/dist/shaders/main.wgsl.js

@@ -3,14 +3,22 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 /**
  * Main rendering shader for IFC geometry.
- * Features: linear-space diffuse lighting of sRGB-authored colours, section
- * plane clipping, selection highlight, glass fresnel, hue-preserving highlight
- * roll-off, screen-space edge enhancement.
+ * Features: linear-space lighting of sRGB-authored colours with a GGX
+ * specular term (specular.wgsl.ts), section plane clipping, selection
+ * highlight, glass, hue-preserving highlight roll-off, screen-space edge
+ * enhancement.
  */
 import { MESH_FLAG_RTE_DRAWABLE } from '../mesh-rte-uniforms.js';
 import { colorTransferWgsl } from './color-transfer.wgsl.js';
 import { mainRteWgsl, mainShadowWgsl } from './main-rte-shadow.wgsl.js';
 import { relativeToEyeWgsl } from './relative-to-eye.wgsl.js';
+import { specularWgsl } from './specular.wgsl.js';
+/**
+ * Translucent surfaces draw at this fraction of their alpha, so interiors
+ * read through windows and X-Ray ghosts stay faint. A viewer choice that
+ * predates #5386, not optics.
+ */
+const TRANSLUCENT_OPACITY_SCALE = 0.7;
 /**
  * Converts the environment's light intensities to linear irradiance.
  *
@@ -33,8 +41,8 @@ export const mainShaderSource = `
           viewProj: mat4x4<f32>,
           model: mat4x4<f32>,
           baseColor: vec4<f32>,
-          metallicRoughness: vec2<f32>, // x = metallic, y = roughness
-          _padding1: vec2<f32>,
+          metallicRoughness: vec2<f32>, // x = metallic, y = roughness (mesh-material.ts)
+          transmission: vec2<f32>,      // x = 1: authored translucent, drawn as glass; y = pad
           sectionPlane: vec4<f32>,      // xyz = plane normal, w = plane distance
           flags: vec4<u32>,             // x = isSelected, y = section/clip bits, z = edgeEnabled, w = edgeIntensityMilli
           clipBoxMin: vec4<f32>,        // xyz = clip-box min corner (world), w = pad
@@ -66,8 +74,15 @@ export const mainShaderSource = `
           _pad2: f32,
         }
         @binding(0) @group(1) var<uniform> env: Environment;
+        // Selection highlight tint (#5484), set by Renderer.setOverlayTheme via
+        // updateSelectionColor — written only on theme change, never per frame.
+        // TRUE LINEAR-LIGHT RGB: re-lit by lightTerm below exactly like the WGSL
+        // constant it replaces, then ACES-tonemapped + gamma-encoded on output.
+        @binding(4) @group(1) var<uniform> selectionColor: vec4<f32>;
         const IRRADIANCE_CALIBRATION: f32 = ${IRRADIANCE_CALIBRATION};
+        const TRANSLUCENT_OPACITY_SCALE: f32 = ${TRANSLUCENT_OPACITY_SCALE};
         ${colorTransferWgsl}
+        ${specularWgsl}
 
         ${mainShadowWgsl}
 
@@ -244,35 +259,6 @@ export const mainShaderSource = `
           return output;
         }
 
-        // PBR helper functions
-        fn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
-          return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-        }
-
-        fn distributionGGX(NdotH: f32, roughness: f32) -> f32 {
-          let a = roughness * roughness;
-          let a2 = a * a;
-          let NdotH2 = NdotH * NdotH;
-          let num = a2;
-          let denomBase = (NdotH2 * (a2 - 1.0) + 1.0);
-          let denom = 3.14159265 * denomBase * denomBase;
-          return num / max(denom, 0.0000001);
-        }
-
-        fn geometrySchlickGGX(NdotV: f32, roughness: f32) -> f32 {
-          let r = (roughness + 1.0);
-          let k = (r * r) / 8.0;
-          let num = NdotV;
-          let denom = NdotV * (1.0 - k) + k;
-          return num / max(denom, 0.0000001);
-        }
-
-        fn geometrySmith(NdotV: f32, NdotL: f32, roughness: f32) -> f32 {
-          let ggx2 = geometrySchlickGGX(NdotV, roughness);
-          let ggx1 = geometrySchlickGGX(NdotL, roughness);
-          return ggx1 * ggx2;
-        }
-
         fn encodeId24(id: u32) -> vec4<f32> {
           let r = f32((id >> 16u) & 255u) / 255.0;
           let g = f32((id >> 8u) & 255u) / 255.0;
@@ -451,10 +437,10 @@ export const mainShaderSource = `
           //   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.
+          //                                    specular term, so an override
+          //                                    paints its colour, lit, and a
+          //                                    low-alpha ghost tint does not
+          //                                    pick up glass reflections.
           // Selected via the per-draw flag (flat path) OR the per-occurrence flag
           // (instanced path — vs_instanced reads it from the instance buffer).
           let isSelected = ((uniforms.flags.x & 1u) == 1u) || ((input.instSelected & 1u) == 1u);
@@ -464,7 +450,7 @@ export const mainShaderSource = `
           //
           // We override the material albedo with selection-blue and re-light
           // it with the SAME lightTerm used for unselected surfaces, then
-          // discard the view-dependent (fresnel) term below. Two requirements
+          // skip the view-dependent (specular) term below. Two requirements
           // are in tension and this satisfies both:
           //
           //   * No base-material bleed-through. The old fresnel-glow mix left
@@ -488,7 +474,10 @@ export const mainShaderSource = `
           if (isSelected) {
             let shadeLum = dot(irradiance, vec3<f32>(0.299, 0.587, 0.114));
             let shade = clamp(shadeLum, 0.45, 1.2);
-            color = srgbToLinear(vec3<f32>(0.3, 0.6, 1.0)) * shade;
+            // selectionColor is already linear-light (set by Renderer.setOverlayTheme
+            // from the app theme, #5484) — no srgbToLinear here, unlike the constant
+            // it replaces.
+            color = selectionColor.rgb * shade;
           }
 
           // flags.x bit 5 (value 32) = EMPHASIZE overlay: render the colour
@@ -502,44 +491,59 @@ export const mainShaderSource = `
             color = baseColor * facet;
           }
 
-          // Beautiful fresnel effect for transparent materials (glass)
-          // Skip when selected — the glass shine and desaturation wash out the
-          // 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).
-          // Emphasized clash overlay paints a SOLID vivid fill (force opaque) so
-          // it isn't blended down to a pale tint against the geometry beneath.
+          // Force alpha to 1.0 for selected objects so the highlight is fully
+          // opaque (the selection pipeline has no alpha blending). Emphasized
+          // clash overlay paints a SOLID vivid fill (force opaque) so it isn't
+          // blended down to a pale tint against the geometry beneath.
           var finalAlpha = select(input.color.a, 1.0, isSelected || emphasizedOverlay);
-          if (finalAlpha < 0.99 && !isSelected && !isOverlay) {
-            // Calculate view direction for fresnel
-            let V = normalize(-fragmentPos);
-            let NdotV = max(dot(N, V), 0.0);
-
-            // Enhanced fresnel effect - stronger at edges (grazing angles)
-            // Using Schlick's approximation for realistic glass reflection
-            let fresnelPower = 1.5; // Higher = softer edge reflections
-            let fresnel = pow(1.0 - NdotV, fresnelPower);
-
-            // Glass reflection tint (sky/environment reflection at edges)
-            let reflectionTint = vec3<f32>(0.92, 0.96, 1.0);  // Cool sky reflection
-            let reflectionStrength = fresnel * 0.6;  // Strong edge reflections
-
-            // Mix in reflection tint at edges
-            color = mix(color, color * reflectionTint, reflectionStrength);
-
-            // Add realistic glass shine - brighter at edges where light reflects.
-            // Linear amount: 0.06 lifts a mid-tone about as much as the 0.12
-            // the pre-linear pipeline added in display space.
-            let glassShine = fresnel * 0.06;
-            color += glassShine;
-
-            // Slight desaturation at edges (glass reflects environment, not just color)
-            let edgeDesaturation = fresnel * 0.25;
-            let gray = dot(color, vec3<f32>(0.299, 0.587, 0.114));
-            color = mix(color, vec3<f32>(gray), edgeDesaturation);
-
-            // Make glass more transparent (reduce opacity by 30%)
-            finalAlpha = finalAlpha * 0.7;
+
+          // Specular (#5386; specular.wgsl.ts), after the diffuse above. Not
+          // on the selection highlight (it would wash the blue out) nor on a
+          // colour-override overlay. The sun lobe is scaled exactly like the
+          // diffuse sun term, and both terms like irradiance, so a preset's
+          // highlights and its diffuse light move together.
+          if (!isSelected && !isOverlay) {
+            // Glass is an authored translucent material (mesh-material.ts
+            // also gives it its smooth roughness). An X-Ray or compare fade
+            // only lowers the alpha and stays a fade. Instanced occurrences
+            // are never authored translucent: prepareInstancedRender routes
+            // those to the flat path, so the per-pass lane is ignored there.
+            let instancedPass = (uniforms.flags.x & 4u) != 0u;
+            let translucent = finalAlpha < 0.99;
+            let glass = translucent && uniforms.transmission.x > 0.5 && !instancedPass;
+            let metallic = clamp(uniforms.metallicRoughness.x, 0.0, 1.0);
+            let spec = surfaceSpecular(
+              N,
+              normalize(-input.eyePos),
+              baseColor,
+              metallic,
+              uniforms.metallicRoughness.y,
+              env.sunColor * (env.sunIntensity * sunShadow),
+            );
+            // What the lobe reflects is not there to diffuse; a metal has no
+            // diffuse at all.
+            let diffuse = color * (1.0 - spec.reflectance) * (1.0 - metallic);
+            let reflected = spec.light * (env.exposure * IRRADIANCE_CALIBRATION);
+            if (translucent) {
+              finalAlpha = finalAlpha * TRANSLUCENT_OPACITY_SCALE;
+            }
+            if (glass) {
+              // The transparent pipelines blend straight alpha:
+              // out = c * a + behind * (1 - a). A pane passes what is behind
+              // it except what its body absorbs and its surface reflects, and
+              // its reflection is not dimmed by the body's opacity, so solve
+              // for (c, a). The reflectance rising at grazing angles is what
+              // makes glass more opaque there; a bright sun glint raises the
+              // alpha further so it is not clipped to the body's opacity.
+              let body = finalAlpha;
+              let reflectance = dot(spec.reflectance, vec3<f32>(0.299, 0.587, 0.114));
+              let premultiplied = diffuse * body + reflected;
+              let peak = max(premultiplied.r, max(premultiplied.g, premultiplied.b));
+              finalAlpha = clamp(max(body + reflectance * (1.0 - body), peak), 0.0, 1.0);
+              color = premultiplied / max(finalAlpha, 0.0001);
+            } else {
+              color = diffuse + reflected;
+            }
           }
 
           // Hue-preserving highlight roll-off (color-transfer.wgsl.ts). No

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;;;;;GAKG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;yCAmBS,sBAAsB;UACrD,iBAAiB;UACjB,WAAW;;;;;;;;;;;;;;;;;8CAiByB,sBAAsB;UAC1D,iBAAiB;;UAEjB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqgBjB,CAAC"}
+{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;GAMG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;GAIG;AACH,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAEpC,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;yCAmBS,sBAAsB;UACrD,iBAAiB;UACjB,WAAW;;;;;;;;;;;;;;;;;;;;;;8CAsByB,sBAAsB;iDACnB,yBAAyB;UAChE,iBAAiB;UACjB,YAAY;;UAEZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0fjB,CAAC"}

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

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

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

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

package/dist/shaders/specular.wgsl.js

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

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

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

package/dist/visual-enhancement.d.ts

@@ -22,10 +22,16 @@ export type ResolvedVisualEnhancement = {
         radius: number;
     };
 };
-/** Accepted `separationLines.radius`, in pixels. */
+/**
+ * Accepted `separationLines.radius`, in pixels: the tap distance the edge
+ * pass (#5385) offsets its cardinal and (at `high` quality) diagonal
+ * samples by. Widened from 1-2 to 1-3 when the pass gained diagonal taps and
+ * a normal-crease/silhouette test alongside the entity-id test, so `high`
+ * quality has room to space its 8 taps out from the 4-tap `low` default.
+ */
 export declare const SEPARATION_RADIUS_RANGE_PX: {
     readonly min: 1;
-    readonly max: 2;
+    readonly max: 3;
 };
 /**
  * Resolves per-frame `VisualEnhancementOptions` against the last-resolved
@@ -45,7 +51,8 @@ export declare class VisualEnhancementResolver {
 export interface LivePostEffects {
     /** The quality to run ambient occlusion at, or null when it does not run. */
     ambientOcclusion: AoQuality | null;
-    separationLines: boolean;
+    /** The edge pass (#5385): entity-id, normal-crease and silhouette lines. Option name stays `separationLines`. */
+    edges: boolean;
 }
 /**
  * The post passes to run this frame: those the options ask for, while

package/dist/visual-enhancement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visual-enhancement.d.ts","sourceRoot":"","sources":["../src/visual-enhancement.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE1G,MAAM,MAAM,yBAAyB,GAAG;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE;QACV,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,cAAc,EAAE;QACZ,OAAO,EAAE,qBAAqB,CAAC;QAC/B,cAAc;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,6CAA6C;QAC7C,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,sBAAsB,CAAC;QAChC,cAAc;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,mDAAmD;QACnD,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;CACL,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,0BAA0B;;;CAA8B,CAAC;AAWtE;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;IAClC,OAAO,CAAC,KAAK,CAKX;IAEF,OAAO,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,yBAAyB;CA+BzE;AAED,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC5B,6EAA6E;IAC7E,gBAAgB,EAAE,SAAS,GAAG,IAAI,CAAC;IACnC,eAAe,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,yBAAyB,EAAE,WAAW,EAAE,OAAO,GAAG,eAAe,CAOpG"}
+{"version":3,"file":"visual-enhancement.d.ts","sourceRoot":"","sources":["../src/visual-enhancement.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE1G,MAAM,MAAM,yBAAyB,GAAG;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE;QACV,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,cAAc,EAAE;QACZ,OAAO,EAAE,qBAAqB,CAAC;QAC/B,cAAc;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,6CAA6C;QAC7C,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,sBAAsB,CAAC;QAChC,cAAc;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,mDAAmD;QACnD,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;CACL,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;CAA8B,CAAC;AAWtE;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;IAClC,OAAO,CAAC,KAAK,CAKX;IAEF,OAAO,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,yBAAyB;CA+BzE;AAED,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC5B,6EAA6E;IAC7E,gBAAgB,EAAE,SAAS,GAAG,IAAI,CAAC;IACnC,iHAAiH;IACjH,KAAK,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,yBAAyB,EAAE,WAAW,EAAE,OAAO,GAAG,eAAe,CAOpG"}

package/dist/visual-enhancement.js

@@ -2,8 +2,14 @@
  * 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 { AO_RADIUS_RANGE } from './ao-params.js';
-/** Accepted `separationLines.radius`, in pixels. */
-export const SEPARATION_RADIUS_RANGE_PX = { min: 1, max: 2 };
+/**
+ * Accepted `separationLines.radius`, in pixels: the tap distance the edge
+ * pass (#5385) offsets its cardinal and (at `high` quality) diagonal
+ * samples by. Widened from 1-2 to 1-3 when the pass gained diagonal taps and
+ * a normal-crease/silhouette test alongside the entity-id test, so `high`
+ * quality has room to space its 8 taps out from the 4-tap `low` default.
+ */
+export const SEPARATION_RADIUS_RANGE_PX = { min: 1, max: 3 };
 /**
  * `value` clamped to [min, max]; a missing or non-finite value keeps
  * `previous` (which is already in range).
@@ -66,7 +72,7 @@ export function livePostEffects(ve, effectsLive) {
     const aoQuality = ve.contactShading.quality;
     return {
         ambientOcclusion: live && aoQuality !== 'off' ? aoQuality : null,
-        separationLines: live && ve.separationLines.enabled && ve.separationLines.quality !== 'off',
+        edges: live && ve.separationLines.enabled && ve.separationLines.quality !== 'off',
     };
 }
 //# sourceMappingURL=visual-enhancement.js.map

package/dist/visual-enhancement.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-enhancement.js","sourceRoot":"","sources":["../src/visual-enhancement.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"visual-enhancement.js","sourceRoot":"","sources":["../src/visual-enhancement.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,OAAO,EAAE,eAAe,EAAkB,MAAM,gBAAgB,CAAC;AA0BjE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAW,CAAC;AAEtE;;;GAGG;AACH,SAAS,OAAO,CAAC,KAAyB,EAAE,QAAgB,EAAE,GAAW,EAAE,GAAW;IAClF,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IACpE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,yBAAyB;IAC1B,KAAK,GAA8B;QACvC,OAAO,EAAE,IAAI;QACb,YAAY,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE;QAC/C,cAAc,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE;QAC/D,eAAe,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE;KAClF,CAAC;IAEF,OAAO,CAAC,OAAkC;QACtC,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,OAAO,IAAI,CAAC,KAAK,CAAC;QACtB,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;QACxB,MAAM,MAAM,GAA8B;YACtC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;YACxC,YAAY,EAAE;gBACV,OAAO,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO;gBACnE,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS;aAC5E;YACD,cAAc,EAAE;gBACZ,OAAO,EAAE,OAAO,CAAC,cAAc,EAAE,OAAO,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO;gBACvE,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC1F,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC;aACxH;YACD,eAAe,EAAE;gBACb,OAAO,EAAE,OAAO,CAAC,eAAe,EAAE,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO;gBACzE,OAAO,EAAE,OAAO,CAAC,eAAe,EAAE,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO;gBACzE,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC5F,MAAM,EAAE,OAAO,CACX,OAAO,CAAC,eAAe,EAAE,MAAM,EAC/B,IAAI,CAAC,eAAe,CAAC,MAAM,EAC3B,0BAA0B,CAAC,GAAG,EAC9B,0BAA0B,CAAC,GAAG,CACjC;aACJ;SACJ,CAAC;QACF,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QACpB,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AAUD;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,EAA6B,EAAE,WAAoB;IAC/E,MAAM,IAAI,GAAG,WAAW,IAAI,EAAE,CAAC,OAAO,CAAC;IACvC,MAAM,SAAS,GAAG,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC;IAC5C,OAAO;QACH,gBAAgB,EAAE,IAAI,IAAI,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;QAChE,KAAK,EAAE,IAAI,IAAI,EAAE,CAAC,eAAe,CAAC,OAAO,IAAI,EAAE,CAAC,eAAe,CAAC,OAAO,KAAK,KAAK;KACpF,CAAC;AACN,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/renderer",
-  "version": "4.2.0",
+  "version": "5.0.0",
   "description": "WebGPU renderer for IFC-Lite",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,7 @@
     }
   },
   "dependencies": {
-    "@ifc-lite/geometry": "^7.5.1",
+    "@ifc-lite/geometry": "^7.5.2",
     "@ifc-lite/spatial": "^1.15.0"
   },
   "devDependencies": {

package/dist/post-processor.d.ts

@@ -1,46 +0,0 @@
-/**
- * Separation-line overlay: a fullscreen pass that darkens pixels where a
- * neighbour belongs to a different entity AND the depth creases or steps
- * there, so abutting elements read as separate parts.
- *
- * Ambient occlusion used to share this pass as "contact shading"; it now
- * lives in `ao-pass.ts` (#5384).
- */
-import { WebGPUDevice } from './device.js';
-export type PostProcessQuality = 'low' | 'high';
-export interface SeparationLinePassOptions {
-    targetView: GPUTextureView;
-    depthView: GPUTextureView;
-    objectIdView: GPUTextureView;
-    quality: PostProcessQuality;
-    /** Tap distance in pixels at `high` quality; `low` always uses 1. */
-    radius: number;
-    intensity: number;
-}
-export declare class PostProcessor {
-    private _device;
-    private colorFormat;
-    private isMultisampled;
-    private uniformBuffer;
-    private uniformStaging;
-    private uniformF32;
-    private uniformU32;
-    private bindGroupLayout;
-    private pipeline;
-    private cachedBindGroup;
-    private cachedDepthView;
-    private cachedObjectIdView;
-    constructor(device: WebGPUDevice, sampleCount: number);
-    /**
-     * Draw the separation lines over `targetView` in a fullscreen overlay pass.
-     */
-    apply(commandEncoder: GPUCommandEncoder, options: SeparationLinePassOptions): void;
-    private destroyed;
-    /**
-     * Destroy all GPU resources held by this post-processor.
-     * After calling this method the post-processor is no longer usable.
-     * Safe to call multiple times.
-     */
-    destroy(): void;
-}
-//# sourceMappingURL=post-processor.d.ts.map

package/dist/post-processor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"post-processor.d.ts","sourceRoot":"","sources":["../src/post-processor.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,MAAM,CAAC;AAEhD,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,cAAc,CAAC;IAC3B,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,EAAE,cAAc,CAAC;IAC7B,OAAO,EAAE,kBAAkB,CAAC;IAC5B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAa;IACtB,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,kBAAkB,CAA+B;gBAE7C,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAwOrD;;OAEG;IACH,KAAK,CAAC,cAAc,EAAE,iBAAiB,EAAE,OAAO,EAAE,yBAAyB,GAAG,IAAI;IAmClF,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;OAIG;IACH,OAAO,IAAI,IAAI;CAQlB"}