@forgeax/engine-shader 0.1.20 → 0.1.23

package/src/default-standard-pbr.wgsl

@@ -1,45 +1,25 @@
 #define_import_path forgeax_material::standard
-#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_view::common::{View, Mesh, InstanceData, view, meshes, instances, shadowMap, shadowSampler, sampleMaterialTexture}
+#import forgeax_scene_temporal::{sceneViewZ}
 #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::ibl_sampling::{sampleIblDiffuse, sampleIblSpecular, sampleReflectionProbeSpecular}
+#import forgeax_pbr::lighting_probe::{evaluateProbeDiffuse}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
 #import forgeax_pbr::lighting_directional::{evalDirectionalNoShadow, evalDirectionalShadowFactor}
-#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}
+#import forgeax_standard::cluster::{evaluateStandardClusterLights, get_ssao_intensity}
 #endif
 
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis CLUSTER_FORWARD_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
+#pragma variant_axis PROBE_BLEND_AVAILABLE
+#pragma variant_axis EXTENDED_LIGHTING_AVAILABLE
 #pragma variant_axis TRANSMISSION_AVAILABLE
+#pragma variant_axis DIRECTIONAL_PCSS_AVAILABLE
 #pragma variant_axis PROJECTOR_AVAILABLE
+#pragma variant_axis REFLECTION_FALLBACK_AVAILABLE
 
 // @forgeax/engine-shader - default-standard-pbr.wgsl
 // (feat-20260523-shader-template-instance-split M5 / T04).
@@ -235,6 +215,12 @@ struct SkylightUniforms {
 @group(1) @binding(22) var brdfLutSampler       : sampler;
 @group(1) @binding(23) var<uniform> skylight    : SkylightUniforms;
 
+#ifdef PROBE_BLEND_AVAILABLE
+// Optional consumer lane. The host must provide the retained 160B record
+// buffer and matching BGL before enabling this capability.
+@group(3) @binding(1) var<storage, read> probeBlendRecords : array<vec4<f32>>;
+#endif
+
 // 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
 // cluster bindings (binding 7 = ssao texture, binding 8 = sampler). The
@@ -274,7 +260,11 @@ struct VsOut {
   @location(1) worldNormal : vec3<f32>,
   @location(2) uv : vec2<f32>,
   @location(3) worldTangent : vec4<f32>,
-  @location(4) @interpolate(flat) instanceIdx : u32,
+#ifdef TRANSMISSION_AVAILABLE
+  // Keep mesh and instance storage vertex-only; transmission receives the
+  // transform basis from the vertex stage below.
+  @location(4) @interpolate(flat) transmissionBasis0 : vec4<f32>,
+#endif
   // feat-city-glb multi-UV tiling: second UV set inter-stage varying. Uses the
   // previously-vacant @location(5) so @location(6)/(7) stay byte-stable with
   // the prior layout (CSM M5/w19).
@@ -288,7 +278,7 @@ struct VsOut {
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
-  @location(6) ndc : vec3<f32>,  // NDC for HDRP cluster lookup (w10)
+  @location(6) ndc : vec4<f32>,  // NDC for HDRP cluster lookup; .w = transmission basis tail
   // feat-20260609-hdrp-cluster-fragment-ggx M4.5-followup: view-space z is
   // needed by ndc_position_to_cluster (slice index uses log-z mapping that
   // takes negative view_z, NOT NDC z which is [0,1]). Earlier `in.ndc.z`
@@ -297,6 +287,9 @@ struct VsOut {
   // hot zone -- received zero light. Forward view_z explicitly. M5 / w19:
   // also feeds CSM cascade selection in evalDirectional.
   @location(7) viewZ : f32,
+#ifdef TRANSMISSION_AVAILABLE
+  @location(15) @interpolate(flat) transmissionBasis1 : vec4<f32>,
+#endif
 };
 
 fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
@@ -310,18 +303,12 @@ fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
   }
 }
 
-// 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;
-// feat-20260520-directional-light-shadow-mapping byte-equivalent). evalPoint
-// / evalSpot share evalPunctualBody (GGX specular + Lambertian diffuse +
-// KHR_lights_punctual quartic range attenuation;
-// feat-20260519-light-casters-point-spot-pbr M4 / w22 byte-equivalent).
-// Charter P4: spot light is a thin cone-multiplier on top of the punctual
-// body, point light is the body unchanged -- no magic-value collapse.
+// Directional lighting lives in forgeax_pbr::lighting_directional. Point,
+// Spot, and Rect local lights are evaluated by the Standard Cluster module
+// below from one indexed light_data corpus; no per-kind fixed-slot loop is
+// present in this material shader.
 
-@vertex
-fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
+fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32) -> VsOut {
   // feat-20260604-instances-per-instance-transform-shader-group3-bin M1 / w4:
   // Entity world from meshes[0] — the @group(2) dynamic-offset window has
   // already been aimed at this entity's slot (render-system-record.ts:2996
@@ -329,8 +316,8 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // local from instances[idx] — @group(3) is a flat per-instance buffer indexed
   // directly by instance_index (firstInstance=0, render-system-record.ts:2898).
   // Combine: entity_world * per_instance_local.
-  let instanceLocal = instances[idx].localFromInstance;
-  let entityWorld = meshes[0].worldFromLocal;
+  let instanceLocal = instances[instanceIndex].localFromInstance;
+  let entityWorld = meshes[meshIndex].worldFromLocal;
   let localToWorld = entityWorld * instanceLocal;
   let world = localToWorld * vec4<f32>(in.pos, 1.0);
   var out : VsOut;
@@ -358,6 +345,20 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // (w=0); .w handedness preserved for bitangent reconstruction in fragment.
   let worldTangentXyz = normalize((entityWorld * instanceLocal * vec4<f32>(in.tangent.xyz, 0.0)).xyz);
   out.worldTangent = vec4<f32>(worldTangentXyz, in.tangent.w);
+#ifdef TRANSMISSION_AVAILABLE
+  out.transmissionBasis0 = vec4<f32>(
+    localToWorld[0].x,
+    localToWorld[0].y,
+    localToWorld[0].z,
+    localToWorld[1].x,
+  );
+  out.transmissionBasis1 = vec4<f32>(
+    localToWorld[1].y,
+    localToWorld[1].z,
+    localToWorld[2].x,
+    localToWorld[2].y,
+  );
+#endif
   out.uv = in.uv;
   out.uv1 = in.uv1;
   out.uv2 = in.uv2;
@@ -369,7 +370,6 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
 #ifdef VERTEX_COLOR_AVAILABLE
   out.color = in.color;
 #endif
-  out.instanceIdx = idx;
   // feat-20260613-csm-cascaded-shadow-maps M5 / w19: the per-fragment
   // light-space position varying is gone; evalDirectional computes
   // per-cascade lightViewProj * worldPos in the fragment stage from
@@ -377,15 +377,30 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // NDC for HDRP cluster lookup (feat-20260609-hdrp-cluster-fragment-ggx M2 / w10).
   // Perspective divide on clip-space position; ndc.z retains depth-buffer value.
   let clipPos = out.clip;
-  out.ndc = vec3(clipPos.xy / clipPos.w, clipPos.z / clipPos.w);
+  out.ndc = vec4(clipPos.xy / clipPos.w, clipPos.z / clipPos.w, localToWorld[2].z);
   // Standard WebGPU/GL perspective projection has clip.w = -view.z, so
   // view_z = -clip.w (negative in front of the camera). M4.5-followup:
   // ndc_position_to_cluster needs this for log-z slice mapping; passing
   // ndc.z (in [0,1]) instead made every fragment land in slice 0.
-  out.viewZ = -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;
 }
 
+@vertex
+fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
+  return vs_main_impl(in, 0u, idx);
+}
+
+@vertex
+fn vs_scene_index(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
+  // GPU-driven scene projection packs one Mesh row per visible candidate and
+  // uses the identity instance row. The scene index therefore selects the
+  // projected Mesh directly while retaining the Standard PBR varyings.
+  return vs_main_impl(in, idx, 0u);
+}
+
 fn transformedMaterialUv(transform : vec4<f32>, metadata : vec4<f32>, in : VsOut) -> vec2<f32> {
   var source = in.uv;
   if (metadata.x >= 1.0) { source = in.uv1; }
@@ -447,8 +462,17 @@ fn alphaTest(alpha : f32) {
   }
 }
 
+struct StandardPbrOutput {
+  @location(0) color : vec4<f32>,
+#ifdef REFLECTION_FALLBACK_AVAILABLE
+  // Linear HDR environment contribution from this same Standard BRDF callsite.
+  // The detached producer names this second target S_fallback.
+  @location(1) reflectionFallback : vec4<f32>,
+#endif
+};
+
 @fragment
-fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
+fn fs_main(in : VsOut) -> StandardPbrOutput {
   let baseUv = transformedMaterialUv(material.baseColorTextureCoordinatesTransform, material.baseColorTextureCoordinatesMetadata, in);
   let baseSample = sampleMaterialTexture(baseColorTexture, baseColorSampler, baseUv, material.baseColorTextureCoordinatesMetadata.zw);
   let vertexColor = materialVertexColor(in);
@@ -561,7 +585,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   //  feat-20260520-directional-light-shadow-mapping +
   //  feat-20260518-pbr-direct-lighting-mvp Finding 4):
   //
-  //   color = ambient(IBL) + directional(shadowed) + sum(point) + sum(spot)
+  //   color = ambient(IBL) + directional(shadowed) + clustered local lights
   //
   // When the host Skylight bind group provides default-zero resources the IBL
   // helpers sample to vec3(0) and ambient = 0, so the shader falls through to
@@ -577,22 +601,33 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // split-sum mip lookup, so we re-derive the post-shader-clamp roughness
   // here (matches sampleIblSpecular's `mip = roughness * 4.0` expectation).
   //
-  // Direct lights (1 + N + N): one directional + N point + N spot, summed
-  // sequentially. LIGHT_ARRAY_MAX_SLOTS = 4 host-side bounds the loop trip
-  // counts. GGX BRDF helpers (d_ggx / v_smith / f_schlick from
-  // forgeax_pbr::brdf) run inside each evalDirectional / evalPoint / evalSpot
-  // so all three light types share the same microfacet specular + Lambertian
-  // diffuse form. The directional path additionally projects worldPos
-  // through the per-cascade light-space matrix in the fragment stage for
-  // shadow-map PCF lookup (CSM, feat-20260613).
+  // Directional lighting is evaluated here. All local lights (Point, Spot,
+  // Rect) are evaluated by the Standard Cluster module below, which reads
+  // one indexed light_data corpus and never performs a fixed-slot loop.
   let kD = (vec3<f32>(1.0) - f_schlick(max(dot(n, v), 0.0), f0)) * (1.0 - metallic);
   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,
-    skylight.rotation,
-    prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
-  );
+  var irradiance = vec3<f32>(0.0);
+  var specularIbl = vec3<f32>(0.0);
+  if (skylight.intensity < 0.0) {
+    // A negative intensity is the renderer-owned probe sentinel. The producer
+    // stores -(probeIntensity + 1), so intensity=0 remains distinguishable
+    // from the ordinary Skylight zero payload. The four color/rotation lanes
+    // carry probe center and half extents in this mode; Skylight resources
+    // remain unchanged and therefore preserve the ABI.
+    specularIbl = sampleReflectionProbeSpecular(
+      n, v, iblRoughness, f0, in.worldPos,
+      vec3<f32>(skylight.colorR, skylight.colorG, skylight.colorB),
+      skylight.rotation.xyz, vec4<f32>(0.0, 0.0, 0.0, 1.0),
+      prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
+    );
+  } else {
+    irradiance = sampleIblDiffuse(n, skylight.rotation, irradianceMap, irradianceSampler);
+    specularIbl = sampleIblSpecular(
+      n, v, iblRoughness, f0,
+      skylight.rotation,
+      prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
+    );
+  }
   let occlusionUv = transformedMaterialUv(material.occlusionTextureCoordinatesTransform, material.occlusionTextureCoordinatesMetadata, in);
   let aoSample = sampleMaterialTexture(occlusionTexture, occlusionSampler, occlusionUv, material.occlusionTextureCoordinatesMetadata.zw);
   let ao = mix(1.0, aoSample.r, material.occlusionStrength);
@@ -600,16 +635,67 @@ 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);
+  let skyFactor = skyColor * skylight.intensity;
+  var reflectionFallback = specularIbl * (vec3<f32>(1.0) - coatF);
   var ambient = (kD * irradiance * diffuseAlbedo + specularIbl) * (vec3<f32>(1.0) - coatF);
+#ifdef PROBE_BLEND_AVAILABLE
+  // group(3) is the per-object bind group; record zero is the object selected
+  // by this draw, independent of instance count.
+  let probeShPreblend = array<vec4<f32>, 9>(
+    probeBlendRecords[1], probeBlendRecords[2], probeBlendRecords[3],
+    probeBlendRecords[4], probeBlendRecords[5], probeBlendRecords[6],
+    probeBlendRecords[7], probeBlendRecords[8], probeBlendRecords[9],
+  );
+  let probeLocalBlendFraction = probeBlendRecords[0].z;
+  let probeDiffuseK = kD / max(vec3<f32>(1.0 - metallic), vec3<f32>(0.0001));
+  let probeDiffuse = evaluateProbeDiffuse(probeShPreblend, probeLocalBlendFraction, n, irradiance * skyFactor, probeDiffuseK, albedo, metallic);
+  ambient = (probeDiffuse + specularIbl * skyFactor) * (vec3<f32>(1.0) - coatF);
+#endif
   if (material.clearcoat != 0.0) {
-    let clearcoatIbl = sampleIblSpecular(
-      n, v, coatRoughness, vec3<f32>(0.04),
-      skylight.rotation,
-      prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
-    );
-    ambient = ambient + clearcoatIbl * material.clearcoat;
+    // Keep the clearcoat lobe on the same selected environment as the base
+    // specular lobe. Probe mode reuses the packed center/extents lanes in the
+    // per-probe uniform; routing it through global Skylight IBL would make the
+    // fallback a mixed-source projection and break c=1 source equivalence.
+    var clearcoatIbl = vec3<f32>(0.0);
+    if (skylight.intensity < 0.0) {
+      clearcoatIbl = sampleReflectionProbeSpecular(
+        n, v, coatRoughness, vec3<f32>(0.04), in.worldPos,
+        vec3<f32>(skylight.colorR, skylight.colorG, skylight.colorB),
+        skylight.rotation.xyz, vec4<f32>(0.0, 0.0, 0.0, 1.0),
+        prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
+      );
+    } else {
+      clearcoatIbl = sampleIblSpecular(
+        n, v, coatRoughness, vec3<f32>(0.04),
+        skylight.rotation,
+        prefilterMap, prefilterSampler, brdfLut, brdfLutSampler,
+      );
+    }
+    let clearcoatContribution = clearcoatIbl * material.clearcoat;
+#ifdef PROBE_BLEND_AVAILABLE
+    if (skylight.intensity < 0.0) {
+      ambient = ambient + clearcoatContribution;
+    } else {
+      ambient = ambient + clearcoatIbl * material.clearcoat * skyFactor;
+    }
+#else
+    ambient = ambient + clearcoatContribution;
+#endif
+    reflectionFallback = reflectionFallback + clearcoatContribution;
   }
-  ambient = ambient * skyColor * skylight.intensity * ao;
+#ifdef PROBE_BLEND_AVAILABLE
+  ambient = ambient * ao;
+#else
+  if (skylight.intensity < 0.0) {
+    let environmentScale = max(-skylight.intensity - 1.0, 0.0) * ao;
+    ambient = ambient * environmentScale;
+    reflectionFallback = reflectionFallback * environmentScale;
+  } else {
+    let environmentScale = skyColor * skylight.intensity * ao;
+    ambient = ambient * environmentScale;
+    reflectionFallback = reflectionFallback * environmentScale;
+  }
+#endif
 #ifdef CLUSTER_FORWARD_AVAILABLE
   // feat-20260612-hdrp-ssao M2 round-1 + M7 round-2 (plan-strategy D-7 + D-B + D-C):
   // SSAO ambient synthesis. Reads the half-res R8 `ssaoBlurredTexture` from
@@ -625,7 +711,9 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let ssaoFactor = textureSample(ssaoBlurredTexture, ssaoBlurredSampler, ssaoUv).r;
   // scope-amend-webgl2-ubo: intensity packed into cluster_uniform.near_far_log.w.
   let ssaoIntensity = get_ssao_intensity();
+  let ssaoScale = mix(1.0, ssaoFactor * ao, ssaoIntensity);
   ambient *= mix(1.0, ssaoFactor * ao, ssaoIntensity);
+  reflectionFallback *= ssaoScale;
 #endif
   var color = ambient;
 #ifdef TRANSMISSION_AVAILABLE
@@ -636,10 +724,17 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // 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 localToWorld0 = in.transmissionBasis0.xyz;
+  let localToWorld1 = vec3<f32>(
+    in.transmissionBasis0.w,
+    in.transmissionBasis1.x,
+    in.transmissionBasis1.y,
+  );
+  let localToWorld2 = vec3<f32>(
+    in.transmissionBasis1.z,
+    in.transmissionBasis1.w,
+    in.ndc.w,
+  );
   let inverseCofactor0 = cross(localToWorld1, localToWorld2);
   let inverseCofactor1 = cross(localToWorld2, localToWorld0);
   let inverseCofactor2 = cross(localToWorld0, localToWorld1);
@@ -723,127 +818,24 @@ 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, diffuseAlbedo, metallic, a, f0);
+  color = color + evaluateStandardClusterLights(
+    in.ndc.xyz, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0, false,
+  );
   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),
+    color = color + material.clearcoat * evaluateStandardClusterLights(
+      in.ndc.xyz, in.viewZ, in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04), false,
     );
   }
-#else
-  let pointCount = pointLightsBuffer.count;
-  for (var i: u32 = 0u; i < pointCount; i = i + 1u) {
-    let p = pointLightsBuffer.slots[i];
-#ifdef POINT_SHADOW_AVAILABLE
-    // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: gate between
-    // shadowed and unshadowed evaluation on the host-assigned
-    // shadowAtlasLayer (>= 0 means PointLightShadow companion exists; -1
-    // sentinel means no shadow). shadowParams[layer] = (near, far,
-    // 1/(far-near), 0) is bound at @group(0) @binding(6) (shadowParams
-    // declared in common.wgsl).
-    if (p.shadowAtlasLayer >= 0) {
-      let lane = shadowParams[p.shadowAtlasLayer];
-      color = color + evalPointShadowed(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
-        p.shadowAtlasLayer, lane.x, lane.y, 0.005, 0.05,
-      );
-      if (material.clearcoat != 0.0) {
-        color = color + material.clearcoat * evalPointShadowed(
-          p.position, p.colorTimesIntensity, p.invRangeSquared,
-          in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-          p.shadowAtlasLayer, lane.x, lane.y, 0.005, 0.05,
-        );
-      }
-    } else {
-      color = color + evalPoint(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
-      );
-      if (material.clearcoat != 0.0) {
-        color = color + material.clearcoat * evalPoint(
-          p.position, p.colorTimesIntensity, p.invRangeSquared,
-          in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-        );
-      }
-    }
-#else
-    color = color + evalPoint(
-      p.position, p.colorTimesIntensity, p.invRangeSquared,
-      in.worldPos, n, v, diffuseAlbedo, metallic, a, f0,
-    );
-    if (material.clearcoat != 0.0) {
-      color = color + material.clearcoat * evalPoint(
-        p.position, p.colorTimesIntensity, p.invRangeSquared,
-        in.worldPos, n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-      );
-    }
-#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
-    // fragment side + D-3 + D-4): gate on the host-assigned shadowAtlasTile
-    // (>= 0 means a spot atlas tile was allocated; -1 sentinel means no
-    // shadow / clipped / direction-degenerate). The shadowed path reads the
-    // 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. 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, 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, 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, diffuseAlbedo, metallic, a, f0,
-    );
-    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),
-      );
-    }
-    }
-  }
 #endif // CLUSTER_FORWARD_AVAILABLE
   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 vec4<f32>(color, alpha);
+  var output : StandardPbrOutput;
+  output.color = vec4<f32>(color, alpha);
+#ifdef REFLECTION_FALLBACK_AVAILABLE
+  output.reflectionFallback = vec4<f32>(reflectionFallback, 1.0);
+#endif
+  return output;
 }
 
 // ── G-buffer output struct (feat-20260612-hdrp-deferred-shading M2 / w12) ──
@@ -931,6 +923,7 @@ struct TemporalVsOut {
   @location(7) uv7 : vec2<f32>,
   @location(8) @interpolate(perspective) currentClip : vec4<f32>,
   @location(9) @interpolate(perspective) previousClip : vec4<f32>,
+  @location(10) @interpolate(flat) reactive : f32,
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
@@ -941,7 +934,7 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32) -> TemporalVsOut {
   let currentWorld = meshes[0].worldFromLocal *
     instances[idx].localFromInstance * vec4<f32>(in.pos, 1.0);
   var previousWorld = currentWorld;
-#if STORAGE_BUFFER_AVAILABLE == true
+#ifdef STORAGE_BUFFER_AVAILABLE
   previousWorld = meshes[0].previousWorldFromLocal *
     instances[idx].previousLocalFromInstance * vec4<f32>(in.pos, 1.0);
 #endif
@@ -949,6 +942,11 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32) -> TemporalVsOut {
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
   out.clip = out.currentClip;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
+#if STORAGE_BUFFER_AVAILABLE == true
+  out.reactive = meshes[0].temporal.x;
+#else
+  out.reactive = 1.0;
+#endif
   out.uv = in.uv;
   out.uv1 = in.uv1;
   out.uv2 = in.uv2;
@@ -974,7 +972,7 @@ fn temporalVertexAlpha(in : TemporalVsOut) -> f32 {
 @fragment
 fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   var reactive = 0.0;
-#if STORAGE_BUFFER_AVAILABLE == true
+#ifdef STORAGE_BUFFER_AVAILABLE
   reactive = meshes[0].temporal.x;
 #endif
   return projectPbrSceneTemporal(
@@ -987,7 +985,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
     in.currentClip,
     in.previousClip,
     view.temporalProjection,
-    reactive,
+    in.reactive,
     in.uv, in.uv1, in.uv2, in.uv3,
     in.uv4, in.uv5, in.uv6, in.uv7,
   );

package/src/fxaa.wgsl

@@ -7,8 +7,8 @@
 // FXAA 3.11 fragment shader -- faithful port of the canonical Simon
 // Rodriguez reference (same lineage as Bevy's WGSL port), adapted to
 // forgeax naga_oil conventions. Hardcoded "High" quality preset: 12-step
-// edge search with compile-time step multipliers (no UBO, no #ifdef quality
-// branches).
+// edge search with compile-time step multipliers (the only UBO field is the
+// final-output dither switch; there are no quality #ifdef branches).
 //
 // Vertex stage: imports the SSOT fullscreen_triangle() from
 // forgeax_view::common (single large triangle, research Finding 1).
@@ -35,10 +35,13 @@
 // Bindings (group 0):
 //   @binding(0) screenTexture : texture_2d<f32>  -- sampled display-encoded input
 //   @binding(1) samp          : sampler           -- linear filterable sampler
+//   @binding(2) params        : FxaaParams        -- final-output policy
 // display-encoded: FXAA samples and writes display-encoded values; the Output
-// Transform owns the sole linear-to-sRGB conversion before this pass.
+// Transform owns the sole linear-to-sRGB conversion before this pass. FXAA is
+// the final Standard surface writer, so the shared bounded dither is applied
+// here, immediately before the surface's UNORM8 conversion.
 
-#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::{FullscreenOutput, ditherUnorm8}
 #import forgeax_view::common::fullscreen_triangle
 
 const EDGE_THRESHOLD_MIN: f32 = 0.0312;
@@ -49,6 +52,18 @@ const ITERATIONS: i32 = 12;
 @group(0) @binding(0) var screenTexture: texture_2d<f32>;
 @group(0) @binding(1) var samp: sampler;
 
+struct FxaaParams {
+  ditherEnabled: f32,
+  // Keep the uniform block at one 16-byte slot. WebGL2/GLES uniform-buffer
+  // validation uses the std140-aligned block size, while the host uploads a
+  // four-f32 (16-byte) payload.
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(0) @binding(2) var<uniform> params: FxaaParams;
+
 fn rgb2luma(rgb: vec3<f32>) -> f32 {
   return sqrt(dot(rgb, vec3<f32>(0.299, 0.587, 0.114)));
 }
@@ -105,7 +120,10 @@ 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>(centerColor, 1.0);
+    return vec4<f32>(
+      select(centerColor, ditherUnorm8(centerColor, in.position.xy), params.ditherEnabled > 0.5),
+      1.0,
+    );
   }
 
   // Lumas of the 4 corners.
@@ -254,5 +272,8 @@ fn fs_main(in: FullscreenOutput) -> @location(0) vec4<f32> {
   }
 
   let finalColor = sampleColor(finalUv);
-  return vec4<f32>(finalColor, 1.0);
+  return vec4<f32>(
+    select(finalColor, ditherUnorm8(finalColor, in.position.xy), params.ditherEnabled > 0.5),
+    1.0,
+  );
 }

package/src/ibl-irradiance.wgsl

@@ -83,7 +83,10 @@ fn irradianceConvolve_fs(in0: CubemapVsOut) -> @location(0) vec4<f32> {
     phi += IRRADIANCE_SAMPLE_DELTA;
   }
 
-  // IRRADIANCE_PAYLOAD_E_TIMES_PI: the stored payload is E * pi.
+  // IRRADIANCE_PAYLOAD_E_OVER_PI: PI * the uniform theta/phi sample average
+  // produces the Lambert-normalized diffuse radiance E / PI. Runtime sampling
+  // consumes this payload directly; applying another Lambert divide would
+  // darken diffuse IBL by PI.
   irradiance = PI * irradiance / max(nrSamples, 1.0);
   return vec4<f32>(irradiance, 1.0);
 }