@forgeax/engine-shader 0.1.27 → 0.1.29

package/src/default-standard-pbr.wgsl

@@ -1,6 +1,6 @@
 #define_import_path forgeax_material::standard
 #pragma material_slot surface
-#import forgeax_material::slot::surface::{evaluate_surface}
+#import forgeax_material::slot::surface::{evaluate_surface, evaluate_standard_surface}
 #import forgeax_material::surface_v1::{SurfaceInput, SurfaceData}
 #import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, shadowMap, shadowSampler, sampleMaterialTexture}
 #import forgeax_scene_temporal::{sceneViewZ}
@@ -14,7 +14,7 @@
 #endif
 #import forgeax_pbr::temporal::{projectPbrSceneTemporal}
 #import forgeax_pbr::brdf::{f_schlick, v_smith, d_ggx}
-#import forgeax_pbr::ibl_sampling::{box_project, sampleIblDiffuse, sampleIblSpecular, sampleReflectionProbeSpecular}
+#import forgeax_pbr::ibl_sampling::{box_project, decodeSpecularEnvironmentScale, sampleIblDiffuse, sampleIblSpecular, sampleReflectionProbeSpecular, projectSpecularRadiance}
 #import forgeax_pbr::lighting_probe::{evaluateProbeDiffuse}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
 #ifdef CLEARCOAT_AVAILABLE
@@ -42,25 +42,9 @@
 #pragma variant_axis TRANSMISSION_AVAILABLE
 #pragma variant_axis DIRECTIONAL_PCSS_AVAILABLE
 #pragma variant_axis PROJECTOR_AVAILABLE
+#pragma variant_axis GPU_DRIVEN_SCENE_INDEX_AVAILABLE
 #pragma variant_axis REFLECTION_FALLBACK_AVAILABLE
 
-// reflection_probe is a scene-projected Standard material lane. Its optional
-// texture arguments stay binding-free here; the host selects the bounded table
-// row and falls back to the Skylight helpers when no candidate is admitted.
-// Keep this compile-time witness in the probe variant only: authored physical
-// aliases intentionally flatten renderer-owned probe axes, and naga_oil must
-// not resolve a probe-only helper for those roots.
-#ifdef PROBE_BLEND_AVAILABLE
-fn reflection_probe_sampling_contract(
-  worldPosition: vec3<f32>,
-  direction: vec3<f32>,
-  boxCenter: vec3<f32>,
-  boxExtents: vec3<f32>,
-) -> vec3<f32> {
-  return box_project(worldPosition, direction, boxCenter, boxExtents);
-}
-#endif
-
 // @forgeax/engine-shader - default-standard-pbr.wgsl
 // (feat-20260523-shader-template-instance-split M5 / T04).
 //
@@ -120,7 +104,7 @@ fn reflection_probe_sampling_contract(
 // plan-strategy D-5). RG-only tangent-space normal: sample.rg encodes
 // (x,y) of the unit-length tangent normal, z is reconstructed via
 // z = sqrt(1 - x^2 - y^2). Default 1x1 normal fallback texture is
-// RG=(128,128) which decodes to tangent (0,0,1) -- zero perturbation when
+// half-float RG=(0.5,0.5), which decodes exactly to tangent (0,0,1) when
 // normalTexture is absent (host-side pipelineState.defaultNormalTextureView,
 // distinct from the white fallback used by baseColor / metallicRoughness
 // slots so a missing normal does not pollute the white-on-missing semantics
@@ -132,21 +116,35 @@ fn reflection_probe_sampling_contract(
 // from the root ParamSchema during composition. Keeping the ABI out of this
 // template prevents a second handwritten interface from drifting from the
 // runtime UBO writer.
+#ifdef BASE_COLOR_TEXTURE_AVAILABLE
 @group(1) @binding(1) var baseColorTexture_sampler : sampler;
 @group(1) @binding(2) var baseColorTexture : texture_2d<f32>;
+#endif
+#ifdef METALLIC_ROUGHNESS_TEXTURE_AVAILABLE
 @group(1) @binding(3) var metallicRoughnessTexture_sampler : sampler;
 @group(1) @binding(4) var metallicRoughnessTexture : texture_2d<f32>;
+#endif
+#ifdef NORMAL_TEXTURE_AVAILABLE
 @group(1) @binding(5) var normalTexture_sampler : sampler;
 @group(1) @binding(6) var normalTexture : texture_2d<f32>;
+#endif
+#ifdef EMISSIVE_TEXTURE_AVAILABLE
 @group(1) @binding(9) var emissiveTexture_sampler : sampler;
 @group(1) @binding(10) var emissiveTexture : texture_2d<f32>;
+#endif
+#ifdef OCCLUSION_TEXTURE_AVAILABLE
 @group(1) @binding(11) var occlusionTexture_sampler : sampler;
 @group(1) @binding(12) var occlusionTexture : texture_2d<f32>;
+#endif
 #ifdef TRANSMISSION_AVAILABLE
+#ifdef TRANSMISSION_TEXTURE_AVAILABLE
 @group(1) @binding(13) var transmissionSampler : sampler;
 @group(1) @binding(14) var transmissionTexture : texture_2d<f32>;
+#endif
+#ifdef THICKNESS_TEXTURE_AVAILABLE
 @group(1) @binding(15) var thicknessSampler : sampler;
 @group(1) @binding(16) var thicknessTexture : texture_2d<f32>;
+#endif
 @group(1) @binding(24) var transmissionBackdropSampler : sampler;
 @group(1) @binding(25) var transmissionBackdropTexture : texture_2d<f32>;
 #endif
@@ -195,11 +193,21 @@ fn reflection_probe_sampling_contract(
 // helper. These compile-time-only witnesses retain the binding contract while
 // every runtime material sample still goes through sampleMaterialTexture.
 fn materialTextureFilteringWitness() {
+#ifdef BASE_COLOR_TEXTURE_AVAILABLE
   let base = baseColorTexture;
+#endif
+#ifdef METALLIC_ROUGHNESS_TEXTURE_AVAILABLE
   let metallicRoughness = metallicRoughnessTexture;
+#endif
+#ifdef NORMAL_TEXTURE_AVAILABLE
   let normal = normalTexture;
+#endif
+#ifdef EMISSIVE_TEXTURE_AVAILABLE
   let emissive = emissiveTexture;
+#endif
+#ifdef OCCLUSION_TEXTURE_AVAILABLE
   let occlusion = occlusionTexture;
+#endif
 #ifdef CLEARCOAT_TEXTURE_AVAILABLE
   let clearcoat = clearcoatTexture;
 #endif
@@ -209,11 +217,21 @@ fn materialTextureFilteringWitness() {
 #ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
   let clearcoatNormal = clearcoatNormalTexture;
 #endif
+#ifdef BASE_COLOR_TEXTURE_AVAILABLE
   let baseWitness = textureSample(base, baseColorTexture_sampler, vec2<f32>(0.0));
+#endif
+#ifdef METALLIC_ROUGHNESS_TEXTURE_AVAILABLE
   let metallicRoughnessWitness = textureSample(metallicRoughness, metallicRoughnessTexture_sampler, vec2<f32>(0.0));
+#endif
+#ifdef NORMAL_TEXTURE_AVAILABLE
   let normalWitness = textureSample(normal, normalTexture_sampler, vec2<f32>(0.0));
+#endif
+#ifdef EMISSIVE_TEXTURE_AVAILABLE
   let emissiveWitness = textureSample(emissive, emissiveTexture_sampler, vec2<f32>(0.0));
+#endif
+#ifdef OCCLUSION_TEXTURE_AVAILABLE
   let occlusionWitness = textureSample(occlusion, occlusionTexture_sampler, vec2<f32>(0.0));
+#endif
 #ifdef CLEARCOAT_TEXTURE_AVAILABLE
   let clearcoatWitness = textureSample(clearcoat, clearcoatSampler, vec2<f32>(0.0));
 #endif
@@ -245,11 +263,19 @@ fn materialTextureFilteringWitness() {
   let specularColorWitness = textureSample(specularColorTexture, specularColorTextureSampler, vec2<f32>(0.0));
 #endif
 #ifdef TRANSMISSION_AVAILABLE
+#ifdef TRANSMISSION_TEXTURE_AVAILABLE
   let transmission = transmissionTexture;
+#endif
+#ifdef THICKNESS_TEXTURE_AVAILABLE
   let thickness = thicknessTexture;
+#endif
+#ifdef TRANSMISSION_TEXTURE_AVAILABLE
   let transmissionWitness = textureSample(transmission, transmissionSampler, vec2<f32>(0.0));
+#endif
+#ifdef THICKNESS_TEXTURE_AVAILABLE
   let thicknessWitness = textureSample(thickness, thicknessSampler, vec2<f32>(0.0));
 #endif
+#endif
 }
 
 // Skylight bindings merged into the PBR material BGL
@@ -292,6 +318,14 @@ struct SkylightUniforms {
 @group(3) @binding(1) var<storage, read> probeBlendRecords : array<vec4<f32>>;
 #endif
 
+#ifdef GPU_DRIVEN_SCENE_INDEX_AVAILABLE
+// GPU-driven production binds the producer-owned Standard material table after
+// the fixed physical texture range. The visible stream carries the projected
+// mesh row and material row selected by the compute cull.
+@group(1) @binding(46) var<storage, read> sceneMaterials : array<MaterialParameters>;
+@group(3) @binding(2) var<storage, read> visibleItems : array<vec2<u32>>;
+#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
@@ -326,7 +360,7 @@ struct VsIn  {
 #endif
 };
 struct VsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) worldPos : vec3<f32>,
   @location(1) worldNormal : vec3<f32>,
   @location(2) uv : vec2<f32>,
@@ -367,6 +401,10 @@ struct VsOut {
 #ifdef TRANSMISSION_AVAILABLE
   @location(7) viewZ : f32,
   @location(13) @interpolate(flat) transmissionBasis1 : vec4<f32>,
+#else
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+  @location(15) @interpolate(flat) materialIndex : u32,
+#endif
 #endif
 };
 
@@ -380,7 +418,7 @@ struct VsOut {
 // 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.
 
-fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32) -> VsOut {
+fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32, materialIndex : 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
@@ -443,6 +481,11 @@ fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32) -> VsOut {
     localToWorld[2].x,
     localToWorld[2].y,
   );
+#endif
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+#if TRANSMISSION_AVAILABLE == false
+  out.materialIndex = materialIndex;
+#endif
 #endif
   // feat-20260613-csm-cascaded-shadow-maps M5 / w19: the per-fragment
   // light-space position varying is gone; evalDirectional computes
@@ -470,17 +513,27 @@ fn standardViewZ(in : VsOut) -> f32 {
 
 @vertex
 fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
-  return vs_main_impl(in, 0u, idx);
+  return vs_main_impl(in, 0u, idx, 0xffffffffu);
 }
 
+#ifdef GPU_DRIVEN_SCENE_INDEX_AVAILABLE
 @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);
+  // carries the material row in the second visible-item lane.
+  let visible = visibleItems[idx];
+  return vs_main_impl(in, visible.x, 0u, visible.y);
+}
+#endif
+
+#ifdef GPU_DRIVEN_SCENE_INDEX_AVAILABLE
+fn selectedMaterial(index : u32) -> MaterialParameters {
+  return sceneMaterials[index];
 }
 
+
+#endif
+
 fn transformedMaterialUv(transform : vec4<f32>, metadata : vec4<f32>, in : VsOut) -> vec2<f32> {
   var source = in.uv;
   if (metadata.x >= 1.0) { source = in.uv1; }
@@ -505,6 +558,7 @@ fn materialVertexColor(in : VsOut) -> vec4<f32> {
 #endif
 }
 
+
 // Keep the cooked artifact content-addressable per declared capability set.
 // Some capability axes only change an imported helper's resource surface; the
 // witness makes that distinction explicit in the composed source as well, so
@@ -550,17 +604,20 @@ fn evaluateStandardSurface(in : VsOut, frontFacing : bool) -> SurfaceData {
 #else
   let positionOS = in.positionOSAndViewZ.xyz;
 #endif
-  return evaluate_surface(SurfaceInput(
-    positionOS,
-    in.worldPos,
-    in.worldNormal,
-    in.worldTangent,
-    viewDirectionWS,
-    in.uv,
-    in.uv1,
-    materialVertexColor(in),
-    frontFacing,
-  ));
+  let input = SurfaceInput(
+    positionOS, in.worldPos, in.worldNormal, in.worldTangent, viewDirectionWS,
+    in.uv, in.uv1, in.uv2, in.uv3, in.uv4, in.uv5,
+    in.uv6And7.xy, in.uv6And7.zw, materialVertexColor(in), frontFacing,
+  );
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+#if TRANSMISSION_AVAILABLE == false
+  return evaluate_standard_surface(input, selectedMaterial(in.materialIndex));
+#else
+  return evaluate_surface(input);
+#endif
+#else
+  return evaluate_surface(input);
+#endif
 }
 
 // The renderer supplies the retained ProbeBlendRecord at the per-object
@@ -620,21 +677,12 @@ struct StandardPbrOutput {
 #endif
 };
 
-@fragment
-fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbrOutput {
-  let _variantIdentity = standardVariantIdentity();
-  let surface = evaluateStandardSurface(in, frontFacing);
-  alphaTestSurface(surface);
-  let alpha = surface.opacity;
+fn standardSurfaceF0(in : VsOut, surface : SurfaceData) -> vec3<f32> {
   let albedo = surface.baseColor;
   let metallic = clamp(finiteScalar(surface.metallic, 0.0), 0.0, 1.0);
-  let iblRoughness = clamp(finiteScalar(surface.roughness, 0.5), 0.04, 1.0);
-  let a = iblRoughness * iblRoughness;
-  let n = normalize(surface.normalWS);
-
-  let v = normalize(view.cameraPos - in.worldPos);
   var specularColor = material.specularColor;
 #ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE
+  if (standardUsesSpecularColorTexture()) {
   let specularUv = transformedMaterialUv(
     material.specularColorTextureCoordinatesTransform,
     material.specularColorTextureCoordinatesMetadata,
@@ -646,9 +694,11 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     specularUv,
     material.specularColorTextureCoordinatesMetadata.zw,
   ).rgb;
+  }
 #endif
   var specularWeight = clamp(finiteScalar(material.specular, 1.0), 0.0, 1.0);
 #ifdef SPECULAR_TEXTURE_AVAILABLE
+  if (standardUsesSpecularTexture()) {
   let specularWeightUv = transformedMaterialUv(
     material.specularTextureCoordinatesTransform,
     material.specularTextureCoordinatesMetadata,
@@ -660,16 +710,57 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     specularWeightUv,
     material.specularTextureCoordinatesMetadata.zw,
   ).a;
+  }
+#endif
+  let safeIor = max(finiteScalar(material.ior, 1.5), 1.0);
+  let dielectricF0 = pow((safeIor - 1.0) / (safeIor + 1.0), 2.0);
+  return mix(vec3<f32>(dielectricF0) * specularColor * specularWeight, albedo, metallic);
+}
+
+// The lighting-owned fallback alpha carries this same material admission to
+// the trace. Unsupported lobes neither receive nor contribute screen radiance.
+fn standardSsrCoverage() -> f32 {
+  var coverage = 1.0;
+#ifdef CLEARCOAT_AVAILABLE
+  coverage = 0.0;
+#endif
+#ifdef ANISOTROPY_AVAILABLE
+  coverage = 0.0;
 #endif
+#ifdef IRIDESCENCE_AVAILABLE
+  coverage = 0.0;
+#endif
+  return coverage;
+}
+
+@fragment
+fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbrOutput {
+  let _variantIdentity = standardVariantIdentity();
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+#if TRANSMISSION_AVAILABLE == false
+  let material = selectedMaterial(in.materialIndex);
+#endif
+#endif
+  let surface = evaluateStandardSurface(in, frontFacing);
+  alphaTestSurface(surface);
+  let alpha = surface.opacity;
+  let albedo = surface.baseColor;
+  let metallic = clamp(finiteScalar(surface.metallic, 0.0), 0.0, 1.0);
+  let iblRoughness = clamp(finiteScalar(surface.roughness, 0.5), 0.04, 1.0);
+  let a = iblRoughness * iblRoughness;
+  let n = normalize(surface.normalWS);
+
+  let v = normalize(view.cameraPos - in.worldPos);
   let safeIor = max(finiteScalar(material.ior, 1.5), 1.0);
   let dielectricF0 = pow((safeIor - 1.0) / (safeIor + 1.0), 2.0);
-  var f0 = mix(vec3<f32>(dielectricF0) * specularColor * specularWeight, albedo, metallic);
+  var f0 = standardSurfaceF0(in, surface);
   var physicalNormal = n;
 #ifdef ANISOTROPY_AVAILABLE
   var anisotropyStrength = finiteScalar(material.anisotropyStrength, 0.0);
   var anisotropyRotation = finiteScalar(material.anisotropyRotation, 0.0);
   var anisotropyDirection = vec2<f32>(1.0, 0.0);
 #ifdef ANISOTROPY_TEXTURE_AVAILABLE
+  if (standardUsesAnisotropyTexture()) {
   let anisotropyUv = transformedMaterialUv(
     material.anisotropyTextureCoordinatesTransform,
     material.anisotropyTextureCoordinatesMetadata,
@@ -686,6 +777,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     anisotropyDirection = normalize(encodedAnisotropyDirection);
   }
   anisotropyStrength = anisotropyStrength * anisotropySample.b;
+  }
 #endif
   physicalNormal = evaluateAnisotropicNormal(
     n,
@@ -699,6 +791,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
   var iridescenceStrength = finiteScalar(material.iridescence, 0.0);
   var iridescenceThicknessFactor = 1.0;
 #ifdef IRIDESCENCE_TEXTURE_AVAILABLE
+  if (standardUsesIridescenceTexture()) {
   let iridescenceUv = transformedMaterialUv(
     material.iridescenceTextureCoordinatesTransform,
     material.iridescenceTextureCoordinatesMetadata,
@@ -711,8 +804,10 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     material.iridescenceTextureCoordinatesMetadata.zw,
   );
   iridescenceStrength = iridescenceStrength * iridescenceSample.r;
+  }
 #endif
 #ifdef IRIDESCENCE_THICKNESS_TEXTURE_AVAILABLE
+  if (standardUsesIridescenceThicknessTexture()) {
   let iridescenceThicknessUv = transformedMaterialUv(
     material.iridescenceThicknessTextureCoordinatesTransform,
     material.iridescenceThicknessTextureCoordinatesMetadata,
@@ -725,6 +820,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     material.iridescenceThicknessTextureCoordinatesMetadata.zw,
   );
   iridescenceThicknessFactor = clamp(iridescenceThicknessSample.g, 0.0, 1.0);
+  }
 #endif
   let filmThickness = mix(
     finiteScalar(material.iridescenceThicknessMinimum, 100.0),
@@ -740,28 +836,30 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
 #endif
   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(
+  var transmissionSample = 1.0;
+#ifdef TRANSMISSION_TEXTURE_AVAILABLE
+  if (standardUsesTransmissionTexture()) {
+  let transmissionUv = transformedMaterialUv(material.transmissionTextureCoordinatesTransform, material.transmissionTextureCoordinatesMetadata, in);
+  transmissionSample = sampleMaterialTexture(
     transmissionTexture,
     transmissionSampler,
     transmissionUv,
     material.transmissionTextureCoordinatesMetadata.zw,
   ).r;
-  let thicknessSample = sampleMaterialTexture(
+  }
+#endif
+  var thicknessSample = 1.0;
+#ifdef THICKNESS_TEXTURE_AVAILABLE
+  if (standardUsesThicknessTexture()) {
+  let thicknessUv = transformedMaterialUv(material.thicknessTextureCoordinatesTransform, material.thicknessTextureCoordinatesMetadata, in);
+  thicknessSample = sampleMaterialTexture(
     thicknessTexture,
     thicknessSampler,
     thicknessUv,
     material.thicknessTextureCoordinatesMetadata.zw,
   ).g;
+  }
+#endif
   let transmissionFactor = clamp(
     finiteScalar(material.transmission, 0.0) * finiteScalar(transmissionSample, 1.0),
     0.0,
@@ -851,6 +949,12 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
   // factor. The non-HDRP path leaves ambient untouched.
   let skyColor = vec3<f32>(skylight.colorR, skylight.colorG, skylight.colorB);
   let skyFactor = skyColor * skylight.intensity;
+  // ReflectionProbe sentinel metadata is decoded by the shared IBL owner;
+  // both ambient specular and the detached SSR fallback use the same scale.
+  let specularEnvironmentScale = decodeSpecularEnvironmentScale(
+    skyColor,
+    skylight.intensity,
+  );
   var reflectionFallback = specularIbl * (vec3<f32>(1.0) - coatF);
   var ambient = (kD * irradiance * diffuseAlbedo + specularIbl) *
     (vec3<f32>(1.0) - coatF);
@@ -872,25 +976,20 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     diffuseAlbedo,
     metallic,
   );
-  ambient = (probeDiffuse + specularIbl * skyFactor) *
+  ambient = (probeDiffuse + specularIbl * specularEnvironmentScale) *
     (vec3<f32>(1.0) - coatF);
 #endif
 #ifdef PROBE_BLEND_AVAILABLE
   ambient = ambient * ao;
+  reflectionFallback = reflectionFallback * specularEnvironmentScale * ao;
 #else
   // In the regular Skylight path tint/intensity are applied after sampling.
   // In the probe-sentinel path intensity is encoded as -(probeIntensity + 1),
   // so decode only the non-negative payload and keep zero-intensity probes
   // distinct from an absent Skylight.
-  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;
-  }
+  let environmentScale = specularEnvironmentScale * 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):
@@ -1011,7 +1110,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
   // view_z: NDC depth for cluster Z-slice lookup.
   color = color + evaluateStandardClusterLights(
     in.ndc.xyz, standardViewZ(in), in.worldPos, physicalNormal, v,
-    diffuseAlbedo, metallic, a, f0, false,
+    diffuseAlbedo, metallic, a, f0, false, true,
   );
 #endif // CLUSTER_FORWARD_AVAILABLE
   // Emissive is part of the lower-energy stack and is attenuated by the
@@ -1021,6 +1120,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
   var sheenColor = material.sheenColor;
   var sheenRoughnessFactor = 1.0;
 #ifdef SHEEN_COLOR_TEXTURE_AVAILABLE
+  if (standardUsesSheenColorTexture()) {
   let sheenColorUv = transformedMaterialUv(
     material.sheenColorTextureCoordinatesTransform,
     material.sheenColorTextureCoordinatesMetadata,
@@ -1032,8 +1132,10 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     sheenColorUv,
     material.sheenColorTextureCoordinatesMetadata.zw,
   ).rgb;
+  }
 #endif
 #ifdef SHEEN_ROUGHNESS_TEXTURE_AVAILABLE
+  if (standardUsesSheenRoughnessTexture()) {
   let sheenRoughnessUv = transformedMaterialUv(
     material.sheenRoughnessTextureCoordinatesTransform,
     material.sheenRoughnessTextureCoordinatesMetadata,
@@ -1045,6 +1147,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     sheenRoughnessUv,
     material.sheenRoughnessTextureCoordinatesMetadata.zw,
   ).a;
+  }
 #endif
   let sheenRoughness = clamp(
     finiteScalar(material.sheenRoughness, 0.0) * sheenRoughnessFactor,
@@ -1056,6 +1159,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
 #ifdef CLEARCOAT_AVAILABLE
   var clearcoatFactor = clamp(material.clearcoat, 0.0, 1.0);
 #ifdef CLEARCOAT_TEXTURE_AVAILABLE
+  if (standardUsesClearcoatTexture()) {
   let clearcoatUv = transformedMaterialUv(material.clearcoatTextureCoordinatesTransform, material.clearcoatTextureCoordinatesMetadata, in);
   clearcoatFactor = clamp(
     material.clearcoat * sampleMaterialTexture(
@@ -1067,9 +1171,11 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     0.0,
     1.0,
   );
+  }
 #endif
   var clearcoatRoughnessValue = clamp(max(material.clearcoatRoughness, 0.04), 0.04, 1.0);
 #ifdef CLEARCOAT_ROUGHNESS_TEXTURE_AVAILABLE
+  if (standardUsesClearcoatRoughnessTexture()) {
   let clearcoatRoughnessUv = transformedMaterialUv(material.clearcoatRoughnessTextureCoordinatesTransform, material.clearcoatRoughnessTextureCoordinatesMetadata, in);
   clearcoatRoughnessValue = clamp(
     max(material.clearcoatRoughness, 0.04) * sampleMaterialTexture(
@@ -1081,9 +1187,11 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
     0.04,
     1.0,
   );
+  }
 #endif
   var clearcoatNormalValue = in.worldNormal;
 #ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
+  if (standardUsesClearcoatNormalTexture()) {
   let clearcoatNormalUv = transformedMaterialUv(material.clearcoatNormalTextureCoordinatesTransform, material.clearcoatNormalTextureCoordinatesMetadata, in);
   clearcoatNormalValue = applyTBN(
     in.worldNormal,
@@ -1098,6 +1206,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
       material.clearcoatNormalScale,
     ),
   );
+  }
 #endif
   var clearcoatIbl = vec3<f32>(0.0);
   if (skylight.intensity < 0.0) {
@@ -1154,7 +1263,7 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
   var output : StandardPbrOutput;
   output.color = vec4<f32>(color, alpha);
 #ifdef REFLECTION_FALLBACK_AVAILABLE
-  output.reflectionFallback = vec4<f32>(reflectionFallback, 1.0);
+  output.reflectionFallback = vec4<f32>(reflectionFallback, standardSsrCoverage());
 #endif
   return output;
 }
@@ -1168,18 +1277,17 @@ fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) -> StandardPbr
 // D-2 / requirements §3.2 g-buffer schema:
 //   @location(0) RT0 = normal.rgb + roughness.a → rgba16f
 //   @location(1) RT1 = albedo.rgb + metallic.a → rgba8unorm
-//   @location(2) RT2 = emissive.rgb + ao.a → rgba16f
+//   @location(2) RT2 = material-owned specular response.rgb + ao.a → rgba16f
 
 struct GBufferOutput {
   @location(0) normal_roughness : vec4<f32>,
   @location(1) albedo_metallic  : vec4<f32>,
-  @location(2) emissive_ao      : vec4<f32>,
+  @location(2) specular_response_ao : vec4<f32>,
 };
 
-/// Deferred g-buffer fragment entry: writes material properties (normal,
-/// albedo, roughness, metallic, emissive, ao) to a 3-RT g-buffer for the
-/// deferred lighting pass to decode. Lighting evaluation is deferred — this
-/// entry does NOT compute GGX / directional / cluster lights.
+/// Material g-buffer entry: writes normal/roughness, albedo/metallic and the
+/// material-owned unit-radiance specular response/AO. Direct lighting and
+/// emissive color remain in the same material's forward lighting entry.
 ///
 /// Shares the same vertex shader `vs_main` and the same material UBO / texture
 /// bindings as `fs_main`; only the fragment output differs. The HDRP
@@ -1197,12 +1305,17 @@ fn fs_gbuffer(in : VsOut, @builtin(front_facing) frontFacing : bool) -> GBufferO
   var out : GBufferOutput;
   out.normal_roughness = vec4<f32>(n * 0.5 + 0.5, roughness);
   out.albedo_metallic  = vec4<f32>(albedo, metallic);
-  out.emissive_ao      = vec4<f32>(surface.emissive, surface.occlusion);
+  // Preserve the material's own IOR/specular maps and BRDF projection. SSR
+  // applies this response once per visible pixel without re-drawing geometry.
+  let response = projectSpecularRadiance(vec3<f32>(1.0), n,
+    normalize(view.cameraPos - in.worldPos), roughness,
+    standardSurfaceF0(in, surface), brdfLut, brdfLutSampler) * surface.occlusion;
+  out.specular_response_ao = vec4<f32>(response, surface.occlusion);
   return out;
 }
 
 struct TemporalVsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) uv : vec2<f32>,
   @location(1) uv1 : vec2<f32>,
   @location(2) uv2 : vec2<f32>,
@@ -1229,7 +1342,7 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32) -> TemporalVsOut {
 #endif
   var out : TemporalVsOut;
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
-  out.clip = out.currentClip;
+  out.clip = view.worldViewProj * currentWorld;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
   out.uv = in.uv;
   out.uv1 = in.uv1;
@@ -1262,10 +1375,13 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   return projectPbrSceneTemporal(
     material.baseColor.a * temporalVertexAlpha(in),
     material.alphaCutoff,
+#ifdef BASE_COLOR_TEXTURE_AVAILABLE
+    standardUsesBaseColorTexture(),
     baseColorTexture,
     baseColorTexture_sampler,
     material.baseColorTextureCoordinatesTransform,
     material.baseColorTextureCoordinatesMetadata,
+#endif
     in.currentClip,
     in.previousClip,
     view.temporalProjection,