@forgeax/engine-shader 0.1.7 → 0.1.20

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
@@ -18,6 +38,8 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #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).
@@ -32,8 +54,8 @@
 //
 // Bindings (4 BG layout slots; View + Mesh bindings inherited from
 // forgeax_view::common; shadow map + comparison sampler at view BG
-// @binding(3..4) per shadow-mapping feat; Skylight 7 bindings merged into
-// the PBR material BGL at @binding(7..13) per D-5 round-4):
+// @binding(3..4) per shadow-mapping feat; Skylight 7 bindings merged after
+// the Standard user region per D-5 round-4:
 //
 //   @group(0) @binding(0) view                       uniform   (see common.wgsl)
 //   @group(1) @binding(0) material                   uniform   (baseColor vec4
@@ -112,6 +134,11 @@ struct Material {
   clearcoatRoughness : f32,
   specularTint       : vec3<f32>,
   normalScale                   : f32,
+  transmission                  : f32,
+  ior                           : f32,
+  thickness                     : f32,
+  attenuationColor              : vec3<f32>,
+  attenuationDistance           : f32,
   baseColorTextureCoordinatesTransform : vec4<f32>,
   baseColorTextureCoordinatesMetadata : vec4<f32>,
   metallicRoughnessTextureCoordinatesTransform : vec4<f32>,
@@ -124,6 +151,10 @@ struct Material {
   emissiveTextureCoordinatesMetadata : vec4<f32>,
   occlusionTextureCoordinatesTransform : vec4<f32>,
   occlusionTextureCoordinatesMetadata : vec4<f32>,
+  transmissionTextureCoordinatesTransform : vec4<f32>,
+  transmissionTextureCoordinatesMetadata : vec4<f32>,
+  thicknessTextureCoordinatesTransform : vec4<f32>,
+  thicknessTextureCoordinatesMetadata : vec4<f32>,
 };
 
 @group(1) @binding(0) var<uniform> material : Material;
@@ -139,6 +170,14 @@ struct Material {
 @group(1) @binding(10) var emissiveTexture : texture_2d<f32>;
 @group(1) @binding(11) var occlusionSampler : sampler;
 @group(1) @binding(12) var occlusionTexture : texture_2d<f32>;
+#ifdef TRANSMISSION_AVAILABLE
+@group(1) @binding(13) var transmissionSampler : sampler;
+@group(1) @binding(14) var transmissionTexture : texture_2d<f32>;
+@group(1) @binding(15) var thicknessSampler : sampler;
+@group(1) @binding(16) var thicknessTexture : texture_2d<f32>;
+@group(1) @binding(24) var transmissionBackdropSampler : sampler;
+@group(1) @binding(25) var transmissionBackdropTexture : texture_2d<f32>;
+#endif
 
 // Naga reflection does not retain filtering usage through the generic shared
 // helper. These compile-time-only witnesses retain the binding contract while
@@ -156,6 +195,12 @@ fn materialTextureFilteringWitness() {
   let specularTintWitness = textureSample(specularTint, specularTintSampler, vec2<f32>(0.0));
   let emissiveWitness = textureSample(emissive, emissiveSampler, vec2<f32>(0.0));
   let occlusionWitness = textureSample(occlusion, occlusionSampler, vec2<f32>(0.0));
+#ifdef TRANSMISSION_AVAILABLE
+  let transmission = transmissionTexture;
+  let thickness = thicknessTexture;
+  let transmissionWitness = textureSample(transmission, transmissionSampler, vec2<f32>(0.0));
+  let thicknessWitness = textureSample(thickness, thicknessSampler, vec2<f32>(0.0));
+#endif
 }
 
 // Skylight bindings merged into the PBR material BGL
@@ -163,10 +208,10 @@ fn materialTextureFilteringWitness() {
 // round-4 REVISED). The round-2 stand-alone group 4 Skylight BGL collided
 // with WebGPU's default maxBindGroups=4 in chrome-beta and blocked pbr-pl
 // pipeline-layout creation; round-4 appends the 7 Skylight entries to the
-// PBR material BindGroupLayout at binding 7..13. The material BG factory
+// PBR material BindGroupLayout after the eight Standard texture pairs. The material BG factory
 // (mergeSkylightIntoMaterialBgl in
 // packages/runtime/src/ibl/skylight-bind-group.ts) extends the layout to
-// 14 entries; render-system-record assembles a single merged material
+// merged entries; render-system-record assembles a single merged material
 // BindGroup (no extra setBindGroup(4) call). Identity (default) resources
 // produce ambient = 0; with a real Skylight, ibl_sampling helpers project
 // the IBL irradiance + split-sum specular into `ambient` below.
@@ -182,13 +227,13 @@ struct SkylightUniforms {
   colorB : f32,
   rotation : vec4<f32>,
 };
-@group(1) @binding(13) var irradianceMap        : texture_cube<f32>;
-@group(1) @binding(14) var irradianceSampler    : sampler;
-@group(1) @binding(15) var prefilterMap         : texture_cube<f32>;
-@group(1) @binding(16) var prefilterSampler     : sampler;
-@group(1) @binding(17) var brdfLut              : texture_2d<f32>;
-@group(1) @binding(18) var brdfLutSampler       : sampler;
-@group(1) @binding(19) var<uniform> skylight    : SkylightUniforms;
+@group(1) @binding(17) var irradianceMap        : texture_cube<f32>;
+@group(1) @binding(18) var irradianceSampler    : sampler;
+@group(1) @binding(19) var prefilterMap         : texture_cube<f32>;
+@group(1) @binding(20) var prefilterSampler     : sampler;
+@group(1) @binding(21) var brdfLut              : texture_2d<f32>;
+@group(1) @binding(22) var brdfLutSampler       : sampler;
+@group(1) @binding(23) var<uniform> skylight    : SkylightUniforms;
 
 // feat-20260612-hdrp-ssao M7 (round 2) D-B + D-C, scope-amend-webgl2-ubo:
 // SSAO sampling lives on the HDRP unified BGL @group(2) alongside the
@@ -265,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;
@@ -305,7 +331,8 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // Combine: entity_world * per_instance_local.
   let instanceLocal = instances[idx].localFromInstance;
   let entityWorld = meshes[0].worldFromLocal;
-  let world = entityWorld * instanceLocal * vec4<f32>(in.pos, 1.0);
+  let localToWorld = entityWorld * instanceLocal;
+  let world = localToWorld * vec4<f32>(in.pos, 1.0);
   var out : VsOut;
   out.clip = view.worldViewProj * world;
   out.worldPos = world.xyz;
@@ -387,6 +414,19 @@ fn materialVertexColor(in : VsOut) -> vec4<f32> {
 #endif
 }
 
+fn finiteScalar(value : f32, fallback : f32) -> f32 {
+  let bounded = clamp(value, -65504.0, 65504.0);
+  return select(fallback, bounded, value == value);
+}
+
+fn finiteColor(value : vec3<f32>, fallback : vec3<f32>) -> vec3<f32> {
+  return vec3<f32>(
+    finiteScalar(value.x, fallback.x),
+    finiteScalar(value.y, fallback.y),
+    finiteScalar(value.z, fallback.z),
+  );
+}
+
 // linearColorDomain: transparent source and destination values are blended
 // before any display encoding. The fixed-function material blend state uses
 // this same equation for the render target's declared linear domain.
@@ -423,8 +463,17 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // at the pick_channel call site; values stay in {0,1,2,3}.
   let mrUv = transformedMaterialUv(material.metallicRoughnessTextureCoordinatesTransform, material.metallicRoughnessTextureCoordinatesMetadata, in);
   let mrSample = sampleMaterialTexture(metallicRoughnessTexture, metallicRoughnessSampler, mrUv, material.metallicRoughnessTextureCoordinatesMetadata.zw);
-  let metallic = material.metallic * pick_channel(mrSample, u32(material.metallicChannel));
-  let roughnessTex = pick_channel(mrSample, u32(material.roughnessChannel));
+  let metallic = clamp(
+    finiteScalar(material.metallic, 0.0) *
+      finiteScalar(pick_channel(mrSample, u32(material.metallicChannel)), 1.0),
+    0.0,
+    1.0,
+  );
+  let roughnessTex = clamp(
+    finiteScalar(pick_channel(mrSample, u32(material.roughnessChannel)), 1.0),
+    0.0,
+    1.0,
+  );
 
   // Layer-2 fail-fast: shader internal clamp keeps D_GGX finite for
   // roughness=0 even if the asset somehow bypasses layer-1 register
@@ -433,7 +482,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // so the final roughness >= 0.04 floor is preserved (texture sample is
   // a 1.0-default white when metallicRoughnessTexture is absent, so
   // multiplying after the clamp keeps the floor intact).
-  var a = max(material.roughness, 0.04);
+  var a = max(finiteScalar(material.roughness, 0.5), 0.04);
   a = a * roughnessTex;
   a = a * a;
 
@@ -452,7 +501,57 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let specularTint = material.specularTint * sampleMaterialTexture(
     specularTintTexture, specularTintSampler, specularUv, material.specularTintTextureCoordinatesMetadata.zw,
   ).rgb;
-  let f0 = mix(vec3<f32>(0.04) * specularTint, albedo, metallic);
+  let safeIor = max(finiteScalar(material.ior, 1.5), 1.0);
+  let dielectricF0 = pow((safeIor - 1.0) / (safeIor + 1.0), 2.0);
+  let f0 = mix(vec3<f32>(dielectricF0) * specularTint, albedo, metallic);
+  var diffuseAlbedo = albedo;
+#ifdef TRANSMISSION_AVAILABLE
+  let transmissionUv = transformedMaterialUv(
+    material.transmissionTextureCoordinatesTransform,
+    material.transmissionTextureCoordinatesMetadata,
+    in,
+  );
+  let thicknessUv = transformedMaterialUv(
+    material.thicknessTextureCoordinatesTransform,
+    material.thicknessTextureCoordinatesMetadata,
+    in,
+  );
+  let transmissionSample = sampleMaterialTexture(
+    transmissionTexture,
+    transmissionSampler,
+    transmissionUv,
+    material.transmissionTextureCoordinatesMetadata.zw,
+  ).r;
+  let thicknessSample = sampleMaterialTexture(
+    thicknessTexture,
+    thicknessSampler,
+    thicknessUv,
+    material.thicknessTextureCoordinatesMetadata.zw,
+  ).g;
+  let transmissionFactor = clamp(
+    finiteScalar(material.transmission, 0.0) * finiteScalar(transmissionSample, 1.0),
+    0.0,
+    1.0,
+  );
+  let viewDot = finiteScalar(dot(n, v), 0.0);
+  let refractionFromInside = viewDot < 0.0;
+  let refractionNormal = select(n, -n, refractionFromInside);
+  let refractionEta = select(1.0 / safeIor, safeIor, refractionFromInside);
+  let incident = -v;
+  let refracted = refract(incident, refractionNormal, refractionEta);
+  let refractedLengthSquared = dot(refracted, refracted);
+  let viewCos = clamp(abs(viewDot), 0.0, 1.0);
+  let fresnel = clamp(f_schlick(viewCos, vec3<f32>(dielectricF0)).x, 0.0, 1.0);
+  // `refract` returns the zero vector for total internal reflection. Keep the
+  // reflection/IBL term above authoritative and remove transmission energy
+  // instead of sampling and adding a second reflected environment.
+  let transmittedEnergy = select(
+    0.0,
+    transmissionFactor * (1.0 - metallic) * (1.0 - fresnel),
+    refractedLengthSquared > 1e-6,
+  );
+  diffuseAlbedo = albedo * (1.0 - transmittedEnergy);
+#endif
   let coatRoughness = max(material.clearcoatRoughness, 0.04);
   let coatAlpha = coatRoughness * coatRoughness;
   let coatF = f_schlick(max(dot(n, v), 0.0), vec3<f32>(0.04)) * material.clearcoat;
@@ -487,7 +586,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // through the per-cascade light-space matrix in the fragment stage for
   // shadow-map PCF lookup (CSM, feat-20260613).
   let kD = (vec3<f32>(1.0) - f_schlick(max(dot(n, v), 0.0), f0)) * (1.0 - metallic);
-  let iblRoughness = max(material.roughness, 0.04) * roughnessTex;
+  let iblRoughness = clamp(max(finiteScalar(material.roughness, 0.5), 0.04) * roughnessTex, 0.04, 1.0);
   let irradiance = sampleIblDiffuse(n, skylight.rotation, irradianceMap, irradianceSampler);
   let specularIbl = sampleIblSpecular(
     n, v, iblRoughness, f0,
@@ -501,7 +600,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // CLUSTER_FORWARD_AVAILABLE branch below can `ambient *=` the SSAO
   // factor. The non-HDRP path leaves ambient untouched.
   let skyColor = vec3<f32>(skylight.colorR, skylight.colorG, skylight.colorB);
-  var ambient = (kD * irradiance * albedo + specularIbl) * (vec3<f32>(1.0) - coatF);
+  var ambient = (kD * irradiance * diffuseAlbedo + specularIbl) * (vec3<f32>(1.0) - coatF);
   if (material.clearcoat != 0.0) {
     let clearcoatIbl = sampleIblSpecular(
       n, v, coatRoughness, vec3<f32>(0.04),
@@ -529,8 +628,91 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   ambient *= mix(1.0, ssaoFactor * ao, ssaoIntensity);
 #endif
   var color = ambient;
+#ifdef TRANSMISSION_AVAILABLE
+  let screenUv = in.ndc.xy * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5);
+  // Read the same renderer-owned transform tables that the vertex stage uses
+  // instead of adding six more interstage varyings. WebGPU guarantees only 16
+  // user-defined vertex output locations; keeping the affine conversion in
+  // the fragment stage preserves that contract and keeps thickness in the
+  // glTF unit-scale mesh space before measuring the refracted segment in world
+  // metres.
+  let localToWorld = meshes[0].worldFromLocal * instances[in.instanceIdx].localFromInstance;
+  let localToWorld0 = localToWorld[0].xyz;
+  let localToWorld1 = localToWorld[1].xyz;
+  let localToWorld2 = localToWorld[2].xyz;
+  let inverseCofactor0 = cross(localToWorld1, localToWorld2);
+  let inverseCofactor1 = cross(localToWorld2, localToWorld0);
+  let inverseCofactor2 = cross(localToWorld0, localToWorld1);
+  let localToWorldDet = dot(localToWorld0, inverseCofactor0);
+  let safeLocalToWorldDet = select(1.0, localToWorldDet, abs(localToWorldDet) >= 1e-6);
+  let worldToLocal0 = vec3<f32>(
+    inverseCofactor0.x,
+    inverseCofactor1.x,
+    inverseCofactor2.x,
+  ) / safeLocalToWorldDet;
+  let worldToLocal1 = vec3<f32>(
+    inverseCofactor0.y,
+    inverseCofactor1.y,
+    inverseCofactor2.y,
+  ) / safeLocalToWorldDet;
+  let worldToLocal2 = vec3<f32>(
+    inverseCofactor0.z,
+    inverseCofactor1.z,
+    inverseCofactor2.z,
+  ) / safeLocalToWorldDet;
+  let refractedLocal = normalize(
+    worldToLocal0 * refracted.x +
+      worldToLocal1 * refracted.y +
+      worldToLocal2 * refracted.z,
+  );
+  let worldRefractedDirection =
+    localToWorld0 * refractedLocal.x +
+    localToWorld1 * refractedLocal.y +
+    localToWorld2 * refractedLocal.z;
+  let worldThickness = max(
+    finiteScalar(material.thickness, 0.0) * length(worldRefractedDirection) *
+      finiteScalar(thicknessSample, 1.0),
+    0.0,
+  );
+  let refractedUv = screenUv + (refracted.xy - incident.xy) * worldThickness * 0.25;
+  let guardBand = 0.02;
+  let insideGuardBand = all(refractedUv >= vec2<f32>(guardBand)) &&
+    all(refractedUv <= vec2<f32>(1.0 - guardBand));
+  let backdropMipCount = textureNumLevels(transmissionBackdropTexture);
+  let backdropMaxLod = max(f32(backdropMipCount) - 1.0, 0.0);
+  let backdropLod = clamp(iblRoughness * iblRoughness * backdropMaxLod, 0.0, backdropMaxLod);
+  let unrefractedBackdrop = textureSampleLevel(
+    transmissionBackdropTexture,
+    transmissionBackdropSampler,
+    clamp(screenUv, vec2<f32>(0.0), vec2<f32>(1.0)),
+    backdropLod,
+  ).rgb;
+  var transmittedBackdrop = unrefractedBackdrop;
+  if (refractedLengthSquared > 1e-6 && insideGuardBand) {
+    transmittedBackdrop = textureSampleLevel(
+      transmissionBackdropTexture,
+      transmissionBackdropSampler,
+      clamp(refractedUv, vec2<f32>(0.0), vec2<f32>(1.0)),
+      backdropLod,
+    ).rgb;
+  }
+  let safeAttenuationColor = clamp(
+    finiteColor(material.attenuationColor, vec3<f32>(1.0)),
+    vec3<f32>(0.0),
+    vec3<f32>(1.0),
+  );
+  let safeAttenuationDistance = max(finiteScalar(material.attenuationDistance, 0.0), 0.0);
+  let attenuationExponent = worldThickness / max(safeAttenuationDistance, 1e-6);
+  let beerAttenuation = select(
+    vec3<f32>(1.0),
+    pow(safeAttenuationColor, vec3<f32>(attenuationExponent)),
+    safeAttenuationDistance > 1e-6 && worldThickness > 0.0,
+  );
+  color = color + finiteColor(transmittedBackdrop, vec3<f32>(0.0)) *
+    transmittedEnergy * beerAttenuation;
+#endif
   let directionalShadow = evalDirectionalShadowFactor(n, in.worldPos, in.viewZ);
-  let directionalBase = evalDirectionalNoShadow(n, v, albedo, metallic, a, f0);
+  let directionalBase = evalDirectionalNoShadow(n, v, diffuseAlbedo, metallic, a, f0);
   color = color + directionalShadow * directionalBase;
   if (material.clearcoat != 0.0) {
     let directionalClearcoat = evalDirectionalNoShadow(
@@ -541,7 +723,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 #ifdef CLUSTER_FORWARD_AVAILABLE
   // NDC from vertex shader (perspective-divided clip-space, interpolated).
   // view_z: NDC depth for cluster Z-slice lookup.
-  color = color + evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, albedo, metallic, a, f0);
+  color = color + evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0);
   if (material.clearcoat != 0.0) {
     color = color + material.clearcoat * evaluate_cluster_lights(
       in.ndc, in.viewZ, in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
@@ -562,7 +744,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
       let lane = shadowParams[p.shadowAtlasLayer];
       color = color + evalPointShadowed(
         p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, albedo, metallic, a, f0,
+        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
         p.shadowAtlasLayer, lane.x, lane.y, 0.005, 0.05,
       );
       if (material.clearcoat != 0.0) {
@@ -575,7 +757,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
     } else {
       color = color + evalPoint(
         p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, albedo, metallic, a, f0,
+        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
       );
       if (material.clearcoat != 0.0) {
         color = color + material.clearcoat * evalPoint(
@@ -587,7 +769,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
 #else
     color = color + evalPoint(
       p.position, p.colorTimesIntensity, p.invRangeSquared,
-      in.worldPos, n, v, albedo, metallic, a, f0,
+      in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
     );
     if (material.clearcoat != 0.0) {
       color = color + material.clearcoat * evalPoint(
@@ -598,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
@@ -607,29 +792,43 @@ 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, albedo, metallic, a, f0,
-        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;
       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(
         s.position, s.direction, s.colorTimesIntensity,
         s.cosInner, s.cosOuter, s.invRangeSquared,
-        in.worldPos, n, v, albedo, metallic, a, f0,
+        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
     );
     if (material.clearcoat != 0.0) {
       color = color + material.clearcoat * evalSpot(
@@ -644,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) ──
@@ -730,8 +929,8 @@ struct TemporalVsOut {
   @location(5) uv5 : vec2<f32>,
   @location(6) uv6 : vec2<f32>,
   @location(7) uv7 : vec2<f32>,
-  @location(8) @interpolate(linear) currentClip : vec4<f32>,
-  @location(9) @interpolate(linear) previousClip : vec4<f32>,
+  @location(8) @interpolate(perspective) currentClip : vec4<f32>,
+  @location(9) @interpolate(perspective) previousClip : vec4<f32>,
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
@@ -774,7 +973,7 @@ fn temporalVertexAlpha(in : TemporalVsOut) -> f32 {
 
 @fragment
 fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
-  var reactive = 1.0;
+  var reactive = 0.0;
 #if STORAGE_BUFFER_AVAILABLE == true
   reactive = meshes[0].temporal.x;
 #endif
@@ -787,6 +986,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
     material.baseColorTextureCoordinatesMetadata,
     in.currentClip,
     in.previousClip,
+    view.temporalProjection,
     reactive,
     in.uv, in.uv1, in.uv2, in.uv3,
     in.uv4, in.uv5, in.uv6, in.uv7,

package/src/fxaa.wgsl

@@ -33,14 +33,13 @@
 // holes in shaded surfaces -- the bug this rewrite fixes.
 //
 // Bindings (group 0):
-//   @binding(0) screenTexture : texture_2d<f32>  -- sampled LDR input
+//   @binding(0) screenTexture : texture_2d<f32>  -- sampled display-encoded input
 //   @binding(1) samp          : sampler           -- linear filterable sampler
-// linearLdrColorDomain: FXAA samples and writes linear LDR values; display
-// encoding happens only at the final output surface.
+// display-encoded: FXAA samples and writes display-encoded values; the Output
+// Transform owns the sole linear-to-sRGB conversion before this pass.
 
 #import forgeax_view::common::FullscreenOutput
 #import forgeax_view::common::fullscreen_triangle
-#import forgeax_view::common::linearToSrgbOetf
 
 const EDGE_THRESHOLD_MIN: f32 = 0.0312;
 const EDGE_THRESHOLD_MAX: f32 = 0.125;
@@ -106,7 +105,7 @@ fn fs_main(in: FullscreenOutput) -> @location(0) vec4<f32> {
 
   // Not on an edge (or in a near-uniform region): pass the centre through.
   if lumaRange < max(EDGE_THRESHOLD_MIN, lumaMax * EDGE_THRESHOLD_MAX) {
-    return vec4<f32>(linearToSrgbOetf(centerColor), 1.0);
+    return vec4<f32>(centerColor, 1.0);
   }
 
   // Lumas of the 4 corners.
@@ -255,5 +254,5 @@ fn fs_main(in: FullscreenOutput) -> @location(0) vec4<f32> {
   }
 
   let finalColor = sampleColor(finalUv);
-  return vec4<f32>(linearToSrgbOetf(finalColor), 1.0);
+  return vec4<f32>(finalColor, 1.0);
 }

package/src/hdrp-cluster-forward.wgsl

@@ -6,8 +6,11 @@
 
 #define_import_path forgeax_hdrp::cluster_forward
 
-#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed}
+#import forgeax_pbr::lighting_punctual::{evalPoint, evalSpot, evalSpotShadowed, projectSpotUv}
 #import forgeax_view::common::{view}
+#ifdef PROJECTOR_AVAILABLE
+#import forgeax_view::common::{projectorTexture, projectorSampler}
+#endif
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
 #endif
@@ -16,13 +19,15 @@
 
 const KIND_POINT: u32 = 0u;
 const KIND_SPOT: u32 = 1u;
+const PROJECTOR_ONLY_TILE: i32 = -2;
 
 // LightSlot is the byte-frozen 64B std430/std140 transport contract.
 // [0..2] position, [3] invRangeSquared
 // [4..6] colorTimesIntensity, [7] cosInner
 // [8..10] direction, [11] cosOuter
 // [12] raw kind u32, [13] shadow identity i32
-// [14..15] point near/far f32 bits; spot keeps these lanes zero.
+// [14] point near / spot shadow intensity f32 bits
+// [15] point far / spot PCF kernel width f32 bits
 struct LightSlot {
   position        : vec4<f32>,
   color           : vec4<f32>,
@@ -32,6 +37,23 @@ 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>,
@@ -119,6 +141,7 @@ 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);
       return evalSpotShadowed(
         light.position.xyz, light.direction.xyz, light.color.xyz,
         // LightSlot packs cosInner in color.w and cosOuter in direction.w;
@@ -126,7 +149,22 @@ 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;
     }
     return evalSpot(
       light.position.xyz, light.direction.xyz, light.color.xyz,