@forgeax/engine-shader 0.1.20 → 0.1.21

package/src/sprite-lit.wgsl

@@ -1,8 +1,12 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
+#pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #define_import_path forgeax_material::sprite-lit
 
-#import forgeax_view::common::{View, Mesh, InstanceData, PointLight, SpotLight, view, meshes, instances, pointLightsBuffer, spotLightsBuffer, sampleMaterialTexture}
-#import forgeax_scene_temporal::{packSceneTemporalV1}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1, sceneViewZ}
+#ifdef CLUSTER_FORWARD_AVAILABLE
+#import forgeax_standard::cluster::{evaluateStandardClusterLights}
+#endif
 
 // @forgeax/engine-shader - sprite-lit.wgsl
 // (tweak-20260701-sprite-lit-flat-default-drop-ndotl-for-2d).
@@ -26,7 +30,8 @@
 //   - no shadow receiver / caster
 //   - no Godot-style light_mode blends
 //   - no IBL ambient
-//   - no HDRP cluster-forward path
+//   - Standard clustered punctual lights are enabled by the
+//     CLUSTER_FORWARD_AVAILABLE variant.
 //
 // >>> AI user error self-recovery hint:
 // sprite-lit needs at least one light in scene; for unlit sprites use
@@ -38,8 +43,7 @@
 // pipelineState.defaultSampler + .defaultWhiteTextureView on the host side):
 //
 //   @group(0) @binding(0) view                       uniform
-//   @group(0) @binding(1) pointLightsBuffer          storage / uniform (variant)
-//   @group(0) @binding(2) spotLightsBuffer           storage / uniform (variant)
+//   @group(0) @binding(1..2) Standard Cluster storage (selected variant)
 //   @group(1) @binding(0) material                   uniform (sprite layout
 //                                                             colorTint /
 //                                                             region /
@@ -80,16 +84,17 @@ struct VsIn {
   @location(3) tangent : vec4<f32>,
 };
 
-// VsOut carries the atlas UV plus the per-fragment world-space position.
-// The world position is emitted from the vertex stage (already computed
-// there for `out.clip`), so PointLight / SpotLight attenuation gets an
-// exact per-fragment worldPos through interpolation. This replaces the
-// earlier fragment-side reconstruction path, which collapsed under
-// multi-instance draws and could not handle the 9-slice quad layout.
+// VsOut carries the atlas UV plus the per-fragment world-space position and
+// the Standard cluster coordinates produced by the vertex stage. Fragment
+// `@builtin(position)` is framebuffer-space after rasterization, so it is not
+// a valid source for NDC cluster lookup; keep the perspective divide here and
+// interpolate the result alongside worldPos.
 struct VsOut {
   @builtin(position) clip     : vec4<f32>,
   @location(0)       uv_atlas : vec2<f32>,
   @location(1)       worldPos : vec3<f32>,
+  @location(2)       ndc      : vec3<f32>,
+  @location(3)       viewZ    : f32,
 };
 
 struct SpriteVertex {
@@ -155,6 +160,11 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32, @builtin(vertex_index)
   out.clip = view.worldViewProj * world;
   out.uv_atlas = vertex.uvAtlas;
   out.worldPos = world.xyz;
+  let clipPos = out.clip;
+  out.ndc = clipPos.xyz / clipPos.w;
+  // Keep the cluster depth exactly aligned with the CPU binner for both
+  // perspective and off-axis orthographic projections.
+  out.viewZ = sceneViewZ(clipPos, view.temporalProjection);
   return out;
 }
 
@@ -174,50 +184,24 @@ fn spriteLitDirectional(albedo : vec3<f32>) -> vec3<f32> {
   return albedo * view.lightColor;
 }
 
-// Flat point-light contribution. Applies the KHR-lights-punctual smooth-
-// window range attenuation only. `attenuation` is 0 outside the light's
-// range (`invRangeSquared`) and 1 at the light center; the reciprocal-square
-// term gives the physical falloff. URP cap = 4 point lights per pass.
-fn spriteLitPoint(p : PointLight, worldPos : vec3<f32>, albedo : vec3<f32>) -> vec3<f32> {
-  let toLight = p.position - worldPos;
-  let dSquared = max(dot(toLight, toLight), 1e-4);
-  let factor = 1.0 - (dSquared * p.invRangeSquared) * (dSquared * p.invRangeSquared);
-  let attenuation = max(min(factor, 1.0), 0.0) / dSquared;
-  return albedo * p.colorTimesIntensity * attenuation;
-}
-
-// Flat spot-light contribution. Same range attenuation as spriteLitPoint,
-// modulated by a smoothstep cone factor (host-side degree -> cosine
-// conversion). Spot direction only shapes the cone; it does not project
-// onto a surface normal. URP cap = 4 spot lights per pass.
-fn spriteLitSpot(s : SpotLight, worldPos : vec3<f32>, albedo : vec3<f32>) -> vec3<f32> {
-  let toLight = s.position - worldPos;
-  let dSquared = max(dot(toLight, toLight), 1e-4);
-  let l = toLight / sqrt(dSquared);
-  let factor = 1.0 - (dSquared * s.invRangeSquared) * (dSquared * s.invRangeSquared);
-  let attenuation = max(min(factor, 1.0), 0.0) / dSquared;
-  let cone = smoothstep(s.cosOuter, s.cosInner, dot(l, -s.direction));
-  return albedo * s.colorTimesIntensity * attenuation * cone;
-}
-
 // Shared shading body used by both fs_main (LDR) and fs_main_hdr (HDR).
 // The two entry points differ only in their tail-end clamp + srgb encode
 // step (LDR clamp / HDR pass-through boundary).
-fn spriteLitShadeAccum(albedo : vec3<f32>, worldPos : vec3<f32>) -> vec3<f32> {
+fn spriteLitShadeAccum(
+  albedo : vec3<f32>,
+  worldPos : vec3<f32>,
+  ndc : vec3<f32>,
+  viewZ : f32,
+) -> vec3<f32> {
   // Directional contribution (1 light, View UBO).
   var lit = spriteLitDirectional(albedo);
-  // Point-light contribution (URP cap = 4; PointLightsArray.count).
-  let pointCount = pointLightsBuffer.count;
-  for (var i : u32 = 0u; i < pointCount; i = i + 1u) {
-    let p = pointLightsBuffer.slots[i];
-    lit = lit + spriteLitPoint(p, worldPos, albedo);
-  }
-  // Spot-light contribution (URP cap = 4).
-  let spotCount = spotLightsBuffer.count;
-  for (var i : u32 = 0u; i < spotCount; i = i + 1u) {
-    let s = spotLightsBuffer.slots[i];
-    lit = lit + spriteLitSpot(s, worldPos, albedo);
-  }
+#ifdef CLUSTER_FORWARD_AVAILABLE
+  let viewDir = normalize(view.cameraPos - worldPos);
+  lit = lit + evaluateStandardClusterLights(
+    ndc, viewZ, worldPos, vec3<f32>(0.0, 0.0, 1.0),
+    viewDir, albedo, 0.0, 1.0, vec3<f32>(0.04), true,
+  );
+#endif
   return lit;
 }
 
@@ -225,7 +209,7 @@ fn spriteLitShadeAccum(albedo : vec3<f32>, worldPos : vec3<f32>) -> vec3<f32> {
 fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let texel = sampleMaterialTexture(baseColorTexture, baseColorSampler, in.uv_atlas, material.baseColorTextureCoordinatesMetadata.zw);
   let albedo4 = texel * material.colorTint;
-  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos);
+  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos, in.ndc, in.viewZ);
   // Strict clamp 0..1 before premultiplied alpha multiply keeps the LDR
   // path bounded even when a scene stacks many lights.
   let lit_rgba = clamp(vec4<f32>(lit, albedo4.a), vec4<f32>(0.0), vec4<f32>(1.0));
@@ -243,7 +227,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
   let texel = sampleMaterialTexture(baseColorTexture, baseColorSampler, in.uv_atlas, material.baseColorTextureCoordinatesMetadata.zw);
   let albedo4 = texel * material.colorTint;
-  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos);
+  let lit = spriteLitShadeAccum(albedo4.rgb, in.worldPos, in.ndc, in.viewZ);
   // HDR variant: do NOT clamp the lit output to [0, 1]; let the tonemap
   // pass absorb HDR values > 1. Alpha stays clamped because the premult
   // math requires alpha in [0, 1].

package/src/{hdrp-cluster-forward.wgsl → standard-cluster.wgsl}

@@ -1,12 +1,13 @@
-// hdrp-cluster-forward.wgsl — HDRP cluster-forward punctual light evaluation.
+// 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.
 
-#define_import_path forgeax_hdrp::cluster_forward
+#define_import_path forgeax_standard::cluster
 
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed, projectSpotUv}
+#import forgeax_pbr::lighting_punctual::{evalPoint, evalPointFlat, evalSpot, evalSpotFlat, evalSpotShadowed}
+#import forgeax_pbr::lighting_attenuation::{projectSpotUv}
 #import forgeax_view::common::{view}
 #ifdef PROJECTOR_AVAILABLE
 #import forgeax_view::common::{projectorTexture, projectorSampler}
@@ -19,15 +20,18 @@
 
 const KIND_POINT: u32 = 0u;
 const KIND_SPOT: u32 = 1u;
-const PROJECTOR_ONLY_TILE: i32 = -2;
+// 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 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] point near / spot shadow intensity f32 bits
-// [15] point far / spot PCF kernel width f32 bits
+// [14..15] point near/far f32 bits; spot keeps these lanes zero.
 struct LightSlot {
   position        : vec4<f32>,
   color           : vec4<f32>,
@@ -37,35 +41,14 @@ struct LightSlot {
 
 const LIGHTSLOT_BYTE_SIZE: u32 = 64u;
 
-fn sampleClusterSpotProjector(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec3<f32> {
-#ifdef PROJECTOR_AVAILABLE
-  let clip = lightViewProj * vec4<f32>(worldPos, 1.0);
-  // The projector is a cookie, not an extra cone. A fragment that cannot be
-  // projected (or lies outside the tile) keeps the analytic Spot contribution
-  // intact, matching Three's SpotLightNode fail-open map gate.
-  if (abs(clip.w) < 1e-6) { return vec3<f32>(1.0); }
-  let uv = projectSpotUv(lightViewProj, worldPos);
-  if (any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0))) {
-    return vec3<f32>(1.0);
-  }
-  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
-#else
-  return vec3<f32>(1.0);
-#endif
-}
-
 struct ClusterUniform {
   grid         : vec4<u32>,
   near_far_log : vec4<f32>,
 };
 
-#if STORAGE_BUFFER_AVAILABLE == true
 @group(2) @binding(3) var<storage, read> light_data      : array<LightSlot, 256>;
 @group(2) @binding(4) var<storage, read> cluster_grid     : array<u32>;
 @group(2) @binding(5) var<storage, read> light_index_list : array<u32>;
-#else
-@group(2) @binding(3) var<uniform> light_data_uniform : array<LightSlot, 128>;
-#endif
 @group(2) @binding(6) var<uniform> cluster_uniform : ClusterUniform;
 
 fn get_ssao_intensity() -> f32 {
@@ -106,6 +89,26 @@ 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(
@@ -117,9 +120,16 @@ fn evaluate_cluster_light(
   metallic   : f32,
   alpha_sq   : f32,
   f0         : vec3<f32>,
+  flat_2d    : bool,
 ) -> vec3<f32> {
   let kind = light.kind_and_shadow.x;
   if (kind == KIND_POINT) {
+    if (flat_2d) {
+      return evalPointFlat(
+        light.position.xyz, light.color.xyz, light.position.w,
+        world_pos, base_color,
+      );
+    }
 #ifdef POINT_SHADOW_AVAILABLE
     let layer = bitcast<i32>(light.kind_and_shadow.y);
     if (layer >= 0) {
@@ -139,9 +149,36 @@ fn evaluate_cluster_light(
     );
   }
   if (kind == KIND_SPOT) {
-    let tile = bitcast<i32>(light.kind_and_shadow.y);
-    if (tile >= 0) {
-      let projector = sampleClusterSpotProjector(view.spotLightViewProj[tile], world_pos);
+    if (flat_2d) {
+      return evalSpotFlat(
+        light.position.xyz, light.direction.xyz, light.color.xyz,
+        light.color.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.
+    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);
+    }
+    if (encoded_tile >= 0 && encoded_tile < 4) {
+      let tile = encoded_tile;
       return evalSpotShadowed(
         light.position.xyz, light.direction.xyz, light.color.xyz,
         // LightSlot packs cosInner in color.w and cosOuter in direction.w;
@@ -149,22 +186,9 @@ fn evaluate_cluster_light(
         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,
-        clamp(
-          round(select(3.0, bitcast<f32>(light.kind_and_shadow.w),
-            bitcast<f32>(light.kind_and_shadow.w) > 0.5)),
-          1.0,
-          5.0,
-        ),
-        clamp(bitcast<f32>(light.kind_and_shadow.z), 0.0, 1.0),
-      ) * projector;
-    }
-    if (tile == PROJECTOR_ONLY_TILE) {
-      let projector = sampleClusterSpotProjector(view.spotLightViewProj[0], world_pos);
-      return evalSpot(
-        light.position.xyz, light.direction.xyz, light.color.xyz,
-        light.color.w, light.direction.w, light.position.w,
-        world_pos, normal, view_dir, base_color, metallic, alpha_sq, f0,
-      ) * projector;
+        bitcast<f32>(light.kind_and_shadow.w),
+        bitcast<f32>(light.kind_and_shadow.z),
+      );
     }
     return evalSpot(
       light.position.xyz, light.direction.xyz, light.color.xyz,
@@ -175,7 +199,7 @@ fn evaluate_cluster_light(
   return vec3<f32>(0.0);
 }
 
-fn evaluate_cluster_lights(
+fn evaluateStandardClusterLights(
   ndc        : vec3<f32>,
   view_z     : f32,
   world_pos  : vec3<f32>,
@@ -185,6 +209,7 @@ fn evaluate_cluster_lights(
   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;
@@ -194,7 +219,6 @@ fn evaluate_cluster_lights(
   let log_far = cluster_uniform.near_far_log.z;
   var total_radiance = vec3<f32>(0.0);
 
-#if STORAGE_BUFFER_AVAILABLE == true
   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;
@@ -204,20 +228,9 @@ fn evaluate_cluster_lights(
     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,
     );
   }
-#else
-  let light_count = min(cluster_uniform.grid.w, 128u);
-  for (var i = 0u; i < 128u; i = i + 1u) {
-    if (i >= light_count) {
-      break;
-    }
-    total_radiance += evaluate_cluster_light(
-      light_data_uniform[i], world_pos, normal, view_dir,
-      base_color, metallic, alpha_sq, f0,
-    );
-  }
-#endif
   return total_radiance;
 }
 

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/volume/volume-inject.wgsl

@@ -9,7 +9,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>,
 };
@@ -143,9 +144,20 @@ 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,
   );
 }
 

package/src/volume/volume-integrate.wgsl

@@ -1,6 +1,7 @@
 #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}
 
 struct VolumeView {
   _prefix : array<vec4<f32>, 6>,
@@ -106,12 +107,6 @@ 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 spotProjectorMatrix(light : SpotLight) -> mat4x4<f32> {
   if (light.shadowAtlasTile >= 0) {
     return volume_view.spotLightViewProj[light.shadowAtlasTile];