@forgeax/engine-shader 0.1.28 → 0.1.29

package/src/__tests__/standard-pbr-artifact-receipt.unit.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { createStandardPbrArtifactReceipt } from '../material/artifact-types.js';
+
+const BASE_VERTEX_INPUTS = [
+  { semantic: 'position', location: 0, format: 'float32x3' },
+  { semantic: 'normal', location: 1, format: 'float32x3' },
+  { semantic: 'uv', location: 2, format: 'float32x2' },
+  { semantic: 'tangent', location: 3, format: 'float32x4' },
+] as const;
+
+const SKIN_VERTEX_INPUTS = [
+  { semantic: 'skinIndex', location: 4, format: 'uint16x4' },
+  { semantic: 'skinWeight', location: 5, format: 'float32x4' },
+] as const;
+
+const COLOR_VERTEX_INPUT = { semantic: 'color', location: 13, format: 'float32x4' } as const;
+
+const CASES = [
+  {
+    name: 'rigid uncolored',
+    skinned: false,
+    vertexColorAvailable: false,
+    vertexInputs: BASE_VERTEX_INPUTS,
+  },
+  {
+    name: 'rigid colored',
+    skinned: false,
+    vertexColorAvailable: true,
+    vertexInputs: [...BASE_VERTEX_INPUTS, COLOR_VERTEX_INPUT],
+  },
+  {
+    name: 'skinned uncolored',
+    skinned: true,
+    vertexColorAvailable: false,
+    vertexInputs: [...BASE_VERTEX_INPUTS, ...SKIN_VERTEX_INPUTS],
+  },
+  {
+    name: 'skinned colored',
+    skinned: true,
+    vertexColorAvailable: true,
+    vertexInputs: [...BASE_VERTEX_INPUTS, ...SKIN_VERTEX_INPUTS, COLOR_VERTEX_INPUT],
+  },
+] as const;
+
+describe('Standard PBR artifact receipt vertex ABI', () => {
+  it.each(CASES)('publishes the $name input sequence in location order', (testCase) => {
+    const receipt = createStandardPbrArtifactReceipt(
+      testCase.skinned,
+      testCase.vertexColorAvailable,
+    );
+
+    expect(receipt.vertexInputs).toEqual(testCase.vertexInputs);
+    expect(receipt.reflection.vertexInputs).toEqual(testCase.vertexInputs);
+    expect(receipt.vertexInputs.map((input) => input.location)).toEqual(
+      testCase.vertexInputs.map((input) => input.location),
+    );
+    expect(receipt.skinPaletteAddress).toEqual(
+      testCase.skinned ? { group: 2, binding: 1, stride: 64 } : undefined,
+    );
+  });
+
+  it('shares material row and resource ABI across all rigid and skinned color variants', () => {
+    const receipts = CASES.map((testCase) =>
+      createStandardPbrArtifactReceipt(testCase.skinned, testCase.vertexColorAvailable),
+    );
+    const [baseline, ...variants] = receipts;
+
+    for (const receipt of variants) {
+      expect(receipt.materialRow).toEqual(baseline.materialRow);
+      expect(receipt.resourceSlots).toEqual(baseline.resourceSlots);
+      expect(receipt.reflection.resourceSlots).toEqual(baseline.reflection.resourceSlots);
+      expect(receipt.uvSets).toEqual(baseline.uvSets);
+      expect(receipt.alphaMask).toEqual(baseline.alphaMask);
+    }
+  });
+
+  it('separates colored and uncolored identities while retaining rigid and skin compatibility', () => {
+    const rigid = createStandardPbrArtifactReceipt(false, false);
+    const rigidColor = createStandardPbrArtifactReceipt(false, true);
+    const skin = createStandardPbrArtifactReceipt(true, false);
+    const skinColor = createStandardPbrArtifactReceipt(true, true);
+
+    expect(rigid.receiptIdentity).toBe('standard-pbr/material-row-v2');
+    expect(rigid.reflection.layoutIdentity).toBe(rigid.receiptIdentity);
+    expect(skin.receiptIdentity).toBe(rigid.receiptIdentity);
+    expect(skin.reflection.layoutIdentity).toBe(skin.receiptIdentity);
+    expect(rigidColor.receiptIdentity).toBe('standard-pbr/material-row-v2/vertex-color');
+    expect(rigidColor.reflection.layoutIdentity).toBe(rigidColor.receiptIdentity);
+    expect(skinColor.receiptIdentity).toBe(rigidColor.receiptIdentity);
+    expect(skinColor.reflection.layoutIdentity).toBe(skinColor.receiptIdentity);
+    expect(new Set([rigid.receiptIdentity, rigidColor.receiptIdentity])).toHaveLength(2);
+  });
+});

package/src/__tests__/standard-surface-pass-evaluation.integration.test.ts

@@ -21,16 +21,28 @@ describe('Standard Surface pass evaluation', () => {
       for (const entry of ['fs_main', 'fs_gbuffer']) {
         const body = entryBody(shader, entry);
         expect(body, `${name}:${entry} must exist`).toContain(`fn ${entry}`);
-        expect(body, `${name}:${entry}`).toMatch(
-          /(?:evaluateStandardSurface|evaluate_surface|forgeax_evaluate_surface_from_fragments)\s*\(/,
-        );
+        expect(
+          body.match(
+            /(?:evaluateStandardSurface|evaluate_surface|forgeax_evaluate_surface_from_fragments)\s*\(/g,
+          ),
+          `${name}:${entry}`,
+        ).toHaveLength(1);
         expect(body).toContain('alphaTestSurface(surface)');
         if (entry === 'fs_main') expect(body).toContain('surface.opacity');
         expect(body).toContain('surface.baseColor');
         expect(body).toContain('surface.normalWS');
         expect(body).toContain('surface.metallic');
         expect(body).toContain('surface.roughness');
-        expect(body).toContain('surface.emissive');
+        if (entry === 'fs_gbuffer' && name === 'default-standard-pbr.wgsl') {
+          // The rigid SSR G-buffer stores the material's unit-radiance response.
+          // Emissive stays in fs_main; skin remains outside SSR admission.
+          expect(body).toContain('out.specular_response_ao');
+          expect(body).toContain('projectSpecularRadiance(vec3<f32>(1.0)');
+          expect(body).toContain('standardSurfaceF0(in, surface)');
+          expect(body).not.toContain('surface.emissive');
+        } else {
+          expect(body).toContain('surface.emissive');
+        }
         expect(body).toContain('surface.occlusion');
       }
     }

package/src/__tests__/surface-v1.unit.test.ts

@@ -19,6 +19,12 @@ const inputFields = [
   ['viewDirectionWS', 'vec3<f32>'],
   ['uv0', 'vec2<f32>'],
   ['uv1', 'vec2<f32>'],
+  ['uv2', 'vec2<f32>'],
+  ['uv3', 'vec2<f32>'],
+  ['uv4', 'vec2<f32>'],
+  ['uv5', 'vec2<f32>'],
+  ['uv6', 'vec2<f32>'],
+  ['uv7', 'vec2<f32>'],
   ['vertexColor', 'vec4<f32>'],
   ['frontFacing', 'bool'],
 ] as const;

package/src/__tests__/taa-resolve.unit.test.ts

@@ -7,15 +7,18 @@ const pbrTemporal = readFileSync(resolve(import.meta.dirname, '../pbr-temporal.w
 const sceneTemporal = readFileSync(resolve(import.meta.dirname, '../scene-temporal.wgsl'), 'utf8');
 
 describe('taa-resolve.wgsl', () => {
-  it('keeps the fixed packed temporal and two-attachment ABI', () => {
+  it('preserves receiver motion/depth, merges secondary reactivity and stores stability separately', () => {
     expect(source).toContain('struct TaaResolveParams');
     expect(source).toContain('@location(0) color');
     expect(source).toContain('@location(1) temporal');
+    expect(source).toContain('@location(2) stability');
     expect(source).toContain('return TaaResolveOutput(');
     expect(source).toContain('temporal,');
     expect(source).toContain('current.a');
     expect(source).toContain('1.0 - clamp(temporal.w');
     expect(source).not.toContain('1.0 - clamp(current.a');
+    expect(source).toContain('vec4<f32>(sceneTemporal.xyz,');
+    expect(source).toContain('max(sceneTemporal.w, sampleSecondaryReactivity(currentUv))');
   });
 
   it('contains every v1 rejection and adaptive weighting term', () => {
@@ -24,14 +27,18 @@ describe('taa-resolve.wgsl', () => {
     expect(source).toContain('closestCurrentTemporal(pixel, dimensions)');
     expect(source).toContain('historyInBounds');
     expect(source).toContain('depthDelta > depthThreshold');
-    expect(source).toContain('neighborhoodSquareMean');
-    expect(source).toContain('clamp(rgbToYCoCg(history.rgb), clipMin, clipMax)');
+    expect(source).toContain('taaNeighborhood');
+    expect(source).toContain('clamp(rgbToYCoCg(history), clipMin, clipMax)');
     expect(source).toContain('reactiveFactor');
     expect(source).toContain('velocityFactor');
-    expect(source).toContain('depthFactor');
-    expect(source).toContain('lumaFactor');
-    expect(source).toContain('mix(0.88, 0.97, lumaFactor)');
-    expect(source).toContain('params.temporalFrameIndex < 8u');
+    expect(source).not.toContain('depthFactor');
+    expect(source).toContain('progressiveWeight * reactiveFactor * velocityFactor');
+    expect(source).not.toContain('unbiasedLumaDelta');
+    expect(source).toContain('blendTaaHistory(current.rgb, clippedHistoryRgb, historyWeight)');
+    expect(source).toContain('taaAccumulationWeight(params.temporalFrameIndex, steadyWeight)');
+    expect(source).toContain(
+      'mix(0.95, 0.99, smoothstep(64.0, TAA_HISTORY_SETTLE_FRAMES, stableAge))',
+    );
     expect(source).toContain('progressiveWeight');
     expect(source).toContain('let dimensions = vec2<i32>(textureDimensions(currentColor, 0));');
     expect(source).toContain('closestCurrentTemporal(pixel, dimensions)');
@@ -63,7 +70,7 @@ ${pbrTemporal.replace(/^#define_import_path.*$/gm, '').replace(/^#import.*$/gm,
 @fragment
 fn fs_temporal_probe() -> @location(0) vec4<f32> {
   return projectPbrSceneTemporal(
-    0.75, 0.5, colorTexture, colorSampler,
+    0.75, 0.5, true, colorTexture, colorSampler,
     vec4<f32>(0.0, 0.0, 1.0, 1.0), vec4<f32>(0.0),
     vec4<f32>(0.0, 0.0, 1.0, 1.0), vec4<f32>(0.0),
     vec4<f32>(0.0, 0.0, 0.0, 0.0), 0.0,
@@ -74,7 +81,11 @@ fn fs_temporal_probe() -> @location(0) vec4<f32> {
 `;
     const compiled = await compileShader(entry, {
       id: 'test::pbr-temporal-reactive',
-      defines: { PER_INSTANCE_REGION: false, STORAGE_BUFFER_AVAILABLE: true },
+      defines: {
+        PER_INSTANCE_REGION: false,
+        STORAGE_BUFFER_AVAILABLE: true,
+        BASE_COLOR_TEXTURE_AVAILABLE: true,
+      },
     });
     expect(compiled.ok, compiled.ok ? undefined : String(compiled.error)).toBe(true);
     if (!compiled.ok) return;

package/src/__tests__/transmission-thickness-scale.unit.test.ts

@@ -8,7 +8,12 @@ describe('standard transmission thickness scale contract', () => {
   it('converts local authored thickness through the combined local-to-world basis', () => {
     expect(shader).toContain('@location(4) @interpolate(flat) transmissionBasis0 : vec4<f32>');
     expect(shader).toContain('@location(13) @interpolate(flat) transmissionBasis1 : vec4<f32>');
-    expect(shader).not.toContain('@location(15)');
+    // Scene-index Standard uses location 15 for its flat material-row index
+    // when transmission is disabled.  Keep this assertion scoped to the
+    // transmission ABI: it must not claim that the unrelated scene-index
+    // varying is absent from the shared source template.
+    expect(shader).toMatch(/@location\(15\)\s+@interpolate\(flat\)\s+materialIndex\s+:\s+u32/);
+    expect(shader).not.toMatch(/@location\(15\)[^\n]*thickness/i);
     expect(shader).toContain('let localToWorld0 = in.transmissionBasis0.xyz;');
     expect(shader).toContain('let localToWorld1 = vec3<f32>(');
     expect(shader).toContain('let localToWorld2 = vec3<f32>(');

package/src/__tests__/transparent-pbr.unit.test.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { describe, expect, it } from 'vitest';
 
-const shader = readFileSync(resolve(import.meta.dirname, '../default-standard-pbr.wgsl'), 'utf8');
+const shader = readFileSync(resolve(import.meta.dirname, '../standard-surface.wgsl'), 'utf8');
 
 describe('transparent PBR color domain contract', () => {
   it('mixes transparent source and destination in the linear domain', () => {

package/src/__tests__/vertex-color-variant.unit.test.ts

@@ -42,7 +42,10 @@ describe('M4 vertex-color shader contract', () => {
       expect(text).toMatch(/baseColor\.rgb\s*\*\s*texSample\.rgb\s*\*\s*vertexColor\.rgb/);
       expect(text).toMatch(/baseColor\.a\s*\*\s*texSample\.a\s*\*\s*vertexColor\.a/);
     } else {
-      expect(text).toContain('#import forgeax_material::slot::surface::{evaluate_surface}');
+      expect(text).toContain(
+        '#import forgeax_material::slot::surface::{evaluate_surface, evaluate_standard_surface}',
+      );
+      expect(text).toContain('materialVertexColor(in), frontFacing');
     }
     expect(text).toMatch(/alphaCutoff/);
     expect(text).toMatch(/fs_temporal/);

package/src/atmosphere-background.wgsl

@@ -48,9 +48,9 @@ fn atmosphere_sun_disc_radiance(
 
 @vertex
 fn atmosphere_background_vs(@builtin(vertex_index) vertexIndex: u32) -> FullscreenOutput {
-  // Keep the fullscreen primitive at the far plane. The render graph binds
-  // the existing depth authority read-only, so fixed-function less-equal
-  // rejects background fragments covered by geometry without sampling depth.
+  // Initialize the far-plane background before scene draws. The shared
+  // geometry depth authority preserves occlusion and transparent blending;
+  // background never samples depth or overwrites a later foreground.
   var output = fullscreen_triangle(vertexIndex);
   output.position.z = 1.0;
   return output;

package/src/auto-exposure-meter.wgsl

@@ -0,0 +1,179 @@
+// Auto exposure meter module. Runtime uses the cooked WGSL string directly.
+// The three entry points execute as ordered dispatches in one meter pass.
+struct AutoExposureParameters {
+  compensationEv: f32,
+  rangeMinEv: f32,
+  rangeMaxEv: f32,
+  upRate: f32,
+  downRate: f32,
+  deltaTime: f32,
+  fallback: f32,
+  generation: f32,
+};
+
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> histogram: array<atomic<u32>>;
+@group(0) @binding(2) var<storage, read_write> state: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> candidate: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read> parameters: AutoExposureParameters;
+
+var<workgroup> localHistogram: array<atomic<u32>, 256>;
+var<workgroup> totals: array<u32, 64>;
+var<workgroup> sampleTotal: u32;
+
+fn finite(value: f32) -> bool {
+  // Equality rejects NaN; the magnitude bound rejects +/-infinity.
+  return value == value && abs(value) <= 3.402823e+37;
+}
+
+fn centerWeight(
+  block: vec2<u32>,
+  center: vec2<f32>,
+  inverseExtentSquared: vec2<f32>,
+) -> u32 {
+  let delta = vec2<f32>(block) - center;
+  let distanceSquared =
+    delta.x * delta.x * inverseExtentSquared.x +
+    delta.y * delta.y * inverseExtentSquared.y;
+  if (distanceSquared <= 0.25) { return 3u; }
+  if (distanceSquared <= 0.75) { return 2u; }
+  return 1u;
+}
+
+fn accumulateSample(
+  block: vec2<u32>,
+  sampleGrid: vec2<u32>,
+  dimensions: vec2<u32>,
+  center: vec2<f32>,
+  extent: vec2<f32>,
+) {
+  if (block.x >= sampleGrid.x || block.y >= sampleGrid.y) { return; }
+  let pixel = min(block * vec2<u32>(4u) + vec2<u32>(2u), dimensions - vec2<u32>(1u));
+  let sample = textureLoad(source, vec2<i32>(pixel), 0);
+  if (!finite(sample.r) || !finite(sample.g) || !finite(sample.b)) { return; }
+  let luminance = dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+  if (!finite(luminance) || luminance <= 0.0) { return; }
+  let bin = min(u32(clamp(log2(luminance) + 12.0, 0.0, 23.999) * (256.0 / 24.0)), 255u);
+  atomicAdd(&localHistogram[bin], centerWeight(block, center, extent));
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_clear(@builtin(local_invocation_index) localIndex: u32) {
+  atomicStore(&histogram[localIndex], 0u);
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_histogram(
+  @builtin(local_invocation_index) localIndex: u32,
+  @builtin(workgroup_id) workgroupId: vec3<u32>,
+  @builtin(num_workgroups) numWorkgroups: vec3<u32>,
+) {
+  let dimensions = textureDimensions(source);
+  let sampleGrid = (dimensions.xy + vec2<u32>(3u)) / vec2<u32>(4u);
+  let grid = vec2<f32>(sampleGrid);
+  let center = (grid - vec2<f32>(1.0)) * 0.5;
+  let extent = max(center, vec2<f32>(1.0));
+  let inverseExtent = 1.0 / extent;
+  let inverseExtentSquared = inverseExtent * inverseExtent;
+
+  // Map the 256 lanes to a 16x16 logical tile. The fixed 4x8 dispatch grid
+  // then uses a two-dimensional tile stride to cover every 4x4 sample block.
+  atomicStore(&localHistogram[localIndex], 0u);
+  workgroupBarrier();
+  let localGrid = vec2<u32>(localIndex % 16u, localIndex / 16u);
+  let tileSize = vec2<u32>(16u);
+  let blockStart = workgroupId.xy * tileSize + localGrid;
+  let blockStride = numWorkgroups.xy * tileSize;
+  for (var blockY = blockStart.y; blockY < sampleGrid.y; blockY += blockStride.y) {
+    for (var blockX = blockStart.x; blockX < sampleGrid.x; blockX += blockStride.x) {
+      accumulateSample(
+        vec2<u32>(blockX, blockY),
+        sampleGrid,
+        dimensions,
+        center,
+        inverseExtentSquared,
+      );
+    }
+  }
+  workgroupBarrier();
+
+  // Every lane owns one bin. All local accumulation is complete before the
+  // owners atomically publish their finite result to the one global 1KiB map.
+  let localCount = atomicLoad(&localHistogram[localIndex]);
+  if (localCount > 0u) {
+    atomicAdd(&histogram[localIndex], localCount);
+  }
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn auto_exposure_adapt(@builtin(local_invocation_index) localIndex: u32) {
+  var total = 0u;
+  for (var index = localIndex; index < 256u; index += 64u) {
+    total += atomicLoad(&histogram[index]);
+  }
+  totals[localIndex] = total;
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    var reducedTotal = 0u;
+    for (var lane = 0u; lane < 64u; lane += 1u) {
+      reducedTotal += totals[lane];
+    }
+    sampleTotal = reducedTotal;
+  }
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    let validParameters =
+      finite(parameters.compensationEv) &&
+      finite(parameters.rangeMinEv) &&
+      finite(parameters.rangeMaxEv) &&
+      parameters.rangeMinEv <= parameters.rangeMaxEv &&
+      finite(parameters.upRate) &&
+      finite(parameters.downRate) &&
+      finite(parameters.deltaTime) &&
+      parameters.deltaTime >= 0.0 &&
+      finite(parameters.fallback) &&
+      parameters.fallback > 0.0 &&
+      finite(parameters.generation);
+    let safeFallback = select(
+      1.0,
+      parameters.fallback,
+      finite(parameters.fallback) && parameters.fallback > 0.0,
+    );
+    let safeGeneration = select(0.0, parameters.generation, finite(parameters.generation));
+    let lowRank = min(sampleTotal, u32(f32(sampleTotal) * 0.05));
+    let highRank = min(sampleTotal, max(lowRank + 1u, u32(ceil(f32(sampleTotal) * 0.95))));
+    var cumulative = 0u;
+    var clippedWeightedLog = 0.0;
+    var clippedTotal = 0u;
+    for (var index = 0u; index < 256u; index += 1u) {
+      let count = atomicLoad(&histogram[index]);
+      let begin = cumulative;
+      cumulative += count;
+      let keptBegin = max(begin, lowRank);
+      let keptEnd = min(cumulative, highRank);
+      if (keptEnd > keptBegin) {
+        let kept = keptEnd - keptBegin;
+        clippedTotal += kept;
+        clippedWeightedLog += f32(kept) * (-12.0 + (f32(index) + 0.5) * (24.0 / 256.0));
+      }
+    }
+    let averageLog = select(0.0, clippedWeightedLog / f32(clippedTotal), clippedTotal > 0u);
+    let measuredExposure = exp2(-averageLog) * 0.18;
+    let targetExposure = select(
+      safeFallback,
+      exp2(clamp(log2(max(measuredExposure, 1e-6)) + parameters.compensationEv, parameters.rangeMinEv, parameters.rangeMaxEv)),
+      validParameters && clippedTotal > 0u && finite(measuredExposure),
+    );
+    let previous = state[0];
+    let hasPrevious = validParameters && previous.y > 0.5 && previous.z == safeGeneration && previous.w == safeFallback && finite(previous.x) && previous.x > 0.0;
+    let current = select(safeFallback, previous.x, hasPrevious);
+    let rate = select(parameters.downRate, parameters.upRate, targetExposure > current);
+    let safeRate = select(0.0, rate, finite(rate) && rate >= 0.0);
+    let dt = select(0.0, parameters.deltaTime, finite(parameters.deltaTime) && parameters.deltaTime >= 0.0);
+    let amount = 1.0 - exp(-safeRate * dt);
+    let adapted = select(current, current + (targetExposure - current) * amount, validParameters && finite(targetExposure) && finite(current) && dt > 0.0 && safeRate > 0.0);
+    let exposure = select(safeFallback, adapted, finite(adapted) && adapted > 0.0);
+    candidate[0] = vec4<f32>(exposure, 1.0, safeGeneration, safeFallback);
+    state[0] = candidate[0];
+  }
+}

package/src/color-lut.wgsl

@@ -0,0 +1,17 @@
+// Standard output 3D LUT sampling. The sampler is fixed to clamp and linear.
+
+struct ColorLutParams {
+  strength: f32,
+};
+
+fn sampleColorLut(
+  source: texture_3d<f32>,
+  lutSampler: sampler,
+  color: vec3<f32>,
+  params: ColorLutParams,
+) -> vec4<f32> {
+  let clamped = clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));
+  let sampled = textureSampleLevel(source, lutSampler, clamped, 0.0);
+  let amount = clamp(params.strength, 0.0, 1.0);
+  return vec4<f32>(mix(color, sampled.rgb, amount), sampled.a);
+}

package/src/common.wgsl

@@ -183,6 +183,9 @@ struct View {
   // Accepted camera origin at the previous submitted frame. This occupies
   // the existing tail padding and keeps temporal reprojection on one SSOT.
   temporalPreviousCameraPos : vec4<f32>,
+  // SSR authoring facts share the fixed View UBO tail. x/y/z are the validated
+  // maxDistance/thickness/maxRoughness values; w is a finite enabled sentinel.
+  ssrParams : vec4<f32>,
 };
 
 // Per-instance mesh slot (feat-20260518-pbr-direct-lighting-mvp M2 / w8.5,
@@ -292,10 +295,9 @@ struct DirectLightSlot {
 // Per-light shadow params (binding 6):
 //   `array<vec4<f32>, 4>` carrying the URP-side proj constants for cube
 //   depth-ref reconstruction (research L0.5 + L1.13). Each lane stores the
-//   shader-side reconstruction constants for one shadow-casting point light;
-//   slot N matches `PointLight.shadowAtlasLayer = N`. HDRP rides the same
-//   constants on direct-light metadata so binding 6 stays unbound on
-//   the HDRP path.
+//   (near, far, depthBias, normalBias) for one shadow-casting point light;
+//   slot N matches `PointLight.shadowAtlasLayer = N`. Direct and clustered
+//   Standard consumers share this exact binding and authored bias payload.
 #ifdef POINT_SHADOW_AVAILABLE
 @group(0) @binding(5) var shadowAtlas : texture_depth_cube_array;
 @group(0) @binding(6) var<uniform> shadowParams : array<vec4<f32>, 4>;
@@ -383,7 +385,7 @@ struct ShadowCasterCascade {
 @group(0) @binding(15) var<uniform> cookieMatrices : array<mat4x4<f32>, 32>;
 #endif
 #ifdef PROJECTOR_AVAILABLE
-#ifndef EXTENDED_LIGHTING_AVAILABLE
+#if EXTENDED_LIGHTING_AVAILABLE == false
 // Optional authored SpotLight projector. Surface and volume bind the same
 // accepted TextureAsset view and linear-clamp sampler; an unprojected spot
 // receives the renderer-owned white fallback. The declaration is capability