@forgeax/engine-shader 0.1.21 → 0.1.24

package/src/default-standard-pbr.wgsl

@@ -1,10 +1,34 @@
 #define_import_path forgeax_material::standard
-#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTexture}
+#pragma material_slot surface
+#import forgeax_material::slot::surface::{evaluate_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}
+#ifdef EXTENDED_LIGHTING_AVAILABLE
+#import forgeax_view::common::{spotModifierSampler, iesProfileTexture, cookieTexture, cookieMatrices}
+#endif
+#ifdef PROJECTOR_AVAILABLE
+#ifndef EXTENDED_LIGHTING_AVAILABLE
+#import forgeax_view::common::{projectorTexture, projectorSampler}
+#endif
+#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::lighting_probe::{evaluateProbeDiffuse}
 #import forgeax_pbr::tbn::{decodeTangentSpaceNormalRg, scaleTangentSpaceNormal, applyTBN}
+#ifdef CLEARCOAT_AVAILABLE
+#import forgeax_pbr::clearcoat::{evaluateClearcoatLayer}
+#endif
+#ifdef ANISOTROPY_AVAILABLE
+#import forgeax_pbr::anisotropy::{evaluateAnisotropicNormal}
+#endif
+#ifdef SHEEN_AVAILABLE
+#import forgeax_pbr::sheen::{evaluateSheenLayer}
+#endif
+#ifdef IRIDESCENCE_AVAILABLE
+#import forgeax_pbr::iridescence::{evaluateIridescenceFresnel}
+#endif
 #import forgeax_pbr::lighting_directional::{evalDirectionalNoShadow, evalDirectionalShadowFactor}
 #ifdef CLUSTER_FORWARD_AVAILABLE
 #import forgeax_standard::cluster::{evaluateStandardClusterLights, get_ssao_intensity}
@@ -13,13 +37,20 @@
 #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
 
-// Reflection probes remain a bounded scene-projected sampling lane. Their
-// optional texture resources are the same Skylight inputs; when no probe is
-// admitted, the explicit Skylight path below remains authoritative.
+// 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>,
@@ -28,6 +59,7 @@ fn reflection_probe_sampling_contract(
 ) -> 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).
@@ -50,14 +82,13 @@ fn reflection_probe_sampling_contract(
 //                                                               + metallic + roughness
 //                                                               + 4 channel selectors f32
 //                                                               + emissive vec3 + emissiveIntensity
-//                                                               + uv/alpha/clearcoat/specularTint = 112 B)
+//                                                               + uv/alpha/specularColor = 104 B)
 //   @group(1) @binding(1) baseColorSampler           sampler
 //   @group(1) @binding(2) baseColorTexture           texture_2d<f32>
 //   @group(1) @binding(3) metallicRoughnessSampler   sampler
 //   @group(1) @binding(4) metallicRoughnessTexture   texture_2d<f32>
 //   @group(1) @binding(5) normalSampler              sampler
 //   @group(1) @binding(6) normalTexture              texture_2d<f32>
-//   @group(1) @binding(7) specularTintSampler + @binding(8) specularTintTexture
 //   @group(1) @binding(9..15) Skylight (irradiance / prefilter / brdfLut +
 //                              samplers) + skylight uniform (intensity)
 //   @group(2) @binding(0) meshes                     storage   (worldFromLocal mat4
@@ -97,63 +128,16 @@ fn reflection_probe_sampling_contract(
 // and tolerates RGB normal maps (b is dropped, z is recomputed --
 // equivalent for unit vectors).
 
-struct Material {
-  baseColor          : vec4<f32>,
-  metallic           : f32,
-  roughness          : f32,
-  // Channel selectors (D-8): 4 independent f32 entries split out of the
-  // legacy `channelMap : vec4<u32>`. Each value is a small integer encoded
-  // as f32 in {0.0, 1.0, 2.0, 3.0} indexing into {r,g,b,a}. Default glTF 2.0
-  // packing = (metallicChannel=2, roughnessChannel=1, aoChannel=0,
-  // extraChannel=0). The fragment casts to u32 at the pick site -- f32 is
-  // chosen so the schema entry type aligns with the 14-tuple
-  // MaterialParamType numeric-run packing rule (4-byte stride, 16 B span).
-  metallicChannel    : f32,
-  roughnessChannel   : f32,
-  aoChannel          : f32,
-  extraChannel       : f32,
-  // vec3 align=16 inserts 8 implicit padding bytes after extraChannel
-  // (offsets 40..48) so emissive lands at offset 48.
-  emissive           : vec3<f32>,
-  emissiveIntensity  : f32,
-  occlusionStrength  : f32,
-  alphaCutoff        : f32,
-  clearcoat          : f32,
-  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>,
-  metallicRoughnessTextureCoordinatesMetadata : vec4<f32>,
-  normalTextureCoordinatesTransform : vec4<f32>,
-  normalTextureCoordinatesMetadata : vec4<f32>,
-  specularTintTextureCoordinatesTransform : vec4<f32>,
-  specularTintTextureCoordinatesMetadata : vec4<f32>,
-  emissiveTextureCoordinatesTransform : vec4<f32>,
-  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;
+// The MaterialParameters struct and its binding-0 declaration are generated
+// 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.
 @group(1) @binding(1) var baseColorSampler : sampler;
 @group(1) @binding(2) var baseColorTexture : texture_2d<f32>;
 @group(1) @binding(3) var metallicRoughnessSampler : sampler;
 @group(1) @binding(4) var metallicRoughnessTexture : texture_2d<f32>;
 @group(1) @binding(5) var normalSampler : sampler;
 @group(1) @binding(6) var normalTexture : texture_2d<f32>;
-@group(1) @binding(7) var specularTintSampler : sampler;
-@group(1) @binding(8) var specularTintTexture : texture_2d<f32>;
 @group(1) @binding(9) var emissiveSampler : sampler;
 @group(1) @binding(10) var emissiveTexture : texture_2d<f32>;
 @group(1) @binding(11) var occlusionSampler : sampler;
@@ -166,6 +150,46 @@ struct Material {
 @group(1) @binding(24) var transmissionBackdropSampler : sampler;
 @group(1) @binding(25) var transmissionBackdropTexture : texture_2d<f32>;
 #endif
+#ifdef CLEARCOAT_TEXTURE_AVAILABLE
+@group(1) @binding(26) var clearcoatSampler : sampler;
+@group(1) @binding(27) var clearcoatTexture : texture_2d<f32>;
+#endif
+#ifdef CLEARCOAT_ROUGHNESS_TEXTURE_AVAILABLE
+@group(1) @binding(28) var clearcoatRoughnessSampler : sampler;
+@group(1) @binding(29) var clearcoatRoughnessTexture : texture_2d<f32>;
+#endif
+#ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
+@group(1) @binding(30) var clearcoatNormalSampler : sampler;
+@group(1) @binding(31) var clearcoatNormalTexture : texture_2d<f32>;
+#endif
+#ifdef ANISOTROPY_TEXTURE_AVAILABLE
+@group(1) @binding(32) var anisotropySampler : sampler;
+@group(1) @binding(33) var anisotropyTexture : texture_2d<f32>;
+#endif
+#ifdef SHEEN_COLOR_TEXTURE_AVAILABLE
+@group(1) @binding(34) var sheenColorSampler : sampler;
+@group(1) @binding(35) var sheenColorTexture : texture_2d<f32>;
+#endif
+#ifdef SHEEN_ROUGHNESS_TEXTURE_AVAILABLE
+@group(1) @binding(36) var sheenRoughnessSampler : sampler;
+@group(1) @binding(37) var sheenRoughnessTexture : texture_2d<f32>;
+#endif
+#ifdef IRIDESCENCE_TEXTURE_AVAILABLE
+@group(1) @binding(38) var iridescenceSampler : sampler;
+@group(1) @binding(39) var iridescenceTexture : texture_2d<f32>;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE_AVAILABLE
+@group(1) @binding(40) var iridescenceThicknessSampler : sampler;
+@group(1) @binding(41) var iridescenceThicknessTexture : texture_2d<f32>;
+#endif
+#ifdef SPECULAR_TEXTURE_AVAILABLE
+@group(1) @binding(42) var specularTextureSampler : sampler;
+@group(1) @binding(43) var specularTexture : texture_2d<f32>;
+#endif
+#ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE
+@group(1) @binding(44) var specularColorTextureSampler : sampler;
+@group(1) @binding(45) var specularColorTexture : 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
@@ -174,15 +198,52 @@ fn materialTextureFilteringWitness() {
   let base = baseColorTexture;
   let metallicRoughness = metallicRoughnessTexture;
   let normal = normalTexture;
-  let specularTint = specularTintTexture;
   let emissive = emissiveTexture;
   let occlusion = occlusionTexture;
+#ifdef CLEARCOAT_TEXTURE_AVAILABLE
+  let clearcoat = clearcoatTexture;
+#endif
+#ifdef CLEARCOAT_ROUGHNESS_TEXTURE_AVAILABLE
+  let clearcoatRoughness = clearcoatRoughnessTexture;
+#endif
+#ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
+  let clearcoatNormal = clearcoatNormalTexture;
+#endif
   let baseWitness = textureSample(base, baseColorSampler, vec2<f32>(0.0));
   let metallicRoughnessWitness = textureSample(metallicRoughness, metallicRoughnessSampler, vec2<f32>(0.0));
   let normalWitness = textureSample(normal, normalSampler, vec2<f32>(0.0));
-  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 CLEARCOAT_TEXTURE_AVAILABLE
+  let clearcoatWitness = textureSample(clearcoat, clearcoatSampler, vec2<f32>(0.0));
+#endif
+#ifdef CLEARCOAT_ROUGHNESS_TEXTURE_AVAILABLE
+  let clearcoatRoughnessWitness = textureSample(clearcoatRoughness, clearcoatRoughnessSampler, vec2<f32>(0.0));
+#endif
+#ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
+  let clearcoatNormalWitness = textureSample(clearcoatNormal, clearcoatNormalSampler, vec2<f32>(0.0));
+#endif
+#ifdef ANISOTROPY_TEXTURE_AVAILABLE
+  let anisotropyWitness = textureSample(anisotropyTexture, anisotropySampler, vec2<f32>(0.0));
+#endif
+#ifdef SHEEN_COLOR_TEXTURE_AVAILABLE
+  let sheenColorWitness = textureSample(sheenColorTexture, sheenColorSampler, vec2<f32>(0.0));
+#endif
+#ifdef SHEEN_ROUGHNESS_TEXTURE_AVAILABLE
+  let sheenRoughnessWitness = textureSample(sheenRoughnessTexture, sheenRoughnessSampler, vec2<f32>(0.0));
+#endif
+#ifdef IRIDESCENCE_TEXTURE_AVAILABLE
+  let iridescenceWitness = textureSample(iridescenceTexture, iridescenceSampler, vec2<f32>(0.0));
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE_AVAILABLE
+  let iridescenceThicknessWitness = textureSample(iridescenceThicknessTexture, iridescenceThicknessSampler, vec2<f32>(0.0));
+#endif
+#ifdef SPECULAR_TEXTURE_AVAILABLE
+  let specularWeightWitness = textureSample(specularTexture, specularTextureSampler, vec2<f32>(0.0));
+#endif
+#ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE
+  let specularColorWitness = textureSample(specularColorTexture, specularColorTextureSampler, vec2<f32>(0.0));
+#endif
 #ifdef TRANSMISSION_AVAILABLE
   let transmission = transmissionTexture;
   let thickness = thicknessTexture;
@@ -223,6 +284,14 @@ 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 provides the retained ProbeBlendRecord
+// storage for the object selected by this draw. Keeping it in group(3)
+// preserves the mesh/instance ownership of groups (2)/(3) without inventing a
+// second probe bind group.
+@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
@@ -266,6 +335,10 @@ struct VsOut {
   // Keep mesh and instance storage vertex-only; transmission receives the
   // transform basis from the vertex stage below.
   @location(4) @interpolate(flat) transmissionBasis0 : vec4<f32>,
+#else
+  // WebGL2 exposes only inter-stage locations 0..14. Pack the object-space
+  // Surface position with its cluster/CSM depth in one varying.
+  @location(7) positionOSAndViewZ : 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
@@ -275,8 +348,9 @@ struct VsOut {
   @location(9) uv3 : vec2<f32>,
   @location(10) uv4 : vec2<f32>,
   @location(11) uv5 : vec2<f32>,
-  @location(12) uv6 : vec2<f32>,
-  @location(13) uv7 : vec2<f32>,
+  // UV6/UV7 share one vec4 slot so the transmission basis tail can stay
+  // inside WebGL2's 14 user varying locations.
+  @location(12) uv6And7 : vec4<f32>,
 #ifdef VERTEX_COLOR_AVAILABLE
   @location(14) color : vec4<f32>,
 #endif
@@ -288,23 +362,14 @@ struct VsOut {
   // surfaces -- whose cluster cells were unrelated to the floor's slice 0
   // hot zone -- received zero light. Forward view_z explicitly. M5 / w19:
   // also feeds CSM cascade selection in evalDirectional.
-  @location(7) viewZ : f32,
+  // Surface position and clustered/CSM view depth share one varying so the
+  // composed Standard shader stays within WebGL2's 14 inter-stage locations.
 #ifdef TRANSMISSION_AVAILABLE
-  @location(15) @interpolate(flat) transmissionBasis1 : vec4<f32>,
+  @location(7) viewZ : f32,
+  @location(13) @interpolate(flat) transmissionBasis1 : vec4<f32>,
 #endif
 };
 
-fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
-  // Branch-free channel pick. WGSL has no array<f32, 4>(rgba) addressable
-  // helper; manual switch keeps the path uniform.
-  switch (channelIndex) {
-    case 0u: { return rgba.r; }
-    case 1u: { return rgba.g; }
-    case 2u: { return rgba.b; }
-    default: { return rgba.a; }
-  }
-}
-
 // 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;
@@ -315,8 +380,7 @@ fn pick_channel(rgba : vec4<f32>, channelIndex : u32) -> f32 {
 // 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.
 
-@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
@@ -324,12 +388,15 @@ 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;
   out.clip = view.worldViewProj * world;
+#ifndef TRANSMISSION_AVAILABLE
+  out.positionOSAndViewZ = vec4<f32>(in.pos, sceneViewZ(out.clip, view.temporalProjection));
+#endif
   out.worldPos = world.xyz;
   // Normal: derive the inverse-transpose from the world matrix columns. This
   // keeps non-uniform entity scale correct while avoiding the Mesh.normalMatrix
@@ -353,6 +420,16 @@ 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);
+  out.uv = in.uv;
+  out.uv1 = in.uv1;
+  out.uv2 = in.uv2;
+  out.uv3 = in.uv3;
+  out.uv4 = in.uv4;
+  out.uv5 = in.uv5;
+  out.uv6And7 = vec4<f32>(in.uv6, in.uv7);
+#ifdef VERTEX_COLOR_AVAILABLE
+  out.color = in.color;
+#endif
 #ifdef TRANSMISSION_AVAILABLE
   out.transmissionBasis0 = vec4<f32>(
     localToWorld[0].x,
@@ -366,17 +443,6 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
     localToWorld[2].x,
     localToWorld[2].y,
   );
-#endif
-  out.uv = in.uv;
-  out.uv1 = in.uv1;
-  out.uv2 = in.uv2;
-  out.uv3 = in.uv3;
-  out.uv4 = in.uv4;
-  out.uv5 = in.uv5;
-  out.uv6 = in.uv6;
-  out.uv7 = in.uv7;
-#ifdef VERTEX_COLOR_AVAILABLE
-  out.color = in.color;
 #endif
   // feat-20260613-csm-cascaded-shadow-maps M5 / w19: the per-fragment
   // light-space position varying is gone; evalDirectional computes
@@ -386,16 +452,35 @@ fn vs_main(in : VsIn, @builtin(instance_index) idx : u32) -> VsOut {
   // Perspective divide on clip-space position; ndc.z retains depth-buffer value.
   let clipPos = out.clip;
   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.
   // Keep the cluster depth exactly aligned with the CPU binner for both
   // perspective and off-axis orthographic projections.
+#ifdef TRANSMISSION_AVAILABLE
   out.viewZ = sceneViewZ(clipPos, view.temporalProjection);
+#endif
   return out;
 }
 
+fn standardViewZ(in : VsOut) -> f32 {
+#ifdef TRANSMISSION_AVAILABLE
+  return in.viewZ;
+#else
+  return in.positionOSAndViewZ.w;
+#endif
+}
+
+@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; }
@@ -403,8 +488,8 @@ fn transformedMaterialUv(transform : vec4<f32>, metadata : vec4<f32>, in : VsOut
   if (metadata.x >= 3.0) { source = in.uv3; }
   if (metadata.x >= 4.0) { source = in.uv4; }
   if (metadata.x >= 5.0) { source = in.uv5; }
-  if (metadata.x >= 6.0) { source = in.uv6; }
-  if (metadata.x >= 7.0) { source = in.uv7; }
+  if (metadata.x >= 6.0) { source = in.uv6And7.xy; }
+  if (metadata.x >= 7.0) { source = in.uv6And7.zw; }
   let scaled = source * transform.zw;
   let angle = metadata.y;
   let c = cos(angle);
@@ -412,10 +497,6 @@ fn transformedMaterialUv(transform : vec4<f32>, metadata : vec4<f32>, in : VsOut
   return vec2<f32>(scaled.x * c - scaled.y * s, scaled.x * s + scaled.y * c) + transform.xy;
 }
 
-fn materialAlpha(baseSample : vec4<f32>) -> f32 {
-  return material.baseColor.a * baseSample.a;
-}
-
 fn materialVertexColor(in : VsOut) -> vec4<f32> {
 #ifdef VERTEX_COLOR_AVAILABLE
   return in.color;
@@ -424,6 +505,79 @@ 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
+// two valid manifest keys can never alias one artifact hash.
+fn standardVariantIdentity() -> f32 {
+  var identity = 0.0;
+#ifdef STORAGE_BUFFER_AVAILABLE
+  identity = identity + 1.0;
+#endif
+#ifdef CLUSTER_FORWARD_AVAILABLE
+  identity = identity + 2.0;
+#endif
+#ifdef VERTEX_COLOR_AVAILABLE
+  identity = identity + 4.0;
+#endif
+#ifdef PROBE_BLEND_AVAILABLE
+  identity = identity + 8.0;
+#endif
+#ifdef EXTENDED_LIGHTING_AVAILABLE
+  identity = identity + 16.0;
+#endif
+#ifdef TRANSMISSION_AVAILABLE
+  identity = identity + 32.0;
+#endif
+#ifdef DIRECTIONAL_PCSS_AVAILABLE
+  identity = identity + 64.0;
+#endif
+#ifdef PROJECTOR_AVAILABLE
+  identity = identity + 128.0;
+#endif
+#ifdef REFLECTION_FALLBACK_AVAILABLE
+  identity = identity + 256.0;
+#endif
+  return identity;
+}
+
+// Standard owns the lighting and pass policy; the selected Surface owns only
+// the base facts exchanged through surface_v1.
+fn evaluateStandardSurface(in : VsOut, frontFacing : bool) -> SurfaceData {
+  let viewDirectionWS = normalize(view.cameraPos - in.worldPos);
+#ifdef TRANSMISSION_AVAILABLE
+  let positionOS = in.worldPos;
+#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,
+  ));
+}
+
+// The renderer supplies the retained ProbeBlendRecord at the per-object
+// consumer boundary. This helper deliberately accepts only diffuse inputs;
+// Skylight/ReflectionProbe continue to own specular.
+fn composeProbeDiffuse(
+  shPreblend : array<vec4<f32>, 9>,
+  localBlendFraction : f32,
+  normal : vec3<f32>,
+  skyIrradiance : vec3<f32>,
+  kD : vec3<f32>,
+  albedo : vec3<f32>,
+  metallic : f32,
+) -> vec3<f32> {
+  return evaluateProbeDiffuse(shPreblend, localBlendFraction, normal, skyIrradiance, kD, albedo, metallic);
+}
+
 fn finiteScalar(value : f32, fallback : f32) -> f32 {
   let bounded = clamp(value, -65504.0, 65504.0);
   return select(fallback, bounded, value == value);
@@ -451,69 +605,139 @@ fn blendLinearTransparent(
 // linearHdrColorDomain: fs_main writes linear HDR when its target is HDR.
 // toneStageInput: the value remains linear until the fullscreen tone stage.
 
-fn alphaTest(alpha : f32) {
-  if (material.alphaCutoff > 0.0 && alpha <= material.alphaCutoff) {
+fn alphaTestSurface(surface : SurfaceData) {
+  if (surface.alphaClipThreshold > 0.0 && surface.opacity <= surface.alphaClipThreshold) {
     discard;
   }
 }
 
-@fragment
-fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
-  let baseUv = transformedMaterialUv(material.baseColorTextureCoordinatesTransform, material.baseColorTextureCoordinatesMetadata, in);
-  let baseSample = sampleMaterialTexture(baseColorTexture, baseColorSampler, baseUv, material.baseColorTextureCoordinatesMetadata.zw);
-  let vertexColor = materialVertexColor(in);
-  alphaTest(material.baseColor.a * baseSample.a * vertexColor.a);
-  let alpha = materialAlpha(baseSample) * vertexColor.a;
-  let albedo = material.baseColor.rgb * baseSample.rgb * vertexColor.rgb;
-
-  // Metallic-roughness texture sampling with per-field channel selectors
-  // (D-8): glTF 2.0 default layout B=metallic, G=roughness, R=occlusion is
-  // encoded by the host as 4 independent f32 selectors in the merged UBO
-  // (metallicChannel/roughnessChannel/aoChannel/extraChannel). Cast to u32
-  // 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 = 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
-  // fail-fast (plan-strategy section 5.3 + AC-02 (b)+(c)). Apply to the
-  // material scalar prior to the channelMap-extracted texture multiplier
-  // 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(finiteScalar(material.roughness, 0.5), 0.04);
-  a = a * roughnessTex;
-  a = a * a;
+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
+};
 
-  // TBN basis composed via forgeax_pbr::tbn helpers; default fallback
-  // (defaultNormalTextureView) RG=(128,128) -> tangent (0,0,1) -> world n
-  // unchanged.
-  let normalUv = transformedMaterialUv(material.normalTextureCoordinatesTransform, material.normalTextureCoordinatesMetadata, in);
-  let normSampleRg = sampleMaterialTexture(normalTexture, normalSampler, normalUv, material.normalTextureCoordinatesMetadata.zw).rg;
-  let normTangent = scaleTangentSpaceNormal(
-    decodeTangentSpaceNormalRg(normSampleRg), material.normalScale,
-  );
-  let n = applyTBN(in.worldNormal, in.worldTangent, normTangent);
+@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;
+  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 specularUv = transformedMaterialUv(material.specularTintTextureCoordinatesTransform, material.specularTintTextureCoordinatesMetadata, in);
-  let specularTint = material.specularTint * sampleMaterialTexture(
-    specularTintTexture, specularTintSampler, specularUv, material.specularTintTextureCoordinatesMetadata.zw,
+  var specularColor = material.specularColor;
+#ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE
+  let specularUv = transformedMaterialUv(
+    material.specularColorTextureCoordinatesTransform,
+    material.specularColorTextureCoordinatesMetadata,
+    in,
+  );
+  specularColor = specularColor * sampleMaterialTexture(
+    specularColorTexture,
+    specularColorTextureSampler,
+    specularUv,
+    material.specularColorTextureCoordinatesMetadata.zw,
   ).rgb;
+#endif
+  var specularWeight = clamp(finiteScalar(material.specular, 1.0), 0.0, 1.0);
+#ifdef SPECULAR_TEXTURE_AVAILABLE
+  let specularWeightUv = transformedMaterialUv(
+    material.specularTextureCoordinatesTransform,
+    material.specularTextureCoordinatesMetadata,
+    in,
+  );
+  specularWeight = specularWeight * sampleMaterialTexture(
+    specularTexture,
+    specularTextureSampler,
+    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);
-  let f0 = mix(vec3<f32>(dielectricF0) * specularTint, albedo, metallic);
+  var f0 = mix(vec3<f32>(dielectricF0) * specularColor * specularWeight, albedo, metallic);
+  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
+  let anisotropyUv = transformedMaterialUv(
+    material.anisotropyTextureCoordinatesTransform,
+    material.anisotropyTextureCoordinatesMetadata,
+    in,
+  );
+  let anisotropySample = sampleMaterialTexture(
+    anisotropyTexture,
+    anisotropySampler,
+    anisotropyUv,
+    material.anisotropyTextureCoordinatesMetadata.zw,
+  );
+  let encodedAnisotropyDirection = 2.0 * anisotropySample.rg - vec2<f32>(1.0, 1.0);
+  if (dot(encodedAnisotropyDirection, encodedAnisotropyDirection) >= 1e-6) {
+    anisotropyDirection = normalize(encodedAnisotropyDirection);
+  }
+  anisotropyStrength = anisotropyStrength * anisotropySample.b;
+#endif
+  physicalNormal = evaluateAnisotropicNormal(
+    n,
+    in.worldTangent,
+    anisotropyStrength,
+    anisotropyRotation,
+    anisotropyDirection,
+  );
+#endif
+#ifdef IRIDESCENCE_AVAILABLE
+  var iridescenceStrength = finiteScalar(material.iridescence, 0.0);
+  var iridescenceThicknessFactor = 1.0;
+#ifdef IRIDESCENCE_TEXTURE_AVAILABLE
+  let iridescenceUv = transformedMaterialUv(
+    material.iridescenceTextureCoordinatesTransform,
+    material.iridescenceTextureCoordinatesMetadata,
+    in,
+  );
+  let iridescenceSample = sampleMaterialTexture(
+    iridescenceTexture,
+    iridescenceSampler,
+    iridescenceUv,
+    material.iridescenceTextureCoordinatesMetadata.zw,
+  );
+  iridescenceStrength = iridescenceStrength * iridescenceSample.r;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE_AVAILABLE
+  let iridescenceThicknessUv = transformedMaterialUv(
+    material.iridescenceThicknessTextureCoordinatesTransform,
+    material.iridescenceThicknessTextureCoordinatesMetadata,
+    in,
+  );
+  let iridescenceThicknessSample = sampleMaterialTexture(
+    iridescenceThicknessTexture,
+    iridescenceThicknessSampler,
+    iridescenceThicknessUv,
+    material.iridescenceThicknessTextureCoordinatesMetadata.zw,
+  );
+  iridescenceThicknessFactor = clamp(iridescenceThicknessSample.g, 0.0, 1.0);
+#endif
+  let filmThickness = mix(
+    finiteScalar(material.iridescenceThicknessMinimum, 100.0),
+    finiteScalar(material.iridescenceThicknessMaximum, 400.0),
+    iridescenceThicknessFactor,
+  );
+  f0 = evaluateIridescenceFresnel(
+    f0,
+    iridescenceStrength,
+    finiteScalar(material.iridescenceIor, 1.3),
+    filmThickness,
+  );
+#endif
   var diffuseAlbedo = albedo;
 #ifdef TRANSMISSION_AVAILABLE
   let transmissionUv = transformedMaterialUv(
@@ -562,10 +786,6 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   );
   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;
-
   // Ambient (IBL) + 1 + N + N accumulation
   // (feat-20260520-skylight-ibl-cubemap M3 / t48 +
   //  feat-20260520-directional-light-shadow-mapping +
@@ -595,49 +815,83 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // 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).
-  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 kD = (vec3<f32>(1.0) - f_schlick(max(dot(physicalNormal, v), 0.0), f0)) * (1.0 - metallic);
+  var coatRoughness = 0.04;
+  var coatAlpha = coatRoughness * coatRoughness;
+  var coatF = vec3<f32>(0.0);
+#ifdef CLEARCOAT_AVAILABLE
+  coatRoughness = max(finiteScalar(material.clearcoatRoughness, 0.04), 0.04);
+  coatAlpha = coatRoughness * coatRoughness;
+  coatF = f_schlick(max(dot(physicalNormal, v), 0.0), vec3<f32>(0.04)) *
+    clamp(finiteScalar(material.clearcoat, 0.0), 0.0, 1.0);
+#endif
   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 four
-    // color/rotation lanes carry probe center and half extents in this mode;
-    // Skylight resources remain unchanged and therefore preserve the ABI.
+    // color/rotation lanes carry the selected probe center and half extents;
+    // ordinary Skylight resources remain unchanged, preserving the ABI.
     specularIbl = sampleReflectionProbeSpecular(
-      n, v, iblRoughness, f0, in.worldPos,
+      physicalNormal, 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);
+    irradiance = sampleIblDiffuse(physicalNormal, skylight.rotation, irradianceMap, irradianceSampler);
     specularIbl = sampleIblSpecular(
-      n, v, iblRoughness, f0,
+      physicalNormal, 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);
+  let ao = surface.occlusion;
   // feat-20260612-hdrp-ssao M7 round-2: `var` (mutable) so the
   // 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 * diffuseAlbedo + specularIbl) * (vec3<f32>(1.0) - coatF);
-  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;
-  }
+  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 = composeProbeDiffuse(probeShPreblend,
+    probeLocalBlendFraction,
+    physicalNormal,
+    irradiance * skyFactor,
+    probeDiffuseK,
+    diffuseAlbedo,
+    metallic,
+  );
+  ambient = (probeDiffuse + specularIbl * skyFactor) *
+    (vec3<f32>(1.0) - coatF);
+#endif
+#ifdef PROBE_BLEND_AVAILABLE
+  ambient = ambient * 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) {
-    ambient = ambient * (-skylight.intensity) * ao;
+    let environmentScale = max(-skylight.intensity - 1.0, 0.0) * ao;
+    ambient = ambient * environmentScale;
+    reflectionFallback = reflectionFallback * environmentScale;
   } else {
-    ambient = ambient * skyColor * skylight.intensity * ao;
+    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
@@ -654,16 +908,15 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   // scope-amend-webgl2-ubo: intensity packed into cluster_uniform.near_far_log.w.
   let ssaoIntensity = get_ssao_intensity();
   ambient *= mix(1.0, ssaoFactor * ao, ssaoIntensity);
+  let ssaoScale = mix(1.0, ssaoFactor * ao, ssaoIntensity);
+  reflectionFallback *= ssaoScale;
 #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.
+  // Read the affine basis forwarded by the vertex stage. This keeps the
+  // fragment path within the inter-stage location budget and preserves the
+  // scene-index vertex entry used by the GPU-driven lane.
   let localToWorld0 = in.transmissionBasis0.xyz;
   let localToWorld1 = vec3<f32>(
     in.transmissionBasis0.w,
@@ -746,31 +999,164 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   color = color + finiteColor(transmittedBackdrop, vec3<f32>(0.0)) *
     transmittedEnergy * beerAttenuation;
 #endif
-  let directionalShadow = evalDirectionalShadowFactor(n, in.worldPos, in.viewZ);
-  let directionalBase = evalDirectionalNoShadow(n, v, diffuseAlbedo, metallic, a, f0);
+  let directionalShadow = evalDirectionalShadowFactor(
+    physicalNormal,
+    in.worldPos,
+    standardViewZ(in),
+  );
+  let directionalBase = evalDirectionalNoShadow(physicalNormal, v, diffuseAlbedo, metallic, a, f0);
   color = color + directionalShadow * directionalBase;
-  if (material.clearcoat != 0.0) {
-    let directionalClearcoat = evalDirectionalNoShadow(
-      n, v, vec3<f32>(0.0), 1.0, coatAlpha, vec3<f32>(0.04),
-    );
-    color = color + directionalShadow * material.clearcoat * directionalClearcoat;
-  }
 #ifdef CLUSTER_FORWARD_AVAILABLE
   // NDC from vertex shader (perspective-divided clip-space, interpolated).
   // view_z: NDC depth for cluster Z-slice lookup.
   color = color + evaluateStandardClusterLights(
-    in.ndc.xyz, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0, false,
+    in.ndc.xyz, standardViewZ(in), in.worldPos, physicalNormal, v,
+    diffuseAlbedo, metallic, a, f0, false,
+  );
+#endif // CLUSTER_FORWARD_AVAILABLE
+  // Emissive is part of the lower-energy stack and is attenuated by the
+  // topcoat just like diffuse/specular radiance.
+  color = color + surface.emissive;
+#ifdef SHEEN_AVAILABLE
+  var sheenColor = material.sheenColor;
+  var sheenRoughnessFactor = 1.0;
+#ifdef SHEEN_COLOR_TEXTURE_AVAILABLE
+  let sheenColorUv = transformedMaterialUv(
+    material.sheenColorTextureCoordinatesTransform,
+    material.sheenColorTextureCoordinatesMetadata,
+    in,
+  );
+  sheenColor = sheenColor * sampleMaterialTexture(
+    sheenColorTexture,
+    sheenColorSampler,
+    sheenColorUv,
+    material.sheenColorTextureCoordinatesMetadata.zw,
+  ).rgb;
+#endif
+#ifdef SHEEN_ROUGHNESS_TEXTURE_AVAILABLE
+  let sheenRoughnessUv = transformedMaterialUv(
+    material.sheenRoughnessTextureCoordinatesTransform,
+    material.sheenRoughnessTextureCoordinatesMetadata,
+    in,
+  );
+  sheenRoughnessFactor = sampleMaterialTexture(
+    sheenRoughnessTexture,
+    sheenRoughnessSampler,
+    sheenRoughnessUv,
+    material.sheenRoughnessTextureCoordinatesMetadata.zw,
+  ).a;
+#endif
+  let sheenRoughness = clamp(
+    finiteScalar(material.sheenRoughness, 0.0) * sheenRoughnessFactor,
+    0.0,
+    1.0,
+  );
+  color = evaluateSheenLayer(color, sheenColor, sheenRoughness, dot(n, v));
+#endif
+#ifdef CLEARCOAT_AVAILABLE
+  var clearcoatFactor = clamp(material.clearcoat, 0.0, 1.0);
+#ifdef CLEARCOAT_TEXTURE_AVAILABLE
+  let clearcoatUv = transformedMaterialUv(material.clearcoatTextureCoordinatesTransform, material.clearcoatTextureCoordinatesMetadata, in);
+  clearcoatFactor = clamp(
+    material.clearcoat * sampleMaterialTexture(
+      clearcoatTexture,
+      clearcoatSampler,
+      clearcoatUv,
+      material.clearcoatTextureCoordinatesMetadata.zw,
+    ).r,
+    0.0,
+    1.0,
+  );
+#endif
+  var clearcoatRoughnessValue = clamp(max(material.clearcoatRoughness, 0.04), 0.04, 1.0);
+#ifdef CLEARCOAT_ROUGHNESS_TEXTURE_AVAILABLE
+  let clearcoatRoughnessUv = transformedMaterialUv(material.clearcoatRoughnessTextureCoordinatesTransform, material.clearcoatRoughnessTextureCoordinatesMetadata, in);
+  clearcoatRoughnessValue = clamp(
+    max(material.clearcoatRoughness, 0.04) * sampleMaterialTexture(
+      clearcoatRoughnessTexture,
+      clearcoatRoughnessSampler,
+      clearcoatRoughnessUv,
+      material.clearcoatRoughnessTextureCoordinatesMetadata.zw,
+    ).g,
+    0.04,
+    1.0,
   );
-  if (material.clearcoat != 0.0) {
-    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,
+#endif
+  var clearcoatNormalValue = in.worldNormal;
+#ifdef CLEARCOAT_NORMAL_TEXTURE_AVAILABLE
+  let clearcoatNormalUv = transformedMaterialUv(material.clearcoatNormalTextureCoordinatesTransform, material.clearcoatNormalTextureCoordinatesMetadata, in);
+  clearcoatNormalValue = applyTBN(
+    in.worldNormal,
+    in.worldTangent,
+    scaleTangentSpaceNormal(
+      decodeTangentSpaceNormalRg(sampleMaterialTexture(
+        clearcoatNormalTexture,
+        clearcoatNormalSampler,
+        clearcoatNormalUv,
+        material.clearcoatNormalTextureCoordinatesMetadata.zw,
+      ).rg),
+      material.clearcoatNormalScale,
+    ),
+  );
+#endif
+  var clearcoatIbl = vec3<f32>(0.0);
+  if (skylight.intensity < 0.0) {
+    clearcoatIbl = sampleReflectionProbeSpecular(
+      clearcoatNormalValue,
+      v,
+      clearcoatRoughnessValue,
+      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(
+      clearcoatNormalValue,
+      v,
+      clearcoatRoughnessValue,
+      vec3<f32>(0.04),
+      skylight.rotation,
+      prefilterMap,
+      prefilterSampler,
+      brdfLut,
+      brdfLutSampler,
     );
   }
-#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);
+  let clearcoatAlpha = clearcoatRoughnessValue * clearcoatRoughnessValue;
+  let clearcoatDirect = directionalShadow * evalDirectionalNoShadow(
+    clearcoatNormalValue,
+    v,
+    vec3<f32>(0.0),
+    1.0,
+    clearcoatAlpha,
+    vec3<f32>(0.04),
+  );
+  let directionalClearcoat = clearcoatDirect;
+  let clearcoatContribution = clearcoatIbl * clearcoatFactor;
+  var clearcoatEnvironment = clearcoatIbl * skyColor * skylight.intensity;
+  if (skylight.intensity < 0.0) {
+    clearcoatEnvironment = clearcoatIbl;
+  }
+  color = evaluateClearcoatLayer(
+    color,
+    clearcoatEnvironment + directionalClearcoat,
+    dot(clearcoatNormalValue, v),
+    clearcoatFactor,
+  );
+  reflectionFallback = reflectionFallback + clearcoatContribution;
+#endif
+  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) ──
@@ -800,49 +1186,18 @@ struct GBufferOutput {
 /// pipeline's g-buffer render pass binds this entry point via the shader's
 /// multi-entry support (passKind='deferred' selects `fs_gbuffer`).
 @fragment
-fn fs_gbuffer(in : VsOut) -> GBufferOutput {
-  let baseUv = transformedMaterialUv(
-    material.baseColorTextureCoordinatesTransform,
-    material.baseColorTextureCoordinatesMetadata,
-    in,
-  );
-  let baseSample = sampleMaterialTexture(baseColorTexture, baseColorSampler, baseUv, material.baseColorTextureCoordinatesMetadata.zw);
-  let vertexColor = materialVertexColor(in);
-  alphaTest(material.baseColor.a * baseSample.a * vertexColor.a);
-  let alpha = materialAlpha(baseSample) * vertexColor.a;
-  let albedo = material.baseColor.rgb * baseSample.rgb * vertexColor.rgb;
-
-  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));
-
-  var a = max(material.roughness, 0.04);
-  a = a * roughnessTex;
-
-  let normalUv = transformedMaterialUv(material.normalTextureCoordinatesTransform, material.normalTextureCoordinatesMetadata, in);
-  let normSampleRg = sampleMaterialTexture(normalTexture, normalSampler, normalUv, material.normalTextureCoordinatesMetadata.zw).rg;
-  let normTangent = scaleTangentSpaceNormal(
-    decodeTangentSpaceNormalRg(normSampleRg), material.normalScale,
-  );
-  let n = applyTBN(in.worldNormal, in.worldTangent, normTangent);
-
-  let emissiveUv = transformedMaterialUv(material.emissiveTextureCoordinatesTransform, material.emissiveTextureCoordinatesMetadata, in);
-  let emissiveSample = sampleMaterialTexture(emissiveTexture, emissiveSampler, emissiveUv, material.emissiveTextureCoordinatesMetadata.zw).rgb;
-  let emissive = material.emissive * material.emissiveIntensity * emissiveSample;
-
-  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);
+fn fs_gbuffer(in : VsOut, @builtin(front_facing) frontFacing : bool) -> GBufferOutput {
+  let surface = evaluateStandardSurface(in, frontFacing);
+  alphaTestSurface(surface);
+  let albedo = surface.baseColor;
+  let metallic = clamp(surface.metallic, 0.0, 1.0);
+  let roughness = clamp(surface.roughness, 0.04, 1.0);
+  let n = normalize(surface.normalWS);
 
   var out : GBufferOutput;
-  out.normal_roughness = vec4<f32>(n * 0.5 + 0.5, a);
+  out.normal_roughness = vec4<f32>(n * 0.5 + 0.5, roughness);
   out.albedo_metallic  = vec4<f32>(albedo, metallic);
-  out.emissive_ao      = vec4<f32>(emissive, ao);
+  out.emissive_ao      = vec4<f32>(surface.emissive, surface.occlusion);
   return out;
 }
 
@@ -858,7 +1213,6 @@ 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
@@ -877,11 +1231,6 @@ 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;
@@ -906,6 +1255,10 @@ fn temporalVertexAlpha(in : TemporalVsOut) -> f32 {
 
 @fragment
 fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
+  var reactive = 0.0;
+#if STORAGE_BUFFER_AVAILABLE == true
+  reactive = meshes[0].temporal.x;
+#endif
   return projectPbrSceneTemporal(
     material.baseColor.a * temporalVertexAlpha(in),
     material.alphaCutoff,
@@ -916,7 +1269,7 @@ fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
     in.currentClip,
     in.previousClip,
     view.temporalProjection,
-    in.reactive,
+    reactive,
     in.uv, in.uv1, in.uv2, in.uv3,
     in.uv4, in.uv5, in.uv6, in.uv7,
   );