@forgeax/engine-shader 0.1.27 → 0.1.29

package/src/default_standard_surface.wgsl

@@ -6,7 +6,14 @@
 // interface remains the source of the scalar and texture values; the
 // Standard template owns physical-layer selection and lighting.
 fn surfaceUv(input : SurfaceInput, transform : vec4<f32>, metadata : vec4<f32>) -> vec2<f32> {
-  let source = select(input.uv0, input.uv1, metadata.x >= 1.0);
+  var source = input.uv0;
+  if (metadata.x >= 1.0) { source = input.uv1; }
+  if (metadata.x >= 2.0) { source = input.uv2; }
+  if (metadata.x >= 3.0) { source = input.uv3; }
+  if (metadata.x >= 4.0) { source = input.uv4; }
+  if (metadata.x >= 5.0) { source = input.uv5; }
+  if (metadata.x >= 6.0) { source = input.uv6; }
+  if (metadata.x >= 7.0) { source = input.uv7; }
   let scaled = source * transform.zw;
   let c = cos(metadata.y);
   let s = sin(metadata.y);
@@ -31,58 +38,88 @@ fn surfaceNormal(input : SurfaceInput, encoded : vec4<f32>, normalScale : f32) -
   return normalize(tangent * tangentXY.x + bitangent * tangentXY.y + geometric * tangentZ);
 }
 
-fn evaluate_surface(input : SurfaceInput) -> SurfaceData {
-  let baseSample = textureSample(
+fn evaluate_standard_surface(input : SurfaceInput, materialValue : MaterialParameters) -> SurfaceData {
+  var baseSample = vec4<f32>(1.0);
+#ifdef BASE_COLOR_TEXTURE_AVAILABLE
+  if (standardUsesBaseColorTexture()) {
+  baseSample = textureSample(
     baseColorTexture,
     baseColorTexture_sampler,
-    surfaceUv(input, material.baseColorTextureCoordinatesTransform, material.baseColorTextureCoordinatesMetadata) * material.baseColorTextureCoordinatesMetadata.zw,
+    surfaceUv(input, materialValue.baseColorTextureCoordinatesTransform, materialValue.baseColorTextureCoordinatesMetadata) * materialValue.baseColorTextureCoordinatesMetadata.zw,
   );
-  let metallicRoughnessSample = textureSample(
+  }
+#endif
+  var metallicRoughnessSample = vec4<f32>(1.0);
+#ifdef METALLIC_ROUGHNESS_TEXTURE_AVAILABLE
+  if (standardUsesMetallicRoughnessTexture()) {
+  metallicRoughnessSample = textureSample(
     metallicRoughnessTexture,
     metallicRoughnessTexture_sampler,
-    surfaceUv(input, material.metallicRoughnessTextureCoordinatesTransform, material.metallicRoughnessTextureCoordinatesMetadata) * material.metallicRoughnessTextureCoordinatesMetadata.zw,
+    surfaceUv(input, materialValue.metallicRoughnessTextureCoordinatesTransform, materialValue.metallicRoughnessTextureCoordinatesMetadata) * materialValue.metallicRoughnessTextureCoordinatesMetadata.zw,
   );
+  }
+#endif
+  var normal = normalize(input.geometricNormalWS);
+#ifdef NORMAL_TEXTURE_AVAILABLE
+  if (standardUsesNormalTexture()) {
   let normalSample = textureSample(
     normalTexture,
     normalTexture_sampler,
-    surfaceUv(input, material.normalTextureCoordinatesTransform, material.normalTextureCoordinatesMetadata) * material.normalTextureCoordinatesMetadata.zw,
+    surfaceUv(input, materialValue.normalTextureCoordinatesTransform, materialValue.normalTextureCoordinatesMetadata) * materialValue.normalTextureCoordinatesMetadata.zw,
   );
-  let emissiveSample = textureSample(
+  normal = surfaceNormal(input, normalSample, materialValue.normalScale);
+  }
+#endif
+  var emissiveSample = vec4<f32>(1.0);
+#ifdef EMISSIVE_TEXTURE_AVAILABLE
+  if (standardUsesEmissiveTexture()) {
+  emissiveSample = textureSample(
     emissiveTexture,
     emissiveTexture_sampler,
-    surfaceUv(input, material.emissiveTextureCoordinatesTransform, material.emissiveTextureCoordinatesMetadata) * material.emissiveTextureCoordinatesMetadata.zw,
+    surfaceUv(input, materialValue.emissiveTextureCoordinatesTransform, materialValue.emissiveTextureCoordinatesMetadata) * materialValue.emissiveTextureCoordinatesMetadata.zw,
   );
-  let occlusionSample = textureSample(
+  }
+#endif
+  var occlusionSample = vec4<f32>(1.0);
+#ifdef OCCLUSION_TEXTURE_AVAILABLE
+  if (standardUsesOcclusionTexture()) {
+  occlusionSample = textureSample(
     occlusionTexture,
     occlusionTexture_sampler,
-    surfaceUv(input, material.occlusionTextureCoordinatesTransform, material.occlusionTextureCoordinatesMetadata) * material.occlusionTextureCoordinatesMetadata.zw,
+    surfaceUv(input, materialValue.occlusionTextureCoordinatesTransform, materialValue.occlusionTextureCoordinatesMetadata) * materialValue.occlusionTextureCoordinatesMetadata.zw,
   );
+  }
+#endif
   let vertexColor = input.vertexColor;
-  let baseColor = material.baseColor.rgb * baseSample.rgb * vertexColor.rgb;
+  let baseColor = materialValue.baseColor.rgb * baseSample.rgb * vertexColor.rgb;
   let metallic = clamp(
-    material.metallic * surfaceChannel(metallicRoughnessSample, u32(material.metallicChannel)),
+    materialValue.metallic * surfaceChannel(metallicRoughnessSample, u32(materialValue.metallicChannel)),
     0.0,
     1.0,
   );
   let roughness = clamp(
-    material.roughness * surfaceChannel(metallicRoughnessSample, u32(material.roughnessChannel)),
+    materialValue.roughness * surfaceChannel(metallicRoughnessSample, u32(materialValue.roughnessChannel)),
     0.04,
     1.0,
   );
-  let emissive = material.emissive * material.emissiveIntensity * emissiveSample.rgb;
+  let emissive = materialValue.emissive * materialValue.emissiveIntensity * emissiveSample.rgb;
   let occlusion = clamp(
-    1.0 + (occlusionSample.r - 1.0) * material.occlusionStrength,
+    1.0 + (occlusionSample.r - 1.0) * materialValue.occlusionStrength,
     0.0,
     1.0,
   );
   return SurfaceData(
     baseColor,
-    surfaceNormal(input, normalSample, material.normalScale),
+    normal,
     metallic,
     roughness,
     emissive,
     occlusion,
-    clamp(material.baseColor.a * baseSample.a * vertexColor.a, 0.0, 1.0),
-    clamp(material.alphaCutoff, 0.0, 1.0),
+    clamp(materialValue.baseColor.a * baseSample.a * vertexColor.a, 0.0, 1.0),
+    clamp(materialValue.alphaCutoff, 0.0, 1.0),
   );
 }
+
+fn evaluate_surface(input : SurfaceInput) -> SurfaceData {
+  return evaluate_standard_surface(input, material);
+}

package/src/fxaa.wgsl

@@ -33,13 +33,15 @@
 // holes in shaded surfaces -- the bug this rewrite fixes.
 //
 // Bindings (group 0):
-//   @binding(0) screenTexture : texture_2d<f32>  -- sampled display-encoded input
+//   @binding(0) screenTexture : texture_2d<f32>  -- sampled pass-domain input
 //   @binding(1) samp          : sampler           -- linear filterable sampler
 //   @binding(2) params        : FxaaParams        -- final-output policy
-// display-encoded: FXAA samples and writes display-encoded values; the Output
-// Transform owns the sole linear-to-sRGB conversion before this pass. FXAA is
-// the final Standard surface writer, so the shared bounded dither is applied
-// here, immediately before the surface's UNORM8 conversion.
+// DOMAIN: the positive LUT path samples and writes linear-LDR values. Its
+// ditherEnabled uniform is forced to zero because the following fs_encode_only
+// surface writer owns the sole OETF and final dither. The legacy direct path
+// may still enable the same bounded dither when FXAA is itself the surface
+// writer; that legacy route remains display-encoded. FXAA never performs an
+// OETF.
 
 #import forgeax_view::common::{FullscreenOutput, ditherUnorm8}
 #import forgeax_view::common::fullscreen_triangle
@@ -53,6 +55,8 @@ const ITERATIONS: i32 = 12;
 @group(0) @binding(1) var samp: sampler;
 
 struct FxaaParams {
+  // Zero for graph-owned linear-LDR intermediates; non-zero is reserved for a
+  // direct final surface writer and never performs color-space conversion.
   ditherEnabled: f32,
   // Keep the uniform block at one 16-byte slot. WebGL2/GLES uniform-buffer
   // validation uses the std140-aligned block size, while the host uploads a

package/src/ibl-sampling.wgsl

@@ -21,6 +21,22 @@
 
 #import forgeax_pbr::ibl_shared::{fresnelSchlickRoughness, inverseRotateEnvironment}
 
+// Decode the renderer's Skylight/probe scalar without touching the probe box
+// metadata carried in the color lanes. A negative intensity is the
+// ReflectionProbe sentinel `-(probeIntensity + 1)`; regular Skylights retain
+// their linear RGB tint and intensity product. Both the PBR ambient specular
+// term and its detached SSR fallback consume this one scale.
+fn decodeSpecularEnvironmentScale(
+  skyColor: vec3<f32>,
+  intensity: f32,
+) -> vec3<f32> {
+  return select(
+    skyColor * intensity,
+    vec3<f32>(max(-intensity - 1.0, 0.0)),
+    intensity < 0.0,
+  );
+}
+
 // Sample pre-convolved irradiance from the irradiance cubemap.
 // Y is negated to compensate for WebGPU's top-left texture origin vs the
 // OpenGL convention used during equirect-to-cube render passes.
@@ -37,6 +53,18 @@ fn sampleIblDiffuse(
 }
 
 // Split-sum specular IBL: prefiltered env * (F0 * scale + bias).
+fn projectSpecularRadiance(
+  radiance: vec3<f32>, normal: vec3<f32>, view: vec3<f32>,
+  roughness: f32, F0: vec3<f32>, brdfLut: texture_2d<f32>, brdfLutSampler: sampler,
+) -> vec3<f32> {
+  let NdotV = max(dot(normal, view), 0.001);
+  // The preintegrated LUT has one level; explicit LOD remains valid when the
+  // Standard evaluator is selected by a non-uniform particle control path.
+  let envBRDF = textureSampleLevel(brdfLut, brdfLutSampler, vec2<f32>(NdotV, roughness), 0.0).rg;
+  let F = fresnelSchlickRoughness(NdotV, F0, roughness);
+  return radiance * (F * envBRDF.r + envBRDF.g);
+}
+
 fn sampleIblSpecular(
   normal: vec3<f32>,
   view: vec3<f32>,
@@ -54,9 +82,7 @@ fn sampleIblSpecular(
   let Rflip = vec3<f32>(rotated.x, -rotated.y, rotated.z);
   let mip = roughness * 4.0;
   let prefilteredColor = textureSampleLevel(prefilterMap, prefilterSampler, Rflip, mip).rgb;
-  let envBRDF = textureSample(brdfLut, brdfLutSampler, vec2<f32>(NdotV, roughness)).rg;
-  let F = fresnelSchlickRoughness(NdotV, F0, roughness);
-  return prefilteredColor * (F * envBRDF.r + envBRDF.g);
+  return projectSpecularRadiance(prefilteredColor, normal, view, roughness, F0, brdfLut, brdfLutSampler);
 }
 
 // Project a reflection ray from a point inside a probe box onto the box
@@ -106,7 +132,5 @@ fn sampleReflectionProbeSpecular(
   let probeDirection = vec3<f32>(rotated.x, -rotated.y, rotated.z);
   let mip = roughness * 4.0;
   let prefilteredColor = textureSampleLevel(probeMap, probeSampler, probeDirection, mip).rgb;
-  let envBRDF = textureSample(brdfLut, brdfLutSampler, vec2<f32>(NdotV, roughness)).rg;
-  let F = fresnelSchlickRoughness(NdotV, F0, roughness);
-  return prefilteredColor * (F * envBRDF.r + envBRDF.g);
+  return projectSpecularRadiance(prefilteredColor, normal, view, roughness, F0, brdfLut, brdfLutSampler);
 }

package/src/index.ts

@@ -69,6 +69,7 @@ export {
   DEFAULT_SPRITE_PARAM_SCHEMA,
   DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   DEFAULT_UNLIT_PARAM_SCHEMA,
+  PARTICLE_MESH_SURFACE_PARAM_SCHEMA,
   STANDARD_BASE_PARAM_SCHEMA,
   STANDARD_PBR_ALPHA_CUTOFF_DEFAULT,
   STANDARD_PBR_ARTIFACT_RECEIPT,
@@ -76,8 +77,10 @@ export {
   STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA,
   STANDARD_PHYSICAL_TEXTURE_FIELDS,
   STANDARD_PIPELINE_PARAM_SCHEMA,
+  STANDARD_TEXTURE_MASK_OVERRIDE,
   type StandardPhysicalTextureField,
   standardPhysicalTextureFields,
+  standardTextureMask,
 } from './material-schemas.js';
 export {
   registerDefaultSpriteLit,
@@ -95,6 +98,8 @@ export {
   type ShaderRegistryDevice as ShaderCatalogDevice,
   type ShaderRegistryOptions,
   type ShaderRegistryOptions as ShaderCatalogOptions,
+  SSR_SHADER_MODULES,
+  type SsrShaderModule,
 } from './ShaderRegistry.js';
 export {
   findVariantByKey,
@@ -119,6 +124,189 @@ export const DEFAULT_STANDARD_SURFACE_MODULE =
 /** Stable build-time module id for the temporal-v1 accessor owner. */
 export const SCENE_DATA_TEMPORAL_V1_SHADER_MODULE = 'forgeax_scene_temporal' as const;
 
+/** Stable build-time module id for the single Standard output encoder. */
+export const STANDARD_OUTPUT_ENCODING_SHADER_MODULE = 'forgeax_view::output_encoding' as const;
+
+/** Runtime WGSL for the fixed-cohort, same-frame auto exposure meter. */
+export const AUTO_EXPOSURE_METER_WGSL = /* wgsl */ `
+struct AutoExposureParameters {
+  compensationEv: f32,
+  rangeMinEv: f32,
+  rangeMaxEv: f32,
+  upRate: f32,
+  downRate: f32,
+  deltaTime: f32,
+  fallback: f32,
+  generation: f32,
+};
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> histogram: array<atomic<u32>>;
+@group(0) @binding(2) var<storage, read_write> state: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> candidate: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read> parameters: AutoExposureParameters;
+
+var<workgroup> localHistogram: array<atomic<u32>, 256>;
+var<workgroup> totals: array<u32, 64>;
+var<workgroup> sampleTotal: u32;
+
+fn finite(value: f32) -> bool {
+  // Equality rejects NaN; the magnitude bound rejects +/-infinity.
+  return value == value && abs(value) <= 3.402823e+37;
+}
+
+fn centerWeight(
+  block: vec2<u32>,
+  center: vec2<f32>,
+  inverseExtentSquared: vec2<f32>,
+) -> u32 {
+  let delta = vec2<f32>(block) - center;
+  let distanceSquared =
+    delta.x * delta.x * inverseExtentSquared.x +
+    delta.y * delta.y * inverseExtentSquared.y;
+  if (distanceSquared <= 0.25) { return 3u; }
+  if (distanceSquared <= 0.75) { return 2u; }
+  return 1u;
+}
+
+fn accumulateSample(
+  block: vec2<u32>,
+  sampleGrid: vec2<u32>,
+  dimensions: vec2<u32>,
+  center: vec2<f32>,
+  extent: vec2<f32>,
+) {
+  if (block.x >= sampleGrid.x || block.y >= sampleGrid.y) { return; }
+  let pixel = min(block * vec2<u32>(4u) + vec2<u32>(2u), dimensions - vec2<u32>(1u));
+  let sample = textureLoad(source, vec2<i32>(pixel), 0);
+  if (!finite(sample.r) || !finite(sample.g) || !finite(sample.b)) { return; }
+  let luminance = dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+  if (!finite(luminance) || luminance <= 0.0) { return; }
+  let bin = min(u32(clamp(log2(luminance) + 12.0, 0.0, 23.999) * (256.0 / 24.0)), 255u);
+  atomicAdd(&localHistogram[bin], centerWeight(block, center, extent));
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_clear(@builtin(local_invocation_index) localIndex: u32) {
+  atomicStore(&histogram[localIndex], 0u);
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_histogram(
+  @builtin(local_invocation_index) localIndex: u32,
+  @builtin(workgroup_id) workgroupId: vec3<u32>,
+  @builtin(num_workgroups) numWorkgroups: vec3<u32>,
+) {
+  let dimensions = textureDimensions(source);
+  let sampleGrid = (dimensions.xy + vec2<u32>(3u)) / vec2<u32>(4u);
+  let grid = vec2<f32>(sampleGrid);
+  let center = (grid - vec2<f32>(1.0)) * 0.5;
+  let extent = max(center, vec2<f32>(1.0));
+  let inverseExtent = 1.0 / extent;
+  let inverseExtentSquared = inverseExtent * inverseExtent;
+
+  // Map the 256 lanes to a 16x16 logical tile. The fixed 4x8 dispatch grid
+  // then uses a two-dimensional tile stride to cover every 4x4 sample block.
+  atomicStore(&localHistogram[localIndex], 0u);
+  workgroupBarrier();
+  let localGrid = vec2<u32>(localIndex % 16u, localIndex / 16u);
+  let tileSize = vec2<u32>(16u);
+  let blockStart = workgroupId.xy * tileSize + localGrid;
+  let blockStride = numWorkgroups.xy * tileSize;
+  for (var blockY = blockStart.y; blockY < sampleGrid.y; blockY += blockStride.y) {
+    for (var blockX = blockStart.x; blockX < sampleGrid.x; blockX += blockStride.x) {
+      accumulateSample(
+        vec2<u32>(blockX, blockY),
+        sampleGrid,
+        dimensions,
+        center,
+        inverseExtentSquared,
+      );
+    }
+  }
+  workgroupBarrier();
+
+  // Every lane owns one bin. All local accumulation is complete before the
+  // owners atomically publish their finite result to the one global 1KiB map.
+  let localCount = atomicLoad(&localHistogram[localIndex]);
+  if (localCount > 0u) {
+    atomicAdd(&histogram[localIndex], localCount);
+  }
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn auto_exposure_adapt(@builtin(local_invocation_index) localIndex: u32) {
+  var total = 0u;
+  for (var index = localIndex; index < 256u; index += 64u) {
+    total += atomicLoad(&histogram[index]);
+  }
+  totals[localIndex] = total;
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    var reducedTotal = 0u;
+    for (var lane = 0u; lane < 64u; lane += 1u) {
+      reducedTotal += totals[lane];
+    }
+    sampleTotal = reducedTotal;
+  }
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    let validParameters =
+      finite(parameters.compensationEv) &&
+      finite(parameters.rangeMinEv) &&
+      finite(parameters.rangeMaxEv) &&
+      parameters.rangeMinEv <= parameters.rangeMaxEv &&
+      finite(parameters.upRate) &&
+      finite(parameters.downRate) &&
+      finite(parameters.deltaTime) &&
+      parameters.deltaTime >= 0.0 &&
+      finite(parameters.fallback) &&
+      parameters.fallback > 0.0 &&
+      finite(parameters.generation);
+    let safeFallback = select(
+      1.0,
+      parameters.fallback,
+      finite(parameters.fallback) && parameters.fallback > 0.0,
+    );
+    let safeGeneration = select(0.0, parameters.generation, finite(parameters.generation));
+    let lowRank = min(sampleTotal, u32(f32(sampleTotal) * 0.05));
+    let highRank = min(sampleTotal, max(lowRank + 1u, u32(ceil(f32(sampleTotal) * 0.95))));
+    var cumulative = 0u;
+    var clippedWeightedLog = 0.0;
+    var clippedTotal = 0u;
+    for (var index = 0u; index < 256u; index += 1u) {
+      let count = atomicLoad(&histogram[index]);
+      let begin = cumulative;
+      cumulative += count;
+      let keptBegin = max(begin, lowRank);
+      let keptEnd = min(cumulative, highRank);
+      if (keptEnd > keptBegin) {
+        let kept = keptEnd - keptBegin;
+        clippedTotal += kept;
+        clippedWeightedLog += f32(kept) * (-12.0 + (f32(index) + 0.5) * (24.0 / 256.0));
+      }
+    }
+    let averageLog = select(0.0, clippedWeightedLog / f32(clippedTotal), clippedTotal > 0u);
+    let measuredExposure = exp2(-averageLog) * 0.18;
+    let targetExposure = select(
+      safeFallback,
+      exp2(clamp(log2(max(measuredExposure, 1e-6)) + parameters.compensationEv, parameters.rangeMinEv, parameters.rangeMaxEv)),
+      validParameters && clippedTotal > 0u && finite(measuredExposure),
+    );
+    let previous = state[0];
+    let hasPrevious = validParameters && previous.y > 0.5 && previous.z == safeGeneration && previous.w == safeFallback && finite(previous.x) && previous.x > 0.0;
+    let current = select(safeFallback, previous.x, hasPrevious);
+    let rate = select(parameters.downRate, parameters.upRate, targetExposure > current);
+    let safeRate = select(0.0, rate, finite(rate) && rate >= 0.0);
+    let dt = select(0.0, parameters.deltaTime, finite(parameters.deltaTime) && parameters.deltaTime >= 0.0);
+    let amount = 1.0 - exp(-safeRate * dt);
+    let adapted = select(current, current + (targetExposure - current) * amount, validParameters && finite(targetExposure) && finite(current) && dt > 0.0 && safeRate > 0.0);
+    let exposure = select(safeFallback, adapted, finite(adapted) && adapted > 0.0);
+    candidate[0] = vec4<f32>(exposure, 1.0, safeGeneration, safeFallback);
+    state[0] = candidate[0];
+  }
+}
+`;
+
 /**
  * Material modules whose shader source and parameter contract are owned by
  * the Engine. They live in the runtime ShaderRegistry, so a Pack containing
@@ -203,6 +391,7 @@ export function createBuiltinMaterialAsset(kind: BuiltinMaterialKind): MaterialA
             ? { moduleSlots: { surface: DEFAULT_STANDARD_SURFACE_MODULE } }
             : {}),
         },
+        renderState: { tags: { LightMode: 'Forward' } },
       },
     ],
     parameters:

package/src/lighting-punctual.wgsl

@@ -218,13 +218,12 @@ fn evalPointShadowed(
     lightPos, colorTimesIntensity, invRangeSquared,
     worldPos, normal, viewDir, baseColor, metallic, alphaSq, F0,
   );
-  // Keep the fragment-to-light vector for BRDF and nDotL. Shadow matrices are
-  // authored light-to-fragment (`lookAt(lightPos, fragment)`), so the cube
-  // lookup must use the opposite direction. For a right-handed world, the
-  // cubemap convention flips Z so the +Z face look direction matches.
+  // The atlas uses the shared CubeCamera face directions. The raster matrices
+  // reflect clip-space X to preserve authored front-face winding, so sampling
+  // must use the corresponding raw light-to-fragment direction.
   let toLight = lightPos - worldPos;
   let fromLight = worldPos - lightPos;
-  let lightLocal = vec3<f32>(fromLight.x, fromLight.y, -fromLight.z);
+  let lightLocal = fromLight;
   // Reconstruct [0,1] NDC depth from world-space distance: largest-axis
   // projection (research L0.5). Match the per-face perspective near / far
   // configured by buildPointShadowMatrices (PointLightShadow.nearPlane /
@@ -239,7 +238,7 @@ fn evalPointShadowed(
   let nDotL = max(dot(normal, normalize(toLight)), 0.0);
   let shadowFactor = sample_shadow_cube_hw2x2(
     shadowAtlas, shadowSampler, lightLocal, shadowAtlasLayer,
-    depthRef, depthBias, normalBias, nDotL,
+    depthRef, normalBias, depthBias, nDotL,
   );
   return lit * shadowFactor;
 }