@forgeax/engine-shader 0.1.21 → 0.1.23

package/src/material/artifact-types.ts

@@ -1,14 +1,151 @@
 import type { BindGroupLayoutDescriptor } from '@forgeax/engine-types';
 
+export interface MaterialShaderResourceSlot {
+  readonly name: string;
+  readonly parameter: string;
+  readonly kind: 'sampler' | 'texture';
+  readonly group: number;
+  readonly binding: number;
+}
+
+export interface MaterialShaderVertexInput {
+  readonly semantic: string;
+  readonly location: number;
+  readonly format: string;
+}
+
+export interface MaterialShaderArtifactReceipt {
+  readonly directEntry: string;
+  readonly sceneIndexEntry: string;
+  readonly materialRow: {
+    readonly byteLength: number;
+    readonly fields: readonly string[];
+  };
+  readonly resourceSlots: readonly MaterialShaderResourceSlot[];
+  readonly uvSets: readonly { readonly parameter: string; readonly set: number }[];
+  readonly vertexInputs: readonly MaterialShaderVertexInput[];
+  readonly alphaMask: { readonly cutoff: string; readonly source: string };
+  readonly skinPaletteAddress?: {
+    readonly group: number;
+    readonly binding: number;
+    readonly stride: number;
+  };
+  readonly reflection: {
+    readonly layoutIdentity: string;
+    readonly resourceSlots: readonly MaterialShaderResourceSlot[];
+    readonly vertexInputs: readonly MaterialShaderVertexInput[];
+  };
+  readonly receiptIdentity: string;
+  readonly generation: number;
+}
+
 export interface MaterialShaderArtifact {
   readonly material: string;
   readonly pass: string;
   readonly wgsl: string;
   readonly layoutIdentity: string;
+  /** Naga-reflected UV set count used to derive clamp-to-last vertex aliases. */
+  readonly uvSetCount?: number;
   readonly bindings: readonly BindGroupLayoutDescriptor[];
   readonly deps: readonly string[];
   readonly vertexInputs: readonly Readonly<Record<string, unknown>>[];
   readonly specializationKey?: string;
+  /** Producer-owned ABI facts shared by direct and scene-index consumers. */
+  readonly receipt?: MaterialShaderArtifactReceipt;
+}
+
+const STANDARD_PBR_TEXTURES = [
+  'baseColorTexture',
+  'metallicRoughnessTexture',
+  'normalTexture',
+  'specularTintTexture',
+  'emissiveTexture',
+  'occlusionTexture',
+  'transmissionTexture',
+  'thicknessTexture',
+] as const;
+
+const STANDARD_PBR_NUMERIC_FIELDS = [
+  'baseColor',
+  'metallic',
+  'roughness',
+  'metallicChannel',
+  'roughnessChannel',
+  'aoChannel',
+  'extraChannel',
+  'emissive',
+  'emissiveIntensity',
+  'occlusionStrength',
+  'alphaCutoff',
+  'clearcoat',
+  'clearcoatRoughness',
+  'specularTint',
+  'normalScale',
+  'transmission',
+  'ior',
+  'thickness',
+  'attenuationColor',
+  'attenuationDistance',
+] as const;
+
+const STANDARD_PBR_VERTEX_INPUTS: readonly MaterialShaderVertexInput[] = [
+  { semantic: 'position', location: 0, format: 'float32x3' },
+  { semantic: 'normal', location: 1, format: 'float32x3' },
+  { semantic: 'uv', location: 2, format: 'float32x2' },
+  { semantic: 'tangent', location: 3, format: 'float32x4' },
+];
+
+function standardPbrResourceSlots(): MaterialShaderResourceSlot[] {
+  return STANDARD_PBR_TEXTURES.flatMap((parameter, index) => [
+    {
+      name: `${parameter}_sampler`,
+      parameter,
+      kind: 'sampler' as const,
+      group: 1,
+      binding: index * 2 + 1,
+    },
+    {
+      name: parameter,
+      parameter,
+      kind: 'texture' as const,
+      group: 1,
+      binding: index * 2 + 2,
+    },
+  ]);
+}
+
+/**
+ * Builds the one Standard PBR ABI receipt consumed by both material lanes.
+ * The skinned module uses the same material producer and only adds its palette
+ * address; it must retain the same receipt identity for material compatibility.
+ */
+export function createStandardPbrArtifactReceipt(skinned = false): MaterialShaderArtifactReceipt {
+  const resourceSlots = standardPbrResourceSlots();
+  const uvSets = STANDARD_PBR_TEXTURES.map((parameter) => ({ parameter, set: 0 }));
+  const vertexInputs = skinned
+    ? [
+        ...STANDARD_PBR_VERTEX_INPUTS,
+        { semantic: 'skinIndex', location: 4, format: 'uint16x4' },
+        { semantic: 'skinWeight', location: 5, format: 'float32x4' },
+      ]
+    : [...STANDARD_PBR_VERTEX_INPUTS];
+  return {
+    directEntry: 'vs_main',
+    sceneIndexEntry: 'vs_scene_index',
+    materialRow: { byteLength: 384, fields: [...STANDARD_PBR_NUMERIC_FIELDS] },
+    resourceSlots,
+    uvSets,
+    vertexInputs,
+    alphaMask: { cutoff: 'alphaCutoff', source: 'baseColor.a' },
+    ...(skinned ? { skinPaletteAddress: { group: 2, binding: 1, stride: 64 } } : {}),
+    reflection: {
+      layoutIdentity: 'standard-pbr/material-row-v1',
+      resourceSlots,
+      vertexInputs,
+    },
+    receiptIdentity: 'standard-pbr/material-row-v1',
+    generation: 1,
+  };
 }
 
 export function isMaterialShaderArtifact(value: unknown): value is MaterialShaderArtifact {

package/src/material-schemas.ts

@@ -1,4 +1,8 @@
 import type { ParamSchemaEntry } from '@forgeax/engine-types';
+import {
+  createStandardPbrArtifactReceipt,
+  type MaterialShaderArtifactReceipt,
+} from './material/artifact-types.js';
 
 export const STANDARD_PBR_ALPHA_CUTOFF_DEFAULT = 0;
 
@@ -34,6 +38,14 @@ export const DEFAULT_STANDARD_PBR_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [
   { name: 'thicknessTexture', type: 'texture2d' },
 ];
 
+/** The single producer receipt shared by direct and scene-index Standard PBR. */
+export const STANDARD_PBR_ARTIFACT_RECEIPT: MaterialShaderArtifactReceipt =
+  createStandardPbrArtifactReceipt();
+
+/** Skinned Standard PBR keeps the material receipt identity and adds palette ABI. */
+export const STANDARD_PBR_SKIN_ARTIFACT_RECEIPT: MaterialShaderArtifactReceipt =
+  createStandardPbrArtifactReceipt(true);
+
 export const DEFAULT_UNLIT_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [
   { name: 'baseColor', type: 'color', default: [1, 1, 1, 1] },
   { name: 'alphaCutoff', type: 'f32', default: 0 },

package/src/register-default-sprite-lit.ts

@@ -56,12 +56,9 @@ export interface SpriteLitCaps {
  * compiled by @forgeax/engine-vite-plugin-shader at build time and surfaced
  * in manifest.json. The caller reads it from the manifest entries.
  *
- * `caps.storageBuffer` switches the runtime BGL buffer types for
- * @group(0) bindings 1+2 (pointLightsBuffer / spotLightsBuffer):
- * `false` -> uniform fallback (AC-10 WebGL2 path); `true` -> read-only-storage.
- * The BGL itself is built downstream in runtime/pbr-pipeline.ts (sprite-lit
- * reuses pbr-view / pbr-mesh-array / pbr-instances unchanged; AC-07
- * BGL byte-identical).
+ * `caps.storageBuffer` is retained for the shared mesh/instance layout
+ * selection. Sprite-lit local lighting reads the same Standard Cluster group
+ * as PBR; the view group has no direct point/spot arrays.
  *
  * @param registry ShaderRegistry instance (engine boot path).
  * @param composedWgsl Post-naga_oil composed WGSL source string.

package/src/sprite-lit.wgsl

@@ -2,7 +2,7 @@
 #pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #define_import_path forgeax_material::sprite-lit
 
-#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture, packSceneTemporal}
 #import forgeax_scene_temporal::{packSceneTemporalV1, sceneViewZ}
 #ifdef CLUSTER_FORWARD_AVAILABLE
 #import forgeax_standard::cluster::{evaluateStandardClusterLights}
@@ -39,11 +39,11 @@
 // 1 string change in MaterialAsset.passes[0].shader).
 //
 // Bindings (byte-identical to sprite.wgsl so the 4 BindGroupLayout chain is
-// reused without a per-pipeline BGL; the 4 PBR-unused entries 3..6 bind
+// reused without a per-pipeline BGL; the PBR-unused entries 3..6 bind
 // pipelineState.defaultSampler + .defaultWhiteTextureView on the host side):
 //
 //   @group(0) @binding(0) view                       uniform
-//   @group(0) @binding(1..2) Standard Cluster storage (selected variant)
+//   @group(2) @binding(3..6) Standard Cluster storage (selected variant)
 //   @group(1) @binding(0) material                   uniform (sprite layout
 //                                                             colorTint /
 //                                                             region /

package/src/sprite.wgsl

@@ -152,7 +152,7 @@ fn resolveSpriteVertex(in : VsIn, idx : u32, vertex_index : u32) -> SpriteVertex
   // pivotAndSize.zw scaled the local quad AND the world matrix also scaled
   // it, producing the scale^2 visual size debt that research F-4 flagged.
   // Post-w11 there is one and only one scale source: the entity's
-  // Transform.world. The mesh's built-in vertex.pos is NOT consumed (sprite
+  // GlobalTransform.world. The mesh's built-in vertex.pos is NOT consumed (sprite
   // geometry is fully re-derived from uv + pivot) so HANDLE_QUAD's mesh.pos
   // remains a placeholder driving vertex count (4) and topology only.
   //

package/src/standard-cluster.wgsl

@@ -3,50 +3,56 @@
 //
 // The cluster module owns membership and raw payload decoding only. Punctual
 // BRDF, range, cone, PCF, and fail-open behavior live in lighting-punctual.
+// ProbeBlendRecord is intentionally absent: probes are not DirectLightSlot
+// members and this cluster owner never performs an all-probe loop.
 
 #define_import_path forgeax_standard::cluster
 
 #import forgeax_pbr::lighting_punctual::{evalPoint, evalPointFlat, evalSpot, evalSpotFlat, evalSpotShadowed}
 #import forgeax_pbr::lighting_attenuation::{projectSpotUv}
+#import forgeax_pbr::lighting_spot_modifiers::{spotModifierFactors}
+#import forgeax_pbr::lighting_rect_area::{evalRectAreaLtcGgx}
 #import forgeax_view::common::{view}
 #ifdef PROJECTOR_AVAILABLE
+#ifdef EXTENDED_LIGHTING_AVAILABLE
+#import forgeax_view::common::{spotModifierSampler, cookieTexture}
+#else
+#ifndef EXTENDED_LIGHTING_AVAILABLE
 #import forgeax_view::common::{projectorTexture, projectorSampler}
 #endif
+#endif
+#endif
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
+#import forgeax_view::common::{shadowParams}
 #endif
 
 #ifdef CLUSTER_FORWARD_AVAILABLE
 
 const KIND_POINT: u32 = 0u;
 const KIND_SPOT: u32 = 1u;
-// LightSlot.kind_and_shadow.y uses one high bit as the accepted projector
-// marker. The remaining bits are the shadow-atlas tile (0..3), with zero as
-// the explicit View-UBO lane for projector-only spots.
+const KIND_RECT_AREA: u32 = 2u;
 const PROJECTOR_FLAG: i32 = 0x40000000;
 const TILE_MASK: i32 = 0x3fffffff;
 
-// LightSlot is the byte-frozen 64B std430/std140 transport contract.
-// [0..2] position, [3] invRangeSquared
-// [4..6] colorTimesIntensity, [7] cosInner
-// [8..10] direction, [11] cosOuter
-// [12] raw kind u32, [13] shadow identity i32
-// [14..15] point near/far f32 bits; spot keeps these lanes zero.
-struct LightSlot {
-  position        : vec4<f32>,
-  color           : vec4<f32>,
-  direction       : vec4<f32>,
-  kind_and_shadow : vec4<u32>,
+// DirectLightSlot is the byte-frozen 80B std430/std140 transport contract.
+// The named rows match the host packer; metadata carries kind and identities.
+struct DirectLightSlot {
+  position            : vec4<f32>,
+  colorTimesIntensity : vec4<f32>,
+  direction           : vec4<f32>,
+  auxiliary           : vec4<f32>,
+  metadata            : vec4<u32>,
 };
 
-const LIGHTSLOT_BYTE_SIZE: u32 = 64u;
+const DIRECT_LIGHT_SLOT_BYTE_SIZE: u32 = 80u;
 
 struct ClusterUniform {
   grid         : vec4<u32>,
   near_far_log : vec4<f32>,
 };
 
-@group(2) @binding(3) var<storage, read> light_data      : array<LightSlot, 256>;
+@group(2) @binding(3) var<storage, read> light_data      : array<DirectLightSlot, 256>;
 @group(2) @binding(4) var<storage, read> cluster_grid     : array<u32>;
 @group(2) @binding(5) var<storage, read> light_index_list : array<u32>;
 @group(2) @binding(6) var<uniform> cluster_uniform : ClusterUniform;
@@ -91,19 +97,27 @@ fn ndc_position_to_cluster(
 
 // Surface SpotLight projector sampling is owned by the same clustered light
 // evaluator as the analytic cone/range contribution. The host marks the
-// selected projector in the LightSlot flag and writes its matrix to the
+// selected projector in the DirectLightSlot flag and writes its matrix to the
 // corresponding View lane (lane 0 for projector-only); no second
 // material-local sampling loop or resource owner is allowed.
 fn sampleStandardSpotProjector(
   lightViewProj : mat4x4<f32>,
   world_pos    : vec3<f32>,
+  metadata     : vec4<u32>,
 ) -> vec3<f32> {
 #ifdef PROJECTOR_AVAILABLE
   let uv = projectSpotUv(lightViewProj, world_pos);
   if (!(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)) {
     return vec3<f32>(1.0);
   }
+#ifdef EXTENDED_LIGHTING_AVAILABLE
+  if (metadata.w == 0xffffffffu) {
+    return vec3<f32>(1.0);
+  }
+  return textureSampleLevel(cookieTexture, spotModifierSampler, uv, metadata.w, 0.0).rgb;
+#else
   return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
+#endif
 #else
   return vec3<f32>(1.0);
 #endif
@@ -112,7 +126,7 @@ fn sampleStandardSpotProjector(
 // Decode one kind first, then delegate the complete evaluation to the shared
 // punctual owner. Unknown kinds are explicitly zero contribution.
 fn evaluate_cluster_light(
-  light      : LightSlot,
+  light      : DirectLightSlot,
   world_pos  : vec3<f32>,
   normal     : vec3<f32>,
   view_dir   : vec3<f32>,
@@ -122,78 +136,101 @@ fn evaluate_cluster_light(
   f0         : vec3<f32>,
   flat_2d    : bool,
 ) -> vec3<f32> {
-  let kind = light.kind_and_shadow.x;
+  let kind = light.metadata.x;
   if (kind == KIND_POINT) {
     if (flat_2d) {
       return evalPointFlat(
-        light.position.xyz, light.color.xyz, light.position.w,
+        light.position.xyz, light.colorTimesIntensity.xyz, light.position.w,
         world_pos, base_color,
       );
     }
 #ifdef POINT_SHADOW_AVAILABLE
-    let layer = bitcast<i32>(light.kind_and_shadow.y);
+    let layer = bitcast<i32>(light.metadata.y);
     if (layer >= 0) {
+      let shadow = shadowParams[layer];
       return evalPointShadowed(
-        light.position.xyz, light.color.xyz, light.position.w,
+        light.position.xyz, light.colorTimesIntensity.xyz, light.position.w,
         world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
         layer,
-        bitcast<f32>(light.kind_and_shadow.z),
-        bitcast<f32>(light.kind_and_shadow.w),
+        shadow.x,
+        shadow.y,
         0.005, 0.05,
       );
     }
 #endif
     return evalPoint(
-      light.position.xyz, light.color.xyz, light.position.w,
+      light.position.xyz, light.colorTimesIntensity.xyz, light.position.w,
       world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
     );
   }
   if (kind == KIND_SPOT) {
     if (flat_2d) {
       return evalSpotFlat(
-        light.position.xyz, light.direction.xyz, light.color.xyz,
-        light.color.w, light.direction.w, light.position.w,
+        light.position.xyz, light.direction.xyz, light.colorTimesIntensity.xyz,
+        light.colorTimesIntensity.w, light.direction.w, light.position.w,
         world_pos, base_color,
       );
     }
-    let encoded_tile = bitcast<i32>(light.kind_and_shadow.y);
-    // The unshadowed sentinel is -1. A signed bitwise test against the
-    // projector flag would misclassify that sentinel because -1 has every bit
-    // set, so admit the flag only from the non-negative encoded domain.
+    let modifierFactors = spotModifierFactors(
+      light.position.xyz,
+      light.direction.xyz,
+      light.direction.w,
+      world_pos,
+      light.auxiliary.w,
+      light.metadata,
+    );
+    let modifier = vec3<f32>(modifierFactors.x) * modifierFactors.yzw;
+    let encoded_tile = bitcast<i32>(light.metadata.y);
+    // The optional projector marker shares the non-negative shadow identity
+    // lane. The direct-light packer keeps the lower tile bits intact.
+    var projector_selected = false;
+    var tile : i32 = encoded_tile;
     if (encoded_tile >= 0 && (encoded_tile & PROJECTOR_FLAG) != 0) {
-      let tile = encoded_tile & TILE_MASK;
-      if (tile < 4) {
-        let projector = sampleStandardSpotProjector(view.spotLightViewProj[tile], world_pos);
-        return evalSpotShadowed(
-          light.position.xyz, light.direction.xyz, light.color.xyz,
-          // LightSlot packs cosInner in color.w and cosOuter in direction.w;
-          // keep the evaluator's named cone order intact at the decode boundary.
-          light.color.w, light.direction.w, light.position.w,
-          world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
-          view.spotLightViewProj[tile], tile, 0.005, 0.05,
-          bitcast<f32>(light.kind_and_shadow.w),
-          bitcast<f32>(light.kind_and_shadow.z),
-        ) * projector;
-      }
-      return vec3<f32>(0.0);
+      projector_selected = true;
+      tile = encoded_tile & TILE_MASK;
     }
-    if (encoded_tile >= 0 && encoded_tile < 4) {
-      let tile = encoded_tile;
+    if (tile >= 0 && tile < 4) {
       return evalSpotShadowed(
-        light.position.xyz, light.direction.xyz, light.color.xyz,
-        // LightSlot packs cosInner in color.w and cosOuter in direction.w;
+        light.position.xyz, light.direction.xyz, light.colorTimesIntensity.xyz,
+        // DirectLightSlot packs cosInner in color.w and cosOuter in direction.w;
         // keep the evaluator's named cone order intact at the decode boundary.
-        light.color.w, light.direction.w, light.position.w,
-        world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+        light.colorTimesIntensity.w, light.direction.w, light.position.w,
+          world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
         view.spotLightViewProj[tile], tile, 0.005, 0.05,
-        bitcast<f32>(light.kind_and_shadow.w),
-        bitcast<f32>(light.kind_and_shadow.z),
-      );
+        3.0,
+        1.0,
+      ) * modifier
+#ifdef PROJECTOR_AVAILABLE
+        * select(
+          vec3<f32>(1.0),
+          sampleStandardSpotProjector(view.spotLightViewProj[tile], world_pos, light.metadata),
+          projector_selected,
+        )
+#endif
+      ;
     }
     return evalSpot(
-      light.position.xyz, light.direction.xyz, light.color.xyz,
-      light.color.w, light.direction.w, light.position.w,
+      light.position.xyz, light.direction.xyz, light.colorTimesIntensity.xyz,
+      light.colorTimesIntensity.w, light.direction.w, light.position.w,
       world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+    ) * modifier;
+  }
+  if (kind == KIND_RECT_AREA) {
+    return evalRectAreaLtcGgx(
+      light.position.xyz,
+      light.colorTimesIntensity.xyz,
+      light.auxiliary.xyz,
+      light.direction.xyz,
+      light.colorTimesIntensity.w,
+      light.direction.w,
+      light.position.w,
+      world_pos,
+      normal,
+      view_dir,
+      base_color,
+      metallic,
+      alpha_sq,
+      f0,
     );
   }
   return vec3<f32>(0.0);

package/src/types.ts

@@ -17,6 +17,7 @@
  * no longer carry a bindingLayout sidecar (§Change stance: no v1/v2
  * dual-path, no incremental drop window).
  */
+import type { MaterialShaderArtifactReceipt } from './material/artifact-types.js';
 export interface MaterialShaderManifestVariant {
   readonly definesKey: string;
   readonly defines: Record<string, boolean>;
@@ -33,7 +34,7 @@ export interface MaterialShaderManifestVariant {
  *
  * For Engine.create() internal use only; AI users never see this type.
  */
-export interface MaterialShaderManifestEntry {
+export interface MaterialShaderManifestEntry extends Partial<MaterialShaderArtifactReceipt> {
   readonly identifier: string;
   readonly sourcePath: string;
   readonly composedWgsl: string;

package/src/volume/volume-inject.wgsl

@@ -1,6 +1,7 @@
 #define_import_path forgeax_view::volume_inject
 #import forgeax_pbr::shadow_pcf::{sample_shadow_2d_kernel}
 #import forgeax_pbr::lighting_attenuation::{projectSpotUv}
+#import forgeax_view::common::{DirectLightSlot}
 // forgeax_pbr::lighting_punctual exports the surface-equivalent
 // evalVolumePoint and evalVolumeSpot contract; this stage consumes their
 // shared projector and shadow visibility facts without a second light owner.
@@ -29,41 +30,18 @@ struct VolumeParams {
   optics : vec4<f32>,
 };
 
-struct SpotLight {
-  position : vec3<f32>,
-  invRangeSquared : f32,
-  colorTimesIntensity : vec3<f32>,
-  cosInner : f32,
-  direction : vec3<f32>,
-  cosOuter : f32,
-  depthBias : f32,
-  normalBias : f32,
-  pcfKernelSize : f32,
-  shadowAtlasTile : i32,
-  shadowIntensity : f32,
-};
-
-struct SpotLightsArray {
-  count : u32,
-  slots : array<SpotLight, 4>,
-};
-
-struct PointLight {
-  position : vec3<f32>,
-  invRangeSquared : f32,
-  colorTimesIntensity : vec3<f32>,
-  shadowAtlasLayer : i32,
-};
+const DIRECT_LIGHT_METADATA_SENTINEL : u32 = 0xffffffffu;
+const DIRECT_LIGHT_TILE_MASK : u32 = 0x3fffffffu;
 
-struct PointLightsArray {
-  count : u32,
-  slots : array<PointLight, 4>,
+struct ClusterUniform {
+  grid : vec4<u32>,
+  near_far_log : vec4<f32>,
 };
 
 @group(0) @binding(5) var<uniform> volume_params : VolumeParams;
 @group(0) @binding(6) var volume_froxel : texture_storage_2d_array<rgba8unorm, write>;
-@group(0) @binding(7) var<storage, read> spotLightsBuffer : SpotLightsArray;
-@group(0) @binding(8) var<storage, read> pointLightsBuffer : PointLightsArray;
+@group(0) @binding(7) var<storage, read> light_data : array<DirectLightSlot, 256>;
+@group(0) @binding(8) var<uniform> cluster_uniform : ClusterUniform;
 @group(0) @binding(0) var<uniform> view : View;
 
 fn reconstruct_world(uv : vec2<f32>, depth : f32) -> vec3<f32> {
@@ -161,12 +139,32 @@ fn volume_cascade(world_position : vec3<f32>, view_depth : f32) -> f32 {
   );
 }
 
+fn shadowAtlasTile(light : DirectLightSlot) -> i32 {
+  let encoded = light.metadata.y;
+  if (encoded == DIRECT_LIGHT_METADATA_SENTINEL) { return -1; }
+  // Projector-selected spots carry the marker in bit 30 and retain the
+  // selected shadow tile in the lower 30 bits. A projector-only spot uses
+  // tile zero, matching the surface projector contract.
+  let tile = encoded & DIRECT_LIGHT_TILE_MASK;
+  if (tile >= 4u) { return -1; }
+  return i32(tile);
+}
+
+fn selected_cluster_light_slot(value : f32) -> i32 {
+  let slot = i32(round(value));
+  if (slot < 0) { return -1; }
+  let index = u32(slot);
+  if (index >= cluster_uniform.grid.w || index >= 256u) { return -1; }
+  return slot;
+}
+
 fn spot_shadow_visibility_at(world_position : vec3<f32>) -> f32 {
-  let slot = u32(clamp(round(volume_params.light_color.w), 0.0, 3.0));
-  if (slot >= spotLightsBuffer.count) { return 0.0; }
-  let light = spotLightsBuffer.slots[slot];
-  if (light.shadowAtlasTile < 0) { return 1.0; }
-  let tile = u32(light.shadowAtlasTile);
+  let slot = selected_cluster_light_slot(volume_params.light_color.w);
+  if (slot < 0) { return 0.0; }
+  let light = light_data[u32(slot)];
+  let encodedTile = shadowAtlasTile(light);
+  if (encodedTile < 0) { return 1.0; }
+  let tile = u32(encodedTile);
   let projectorUv = projectSpotUv(view.spotLightViewProj[tile], world_position);
   // The accepted projector tuple is sampled with textureSampleLevel by the
   // surface and volume owners when a projector texture is present.
@@ -186,7 +184,7 @@ fn spot_shadow_visibility_at(world_position : vec3<f32>) -> f32 {
   let shadow_size = vec2<f32>(textureDimensions(shadowMap));
   return sample_shadow_2d_kernel(
     shadowMap, shadowSampler, atlas_uv, 1.0 / shadow_size, projected.z,
-    light.normalBias, light.depthBias, 1.0, light.pcfKernelSize,
+    light.auxiliary.y, light.auxiliary.x, 1.0, 3.0,
   );
 }