@forgeax/engine-shader 0.1.21 → 0.1.24

package/src/standard-cluster.wgsl

@@ -3,50 +3,49 @@
 //
 // 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
-#import forgeax_view::common::{projectorTexture, projectorSampler}
+#import forgeax_pbr::lighting_spot_projector::{sampleStandardSpotProjector}
 #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;
@@ -89,30 +88,10 @@ fn ndc_position_to_cluster(
   return vec3(cx, cy, cz);
 }
 
-// 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
-// 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>,
-) -> 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);
-  }
-  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
-#else
-  return vec3<f32>(1.0);
-#endif
-}
-
 // 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 +101,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/surface_v1.wgsl

@@ -0,0 +1,26 @@
+#define_import_path forgeax_material::surface_v1
+
+// Engine-owned input ABI for authored Standard material surfaces.
+struct SurfaceInput {
+  positionOS : vec3<f32>,
+  positionWS : vec3<f32>,
+  geometricNormalWS : vec3<f32>,
+  tangentWS : vec4<f32>,
+  viewDirectionWS : vec3<f32>,
+  uv0 : vec2<f32>,
+  uv1 : vec2<f32>,
+  vertexColor : vec4<f32>,
+  frontFacing : bool,
+};
+
+// Surface output is consumed by the Standard BRDF and pass family.
+struct SurfaceData {
+  baseColor : vec3<f32>,
+  normalWS : vec3<f32>,
+  metallic : f32,
+  roughness : f32,
+  emissive : vec3<f32>,
+  occlusion : f32,
+  opacity : f32,
+  alphaClipThreshold : f32,
+};

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,
   );
 }
 

package/src/volume/volume-integrate.wgsl

@@ -2,6 +2,7 @@
 // forgeax_pbr::lighting_punctual remains the surface contract; the isolated
 // attenuation module below provides its resource-free volume equivalents.
 #import forgeax_pbr::lighting_attenuation::{projectSpotUv}
+#import forgeax_view::common::{DirectLightSlot}
 
 struct VolumeView {
   _prefix : array<vec4<f32>, 6>,
@@ -11,20 +12,12 @@ struct VolumeView {
   _viewTail : array<vec4<f32>, 18>,
   spotLightViewProj : array<mat4x4<f32>, 4>,
 };
-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,
+// Volume reads the same full light_data payload as Standard surface Cluster;
+// it has no secondary light mirror.
+struct ClusterUniform {
+  grid : vec4<u32>,
+  near_far_log : vec4<f32>,
 };
-struct SpotLightsArray { count : u32, slots : array<SpotLight, 4>, };
-struct PointLight {
-  position : vec3<f32>, invRangeSquared : f32,
-  colorTimesIntensity : vec3<f32>, shadowAtlasLayer : i32,
-};
-struct PointLightsArray { count : u32, slots : array<PointLight, 4>, };
 struct VolumeParams {
   bounds_min : vec4<f32>, bounds_max : vec4<f32>, extinction : vec4<f32>, albedo : vec4<f32>,
   emission : vec4<f32>, light_direction : vec4<f32>, light_color : vec4<f32>, optics : vec4<f32>,
@@ -69,8 +62,8 @@ fn stratified32(seed : u32, frame_index : u32, odd_stride : u32) -> f32 {
 @group(0) @binding(7) var density_sampler : sampler;
 @group(0) @binding(8) var history_seed : texture_storage_2d<rgba16float, write>;
 @group(0) @binding(9) var temporal_seed : texture_storage_2d<rgba16float, write>;
-@group(0) @binding(10) var<storage, read> spotLightsBuffer : SpotLightsArray;
-@group(0) @binding(11) var<storage, read> pointLightsBuffer : PointLightsArray;
+@group(0) @binding(10) var<storage, read> light_data : array<DirectLightSlot, 256>;
+@group(0) @binding(11) var<uniform> cluster_uniform : ClusterUniform;
 @group(0) @binding(12) var projectorTexture : texture_2d<f32>;
 @group(0) @binding(13) var projectorSampler : sampler;
 
@@ -107,26 +100,43 @@ fn evalSpotAttenuation(
   return distance * smoothstep(cosOuter, cosInner, dot(direction, -normalize(lightDir)));
 }
 
-fn spotProjectorMatrix(light : SpotLight) -> mat4x4<f32> {
-  if (light.shadowAtlasTile >= 0) {
-    return volume_view.spotLightViewProj[light.shadowAtlasTile];
+fn shadowAtlasTile(light : DirectLightSlot) -> i32 {
+  let encoded = light.metadata.y;
+  if (encoded == 0xffffffffu) { return -1; }
+  let tile = encoded & 0x3fffffffu;
+  if (tile >= 4u) { return -1; }
+  return i32(tile);
+}
+
+fn spotProjectorMatrix(light : DirectLightSlot) -> mat4x4<f32> {
+  let tile = shadowAtlasTile(light);
+  if (tile >= 0) {
+    return volume_view.spotLightViewProj[tile];
   }
   return volume_view.spotLightViewProj[0];
 }
 
+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_attenuation_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];
+  let slot = selected_cluster_light_slot(volume_params.light_color.w);
+  if (slot < 0) { return 0.0; }
+  let light = light_data[u32(slot)];
   let projectorUv = projectSpotUv(spotProjectorMatrix(light), world_position);
   if (any(projectorUv < vec2<f32>(0.0)) || any(projectorUv > vec2<f32>(1.0))) { return 0.0; }
   return evalSpotAttenuation(
-    light.position,
-    light.direction,
+    light.position.xyz,
+    light.direction.xyz,
     world_position,
-    light.cosInner,
-    light.cosOuter,
-    light.invRangeSquared,
+    light.colorTimesIntensity.w,
+    light.direction.w,
+    light.position.w,
   );
 }
 
@@ -151,21 +161,21 @@ fn evalVolumeSpot(
 }
 
 fn volume_point_radiance(world_position : vec3<f32>) -> vec3<f32> {
-  let pointSlot = u32(clamp(round(volume_params.emission.w), 0.0, 3.0));
-  if (pointSlot >= pointLightsBuffer.count) { return vec3<f32>(0.0); }
-  let point = pointLightsBuffer.slots[pointSlot];
+  let pointSlot = selected_cluster_light_slot(volume_params.emission.w);
+  if (pointSlot < 0) { return vec3<f32>(0.0); }
+  let point = light_data[u32(pointSlot)];
   return evalVolumePoint(
-    point.position, point.colorTimesIntensity, point.invRangeSquared, world_position,
+    point.position.xyz, point.colorTimesIntensity.xyz, point.position.w, world_position,
   );
 }
 
 fn volume_spot_radiance(world_position : vec3<f32>) -> vec3<f32> {
-  let spotSlot = u32(clamp(round(volume_params.light_color.w), 0.0, 3.0));
-  if (spotSlot >= spotLightsBuffer.count) { return vec3<f32>(0.0); }
-  let spot = spotLightsBuffer.slots[spotSlot];
+  let spotSlot = selected_cluster_light_slot(volume_params.light_color.w);
+  if (spotSlot < 0) { return vec3<f32>(0.0); }
+  let spot = light_data[u32(spotSlot)];
   let radiance = evalVolumeSpot(
-    spot.position, spot.direction, spot.colorTimesIntensity,
-    spot.cosInner, spot.cosOuter, spot.invRangeSquared, world_position,
+    spot.position.xyz, spot.direction.xyz, spot.colorTimesIntensity.xyz,
+    spot.colorTimesIntensity.w, spot.direction.w, spot.position.w, world_position,
   );
   let projectorUv = projectSpotUv(spotProjectorMatrix(spot), world_position);
   if (!(projectorUv.x >= 0.0 && projectorUv.x <= 1.0 && projectorUv.y >= 0.0 && projectorUv.y <= 1.0)) {
@@ -178,9 +188,9 @@ fn volume_spot_radiance(world_position : vec3<f32>) -> vec3<f32> {
 }
 
 fn volume_spot_shadow_intensity() -> f32 {
-  let spotSlot = u32(clamp(round(volume_params.light_color.w), 0.0, 3.0));
-  if (spotSlot >= spotLightsBuffer.count) { return 1.0; }
-  return clamp(spotLightsBuffer.slots[spotSlot].shadowIntensity, 0.0, 1.0);
+  let spotSlot = selected_cluster_light_slot(volume_params.light_color.w);
+  if (spotSlot < 0) { return 1.0; }
+  return clamp(light_data[u32(spotSlot)].auxiliary.z, 0.0, 1.0);
 }
 
 fn volume_light_radiance(world_position : vec3<f32>) -> vec3<f32> {