@forgeax/engine-shader 0.1.20 → 0.1.23

package/src/standard-cluster.wgsl

@@ -0,0 +1,274 @@
+// standard-cluster.wgsl — Standard clustered punctual light evaluation.
+// feat-20260608-cluster-lighting M4 / w17.
+//
+// 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;
+const KIND_RECT_AREA: u32 = 2u;
+const PROJECTOR_FLAG: i32 = 0x40000000;
+const TILE_MASK: i32 = 0x3fffffff;
+
+// 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 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<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;
+
+fn get_ssao_intensity() -> f32 {
+  return cluster_uniform.near_far_log.w;
+}
+
+fn view_z_to_z_slice(
+  view_z : f32,
+  grid_z : u32,
+  near   : f32,
+  far    : f32,
+  log_far_over_near : f32,
+) -> u32 {
+  if (view_z >= -near) {
+    return 0u;
+  }
+  let slice = floor(log(-view_z / near) / log_far_over_near * f32(grid_z));
+  let u_slice = u32(slice);
+  if (u_slice >= grid_z) {
+    return grid_z - 1u;
+  }
+  return u_slice;
+}
+
+fn ndc_position_to_cluster(
+  ndc     : vec3<f32>,
+  view_z  : f32,
+  grid_x  : u32,
+  grid_y  : u32,
+  grid_z  : u32,
+  near    : f32,
+  far     : f32,
+  log_far : f32,
+) -> vec3<u32> {
+  let cx = clamp(u32(floor((ndc.x * 0.5 + 0.5) * f32(grid_x))), 0u, grid_x - 1u);
+  let cy = clamp(u32(floor((ndc.y * 0.5 + 0.5) * f32(grid_y))), 0u, grid_y - 1u);
+  let cz = view_z_to_z_slice(view_z, grid_z, near, far, log_far);
+  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 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
+}
+
+// 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      : DirectLightSlot,
+  world_pos  : vec3<f32>,
+  normal     : vec3<f32>,
+  view_dir   : vec3<f32>,
+  base_color : vec3<f32>,
+  metallic   : f32,
+  alpha_sq   : f32,
+  f0         : vec3<f32>,
+  flat_2d    : bool,
+) -> vec3<f32> {
+  let kind = light.metadata.x;
+  if (kind == KIND_POINT) {
+    if (flat_2d) {
+      return evalPointFlat(
+        light.position.xyz, light.colorTimesIntensity.xyz, light.position.w,
+        world_pos, base_color,
+      );
+    }
+#ifdef POINT_SHADOW_AVAILABLE
+    let layer = bitcast<i32>(light.metadata.y);
+    if (layer >= 0) {
+      let shadow = shadowParams[layer];
+      return evalPointShadowed(
+        light.position.xyz, light.colorTimesIntensity.xyz, light.position.w,
+        world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+        layer,
+        shadow.x,
+        shadow.y,
+        0.005, 0.05,
+      );
+    }
+#endif
+    return evalPoint(
+      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.colorTimesIntensity.xyz,
+        light.colorTimesIntensity.w, light.direction.w, light.position.w,
+        world_pos, base_color,
+      );
+    }
+    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) {
+      projector_selected = true;
+      tile = encoded_tile & TILE_MASK;
+    }
+    if (tile >= 0 && tile < 4) {
+      return evalSpotShadowed(
+        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.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,
+        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.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);
+}
+
+fn evaluateStandardClusterLights(
+  ndc        : vec3<f32>,
+  view_z     : f32,
+  world_pos  : vec3<f32>,
+  normal     : vec3<f32>,
+  view_dir   : vec3<f32>,
+  base_color : vec3<f32>,
+  metallic   : f32,
+  alpha_sq   : f32,
+  f0         : vec3<f32>,
+  flat_2d    : bool,
+) -> vec3<f32> {
+  let gx = cluster_uniform.grid.x;
+  let gy = cluster_uniform.grid.y;
+  let gz = cluster_uniform.grid.z;
+  let near = cluster_uniform.near_far_log.x;
+  let far = cluster_uniform.near_far_log.y;
+  let log_far = cluster_uniform.near_far_log.z;
+  var total_radiance = vec3<f32>(0.0);
+
+  let cluster_idx = ndc_position_to_cluster(ndc, view_z, gx, gy, gz, near, far, log_far);
+  let cluster_linear = cluster_idx.z * gy * gx + cluster_idx.y * gx + cluster_idx.x;
+  let grid_offset = cluster_linear * 2u;
+  let list_offset = cluster_grid[grid_offset];
+  let list_count = cluster_grid[grid_offset + 1u];
+  for (var i = 0u; i < list_count; i = i + 1u) {
+    let light = light_data[light_index_list[list_offset + i]];
+    total_radiance += evaluate_cluster_light(
+      light, world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
+      flat_2d,
+    );
+  }
+  return total_radiance;
+}
+
+#endif // CLUSTER_FORWARD_AVAILABLE

package/src/tonemap.wgsl

@@ -9,7 +9,7 @@
 
 #import forgeax_view::common::FullscreenOutput
 #import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::common::linearToSrgbOetf
+#import forgeax_view::common::{linearToSrgbOetf, ditherUnorm8}
 
 const TONEMAP_LUMINANCE_EPSILON : f32 = 1e-5;
 
@@ -17,7 +17,7 @@ struct TonemapParams {
   exposure   : f32,
   whitePoint : f32,
   mode       : u32,
-  pad1       : f32,
+  ditherEnabled : f32,
 };
 
 @group(1) @binding(0) var hdr  : texture_2d<f32>;
@@ -171,5 +171,10 @@ fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
   }
   // Every public mode reaches exactly one shared sRGB OETF.
   let encoded = linearToSrgbOetf(mapped);
-  return vec4<f32>(encoded, source.a);
+  let output = select(
+    encoded,
+    ditherUnorm8(encoded, in.position.xy),
+    params.ditherEnabled > 0.5,
+  );
+  return vec4<f32>(output, source.a);
 }

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.
@@ -9,7 +10,8 @@ struct View {
   worldViewProj : mat4x4<f32>, lightDir : vec3<f32>, lightColor : vec3<f32>, cameraPos : vec3<f32>,
   lightViewProj_A : mat4x4<f32>, inverseViewProj : mat4x4<f32>, lightViewProj_B : mat4x4<f32>,
   lightViewProj_C : mat4x4<f32>, lightViewProj_D : mat4x4<f32>, splitPlanes : array<vec4<f32>,4>,
-  cascadeCount : f32, cascadeBlend : f32, depthBias : f32, normalBias : f32, pcfKernelSize : f32,
+  cascadeCount : f32, cascadeBlend : f32, depthBias : f32, normalBias : f32,
+  directionalShadowFilter : vec4<f32>,
   spotLightViewProj : array<mat4x4<f32>,4>, temporalCurrentViewProj : mat4x4<f32>,
   temporalPreviousViewProj : mat4x4<f32>, temporalProjection : vec4<f32>, temporalPreviousCameraPos : vec4<f32>,
 };
@@ -28,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> {
@@ -143,18 +122,49 @@ fn volume_cascade(world_position : vec3<f32>, view_depth : f32) -> f32 {
   if (!(tile_uv.x >= 0.0 && tile_uv.x <= 1.0 && tile_uv.y >= 0.0 && tile_uv.y <= 1.0 && projected.z <= 1.0)) { return 1.0; }
   let uv = tile_uv * tile_scale + vec2<f32>(tile) * tile_scale;
   let shadow_size = vec2<f32>(textureDimensions(shadowMap));
+  let filter_profile = clamp(u32(round(view.directionalShadowFilter.x)), 1u, 5u);
+  // Volumetric injection currently owns a depth-only PCF receiver. Directional
+  // PCSS profiles remain an explicit capability fallback here: the surface
+  // directional owner performs blocker search, while volume keeps the same
+  // accepted filter carrier and uses the stable PCF3 receiver instead of
+  // misreading profiles 4/5 as a kernel width.
+  let volume_kernel = select(
+    select(select(3.0, 5.0, filter_profile == 3u), 1.0, filter_profile == 1u),
+    3.0,
+    filter_profile >= 4u,
+  );
   return sample_shadow_2d_kernel(
     shadowMap, shadowSampler, uv, 1.0 / shadow_size, projected.z,
-    0.0, view.depthBias, 1.0, view.pcfKernelSize,
+    0.0, view.depthBias, 1.0, volume_kernel,
   );
 }
 
+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.
@@ -174,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

@@ -1,6 +1,8 @@
 #define_import_path forgeax_view::volume_integrate
 // 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>,
@@ -10,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>,
@@ -68,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;
 
@@ -106,32 +100,43 @@ fn evalSpotAttenuation(
   return distance * smoothstep(cosOuter, cosInner, dot(direction, -normalize(lightDir)));
 }
 
-fn projectSpotUv(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec2<f32> {
-  let clip = lightViewProj * vec4<f32>(worldPos, 1.0);
-  let invW = select(1.0 / clip.w, 0.0, abs(clip.w) < 1e-6);
-  return vec2<f32>(clip.x * invW * 0.5 + 0.5, clip.y * invW * -0.5 + 0.5);
+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 : SpotLight) -> mat4x4<f32> {
-  if (light.shadowAtlasTile >= 0) {
-    return volume_view.spotLightViewProj[light.shadowAtlasTile];
+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,
   );
 }
 
@@ -156,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)) {
@@ -183,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> {