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

package/dist/modules/lighting/shadow/shadow.cjs

@@ -0,0 +1,458 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shadow_exports = {};
+__export(shadow_exports, {
+  shadow: () => shadow
+});
+module.exports = __toCommonJS(shadow_exports);
+var import_shadow_glsl = require("./shadow-glsl.cjs");
+const MAX_CASCADES = 4;
+const MAX_SPOT_LIGHTS = 4;
+const MAX_POINT_LIGHTS = 4;
+const MAX_POINT_MATRICES = 24;
+const DIRECTIONAL_LIGHT_UNIFORM_TYPE = {
+  direction: "vec3<f32>",
+  strength: "f32",
+  normalBias: "f32",
+  sourceAngularRadius: "f32",
+  cascadeBlendFraction: "f32",
+  farFadeFraction: "f32",
+  shadowDistance: "f32"
+};
+const SPOT_LIGHT_UNIFORM_TYPE = {
+  position: "vec3<f32>",
+  range: "f32",
+  direction: "vec3<f32>",
+  outerConeCos: "f32",
+  sourceRadius: "f32",
+  normalBias: "f32",
+  strength: "f32",
+  nearPlane: "f32"
+};
+const POINT_LIGHT_UNIFORM_TYPE = {
+  position: "vec3<f32>",
+  range: "f32",
+  sourceRadius: "f32",
+  normalBias: "f32",
+  strength: "f32",
+  nearPlane: "f32"
+};
+const 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);
+}
+`
+);
+const shadow = {
+  name: "shadow",
+  source: SHADOW_WGSL,
+  fs: import_shadow_glsl.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shadow
+});

package/dist/modules/lighting/shadow/shadow.d.ts

@@ -0,0 +1,117 @@
+import type { NumberArray3, NumberArray4, NumberArray16 } from '@math.gl/core';
+import type { ShadowProps } from "./shadow-types.js";
+type DirectionalShadowUniform = {
+    direction: Readonly<NumberArray3>;
+    strength: number;
+    normalBias: number;
+    sourceAngularRadius: number;
+    cascadeBlendFraction: number;
+    farFadeFraction: number;
+    shadowDistance: number;
+};
+type SpotShadowUniform = {
+    position: Readonly<NumberArray3>;
+    range: number;
+    direction: Readonly<NumberArray3>;
+    outerConeCos: number;
+    sourceRadius: number;
+    normalBias: number;
+    strength: number;
+    nearPlane: number;
+};
+type PointShadowUniform = {
+    position: Readonly<NumberArray3>;
+    range: number;
+    sourceRadius: number;
+    normalBias: number;
+    strength: number;
+    nearPlane: number;
+};
+export type ShadowUniforms = {
+    directionalLightCount: number;
+    spotLightCount: number;
+    pointLightCount: number;
+    cascadeCount: number;
+    blockerSampleCount: number;
+    filterSampleCount: number;
+    cascadeSplits: Readonly<NumberArray4>;
+    directionalViewProjectionMatrices: readonly Readonly<NumberArray16>[];
+    spotViewProjectionMatrices: readonly Readonly<NumberArray16>[];
+    pointViewProjectionMatrices: readonly Readonly<NumberArray16>[];
+    directionalLights: readonly DirectionalShadowUniform[];
+    spotLights: readonly SpotShadowUniform[];
+    pointLights: readonly PointShadowUniform[];
+};
+export type ShadowBindings<TextureT = unknown, SamplerT = unknown> = {
+    directionalShadowTexture: TextureT;
+    spotShadowTexture: TextureT;
+    pointShadowTexture: TextureT;
+    shadowComparisonSampler?: SamplerT;
+};
+/** Backend-aware shadow sampling module. Applications explicitly apply factors to direct-light terms. */
+export declare const shadow: {
+    readonly name: "shadow";
+    readonly source: "const SHADOW_PI: f32 = 3.141592653589793;\n\nstruct DirectionalShadowLightUniform {\n  direction: vec3f,\n  strength: f32,\n  normalBias: f32,\n  sourceAngularRadius: f32,\n  cascadeBlendFraction: f32,\n  farFadeFraction: f32,\n  shadowDistance: f32,\n};\n\nstruct SpotShadowLightUniform {\n  position: vec3f,\n  range: f32,\n  direction: vec3f,\n  outerConeCos: f32,\n  sourceRadius: f32,\n  normalBias: f32,\n  strength: f32,\n  nearPlane: f32,\n};\n\nstruct PointShadowLightUniform {\n  position: vec3f,\n  range: f32,\n  sourceRadius: f32,\n  normalBias: f32,\n  strength: f32,\n  nearPlane: f32,\n};\n\nstruct ShadowUniforms {\n  directionalLightCount: i32,\n  spotLightCount: i32,\n  pointLightCount: i32,\n  cascadeCount: i32,\n  blockerSampleCount: i32,\n  filterSampleCount: i32,\n  cascadeSplits: vec4f,\n  directionalViewProjectionMatrices: array<mat4x4f, 4>,\n  spotViewProjectionMatrices: array<mat4x4f, 4>,\n  pointViewProjectionMatrices: array<mat4x4f, 24>,\n  directionalLights: array<DirectionalShadowLightUniform, 1>,\n  spotLights: array<SpotShadowLightUniform, 4>,\n  pointLights: array<PointShadowLightUniform, 4>,\n};\n\n@group(2) @binding(auto) var<uniform> shadow: ShadowUniforms;\n@group(2) @binding(auto) var directionalShadowTexture: texture_depth_2d_array;\n@group(2) @binding(auto) var spotShadowTexture: texture_depth_2d_array;\n@group(2) @binding(auto) var pointShadowTexture: texture_depth_cube_array;\n@group(2) @binding(auto) var directionalShadowTextureSampler: sampler;\n@group(2) @binding(auto) var shadowComparisonSampler: sampler_comparison;\n\nfn shadow_hash(position: vec3f) -> f32 {\n  return fract(sin(dot(position, vec3f(12.9898, 78.233, 37.719))) * 43758.5453);\n}\n\nfn shadow_diskSample(index: i32, count: i32, rotation: f32) -> vec2f {\n  let fraction = (f32(index) + 0.5) / max(f32(count), 1.0);\n  let angle = f32(index) * 2.39996323 + rotation;\n  return sqrt(fraction) * vec2f(cos(angle), sin(angle));\n}\n\nfn shadow_project(matrix: mat4x4f, worldPosition: vec3f) -> vec3f {\n  let clip = matrix * vec4f(worldPosition, 1.0);\n  let ndc = clip.xyz / max(abs(clip.w), 0.00001);\n  return vec3f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z);\n}\n\nfn shadow_validProjection(projected: vec3f) -> bool {\n  return all(projected.xy >= vec2f(0.0)) && all(projected.xy <= vec2f(1.0)) &&\n    projected.z >= 0.0 && projected.z <= 1.0;\n}\n\nfn shadow_directionalCascadeIndex(viewDepth: f32) -> i32 {\n  var cascadeIndex = 0;\n  for (var index: i32 = 0; index < 4; index++) {\n    if (index >= shadow.cascadeCount) { break; }\n    cascadeIndex = index;\n    if (viewDepth <= shadow.cascadeSplits[index]) { break; }\n  }\n  return cascadeIndex;\n}\n\nfn shadow_getDirectionalCascadeIndex(viewDepth: f32) -> i32 {\n  if (shadow.directionalLightCount == 0) { return -1; }\n  return shadow_directionalCascadeIndex(viewDepth);\n}\n\nfn shadow_directionalPCSS(cascadeIndex: i32, worldPosition: vec3f, viewDepth: f32) -> f32 {\n  let projected = shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition);\n  if (!shadow_validProjection(projected)) { return 1.0; }\n  let dimensions = vec2f(textureDimensions(directionalShadowTexture));\n  let texel = 1.0 / dimensions;\n  let light = shadow.directionalLights[0];\n  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;\n  let searchRadius = max(texel.x, light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001));\n  var blockerDepth = 0.0;\n  var blockerCount = 0.0;\n  for (var index: i32 = 0; index < 24; index++) {\n    if (index >= shadow.blockerSampleCount) { break; }\n    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;\n    let sampleDepth = textureSampleLevel(\n      directionalShadowTexture,\n      directionalShadowTextureSampler,\n      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),\n      cascadeIndex,\n      0\n    );\n    if (sampleDepth < projected.z) {\n      blockerDepth += sampleDepth;\n      blockerCount += 1.0;\n    }\n  }\n  if (blockerCount == 0.0) { return 1.0; }\n  let averageBlocker = blockerDepth / blockerCount;\n  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);\n  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 18.0));\n  var visibility = 0.0;\n  for (var index: i32 = 0; index < 48; index++) {\n    if (index >= shadow.filterSampleCount) { break; }\n    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;\n    visibility += textureSampleCompareLevel(\n      directionalShadowTexture,\n      shadowComparisonSampler,\n      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),\n      cascadeIndex,\n      projected.z\n    );\n  }\n  return visibility / max(f32(shadow.filterSampleCount), 1.0);\n}\n\nfn shadow_getDirectionalFactor(worldPosition: vec3f, worldNormal: vec3f, viewDepth: f32) -> f32 {\n  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) { return 1.0; }\n  let light = shadow.directionalLights[0];\n  if (viewDepth >= light.shadowDistance) { return 1.0; }\n  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;\n  let cascadeIndex = shadow_directionalCascadeIndex(viewDepth);\n  var visibility = shadow_directionalPCSS(cascadeIndex, biasedPosition, viewDepth);\n  if (cascadeIndex + 1 < shadow.cascadeCount) {\n    var cascadeStart = 0.0;\n    if (cascadeIndex > 0) { cascadeStart = shadow.cascadeSplits[cascadeIndex - 1]; }\n    let cascadeEnd = shadow.cascadeSplits[cascadeIndex];\n    let blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);\n    let blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);\n    if (blend > 0.0) {\n      visibility = mix(\n        visibility,\n        shadow_directionalPCSS(cascadeIndex + 1, biasedPosition, viewDepth),\n        blend\n      );\n    }\n  }\n  let fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);\n  let farFade = smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth);\n  visibility = mix(visibility, 1.0, farFade);\n  return mix(1.0, visibility, light.strength);\n}\n\nfn shadow_spotPCSS(lightIndex: i32, worldPosition: vec3f) -> f32 {\n  let projected = shadow_project(shadow.spotViewProjectionMatrices[lightIndex], worldPosition);\n  if (!shadow_validProjection(projected)) { return 1.0; }\n  let light = shadow.spotLights[lightIndex];\n  let dimensions = vec2f(textureDimensions(spotShadowTexture));\n  let texel = 1.0 / dimensions;\n  let distanceToLight = length(worldPosition - light.position);\n  let searchRadius = max(texel.x, light.sourceRadius / max(distanceToLight, 0.001) * 0.5);\n  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;\n  var blockerDepth = 0.0;\n  var blockerCount = 0.0;\n  for (var index: i32 = 0; index < 24; index++) {\n    if (index >= shadow.blockerSampleCount) { break; }\n    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;\n    let sampleDepth = textureSampleLevel(\n      spotShadowTexture,\n      directionalShadowTextureSampler,\n      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),\n      lightIndex,\n      0\n    );\n    if (sampleDepth < projected.z) { blockerDepth += sampleDepth; blockerCount += 1.0; }\n  }\n  if (blockerCount == 0.0) { return 1.0; }\n  let averageBlocker = blockerDepth / blockerCount;\n  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);\n  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 16.0));\n  var visibility = 0.0;\n  for (var index: i32 = 0; index < 48; index++) {\n    if (index >= shadow.filterSampleCount) { break; }\n    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;\n    visibility += textureSampleCompareLevel(\n      spotShadowTexture,\n      shadowComparisonSampler,\n      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),\n      lightIndex,\n      projected.z\n    );\n  }\n  return visibility / max(f32(shadow.filterSampleCount), 1.0);\n}\n\nfn shadow_getSpotFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {\n  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) { return 1.0; }\n  let light = shadow.spotLights[lightIndex];\n  let fromLight = worldPosition - light.position;\n  let distanceToLight = length(fromLight);\n  let coneCos = dot(normalize(fromLight), normalize(light.direction));\n  if (distanceToLight >= light.range || coneCos < light.outerConeCos) { return 1.0; }\n  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;\n  return mix(1.0, shadow_spotPCSS(lightIndex, biasedPosition), light.strength);\n}\n\nfn shadow_pointReferenceDepth(majorDistance: f32, nearPlane: f32, farPlane: f32) -> f32 {\n  // Match the cube-face projection and stored WebGPU depth in [0, 1].\n  return farPlane / (farPlane - nearPlane) -\n    (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);\n}\n\nfn shadow_pointBasis(direction: vec3f) -> mat2x3f {\n  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(direction.y) > 0.99);\n  let tangent = normalize(cross(direction, reference));\n  return mat2x3f(tangent, normalize(cross(direction, tangent)));\n}\n\nfn shadow_getPointFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {\n  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) { return 1.0; }\n  let light = shadow.pointLights[lightIndex];\n  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;\n  let fromLight = biasedPosition - light.position;\n  let distanceToLight = length(fromLight);\n  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) { return 1.0; }\n  let direction = normalize(fromLight);\n  let majorDistance = max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z));\n  let referenceDepth = shadow_pointReferenceDepth(majorDistance, light.nearPlane, light.range);\n  let searchRadius = light.sourceRadius / max(distanceToLight, 0.001);\n  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;\n  let basis = shadow_pointBasis(direction);\n  var blockerDepth = 0.0;\n  var blockerCount = 0.0;\n  for (var index: i32 = 0; index < 24; index++) {\n    if (index >= shadow.blockerSampleCount) { break; }\n    let disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;\n    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);\n    let sampleDepth = textureSampleLevel(\n      pointShadowTexture,\n      directionalShadowTextureSampler,\n      sampleDirection,\n      lightIndex,\n      0\n    );\n    if (sampleDepth < referenceDepth) { blockerDepth += sampleDepth; blockerCount += 1.0; }\n  }\n  if (blockerCount == 0.0) { return 1.0; }\n  let averageBlocker = blockerDepth / blockerCount;\n  let penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);\n  let filterRadius = searchRadius * (1.0 + penumbra * 12.0);\n  var visibility = 0.0;\n  for (var index: i32 = 0; index < 48; index++) {\n    if (index >= shadow.filterSampleCount) { break; }\n    let disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;\n    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);\n    visibility += textureSampleCompareLevel(\n      pointShadowTexture,\n      shadowComparisonSampler,\n      sampleDirection,\n      lightIndex,\n      referenceDepth\n    );\n  }\n  visibility /= max(f32(shadow.filterSampleCount), 1.0);\n  return mix(1.0, visibility, light.strength);\n}\n";
+    readonly fs: "\nprecision highp sampler2DArray;\nstruct DirectionalShadowLightUniform {\n  vec3 direction;\n  float strength;\n  float normalBias;\n  float sourceAngularRadius;\n  float cascadeBlendFraction;\n  float farFadeFraction;\n  float shadowDistance;\n};\nstruct SpotShadowLightUniform {\n  vec3 position;\n  float range;\n  vec3 direction;\n  float outerConeCos;\n  float sourceRadius;\n  float normalBias;\n  float strength;\n  float nearPlane;\n};\nstruct PointShadowLightUniform {\n  vec3 position;\n  float range;\n  float sourceRadius;\n  float normalBias;\n  float strength;\n  float nearPlane;\n};\nlayout(std140) uniform shadowUniforms {\n  int directionalLightCount;\n  int spotLightCount;\n  int pointLightCount;\n  int cascadeCount;\n  int blockerSampleCount;\n  int filterSampleCount;\n  vec4 cascadeSplits;\n  mat4 directionalViewProjectionMatrices[4];\n  mat4 spotViewProjectionMatrices[4];\n  mat4 pointViewProjectionMatrices[24];\n  DirectionalShadowLightUniform directionalLights[1];\n  SpotShadowLightUniform spotLights[4];\n  PointShadowLightUniform pointLights[4];\n} shadow;\nuniform sampler2DArray directionalShadowTexture;\nuniform sampler2DArray spotShadowTexture;\nuniform sampler2DArray pointShadowTexture;\nconst float SHADOW_PI = 3.141592653589793;\nfloat shadow_hash(vec3 position) {\n  return fract(sin(dot(position, vec3(12.9898, 78.233, 37.719))) * 43758.5453);\n}\nvec2 shadow_diskSample(int index, int count, float rotation) {\n  float fraction = (float(index) + 0.5) / max(float(count), 1.0);\n  float angle = float(index) * 2.39996323 + rotation;\n  return sqrt(fraction) * vec2(cos(angle), sin(angle));\n}\nvec3 shadow_project(mat4 matrix, vec3 worldPosition) {\n  vec4 clip = matrix * vec4(worldPosition, 1.0);\n  vec3 projected = clip.xyz / max(abs(clip.w), 0.00001);\n  // Shared matrices retain [0,1] depth; WebGL texture rows start at the bottom.\n  return vec3(projected.xy * 0.5 + 0.5, projected.z);\n}\nbool shadow_validProjection(vec3 projected) {\n  return all(greaterThanEqual(projected, vec3(0.0))) && all(lessThanEqual(projected, vec3(1.0)));\n}\n// Bilinear interpolation of four depth comparisons matches a hardware 2x2 PCF lookup.\nfloat shadow_compare(sampler2DArray shadowMap, vec2 coordinate, int layer, float reference) {\n  ivec2 dimensions = textureSize(shadowMap, 0).xy;\n  vec2 position = coordinate * vec2(dimensions) - 0.5;\n  ivec2 base = ivec2(floor(position));\n  vec2 fraction = fract(position);\n  ivec2 maximum = dimensions - 1;\n  float lowerLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base, ivec2(0), maximum), layer), 0).r);\n  float lowerRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,0), ivec2(0), maximum), layer), 0).r);\n  float upperLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(0,1), ivec2(0), maximum), layer), 0).r);\n  float upperRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,1), ivec2(0), maximum), layer), 0).r);\n  return mix(mix(lowerLeft, lowerRight, fraction.x), mix(upperLeft, upperRight, fraction.x), fraction.y);\n}\nfloat shadow_arrayPCSS(sampler2DArray shadowMap, int layer, vec3 projected, float searchRadius, float rotation, float penumbraScale) {\n  if (!shadow_validProjection(projected)) return 1.0;\n  float texel = 1.0 / float(textureSize(shadowMap, 0).x);\n  searchRadius = max(texel, searchRadius);\n  float blockerDepth = 0.0;\n  float blockerCount = 0.0;\n  for (int index = 0; index < 24; index++) {\n    if (index >= shadow.blockerSampleCount) break;\n    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius, vec2(0.0), vec2(1.0));\n    float depth = textureLod(shadowMap, vec3(coordinate, float(layer)), 0.0).r;\n    if (depth < projected.z) { blockerDepth += depth; blockerCount += 1.0; }\n  }\n  if (blockerCount == 0.0) return 1.0;\n  float averageBlocker = blockerDepth / blockerCount;\n  float penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);\n  float radius = max(texel, searchRadius * (1.0 + penumbra * penumbraScale));\n  float visibility = 0.0;\n  for (int index = 0; index < 48; index++) {\n    if (index >= shadow.filterSampleCount) break;\n    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius, vec2(0.0), vec2(1.0));\n    visibility += shadow_compare(shadowMap, coordinate, layer, projected.z);\n  }\n  return visibility / max(float(shadow.filterSampleCount), 1.0);\n}\nint shadow_directionalCascadeIndex(float viewDepth) {\n  int cascadeIndex = 0;\n  for (int index = 0; index < 4; index++) {\n    if (index >= shadow.cascadeCount) break;\n    cascadeIndex = index;\n    if (viewDepth <= shadow.cascadeSplits[index]) break;\n  }\n  return cascadeIndex;\n}\nint shadow_getDirectionalCascadeIndex(float viewDepth) {\n  return shadow.directionalLightCount == 0 ? -1 : shadow_directionalCascadeIndex(viewDepth);\n}\nfloat shadow_directionalPCSS(int cascadeIndex, vec3 worldPosition, float viewDepth) {\n  DirectionalShadowLightUniform light = shadow.directionalLights[0];\n  return shadow_arrayPCSS(directionalShadowTexture, cascadeIndex,\n    shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition),\n    light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001),\n    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 18.0);\n}\nfloat shadow_getDirectionalFactor(vec3 worldPosition, vec3 worldNormal, float viewDepth) {\n  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) return 1.0;\n  DirectionalShadowLightUniform light = shadow.directionalLights[0];\n  if (viewDepth >= light.shadowDistance) return 1.0;\n  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;\n  int cascadeIndex = shadow_directionalCascadeIndex(viewDepth);\n  float visibility = shadow_directionalPCSS(cascadeIndex, position, viewDepth);\n  if (cascadeIndex + 1 < shadow.cascadeCount) {\n    float cascadeStart = cascadeIndex > 0 ? shadow.cascadeSplits[cascadeIndex - 1] : 0.0;\n    float cascadeEnd = shadow.cascadeSplits[cascadeIndex];\n    float blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);\n    float blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);\n    if (blend > 0.0) visibility = mix(visibility, shadow_directionalPCSS(cascadeIndex + 1, position, viewDepth), blend);\n  }\n  float fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);\n  visibility = mix(visibility, 1.0, smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth));\n  return mix(1.0, visibility, light.strength);\n}\nfloat shadow_getSpotFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {\n  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) return 1.0;\n  SpotShadowLightUniform light = shadow.spotLights[lightIndex];\n  vec3 fromLight = worldPosition - light.position;\n  float distanceToLight = length(fromLight);\n  if (distanceToLight >= light.range || dot(normalize(fromLight), normalize(light.direction)) < light.outerConeCos) return 1.0;\n  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;\n  float visibility = shadow_arrayPCSS(spotShadowTexture, lightIndex,\n    shadow_project(shadow.spotViewProjectionMatrices[lightIndex], position),\n    light.sourceRadius / max(distanceToLight, 0.001) * 0.5,\n    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 16.0);\n  return mix(1.0, visibility, light.strength);\n}\nfloat shadow_pointReferenceDepth(float majorDistance, float nearPlane, float farPlane) {\n  return farPlane / (farPlane - nearPlane) - (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);\n}\nvec3 shadow_pointCoordinate(int lightIndex, vec3 direction) {\n  vec3 magnitude = abs(direction);\n  int face = magnitude.x >= magnitude.y && magnitude.x >= magnitude.z ? (direction.x >= 0.0 ? 0 : 1)\n    : magnitude.y >= magnitude.z ? (direction.y >= 0.0 ? 2 : 3) : (direction.z >= 0.0 ? 4 : 5);\n  PointShadowLightUniform light = shadow.pointLights[lightIndex];\n  vec3 projected = shadow_project(shadow.pointViewProjectionMatrices[lightIndex * 6 + face], light.position + direction * light.range * 0.5);\n  return vec3(projected.xy, float(lightIndex * 6 + face));\n}\nfloat shadow_getPointFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {\n  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) return 1.0;\n  PointShadowLightUniform light = shadow.pointLights[lightIndex];\n  vec3 fromLight = worldPosition + normalize(worldNormal) * light.normalBias - light.position;\n  float distanceToLight = length(fromLight);\n  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) return 1.0;\n  vec3 direction = normalize(fromLight);\n  float referenceDepth = shadow_pointReferenceDepth(max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z)), light.nearPlane, light.range);\n  vec3 reference = abs(direction.y) > 0.99 ? vec3(0,0,1) : vec3(0,1,0);\n  vec3 tangent = normalize(cross(direction, reference));\n  vec3 bitangent = normalize(cross(direction, tangent));\n  float searchRadius = light.sourceRadius / max(distanceToLight, 0.001);\n  float rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;\n  float blockerDepth = 0.0;\n  float blockerCount = 0.0;\n  for (int index = 0; index < 24; index++) {\n    if (index >= shadow.blockerSampleCount) break;\n    vec2 disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;\n    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));\n    float depth = textureLod(pointShadowTexture, coordinate, 0.0).r;\n    if (depth < referenceDepth) { blockerDepth += depth; blockerCount += 1.0; }\n  }\n  if (blockerCount == 0.0) return 1.0;\n  float averageBlocker = blockerDepth / blockerCount;\n  float penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);\n  float radius = searchRadius * (1.0 + penumbra * 12.0);\n  float visibility = 0.0;\n  for (int index = 0; index < 48; index++) {\n    if (index >= shadow.filterSampleCount) break;\n    vec2 disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius;\n    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));\n    visibility += shadow_compare(pointShadowTexture, coordinate.xy, int(coordinate.z), referenceDepth);\n  }\n  return mix(1.0, visibility / max(float(shadow.filterSampleCount), 1.0), light.strength);\n}\n";
+    readonly props: ShadowProps;
+    readonly uniforms: ShadowUniforms;
+    readonly bindings: ShadowBindings;
+    readonly uniformTypes: {
+        readonly directionalLightCount: "i32";
+        readonly spotLightCount: "i32";
+        readonly pointLightCount: "i32";
+        readonly cascadeCount: "i32";
+        readonly blockerSampleCount: "i32";
+        readonly filterSampleCount: "i32";
+        readonly cascadeSplits: "vec4<f32>";
+        readonly directionalViewProjectionMatrices: readonly ["mat4x4<f32>", 4];
+        readonly spotViewProjectionMatrices: readonly ["mat4x4<f32>", 4];
+        readonly pointViewProjectionMatrices: readonly ["mat4x4<f32>", 24];
+        readonly directionalLights: readonly [{
+            readonly direction: "vec3<f32>";
+            readonly strength: "f32";
+            readonly normalBias: "f32";
+            readonly sourceAngularRadius: "f32";
+            readonly cascadeBlendFraction: "f32";
+            readonly farFadeFraction: "f32";
+            readonly shadowDistance: "f32";
+        }, 1];
+        readonly spotLights: readonly [{
+            readonly position: "vec3<f32>";
+            readonly range: "f32";
+            readonly direction: "vec3<f32>";
+            readonly outerConeCos: "f32";
+            readonly sourceRadius: "f32";
+            readonly normalBias: "f32";
+            readonly strength: "f32";
+            readonly nearPlane: "f32";
+        }, 4];
+        readonly pointLights: readonly [{
+            readonly position: "vec3<f32>";
+            readonly range: "f32";
+            readonly sourceRadius: "f32";
+            readonly normalBias: "f32";
+            readonly strength: "f32";
+            readonly nearPlane: "f32";
+        }, 4];
+    };
+    readonly bindingLayout: readonly [{
+        readonly name: "shadow";
+        readonly group: 2;
+    }, {
+        readonly name: "directionalShadowTexture";
+        readonly group: 2;
+    }, {
+        readonly name: "spotShadowTexture";
+        readonly group: 2;
+    }, {
+        readonly name: "pointShadowTexture";
+        readonly group: 2;
+    }, {
+        readonly name: "shadowComparisonSampler";
+        readonly group: 2;
+    }];
+    readonly getUniforms: (props: Partial<ShadowProps>) => Partial<ShadowUniforms & ShadowBindings>;
+};
+export {};
+//# sourceMappingURL=shadow.d.ts.map

package/dist/modules/lighting/shadow/shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/shadow/shadow.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AAE7E,OAAO,KAAK,EAGV,WAAW,EAEZ,0BAAuB;AAOxB,KAAK,wBAAwB,GAAG;IAC9B,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACtC,iCAAiC,EAAE,SAAS,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;IACtE,0BAA0B,EAAE,SAAS,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;IAC/D,2BAA2B,EAAE,SAAS,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;IAChE,iBAAiB,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACvD,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,QAAQ,GAAG,OAAO,EAAE,QAAQ,GAAG,OAAO,IAAI;IACnE,wBAAwB,EAAE,QAAQ,CAAC;IACnC,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,kBAAkB,EAAE,QAAQ,CAAC;IAC7B,uBAAuB,CAAC,EAAE,QAAQ,CAAC;CACpC,CAAC;AAsTF,yGAAyG;AACzG,eAAO,MAAM,MAAM;;;;oBAIJ,WAAW;uBACR,cAAc;uBACd,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAuBX,OAAO,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC,cAAc,GAAG,cAAc,CAAC;CA0CN,CAAC"}