@forgeax/engine-shader 0.1.23 → 0.1.25

package/src/default-standard-pbr.wgsl

@@ -1,11 +1,34 @@
 #define_import_path forgeax_material::standard
+#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::{sampleIblDiffuse, sampleIblSpecular, sampleReflectionProbeSpecular}
+#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}
@@ -21,6 +44,23 @@
 #pragma variant_axis PROJECTOR_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).
 //
@@ -42,14 +82,13 @@
 //                                                               + 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
@@ -89,63 +128,16 @@
 // 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;
@@ -158,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
@@ -166,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;
@@ -216,8 +285,10 @@ struct SkylightUniforms {
 @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.
+// 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
 
@@ -264,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
@@ -273,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
@@ -286,27 +362,23 @@ 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; }
-  }
-}
-
-// 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.
+// 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.
 
 fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32) -> VsOut {
   // feat-20260604-instances-per-instance-transform-shader-group3-bin M1 / w4:
@@ -322,6 +394,9 @@ fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : u32) -> VsOut {
   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
@@ -345,6 +420,16 @@ fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : 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,
@@ -358,17 +443,6 @@ fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : 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
@@ -378,16 +452,22 @@ fn vs_main_impl(in : VsIn, meshIndex : u32, instanceIndex : 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);
@@ -408,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);
@@ -417,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;
@@ -429,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);
@@ -456,8 +605,8 @@ 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;
   }
 }
@@ -472,62 +621,123 @@ struct StandardPbrOutput {
 };
 
 @fragment
-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);
-  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;
-
-  // 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);
+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(
@@ -576,16 +786,12 @@ fn fs_main(in : VsOut) -> StandardPbrOutput {
   );
   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 +
   //  feat-20260518-pbr-direct-lighting-mvp Finding 4):
   //
-  //   color = ambient(IBL) + directional(shadowed) + clustered local lights
+  //   color = ambient(IBL) + directional(shadowed) + sum(point) + sum(spot)
   //
   // 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
@@ -601,43 +807,53 @@ fn fs_main(in : VsOut) -> StandardPbrOutput {
   // split-sum mip lookup, so we re-derive the post-shader-clamp roughness
   // here (matches sampleIblSpecular's `mip = roughness * 4.0` expectation).
   //
-  // 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);
+  // 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).
+  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 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.
+    // A negative intensity is the renderer-owned probe sentinel. The four
+    // 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);
   let skyFactor = skyColor * skylight.intensity;
   var reflectionFallback = specularIbl * (vec3<f32>(1.0) - coatF);
-  var ambient = (kD * irradiance * diffuseAlbedo + 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.
@@ -648,44 +864,24 @@ fn fs_main(in : VsOut) -> StandardPbrOutput {
   );
   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) {
-    // 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;
+  let probeDiffuse = composeProbeDiffuse(probeShPreblend,
+    probeLocalBlendFraction,
+    physicalNormal,
+    irradiance * skyFactor,
+    probeDiffuseK,
+    diffuseAlbedo,
+    metallic,
+  );
+  ambient = (probeDiffuse + specularIbl * skyFactor) *
+    (vec3<f32>(1.0) - coatF);
 #endif
-    reflectionFallback = reflectionFallback + clearcoatContribution;
-  }
 #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) {
     let environmentScale = max(-skylight.intensity - 1.0, 0.0) * ao;
     ambient = ambient * environmentScale;
@@ -711,19 +907,16 @@ fn fs_main(in : VsOut) -> StandardPbrOutput {
   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);
+  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,
@@ -806,30 +999,158 @@ fn fs_main(in : VsOut) -> StandardPbrOutput {
   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,
   );
-  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,
+  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,
+  );
+#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;
+  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
@@ -865,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;
 }
 
@@ -923,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
@@ -934,7 +1223,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;
-#ifdef STORAGE_BUFFER_AVAILABLE
+#if STORAGE_BUFFER_AVAILABLE == true
   previousWorld = meshes[0].previousWorldFromLocal *
     instances[idx].previousLocalFromInstance * vec4<f32>(in.pos, 1.0);
 #endif
@@ -942,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;
@@ -972,7 +1256,7 @@ fn temporalVertexAlpha(in : TemporalVsOut) -> f32 {
 @fragment
 fn fs_temporal(in : TemporalVsOut) -> @location(0) vec4<f32> {
   var reactive = 0.0;
-#ifdef STORAGE_BUFFER_AVAILABLE
+#if STORAGE_BUFFER_AVAILABLE == true
   reactive = meshes[0].temporal.x;
 #endif
   return projectPbrSceneTemporal(
@@ -985,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,
   );