@luma.gl/shaders 10.0.0-alpha.10 → 10.0.0-alpha.12

package/dist/dist.dev.js

@@ -28,6 +28,8 @@ var __exports__ = (() => {
   var bundle_exports = {};
   __export(bundle_exports, {
     GLSLShaderAssembler: () => GLSLShaderAssembler,
+    PBR_ENVIRONMENT_FRAGMENT_GLSL: () => PBR_ENVIRONMENT_FRAGMENT_GLSL,
+    PBR_ENVIRONMENT_FRAGMENT_WGSL: () => PBR_ENVIRONMENT_FRAGMENT_WGSL,
     PBR_TONE_MAP_MODE: () => PBR_TONE_MAP_MODE,
     SKIN_MAX_JOINTS: () => SKIN_MAX_JOINTS,
     STORAGE_COLOR_DEFAULT_BYTE_STRIDES: () => STORAGE_COLOR_DEFAULT_BYTE_STRIDES,
@@ -43,8 +45,12 @@ var __exports__ = (() => {
     checkShaderModuleDeprecations: () => checkShaderModuleDeprecations,
     clipShaderPlugin: () => clipShaderPlugin,
     clouds: () => clouds,
+    clusteredLightGrid: () => clusteredLightGrid,
     colors: () => colors,
     combineInjects: () => combineInjects,
+    contactShadowBilateralBlur: () => contactShadowBilateralBlur,
+    contactShadowComposite: () => contactShadowComposite,
+    contactShadowTrace: () => contactShadowTrace,
     convertToVec4: () => convertToVec4,
     dggs: () => dggs,
     dirlight: () => dirlight,
@@ -80,13 +86,20 @@ var __exports__ = (() => {
     integrateSurfaceWeather: () => integrateSurfaceWeather,
     lambertMaterial: () => lambertMaterial,
     lighting: () => lighting,
+    lightmapBake: () => lightmapBake,
+    lightmapFilter: () => lightmapFilter,
     mergeShaderPluginModules: () => mergeShaderPluginModules,
     normalizeByteColor3: () => normalizeByteColor3,
     normalizeByteColor4: () => normalizeByteColor4,
     pathDash: () => pathDash,
     patternFill: () => patternFill,
+    pbrAmbientOcclusion: () => pbrAmbientOcclusion,
+    pbrContactShadow: () => pbrContactShadow,
+    pbrEnvironmentFilter: () => pbrEnvironmentFilter,
     pbrMaterial: () => pbrMaterial,
     pbrScene: () => pbrScene,
+    pbrShadow: () => pbrShadow,
+    pbrSurface: () => pbrSurface,
     phongMaterial: () => phongMaterial,
     picking: () => picking,
     pointGlow: () => pointGlow,
@@ -97,6 +110,7 @@ var __exports__ = (() => {
     resolveUseByteColors: () => resolveUseByteColors,
     riverWaterMaterial: () => riverWaterMaterial,
     scanWGSLInterface: () => scanWGSLInterface,
+    shadow: () => shadow,
     sketchStroke: () => sketchStroke,
     skin: () => skin,
     storageColors: () => storageColors,
@@ -104,6 +118,7 @@ var __exports__ = (() => {
     toHalfFloat: () => toHalfFloat,
     typeToChannelCount: () => typeToChannelCount,
     typeToChannelSuffix: () => typeToChannelSuffix,
+    unlitMaterial: () => unlitMaterial,
     validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout,
     valueNoise: () => valueNoise,
     volumeRaymarch: () => volumeRaymarch,
@@ -1184,8 +1199,13 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     }
     return decoded;
   }
+  var attributeShaderTypeInfoCache = /* @__PURE__ */ new Map();
   function getAttributeShaderTypeInfo(attributeType) {
     const resolvedAttributeType = resolveAttributeShaderTypeAlias(attributeType);
+    const cached = attributeShaderTypeInfoCache.get(resolvedAttributeType);
+    if (cached) {
+      return cached;
+    }
     const decoded = TYPE_INFO[resolvedAttributeType];
     if (!decoded) {
       throw new Error(`Unsupported attribute shader type: ${attributeType}`);
@@ -1194,13 +1214,15 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     const integer = primitiveType === "i32" || primitiveType === "u32";
     const signed = primitiveType !== "u32";
     const byteLength = PRIMITIVE_TYPE_SIZES[primitiveType] * components;
-    return {
+    const result = Object.freeze({
       primitiveType,
       components,
       byteLength,
       integer,
       signed
-    };
+    });
+    attributeShaderTypeInfoCache.set(resolvedAttributeType, result);
+    return result;
   }
   var ShaderTypeDecoder = class {
     getVariableShaderTypeInfo(format) {
@@ -1309,6 +1331,9 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     "mat4x3<u32>": { type: "u32", components: 12 },
     "mat4x4<u32>": { type: "u32", components: 16 }
   };
+  for (const info of Object.values(UNIFORM_FORMATS)) {
+    Object.freeze(info);
+  }
   var WGSL_ATTRIBUTE_TYPE_ALIAS_MAP = {
     vec2i: "vec2<i32>",
     vec3i: "vec3<i32>",
@@ -5137,6 +5162,35 @@ void main() {
     out[15] = 1;
     return out;
   }
+  function affineComponents(matrix) {
+    if (matrix.length !== 16 || Array.from(matrix).some((x) => !Number.isFinite(x)) || matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1) {
+      throw new RangeError("Expected a finite affine matrix");
+    }
+    const scale2 = [
+      Math.hypot(matrix[0], matrix[1], matrix[2]),
+      Math.hypot(matrix[4], matrix[5], matrix[6]),
+      Math.hypot(matrix[8], matrix[9], matrix[10])
+    ];
+    if (scale2.some((x) => x === 0 || !Number.isFinite(x)))
+      throw new RangeError("Singular transform");
+    const rotation = Array.from({ length: 9 }, (_, i) => matrix[Math.floor(i / 3) * 4 + i % 3] / scale2[Math.floor(i / 3)]);
+    for (const [a, b] of [
+      [0, 3],
+      [0, 6],
+      [3, 6]
+    ]) {
+      if (Math.abs(rotation[a] * rotation[b] + rotation[a + 1] * rotation[b + 1] + rotation[a + 2] * rotation[b + 2]) > 1e-7) {
+        throw new RangeError("Sheared transforms do not have a TRS decomposition");
+      }
+    }
+    const determinant2 = rotation[0] * (rotation[4] * rotation[8] - rotation[5] * rotation[7]) - rotation[3] * (rotation[1] * rotation[8] - rotation[2] * rotation[7]) + rotation[6] * (rotation[1] * rotation[5] - rotation[2] * rotation[4]);
+    if (determinant2 < 0) {
+      scale2[0] = -scale2[0];
+      for (let i = 0; i < 3; i++)
+        rotation[i] = -rotation[i];
+    }
+    return { rotation, scale: scale2, translation: [matrix[12], matrix[13], matrix[14]] };
+  }
 
   // ../../node_modules/@math.gl/core/dist/gl-matrix/vec4.js
   function transformMat43(out, a, m) {
@@ -5431,27 +5485,15 @@ void main() {
      * @returns self
      */
     getRotation(result, scaleResult) {
-      result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
-      scaleResult = scaleResult || [-0, -0, -0];
-      const scale2 = this.getScale(scaleResult);
-      const inverseScale0 = 1 / scale2[0];
-      const inverseScale1 = 1 / scale2[1];
-      const inverseScale2 = 1 / scale2[2];
-      result[0] = this[0] * inverseScale0;
-      result[1] = this[1] * inverseScale1;
-      result[2] = this[2] * inverseScale2;
-      result[3] = 0;
-      result[4] = this[4] * inverseScale0;
-      result[5] = this[5] * inverseScale1;
-      result[6] = this[6] * inverseScale2;
-      result[7] = 0;
-      result[8] = this[8] * inverseScale0;
-      result[9] = this[9] * inverseScale1;
-      result[10] = this[10] * inverseScale2;
-      result[11] = 0;
-      result[12] = 0;
-      result[13] = 0;
-      result[14] = 0;
+      const { rotation, scale: scale2 } = affineComponents(this);
+      result = result || new Array(16);
+      if (scaleResult)
+        for (let i = 0; i < 3; i++)
+          scaleResult[i] = scale2[i];
+      for (let i = 0; i < 16; i++)
+        result[i] = 0;
+      for (let i = 0; i < 9; i++)
+        result[Math.floor(i / 3) * 4 + i % 3] = rotation[i];
       result[15] = 1;
       return result;
     }
@@ -5462,21 +5504,13 @@ void main() {
      * @returns self
      */
     getRotationMatrix3(result, scaleResult) {
-      result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
-      scaleResult = scaleResult || [-0, -0, -0];
-      const scale2 = this.getScale(scaleResult);
-      const inverseScale0 = 1 / scale2[0];
-      const inverseScale1 = 1 / scale2[1];
-      const inverseScale2 = 1 / scale2[2];
-      result[0] = this[0] * inverseScale0;
-      result[1] = this[1] * inverseScale1;
-      result[2] = this[2] * inverseScale2;
-      result[3] = this[4] * inverseScale0;
-      result[4] = this[5] * inverseScale1;
-      result[5] = this[6] * inverseScale2;
-      result[6] = this[8] * inverseScale0;
-      result[7] = this[9] * inverseScale1;
-      result[8] = this[10] * inverseScale2;
+      const { rotation, scale: scale2 } = affineComponents(this);
+      result = result || new Array(9);
+      if (scaleResult)
+        for (let i = 0; i < 3; i++)
+          scaleResult[i] = scale2[i];
+      for (let i = 0; i < 9; i++)
+        result[i] = rotation[i];
       return result;
     }
     // Modifiers
@@ -12913,6 +12947,42 @@ vec4 dirlight_filterColor(vec4 color) {
     return uniforms2;
   }
 
+  // src/modules/lighting/unlit-material/unlit-material.ts
+  var SOURCE_WGSL2 = (
+    /* wgsl */
+    `fn unlitMaterial_getColor(surfaceColor: vec4<f32>) -> vec4<f32> {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, positionWorldspace: vec3<f32>, normalWorldspace: vec3<f32>) -> vec3<f32> {
+  return surfaceColor;
+}
+`
+  );
+  var SOURCE_GLSL = (
+    /* glsl */
+    `vec4 unlitMaterial_getColor(vec4 surfaceColor) {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positionWorldspace, vec3 normalWorldspace) {
+  return surfaceColor;
+}
+`
+  );
+  var unlitMaterial = {
+    name: "unlitMaterial",
+    source: SOURCE_WGSL2,
+    vs: SOURCE_GLSL,
+    fs: SOURCE_GLSL,
+    dependencies: [],
+    bindingLayout: [],
+    uniformTypes: {},
+    defaultUniforms: {}
+  };
+
   // src/modules/lighting/lambert-material/lambert-shaders-wgsl.ts
   var LAMBERT_WGSL = (
     /* wgsl */
@@ -14542,7 +14612,7 @@ void pbr_setPositionNormalTangentUV(
   vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
   pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -15549,7 +15619,9 @@ vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
 }
 
 // Visibility for the first four spotlights; environment and other lights are unaffected.
-vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
+float pbr_ambientVisibility = 1.0;
+
+vec4 pbr_filterColorWithShadows(vec4 vertexColor, float directionalVisibility, vec4 pointVisibility, vec4 spotVisibility)
 {
   vec2 baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
   vec2 metallicRoughnessUV = getMaterialUV(
@@ -15645,7 +15717,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     color.rgb = baseColor.rgb;
 #ifdef HAS_LIGHTMAP
     if (pbrMaterial.lightmapMapEnabled) {
-      color *= lightmapIrradiance / M_PI;
+      color *= lightmapIrradiance / M_PI * pbr_ambientVisibility;
 #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled) {
         float ao = texture(pbr_occlusionSampler, occlusionUV).r;
@@ -15747,12 +15819,12 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
 #ifdef USE_LIGHTS
       PBRInfo_setAmbientLight(pbrInfo);
-      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor * pbr_ambientVisibility);
 
       for(int i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
           PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
-          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0));
         }
       }
 
@@ -15760,7 +15832,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         if (i < lighting.pointLightCount) {
           PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
           float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation);
         }
       }
 
@@ -15786,6 +15858,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       }
 #endif
 
+vec3 indirectBaseColor = color;
 #ifdef USE_IBL
       if (pbrMaterial.IBLenabled) {
         color += getIBLContribution(pbrInfo, n, reflection);
@@ -15794,6 +15867,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
       // The pinned KHR_lightmap draft explicitly defines c_diff = (1 - metallic) * baseColor.
       color += baseColor.rgb * (1.0 - metallic) * lightmapIrradiance / M_PI;
+      color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
 
 #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled) {
@@ -16026,7 +16100,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     PBRInfo_setAmbientLight(pbrInfo);
     color += calculateMaterialLightColor(
       pbrInfo,
-      lighting.ambientColor,
+      lighting.ambientColor * pbr_ambientVisibility,
       clearcoatNormal,
       clearcoatFactor,
       clearcoatRoughness,
@@ -16042,7 +16116,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0),
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -16053,7 +16127,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0),
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -16069,7 +16143,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -16080,7 +16154,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -16149,6 +16223,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       }
 #endif
 
+    vec3 indirectBaseColor = color;
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
     if (pbrMaterial.IBLenabled) {
@@ -16183,6 +16258,8 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       (1.0 - diffuseTransmission) * baseLayerEnergy * lightmapIrradiance / M_PI;
 #endif
 
+    color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
+
  // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled) {
@@ -16244,6 +16321,21 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
   return vec4(applySceneColorManagement(color), alpha);
 }
 
+// Depth-only passes use the same base-color alpha, vertex color and UV transform.
+void pbr_discardMaskedFragment(vec4 vertexColor) {
+#ifdef ALPHA_CUTOFF
+  float alpha = pbrMaterial.baseColorFactor.a * vertexColor.a;
+#ifdef HAS_BASECOLORMAP
+  alpha *= texture(pbr_baseColorSampler, getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform)).a;
+#endif
+  if (alpha < pbrMaterial.alphaCutoff) {discard;}
+#endif
+}
+
+vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility) {
+  return pbr_filterColorWithShadows(vertexColor, 1.0, vec4(1.0), spotVisibility);
+}
+
 vec4 pbr_filterColor(vec4 vertexColor) {
   return pbr_filterColorWithSpotShadows(vertexColor, vec4(1.0));
 }
@@ -17368,7 +17460,9 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 }
 
 // Visibility for the first four spotlights; environment and other lights are unaffected.
-fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f) -> vec4<f32> {
+var<private> pbr_ambientVisibility: f32 = 1.0;
+
+fn pbr_filterColorWithShadows(vertexColor: vec4<f32>, directionalVisibility: f32, pointVisibility: vec4f, spotVisibility: vec4f) -> vec4<f32> {
   let baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
   let metallicRoughnessUV = getMaterialUV(
     pbrMaterial.metallicRoughnessUVSet,
@@ -17461,7 +17555,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     color = baseColor.rgb;
     #ifdef HAS_LIGHTMAP
     if (pbrMaterial.lightmapMapEnabled != 0u) {
-      color *= lightmapIrradiance / M_PI;
+      color *= lightmapIrradiance / M_PI * pbr_ambientVisibility;
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
         let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
@@ -17564,12 +17658,12 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       #ifdef USE_LIGHTS
       PBRInfo_setAmbientLight(&pbrInfo);
-      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor * pbr_ambientVisibility);
 
       for (var i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
           PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
-          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0));
         }
       }
 
@@ -17580,7 +17674,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
             lighting_getPointLight(i),
             distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
           );
-          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation);
         }
       }
 
@@ -17609,7 +17703,8 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       }
       #endif
 
-      #ifdef USE_IBL
+      let indirectBaseColor = color;
+#ifdef USE_IBL
       if (pbrMaterial.IBLenabled != 0) {
         color += getIBLContribution(pbrInfo, n, reflection);
       }
@@ -17617,6 +17712,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       // The pinned KHR_lightmap draft explicitly defines c_diff = (1 - metallic) * baseColor.
       color += baseColor.rgb * (1.0 - metallic) * lightmapIrradiance / M_PI;
+      color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
 
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
@@ -17915,7 +18011,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     PBRInfo_setAmbientLight(&pbrInfo);
     color += calculateMaterialLightColor(
       pbrInfo,
-      lighting.ambientColor,
+      lighting.ambientColor * pbr_ambientVisibility,
       clearcoatNormal,
       clearcoatFactor,
       clearcoatRoughness,
@@ -17931,7 +18027,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0),
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -17942,7 +18038,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0),
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -17961,7 +18057,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -17972,7 +18068,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -18041,6 +18137,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       }
     #endif
 
+    let indirectBaseColor = color;
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
     if (pbrMaterial.IBLenabled != 0) {
@@ -18075,6 +18172,8 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       (1.0 - diffuseTransmission) * baseLayerEnergy * lightmapIrradiance / M_PI;
 #endif
 
+    color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
+
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled != 0) {
@@ -18137,6 +18236,21 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
   return vec4<f32>(applySceneColorManagement(color), alpha);
 }
 
+// Depth-only passes use the same base-color alpha, vertex color and UV transform.
+fn pbr_discardMaskedFragment(vertexColor: vec4f) {
+#ifdef ALPHA_CUTOFF
+  var alpha = pbrMaterial.baseColorFactor.a * vertexColor.a;
+#ifdef HAS_BASECOLORMAP
+  alpha *= textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform)).a;
+#endif
+  if (alpha < pbrMaterial.alphaCutoff) {discard;}
+#endif
+}
+
+fn pbr_filterColorWithSpotShadows(vertexColor: vec4f, spotVisibility: vec4f) -> vec4f {
+  return pbr_filterColorWithShadows(vertexColor, 1.0, vec4f(1.0), spotVisibility);
+}
+
 fn pbr_filterColor(vertexColor: vec4<f32>) -> vec4<f32> {
   return pbr_filterColorWithSpotShadows(vertexColor, vec4f(1.0));
 }
@@ -19874,6 +19988,1755 @@ fn globeClouds_getColor(camera: vec3f, direction: vec3f) -> vec4f {
 `
     )
   };
+
+  // src/modules/lighting/prefiltered-environment/prefiltered-environment.ts
+  var GLSL_UNIFORMS = (
+    /* glsl */
+    `layout(std140) uniform pbrEnvironmentFilterUniforms {
+  int face;
+  float roughness;
+  int mode;
+  int sampleCount;
+  int sourceEncoding;
+} pbrEnvironmentFilter;
+
+uniform sampler2D pbrEnvironmentSource;
+`
+  );
+  var WGSL_UNIFORMS = (
+    /* wgsl */
+    `struct PBREnvironmentFilterUniforms {
+  face: i32,
+  roughness: f32,
+  mode: i32,
+  sampleCount: i32,
+  sourceEncoding: i32,
+};
+
+@group(0) @binding(auto) var<uniform> pbrEnvironmentFilter: PBREnvironmentFilterUniforms;
+@group(0) @binding(auto) var pbrEnvironmentSource: texture_2d<f32>;
+@group(0) @binding(auto) var pbrEnvironmentSourceSampler: sampler;
+`
+  );
+  var pbrEnvironmentFilter = {
+    name: "pbrEnvironmentFilter",
+    bindingLayout: [
+      { name: "pbrEnvironmentFilter", group: 0 },
+      { name: "pbrEnvironmentSource", group: 0 }
+    ],
+    fs: GLSL_UNIFORMS,
+    source: WGSL_UNIFORMS,
+    getUniforms: (properties) => properties,
+    uniformTypes: {
+      face: "i32",
+      roughness: "f32",
+      mode: "i32",
+      sampleCount: "i32",
+      sourceEncoding: "i32"
+    },
+    defaultUniforms: {
+      face: 0,
+      roughness: 0,
+      mode: 0,
+      sampleCount: 64,
+      sourceEncoding: 0
+    }
+  };
+  var PBR_ENVIRONMENT_FRAGMENT_GLSL = (
+    /* glsl */
+    `#version 300 es
+precision highp float;
+precision highp int;
+
+in vec2 uv;
+out vec4 fragmentColor;
+
+const float ENVIRONMENT_PI = 3.141592653589793;
+
+vec2 getEnvironmentHammersley(uint index, uint sampleCount)
+{
+  uint reversedBits = (index << 16u) | (index >> 16u);
+  reversedBits = ((reversedBits & 0x55555555u) << 1u) |
+    ((reversedBits & 0xAAAAAAAAu) >> 1u);
+  reversedBits = ((reversedBits & 0x33333333u) << 2u) |
+    ((reversedBits & 0xCCCCCCCCu) >> 2u);
+  reversedBits = ((reversedBits & 0x0F0F0F0Fu) << 4u) |
+    ((reversedBits & 0xF0F0F0F0u) >> 4u);
+  reversedBits = ((reversedBits & 0x00FF00FFu) << 8u) |
+    ((reversedBits & 0xFF00FF00u) >> 8u);
+  return vec2(
+    float(index) / float(sampleCount),
+    float(reversedBits) * 2.3283064365386963e-10
+  );
+}
+
+vec3 getEnvironmentFaceDirection(int face, vec2 textureCoordinate)
+{
+  vec2 coordinate = textureCoordinate * 2.0 - 1.0;
+  if (face == 0) return normalize(vec3(1.0, -coordinate.y, -coordinate.x));
+  if (face == 1) return normalize(vec3(-1.0, -coordinate.y, coordinate.x));
+  if (face == 2) return normalize(vec3(coordinate.x, 1.0, coordinate.y));
+  if (face == 3) return normalize(vec3(coordinate.x, -1.0, -coordinate.y));
+  if (face == 4) return normalize(vec3(coordinate.x, -coordinate.y, 1.0));
+  return normalize(vec3(-coordinate.x, -coordinate.y, -1.0));
+}
+
+mat3 getEnvironmentTangentBasis(vec3 normal)
+{
+  vec3 up = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+  vec3 tangent = normalize(cross(up, normal));
+  return mat3(tangent, cross(normal, tangent), normal);
+}
+
+vec3 sampleEnvironmentDirection(vec3 direction)
+{
+  vec3 normalizedDirection = normalize(direction);
+  vec2 textureCoordinate = vec2(
+    atan(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,
+    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI
+  );
+  vec3 color = texture(pbrEnvironmentSource, textureCoordinate).rgb;
+  if (pbrEnvironmentFilter.sourceEncoding == 1) {
+    vec3 lower = color / 12.92;
+    vec3 upper = pow((color + 0.055) / 1.055, vec3(2.4));
+    color = mix(lower, upper, step(vec3(0.04045), color));
+  }
+  return color;
+}
+
+vec3 importanceSampleEnvironment(vec2 sequence, vec3 normal, float roughness)
+{
+  float alpha = max(roughness * roughness, 0.0001);
+  float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+  float cosine = sqrt(
+    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)
+  );
+  float sine = sqrt(max(1.0 - cosine * cosine, 0.0));
+  vec3 halfVector = vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine);
+  return normalize(getEnvironmentTangentBasis(normal) * halfVector);
+}
+
+float getEnvironmentGeometry(float normalDotDirection, float roughness)
+{
+  float alpha = roughness * roughness;
+  float factor = alpha * 0.5;
+  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);
+}
+
+vec2 integrateEnvironmentBRDF(vec2 textureCoordinate, int sampleCount)
+{
+  float normalDotView = max(textureCoordinate.x, 0.001);
+  float roughness = 1.0 - textureCoordinate.y;
+  vec3 viewDirection = vec3(sqrt(max(1.0 - normalDotView * normalDotView, 0.0)), 0.0, normalDotView);
+  vec2 integration = vec2(0.0);
+
+  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {
+    if (sampleIndex >= sampleCount) break;
+    vec3 halfVector = importanceSampleEnvironment(
+      getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount)),
+      vec3(0.0, 0.0, 1.0),
+      roughness
+    );
+    vec3 lightDirection = normalize(2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection);
+    float normalDotLight = max(lightDirection.z, 0.0);
+    float normalDotHalf = max(halfVector.z, 0.0);
+    float viewDotHalf = max(dot(viewDirection, halfVector), 0.0);
+    if (normalDotLight > 0.0) {
+      float visibility = getEnvironmentGeometry(normalDotView, roughness) *
+        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /
+        max(normalDotHalf * normalDotView, 0.0001);
+      float fresnel = pow(1.0 - viewDotHalf, 5.0);
+      integration += vec2(1.0 - fresnel, fresnel) * visibility;
+    }
+  }
+  return integration / float(sampleCount);
+}
+
+vec3 integrateEnvironmentDirection(vec3 normal, int sampleCount)
+{
+  vec3 accumulatedColor = vec3(0.0);
+  float accumulatedWeight = 0.0;
+
+  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {
+    if (sampleIndex >= sampleCount) break;
+    vec2 sequence = getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount));
+    vec3 direction;
+    float sampleWeight;
+
+    if (pbrEnvironmentFilter.mode == 1) {
+      float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+      float cosine = sqrt(1.0 - sequence.y);
+      float sine = sqrt(sequence.y);
+      direction = normalize(
+        getEnvironmentTangentBasis(normal) *
+        vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine)
+      );
+      sampleWeight = 1.0;
+    } else {
+      vec3 halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);
+      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);
+      sampleWeight = max(dot(normal, direction), 0.0);
+    }
+
+    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;
+    accumulatedWeight += sampleWeight;
+  }
+
+  return accumulatedColor / max(accumulatedWeight, 0.0001);
+}
+
+void main(void)
+{
+  int sampleCount = max(pbrEnvironmentFilter.sampleCount, 1);
+  if (pbrEnvironmentFilter.mode == 2) {
+    fragmentColor = vec4(integrateEnvironmentBRDF(uv, sampleCount), 0.0, 1.0);
+    return;
+  }
+
+  vec3 direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, uv);
+  fragmentColor = vec4(integrateEnvironmentDirection(direction, sampleCount), 1.0);
+}
+`
+  );
+  var PBR_ENVIRONMENT_FRAGMENT_WGSL = (
+    /* wgsl */
+    `const ENVIRONMENT_PI: f32 = 3.141592653589793;
+
+fn getEnvironmentHammersley(index: u32, sampleCount: u32) -> vec2f {
+  return vec2f(f32(index) / f32(sampleCount), f32(reverseBits(index)) * 2.3283064365386963e-10);
+}
+
+fn getEnvironmentFaceDirection(face: i32, textureCoordinate: vec2f) -> vec3f {
+  let coordinate = textureCoordinate * 2.0 - 1.0;
+  if (face == 0) { return normalize(vec3f(1.0, -coordinate.y, -coordinate.x)); }
+  if (face == 1) { return normalize(vec3f(-1.0, -coordinate.y, coordinate.x)); }
+  if (face == 2) { return normalize(vec3f(coordinate.x, 1.0, coordinate.y)); }
+  if (face == 3) { return normalize(vec3f(coordinate.x, -1.0, -coordinate.y)); }
+  if (face == 4) { return normalize(vec3f(coordinate.x, -coordinate.y, 1.0)); }
+  return normalize(vec3f(-coordinate.x, -coordinate.y, -1.0));
+}
+
+fn getEnvironmentTangentBasis(normal: vec3f) -> mat3x3f {
+  var up = vec3f(1.0, 0.0, 0.0);
+  if (abs(normal.z) < 0.999) {
+    up = vec3f(0.0, 0.0, 1.0);
+  }
+  let tangent = normalize(cross(up, normal));
+  return mat3x3f(tangent, cross(normal, tangent), normal);
+}
+
+fn sampleEnvironmentDirection(direction: vec3f) -> vec3f {
+  let normalizedDirection = normalize(direction);
+  let textureCoordinate = vec2f(
+    atan2(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,
+    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI
+  );
+  var color = textureSampleLevel(
+    pbrEnvironmentSource,
+    pbrEnvironmentSourceSampler,
+    textureCoordinate,
+    0.0
+  ).rgb;
+  if (pbrEnvironmentFilter.sourceEncoding == 1) {
+    let lower = color / 12.92;
+    let upper = pow((color + 0.055) / 1.055, vec3f(2.4));
+    color = mix(lower, upper, step(vec3f(0.04045), color));
+  }
+  return color;
+}
+
+fn importanceSampleEnvironment(sequence: vec2f, normal: vec3f, roughness: f32) -> vec3f {
+  let alpha = max(roughness * roughness, 0.0001);
+  let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+  let cosine = sqrt(
+    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)
+  );
+  let sine = sqrt(max(1.0 - cosine * cosine, 0.0));
+  let halfVector = vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine);
+  return normalize(getEnvironmentTangentBasis(normal) * halfVector);
+}
+
+fn getEnvironmentGeometry(normalDotDirection: f32, roughness: f32) -> f32 {
+  let alpha = roughness * roughness;
+  let factor = alpha * 0.5;
+  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);
+}
+
+fn integrateEnvironmentBRDF(textureCoordinate: vec2f, sampleCount: u32) -> vec2f {
+  let normalDotView = max(textureCoordinate.x, 0.001);
+  let roughness = 1.0 - textureCoordinate.y;
+  let viewDirection = vec3f(
+    sqrt(max(1.0 - normalDotView * normalDotView, 0.0)),
+    0.0,
+    normalDotView
+  );
+  var integration = vec2f(0.0);
+
+  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {
+    let halfVector = importanceSampleEnvironment(
+      getEnvironmentHammersley(sampleIndex, sampleCount),
+      vec3f(0.0, 0.0, 1.0),
+      roughness
+    );
+    let lightDirection = normalize(
+      2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection
+    );
+    let normalDotLight = max(lightDirection.z, 0.0);
+    let normalDotHalf = max(halfVector.z, 0.0);
+    let viewDotHalf = max(dot(viewDirection, halfVector), 0.0);
+    if (normalDotLight > 0.0) {
+      let visibility = getEnvironmentGeometry(normalDotView, roughness) *
+        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /
+        max(normalDotHalf * normalDotView, 0.0001);
+      let fresnel = pow(1.0 - viewDotHalf, 5.0);
+      integration += vec2f(1.0 - fresnel, fresnel) * visibility;
+    }
+  }
+  return integration / f32(sampleCount);
+}
+
+fn integrateEnvironmentDirection(normal: vec3f, sampleCount: u32) -> vec3f {
+  var accumulatedColor = vec3f(0.0);
+  var accumulatedWeight = 0.0;
+
+  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {
+    let sequence = getEnvironmentHammersley(sampleIndex, sampleCount);
+    var direction: vec3f;
+    var sampleWeight: f32;
+
+    if (pbrEnvironmentFilter.mode == 1) {
+      let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+      let cosine = sqrt(1.0 - sequence.y);
+      let sine = sqrt(sequence.y);
+      direction = normalize(
+        getEnvironmentTangentBasis(normal) *
+        vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine)
+      );
+      sampleWeight = 1.0;
+    } else {
+      let halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);
+      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);
+      sampleWeight = max(dot(normal, direction), 0.0);
+    }
+
+    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;
+    accumulatedWeight += sampleWeight;
+  }
+  return accumulatedColor / max(accumulatedWeight, 0.0001);
+}
+
+@fragment
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
+  // ClipSpace UVs increase upward; WebGPU texture rows increase downward.
+  let textureCoordinate = vec2f(inputs.uv.x, 1.0 - inputs.uv.y);
+  let sampleCount = u32(max(pbrEnvironmentFilter.sampleCount, 1));
+  if (pbrEnvironmentFilter.mode == 2) {
+    return vec4f(integrateEnvironmentBRDF(textureCoordinate, sampleCount), 0.0, 1.0);
+  }
+
+  let direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, textureCoordinate);
+  return vec4f(integrateEnvironmentDirection(direction, sampleCount), 1.0);
+}
+`
+  );
+
+  // src/modules/lighting/shadow/shadow-glsl.ts
+  var SHADOW_GLSL = (
+    /* glsl */
+    `
+precision highp sampler2DArray;
+struct DirectionalShadowLightUniform {
+  vec3 direction;
+  float strength;
+  float normalBias;
+  float sourceAngularRadius;
+  float cascadeBlendFraction;
+  float farFadeFraction;
+  float shadowDistance;
+};
+struct SpotShadowLightUniform {
+  vec3 position;
+  float range;
+  vec3 direction;
+  float outerConeCos;
+  float sourceRadius;
+  float normalBias;
+  float strength;
+  float nearPlane;
+};
+struct PointShadowLightUniform {
+  vec3 position;
+  float range;
+  float sourceRadius;
+  float normalBias;
+  float strength;
+  float nearPlane;
+};
+layout(std140) uniform shadowUniforms {
+  int directionalLightCount;
+  int spotLightCount;
+  int pointLightCount;
+  int cascadeCount;
+  int blockerSampleCount;
+  int filterSampleCount;
+  vec4 cascadeSplits;
+  mat4 directionalViewProjectionMatrices[4];
+  mat4 spotViewProjectionMatrices[4];
+  mat4 pointViewProjectionMatrices[24];
+  DirectionalShadowLightUniform directionalLights[1];
+  SpotShadowLightUniform spotLights[4];
+  PointShadowLightUniform pointLights[4];
+} shadow;
+uniform sampler2DArray directionalShadowTexture;
+uniform sampler2DArray spotShadowTexture;
+uniform sampler2DArray pointShadowTexture;
+const float SHADOW_PI = 3.141592653589793;
+float shadow_hash(vec3 position) {
+  return fract(sin(dot(position, vec3(12.9898, 78.233, 37.719))) * 43758.5453);
+}
+vec2 shadow_diskSample(int index, int count, float rotation) {
+  float fraction = (float(index) + 0.5) / max(float(count), 1.0);
+  float angle = float(index) * 2.39996323 + rotation;
+  return sqrt(fraction) * vec2(cos(angle), sin(angle));
+}
+vec3 shadow_project(mat4 matrix, vec3 worldPosition) {
+  vec4 clip = matrix * vec4(worldPosition, 1.0);
+  vec3 projected = clip.xyz / max(abs(clip.w), 0.00001);
+  // Shared matrices retain [0,1] depth; WebGL texture rows start at the bottom.
+  return vec3(projected.xy * 0.5 + 0.5, projected.z);
+}
+bool shadow_validProjection(vec3 projected) {
+  return all(greaterThanEqual(projected, vec3(0.0))) && all(lessThanEqual(projected, vec3(1.0)));
+}
+// Bilinear interpolation of four depth comparisons matches a hardware 2x2 PCF lookup.
+float shadow_compare(sampler2DArray shadowMap, vec2 coordinate, int layer, float reference) {
+  ivec2 dimensions = textureSize(shadowMap, 0).xy;
+  vec2 position = coordinate * vec2(dimensions) - 0.5;
+  ivec2 base = ivec2(floor(position));
+  vec2 fraction = fract(position);
+  ivec2 maximum = dimensions - 1;
+  float lowerLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base, ivec2(0), maximum), layer), 0).r);
+  float lowerRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,0), ivec2(0), maximum), layer), 0).r);
+  float upperLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(0,1), ivec2(0), maximum), layer), 0).r);
+  float upperRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,1), ivec2(0), maximum), layer), 0).r);
+  return mix(mix(lowerLeft, lowerRight, fraction.x), mix(upperLeft, upperRight, fraction.x), fraction.y);
+}
+float shadow_arrayPCSS(sampler2DArray shadowMap, int layer, vec3 projected, float searchRadius, float rotation, float penumbraScale) {
+  if (!shadow_validProjection(projected)) return 1.0;
+  float texel = 1.0 / float(textureSize(shadowMap, 0).x);
+  searchRadius = max(texel, searchRadius);
+  float blockerDepth = 0.0;
+  float blockerCount = 0.0;
+  for (int index = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) break;
+    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius, vec2(0.0), vec2(1.0));
+    float depth = textureLod(shadowMap, vec3(coordinate, float(layer)), 0.0).r;
+    if (depth < projected.z) { blockerDepth += depth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) return 1.0;
+  float averageBlocker = blockerDepth / blockerCount;
+  float penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  float radius = max(texel, searchRadius * (1.0 + penumbra * penumbraScale));
+  float visibility = 0.0;
+  for (int index = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) break;
+    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius, vec2(0.0), vec2(1.0));
+    visibility += shadow_compare(shadowMap, coordinate, layer, projected.z);
+  }
+  return visibility / max(float(shadow.filterSampleCount), 1.0);
+}
+int shadow_directionalCascadeIndex(float viewDepth) {
+  int cascadeIndex = 0;
+  for (int index = 0; index < 4; index++) {
+    if (index >= shadow.cascadeCount) break;
+    cascadeIndex = index;
+    if (viewDepth <= shadow.cascadeSplits[index]) break;
+  }
+  return cascadeIndex;
+}
+int shadow_getDirectionalCascadeIndex(float viewDepth) {
+  return shadow.directionalLightCount == 0 ? -1 : shadow_directionalCascadeIndex(viewDepth);
+}
+float shadow_directionalPCSS(int cascadeIndex, vec3 worldPosition, float viewDepth) {
+  DirectionalShadowLightUniform light = shadow.directionalLights[0];
+  return shadow_arrayPCSS(directionalShadowTexture, cascadeIndex,
+    shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition),
+    light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001),
+    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 18.0);
+}
+float shadow_getDirectionalFactor(vec3 worldPosition, vec3 worldNormal, float viewDepth) {
+  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) return 1.0;
+  DirectionalShadowLightUniform light = shadow.directionalLights[0];
+  if (viewDepth >= light.shadowDistance) return 1.0;
+  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;
+  int cascadeIndex = shadow_directionalCascadeIndex(viewDepth);
+  float visibility = shadow_directionalPCSS(cascadeIndex, position, viewDepth);
+  if (cascadeIndex + 1 < shadow.cascadeCount) {
+    float cascadeStart = cascadeIndex > 0 ? shadow.cascadeSplits[cascadeIndex - 1] : 0.0;
+    float cascadeEnd = shadow.cascadeSplits[cascadeIndex];
+    float blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);
+    float blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);
+    if (blend > 0.0) visibility = mix(visibility, shadow_directionalPCSS(cascadeIndex + 1, position, viewDepth), blend);
+  }
+  float fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);
+  visibility = mix(visibility, 1.0, smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth));
+  return mix(1.0, visibility, light.strength);
+}
+float shadow_getSpotFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {
+  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) return 1.0;
+  SpotShadowLightUniform light = shadow.spotLights[lightIndex];
+  vec3 fromLight = worldPosition - light.position;
+  float distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || dot(normalize(fromLight), normalize(light.direction)) < light.outerConeCos) return 1.0;
+  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;
+  float visibility = shadow_arrayPCSS(spotShadowTexture, lightIndex,
+    shadow_project(shadow.spotViewProjectionMatrices[lightIndex], position),
+    light.sourceRadius / max(distanceToLight, 0.001) * 0.5,
+    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 16.0);
+  return mix(1.0, visibility, light.strength);
+}
+float shadow_pointReferenceDepth(float majorDistance, float nearPlane, float farPlane) {
+  return farPlane / (farPlane - nearPlane) - (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);
+}
+vec3 shadow_pointCoordinate(int lightIndex, vec3 direction) {
+  vec3 magnitude = abs(direction);
+  int face = magnitude.x >= magnitude.y && magnitude.x >= magnitude.z ? (direction.x >= 0.0 ? 0 : 1)
+    : magnitude.y >= magnitude.z ? (direction.y >= 0.0 ? 2 : 3) : (direction.z >= 0.0 ? 4 : 5);
+  PointShadowLightUniform light = shadow.pointLights[lightIndex];
+  vec3 projected = shadow_project(shadow.pointViewProjectionMatrices[lightIndex * 6 + face], light.position + direction * light.range * 0.5);
+  return vec3(projected.xy, float(lightIndex * 6 + face));
+}
+float shadow_getPointFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {
+  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) return 1.0;
+  PointShadowLightUniform light = shadow.pointLights[lightIndex];
+  vec3 fromLight = worldPosition + normalize(worldNormal) * light.normalBias - light.position;
+  float distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) return 1.0;
+  vec3 direction = normalize(fromLight);
+  float referenceDepth = shadow_pointReferenceDepth(max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z)), light.nearPlane, light.range);
+  vec3 reference = abs(direction.y) > 0.99 ? vec3(0,0,1) : vec3(0,1,0);
+  vec3 tangent = normalize(cross(direction, reference));
+  vec3 bitangent = normalize(cross(direction, tangent));
+  float searchRadius = light.sourceRadius / max(distanceToLight, 0.001);
+  float rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  float blockerDepth = 0.0;
+  float blockerCount = 0.0;
+  for (int index = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) break;
+    vec2 disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));
+    float depth = textureLod(pointShadowTexture, coordinate, 0.0).r;
+    if (depth < referenceDepth) { blockerDepth += depth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) return 1.0;
+  float averageBlocker = blockerDepth / blockerCount;
+  float penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  float radius = searchRadius * (1.0 + penumbra * 12.0);
+  float visibility = 0.0;
+  for (int index = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) break;
+    vec2 disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius;
+    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));
+    visibility += shadow_compare(pointShadowTexture, coordinate.xy, int(coordinate.z), referenceDepth);
+  }
+  return mix(1.0, visibility / max(float(shadow.filterSampleCount), 1.0), light.strength);
+}
+`
+  );
+
+  // src/modules/lighting/shadow/shadow.ts
+  var MAX_CASCADES = 4;
+  var MAX_SPOT_LIGHTS = 4;
+  var MAX_POINT_LIGHTS = 4;
+  var MAX_POINT_MATRICES = 24;
+  var DIRECTIONAL_LIGHT_UNIFORM_TYPE = {
+    direction: "vec3<f32>",
+    strength: "f32",
+    normalBias: "f32",
+    sourceAngularRadius: "f32",
+    cascadeBlendFraction: "f32",
+    farFadeFraction: "f32",
+    shadowDistance: "f32"
+  };
+  var SPOT_LIGHT_UNIFORM_TYPE = {
+    position: "vec3<f32>",
+    range: "f32",
+    direction: "vec3<f32>",
+    outerConeCos: "f32",
+    sourceRadius: "f32",
+    normalBias: "f32",
+    strength: "f32",
+    nearPlane: "f32"
+  };
+  var POINT_LIGHT_UNIFORM_TYPE = {
+    position: "vec3<f32>",
+    range: "f32",
+    sourceRadius: "f32",
+    normalBias: "f32",
+    strength: "f32",
+    nearPlane: "f32"
+  };
+  var SHADOW_WGSL = (
+    /* wgsl */
+    `const SHADOW_PI: f32 = 3.141592653589793;
+
+struct DirectionalShadowLightUniform {
+  direction: vec3f,
+  strength: f32,
+  normalBias: f32,
+  sourceAngularRadius: f32,
+  cascadeBlendFraction: f32,
+  farFadeFraction: f32,
+  shadowDistance: f32,
+};
+
+struct SpotShadowLightUniform {
+  position: vec3f,
+  range: f32,
+  direction: vec3f,
+  outerConeCos: f32,
+  sourceRadius: f32,
+  normalBias: f32,
+  strength: f32,
+  nearPlane: f32,
+};
+
+struct PointShadowLightUniform {
+  position: vec3f,
+  range: f32,
+  sourceRadius: f32,
+  normalBias: f32,
+  strength: f32,
+  nearPlane: f32,
+};
+
+struct ShadowUniforms {
+  directionalLightCount: i32,
+  spotLightCount: i32,
+  pointLightCount: i32,
+  cascadeCount: i32,
+  blockerSampleCount: i32,
+  filterSampleCount: i32,
+  cascadeSplits: vec4f,
+  directionalViewProjectionMatrices: array<mat4x4f, 4>,
+  spotViewProjectionMatrices: array<mat4x4f, 4>,
+  pointViewProjectionMatrices: array<mat4x4f, 24>,
+  directionalLights: array<DirectionalShadowLightUniform, 1>,
+  spotLights: array<SpotShadowLightUniform, 4>,
+  pointLights: array<PointShadowLightUniform, 4>,
+};
+
+@group(2) @binding(auto) var<uniform> shadow: ShadowUniforms;
+@group(2) @binding(auto) var directionalShadowTexture: texture_depth_2d_array;
+@group(2) @binding(auto) var spotShadowTexture: texture_depth_2d_array;
+@group(2) @binding(auto) var pointShadowTexture: texture_depth_cube_array;
+@group(2) @binding(auto) var directionalShadowTextureSampler: sampler;
+@group(2) @binding(auto) var shadowComparisonSampler: sampler_comparison;
+
+fn shadow_hash(position: vec3f) -> f32 {
+  return fract(sin(dot(position, vec3f(12.9898, 78.233, 37.719))) * 43758.5453);
+}
+
+fn shadow_diskSample(index: i32, count: i32, rotation: f32) -> vec2f {
+  let fraction = (f32(index) + 0.5) / max(f32(count), 1.0);
+  let angle = f32(index) * 2.39996323 + rotation;
+  return sqrt(fraction) * vec2f(cos(angle), sin(angle));
+}
+
+fn shadow_project(matrix: mat4x4f, worldPosition: vec3f) -> vec3f {
+  let clip = matrix * vec4f(worldPosition, 1.0);
+  let ndc = clip.xyz / max(abs(clip.w), 0.00001);
+  return vec3f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z);
+}
+
+fn shadow_validProjection(projected: vec3f) -> bool {
+  return all(projected.xy >= vec2f(0.0)) && all(projected.xy <= vec2f(1.0)) &&
+    projected.z >= 0.0 && projected.z <= 1.0;
+}
+
+fn shadow_directionalCascadeIndex(viewDepth: f32) -> i32 {
+  var cascadeIndex = 0;
+  for (var index: i32 = 0; index < 4; index++) {
+    if (index >= shadow.cascadeCount) { break; }
+    cascadeIndex = index;
+    if (viewDepth <= shadow.cascadeSplits[index]) { break; }
+  }
+  return cascadeIndex;
+}
+
+fn shadow_getDirectionalCascadeIndex(viewDepth: f32) -> i32 {
+  if (shadow.directionalLightCount == 0) { return -1; }
+  return shadow_directionalCascadeIndex(viewDepth);
+}
+
+fn shadow_directionalPCSS(cascadeIndex: i32, worldPosition: vec3f, viewDepth: f32) -> f32 {
+  let projected = shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition);
+  if (!shadow_validProjection(projected)) { return 1.0; }
+  let dimensions = vec2f(textureDimensions(directionalShadowTexture));
+  let texel = 1.0 / dimensions;
+  let light = shadow.directionalLights[0];
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  let searchRadius = max(texel.x, light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001));
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDepth = textureSampleLevel(
+      directionalShadowTexture,
+      directionalShadowTextureSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      cascadeIndex,
+      0
+    );
+    if (sampleDepth < projected.z) {
+      blockerDepth += sampleDepth;
+      blockerCount += 1.0;
+    }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 18.0));
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    visibility += textureSampleCompareLevel(
+      directionalShadowTexture,
+      shadowComparisonSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      cascadeIndex,
+      projected.z
+    );
+  }
+  return visibility / max(f32(shadow.filterSampleCount), 1.0);
+}
+
+fn shadow_getDirectionalFactor(worldPosition: vec3f, worldNormal: vec3f, viewDepth: f32) -> f32 {
+  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) { return 1.0; }
+  let light = shadow.directionalLights[0];
+  if (viewDepth >= light.shadowDistance) { return 1.0; }
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  let cascadeIndex = shadow_directionalCascadeIndex(viewDepth);
+  var visibility = shadow_directionalPCSS(cascadeIndex, biasedPosition, viewDepth);
+  if (cascadeIndex + 1 < shadow.cascadeCount) {
+    var cascadeStart = 0.0;
+    if (cascadeIndex > 0) { cascadeStart = shadow.cascadeSplits[cascadeIndex - 1]; }
+    let cascadeEnd = shadow.cascadeSplits[cascadeIndex];
+    let blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);
+    let blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);
+    if (blend > 0.0) {
+      visibility = mix(
+        visibility,
+        shadow_directionalPCSS(cascadeIndex + 1, biasedPosition, viewDepth),
+        blend
+      );
+    }
+  }
+  let fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);
+  let farFade = smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth);
+  visibility = mix(visibility, 1.0, farFade);
+  return mix(1.0, visibility, light.strength);
+}
+
+fn shadow_spotPCSS(lightIndex: i32, worldPosition: vec3f) -> f32 {
+  let projected = shadow_project(shadow.spotViewProjectionMatrices[lightIndex], worldPosition);
+  if (!shadow_validProjection(projected)) { return 1.0; }
+  let light = shadow.spotLights[lightIndex];
+  let dimensions = vec2f(textureDimensions(spotShadowTexture));
+  let texel = 1.0 / dimensions;
+  let distanceToLight = length(worldPosition - light.position);
+  let searchRadius = max(texel.x, light.sourceRadius / max(distanceToLight, 0.001) * 0.5);
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDepth = textureSampleLevel(
+      spotShadowTexture,
+      directionalShadowTextureSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      lightIndex,
+      0
+    );
+    if (sampleDepth < projected.z) { blockerDepth += sampleDepth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 16.0));
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    visibility += textureSampleCompareLevel(
+      spotShadowTexture,
+      shadowComparisonSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      lightIndex,
+      projected.z
+    );
+  }
+  return visibility / max(f32(shadow.filterSampleCount), 1.0);
+}
+
+fn shadow_getSpotFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {
+  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) { return 1.0; }
+  let light = shadow.spotLights[lightIndex];
+  let fromLight = worldPosition - light.position;
+  let distanceToLight = length(fromLight);
+  let coneCos = dot(normalize(fromLight), normalize(light.direction));
+  if (distanceToLight >= light.range || coneCos < light.outerConeCos) { return 1.0; }
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  return mix(1.0, shadow_spotPCSS(lightIndex, biasedPosition), light.strength);
+}
+
+fn shadow_pointReferenceDepth(majorDistance: f32, nearPlane: f32, farPlane: f32) -> f32 {
+  // Match the cube-face projection and stored WebGPU depth in [0, 1].
+  return farPlane / (farPlane - nearPlane) -
+    (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);
+}
+
+fn shadow_pointBasis(direction: vec3f) -> mat2x3f {
+  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(direction.y) > 0.99);
+  let tangent = normalize(cross(direction, reference));
+  return mat2x3f(tangent, normalize(cross(direction, tangent)));
+}
+
+fn shadow_getPointFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {
+  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) { return 1.0; }
+  let light = shadow.pointLights[lightIndex];
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  let fromLight = biasedPosition - light.position;
+  let distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) { return 1.0; }
+  let direction = normalize(fromLight);
+  let majorDistance = max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z));
+  let referenceDepth = shadow_pointReferenceDepth(majorDistance, light.nearPlane, light.range);
+  let searchRadius = light.sourceRadius / max(distanceToLight, 0.001);
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  let basis = shadow_pointBasis(direction);
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);
+    let sampleDepth = textureSampleLevel(
+      pointShadowTexture,
+      directionalShadowTextureSampler,
+      sampleDirection,
+      lightIndex,
+      0
+    );
+    if (sampleDepth < referenceDepth) { blockerDepth += sampleDepth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = searchRadius * (1.0 + penumbra * 12.0);
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);
+    visibility += textureSampleCompareLevel(
+      pointShadowTexture,
+      shadowComparisonSampler,
+      sampleDirection,
+      lightIndex,
+      referenceDepth
+    );
+  }
+  visibility /= max(f32(shadow.filterSampleCount), 1.0);
+  return mix(1.0, visibility, light.strength);
+}
+`
+  );
+  var shadow = {
+    name: "shadow",
+    source: SHADOW_WGSL,
+    fs: SHADOW_GLSL,
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+      directionalLightCount: "i32",
+      spotLightCount: "i32",
+      pointLightCount: "i32",
+      cascadeCount: "i32",
+      blockerSampleCount: "i32",
+      filterSampleCount: "i32",
+      cascadeSplits: "vec4<f32>",
+      directionalViewProjectionMatrices: ["mat4x4<f32>", MAX_CASCADES],
+      spotViewProjectionMatrices: ["mat4x4<f32>", MAX_SPOT_LIGHTS],
+      pointViewProjectionMatrices: ["mat4x4<f32>", MAX_POINT_MATRICES],
+      directionalLights: [DIRECTIONAL_LIGHT_UNIFORM_TYPE, 1],
+      spotLights: [SPOT_LIGHT_UNIFORM_TYPE, MAX_SPOT_LIGHTS],
+      pointLights: [POINT_LIGHT_UNIFORM_TYPE, MAX_POINT_LIGHTS]
+    },
+    bindingLayout: [
+      { name: "shadow", group: 2 },
+      { name: "directionalShadowTexture", group: 2 },
+      { name: "spotShadowTexture", group: 2 },
+      { name: "pointShadowTexture", group: 2 },
+      { name: "shadowComparisonSampler", group: 2 }
+    ],
+    getUniforms(props) {
+      if (!props.directionalLights || !props.spotLights || !props.pointLights || !props.cascadeSplits || !props.directionalViewProjectionMatrices || !props.spotViewProjectionMatrices || !props.pointViewProjectionMatrices || !props.directionalShadowTexture || !props.spotShadowTexture || !props.pointShadowTexture || !props.nonFilteringSampler || !props.comparisonSampler) {
+        return {};
+      }
+      return {
+        directionalLightCount: props.directionalLights.length,
+        spotLightCount: props.spotLights.length,
+        pointLightCount: props.pointLights.length,
+        cascadeCount: props.cascadeCount,
+        blockerSampleCount: props.blockerSampleCount,
+        filterSampleCount: props.filterSampleCount,
+        cascadeSplits: props.cascadeSplits,
+        directionalViewProjectionMatrices: props.directionalViewProjectionMatrices,
+        spotViewProjectionMatrices: props.spotViewProjectionMatrices,
+        pointViewProjectionMatrices: props.pointViewProjectionMatrices,
+        directionalLights: padDirectionalLights(props.directionalLights),
+        spotLights: padSpotLights(props.spotLights),
+        pointLights: padPointLights(props.pointLights),
+        directionalShadowTexture: props.directionalShadowTexture,
+        spotShadowTexture: props.spotShadowTexture,
+        pointShadowTexture: props.pointShadowTexture,
+        ...props.directionalShadowTexture.device.type === "webgpu" ? { shadowComparisonSampler: props.comparisonSampler } : {}
+      };
+    }
+  };
+  function padDirectionalLights(lights) {
+    const light = lights[0];
+    return [
+      light ? {
+        direction: light.direction,
+        strength: light.strength ?? 1,
+        normalBias: light.normalBias ?? 0.04,
+        sourceAngularRadius: light.sourceAngularRadius ?? 465e-5,
+        cascadeBlendFraction: light.cascadeBlendFraction ?? 0.1,
+        farFadeFraction: light.farFadeFraction ?? 0.1,
+        shadowDistance: light.shadowDistance ?? 1
+      } : {
+        direction: [0, 1, 0],
+        strength: 0,
+        normalBias: 0,
+        sourceAngularRadius: 0,
+        cascadeBlendFraction: 0,
+        farFadeFraction: 0,
+        shadowDistance: 1
+      }
+    ];
+  }
+  function padSpotLights(lights) {
+    return padArray(
+      lights.map((light) => ({
+        position: light.position,
+        range: light.range,
+        direction: light.direction,
+        outerConeCos: Math.cos(light.outerConeAngle),
+        sourceRadius: light.sourceRadius ?? 0.2,
+        normalBias: light.normalBias ?? 0.025,
+        strength: light.strength ?? 1,
+        nearPlane: light.nearPlane ?? 0.1
+      })),
+      MAX_SPOT_LIGHTS,
+      {
+        position: [0, 0, 0],
+        range: 1,
+        direction: [0, -1, 0],
+        outerConeCos: 1,
+        sourceRadius: 0,
+        normalBias: 0,
+        strength: 0,
+        nearPlane: 0.1
+      }
+    );
+  }
+  function padPointLights(lights) {
+    return padArray(
+      lights.map((light) => ({
+        position: light.position,
+        range: light.range,
+        sourceRadius: light.sourceRadius ?? 0.2,
+        normalBias: light.normalBias ?? 0.025,
+        strength: light.strength ?? 1,
+        nearPlane: light.nearPlane ?? 0.1
+      })),
+      MAX_POINT_LIGHTS,
+      {
+        position: [0, 0, 0],
+        range: 1,
+        sourceRadius: 0,
+        normalBias: 0,
+        strength: 0,
+        nearPlane: 0.1
+      }
+    );
+  }
+  function padArray(values, length, fallback) {
+    const result = values.slice(0, length);
+    while (result.length < length) {
+      result.push(fallback);
+    }
+    return result;
+  }
+
+  // src/modules/lighting/pbr-shadow/pbr-shadow.ts
+  var pbrShadow = {
+    name: "pbrShadow",
+    dependencies: [pbrMaterial, shadow],
+    bindingLayout: [{ name: "pbrShadow", group: 0 }],
+    uniformTypes: { viewMatrix: "mat4x4<f32>", enabled: "i32" },
+    defaultUniforms: {
+      viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+      enabled: 1
+    },
+    getUniforms(properties = {}) {
+      return {
+        ...properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {},
+        ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) }
+      };
+    },
+    source: (
+      /* wgsl */
+      `
+struct PBRShadowUniforms {
+  viewMatrix: mat4x4f,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrShadow: PBRShadowUniforms;
+fn pbrShadow_filterColorWithDirectionalContact(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f, contactVisibility: f32) -> vec4f {
+  var directionalVisibility = 1.0;
+  var pointVisibility = vec4f(1.0);
+  var spotVisibility = vec4f(1.0);
+  if (pbrShadow.enabled != 0) {
+    let normal = normalize(worldNormal);
+    let viewDepth = -(pbrShadow.viewMatrix * vec4f(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (var index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+}
+fn pbrShadow_filterColor(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f) -> vec4f {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform pbrShadowUniforms {
+  mat4 viewMatrix;
+  int enabled;
+} pbrShadow;
+vec4 pbrShadow_filterColorWithDirectionalContact(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal, float contactVisibility) {
+  float directionalVisibility = 1.0;
+  vec4 pointVisibility = vec4(1.0);
+  vec4 spotVisibility = vec4(1.0);
+  if (pbrShadow.enabled != 0) {
+    vec3 normal = normalize(worldNormal);
+    float viewDepth = -(pbrShadow.viewMatrix * vec4(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (int index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+ }
+vec4 pbrShadow_filterColor(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal) {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+    )
+  };
+
+  // src/modules/lighting/pbr-surface/pbr-surface.ts
+  var pbrSurface = {
+    name: "pbrSurface",
+    dependencies: [pbrMaterial],
+    bindingLayout: [{ name: "pbrSurface", group: 0 }],
+    uniformTypes: { viewMatrix: "mat4x4<f32>", useMaterialNormals: "i32" },
+    defaultUniforms: {
+      viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+      useMaterialNormals: 0
+    },
+    getUniforms(properties = {}) {
+      return {
+        ...properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {},
+        ...properties.useMaterialNormals === void 0 ? {} : { useMaterialNormals: Number(properties.useMaterialNormals) }
+      };
+    },
+    source: (
+      /* wgsl */
+      `
+struct PBRSurfaceUniforms {
+  viewMatrix: mat4x4f,
+  useMaterialNormals: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrSurface: PBRSurfaceUniforms;
+fn pbrSurface_getColor() -> vec4f {
+#ifdef HAS_NORMALS
+  var normal = normalize(fragmentInputs.pbr_vNormal);
+#ifdef DOUBLE_SIDED
+  if (!pbr_frontFacing) {normal = -normal;}
+#endif
+#else
+  var normal = normalize(cross(dpdy(fragmentInputs.pbr_vPosition), dpdx(fragmentInputs.pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  let viewNormal = normalize((pbrSurface.viewMatrix * vec4f(normal, 0.0)).xyz);
+  return vec4f(viewNormal * 0.5 + vec3f(0.5), 1.0);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform pbrSurfaceUniforms {
+  mat4 viewMatrix;
+  int useMaterialNormals;
+} pbrSurface;
+vec4 pbrSurface_getColor() {
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normal = normalize(pbr_vTBN[2]);
+#else
+  vec3 normal = normalize(pbr_vNormal);
+#endif
+#ifdef DOUBLE_SIDED
+  if (!gl_FrontFacing) normal = -normal;
+#endif
+#else
+  vec3 normal = normalize(cross(dFdx(pbr_vPosition), dFdy(pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  vec3 viewNormal = normalize((pbrSurface.viewMatrix * vec4(normal, 0.0)).xyz);
+  return vec4(viewNormal * 0.5 + 0.5, 1.0);
+}`
+    )
+  };
+
+  // src/modules/lighting/contact-shadow/contact-shadow.ts
+  var IDENTITY_MATRIX3 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  var contactShadowTrace = {
+    name: "contactShadowTrace",
+    source: (
+      /* wgsl */
+      `struct contactShadowTraceUniforms {
+  projectionMatrix: mat4x4f,
+  inverseProjectionMatrix: mat4x4f,
+  lightDirectionView: vec3f,
+  maxDistance: f32,
+  thickness: f32,
+  stepCount: f32,
+  frameIndex: f32,
+  normalBias: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowTrace: contactShadowTraceUniforms;
+@group(0) @binding(auto) var depthTexture: texture_depth_2d;
+@group(0) @binding(auto) var depthTextureSampler: sampler;
+@group(0) @binding(auto) var normalTexture: texture_2d<f32>;
+@group(0) @binding(auto) var normalTextureSampler: sampler;
+
+fn contactShadow_reconstructViewPosition(uv: vec2f, depth: f32) -> vec3f {
+  let clip = vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);
+  let view = contactShadowTrace.inverseProjectionMatrix * clip;
+  return view.xyz / max(abs(view.w), 0.00001);
+}
+
+fn contactShadow_projectViewPosition(position: vec3f) -> vec2f {
+  let clip = contactShadowTrace.projectionMatrix * vec4f(position, 1.0);
+  let ndc = clip.xy / max(abs(clip.w), 0.00001);
+  return vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+}
+
+fn contactShadowTrace_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let centerDepth = textureSampleLevel(depthTexture, depthTextureSampler, texCoord, 0);
+  if (centerDepth >= 0.99999) { return vec4f(1.0); }
+  let centerNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, texCoord, 0.0).xyz * 2.0 - 1.0);
+  let centerPosition = contactShadow_reconstructViewPosition(texCoord, centerDepth) + centerNormal * contactShadowTrace.normalBias;
+  let rayDirection = normalize(contactShadowTrace.lightDirectionView);
+  let noise = fract(sin(dot(texCoord * texSize + contactShadowTrace.frameIndex, vec2f(12.9898, 78.233))) * 43758.5453);
+  for (var index: i32 = 0; index < 40; index++) {
+    if (f32(index) >= contactShadowTrace.stepCount) { break; }
+    let fraction = (f32(index) + 0.35 + noise * 0.5) / max(contactShadowTrace.stepCount, 1.0);
+    let travel = contactShadowTrace.maxDistance * fraction * fraction;
+    let rayPosition = centerPosition + rayDirection * travel;
+    let sampleUv = contactShadow_projectViewPosition(rayPosition);
+    if (any(sampleUv <= vec2f(0.0)) || any(sampleUv >= vec2f(1.0))) { break; }
+    let sampleDepth = textureSampleLevel(depthTexture, depthTextureSampler, sampleUv, 0);
+    if (sampleDepth >= 0.99999) { continue; }
+    let scenePosition = contactShadow_reconstructViewPosition(sampleUv, sampleDepth);
+    let depthDelta = (-rayPosition.z) - (-scenePosition.z);
+    let hitThickness = contactShadowTrace.thickness + travel * 0.02;
+    if (depthDelta >= 0.0 && depthDelta <= hitThickness) {
+      let distanceFade = 1.0 - clamp(travel / contactShadowTrace.maxDistance, 0.0, 1.0);
+      return vec4f(vec3f(1.0 - distanceFade), 1.0);
+    }
+    if (depthDelta > hitThickness * 8.0) { break; }
+  }
+  return vec4f(1.0);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform contactShadowTraceUniforms {
+  mat4 projectionMatrix;
+  mat4 inverseProjectionMatrix;
+  vec3 lightDirectionView;
+  float maxDistance;
+  float thickness;
+  float stepCount;
+  float frameIndex;
+  float normalBias;
+} contactShadowTrace;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+vec3 contactShadow_reconstructViewPosition(vec2 uv, float depth) {
+  vec4 view = contactShadowTrace.inverseProjectionMatrix * vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+  return view.xyz / max(abs(view.w), 0.00001);
+}
+vec2 contactShadow_projectViewPosition(vec3 position) {
+  vec4 clip = contactShadowTrace.projectionMatrix * vec4(position,1.0);
+  return clip.xy / max(abs(clip.w),0.00001) * 0.5 + 0.5;
+}
+vec4 contactShadowTrace_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  float centerDepth = texture(depthTexture,texCoord).r;
+  if(centerDepth >= 0.99999) return vec4(1.0);
+  vec3 centerNormal = normalize(texture(normalTexture,texCoord).xyz * 2.0 - 1.0);
+  vec3 centerPosition = contactShadow_reconstructViewPosition(texCoord,centerDepth) + centerNormal * contactShadowTrace.normalBias;
+  vec3 rayDirection = normalize(contactShadowTrace.lightDirectionView);
+  float noise = fract(sin(dot(texCoord * texSize + contactShadowTrace.frameIndex,vec2(12.9898,78.233))) * 43758.5453);
+  for(int index=0;index<40;index++) {
+    if(float(index)>=contactShadowTrace.stepCount) break;
+    float fraction=(float(index)+0.35+noise*0.5)/max(contactShadowTrace.stepCount,1.0);
+    float travel=contactShadowTrace.maxDistance*fraction*fraction;
+    vec3 rayPosition=centerPosition+rayDirection*travel;
+    vec2 sampleUv=contactShadow_projectViewPosition(rayPosition);
+    if(any(lessThanEqual(sampleUv,vec2(0.0)))||any(greaterThanEqual(sampleUv,vec2(1.0))))break;
+    float sampleDepth=texture(depthTexture,sampleUv).r;
+    if(sampleDepth>=0.99999)continue;
+    vec3 scenePosition=contactShadow_reconstructViewPosition(sampleUv,sampleDepth);
+    float depthDelta=(-rayPosition.z)-(-scenePosition.z);
+    float hitThickness=contactShadowTrace.thickness+travel*0.02;
+    if(depthDelta>=0.0&&depthDelta<=hitThickness) {
+      float distanceFade=1.0-clamp(travel/contactShadowTrace.maxDistance,0.0,1.0);
+      return vec4(vec3(1.0-distanceFade),1.0);
+    }
+    if(depthDelta>hitThickness*8.0)break;
+  }
+  return vec4(1.0);
+}
+`
+    ),
+    bindingLayout: [
+      { name: "depthTexture", group: 0 },
+      { name: "normalTexture", group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+      projectionMatrix: "mat4x4<f32>",
+      inverseProjectionMatrix: "mat4x4<f32>",
+      lightDirectionView: "vec3<f32>",
+      maxDistance: "f32",
+      thickness: "f32",
+      stepCount: "f32",
+      frameIndex: "f32",
+      normalBias: "f32"
+    },
+    propTypes: {
+      projectionMatrix: { value: IDENTITY_MATRIX3, private: true },
+      inverseProjectionMatrix: { value: IDENTITY_MATRIX3, private: true },
+      lightDirectionView: { value: [0, 1, 0], private: true },
+      maxDistance: { value: 4, min: 0.1, softMax: 16 },
+      thickness: { value: 0.12, min: 5e-3, softMax: 1 },
+      stepCount: { value: 24, min: 1, max: 40 },
+      frameIndex: { value: 0, private: true },
+      normalBias: { value: 0.035, min: 0, softMax: 0.2 }
+    },
+    passes: [{ sampler: true }]
+  };
+  var contactShadowBilateralBlur = {
+    name: "contactShadowBilateralBlur",
+    source: (
+      /* wgsl */
+      `struct contactShadowBilateralBlurUniforms {
+  direction: vec2f,
+  radius: f32,
+  depthSigma: f32,
+  normalPower: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowBilateralBlur: contactShadowBilateralBlurUniforms;
+@group(0) @binding(auto) var depthTexture: texture_depth_2d;
+@group(0) @binding(auto) var depthTextureSampler: sampler;
+@group(0) @binding(auto) var normalTexture: texture_2d<f32>;
+@group(0) @binding(auto) var normalTextureSampler: sampler;
+
+fn contactShadowBilateralBlur_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let sourceDimensions = vec2f(textureDimensions(sourceTexture));
+  let texel = contactShadowBilateralBlur.direction / sourceDimensions;
+  let centerDepth = textureSampleLevel(depthTexture, depthTextureSampler, texCoord, 0);
+  let centerNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, texCoord, 0.0).xyz * 2.0 - 1.0);
+  var result = textureSampleLevel(sourceTexture, sourceTextureSampler, texCoord, 0.0).r;
+  var totalWeight = 1.0;
+  for (var index: i32 = 1; index <= 6; index++) {
+    if (f32(index) > contactShadowBilateralBlur.radius) { break; }
+    for (var side: i32 = -1; side <= 1; side += 2) {
+      let sampleUv = clamp(texCoord + texel * f32(index * side), vec2f(0.0), vec2f(1.0));
+      let sampleDepth = textureSampleLevel(depthTexture, depthTextureSampler, sampleUv, 0);
+      let sampleNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, sampleUv, 0.0).xyz * 2.0 - 1.0);
+      let depthDelta = abs(sampleDepth - centerDepth);
+      let depthWeight = exp(-(depthDelta * depthDelta) / max(2.0 * contactShadowBilateralBlur.depthSigma * contactShadowBilateralBlur.depthSigma, 0.000001));
+      let normalWeight = pow(max(dot(centerNormal, sampleNormal), 0.0), contactShadowBilateralBlur.normalPower);
+      let spatialWeight = exp(-f32(index * index) / 8.0);
+      let weight = depthWeight * normalWeight * spatialWeight;
+      result += textureSampleLevel(sourceTexture, sourceTextureSampler, sampleUv, 0.0).r * weight;
+      totalWeight += weight;
+    }
+  }
+  let visibility = result / totalWeight;
+  return vec4f(vec3f(visibility), 1.0);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform contactShadowBilateralBlurUniforms {
+  vec2 direction;
+  float radius;
+  float depthSigma;
+  float normalPower;
+} contactShadowBilateralBlur;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+vec4 contactShadowBilateralBlur_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  vec2 texel=contactShadowBilateralBlur.direction/vec2(textureSize(sourceTexture,0));
+  float centerDepth=texture(depthTexture,texCoord).r;
+  vec3 centerNormal=normalize(texture(normalTexture,texCoord).xyz*2.0-1.0);
+  float result=texture(sourceTexture,texCoord).r;
+  float totalWeight=1.0;
+  for(int index=1;index<=6;index++) {
+    if(float(index)>contactShadowBilateralBlur.radius)break;
+    for(int side=-1;side<=1;side+=2) {
+      vec2 sampleUv=clamp(texCoord+texel*float(index*side),vec2(0.0),vec2(1.0));
+      float sampleDepth=texture(depthTexture,sampleUv).r;
+      vec3 sampleNormal=normalize(texture(normalTexture,sampleUv).xyz*2.0-1.0);
+      float depthDelta=abs(sampleDepth-centerDepth);
+      float depthWeight=exp(-(depthDelta*depthDelta)/max(2.0*contactShadowBilateralBlur.depthSigma*contactShadowBilateralBlur.depthSigma,0.000001));
+      float normalWeight=pow(max(dot(centerNormal,sampleNormal),0.0),contactShadowBilateralBlur.normalPower);
+      float spatialWeight=exp(-float(index*index)/8.0);
+      float weight=depthWeight*normalWeight*spatialWeight;
+      result+=texture(sourceTexture,sampleUv).r*weight;totalWeight+=weight;
+    }
+  }
+  return vec4(vec3(result/totalWeight),1.0);
+}
+`
+    ),
+    bindingLayout: [
+      { name: "depthTexture", group: 0 },
+      { name: "normalTexture", group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+      direction: "vec2<f32>",
+      radius: "f32",
+      depthSigma: "f32",
+      normalPower: "f32"
+    },
+    propTypes: {
+      direction: { value: [1, 0], private: true },
+      radius: { value: 4, min: 1, max: 6 },
+      depthSigma: { value: 6e-3, min: 1e-4, softMax: 0.05 },
+      normalPower: { value: 24, min: 1, softMax: 64 }
+    },
+    passes: [{ sampler: true }]
+  };
+  var contactShadowComposite = {
+    name: "contactShadowComposite",
+    source: (
+      /* wgsl */
+      `struct contactShadowCompositeUniforms {
+  strength: f32,
+  debugMode: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowComposite: contactShadowCompositeUniforms;
+@group(0) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(0) @binding(auto) var contactShadowTextureSampler: sampler;
+@group(0) @binding(auto) var directionalDirectTexture: texture_2d<f32>;
+@group(0) @binding(auto) var directionalDirectTextureSampler: sampler;
+@group(0) @binding(auto) var shadowDebugTexture: texture_2d<f32>;
+@group(0) @binding(auto) var shadowDebugTextureSampler: sampler;
+
+fn contactShadowComposite_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let color = textureSampleLevel(sourceTexture, sourceTextureSampler, texCoord, 0.0);
+  let contact = textureSampleLevel(contactShadowTexture, contactShadowTextureSampler, texCoord, 0.0).r;
+  let appliedContact = mix(1.0, contact, contactShadowComposite.strength);
+  if (contactShadowComposite.debugMode > 0.5 && contactShadowComposite.debugMode < 1.5) {
+    return vec4f(vec3f(contact), 1.0);
+  }
+  if (contactShadowComposite.debugMode >= 1.5) {
+    let factors = textureSampleLevel(shadowDebugTexture, shadowDebugTextureSampler, texCoord, 0.0).rgb;
+    return vec4f(vec3f(factors.x * factors.y * factors.z * contact), 1.0);
+  }
+  let directionalDirect = textureSampleLevel(
+    directionalDirectTexture,
+    directionalDirectTextureSampler,
+    texCoord,
+    0.0
+  ).rgb;
+  return vec4f(max(color.rgb - directionalDirect * (1.0 - appliedContact), vec3f(0.0)), color.a);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform contactShadowCompositeUniforms {
+  float strength;
+  float debugMode;
+} contactShadowComposite;
+uniform sampler2D contactShadowTexture;
+uniform sampler2D directionalDirectTexture;
+uniform sampler2D shadowDebugTexture;
+vec4 contactShadowComposite_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  vec4 color=texture(sourceTexture,texCoord);
+  float contact=texture(contactShadowTexture,texCoord).r;
+  float appliedContact=mix(1.0,contact,contactShadowComposite.strength);
+  if(contactShadowComposite.debugMode>0.5&&contactShadowComposite.debugMode<1.5)return vec4(vec3(contact),1.0);
+  if(contactShadowComposite.debugMode>=1.5){vec3 factors=texture(shadowDebugTexture,texCoord).rgb;return vec4(vec3(factors.x*factors.y*factors.z*contact),1.0);}
+  vec3 directionalDirect=texture(directionalDirectTexture,texCoord).rgb;
+  return vec4(max(color.rgb-directionalDirect*(1.0-appliedContact),vec3(0.0)),color.a);
+}
+`
+    ),
+    bindingLayout: [
+      { name: "contactShadowTexture", group: 0 },
+      { name: "directionalDirectTexture", group: 0 },
+      { name: "shadowDebugTexture", group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: { strength: "f32", debugMode: "f32" },
+    propTypes: {
+      strength: { value: 1, min: 0, max: 1 },
+      debugMode: { value: 0, min: 0, max: 2, private: true }
+    },
+    passes: [{ sampler: true }]
+  };
+
+  // src/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.ts
+  var pbrContactShadow = {
+    name: "pbrContactShadow",
+    dependencies: [pbrMaterial],
+    bindingLayout: [
+      { name: "pbrContactShadow", group: 0 },
+      { name: "contactShadowTexture", group: 2 }
+    ],
+    uniformTypes: { viewport: "vec4<f32>", strength: "f32", enabled: "i32" },
+    defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+    getUniforms(properties = {}) {
+      return {
+        ...properties.viewport ? { viewport: properties.viewport } : {},
+        ...properties.strength === void 0 ? {} : { strength: properties.strength },
+        ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) },
+        ...properties.contactShadowTexture ? { contactShadowTexture: properties.contactShadowTexture } : {}
+      };
+    },
+    source: (
+      /* wgsl */
+      `
+struct PBRContactShadowUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrContactShadow: PBRContactShadowUniforms;
+@group(2) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(2) @binding(auto) var contactShadowTextureSampler: sampler;
+fn pbrContactShadow_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrContactShadow.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(contactShadowTexture,contactShadowTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+fn pbrContactShadow_filterColor(vertexColor:vec4f,pixelPosition:vec2f)->vec4f {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4f(1.0),vec4f(1.0));
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform pbrContactShadowUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrContactShadow;
+uniform sampler2D contactShadowTexture;
+float pbrContactShadow_getFactor(vec2 pixelPosition) {
+  if(pbrContactShadow.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(contactShadowTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+vec4 pbrContactShadow_filterColor(vec4 vertexColor,vec2 pixelPosition) {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4(1.0),vec4(1.0));
+}`
+    )
+  };
+
+  // src/modules/lighting/clustered-light-grid/clustered-light-grid.ts
+  var clusteredLightGrid = {
+    name: "clusteredLightGrid",
+    source: (
+      /* wgsl */
+      `
+fn clusteredLightGrid_getIndex(coordinates: vec2f, viewDepth: f32, dimensions: vec3u, nearPlane: f32, farPlane: f32) -> u32 {
+  let tile = min(vec2u(clamp(coordinates, vec2f(0.0), vec2f(0.999999)) * vec2f(dimensions.xy)), dimensions.xy - vec2u(1));
+  let normalizedDepth = clamp(log(clamp(viewDepth, nearPlane, farPlane) / nearPlane) / log(farPlane / nearPlane), 0.0, 0.999999);
+  let depthSlice = min(u32(normalizedDepth * f32(dimensions.z)), dimensions.z - 1u);
+  return (depthSlice * dimensions.y + tile.y) * dimensions.x + tile.x;
+}
+`
+    )
+  };
+
+  // src/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.ts
+  var pbrAmbientOcclusion = {
+    name: "pbrAmbientOcclusion",
+    dependencies: [pbrMaterial],
+    bindingLayout: [
+      { name: "pbrAmbientOcclusion", group: 0 },
+      { name: "ambientOcclusionTexture", group: 2 }
+    ],
+    uniformTypes: { viewport: "vec4<f32>", strength: "f32", enabled: "i32" },
+    defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+    getUniforms(properties = {}) {
+      return {
+        ...properties.viewport ? { viewport: properties.viewport } : {},
+        ...properties.strength === void 0 ? {} : { strength: properties.strength },
+        ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) },
+        ...properties.ambientOcclusionTexture ? { ambientOcclusionTexture: properties.ambientOcclusionTexture } : {}
+      };
+    },
+    source: (
+      /* wgsl */
+      `
+struct PBRAmbientOcclusionUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrAmbientOcclusion: PBRAmbientOcclusionUniforms;
+@group(2) @binding(auto) var ambientOcclusionTexture: texture_2d<f32>;
+@group(2) @binding(auto) var ambientOcclusionTextureSampler: sampler;
+fn pbrAmbientOcclusion_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrAmbientOcclusion.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(ambientOcclusionTexture,ambientOcclusionTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+fn pbrAmbientOcclusion_setFactor(pixelPosition:vec2f) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+    ),
+    fs: (
+      /* glsl */
+      `
+layout(std140) uniform pbrAmbientOcclusionUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrAmbientOcclusion;
+uniform sampler2D ambientOcclusionTexture;
+float pbrAmbientOcclusion_getFactor(vec2 pixelPosition) {
+  if(pbrAmbientOcclusion.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(ambientOcclusionTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+void pbrAmbientOcclusion_setFactor(vec2 pixelPosition) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+    )
+  };
+
+  // src/modules/lighting/lightmap/lightmap.ts
+  var lightmapBake = {
+    name: "lightmapBake",
+    dependencies: [pbrMaterial],
+    bindingLayout: [{ name: "lightmapBake", group: 0 }],
+    uniformTypes: { uvSet: "i32", uvTransform: "mat3x3<f32>", chartId: "f32" },
+    defaultUniforms: { uvSet: 1, uvTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1], chartId: 1 },
+    getUniforms: (props) => props,
+    source: `
+struct LightmapBakeUniforms {uvSet: i32, uvTransform: mat3x3f, chartId: f32};
+@group(0) @binding(auto) var<uniform> lightmapBake: LightmapBakeUniforms;
+
+fn lightmap_getIrradiance(position: vec3f, normal: vec3f, directionalVisibility: f32, pointVisibility: vec4f, spotVisibility: vec4f) -> vec3f {
+  if (lighting.enabled == 0) {return vec3f(0.0);}
+  var irradiance = lighting.ambientColor;
+  for (var index = 0; index < lighting.directionalLightCount; index++) {
+    let light = lighting_getDirectionalLight(index);
+    irradiance += light.color * max(dot(normal, -normalize(light.direction)), 0.0) * select(1.0, directionalVisibility, index == 0);
+  }
+  for (var index = 0; index < lighting.pointLightCount; index++) {
+    let light = lighting_getPointLight(index);
+    let offset = light.position - position;
+    let visibility = select(1.0, pointVisibility[min(index, 3)], index < 4);
+    irradiance += light.color * max(dot(normal, normalize(offset)), 0.0) * visibility / max(getPointLightAttenuation(light, length(offset)), 0.0001);
+  }
+  for (var index = 0; index < lighting.spotLightCount; index++) {
+    let light = lighting_getSpotLight(index);
+    irradiance += light.color * max(dot(normal, normalize(light.position - position)), 0.0) * select(1.0, spotVisibility[min(index, 3)], index < 4) / max(getSpotLightAttenuation(light, position), 0.0001);
+  }
+  return irradiance;
+}
+`,
+    vs: `layout(std140) uniform lightmapBakeUniforms {
+ int uvSet;
+ mat3 uvTransform;
+ float chartId;
+} lightmapBake;`,
+    fs: `layout(std140) uniform lightmapBakeUniforms {
+ int uvSet;
+ mat3 uvTransform;
+ float chartId;
+} lightmapBake;
+
+vec3 lightmap_getIrradiance(vec3 position, vec3 normal, float directionalVisibility, vec4 pointVisibility, vec4 spotVisibility) {
+  if (lighting.enabled == 0) {return vec3(0.0);}
+  vec3 irradiance = lighting.ambientColor;
+  for (int index = 0; index < lighting.directionalLightCount; index++) {
+    DirectionalLight light = lighting_getDirectionalLight(index);
+    irradiance += light.color * max(dot(normal, -normalize(light.direction)), 0.0) * (index == 0 ? directionalVisibility : 1.0);
+  }
+  for (int index = 0; index < lighting.pointLightCount; index++) {
+    PointLight light = lighting_getPointLight(index);
+    vec3 offset = light.position - position;
+    irradiance += light.color * max(dot(normal, normalize(offset)), 0.0) * (index < 4 ? pointVisibility[index] : 1.0) / max(getPointLightAttenuation(light, length(offset)), 0.0001);
+  }
+  for (int index = 0; index < lighting.spotLightCount; index++) {
+    SpotLight light = lighting_getSpotLight(index);
+    irradiance += light.color * max(dot(normal, normalize(light.position - position)), 0.0) * (index < 4 ? spotVisibility[index] : 1.0) / max(getSpotLightAttenuation(light, position), 0.0001);
+  }
+  return irradiance;
+}
+`
+  };
+
+  // src/modules/lighting/lightmap/lightmap-filter.ts
+  var lightmapFilter = {
+    name: "lightmapFilter",
+    bindingLayout: [
+      { name: "lightmapFilter", group: 0 },
+      { name: "currentTexture", group: 0 },
+      { name: "previousTexture", group: 0 },
+      { name: "chartTexture", group: 0 }
+    ],
+    uniformTypes: { weight: "f32", mode: "i32" },
+    defaultUniforms: { weight: 1, mode: 0 },
+    getUniforms: (props) => props,
+    source: `
+struct LightmapFilterUniforms {weight: f32, mode: i32};
+@group(0) @binding(auto) var<uniform> lightmapFilter: LightmapFilterUniforms;
+@group(0) @binding(auto) var currentTexture: texture_2d<f32>;
+@group(0) @binding(auto) var previousTexture: texture_2d<f32>;
+@group(0) @binding(auto) var chartTexture: texture_2d<f32>;
+fn lightmapFilter_getColor(coordinates: vec2i) -> vec4f {
+  let current = textureLoad(currentTexture, coordinates, 0);
+  if (lightmapFilter.mode == 0) {
+    let previous = textureLoad(previousTexture, coordinates, 0);
+    return vec4f(mix(previous.rgb, current.rgb, lightmapFilter.weight), current.a);
+  }
+  if (lightmapFilter.mode == 2 || current.a > 0.0) {return current;}
+  let chart = textureLoad(chartTexture, coordinates, 0).r;
+  if (chart <= 0.0) {return current;}
+  let size = vec2i(textureDimensions(currentTexture));
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      let neighbor = coordinates + vec2i(x, y);
+      if (all(neighbor >= vec2i(0)) && all(neighbor < size)) {
+        let candidate = textureLoad(currentTexture, neighbor, 0);
+        if (candidate.a == chart) {return candidate;}
+      }
+    }
+  }
+  return current;
+}`,
+    fs: `
+layout(std140) uniform lightmapFilterUniforms {
+ float weight;
+ int mode;
+} lightmapFilter;
+uniform sampler2D currentTexture;
+uniform sampler2D previousTexture;
+uniform sampler2D chartTexture;
+vec4 lightmapFilter_getColor(ivec2 coordinates) {
+  vec4 current = texelFetch(currentTexture, coordinates, 0);
+  if (lightmapFilter.mode == 0) {
+    return vec4(mix(texelFetch(previousTexture, coordinates, 0).rgb, current.rgb, lightmapFilter.weight), current.a);
+  }
+  if (lightmapFilter.mode == 2 || current.a > 0.0) {return current;}
+  float chart = texelFetch(chartTexture, coordinates, 0).r;
+  ivec2 size = textureSize(currentTexture, 0);
+  if (chart <= 0.0) return current;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      ivec2 neighbor = coordinates + ivec2(x,y);
+      if (all(greaterThanEqual(neighbor, ivec2(0))) && all(lessThan(neighbor,size))) {
+        vec4 candidate = texelFetch(currentTexture, neighbor, 0);
+        if (candidate.a == chart) {return candidate;}
+      }
+    }
+  }
+  return current;
+}`
+  };
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;