@forgeax/engine-shader 0.1.19 → 0.1.20

package/src/__tests__/fog-orthographic-ray.unit.test.ts

@@ -9,54 +9,29 @@ const shaderFiles = [
   'sprite.wgsl',
   'sprite-lit.wgsl',
   'msdf-text.wgsl',
+  'skybox.wgsl',
 ] as const;
 
 function source(name: (typeof shaderFiles)[number]): string {
   return readFileSync(fileURLToPath(new URL(`../${name}`, import.meta.url)), 'utf8');
 }
 
-function subtract(a: readonly number[], b: readonly number[]): number[] {
-  return a.map((value, index) => value - (b[index] ?? 0));
-}
-
-function dot(a: readonly number[], b: readonly number[]): number {
-  return a.reduce((sum, value, index) => sum + value * (b[index] ?? 0), 0);
-}
-
-function scale(a: readonly number[], scalar: number): number[] {
-  return a.map((value) => value * scalar);
-}
-
-describe('Fog orthographic fragment ray contract', () => {
-  it('derives the camera-plane origin from the current fragment for every built-in material', () => {
+describe('Built-in fragment volume handoff', () => {
+  it('does not reconstruct or apply a private analytic fog ray', () => {
     for (const name of shaderFiles) {
       const shader = source(name);
-      expect(shader, name).toContain(
-        'worldPos - direction * dot(worldPos - viewParams.cameraPos, direction)',
-      );
-      expect(shader, name).not.toContain('origin = nearPoint;');
-      expect(shader.match(/applySceneFog\(/g)?.length, name).toBeGreaterThanOrEqual(2);
+      expect(shader, name).not.toContain('applySceneFog(');
+      expect(shader, name).not.toContain('apply_fog(');
+      expect(shader, name).not.toContain('forgeax_view::fog');
     }
   });
 
-  it('keeps a tilted orthographic camera pixel on its own ray rather than the center ray', () => {
-    const camera = [4, 2, -3];
-    const direction = [0.3, -0.8, 0.5];
-    const length = Math.hypot(...direction);
-    const unitDirection = direction.map((value) => value / length);
-    const lateral = [1, 0, -0.6];
-    const fragment = camera
-      .map((value, index) => value + (lateral[index] ?? 0))
-      .map((value, index) => value + (unitDirection[index] ?? 0) * 7);
-    const origin = subtract(
-      fragment,
-      scale(unitDirection, dot(subtract(fragment, camera), unitDirection)),
+  it('keeps the volume composite as the shared post-lighting owner', () => {
+    const volume = readFileSync(
+      fileURLToPath(new URL('../volume/volume-composite.wgsl', import.meta.url)),
+      'utf8',
     );
-
-    expect(origin[0]).toBeCloseTo(5, 8);
-    expect(origin[1]).toBeCloseTo(2, 8);
-    expect(origin[2]).toBeCloseTo(-3.6, 8);
-    expect(dot(subtract(fragment, origin), unitDirection)).toBeCloseTo(7, 8);
-    expect(dot(subtract(origin, camera), unitDirection)).toBeCloseTo(0, 8);
+    expect(volume).toContain('resolved_volume');
+    expect(volume).toContain('composite_resolved_volume');
   });
 });

package/src/__tests__/fog-producer-matrix.integration.test.ts

@@ -10,68 +10,33 @@ const SHADER_FILES = [
   'sprite-lit.wgsl',
   'msdf-text.wgsl',
   'skybox.wgsl',
+  'hdrp-deferred-lighting.wgsl',
 ] as const;
 
 const shaderSource = (file: string): string =>
   readFileSync(fileURLToPath(new URL(`../${file}`, import.meta.url)), 'utf8');
 
-const count = (source: string, pattern: RegExp): number => source.match(pattern)?.length ?? 0;
-
-function producerContract(source: string): boolean {
-  return (
-    /#import\s+forgeax_view::common::\{[^}]*\bFogRay\b[^}]*\}/.test(source) &&
-    /#import\s+forgeax_view::fog::\{[^}]*\bapply_fog\b[^}]*\}/.test(source) &&
-    count(source, /\bapply_fog\s*\(/g) === 1 &&
-    count(source, /\bFogRay\s*\(/g) >= 1 &&
-    (source.includes('view.fog') || source.includes('viewParams.fog'))
-  );
-}
-
-function body(source: string, entry: string, nextEntry: string): string {
-  const start = source.indexOf(entry);
-  const end = nextEntry === '' ? -1 : source.indexOf(nextEntry, start + entry.length);
-  return source.slice(start, end === -1 ? source.length : end);
-}
-
-describe('built-in Fog producer matrix', () => {
-  it('requires one shared Fog module call and a real FogRay for every built-in output', () => {
+describe('Built-in volume producer matrix', () => {
+  it('removes every analytic fog producer from built-in outputs', () => {
     for (const file of SHADER_FILES) {
       const source = shaderSource(file);
-      expect(producerContract(source), file).toBe(true);
+      expect(source, file).not.toContain('apply_fog');
+      expect(source, file).not.toContain('applySceneFog');
+      expect(source, file).not.toContain('forgeax_view::fog');
+      expect(source, file).not.toContain('FogRay');
     }
   });
 
-  it('keeps deferred G-buffer and temporal/reactive outputs free of Fog', () => {
-    const pbr = shaderSource('default-standard-pbr.wgsl');
-    const gbuffer = body(pbr, 'fn fs_gbuffer', 'struct TemporalVsOut');
-    const temporal = body(pbr, 'fn fs_temporal', '');
-
-    expect(gbuffer).not.toContain('applySceneFog(');
-    expect(gbuffer).not.toContain('apply_fog(');
-    expect(temporal).not.toContain('applySceneFog(');
-    expect(temporal).not.toContain('apply_fog(');
+  it('keeps the volume module as the sole optical integration owner', () => {
+    const composite = shaderSource('volume/volume-composite.wgsl');
+    expect(shaderSource('volume/volume-integrate.wgsl')).toContain('fn hg');
+    expect(shaderSource('volume/volume-integrate.wgsl')).toContain('FOUR_PI');
+    expect(composite).toContain('resolved_volume');
   });
 
-  it('turns deletion, duplication, and non-scene output coverage into red verdicts', () => {
-    const source = shaderSource('default-standard-pbr.wgsl');
-    expect(producerContract(source)).toBe(true);
-
-    const deleted = source.replace(/#import\s+forgeax_view::fog::\{[^\n]+\}\n?/, '');
-    expect(producerContract(deleted)).toBe(false);
-
-    const duplicated = `${source}\n${source.match(/\bapply_fog\s*\([\s\S]*?\);/)?.[0] ?? ''}`;
-    expect(producerContract(duplicated)).toBe(false);
-
-    const gbufferStart = source.indexOf('fn fs_gbuffer');
-    const gbufferFogged = `${source.slice(0, gbufferStart)}${source
-      .slice(gbufferStart)
-      .replace(
-        'let baseUv =',
-        'let _falsify = applySceneFog(vec3<f32>(1.0), 1.0, vec3<f32>(0.0));\n  let baseUv =',
-      )}`;
-    expect(gbufferFogged).not.toBe(source);
-    expect(body(gbufferFogged, 'fn fs_gbuffer', 'struct TemporalVsOut')).toContain(
-      'applySceneFog(',
-    );
+  it('keeps a single producer matrix without fallback fog entry points', () => {
+    const sources = SHADER_FILES.map(shaderSource).join('\n');
+    expect(sources.match(/apply_fog|applySceneFog|FogRay/g)).toBeNull();
+    expect(shaderSource('volume/volume-integrate.wgsl')).toContain('local_scatter');
   });
 });

package/src/__tests__/lighting-point-spot-volume.unit.test.ts

@@ -0,0 +1,48 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const punctual = readFileSync(new URL('../lighting-punctual.wgsl', import.meta.url), 'utf8');
+const attenuation = readFileSync(new URL('../lighting-attenuation.wgsl', import.meta.url), 'utf8');
+const inject = readFileSync(new URL('../volume/volume-inject.wgsl', import.meta.url), 'utf8');
+const integrate = readFileSync(new URL('../volume/volume-integrate.wgsl', import.meta.url), 'utf8');
+
+describe('shared punctual optics for volumetric fog', () => {
+  it('publishes one finite Point and Spot volume evaluator', () => {
+    expect(punctual).toContain('fn evalVolumePoint(');
+    expect(punctual).toContain('fn evalVolumeSpot(');
+    expect(punctual).toContain('evalDistanceAttenuation');
+    expect(punctual).toContain('evalSpotAttenuation');
+    expect(punctual).toContain('max(dSquared, 1e-4)');
+    expect(attenuation).toContain('smoothstep(cosOuter, cosInner');
+    expect(attenuation).toContain('safeDistance');
+  });
+
+  it('uses the shared evaluators from the fixed inject and integrate stages', () => {
+    expect(inject).toContain('forgeax_pbr::lighting_punctual');
+    expect(integrate).toContain('forgeax_pbr::lighting_punctual');
+    expect(inject).toContain('evalVolumePoint');
+    expect(inject).toContain('evalVolumeSpot');
+    expect(integrate).toContain('evalVolumePoint');
+    expect(integrate).toContain('evalVolumeSpot');
+    expect(inject).toContain('pointLightsBuffer');
+    expect(inject).toContain('spotLightsBuffer');
+  });
+
+  it('keeps the punctual volume path finite and monotonic at range boundaries', () => {
+    expect(punctual).toMatch(/max\([^\n]*1e-4/);
+    expect(attenuation).toMatch(/clamp\(1\.0 - \(safeDistance \* invRangeSquared\)/);
+    expect(attenuation).toContain('return distance * cone');
+    expect(integrate).toContain('isFinite');
+  });
+
+  it('uses the pinned Three density grain and smoke amount mapping', () => {
+    expect(integrate).toContain('fn volume_sample_grain(');
+    expect(integrate).toContain('fract((position + time_scaled * time_scale) * scale)');
+    expect(integrate).toContain('volume_sample_grain(position, 0.1, time_scaled, 1.0)');
+    expect(integrate).toContain('volume_sample_grain(position, 0.05, time_scaled, 1.0)');
+    expect(integrate).toContain('volume_sample_grain(position, 0.02, time_scaled, 2.0)');
+    expect(integrate).toContain('return 2.0 * grain - 1.0;');
+    expect(integrate).toContain('volume_scattering_density(world_position, frame_index)');
+    expect(integrate).not.toContain('density_uv');
+  });
+});

package/src/__tests__/lighting-spot-volume-attenuation.unit.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const volumeInject = readFileSync(new URL('../volume/volume-inject.wgsl', import.meta.url), 'utf8');
+const volumeIntegrate = readFileSync(
+  new URL('../volume/volume-integrate.wgsl', import.meta.url),
+  'utf8',
+);
+
+describe('volume Spot attenuation precision', () => {
+  it('keeps the shared finite-range attenuation monotonic', () => {
+    expect(volumeInject).not.toContain('evalSpotAttenuation');
+    expect(volumeInject).not.toContain('attenuation * cone_distance');
+    expect(volumeInject).toContain('spot_shadow_visibility_at');
+    expect(volumeIntegrate).toContain('evalSpotAttenuation');
+    expect(volumeIntegrate).toContain('spot_attenuation_at');
+    expect(volumeIntegrate).toContain('light.invRangeSquared');
+    // The paired Point+Spot owner applies visibility only to the Spot term;
+    // the Point radiance remains independent of the spot shadow. Keep the
+    // assertion at the semantic call boundary so WGSL formatting changes do
+    // not turn this contract test into a stale substring check.
+    expect(volumeIntegrate).toContain('volume_light_radiance_pair(world_position, visibility)');
+    expect(volumeIntegrate).toContain('volume_spot_radiance(world_position) *');
+    expect(volumeIntegrate).toContain('mix(1.0, spot_visibility, volume_spot_shadow_intensity())');
+  });
+});

package/src/__tests__/lighting-spot-volume.unit.test.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const attenuation = readFileSync(new URL('../lighting-attenuation.wgsl', import.meta.url), 'utf8');
+const punctual = readFileSync(new URL('../lighting-punctual.wgsl', import.meta.url), 'utf8');
+
+describe('shared Spot volume optics', () => {
+  it('uses finite squared distance attenuation and a smooth cosine cone', () => {
+    expect(attenuation).toContain('evalSpotAttenuation');
+    expect(attenuation).toContain('invRangeSquared');
+    expect(attenuation).toContain('smoothstep(cosOuter, cosInner');
+  });
+
+  it('is consumed by the surface punctual owner', () => {
+    expect(punctual).toContain('forgeax_pbr::lighting_attenuation');
+    expect(punctual).toContain('evalSpotAttenuation');
+  });
+
+  it('keeps invalid range and cone inputs finite at the shared boundary', () => {
+    expect(attenuation).toContain('max(dSquared, 1e-4)');
+    expect(attenuation).toContain('clamp');
+    expect(attenuation).toContain('cosInner');
+    expect(attenuation).toContain('cosOuter');
+  });
+});

package/src/__tests__/shader.unit.test.ts

@@ -805,6 +805,7 @@ import {
         '#pragma variant_axis CLUSTER_FORWARD_AVAILABLE',
         '#pragma variant_axis VERTEX_COLOR_AVAILABLE',
         '#pragma variant_axis TRANSMISSION_AVAILABLE',
+        '#pragma variant_axis PROJECTOR_AVAILABLE',
       ]);
     });
 

package/src/__tests__/sprite-variants.unit.test.ts

@@ -118,6 +118,7 @@ describe('w6 (b) -- pbr / unlit / sprite-adjacent shaders DO NOT pick up PER_INS
       '#pragma variant_axis CLUSTER_FORWARD_AVAILABLE',
       '#pragma variant_axis VERTEX_COLOR_AVAILABLE',
       '#pragma variant_axis TRANSMISSION_AVAILABLE',
+      '#pragma variant_axis PROJECTOR_AVAILABLE',
     ]);
   });
 

package/src/common.wgsl

@@ -76,8 +76,7 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 //   array fold (feat-20260625 w25) removes the standalone @group(0) binding 9
 //   uniform buffer so the WebGL2 fallback fragment uniform-buffer count returns
 //   to 11 (GLES 3.0 max).
-//   temporal projection facts and Fog payload append after the spot matrix;
-//   total = 960 B.
+//   temporal projection facts append after the spot matrix; total = 960 B.
 //
 // Field order must stay byte-for-byte identical to every prior release
 // (charter P4 consistent abstraction); new fields append at the tail.
@@ -128,19 +127,6 @@ fn linearToSrgbOetf(color : vec3<f32>) -> vec3<f32> {
 // 960 (renderer-factory.ts) and writes the full 240 f32
 // payload (render-system-record.ts). Lane N = the spot with `shadowAtlasTile
 // === N` (cap = 4); `evalSpotShadowed` reads `view.spotLightViewProj[tile]`.
-struct FogViewParams {
-  color         : vec3<f32>,
-  density       : f32,
-  heightFalloff : f32,
-  maxOpacity    : f32,
-};
-
-struct FogRay {
-  origin    : vec3<f32>,
-  direction : vec3<f32>,
-  distance  : f32,
-};
-
 struct View {
   worldViewProj   : mat4x4<f32>,
   lightDir        : vec3<f32>,
@@ -167,7 +153,9 @@ struct View {
   temporalPreviousViewProj : mat4x4<f32>,
   // x = near, y = far, z = 1 for orthographic and 0 for perspective.
   temporalProjection : vec4<f32>,
-  fog                 : FogViewParams,
+  // Accepted camera origin at the previous submitted frame. This occupies
+  // the existing tail padding and keeps temporal reprojection on one SSOT.
+  temporalPreviousCameraPos : vec4<f32>,
 };
 
 // Per-instance mesh slot (feat-20260518-pbr-direct-lighting-mvp M2 / w8.5,
@@ -202,7 +190,7 @@ struct Mesh {
 //             color * intensity so the shader avoids the per-fragment mul)
 //     [   7 ] pad f32 = 0
 //
-//   SpotLight (64 B / 16 floats):
+//   SpotLight (80 B / 20 floats):
 //     [ 0..2 ] position vec3<f32>
 //     [   3 ] invRangeSquared f32
 //     [ 4..6 ] colorTimesIntensity vec3<f32>
@@ -211,9 +199,11 @@ struct Mesh {
 //     [ 8..10] direction vec3<f32> (raw outgoing vector; shader reads
 //             via dot(L, -direction) for cone angle test)
 //     [  11 ] cosOuter f32
-//     [12..14] spotPad vec3<f32> = 0 (std430 vec4-alignment padding)
+//     [12] depthBias f32, [13] normalBias f32, [14] pcfKernelSize f32
 //     [  15 ] shadowAtlasTile i32 (sentinel -1 = unassigned/clipped,
 //             0..3 = spot atlas tile index; feat-20260625 M2/M3 D-4)
+//     [  16 ] shadowIntensity f32 (fraction of sampled shadow to apply)
+//     [17..19] alignment tail padding
 //
 // WGSL std430 alignment audit: vec3<f32> alignof=16 / sizeof=12. The
 // f32 lane wedged immediately after each vec3 fills the 4 B remainder
@@ -221,10 +211,10 @@ struct Mesh {
 // prev.size, this.alignof) - for f32 alignof=4 the round-up is a
 // no-op, so position[3] / color[3] / direction[3] sit at byte
 // offsets 12 / 28 / 44 with zero internal padding). PointLight stays
-// 32 B; SpotLight grows to 64 B (feat-20260625 M2/M3 D-4): the trailing
-// `spotPad: vec3<f32>` + `shadowAtlasTile: i32` form one vec4-aligned block
-// at bytes 48..64, with `shadowAtlasTile` at byte 60. These struct sizes
-// match the host packers (packPointLight 32 B / packSpotLight 64 B) exactly.
+// 32 B; SpotLight grows from 64 B (feat-20260625 M2/M3 D-4) for the three
+// receiver controls plus `shadowAtlasTile: i32`, then to 80 B for the
+// parity-only `shadowIntensity` lane at byte 64. These struct sizes match the
+// host packers (packPointLight 32 B / packSpotLight 80 B) exactly.
 //
 // Header `count: u32` lives in a wrapper struct with the trailing
 // runtime-sized array. Array-of-vec4-aligned-struct alignof = 16, so
@@ -255,19 +245,14 @@ struct SpotLight {
   direction           : vec3<f32>,
   cosOuter            : f32,
   // feat-20260625-spot-light-shadow-mapping M3 / w13 (plan-strategy D-4):
-  // The prior 8-lane (48 B) SpotLight had no spare pad lane (unlike PointLight
-  // which repurposed `pointPadW`), so the clip-signal field needs a fresh
-  // vec4-aligned block. `spotPad` fills bytes 48..60 (host packSpotLight slots
-  // 12..14 stay zero); `shadowAtlasTile` (i32 sentinel, -1 = no shadow /
-  // clipped, 0..3 = spot atlas tile) lands at byte 60 (host slot 15, written
-  // through an Int32Array view). The fragment path gates on
-  // `shadowAtlasTile >= 0` (evalSpotShadowed vs evalSpot). Field names are
-  // unique across the composed module surface so naga_oil writeback
-  // substitution does not collide with prior `pad0` members. (naga_oil
-  // reserves the `__` identifier prefix, so the pad lane is `spotPad`, not
-  // `__pad`.)
-  spotPad             : vec3<f32>,
+  // The trailing vec4 transports receiver controls and the tile identity.
+  // Host packSpotLight writes slots 12..14 from the same snapshot; slot 15 is
+  // the i32 shadow tile sentinel and slot 16 carries shadowIntensity.
+  depthBias           : f32,
+  normalBias          : f32,
+  pcfKernelSize       : f32,
   shadowAtlasTile     : i32,
+  shadowIntensity     : f32,
 };
 
 struct PointLightsArray {
@@ -282,32 +267,6 @@ struct SpotLightsArray {
 
 @group(0) @binding(0) var<uniform> view : View;
 
-// Shared screen-space ray reconstruction for scene Fog producers. Keeping the
-// inverse-view and projection branch here prevents each producer from growing
-// a second Fog formula or drifting from the View ABI.
-fn fogWorldPoint(ndc : vec3<f32>) -> vec3<f32> {
-  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
-  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
-  return homogeneous.xyz / divisor;
-}
-
-fn fogRayFromNdc(ndc : vec3<f32>) -> FogRay {
-  let worldPosition = fogWorldPoint(ndc);
-  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
-  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
-  let perspective = view.temporalProjection.z < 0.5;
-  let perspectiveVector = worldPosition - view.cameraPos;
-  let orthographicVector = farPosition - nearPosition;
-  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
-  let origin = select(nearPosition, view.cameraPos, perspective);
-  let rayDistance = select(
-    max(dot(worldPosition - nearPosition, direction), 0.0),
-    length(perspectiveVector),
-    perspective,
-  );
-  return FogRay(origin, direction, rayDistance);
-}
-
 #if STORAGE_BUFFER_AVAILABLE == true
 @group(0) @binding(1) var<storage, read> pointLightsBuffer : PointLightsArray;
 @group(0) @binding(2) var<storage, read> spotLightsBuffer  : SpotLightsArray;
@@ -421,7 +380,17 @@ struct ShadowCasterCascade {
 // — folded there in feat-20260625 w25 (scope-amend) to keep the WebGL2 fallback
 // fragment uniform-buffer count <= 11; binding 8 is the last view-BG binding.
 @group(0) @binding(8) var spotShadowMap : texture_depth_2d;
-
+// 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
+// gated because the complete HDRP PBR view/material ABI reaches the WebGPU
+// minimum of 16 sampled textures without this optional cookie. Devices that
+// cannot expose the 17th sampled texture select the matching white-projector
+// shader variant and omit these resources from the view BGL.
+#ifdef PROJECTOR_AVAILABLE
+@group(0) @binding(11) var projectorTexture : texture_2d<f32>;
+@group(0) @binding(12) var projectorSampler : sampler;
+#endif
 #if STORAGE_BUFFER_AVAILABLE == true
 @group(2) @binding(0) var<storage, read> meshes : array<Mesh>;
 #else

package/src/default-standard-pbr-skin.wgsl

@@ -1,11 +1,10 @@
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, PointLight, SpotLight, pointLightsBuffer, spotLightsBuffer, shadowMap, shadowSampler, sampleMaterialTexture}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, PointLight, SpotLight, pointLightsBuffer, spotLightsBuffer, shadowMap, shadowSampler, sampleMaterialTexture}
 #import forgeax_pbr::temporal::{projectPbrSceneTemporal}
 #import forgeax_pbr::brdf::{f_schlick, v_smith, d_ggx}
 #import forgeax_pbr::ibl_sampling::{sampleIblDiffuse, sampleIblSpecular}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
 #import forgeax_pbr::lighting_directional::{evalDirectionalNoShadow, evalDirectionalShadowFactor}
 #import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot}
-#import forgeax_view::fog::{apply_fog}
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
 #import forgeax_view::common::{shadowParams}
@@ -230,22 +229,6 @@ fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
   }
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-    let nearPoint = nearH.xyz / nearH.w;
-    let farPoint = farH.xyz / farH.w;
-    direction = normalize(farPoint - nearPoint);
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 @vertex
 fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // 4-bone weighted skinning (plan-strategy D-3 / D-3a).
@@ -473,7 +456,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
       );
     }
   }
-  return applySceneFog(view, color, alpha, in.worldPos);
+  return vec4<f32>(color, alpha);
 }
 
 struct TemporalVsOut {

package/src/default-standard-pbr.wgsl

@@ -1,16 +1,36 @@
 #define_import_path forgeax_material::standard
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, PointLight, SpotLight, pointLightsBuffer, spotLightsBuffer, shadowMap, shadowSampler, sampleMaterialTexture}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, PointLight, SpotLight, pointLightsBuffer, spotLightsBuffer, shadowMap, shadowSampler, sampleMaterialTexture}
+#ifdef PROJECTOR_AVAILABLE
+#import forgeax_view::common::{projectorTexture, projectorSampler}
+#endif
 #import forgeax_pbr::temporal::{projectPbrSceneTemporal}
 #import forgeax_pbr::brdf::{f_schlick, v_smith, d_ggx}
 #import forgeax_pbr::ibl_sampling::{sampleIblDiffuse, sampleIblSpecular}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
 #import forgeax_pbr::lighting_directional::{evalDirectionalNoShadow, evalDirectionalShadowFactor}
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed}
-#import forgeax_view::fog::{apply_fog}
+#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed, projectSpotUv}
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
 #import forgeax_view::common::{shadowParams}
 #endif
+
+fn sampleSpotProjector(lightViewProj : mat4x4<f32>, worldPos : vec3<f32>) -> vec3<f32> {
+#ifdef PROJECTOR_AVAILABLE
+  let uv = projectSpotUv(lightViewProj, worldPos);
+  if (!(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)) {
+    // Three's SpotLight.map is a modulation inside the projected light
+    // frustum, not a second cone mask. Outside the map the original spot
+    // radiance remains intact; the cone/visibility terms already own whether
+    // the light reaches the fragment.
+    return vec3<f32>(1.0);
+  }
+  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
+#else
+  // Keep the analytic SpotLight contribution intact on adapters whose
+  // fragment-stage sampled-texture budget cannot carry the optional cookie.
+  return vec3<f32>(1.0);
+#endif
+}
 #ifdef CLUSTER_FORWARD_AVAILABLE
 #import forgeax_hdrp::cluster_forward::{evaluate_cluster_lights, get_ssao_intensity}
 #endif
@@ -19,6 +39,7 @@
 #pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
 #pragma variant_axis TRANSMISSION_AVAILABLE
+#pragma variant_axis PROJECTOR_AVAILABLE
 
 // @forgeax/engine-shader - default-standard-pbr.wgsl
 // (feat-20260523-shader-template-instance-split M5 / T04).
@@ -289,25 +310,6 @@ fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
   }
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-  let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-  let nearPoint = nearH.xyz / nearH.w;
-  let farPoint = farH.xyz / farH.w;
-  direction = normalize(farPoint - nearPoint);
-    // Orthographic rays are parallel, but their origins differ per fragment.
-    // Project the current fragment onto the camera plane instead of reusing
-    // the center NDC ray origin for every pixel.
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 // Light evaluators live in forgeax_pbr::lighting_directional +
 // forgeax_pbr::lighting_punctual (M5 / T02). evalDirectional consumes the
 // host's view UBO + shadowMap (LO 3.1.3 slope-scaled-bias 3x3 PCF;
@@ -778,6 +780,9 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 #endif
   }
   let spotCount = spotLightsBuffer.count;
+  // Surface and volume consume the same projectSpotUv / projectorRevision
+  // tuple; an accepted projector is sampled with textureSampleLevel.
+  const PROJECTOR_ONLY_TILE : i32 = -2;
   for (var i: u32 = 0u; i < spotCount; i = i + 1u) {
     let s = spotLightsBuffer.slots[i];
     // feat-20260625-spot-light-shadow-mapping M3 / w15 (plan-strategy D-1
@@ -787,23 +792,37 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
     // per-spot perspective matrix from the View UBO `view.spotLightViewProj`
     // array (lane N = shadowAtlasTile N; folded from the standalone binding 9
     // into the View UBO in feat-20260625 w25 for WebGL2 uniform-buffer budget);
-    // the unshadowed path stays on evalSpot. bias hardcoded 0.005 / 0.05 aligns
-    // with the DirectionalLight defaults (D-6); the OOB/NaN gate lives inside
-    // evalSpotShadowed, not here.
+    // the unshadowed path stays on evalSpot. Receiver controls come from the
+    // same packed SpotLight snapshot used by the volume path.
     if (s.shadowAtlasTile >= 0) {
+      let projector = sampleSpotProjector(view.spotLightViewProj[s.shadowAtlasTile], in.worldPos);
       color = color + evalSpotShadowed(
         s.position, s.direction, s.colorTimesIntensity,
         s.cosInner, s.cosOuter, s.invRangeSquared,
-        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
-        view.spotLightViewProj[s.shadowAtlasTile], s.shadowAtlasTile, 0.005, 0.05,
-      );
+        in.worldPos, n, v, albedo, metallic, a, f0,
+        view.spotLightViewProj[s.shadowAtlasTile], s.shadowAtlasTile, s.depthBias, s.normalBias, s.pcfKernelSize, s.shadowIntensity,
+      ) * projector;
       if (material.clearcoat != 0.0) {
         color = color + material.clearcoat * evalSpotShadowed(
           s.position, s.direction, s.colorTimesIntensity,
           s.cosInner, s.cosOuter, s.invRangeSquared,
           in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-          view.spotLightViewProj[s.shadowAtlasTile], s.shadowAtlasTile, 0.005, 0.05,
-        );
+          view.spotLightViewProj[s.shadowAtlasTile], s.shadowAtlasTile, s.depthBias, s.normalBias, s.pcfKernelSize, s.shadowIntensity,
+        ) * projector;
+      }
+    } else if (s.shadowAtlasTile == PROJECTOR_ONLY_TILE) {
+      let projector = sampleSpotProjector(view.spotLightViewProj[0], in.worldPos);
+      color = color + evalSpot(
+        s.position, s.direction, s.colorTimesIntensity,
+        s.cosInner, s.cosOuter, s.invRangeSquared,
+        in.worldPos, n, v, albedo, metallic, a, f0,
+      ) * projector;
+      if (material.clearcoat != 0.0) {
+        color = color + material.clearcoat * evalSpot(
+          s.position, s.direction, s.colorTimesIntensity,
+          s.cosInner, s.cosOuter, s.invRangeSquared,
+          in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
+        ) * projector;
       }
     } else {
     color = color + evalSpot(
@@ -824,7 +843,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let emissiveUv = transformedMaterialUv(material.emissiveTextureCoordinatesTransform, material.emissiveTextureCoordinatesMetadata, in);
   let emissiveSample = sampleMaterialTexture(emissiveTexture, emissiveSampler, emissiveUv, material.emissiveTextureCoordinatesMetadata.zw).rgb;
   color = color + material.emissive * material.emissiveIntensity * emissiveSample;
-  return applySceneFog(view, color, alpha, in.worldPos);
+  return vec4<f32>(color, alpha);
 }
 
 // ── G-buffer output struct (feat-20260612-hdrp-deferred-shading M2 / w12) ──