@forgeax/engine-shader 0.1.7 → 0.1.19

package/src/default-standard-pbr.wgsl

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

package/src/fxaa.wgsl

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

package/src/index.ts

@@ -84,6 +84,9 @@ export const BUILTIN_MATERIAL_MODULES = {
   sprite: 'forgeax_material::sprite',
 } as const;
 
+/** Stable build-time module id for the temporal-v1 accessor owner. */
+export const SCENE_DATA_TEMPORAL_V1_SHADER_MODULE = 'forgeax_scene_temporal' as const;
+
 /**
  * Material modules whose shader source and parameter contract are owned by
  * the Engine. They live in the runtime ShaderRegistry, so a Pack containing

package/src/material-schemas.ts

@@ -19,12 +19,19 @@ export const DEFAULT_STANDARD_PBR_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [
   { name: 'clearcoatRoughness', type: 'f32', default: 0.5 },
   { name: 'specularTint', type: 'vec3', colorSpace: 'srgb', default: [1, 1, 1] },
   { name: 'normalScale', type: 'f32', default: 1 },
+  { name: 'transmission', type: 'f32', default: 0 },
+  { name: 'ior', type: 'f32', default: 1.5 },
+  { name: 'thickness', type: 'f32', default: 0 },
+  { name: 'attenuationColor', type: 'vec3', colorSpace: 'linear', default: [1, 1, 1] },
+  { name: 'attenuationDistance', type: 'f32' },
   { name: 'baseColorTexture', type: 'texture2d' },
   { name: 'metallicRoughnessTexture', type: 'texture2d' },
   { name: 'normalTexture', type: 'texture2d' },
   { name: 'specularTintTexture', type: 'texture2d' },
   { name: 'emissiveTexture', type: 'texture2d' },
   { name: 'occlusionTexture', type: 'texture2d' },
+  { name: 'transmissionTexture', type: 'texture2d' },
+  { name: 'thicknessTexture', type: 'texture2d' },
 ];
 
 export const DEFAULT_UNLIT_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [

package/src/motion-blur.wgsl

@@ -0,0 +1,77 @@
+#define_import_path forgeax_view::motion_blur
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::fullscreen_triangle
+#import forgeax_scene_temporal::{unpackSceneTemporalV1}
+
+struct MotionBlurParams {
+  shutterAngle : f32,
+  maxRadiusPixels : f32,
+  sampleCount : u32,
+  reset : u32,
+};
+
+@group(1) @binding(0) var currentColor : texture_2d<f32>;
+@group(1) @binding(1) var linearSampler : sampler;
+@group(1) @binding(2) var<uniform> params : MotionBlurParams;
+@group(1) @binding(3) var sceneTemporal : texture_2d<f32>;
+
+fn depthReject(center : f32, sample : f32) -> bool {
+  return abs(center - sample) > max(0.01, center * 0.01);
+}
+
+fn symmetricOffset(index : u32, count : u32, motion : vec2<f32>) -> vec2<f32> {
+  let denominator = max(f32(count), 1.0);
+  let signedIndex = f32(index) - (denominator - 1.0) * 0.5;
+  return motion * (signedIndex / denominator);
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertexIndex : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertexIndex);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let current = textureSampleLevel(currentColor, linearSampler, in.uv, 0.0);
+  let packed = textureSampleLevel(sceneTemporal, linearSampler, in.uv, 0.0);
+  let temporal = unpackSceneTemporalV1(packed);
+  let dimensions = vec2<f32>(textureDimensions(currentColor));
+  let pixelMotion = temporal.motionUv * dimensions;
+  let shutter = clamp(params.shutterAngle / 360.0, 0.0, 1.0);
+  let radius = min(length(pixelMotion) * shutter, params.maxRadiusPixels);
+  let motion = normalize(select(vec2<f32>(0.0), pixelMotion, radius > 1e-5));
+  let invalidDepth = !temporal.validDepth;
+  let reactive = clamp(temporal.reactive, 0.0, 1.0);
+  let subpixel = radius <= 1e-5;
+  let reset = params.reset != 0u;
+  var output = current;
+  output.a = current.a;
+  if (invalidDepth || subpixel || reset || params.sampleCount < 4u) {
+    return output;
+  }
+
+  var accum = vec3<f32>(0.0);
+  var weight = 0.0;
+  let temporalDimensions = vec2<i32>(textureDimensions(sceneTemporal));
+  for (var index = 0u; index < 16u; index += 1u) {
+    if (index >= params.sampleCount) { break; }
+    let offset = symmetricOffset(index, params.sampleCount, motion * radius) / dimensions;
+    let sampleUv = clamp(in.uv + offset, vec2<f32>(0.0), vec2<f32>(1.0));
+    let samplePixel = clamp(
+      vec2<i32>(sampleUv * dimensions),
+      vec2<i32>(0),
+      temporalDimensions - vec2<i32>(1),
+    );
+    let sampleTemporal = unpackSceneTemporalV1(textureLoad(sceneTemporal, samplePixel, 0));
+    if (sampleTemporal.validDepth && !depthReject(temporal.viewDepth, sampleTemporal.viewDepth)) {
+      accum += textureSampleLevel(currentColor, linearSampler, sampleUv, 0.0).rgb;
+      weight += 1.0;
+    }
+  }
+  let gathered = accum / max(weight, 1.0);
+  let blurWeight = (1.0 - reactive) * select(0.0, 1.0, weight > 0.0);
+  output = vec4<f32>(mix(current.rgb, gathered, blurWeight), current.a);
+  output.a = current.a;
+  return output;
+}

package/src/pbr-temporal.wgsl

@@ -1,6 +1,7 @@
 #define_import_path forgeax_pbr::temporal
 
-#import forgeax_view::common::{sampleMaterialTexture, packSceneTemporal}
+#import forgeax_view::common::{sampleMaterialTexture}
+#import forgeax_scene_temporal::{packSceneTemporalV1}
 
 fn transformedPbrTemporalUv(
   transform : vec4<f32>,
@@ -29,6 +30,16 @@ fn transformedPbrTemporalUv(
   return vec2<f32>(scaled.x * c - scaled.y * s, scaled.x * s + scaled.y * c) + transform.xy;
 }
 
+fn resolvePbrTemporalReactive(
+  reactive : f32,
+  baseColorAlpha : f32,
+  sampledAlpha : f32,
+) -> f32 {
+  let coverage = clamp(baseColorAlpha * sampledAlpha, 0.0, 1.0);
+  let coverageReactive = 1.0 - coverage;
+  return max(clamp(reactive, 0.0, 1.0), coverageReactive);
+}
+
 fn projectPbrSceneTemporal(
   baseColorAlpha : f32,
   alphaCutoff : f32,
@@ -38,6 +49,7 @@ fn projectPbrSceneTemporal(
   metadata : vec4<f32>,
   currentClip : vec4<f32>,
   previousClip : vec4<f32>,
+  temporalProjection : vec4<f32>,
   reactive : f32,
   uv0 : vec2<f32>,
   uv1 : vec2<f32>,
@@ -69,5 +81,6 @@ fn projectPbrSceneTemporal(
   if (alphaCutoff > 0.0 && baseColorAlpha * baseSample.a <= alphaCutoff) {
     discard;
   }
-  return packSceneTemporal(currentClip, previousClip, reactive);
+  let reactiveCoverage = resolvePbrTemporalReactive(reactive, baseColorAlpha, baseSample.a);
+  return packSceneTemporalV1(currentClip, previousClip, temporalProjection, reactiveCoverage);
 }

package/src/scene-temporal.wgsl

@@ -0,0 +1,54 @@
+#define_import_path forgeax_scene_temporal
+
+// The sole shader interpretation of forgeax::scene-data::temporal-v1.
+// The packed target is rgba16float at render resolution and is sampled only.
+
+const SCENE_DATA_TEMPORAL_V1_CLEAR : vec4<f32> = vec4<f32>(0.0, 0.0, -1.0, 1.0);
+
+struct SceneTemporalV1 {
+  motionUv : vec2<f32>,
+  viewDepth : f32,
+  reactive : f32,
+  validDepth : bool,
+};
+
+fn unpackSceneTemporalV1(packed : vec4<f32>) -> SceneTemporalV1 {
+  let invalidDepth = packed.z < 0.0;
+  let validDepth = !invalidDepth;
+  let viewDepth = select(0.0, exp2(packed.z) - 1.0, validDepth);
+  let motionUv = packed.xy;
+  let reactive = clamp(packed.w, 0.0, 1.0);
+  return SceneTemporalV1(motionUv, viewDepth, reactive, validDepth);
+}
+
+fn sceneTemporalUv(clip : vec4<f32>) -> vec2<f32> {
+  let safeW = select(1e-6, clip.w, abs(clip.w) >= 1e-6);
+  let ndc = clip.xy / safeW;
+  return vec2<f32>(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+}
+
+fn sceneTemporalViewDepth(clip : vec4<f32>, temporalProjection : vec4<f32>) -> f32 {
+  let perspectiveDepth = max(clip.w, 0.0);
+  let ndcDepth = clip.z / max(abs(clip.w), 1e-6);
+  let orthographicDepth = temporalProjection.x +
+    ndcDepth * (temporalProjection.y - temporalProjection.x);
+  let viewDepth = select(
+    perspectiveDepth,
+    max(orthographicDepth, 0.0),
+    temporalProjection.z >= 0.5,
+  );
+  return log2(1.0 + viewDepth);
+}
+
+fn packSceneTemporalV1(
+  currentClip : vec4<f32>,
+  previousClip : vec4<f32>,
+  temporalProjection : vec4<f32>,
+  reactive : f32,
+) -> vec4<f32> {
+  return vec4<f32>(
+    sceneTemporalUv(currentClip) - sceneTemporalUv(previousClip),
+    sceneTemporalViewDepth(currentClip, temporalProjection),
+    clamp(reactive, 0.0, 1.0),
+  );
+}