@forgeax/engine-render 0.1.29 → 0.1.31

package/dist/{chunk-FUODTTIA.mjs → chunk-PSEQ6QPH.mjs}

@@ -1,18 +1,52 @@
 import { TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y } from './chunk-RXZ3RGOU.mjs';
-import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-JQTSEI3Z.mjs';
+import { DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, createIblKernelCache, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, createStandardClusterLayout } from './chunk-NO4WZCAH.mjs';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-BLXGONR2.mjs';
-import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, COOKIE_MATRIX_BYTES, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, GPU_SHADER_STAGE_VERTEX, GPU_SHADER_STAGE_FRAGMENT, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_VERTEX, isStandardPbrMaterialShader, GPU_BUFFER_USAGE_MAP_READ, pbrSkinMeshDynamicOffsets, instanceCollectionCacheKey, worldEntityKey, gpuDrivenShadowDrawKey, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, gpuDrivenSourceDrawItemIndex, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, resolveRenderTargetMaterialSource, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, PROBE_BLEND_RECORD_BYTE_SIZE, gpuDrivenDrawKey, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, materialBindGroupLayoutIdentity } from './chunk-BTWH7BP4.mjs';
-import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, VertexColorVariantConflictError, EquirectProjectionFailedError, SHADOW_ATLAS_DEFAULT_LAYERS, SHADOW_ATLAS_DEFAULT_FACE_SIZE, ShadowAtlas, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, StandardClusterTransportUnavailableError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, createVisibilityBudget, instanceUploadRangesForResident, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, VideoUploadUnsupportedError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID } from './chunk-NRNXBLIJ.mjs';
+import { GPU_SHADER_STAGE_COMPUTE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM, createHdrpBindGroupLayoutDescriptor, COOKIE_MATRIX_BYTES, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, GPU_SHADER_STAGE_VERTEX, GPU_SHADER_STAGE_FRAGMENT, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_VERTEX, isStandardPbrMaterialShader, GPU_BUFFER_USAGE_MAP_READ, pbrSkinMeshDynamicOffsets, instanceCollectionCacheKey, worldEntityKey, gpuDrivenShadowDrawKey, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, buildPbrMaterialUserRegionEntries, buildBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, gpuDrivenSourceDrawItemIndex, matchPass, createPbrSkinMeshBindGroupEntries, physicalTextureFields, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, resolveRenderTargetMaterialSource, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, isStandardPbrSkinMaterialShader, SKIN_MATERIAL_SHADER_ID, PROBE_BLEND_RECORD_BYTE_SIZE, gpuDrivenDrawKey, probeBlendRecordOffset, PROBE_BLEND_RECORD_STRIDE, materialBindGroupLayoutIdentity } from './chunk-FUUO4UND.mjs';
+import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_COPY_SRC, VertexColorVariantConflictError, EquirectProjectionFailedError, SHADOW_ATLAS_DEFAULT_LAYERS, SHADOW_ATLAS_DEFAULT_FACE_SIZE, ShadowAtlas, PointShadowAtlasUninitializedError, PointShadowAtlasBoundsViolationError, StandardClusterTransportUnavailableError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_TEXTURE_BINDING, createVisibilityBudget, instanceUploadRangesForResident, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, StandardLightBudgetExceededError, RendererOperationError, VideoUploadUnsupportedError, StandardClusterIndexOverflowError, FXAA_POST_PROCESS_ID } from './chunk-JRBDO2KB.mjs';
 import { derive, ok, err as err$1, toShared, ASSET_ERROR_HINTS, deriveTextureLayout, handleSlot, resolveMaterialTextureCoordinates, KNOWN_PASS_KINDS } from '@forgeax/engine-types';
 import { ok as ok$1, err, RhiError } from '@forgeax/engine-rhi';
 import { mat3, vec3, mat4 } from '@forgeax/engine-math';
 import { deriveVertexLayoutProjection, DEFAULT_VERTEX_ATTRIBUTE_MAP, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection } from '@forgeax/engine-geometry';
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import { probeVideoHighPerfUpload, VIDEO_ELEMENT_PROVIDER_KEY } from '@forgeax/engine-graphics-extras';
-import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, STANDARD_TEXTURE_MASK_OVERRIDE } from '@forgeax/engine-shader';
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, GPU_DRIVEN_MATERIAL_ROW_BYTES, findVariantByKey, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, STANDARD_TEXTURE_MASK_OVERRIDE } from '@forgeax/engine-shader';
 import { isCompressedFormat, bytesPerRow, blockParamsForFormat } from '@forgeax/engine-codec';
 import { RenderGraphError } from '@forgeax/engine-render-graph';
 
+// src/pipeline/render-extent.ts
+function renderExtentSize(extent, domain) {
+  if (domain === "internal") {
+    return { width: extent.internalWidth, height: extent.internalHeight };
+  }
+  return { width: extent.outputWidth, height: extent.outputHeight };
+}
+var MIN_SCALE = 0.5;
+var MAX_SCALE = 1;
+var SCALE_STEPS = 32;
+var AXIS_ALIGNMENT = 8;
+function alignedAxis(output, scale) {
+  return Math.max(AXIS_ALIGNMENT, Math.floor(output * scale / AXIS_ALIGNMENT) * AXIS_ALIGNMENT);
+}
+function finiteDimension(value) {
+  return Math.max(1, Math.floor(value));
+}
+function deriveRenderExtent(input) {
+  const outputWidth = finiteDimension(input.outputWidth);
+  const outputHeight = finiteDimension(input.outputHeight);
+  const clamped = Math.min(MAX_SCALE, Math.max(MIN_SCALE, input.requestedScale));
+  const scale = Math.round(clamped * SCALE_STEPS) / SCALE_STEPS;
+  const nativeSurface = outputWidth < AXIS_ALIGNMENT || outputHeight < AXIS_ALIGNMENT;
+  const internalWidth = nativeSurface ? outputWidth : alignedAxis(outputWidth, scale);
+  const internalHeight = nativeSurface ? outputHeight : alignedAxis(outputHeight, scale);
+  return Object.freeze({
+    outputWidth,
+    outputHeight,
+    internalWidth,
+    internalHeight,
+    scale: nativeSurface ? 1 : scale,
+    generation: input.generation
+  });
+}
 function resolveOutputDither(config) {
   return config?.outputDither ?? true;
 }
@@ -864,6 +898,40 @@ function getOrCreateFromChain(root, handles, variant, factory, counts) {
   leaf.set(variant, bg);
   return bg;
 }
+function getOrCreateFromChainResult(root, handles, variant, factory, counts) {
+  let node = root;
+  for (const h of handles) {
+    let next = node.get(h);
+    if (next === void 0) {
+      next = /* @__PURE__ */ new WeakMap();
+      node.set(h, next);
+    }
+    node = next;
+  }
+  let leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY);
+  if (leaf === void 0) {
+    leaf = /* @__PURE__ */ new Map();
+    node.set(BIND_GROUP_CHAIN_LEAF_KEY, leaf);
+  }
+  const hit = leaf.get(variant);
+  if (hit !== void 0) return ok(hit);
+  const created = factory();
+  if (!created.ok) return created;
+  counts.createBindGroup += 1;
+  counts.keys.push(variant);
+  leaf.set(variant, created.value);
+  return created;
+}
+function findFromChain(root, handles, variant) {
+  let node = root;
+  for (const handle of handles) {
+    const next = node.get(handle);
+    if (next === void 0) return void 0;
+    node = next;
+  }
+  const leaf = node.get(BIND_GROUP_CHAIN_LEAF_KEY);
+  return leaf?.get(variant);
+}
 function getOrCreatePerEntity(outerMap, outerKey, handles, variant, factory, counts) {
   let inner = outerMap.get(outerKey);
   if (inner === void 0) {
@@ -1536,6 +1604,52 @@ function standardLightingEntries(hdrpBuffers, ssaoTexView, ssaoSampler) {
     }
   ];
 }
+var sceneLightingBindings = /* @__PURE__ */ new WeakMap();
+function createGpuDrivenLightingBindGroup(runtime, buffers, layout, binding, ssaoView) {
+  const fallback = getOrCreateSsaoFallbackTexture(runtime);
+  if (fallback === null) return null;
+  const ssao = ssaoView ?? fallback.view;
+  let cache3 = sceneLightingBindings.get(buffers);
+  if (cache3 === void 0) {
+    cache3 = /* @__PURE__ */ new WeakMap();
+    sceneLightingBindings.set(buffers, cache3);
+  }
+  const cached = cache3.get(binding.meshBuffer);
+  if (cached?.layout === layout && cached.palette === binding.paletteBuffer && cached.ssao === ssao)
+    return cached.bindGroup;
+  const result = runtime.device.createBindGroup({
+    label: "gpu-driven-scene-lighting",
+    layout,
+    entries: [
+      {
+        binding: 0,
+        resource: {
+          kind: "buffer",
+          value: { buffer: binding.meshBuffer, size: binding.meshBytes }
+        }
+      },
+      ...binding.paletteBuffer === void 0 ? [] : [1, 2].map((index) => ({
+        binding: index,
+        resource: {
+          kind: "buffer",
+          value: { buffer: binding.paletteBuffer }
+        }
+      })),
+      ...standardLightingEntries(buffers, ssao, fallback.sampler)
+    ]
+  });
+  if (!result.ok) {
+    runtime.errorRegistry.fire(result.error);
+    return null;
+  }
+  cache3.set(binding.meshBuffer, {
+    layout,
+    palette: binding.paletteBuffer,
+    ssao,
+    bindGroup: result.value
+  });
+  return result.value;
+}
 function createStandardSurfaceLightingBindGroup(runtime, layout, grid, ssaoOptions = { enabled: false }) {
   const buffers = getOrCreateHdrpBuffers(runtime, grid);
   const fallback = getOrCreateSsaoFallbackTexture(runtime);
@@ -2124,7 +2238,7 @@ var POST_PROCESS_POLICY = {
   },
   "post-process-not-found": {
     expected: "typed fullscreen plan references a registered post-process id",
-    hint: (detail) => `no post-process is registered for id '${detail.id}'. Register '${detail.id}' with the feature host ({source, reads?}), then reference it from a typed fullscreen RenderFeaturePlan.`
+    hint: (detail) => `no post-process is registered for id '${detail.id}'. For Engine-owned effects, rebuild the shader manifest with that Engine entry enabled. For custom effects, register '${detail.id}' with the feature host ({source, reads?}), then reference it from a typed fullscreen RenderFeaturePlan.`
   },
   "fullscreen-input-not-found": {
     expected: "reads key must be a graph-declared colorTarget with TEXTURE_BINDING",
@@ -2133,6 +2247,10 @@ var POST_PROCESS_POLICY = {
       return `fullscreen pass '${d.passName}' references reads key '${d.readsKey}' but that key is not declared as a graph color target, or the target is not sampleable as a texture. First declare graph color target '${d.readsKey}' with its format and size (or check spelling) before the typed fullscreen pass '${d.passName}' reads it. If '${d.readsKey}' is a depth target, ensure it has TEXTURE_BINDING usage (0x04) and is declared via graph.addColorTarget. Consider switching pipeline if your pipeline does not expose a sampleable depth target.`;
     }
   },
+  "ssao-parameter-invalid": {
+    expected: "finite non-negative SSAO intensity and low, medium, or high quality",
+    hint: () => "Set ssao.intensity to a finite non-negative value and ssao.quality to low, medium, or high."
+  },
   "ssao-radius-non-positive": {
     expected: "SSAO radius must be > 0",
     hint: (detail) => {
@@ -2184,16 +2302,18 @@ var PostProcessError = PostProcessErrorClass;
 var SSAO_DEFAULT_RADIUS = 0.5;
 var SSAO_DEFAULT_BIAS = 0.025;
 var SSAO_DEFAULT_INTENSITY = 1;
+var SSAO_SAMPLE_COUNTS = { low: 16, medium: 32, high: 64 };
 function getSsaoParameters(config) {
   return {
     radius: config?.radius ?? SSAO_DEFAULT_RADIUS,
     bias: config?.bias ?? SSAO_DEFAULT_BIAS,
-    intensity: config?.intensity ?? SSAO_DEFAULT_INTENSITY
+    intensity: config?.intensity ?? SSAO_DEFAULT_INTENSITY,
+    quality: config?.quality ?? "high"
   };
 }
 function resolveSsaoParameters(config) {
   const resolved = getSsaoParameters(config);
-  if (resolved.radius <= 0) {
+  if (!Number.isFinite(resolved.radius) || resolved.radius <= 0) {
     return err$1(
       new PostProcessError({
         code: "ssao-radius-non-positive",
@@ -2201,7 +2321,7 @@ function resolveSsaoParameters(config) {
       })
     );
   }
-  if (resolved.bias < 0) {
+  if (!Number.isFinite(resolved.bias) || resolved.bias < 0) {
     return err$1(
       new PostProcessError({
         code: "ssao-bias-negative",
@@ -2209,6 +2329,15 @@ function resolveSsaoParameters(config) {
       })
     );
   }
+  if (!Number.isFinite(resolved.intensity) || resolved.intensity < 0 || !Object.hasOwn(SSAO_SAMPLE_COUNTS, resolved.quality)) {
+    const paramName = !Number.isFinite(resolved.intensity) || resolved.intensity < 0 ? "intensity" : "quality";
+    return err$1(
+      new PostProcessError({
+        code: "ssao-parameter-invalid",
+        detail: { paramName, value: resolved[paramName] }
+      })
+    );
+  }
   return ok(resolved);
 }
 function variantSetFromDefines(defines) {
@@ -2436,7 +2565,7 @@ function writeViewUbo(queue, viewUniformBuffer, camera, light, lights, spotShado
   }
   viewPayload[124] = lights.cascadeCount ?? 0;
   viewPayload[125] = lights.cascadeBlend ?? 0;
-  viewPayload[126] = lights.depthBias ?? 5e-3;
+  viewPayload[126] = lights.depthBias ?? 1e-5;
   viewPayload[127] = lights.normalBias ?? 0.05;
   const filterCarrier = directionalShadowFilterCarrier(lights.directionalShadowQuality);
   viewPayload[128] = filterCarrier[0] ?? 0;
@@ -3177,6 +3306,7 @@ function writeHdrpClusterAndSsaoBuffers(internals, frameState, camera, prepared,
     profilePhase,
     "record/scene-state/hdrp-cluster/buffer-upload",
     () => {
+      if (frameState.installedPipelineConfig?.ssao?.enabled !== true) return ok(void 0);
       const ssaoBufs = getOrCreateSsaoBuffers(internals);
       if (ssaoBufs === null) return ok(void 0);
       const sProj = computeProjectionMatrix(camera);
@@ -3194,6 +3324,7 @@ function writeHdrpClusterAndSsaoBuffers(internals, frameState, camera, prepared,
       ssaoUniformPayload[48] = parameters.intensity;
       ssaoUniformPayload[49] = parameters.radius;
       ssaoUniformPayload[50] = parameters.bias;
+      ssaoUniformPayload[51] = SSAO_SAMPLE_COUNTS[parameters.quality];
       const ssaoUniformRes = internals.device.queue.writeBuffer(
         ssaoBufs.uniformBuffer,
         0,
@@ -3240,6 +3371,9 @@ function getOrCreateIblCache(scope) {
   return cache3;
 }
 var iblComposedShadersCache;
+function getIblProbeBackgroundSource() {
+  return iblComposedShadersCache?.probeBackground;
+}
 function setIblComposedShaders(sources) {
   iblComposedShadersCache = sources;
 }
@@ -4079,9 +4213,16 @@ var GpuBuffer = class {
   // BUFFER_META_MAP. This local flag is a derived view written only on
   // the success branch of `device.destroyBuffer(...)`; charter §F1.
   destroyed = false;
-  constructor(device, handle) {
+  releaseScope;
+  constructor(device, handle, scope) {
     this.device = device;
     this.handle = handle;
+    if (scope !== void 0) {
+      const ref = scope._adopt("buffer", this, (value) => {
+        if (!value.isDestroyed) value.destroy();
+      });
+      this.releaseScope = () => scope._release(ref);
+    }
   }
   get isDestroyed() {
     return this.destroyed;
@@ -4096,6 +4237,8 @@ var GpuBuffer = class {
     const r = this.device.destroyBuffer(this.handle);
     if (r.ok) {
       this.destroyed = true;
+      this.releaseScope?.();
+      this.releaseScope = void 0;
     }
     return r;
   }
@@ -4104,9 +4247,16 @@ var GpuTexture = class {
   device;
   handle;
   destroyed = false;
-  constructor(device, handle) {
+  releaseScope;
+  constructor(device, handle, scope) {
     this.device = device;
     this.handle = handle;
+    if (scope !== void 0) {
+      const ref = scope._adopt("texture", this, (value) => {
+        if (!value.isDestroyed) value.destroy();
+      });
+      this.releaseScope = () => scope._release(ref);
+    }
   }
   get isDestroyed() {
     return this.destroyed;
@@ -4119,10 +4269,117 @@ var GpuTexture = class {
     const r = this.device.destroyTexture(this.handle);
     if (r.ok) {
       this.destroyed = true;
+      this.releaseScope?.();
+      this.releaseScope = void 0;
     }
     return r;
   }
 };
+var STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES = 18;
+function isOrdinaryMaterialVariant(variant) {
+  return variant.defines.COVERAGE_ONLY !== true;
+}
+function selectHdrpPbrPrewarmVariants(manifestEntry, storageBufferCapable, extendedLightingShaderAvailableOrTransmissionCapable = true, transmissionCapable = true, directionalPcssAvailable = true, projectorAvailable = true) {
+  const variants = manifestEntry?.variants ?? [];
+  const hasExtendedLightingAxis = variants.some(
+    (variant) => "EXTENDED_LIGHTING_AVAILABLE" in variant.defines
+  );
+  const extendedLightingShaderAvailable = hasExtendedLightingAxis ? extendedLightingShaderAvailableOrTransmissionCapable : true;
+  const effectiveTransmissionCapable = hasExtendedLightingAxis ? transmissionCapable : extendedLightingShaderAvailableOrTransmissionCapable;
+  if (!storageBufferCapable) return [];
+  return variants.filter(
+    (variant) => isOrdinaryMaterialVariant(variant) && variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && (!("EXTENDED_LIGHTING_AVAILABLE" in variant.defines) || variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) && variant.defines.CLUSTER_FORWARD_AVAILABLE === true && (!("DIRECTIONAL_PCSS_AVAILABLE" in variant.defines) || variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && variant.defines.PROBE_BLEND_AVAILABLE !== true && (effectiveTransmissionCapable || variant.defines.TRANSMISSION_AVAILABLE !== true)
+  ) ?? [];
+}
+function selectSkinPrewarmVariants(manifestEntry, storageBufferCapable) {
+  return manifestEntry?.variants.filter(
+    (variant) => isOrdinaryMaterialVariant(variant) && variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && (storageBufferCapable || variant.defines.CLUSTER_FORWARD_AVAILABLE !== true) && variant.defines.PROBE_BLEND_AVAILABLE !== true
+  ) ?? [];
+}
+function selectGpuDrivenSceneIndexVariant(manifestEntry, extendedLightingAvailable, directionalPcssAvailable, projectorAvailable, vertexColorAvailable = false) {
+  return manifestEntry?.variants.find(
+    (variant) => isOrdinaryMaterialVariant(variant) && variant.defines.STORAGE_BUFFER_AVAILABLE === true && variant.defines.GPU_DRIVEN_SCENE_INDEX_AVAILABLE === true && (!("CLUSTER_FORWARD_AVAILABLE" in variant.defines) || variant.defines.CLUSTER_FORWARD_AVAILABLE === false) && variant.defines.VERTEX_COLOR_AVAILABLE === true === vertexColorAvailable && (!("PROBE_BLEND_AVAILABLE" in variant.defines) || variant.defines.PROBE_BLEND_AVAILABLE === false) && (!("EXTENDED_LIGHTING_AVAILABLE" in variant.defines) || variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingAvailable) && (!("DIRECTIONAL_PCSS_AVAILABLE" in variant.defines) || variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (!("REFLECTION_FALLBACK_AVAILABLE" in variant.defines) || variant.defines.REFLECTION_FALLBACK_AVAILABLE === false) && (!("TRANSMISSION_AVAILABLE" in variant.defines) || variant.defines.TRANSMISSION_AVAILABLE === false)
+  );
+}
+function selectProbePrewarmVariants(manifestEntry, storageBufferCapable, extendedLightingShaderAvailable = true, transmissionCapable = true, directionalPcssAvailable = true, projectorAvailable = true, webgl2Downlevel = false) {
+  if (!storageBufferCapable) return [];
+  return manifestEntry?.variants.filter((variant) => {
+    const defines = variant.defines;
+    return isOrdinaryMaterialVariant(variant) && defines.PROBE_BLEND_AVAILABLE === true && defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && (!("WEBGL2_COMPAT" in defines) || defines.WEBGL2_COMPAT === webgl2Downlevel) && (!("EXTENDED_LIGHTING_AVAILABLE" in defines) || defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) && (!("DIRECTIONAL_PCSS_AVAILABLE" in defines) || defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) && (!("PROJECTOR_AVAILABLE" in defines) || defines.PROJECTOR_AVAILABLE === projectorAvailable) && (transmissionCapable || defines.TRANSMISSION_AVAILABLE !== true);
+  }) ?? [];
+}
+async function prewarmMaterialShaderVariants(variants, prewarmedModules, compile, seed) {
+  for (const variant of variants) {
+    const moduleLabel = `module-forgeax::default-standard-pbr#${variant.definesKey}`;
+    let module = prewarmedModules.get(variant.composedWgsl);
+    if (module === void 0) {
+      const result = await compile(variant, moduleLabel);
+      if (!result.ok) throw result.error;
+      module = result.value;
+      prewarmedModules.set(variant.composedWgsl, module);
+    }
+    seed(moduleLabel, module);
+  }
+}
+function selectStandardPbrTransmissionPrewarmVariants(manifestEntry, storageBufferCapable, directionalPcssAvailable = true, projectorAvailable = true, extendedLightingShaderAvailable = true) {
+  if (manifestEntry === void 0) {
+    throw new Error("Standard material shader manifest row is missing");
+  }
+  const selected = [];
+  for (const transmissionAvailable of [false, true]) {
+    const declared = manifestEntry.variants.find(
+      (variant) => isOrdinaryMaterialVariant(variant) && variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.CLUSTER_FORWARD_AVAILABLE === standardBootClusterAxis() && variant.defines.VERTEX_COLOR_AVAILABLE === false && (!("DIRECTIONAL_PCSS_AVAILABLE" in variant.defines) || variant.defines.DIRECTIONAL_PCSS_AVAILABLE === directionalPcssAvailable) && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (!("EXTENDED_LIGHTING_AVAILABLE" in variant.defines) || variant.defines.EXTENDED_LIGHTING_AVAILABLE === extendedLightingShaderAvailable) && variant.defines.PROBE_BLEND_AVAILABLE !== true && variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable
+    );
+    if (declared === void 0) {
+      throw new Error(
+        `Standard material shader manifest lacks exact TRANSMISSION_AVAILABLE=${transmissionAvailable} prewarm variant`
+      );
+    }
+    const exact = findVariantByKey(manifestEntry, declared.definesKey);
+    if (exact === void 0) {
+      throw new Error(
+        `Standard material shader manifest exact lookup failed for TRANSMISSION_AVAILABLE=${transmissionAvailable}`
+      );
+    }
+    selected.push(exact);
+  }
+  return selected;
+}
+function standardBootClusterAxis() {
+  return false;
+}
+
+// src/assembly/device-feature-admission.ts
+var COMPRESSION_FEATURES = [
+  "texture-compression-bc",
+  "texture-compression-etc2",
+  "texture-compression-astc"
+];
+function transmissionBackdropAvailable(limit) {
+  return limit === void 0 || limit >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+}
+var STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 22;
+function deriveDeviceFeatureAdmission(adapter, options) {
+  const requiredFeatures = COMPRESSION_FEATURES.filter((feature) => adapter.features.has(feature));
+  const timestampRequested = options?.gpuPassTiming !== void 0 || options?.captureGpuTimings === true;
+  if (timestampRequested && adapter.features.has("timestamp-query")) {
+    requiredFeatures.push("timestamp-query");
+  }
+  const adapterSampledTextureLimit = adapter.limits?.maxSampledTexturesPerShaderStage ?? 0;
+  const requiredSampledTextureLimit = adapterSampledTextureLimit >= STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES ? STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES : adapterSampledTextureLimit >= EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES ? EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES : adapterSampledTextureLimit >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES ? STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES : void 0;
+  return {
+    requiredFeatures,
+    ...requiredSampledTextureLimit === void 0 ? {} : {
+      requiredLimits: {
+        maxSampledTexturesPerShaderStage: requiredSampledTextureLimit
+      }
+    }
+  };
+}
+function deviceOptionsForAdapter(adapter, options) {
+  const admission = deriveDeviceFeatureAdmission(adapter, options);
+  return admission.requiredFeatures.length === 0 && admission.requiredLimits === void 0 ? void 0 : admission;
+}
 
 // src/ibl/skylight-bind-group.ts
 var FALLBACK_BYTES_PER_ROW = 256;
@@ -4162,16 +4419,17 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
   const transmissionSampler = transmission?.sampler ?? skylight.irradianceSampler;
   const transmissionView = transmission?.backdropView ?? skylight.brdfLutView;
   const transmissionStart = result.length;
-  result.push(
-    {
-      binding: transmissionStart,
-      resource: { kind: "sampler", value: transmissionSampler }
-    },
-    {
-      binding: transmissionStart + 1,
-      resource: { kind: "textureView", value: transmissionView }
-    }
-  );
+  if (transmission !== null)
+    result.push(
+      {
+        binding: transmissionStart,
+        resource: { kind: "sampler", value: transmissionSampler }
+      },
+      {
+        binding: transmissionStart + 1,
+        resource: { kind: "textureView", value: transmissionView }
+      }
+    );
   const physicalStart = 26;
   for (let index = 0; index < textureInjections.length; index += 1) {
     const resource = textureInjections[index];
@@ -4188,6 +4446,13 @@ function assembleMaterialWithSkylightEntries(materialEntries, skylight, transmis
       }
     );
   }
+  result.push({
+    binding: 47,
+    resource: {
+      kind: "textureView",
+      value: skylight.skylightPrefilterView ?? skylight.prefilterView
+    }
+  });
   return result;
 }
 function createSkylightFallback(device, queue) {
@@ -4305,7 +4570,7 @@ function createSkylightFallback(device, queue) {
   const brdfLutView = brdfLutViewResult.value;
   const intensityBufResult = device.createBuffer({
     label: "skylight-fallback-intensity",
-    size: 32,
+    size: 64,
     usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST
   });
   if (!intensityBufResult.ok) throw intensityBufResult.error;
@@ -4992,9 +5257,9 @@ function recordIblMaterialBinding(frameState, materialBgl, bindGroup, entries, i
     errors: []
   };
 }
-function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView) {
+function isMaterialBgAssemblyCacheHit(cached, material, materialBgl, materialBuffer, skylightResources, materialResourceEpoch, transmissionBackdropView, sceneMaterialBuffer) {
   if (transmissionBackdropView != null) return false;
-  return cached?.material === material && cached.materialResourceEpoch === materialResourceEpoch && cached.materialBgl === materialBgl && cached.materialBuffer === materialBuffer && cached.skylightResources.irradianceView === skylightResources.irradianceView && cached.skylightResources.irradianceSampler === skylightResources.irradianceSampler && cached.skylightResources.prefilterView === skylightResources.prefilterView && cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler && cached.skylightResources.brdfLutView === skylightResources.brdfLutView && cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler && cached.skylightResources.intensityBuffer === skylightResources.intensityBuffer;
+  return cached?.material === material && cached.materialResourceEpoch === materialResourceEpoch && cached.materialBgl === materialBgl && cached.materialBuffer === materialBuffer && cached.sceneMaterialBuffer === sceneMaterialBuffer && cached.skylightResources.irradianceView === skylightResources.irradianceView && cached.skylightResources.irradianceSampler === skylightResources.irradianceSampler && cached.skylightResources.prefilterView === skylightResources.prefilterView && cached.skylightResources.skylightPrefilterView === skylightResources.skylightPrefilterView && cached.skylightResources.prefilterSampler === skylightResources.prefilterSampler && cached.skylightResources.brdfLutView === skylightResources.brdfLutView && cached.skylightResources.brdfLutSampler === skylightResources.brdfLutSampler && cached.skylightResources.intensityBuffer === skylightResources.intensityBuffer;
 }
 function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWorld = deps.world, materialShaderId = submeshMaterial.materialShaderId) {
   const {
@@ -5012,9 +5277,10 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
     bindGroupCounts,
     frameState
   } = deps;
-  const effectiveSkylightResources = resolveReflectionProbeResources?.(materialWorld, entityKey) ?? skylightResources;
+  const selectedProbe = resolveReflectionProbeResources?.(materialWorld, entityKey);
+  const effectiveSkylightResources = selectedProbe?.resources ?? skylightResources;
   const smMaterialHandle = submeshMaterial.materialHandle;
-  const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ""}`;
+  const materialCacheKey = smMaterialHandle === void 0 ? void 0 : `${materialWorld.identity}:${smMaterialHandle}:${materialShaderId ?? ""}:${selectedProbe?.probeIndex ?? "sky"}`;
   const smHasVideoFields = (submeshMaterial.videoTextureFields?.size ?? 0) > 0;
   const smShaderId = materialShaderId;
   const smSchema = (smShaderId !== void 0 ? runtime.getParamSchema?.(smShaderId) : void 0) ?? submeshMaterial.materialParamSchema;
@@ -5024,6 +5290,7 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   const physicalFields = standardMaterial && smSchema !== void 0 ? physicalTextureFields(smSchema) : [];
   const smUserRegionFields = smPerShaderBgl === void 0 || isCanonicalStandardPbrMaterialShader(smShaderId) ? BUILTIN_USER_REGION_TEXTURE_FIELDS : userRegionTextureFieldOrder(smSchema).filter((field) => !physicalFields.includes(field));
   const hasActiveTransmissionBackdrop = transmissionBackdropView != null;
+  const sceneMaterialBuffer = runtime.device.caps.storageBuffer ? deps.sceneMaterialBuffer ?? pipelineState.meshStorageBuffer.buffer : void 0;
   const diagnosticsEnabled = materialDiagnosticsEnabled();
   if (smMaterialHandle !== void 0 && !smHasVideoFields && !hasActiveTransmissionBackdrop) {
     const cached = materialCacheKey === void 0 ? void 0 : materialBgAssemblyCache.get(materialCacheKey);
@@ -5034,8 +5301,9 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       pipelineState.materialUniformBuffer.buffer,
       effectiveSkylightResources,
       store.materialResourceEpoch,
-      transmissionBackdropView
-    ) && deps.sceneMaterialBuffer === void 0) {
+      transmissionBackdropView,
+      sceneMaterialBuffer
+    )) {
       if (diagnosticsEnabled) {
         recordIblMaterialBinding(
           frameState,
@@ -5044,31 +5312,34 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
           [
             {
               binding: 1 + smUserRegionFields.length * 2,
-              resource: { kind: "textureView", value: skylightResources.irradianceView }
+              resource: { kind: "textureView", value: effectiveSkylightResources.irradianceView }
             },
             {
               binding: 2 + smUserRegionFields.length * 2,
-              resource: { kind: "sampler", value: skylightResources.irradianceSampler }
+              resource: { kind: "sampler", value: effectiveSkylightResources.irradianceSampler }
             },
             {
               binding: 3 + smUserRegionFields.length * 2,
-              resource: { kind: "textureView", value: skylightResources.prefilterView }
+              resource: { kind: "textureView", value: effectiveSkylightResources.prefilterView }
             },
             {
               binding: 4 + smUserRegionFields.length * 2,
-              resource: { kind: "sampler", value: skylightResources.prefilterSampler }
+              resource: { kind: "sampler", value: effectiveSkylightResources.prefilterSampler }
             },
             {
               binding: 5 + smUserRegionFields.length * 2,
-              resource: { kind: "textureView", value: skylightResources.brdfLutView }
+              resource: { kind: "textureView", value: effectiveSkylightResources.brdfLutView }
             },
             {
               binding: 6 + smUserRegionFields.length * 2,
-              resource: { kind: "sampler", value: skylightResources.brdfLutSampler }
+              resource: { kind: "sampler", value: effectiveSkylightResources.brdfLutSampler }
             },
             {
               binding: 7 + smUserRegionFields.length * 2,
-              resource: { kind: "buffer", value: { buffer: skylightResources.intensityBuffer } }
+              resource: {
+                kind: "buffer",
+                value: { buffer: effectiveSkylightResources.intensityBuffer }
+              }
             }
           ],
           1 + smUserRegionFields.length * 2,
@@ -5176,10 +5447,10 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   const smMergedEntries = assembleMaterialWithSkylightEntries(
     smBaseEntries,
     effectiveSkylightResources,
-    {
+    transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) ? {
       sampler: transmissionSampler,
       ...transmissionBackdropView === void 0 ? {} : { backdropView: transmissionBackdropView }
-    },
+    } : null,
     physicalTextureInjections
   );
   if (runtime.device.caps.storageBuffer) {
@@ -5247,13 +5518,14 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
       "miss"
     );
   }
-  if (smMaterialHandle !== void 0 && !smHasVideoFields && materialResourcesResident && deps.sceneMaterialBuffer === void 0 && !hasActiveTransmissionBackdrop) {
+  if (smMaterialHandle !== void 0 && !smHasVideoFields && materialResourcesResident && !hasActiveTransmissionBackdrop) {
     if (materialCacheKey !== void 0) {
       materialBgAssemblyCache.set(materialCacheKey, {
         material: submeshMaterial,
         materialResourceEpoch: store.materialResourceEpoch,
         materialBgl: smMaterialBgl,
         materialBuffer: pipelineState.materialUniformBuffer.buffer,
+        ...sceneMaterialBuffer === void 0 ? {} : { sceneMaterialBuffer },
         skylightResources: effectiveSkylightResources,
         bindGroup: smBindGroup
       });
@@ -5262,7 +5534,7 @@ function buildPerSubmeshMaterialBg(deps, submeshMaterial, entityKey, materialWor
   return smBindGroup;
 }
 var ZERO_SKYLIGHT_PAYLOAD = new Float32Array([0, 0, 0, 0, 0, 0, 0, 1]);
-function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount) {
+function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount, environmentIbl) {
   const skylightFallback = pipelineState.skylightFallback;
   if (skylightFallback === null) {
     throw new RhiError({
@@ -5287,6 +5559,13 @@ function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount
       };
     }
   }
+  if (environmentIbl !== void 0 && skylight !== void 0 && skylight.equirectHandle === 0) {
+    activeViews = {
+      irr: environmentIbl.irradiance,
+      pref: environmentIbl.prefilter,
+      brdf: activeViews?.brdf ?? skylightFallback.brdfLutView
+    };
+  }
   const skylightResources = activeViews !== void 0 ? {
     irradianceView: activeViews.irr,
     irradianceSampler: skylightFallback.sampler,
@@ -5307,10 +5586,19 @@ function resolveMaterialSkylight(runtime, pipelineState, skylight, skylightCount
   return { skylightResources, activeViews };
 }
 function prepareMaterialSkylight(c) {
-  return resolveMaterialSkylight(c.runtime, c.pipelineState, c.skylight, c.skylightCount);
+  return resolveMaterialSkylight(
+    c.runtime,
+    c.pipelineState,
+    c.skylight,
+    c.skylightCount,
+    c.environmentIbl
+  );
 }
 
 // src/record/main-pass-geometry.ts
+function sameOpaqueTemporalDraw(a, b) {
+  return (isStandardPbrMaterialShader(a.materialShaderId) || a.tags.SurfaceKind === "standard" && b.tags.SurfaceKind === "standard" && a.tags.SurfaceModule === b.tags.SurfaceModule) && a.materialShaderId === b.materialShaderId && a.renderState?.blend === void 0 && b.renderState?.blend === void 0 && a.renderState?.stencil === void 0 && b.renderState?.stencil === void 0 && a.stencilReference === b.stencilReference && renderStateHash(a.renderState) === renderStateHash(b.renderState);
+}
 function materialDiagnosticsEnabled2() {
   if (typeof globalThis !== "object" || globalThis === null || !("process" in globalThis)) {
     return false;
@@ -5318,6 +5606,14 @@ function materialDiagnosticsEnabled2() {
   const processValue = globalThis.process;
   return processValue?.env?.FORGEAX_MATERIAL_DIAGNOSTICS === "1";
 }
+function variantSetForCoveragePass(variantSet, coverageOnly) {
+  if (!coverageOnly) return variantSet;
+  if (variantSet?.includes("COVERAGE_ONLY=")) return variantSet;
+  return variantSet === void 0 || variantSet === "" ? "COVERAGE_ONLY=true" : `${variantSet}+COVERAGE_ONLY=true`;
+}
+function isHdrGeometryTarget(tonemapActive, colorFormatOverride) {
+  return colorFormatOverride === void 0 ? tonemapActive : colorFormatOverride === "rgba16float";
+}
 function gpuDrivenDrawIndicesBySubmesh(source, mesh) {
   const draws = source.gpuDrivenDraws;
   if (draws === void 0 || draws.length === 0) return /* @__PURE__ */ new Map();
@@ -5430,11 +5726,11 @@ function effectiveMaterialLayoutIdentity(materialShaderId, materialParamSchema)
   }
   return materialBindGroupLayoutIdentity(materialShaderId, materialParamSchema);
 }
-function geometryRenderStateForPass(base, passKind) {
+function geometryRenderStateForPass(base, passKind, coverageOnly = false) {
   if (passKind !== "temporal") return base;
   return {
     ...base,
-    depthWriteEnabled: false,
+    depthWriteEnabled: coverageOnly,
     depthCompare: "less-equal"
   };
 }
@@ -5477,7 +5773,7 @@ function recordPointsLinesDraw(pass, plan) {
   }
   pass.draw(plan.vertexCount, 1, 0, 0);
 }
-function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward", selectedDispatch, colorFormats = []) {
+function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sampleCount, meshGroup2, meshBindGroup, resolveMaterialBindGroup, passKind = "forward", selectedDispatch, colorFormats = [], coverageOnly = false) {
   const {
     runtime,
     pipelineState,
@@ -5500,12 +5796,14 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     }
     const passes = byMaterial.get(dispatch.materialHandle);
     if (passes === void 0) byMaterial.set(dispatch.materialHandle, [dispatch]);
-    else passes.push(dispatch);
+    else if (passKind !== "temporal" || !passes.some((previous) => sameOpaqueTemporalDraw(previous, dispatch)))
+      passes.push(dispatch);
   }
   const diagnosticsEnabled = materialDiagnosticsEnabled2();
   const colorFormatOverride = c.transparentColorFormat;
   const clusteredLighting = c.standardLighting?.kind === "clustered";
-  const isHdrTarget = tonemapActive || colorFormatOverride === "rgba16float";
+  const isHdrTarget = isHdrGeometryTarget(tonemapActive, colorFormatOverride);
+  const withCoverageVariant = (variantSet) => variantSetForCoveragePass(variantSet, coverageOnly);
   let lastVertexBuffer = null;
   let lastIndexBuffer = null;
   const bindingState = {
@@ -5531,18 +5829,19 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
     draw();
   };
   const resolveMaterialPipeline = (materialShaderId, renderState, topology, indexFormat, variantSet, colorFormat, layoutProjection, vertexEntry, fragmentEntry, textureMask) => {
+    const pipelineVariantSet = withCoverageVariant(variantSet);
     const reflectionFallbackFormats = materialShaderId === "forgeax::default-standard-pbr" && c.reflectionFallbackColorFormat !== void 0 ? passKind === "deferred" ? colorFormats.slice(1) : [c.reflectionFallbackColorFormat] : void 0;
     const renderStateKey = renderStateHash(renderState);
     const shaderLookupCache = materialPipelineLookupCache.get(materialShaderId);
     const cachedLookups = shaderLookupCache?.get(renderStateKey);
     if (cachedLookups !== void 0) {
       for (const cached of cachedLookups) {
-        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === variantSet && cached.vertexEntry === vertexEntry && cached.fragmentEntry === fragmentEntry && cached.textureMask === textureMask && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
+        if (cached.isHdrTarget === isHdrTarget && cached.renderStateKey === renderStateKey && cached.topology === topology && cached.indexFormat === indexFormat && cached.variantSet === pipelineVariantSet && cached.vertexEntry === vertexEntry && cached.fragmentEntry === fragmentEntry && cached.textureMask === textureMask && cached.passKind === passKind && cached.layoutProjection.digest === layoutProjection.digest && cached.sampleCount === sampleCount && cached.colorFormatOverride === colorFormat && cached.additionalColorFormats?.join(",") === reflectionFallbackFormats?.join(",")) {
           return cached.handle;
         }
       }
     }
-    const resolvedVariantSetResult = runtime.getMaterialArtifact?.(materialShaderId) !== void 0 ? { ok: true, value: void 0 } : variantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, variantSet);
+    const resolvedVariantSetResult = runtime.getMaterialArtifact?.(materialShaderId) !== void 0 ? { ok: true, value: void 0 } : pipelineVariantSet === void 0 && (materialShaderId === "forgeax::sprite" || materialShaderId === "forgeax::sprite-lit") ? { ok: true, value: void 0 } : variantSetFromVertexLayoutProjection(layoutProjection, pipelineVariantSet);
     if (!resolvedVariantSetResult.ok) {
       runtime.errorRegistry.fire(resolvedVariantSetResult.error);
       return null;
@@ -5581,7 +5880,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
         renderStateKey,
         topology,
         indexFormat,
-        variantSet,
+        variantSet: pipelineVariantSet,
         vertexEntry,
         fragmentEntry,
         passKind,
@@ -5721,7 +6020,7 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
       )
     );
     if (!skinVariantSetResult.ok) runtime.errorRegistry.fire(skinVariantSetResult.error);
-    const skinVariantSet = skinVariantSetResult.ok ? skinVariantSetResult.value : void 0;
+    const skinVariantSet = skinVariantSetResult.ok ? withCoverageVariant(skinVariantSetResult.value) : void 0;
     const skinPsoProbe = skinResources !== null && skinVariantSetResult.ok ? runtime.getMaterialShaderPipeline?.(
       SKIN_MATERIAL_SHADER_ID,
       isHdrTarget,
@@ -5892,7 +6191,11 @@ function recordGeometryDraws(c, pass, matchedMaterials, materialSlotIndices, sam
           cullMode: "none",
           blend: selectedRenderState?.blend ?? SPRITE_PREMULTIPLIED_ALPHA_BLEND
         } : geometryRenderStateForTopology(smTopology, selectedRenderState);
-        const pipelineRenderState = geometryRenderStateForPass(basePipelineRenderState, passKind);
+        const pipelineRenderState = geometryRenderStateForPass(
+          basePipelineRenderState,
+          passKind,
+          coverageOnly
+        );
         let smPipelineHandle;
         let materialGroup2Contract;
         let materialPipelineEntry = null;
@@ -7192,7 +7495,13 @@ function deriveStandardMaterialFields() {
     ])
   ];
   fields.sort((left, right) => left.offset - right.offset);
-  return fields.map(({ field }) => field);
+  return [
+    ...fields.map(({ field }) => field),
+    ...Array.from(
+      { length: (GPU_DRIVEN_MATERIAL_ROW_BYTES - derived.totalBytes) / 16 },
+      (_, index) => ({ name: `_gpuDrivenPadding${index}`, type: "vec4<f32>" })
+    )
+  ];
 }
 var GPU_SCENE_SCHEMAS = Object.freeze({
   lod: {
@@ -7365,6 +7674,15 @@ function buildBatchAlignedSubmission(source, candidatesByBatch) {
     visibleCapacity: visibleBase
   });
 }
+function hasActiveAlphaMask(material, prepared) {
+  const { cutoff, source } = prepared.alphaMask;
+  if (cutoff.length === 0 || source.length === 0) return false;
+  if (prepared.identity.material === "forgeax::default-standard-pbr" || prepared.identity.material === "forgeax::pbr-skin" || prepared.identity.material === "forgeax::default-standard-pbr-skin") {
+    const value = material.paramSnapshot?.[cutoff];
+    return typeof value === "number" && value > 0;
+  }
+  return true;
+}
 function eligibleDraws(slot) {
   const snapshot = slot.snapshot;
   const draws = snapshot.gpuDrivenDraws;
@@ -7379,14 +7697,19 @@ function eligibleDraws(slot) {
     const prepared = draw.prepared;
     const material = snapshot.materials[draw.materialSlot] ?? snapshot.material;
     if (prepared !== void 0) {
-      const isStandardPbr = material.materialShaderId === "forgeax::default-standard-pbr" && prepared.identity.material === "forgeax::default-standard-pbr" || (material.materialShaderId === "forgeax::pbr-skin" || material.materialShaderId === "forgeax::default-standard-pbr-skin") && (prepared.identity.material === "forgeax::pbr-skin" || prepared.identity.material === "forgeax::default-standard-pbr-skin");
+      const materialIdentityMatches = material.materialShaderId === void 0 || prepared.identity.material === material.materialShaderId;
       const isAlphaBlend = material.transparent === true || material.renderState?.blend !== void 0;
       const cpuOnlyMaterialResources = (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
       const skinReady = prepared.identity.deformation !== "skin" || snapshot.skin?.storageOrUniform === "storage" && snapshot.skin.customDataStart >= 0 && Number.isInteger(snapshot.skin.customDataStart) && hasFiniteOrderedBounds(snapshot.skin.bounds) && prepared.skinPaletteAddress !== void 0;
-      if (!isStandardPbr || isAlphaBlend || cpuOnlyMaterialResources || prepared.identity.deformation !== "rigid" && prepared.identity.deformation !== "skin" || !skinReady)
+      if (!materialIdentityMatches || isAlphaBlend || cpuOnlyMaterialResources || prepared.identity.deformation !== "rigid" && prepared.identity.deformation !== "skin" || !skinReady)
         continue;
-      const preparedIdentity = `${prepared.identity.material}|${prepared.identity.geometry}|${prepared.identity.deformation}`;
-      const admission = typeof material.paramSnapshot?.alphaCutoff === "number" ? "alpha-mask" : "opaque";
+      const preparedIdentity = [
+        prepared.identity.material,
+        prepared.identity.geometry,
+        prepared.identity.deformation,
+        ...prepared.receiptIdentity === void 0 ? [] : [prepared.receiptIdentity]
+      ].join("|");
+      const admission = hasActiveAlphaMask(material, prepared) ? "alpha-mask" : "opaque";
       result.push({
         sourceDrawIndex: drawItemIndex,
         key: {
@@ -9739,9 +10062,7 @@ function recordGpuDrivenShadowIndirect(pass, submission) {
       pass.setVertexBuffer(0, raster.vertexBuffer);
       currentVertex = raster.vertexBuffer;
     }
-    if (raster.alphaMaskMaterialGroup !== void 0) {
-      pass.setBindGroup(1, raster.alphaMaskMaterialGroup, [0]);
-    }
+    pass.setBindGroup(1, raster.materialGroup, [0]);
     if (raster.indexBuffer !== void 0) {
       if (raster.indexFormat === void 0) {
         throw new RhiError({
@@ -9868,12 +10189,12 @@ function validateShadowOwnership(c, identity, claimedKeys, recordedKeys) {
   const overlap = [...claimed].filter((key) => recordedKeys.has(key));
   const union = /* @__PURE__ */ new Set([...claimed, ...recordedKeys]);
   const missing = [...expectedKeys].filter((key) => !union.has(key));
-  const extra = [...union].filter((key) => !expectedKeys.has(key));
-  if (overlap.length === 0 && missing.length === 0 && extra.length === 0) return;
+  const unexpectedClaims = [...claimed].filter((key) => !expectedKeys.has(key));
+  if (overlap.length === 0 && missing.length === 0 && unexpectedClaims.length === 0) return;
   throw new RhiError({
     code: "internal-error",
     expected: `disjoint ShadowCaster ownership for ${shadowViewIdentityKey(identity)}`,
-    hint: `claimed=${[...claimed].sort().join(",")} recorded=${[...recordedKeys].sort().join(",")} missing=${missing.sort().join(",")} extra=${extra.sort().join(",")}`
+    hint: `claimed=${[...claimed].sort().join(",")} recorded=${[...recordedKeys].sort().join(",")} missing=${missing.sort().join(",")} unexpectedClaims=${unexpectedClaims.sort().join(",")}`
   });
 }
 function hasUnclaimedShadowCasters(c, claimedKeys) {
@@ -9916,18 +10237,31 @@ function recordGpuDrivenShadowIfPublished(c, pass, identity) {
         hint: "keep shadow batch scene rows aligned with the shared SubmissionPlan"
       });
     }
+    const shadowArtifact = projection.shadowArtifact;
+    const shadowReceipt = shadowArtifact.receipt;
+    if (shadowReceipt === void 0) {
+      throw new RhiError({
+        code: "rhi-not-available",
+        expected: `published shadow MaterialProgramAbi for batch ${batch.batchId}`,
+        hint: "keep the shadow draw out of the capable lane until its producer receipt is ready"
+      });
+    }
+    const shadowVariantSet = shadowArtifact.variantSet ?? (shadowArtifact.material === SHADOW_CASTER_SHADER_ID ? shadowCasterVariantSet(
+      c.runtime.device.caps.storageBuffer,
+      projection.deformation === "skin",
+      true,
+      batch.key.admission === "alpha-mask",
+      projection.vertexColorAvailable
+    ) : void 0);
     const pipeline = c.runtime.getMaterialShaderPipeline?.(
-      SHADOW_CASTER_SHADER_ID,
+      // A scene-index shadow artifact may retain the logical material id for
+      // batching while its specialization key owns the actual WGSL module.
+      shadowArtifact.specializationKey ?? shadowArtifact.material,
       false,
       shadowRasterState(void 0, identity.kind === "point"),
       batch.key.topology,
       batch.key.drawKind === "indexed" ? projection.mesh.indexFormat : void 0,
-      shadowCasterVariantSet(
-        c.runtime.device.caps.storageBuffer,
-        projection.deformation === "skin",
-        true,
-        batch.key.admission === "alpha-mask"
-      ),
+      shadowVariantSet,
       "shadow-caster",
       void 0,
       void 0,
@@ -9936,9 +10270,15 @@ function recordGpuDrivenShadowIfPublished(c, pass, identity) {
       void 0,
       void 0,
       projection.mesh.layoutProjection,
-      void 0,
+      // The shadow projection carries the producer-validated receipt. Select
+      // the immediate module adapter so a newly loaded custom Surface cannot
+      // lose its first capable shadow draw to async pre-bake warm-up.
+      "immediate",
       projection.deformation === "skin" ? "gpu-driven-skin" : "gpu-driven-pbr",
-      "vs_scene_index"
+      shadowReceipt.sceneIndexEntry,
+      void 0,
+      projection.shadowVertexEntry,
+      projection.shadowFragmentEntry
     );
     if (pipeline === null || pipeline === void 0) {
       throw new RhiError({
@@ -9954,12 +10294,20 @@ function recordGpuDrivenShadowIfPublished(c, pass, identity) {
         hint: "keep the geometry residency and topology draw kind aligned before capable recording"
       });
     }
+    const materialGroup = shadowArtifact.material !== SHADOW_CASTER_SHADER_ID ? ensureGpuDrivenCustomShadowMaterialBg(c, projection) : batch.key.admission === "alpha-mask" ? ensureGpuDrivenAlphaMaskMaterialBg(c, projection) : ensureSpotShadowMaterialBg(c);
+    if (materialGroup === null) {
+      throw new RhiError({
+        code: "rhi-not-available",
+        expected: "material resources for every GPU shadow batch",
+        hint: "publish the shadow material binding before recording the indirect batch"
+      });
+    }
     batches.set(batch.batchId, {
       pipeline,
       meshBindGroup: projection.meshBindGroup,
       visibleBindGroup: projection.visibleBindGroup,
       deformation: projection.deformation,
-      ...batch.key.admission === "alpha-mask" ? { alphaMaskMaterialGroup: ensureGpuDrivenAlphaMaskMaterialBg(c, projection) } : {},
+      materialGroup,
       vertexBuffer: projection.mesh.vertexBuffer.handle,
       ...batch.key.drawKind === "indexed" && projection.mesh.indexBuffer !== null ? {
         indexBuffer: projection.mesh.indexBuffer.handle,
@@ -10629,7 +10977,10 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
               runtime.device.caps.storageBuffer,
               skinned,
               false,
-              Number(shadowDispatch?.paramSnapshot?.alphaCutoff ?? 0) > 0
+              Number(shadowDispatch?.paramSnapshot?.alphaCutoff ?? 0) > 0,
+              entry.mesh.layoutProjection.attributes.some(
+                (attribute) => attribute.key === "color"
+              )
             ),
             "shadow-caster",
             void 0,
@@ -10733,9 +11084,23 @@ function recordShadowCasterDraws(c, shadowPass, shadowPipeline2, shadowMeshBindG
 }
 function ensureSpotShadowMaterialBg(c) {
   const { runtime, frameState, pipelineState } = c;
-  const cached = frameState.singletonMaterialCache.get("shadow-material-singleton");
-  if (cached !== void 0) return cached;
   const fb = pipelineState.skylightFallback;
+  const sceneMaterialBuffer = c.gpuDrivenStandardPbrFrameResources?.sceneMaterialBuffer ?? pipelineState.meshStorageBuffer.buffer;
+  const handles = [
+    pipelineState.materialBindGroupLayout,
+    pipelineState.materialUniformBuffer.buffer,
+    pipelineState.defaultSampler,
+    pipelineState.defaultNormalTextureView,
+    pipelineState.fallbackTextureView,
+    sceneMaterialBuffer,
+    ...fb === null ? [] : [fb]
+  ];
+  const cached = findFromChain(
+    frameState.shadowMaterialBindGroups,
+    handles,
+    "shadow-material-singleton"
+  );
+  if (cached !== void 0) return cached;
   const fallbackEntries = buildPbrMaterialUserRegionEntries().map((entry) => {
     if (entry.buffer !== void 0) {
       return {
@@ -10764,36 +11129,43 @@ function ensureSpotShadowMaterialBg(c) {
       }
     };
   });
-  const merged = fb !== null ? assembleMaterialWithSkylightEntries(fallbackEntries, {
-    irradianceView: fb.irradianceView,
-    irradianceSampler: fb.sampler,
-    prefilterView: fb.prefilterView,
-    prefilterSampler: fb.sampler,
-    brdfLutView: fb.brdfLutView,
-    brdfLutSampler: fb.sampler,
-    intensityBuffer: fb.intensityBuffer
-  }) : fallbackEntries;
+  const merged = fb !== null ? assembleMaterialWithSkylightEntries(
+    fallbackEntries,
+    {
+      irradianceView: fb.irradianceView,
+      irradianceSampler: fb.sampler,
+      prefilterView: fb.prefilterView,
+      prefilterSampler: fb.sampler,
+      brdfLutView: fb.brdfLutView,
+      brdfLutSampler: fb.sampler,
+      intensityBuffer: fb.intensityBuffer
+    },
+    transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) ? void 0 : null
+  ) : fallbackEntries;
   if (runtime.device.caps.storageBuffer) {
     merged.push({
       binding: 46,
       resource: {
         kind: "buffer",
-        value: { buffer: pipelineState.meshStorageBuffer.buffer }
+        value: { buffer: sceneMaterialBuffer }
       }
     });
   }
-  const r = runtime.device.createBindGroup({
-    label: "shadow-material-bg",
-    layout: pipelineState.materialBindGroupLayout,
-    entries: merged
-  });
+  const r = getOrCreateFromChainResult(
+    frameState.shadowMaterialBindGroups,
+    handles,
+    "shadow-material-singleton",
+    () => runtime.device.createBindGroup({
+      label: "shadow-material-bg",
+      layout: pipelineState.materialBindGroupLayout,
+      entries: merged
+    }),
+    c.bindGroupCounts
+  );
   if (!r.ok) {
     runtime.errorRegistry.fire(r.error);
     return null;
   }
-  c.bindGroupCounts.createBindGroup += 1;
-  c.bindGroupCounts.keys.push("shadow-material-singleton");
-  frameState.singletonMaterialCache.set("shadow-material-singleton", r.value);
   return r.value;
 }
 function ensureGpuDrivenAlphaMaskMaterialBg(c, projection) {
@@ -10805,9 +11177,6 @@ function ensureGpuDrivenAlphaMaskMaterialBg(c, projection) {
       hint: "publish the receipt-derived scene material table before the capable shadow pass"
     });
   }
-  const materialKey = `shadow-material-alpha:${projection.materialEntityKey}:${projection.material.materialHandle ?? -1}:${c.store.materialResourceEpoch}`;
-  const cached = c.frameState.singletonMaterialCache.get(materialKey);
-  if (cached !== void 0) return cached;
   const fallback = c.pipelineState.skylightFallback;
   if (fallback === null) {
     throw new RhiError({
@@ -10845,7 +11214,56 @@ function ensureGpuDrivenAlphaMaskMaterialBg(c, projection) {
     projection.materialEntityKey,
     c.world
   );
-  c.frameState.singletonMaterialCache.set(materialKey, bindGroup);
+  return bindGroup;
+}
+function ensureGpuDrivenCustomShadowMaterialBg(c, projection) {
+  const shaderId = projection.shadowArtifact.material;
+  const fallback = c.pipelineState.skylightFallback;
+  if (fallback === null) {
+    throw new RhiError({
+      code: "rhi-not-available",
+      expected: "skylight resources for custom shadow material binding",
+      hint: "publish the custom material resource owner before recording the shadow lane"
+    });
+  }
+  const sceneMaterialBuffer = c.gpuDrivenStandardPbrFrameResources?.sceneMaterialBuffer;
+  if (sceneMaterialBuffer === void 0) {
+    throw new RhiError({
+      code: "rhi-not-available",
+      expected: "producer-owned scene material buffer for custom shadow ABI",
+      hint: "publish the selected shadow MaterialProgramAbi scene-index resource before recording"
+    });
+  }
+  const skylightResources = {
+    irradianceView: fallback.irradianceView,
+    irradianceSampler: fallback.sampler,
+    prefilterView: fallback.prefilterView,
+    prefilterSampler: fallback.sampler,
+    brdfLutView: fallback.brdfLutView,
+    brdfLutSampler: fallback.sampler,
+    intensityBuffer: fallback.intensityBuffer
+  };
+  const deps = {
+    runtime: c.runtime,
+    pipelineState: c.pipelineState,
+    world: c.world,
+    store: c.store,
+    materialSlice: STANDARD_PBR_UBO_SIZE,
+    videoHighPerfAvailable: false,
+    skylightResources,
+    materialBgShared: c.frameState.materialBgShared,
+    materialBgAssemblyCache: c.materialBgAssemblyCache,
+    bindGroupCounts: c.bindGroupCounts,
+    frameState: c.frameState,
+    sceneMaterialBuffer
+  };
+  const bindGroup = buildPerSubmeshMaterialBg(
+    deps,
+    projection.material,
+    projection.materialEntityKey,
+    c.world,
+    shaderId
+  );
   return bindGroup;
 }
 
@@ -11057,6 +11475,10 @@ function recordMainPass(c, selector, options, graphPass) {
         errors: []
       };
     }
+    const hasProbeBindings = (c.reflectionProbes?.table.rows.length ?? 0) > 0;
+    const worldIndices = hasProbeBindings ? new Map(
+      validatedOrdered.map((entry) => [entry.world ?? world, entry.source.worldId])
+    ) : void 0;
     const perSubmeshMaterialBgDeps = {
       runtime,
       pipelineState,
@@ -11068,8 +11490,10 @@ function recordMainPass(c, selector, options, graphPass) {
       resolveRenderTargetTextureSource: runtime.resolveRenderTargetTextureSource,
       resolveReflectionProbeResources: (materialWorld, entityKey) => {
         const reflectionProbes = c.reflectionProbes;
-        if (reflectionProbes === void 0) return void 0;
-        const selection = reflectionProbes.selections.get(`${materialWorld.identity}:${entityKey}`);
+        if (reflectionProbes === void 0 || !hasProbeBindings) return void 0;
+        const selection = reflectionProbes.selections.get(
+          `${worldIndices?.get(materialWorld)}:${entityKey}`
+        );
         if (selection === void 0) return void 0;
         const binding = resolveReflectionProbeBinding(selection, reflectionProbes.table);
         if (binding.useSkylight || binding.probeIndex === void 0) return void 0;
@@ -11083,12 +11507,13 @@ function recordMainPass(c, selector, options, graphPass) {
           irradianceView: skylightResources.irradianceView,
           irradianceSampler: skylightResources.irradianceSampler,
           prefilterView: row.filteredView,
+          skylightPrefilterView: skylightResources.prefilterView,
           prefilterSampler: row.sampler,
           brdfLutView: skylightResources.brdfLutView,
           brdfLutSampler: skylightResources.brdfLutSampler,
           intensityBuffer: row.uniformBuffer
         };
-        return probeResources;
+        return { resources: probeResources, probeIndex: row.index };
       },
       materialBgShared: frameState.materialBgShared,
       materialBgAssemblyCache: c.materialBgAssemblyCache,
@@ -11119,19 +11544,53 @@ function recordMainPass(c, selector, options, graphPass) {
       );
     }
     if (gpuDrivenStandardPbrFrameResources !== void 0) {
+      gpuDrivenStandardPbrFrameResources.resolveClusteredMeshBindGroup = (binding) => {
+        const buffers = getOrCreateHdrpBuffers(
+          runtime,
+          frameState.installedPipelineConfig?.clusterGrid
+        );
+        const layout = binding.paletteBuffer === void 0 ? pipelineState.hdrpMeshBindGroupLayout : pipelineState.hdrpSkinMeshBindGroupLayout;
+        const group = buffers === null || layout == null ? null : createGpuDrivenLightingBindGroup(
+          runtime,
+          buffers,
+          layout,
+          binding,
+          c.hdrpSsaoBlurredView
+        );
+        if (group === null)
+          throw new RhiError({
+            code: "rhi-not-available",
+            expected: "scene-index clustered lighting binding",
+            hint: "publish scene rows and the current lighting/AO resources before indirect drawing"
+          });
+        return group;
+      };
       gpuDrivenStandardPbrFrameResources.materialBindGroups.length = 0;
       gpuDrivenStandardPbrFrameResources.materialBindGroups.push(...preparedMaterialBindGroups);
+      gpuDrivenStandardPbrFrameResources.colorFormats = colorFormats;
+      const selectedMaterialSlots = /* @__PURE__ */ new Set();
+      if (matchedMaterials === null)
+        delete gpuDrivenStandardPbrFrameResources.selectedMaterialSlots;
+      else gpuDrivenStandardPbrFrameResources.selectedMaterialSlots = selectedMaterialSlots;
       gpuDrivenStandardPbrFrameResources.materialSlotIndicesByEntity.clear();
       for (let index = 0; index < validatedOrdered.length; index += 1) {
         const entry = validatedOrdered[index];
         if (entry === void 0) continue;
+        const selected = matchedMaterials?.get(entry.renderableIndex);
+        const materials = entry.source.materials.length > 0 ? entry.source.materials : [entry.source.material];
+        for (let slot = 0; slot < materials.length; slot += 1) {
+          const handle = materials[slot]?.materialHandle ?? -1;
+          const globalSlot = materialSlotIndices[index]?.[slot];
+          if (globalSlot !== void 0 && selected?.has(handle))
+            selectedMaterialSlots.add(globalSlot);
+        }
         gpuDrivenStandardPbrFrameResources.materialSlotIndicesByEntity.set(
           worldEntityKey(entry.source.worldId, entry.source.entityKey),
           materialSlotIndices[index] ?? []
         );
       }
     }
-    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world, materialShaderId = material.materialShaderId) => materialShaderId === material.materialShaderId && materialShaderId !== POINTS_LINES_MATERIAL_SHADER_ID ? preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId) : buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId);
+    const resolveMaterialBindGroup = (materialSlot, material, entityKey, materialWorld = world, materialShaderId = material.materialShaderId) => !hasProbeBindings && materialShaderId === material.materialShaderId && materialShaderId !== POINTS_LINES_MATERIAL_SHADER_ID ? preparedMaterialBindGroups[materialSlot] ?? buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId) : buildPerSubmeshMaterialBg2(material, entityKey, materialWorld, materialShaderId);
     pass.setBindGroup(0, viewBindGroup, [viewBindGroupDynamicOffset, 0]);
     const recordGeometry = () => {
       recordGeometryDraws(
@@ -11145,7 +11604,8 @@ function recordMainPass(c, selector, options, graphPass) {
         resolveMaterialBindGroup,
         passKind,
         selectedDispatch,
-        colorFormats
+        colorFormats,
+        options?.coverageOnly ?? false
       );
     };
     if (c.profilePhase === void 0) {
@@ -11847,6 +12307,12 @@ function ensureSsaoRecordCompanions(internals) {
 function buildSsaoUniformPayload(internals) {
   const { camera, frameState } = internals;
   const sProj = computeProjectionMatrix(camera);
+  if (camera.temporal?.currentJitterUv !== void 0) {
+    const jitter = mat4.identity(mat4.create());
+    jitter[12] = camera.temporal.currentJitterUv[0] * 2;
+    jitter[13] = camera.temporal.currentJitterUv[1] * -2;
+    mat4.multiply(sProj, jitter, sProj);
+  }
   const sView = computeViewMatrix(camera);
   const invProj = mat4.create();
   mat4.invert(invProj, sProj);
@@ -11861,12 +12327,25 @@ function buildSsaoUniformPayload(internals) {
   out[48] = parameters.intensity;
   out[49] = parameters.radius;
   out[50] = parameters.bias;
+  out[51] = SSAO_SAMPLE_COUNTS[parameters.quality];
   return out;
 }
 function recordSsaoCalcPass(_c, resolveCtx, ssaoRawKey, gbuf0Key, hdrDepthKey, graphPass, graphViews) {
   const { runtime, pipelineState, encoder } = _c;
   const pp = pipelineState.perPassResources;
-  if (pp.ssaoCalcPipeline === null || pp.ssaoBgl === null) return;
+  if (runtime.device.caps.backendKind === "wgpu-webgl2") {
+    throw new RhiError({
+      code: "feature-not-enabled",
+      expected: "SSAO raw depth sampling on a WebGPU-capable backend",
+      hint: "use WebGPU for SSAO or disable StandardProfile.ssao on the GLES fallback"
+    });
+  }
+  if (pp.ssaoCalcPipeline === null || pp.ssaoBgl === null) {
+    throw new PostProcessError({
+      code: "post-process-not-found",
+      detail: { id: "forgeax::post::ssao-calc" }
+    });
+  }
   if (graphViews === void 0 && (resolveCtx === void 0)) return;
   const ssaoRawView = graphViews?.output ?? resolveCtx?.resolve(ssaoRawKey);
   const gbuf0View = graphViews?.normal ?? (void 0);
@@ -11943,7 +12422,12 @@ function recordSsaoCalcPass(_c, resolveCtx, ssaoRawKey, gbuf0Key, hdrDepthKey, g
 function recordSsaoBlurPass(_c, resolveCtx, ssaoBlurredKey, ssaoRawKey, gbuf0Key, hdrDepthKey, graphPass, graphViews) {
   const { runtime, pipelineState, encoder } = _c;
   const pp = pipelineState.perPassResources;
-  if (pp.ssaoBlurPipeline === null || pp.ssaoBgl === null) return;
+  if (pp.ssaoBlurPipeline === null || pp.ssaoBgl === null) {
+    throw new PostProcessError({
+      code: "post-process-not-found",
+      detail: { id: "forgeax::post::ssao-blur" }
+    });
+  }
   if (graphViews === void 0 && (resolveCtx === void 0))
     return;
   const ssaoBlurredView = graphViews?.output ?? resolveCtx?.resolve(ssaoBlurredKey);
@@ -12373,6 +12857,11 @@ function getTemporalBindGroupResources(state) {
           binding: 10,
           visibility: 2,
           texture: { sampleType: "unfilterable-float", viewDimension: "2d" }
+        },
+        {
+          binding: 11,
+          visibility: 2,
+          texture: { sampleType: "unfilterable-float", viewDimension: "2d" }
         }
       ]
     });
@@ -12605,6 +13094,10 @@ function addTypedScenePass(graph, options) {
       usage: "sampled-read"
     })),
     ...options.transmissionBackdrop === void 0 ? [] : [{ resource: options.transmissionBackdrop, usage: "sampled-read" }],
+    ...options.environment === void 0 ? [] : [options.environment.irradiance, options.environment.prefilter].map((resource) => ({
+      resource,
+      usage: "sampled-read"
+    })),
     ...options.extraAccesses ?? [],
     ...options.gpuDriven?.accesses ?? []
   ];
@@ -12664,6 +13157,12 @@ function addTypedScenePass(graph, options) {
       const activeOcclusion = options.occlusion;
       const passContext = {
         ...internal,
+        ...options.environment === void 0 ? {} : {
+          environmentIbl: {
+            irradiance: resolvedView(resources, options.environment.irradiance),
+            prefilter: resolvedView(resources, options.environment.prefilter)
+          }
+        },
         ...activeOcclusion === void 0 ? {} : { occlusion: activeOcclusion },
         geometryColorView: colorViews[0] ?? null,
         geometryDepthView: depthView,
@@ -12684,6 +13183,7 @@ function addTypedScenePass(graph, options) {
         passKind: options.passKind ?? "forward",
         ...options.clearColor === void 0 ? {} : { clearColor: options.clearColor },
         ...options.recordMode === void 0 ? {} : { recordMode: options.recordMode },
+        ...options.coverageOnly === void 0 ? {} : { coverageOnly: options.coverageOnly },
         ...options.excludeSelector === void 0 ? {} : { excludeSelector: options.excludeSelector },
         ...options.includeSelector === void 0 ? {} : { includeSelector: options.includeSelector },
         ...options.transmissionBackdrop === void 0 ? {} : { transmissionBackdropView: transmissionBackdrop },
@@ -12869,6 +13369,8 @@ function addTypedTemporalResolvePass(graph, targets) {
     accesses: [
       { resource: targets.scene.view, usage: "sampled-read" },
       { resource: targets.currentTemporal.view, usage: "sampled-read" },
+      ...targets.coverage === void 0 ? [] : [{ resource: targets.coverage.view, usage: "sampled-read" }],
+      ...targets.coverageDepth === void 0 ? [] : [{ resource: targets.coverageDepth.view, usage: "sampled-read" }],
       { resource: targets.historyColor.view, usage: "sampled-read" },
       { resource: targets.historyTemporal.view, usage: "sampled-read" },
       { resource: targets.historyStability.view, usage: "sampled-read" },
@@ -12925,6 +13427,7 @@ function addTypedTemporalResolvePass(graph, targets) {
       words[2] = state.valid && (frame.camera.temporal?.historyValid ?? true) ? 1 : 0;
       words[3] = frame.camera.temporal?.temporalFrameIndex ?? 0;
       words[4] = Number(targets.secondaryReactivity !== void 0);
+      words[5] = Number(targets.coverage !== void 0);
       const written = frame.runtime.device.queue.writeBuffer(params, 0, new Uint8Array(payload));
       if (!written.ok)
         throwTemporalEncodeFailure("TAA resolve params upload succeeds", written.error);
@@ -12948,6 +13451,13 @@ function addTypedTemporalResolvePass(graph, targets) {
               kind: "textureView",
               value: targets.secondaryReactivity === void 0 ? currentTemporal : resolvedView(resources, targets.secondaryReactivity)
             }
+          },
+          {
+            binding: 11,
+            resource: {
+              kind: "textureView",
+              value: targets.coverage === void 0 ? currentTemporal : resolvedView(resources, targets.coverage.view)
+            }
           }
         ]
       });
@@ -13152,8 +13662,11 @@ var TEMPORAL_TARGET = {
   size: "surface",
   sampleCount: 1
 };
-function createStandardSceneDataTarget(graph) {
-  const temporal = createRenderPipelineTarget(graph, "standard-scene-temporal", TEMPORAL_TARGET);
+function createStandardSceneDataTarget(graph, extent) {
+  const temporal = createRenderPipelineTarget(graph, "standard-scene-temporal", {
+    ...TEMPORAL_TARGET,
+    size: extent === void 0 ? TEMPORAL_TARGET.size : renderExtentSize(extent, "internal")
+  });
   return temporal.ok ? ok({ temporal: temporal.value }) : temporal;
 }
 function addStandardSceneDataPass(graph, target, depth) {
@@ -13187,6 +13700,6 @@ function addTaaResolvePass(graph, current, currentTemporal, previousColor, previ
   });
 }
 
-export { BYTES_PER_DIRECT_LIGHT_SLOT, BatchTopology, CAPTURE_VIEW_PROJS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, FALLBACK_BYTES_PER_ROW, GPU_DRIVEN_VIEW_WGSL, GPU_SCENE_LAYOUTS, GpuBuffer, GpuDrivenView, GpuTexture, MATERIAL_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, OcclusionConfidenceScheduler, POINTS_LINES_MATERIAL_SHADER_ID, POINTS_LINES_VIEW_BUFFER_SIZE, PREFILTER_MIP_LEVELS, PREFILTER_SIZE, PipelineSpecError, PostProcessError, REFLECTION_PROBE_VIEW_SLOT_BASE, SHADOW_CASTER_BUFFER_SIZE, STANDARD_PBR_UBO_SIZE, ShadowViewStatePool, TEMPORAL_HISTORY_FORMATS, TYPED_BLOOM_PASS_NAMES, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, applyMaterialTextureUvScales, applyParamSchemaDefaultsToUbo, applyParamSnapshotToUbo, assembleMaterialWithSkylightEntries, assertStorageBufferCap, buildFoldDispatchPlan, buildFullscreenPostProcessPass, buildLinearLdrMaterialSpecTable, buildPerFrameBindGroups, buildSpecConstTable, cacheKeyOf, cleanPerEntityCache, colorFormatsForPassKind, commitTemporalGpuSubmit, computeProjectionMatrix, computeSplitLdrSprite, computeViewMatrix, configureSurface, createClusterBinScratch, createFullscreenBindGroup, createHdrpClusterMembershipBindGroupLayoutDescriptor, createIblPipelines, createPointsLinesLaneAdapter, createPointsLinesLaneContract, createRenderPipelineTarget, createSkylightFallback, createStandardSceneDataTarget, createStandardSurfaceLightingBindGroup, decideVisibility, defaultViewForUserRegionField, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, describeTemporalDemand, detectNineSliceScaleTooSmall, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForPass, geometryRenderStateForTopology, getOrBuildPipeline, getOrCreateFromChain, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, gpuSceneFieldOffset, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, packInstanceStorageBuffer, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, projectedHeightForCandidate, resetHdrpBuffers, residentTextureView, resolveMaterialSkylight, resolveOutputDither, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectGpuLodLane, selectLazyEquirectHandle, selectLod, selectSwapChainFormat, setIblComposedShaders, shadowViewIdentityKey, shadowViewRasterAccesses, shouldIssueRetest, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
-//# sourceMappingURL=chunk-FUODTTIA.mjs.map
-//# sourceMappingURL=chunk-FUODTTIA.mjs.map
+export { BYTES_PER_DIRECT_LIGHT_SLOT, BatchTopology, CAPTURE_VIEW_PROJS, CUBEMAP_FACE_VERTICES, CUBE_CAPTURE_VIEW_SLOT_BASE, DEFERRED_COLOR_FORMATS, DEPTH_MIN_PARAMS_BYTE_SIZE, FALLBACK_BYTES_PER_ROW, GPU_DRIVEN_VIEW_WGSL, GPU_SCENE_LAYOUTS, GpuBuffer, GpuDrivenView, GpuTexture, MATERIAL_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, OcclusionConfidenceScheduler, POINTS_LINES_MATERIAL_SHADER_ID, POINTS_LINES_VIEW_BUFFER_SIZE, PREFILTER_MIP_LEVELS, PREFILTER_SIZE, PipelineSpecError, PostProcessError, REFLECTION_PROBE_VIEW_SLOT_BASE, SHADOW_CASTER_BUFFER_SIZE, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, STANDARD_PBR_UBO_SIZE, ShadowViewStatePool, TEMPORAL_HISTORY_FORMATS, TYPED_BLOOM_PASS_NAMES, VIEW_UNIFORM_BUFFER_SIZE, VIEW_UNIFORM_BYTES, VIEW_UNIFORM_SLOT_STRIDE, abortTemporalGpuSubmit, addReflectionFallbackObservationPass, addStandardSceneDataPass, addTaaResolvePass, addTypedBloomPasses, addTypedCompositePostEffects, addTypedFrameObservationPass, addTypedFullscreenPass, addTypedOutputTransformPass, addTypedScenePass, addTypedSkyboxPass, addTypedSsaoPasses, addTypedTemporalResolvePass, aggregateTemporalDemand, applyMaterialTextureUvScales, applyParamSchemaDefaultsToUbo, applyParamSnapshotToUbo, assembleMaterialWithSkylightEntries, assertStorageBufferCap, buildFoldDispatchPlan, buildFullscreenPostProcessPass, buildLinearLdrMaterialSpecTable, buildPerFrameBindGroups, buildSpecConstTable, cacheKeyOf, cleanPerEntityCache, colorFormatsForPassKind, commitTemporalGpuSubmit, computeProjectionMatrix, computeSplitLdrSprite, computeViewMatrix, configureSurface, createClusterBinScratch, createFullscreenBindGroup, createHdrpClusterMembershipBindGroupLayoutDescriptor, createIblPipelines, createPointsLinesLaneAdapter, createPointsLinesLaneContract, createRenderPipelineTarget, createSkylightFallback, createStandardSceneDataTarget, createStandardSurfaceLightingBindGroup, decideVisibility, defaultViewForUserRegionField, deriveRenderDataCubemap, deriveRenderDataMesh, deriveRenderDataTexture, deriveRenderExtent, describeTemporalDemand, detectNineSliceScaleTooSmall, deviceOptionsForAdapter, driveLazyEquirectProjection, encodeDirectionalShadowPass, encodeMainPass, encodePointShadowPass, encodeSpotShadowPass, ensureMeshSsboCapacity, entryHasDepthRead, evaluateFoldBucketUniformCap, foldDispatchBuckets, geometryRenderStateForPass, geometryRenderStateForTopology, getIblProbeBackgroundSource, getOrBuildPipeline, getOrCreateFromChain, getOrCreateHdrpBuffers, getOrCreateIblCache, getTemporalBindGroupResources, getTemporalGpuState, getTemporalParamsBuffer, gpuSceneFieldOffset, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, incrementFoldedDrawsMetric, isTemporalFullscreenBinding, packInstanceStorageBuffer, passKindPolicyTable, postProcessShaderEntrySignature, postProcessShaderModuleLabel, postProcessShaderPipelineLabel, prepareFrameLighting, prepareMaterialSkylight, prewarmMaterialShaderVariants, projectedHeightForCandidate, renderExtentSize, resetHdrpBuffers, residentTextureView, resolveMaterialSkylight, resolveOutputDither, resolveReflectionProbeBinding, resolveSkyboxActive, resolveSsaoParameters, resolveSurfaceFormatPair, resolveSurfaceProfile, retireTemporalGpuState, retireTemporalGpuStateAfterFence, runIblPrecompute, selectGpuDrivenSceneIndexVariant, selectGpuLodLane, selectHdrpPbrPrewarmVariants, selectLazyEquirectHandle, selectLod, selectProbePrewarmVariants, selectSkinPrewarmVariants, selectStandardPbrTransmissionPrewarmVariants, selectSwapChainFormat, setIblComposedShaders, shadowViewIdentityKey, shadowViewRasterAccesses, shouldIssueRetest, standardStorageVariantSet, standardTemporalLaneAdmission, standardTemporalPostOrder, standardTopologyVariantSet, temporalReadIndex, temporalWriteIndex, transmissionBackdropAvailable, uploadMeshSsboBatch, variantSetFromDefines, variantSetFromVertexLayoutProjection, warnMultiSkybox, warnMultiSkylight, warnZeroLightStandard, writeHdrpClusterAndSsaoBuffers, writePbrMaterialUboPayload, writePointsLinesViewUbo, writeShadowCasterUniforms, writeShadowParamsBuffer, writeSpotModifierTextures, writeViewUbo };
+//# sourceMappingURL=chunk-PSEQ6QPH.mjs.map
+//# sourceMappingURL=chunk-PSEQ6QPH.mjs.map