@forgeax/engine-render 0.1.27 → 0.1.29

package/dist/{chunk-HKXTW355.mjs → chunk-BTWH7BP4.mjs}

@@ -1,8 +1,9 @@
-import { LifecycleConstructionError, RenderTargetDescriptorInvalidError } from './chunk-ZZ4YQ474.mjs';
+import { LifecycleConstructionError, GpuDrivenPreparationError, RenderTargetDescriptorInvalidError } from './chunk-NRNXBLIJ.mjs';
 import { ok, err, derive } from '@forgeax/engine-types';
 import '@forgeax/engine-rhi';
 import { vec3 } from '@forgeax/engine-math';
-import { STANDARD_PIPELINE_PARAM_SCHEMA, standardPhysicalTextureFields } from '@forgeax/engine-shader';
+import { STANDARD_PIPELINE_PARAM_SCHEMA, standardPhysicalTextureFields, STANDARD_PHYSICAL_TEXTURE_FIELDS } from '@forgeax/engine-shader';
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 
 var DeviceResourceRef = class {
   kind;
@@ -369,6 +370,40 @@ function makeZeroCameraFallbackSnapshot() {
   };
 }
 
+// src/temporal/coverage.ts
+function createTemporalCoverage(width, height) {
+  if (!Number.isSafeInteger(width) || width <= 0) throw new RangeError("width must be positive.");
+  if (!Number.isSafeInteger(height) || height <= 0)
+    throw new RangeError("height must be positive.");
+  return Object.freeze({ width, height, bytes: 34 * width * height, fullScreen: true });
+}
+function classifySceneDataCoverage(input) {
+  const exactContributorIds = input.contributors.filter((c) => c.kind === "exact").map((c) => c.id);
+  const reactiveContributorIds = input.contributors.filter((c) => c.kind === "reactive").map((c) => c.id);
+  const available = new Set(input.contributors.map((c) => c.id));
+  const missing = input.requiredContributorIds.filter((id) => !available.has(id));
+  return {
+    exactContributorIds: Object.freeze(exactContributorIds),
+    reactiveContributorIds: Object.freeze(reactiveContributorIds),
+    missingContributorIds: Object.freeze(missing.slice(0, 32)),
+    omittedMissingContributorCount: Math.max(0, missing.length - 32),
+    complete: missing.length === 0
+  };
+}
+function scanSceneDataCoverage(input) {
+  const classification = classifySceneDataCoverage({
+    contributors: input.contributorIds.map((id) => ({ id, kind: "exact" })),
+    requiredContributorIds: input.requiredContributorIds
+  });
+  return Object.freeze({
+    schema: input.schema,
+    lane: input.lane,
+    producerId: input.producerId,
+    ...classification,
+    contributorIds: Object.freeze([...input.contributorIds])
+  });
+}
+
 // src/gpu-stage.ts
 var GPU_SHADER_STAGE_VERTEX = 1;
 var GPU_SHADER_STAGE_FRAGMENT = 2;
@@ -387,7 +422,7 @@ function buildPbrMaterialUserRegionEntries(paramSchema = STANDARD_PIPELINE_PARAM
       (entry) => !excluded.has(entry.name) || !entry.type.startsWith("texture")
     )
   );
-  const entries = derived.bglEntries.map(
+  let entries = derived.bglEntries.map(
     (entry) => ({
       binding: entry.binding,
       visibility: entry.visibility,
@@ -404,6 +439,15 @@ function buildPbrMaterialUserRegionEntries(paramSchema = STANDARD_PIPELINE_PARAM
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
       buffer: { type: "uniform", hasDynamicOffset: true }
     };
+  } else {
+    entries = [
+      {
+        binding: 0,
+        visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
+        buffer: { type: "uniform", hasDynamicOffset: true }
+      },
+      ...entries.map((entry) => ({ ...entry, binding: entry.binding + 1 }))
+    ];
   }
   return entries;
 }
@@ -511,14 +555,16 @@ function appendInjection(bgl, kind) {
 function physicalTextureFields(paramSchema) {
   return standardPhysicalTextureFields(paramSchema);
 }
-function appendTextureInjection(bgl, fields) {
-  const start = bgl.length;
+function appendTextureInjection(_bgl, fields) {
   const fieldSet = new Set(fields);
   return standardPhysicalTextureFields(
-    fields.map((name) => ({ name, type: "texture2d" }))
-  ).flatMap((field, index) => {
+    STANDARD_PIPELINE_PARAM_SCHEMA.concat(
+      fields.map((name) => ({ name, type: "texture2d" }))
+    )
+  ).flatMap((field) => {
     if (!fieldSet.has(field)) return [];
-    const binding = start + index * 2;
+    const canonicalIndex = STANDARD_PHYSICAL_TEXTURE_FIELDS.indexOf(field);
+    const binding = 26 + canonicalIndex * 2;
     return [
       {
         binding,
@@ -578,7 +624,7 @@ function buildPbrViewBglEntries(caps) {
     // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: point shadow
     // params UBO. Carries `array<vec4<f32>, 4>` = 64 B with one lane per
     // shadow-casting point light slot (shadowAtlasLayer in [0, 4)). Each
-    // lane stores `(near, far, 1/(far-near), 0)` so the fragment-shader
+    // lane stores `(near, far, depthBias, normalBias)` so the fragment-shader
     // depth-ref reconstruction (lighting-punctual.wgsl evalPointShadowed)
     // can avoid sampling DirectLightSlot for the URP path. The shared
     // DirectLightSlot metadata remains the identity owner, so binding 6 is
@@ -693,7 +739,10 @@ function buildPbrPipelineLayouts(device, caps) {
   );
   if (!viewBglRes.ok) throw viewBglRes.error;
   const materialBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, { kind: "pbr-material-merged" })
+    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
+      kind: "pbr-material-merged",
+      caps
+    })
   );
   if (!materialBglRes.ok) throw materialBglRes.error;
   const meshArrayBglRes = device.createBindGroupLayout(
@@ -752,10 +801,16 @@ var AUTHORED_STANDARD_ID_RE = /::(?:standard|pbr-skin)(?:-|$)/;
 function isStandardPbrSkinMaterialShader(shaderId) {
   return shaderId === SKIN_MATERIAL_SHADER_ID || shaderId === "forgeax::default-standard-pbr-skin" || shaderId !== void 0 && /::pbr-skin(?:-|$)/.test(shaderId);
 }
-function shadowCasterVariantSet(storageBuffer, skinned) {
+function shadowCasterVariantSet(storageBuffer, skinned, gpuDrivenSceneIndex = false, alphaMask = false) {
   const skinningDisabled = !skinned;
-  if (storageBuffer && skinningDisabled) return "";
-  return `SKINNING_DISABLED=${String(skinningDisabled)}+STORAGE_BUFFER_AVAILABLE=${String(storageBuffer)}`;
+  const defines = {
+    ALPHA_MASK: alphaMask,
+    GPU_DRIVEN_SCENE_INDEX_AVAILABLE: gpuDrivenSceneIndex,
+    GPU_DRIVEN_SCENE_INDEX_EXPLICIT: false,
+    SKINNING_DISABLED: skinningDisabled,
+    STORAGE_BUFFER_AVAILABLE: storageBuffer
+  };
+  return Object.entries(defines).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([name, value]) => `${name}=${String(value)}`).join("+");
 }
 function resolvePipelineGroup2Contract(source) {
   const withoutComments = source.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/\/\/.*$/gmu, "");
@@ -815,6 +870,40 @@ function buildPbrSkinLayouts(device, caps, pbr) {
     bindGroupLayouts: layouts
   };
 }
+function buildGpuDrivenPbrInstancesBindGroupLayout(device, caps) {
+  if (!caps.storageBuffer) {
+    throw new Error("GPU-driven PBR instances layout requires storage-buffer capability");
+  }
+  const result = device.createBindGroupLayout(
+    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
+      kind: "pbr-gpu-driven-instances",
+      caps
+    })
+  );
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+function buildGpuDrivenPbrPipelineLayout(device, pbr, gpuDrivenInstancesBgl) {
+  const result = device.createPipelineLayout({
+    label: "pbr-gpu-driven-pl",
+    bindGroupLayouts: [pbr.viewBgl, pbr.materialBgl, pbr.meshArrayBgl, gpuDrivenInstancesBgl]
+  });
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+function buildGpuDrivenPbrSkinPipelineLayout(device, pbrSkin, gpuDrivenInstancesBgl) {
+  const result = device.createPipelineLayout({
+    label: "pbr-skin-gpu-driven-pl",
+    bindGroupLayouts: [
+      pbrSkin.viewBgl,
+      pbrSkin.materialBgl,
+      pbrSkin.meshArrayBgl,
+      gpuDrivenInstancesBgl
+    ]
+  });
+  if (!result.ok) throw result.error;
+  return result.value;
+}
 function createPbrSkinMeshBindGroupEntries(meshBuffer, meshSize, paletteBuffer, paletteWindowBytes) {
   return [
     {
@@ -974,6 +1063,34 @@ function buildBindGroupLayoutDescriptor(spec, options) {
         )
       };
     }
+    case "pbr-gpu-driven-instances": {
+      const caps = options.caps ?? { storageBuffer: true };
+      const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
+      return {
+        label: "pbr-gpu-driven-instances-bgl",
+        entries: [
+          {
+            binding: 0,
+            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
+            buffer: { type: meshBufType, hasDynamicOffset: false }
+          },
+          {
+            // ShadowCaster's scene-index entry still reads the visible row
+            // through binding(1). Keep this alias in the dedicated layout so
+            // the shared visible bind group can serve both the Standard PBR
+            // (binding(2)) and depth-only shadow (binding(1)) consumers.
+            binding: 1,
+            visibility: GPU_SHADER_STAGE_VERTEX,
+            buffer: { type: meshBufType, hasDynamicOffset: false }
+          },
+          {
+            binding: 2,
+            visibility: GPU_SHADER_STAGE_VERTEX,
+            buffer: { type: meshBufType, hasDynamicOffset: false }
+          }
+        ]
+      };
+    }
     case "pbr-skin-mesh-array": {
       const caps = options.caps ?? { storageBuffer: true };
       const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
@@ -982,7 +1099,7 @@ function buildBindGroupLayoutDescriptor(spec, options) {
         entries: [
           {
             binding: 0,
-            visibility: GPU_SHADER_STAGE_VERTEX,
+            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
             buffer: { type: meshBufType, hasDynamicOffset: true }
           },
           {
@@ -1010,6 +1127,13 @@ function buildBindGroupLayoutDescriptor(spec, options) {
         ...afterTransmission,
         ...appendTextureInjection(afterTransmission, physicalFields)
       ];
+      if (options.caps?.storageBuffer ?? true) {
+        merged.push({
+          binding: 46,
+          visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
+          buffer: { type: "read-only-storage", hasDynamicOffset: false }
+        });
+      }
       return {
         label: "pbr-material-skylight-bgl",
         entries: merged
@@ -1189,6 +1313,251 @@ function selectPasses(passes, selector) {
   );
 }
 
-export { COOKIE_MATRIX_BYTES, COOKIE_SLICE_CAPACITY, COOKIE_SLICE_SIZE, DeviceScope, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, EXTENDED_LIGHTING_TOPOLOGY, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_INDIRECT, GPU_BUFFER_USAGE_MAP_READ, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_UNIFORM, GPU_BUFFER_USAGE_VERTEX, GPU_SHADER_STAGE_COMPUTE, GPU_SHADER_STAGE_FRAGMENT, GPU_SHADER_STAGE_VERTEX, IES_SLICE_CAPACITY, IES_SLICE_HEIGHT, IES_SLICE_WIDTH, LifecycleTransaction, PROBE_BLEND_RECORD_BYTE_SIZE, PROBE_BLEND_RECORD_CAPACITY, PROBE_BLEND_RECORD_STRIDE, SHADOW_CASTER_SHADER_ID, SKIN_MATERIAL_SHADER_ID, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, buildBindGroupLayoutDescriptor, buildPbrMaterialUserRegionEntries, buildPbrPipelineLayouts, buildPbrSkinLayouts, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, createPbrSkinMeshBindGroupEntries, createRenderTargetMaterialSource, deriveExtendedLightingCapability, extendedLightingSampledTextureCapacityAvailable, getOpaqueResourceIdentity, getTextureIdentity, instanceCollectionCacheKey, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, makeZeroCameraFallbackSnapshot, matchPass, materialBindGroupLayoutIdentity, pbrSkinMeshDynamicOffsets, physicalTextureFields, probeBlendRecordOffset, resolvePipelineGroup2Contract, resolveRenderTargetMaterialSource, selectPasses, shadowCasterVariantSet, validateGraphTargetCaptureReadback, worldEntityKey };
-//# sourceMappingURL=chunk-HKXTW355.mjs.map
-//# sourceMappingURL=chunk-HKXTW355.mjs.map
+// src/gpu-driven/prepared-draw.ts
+function failure(code, detail) {
+  return { ok: false, error: new GpuDrivenPreparationError(code, detail) };
+}
+function sameVertexInputs(expected, actual) {
+  return expected.length === actual.length && expected.every(
+    (input, index) => input.semantic === actual[index]?.semantic && input.location === actual[index]?.location && input.format === actual[index]?.format
+  );
+}
+function hasMaterialResources(snapshot, receipt) {
+  if ((snapshot.material.textureSources?.size ?? 0) > 0 || (snapshot.material.videoTextureFields?.size ?? 0) > 0) {
+    return false;
+  }
+  const textures = snapshot.material.textureHandles;
+  const samplers = snapshot.material.samplerHandles;
+  const authoredTextures = snapshot.material.authoredTextureFields;
+  const authoredSamplers = snapshot.material.authoredSamplerFields;
+  return receipt.resourceSlots.every((slot) => {
+    if (slot.kind === "texture") {
+      if (!authoredTextures?.has(slot.parameter)) return true;
+      return textures?.has(slot.parameter) === true || snapshot.material.textureSources?.has(slot.parameter) === true || snapshot.material.videoTextureFields?.has(slot.parameter) === true;
+    }
+    if (!authoredSamplers?.has(slot.parameter)) return true;
+    return samplers?.has(slot.parameter) === true;
+  });
+}
+function prepareGpuDrivenDraw(input) {
+  const receipt = input.artifact.receipt;
+  if (receipt === void 0) {
+    return failure("missing-material-receipt", {
+      reason: "material-receipt-missing",
+      owner: "material",
+      expected: "MaterialShaderArtifact.receipt"
+    });
+  }
+  if (receipt.generation !== input.generation) {
+    return failure("stale-generation", {
+      reason: "generation-stale",
+      owner: "generation",
+      expectedGeneration: input.generation,
+      actualGeneration: receipt.generation
+    });
+  }
+  if (receipt.reflection.layoutIdentity !== input.artifact.layoutIdentity) {
+    return failure("reflection-mismatch", {
+      reason: "reflection-receipt-mismatch",
+      owner: "material",
+      expected: input.artifact.layoutIdentity,
+      actual: receipt.reflection.layoutIdentity
+    });
+  }
+  if (receipt.uvSets.some((uv) => uv.set > 0) && input.geometry.vertexInputs.length < 3) {
+    return failure("missing-uv", {
+      reason: "uv-set-missing",
+      owner: "geometry",
+      expected: `${receipt.uvSets.length} material UV sets`,
+      actual: `${input.geometry.vertexInputs.filter((vertex) => vertex.semantic.startsWith("uv")).length} geometry UV sets`
+    });
+  }
+  if (!sameVertexInputs(receipt.vertexInputs, input.geometry.vertexInputs)) {
+    return failure("vertex-input-mismatch", {
+      reason: "vertex-semantic-mismatch",
+      owner: "geometry",
+      expected: receipt.vertexInputs.map((input2) => input2.semantic).join(","),
+      actual: input.geometry.vertexInputs.map((input2) => input2.semantic).join(",")
+    });
+  }
+  if (receipt.alphaMask.cutoff.length === 0) {
+    return failure("alpha-mask-mismatch", {
+      reason: "alpha-mask-receipt-missing",
+      owner: "material",
+      expected: "alphaMask.cutoff"
+    });
+  }
+  if (!hasMaterialResources(input.snapshot, receipt)) {
+    return failure("resource-not-ready", {
+      reason: "material-resource-missing",
+      owner: "material",
+      expected: receipt.resourceSlots.map((slot) => slot.parameter).join(",")
+    });
+  }
+  const deformation = input.snapshot.skin === void 0 ? "rigid" : "skin";
+  if (deformation === "skin") {
+    if (input.skinReceipt === void 0 || receipt.skinPaletteAddress === void 0) {
+      return failure("skin-receipt-mismatch", {
+        reason: "skin-address-missing",
+        owner: "skin",
+        expected: "skinPaletteAddress and skinReceipt"
+      });
+    }
+    if (input.skinReceipt.identity !== input.snapshot.skin?.identity || input.skinReceipt.generation !== input.snapshot.skin?.generation || input.skinReceipt.group !== receipt.skinPaletteAddress.group || input.skinReceipt.binding !== receipt.skinPaletteAddress.binding) {
+      return failure("skin-receipt-mismatch", {
+        reason: "skin-address-missing",
+        owner: "skin",
+        expected: `${receipt.skinPaletteAddress.group}:${receipt.skinPaletteAddress.binding}@${input.snapshot.skin?.generation ?? "<missing>"}`,
+        actual: `${input.skinReceipt.group}:${input.skinReceipt.binding}@${input.skinReceipt.generation}`
+      });
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      identity: {
+        material: input.artifact.material,
+        geometry: input.geometry.identity,
+        deformation
+      },
+      receiptGeneration: receipt.generation,
+      directEntry: receipt.directEntry,
+      sceneIndexEntry: receipt.sceneIndexEntry,
+      materialRow: receipt.materialRow,
+      resourceSlots: receipt.resourceSlots,
+      uvSets: receipt.uvSets,
+      vertexInputs: receipt.vertexInputs,
+      alphaMask: receipt.alphaMask,
+      skinPaletteAddress: receipt.skinPaletteAddress,
+      topology: input.draw.topology,
+      indexed: input.draw.kind === "indexed",
+      first: input.draw.first,
+      count: input.draw.count,
+      baseVertex: input.draw.baseVertex
+    }
+  };
+}
+
+// src/extract/gpu-driven.ts
+function gpuDrivenDrawKey(worldEntity, materialHandle, drawItemIndex) {
+  return `${worldEntity}:${materialHandle}:${drawItemIndex}`;
+}
+function gpuDrivenShadowDrawKey(worldEntity, materialHandle, drawItemIndex, passIndex) {
+  return `${gpuDrivenDrawKey(worldEntity, materialHandle, drawItemIndex)}:${passIndex}`;
+}
+function gpuDrivenSourceDrawItemIndex(draw, compactIndex) {
+  return draw.drawItemIndex ?? compactIndex;
+}
+function resolvePreparedGpuDrivenDraw(input) {
+  return prepareGpuDrivenDraw(input);
+}
+function gpuDrivenMaterialResourceClass(material) {
+  const textures = [...material.textureHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
+  const samplers = [...material.samplerHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
+  return JSON.stringify({
+    textures,
+    samplers
+  });
+}
+function hasCpuOnlyMaterialResources(material) {
+  return (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
+}
+function buildGpuDrivenDraws(input) {
+  const legacy = "submeshes" in input;
+  if (!legacy && input.mesh === void 0) return [];
+  const parsedMesh = legacy ? void 0 : input.mesh;
+  if (!legacy && parsedMesh === void 0) return [];
+  const indexed = legacy ? input.indexed : parsedMesh?.indices !== void 0;
+  const submeshes = legacy ? input.submeshes : parsedMesh?.submeshes ?? [];
+  const layoutProjection = parsedMesh === void 0 ? void 0 : deriveVertexLayoutProjection(parsedMesh.attributes);
+  const geometry = {
+    identity: parsedMesh === void 0 ? "<no-mesh>" : `${parsedMesh.guid ?? "<no-guid>"}:${layoutProjection?.digest ?? ""}`,
+    vertexInputs: (layoutProjection?.attributes ?? []).map((attribute) => ({
+      semantic: attribute.key,
+      location: attribute.shaderLocation,
+      format: attribute.format
+    })),
+    topology: submeshes[0]?.topology ?? "triangle-list",
+    indexed
+  };
+  let nonIndexedFirst = 0;
+  return submeshes.flatMap((submesh, drawItemIndex) => {
+    const drawMaterial = input.materials[submesh.materialSlot] ?? input.fallbackMaterial;
+    const first = indexed ? submesh.indexOffset : nonIndexedFirst;
+    nonIndexedFirst += submesh.vertexCount;
+    if (drawMaterial.transparent === true) return [];
+    const draw = {
+      drawItemIndex,
+      kind: indexed ? "indexed" : "non-indexed",
+      first,
+      count: indexed ? submesh.indexCount : submesh.vertexCount,
+      baseVertex: 0,
+      materialSlot: submesh.materialSlot,
+      topology: submesh.topology,
+      pipelineClass: `${drawMaterial.materialShaderId ?? "forgeax::default-unlit"}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
+      materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial)
+    };
+    const lodRanges = !legacy ? input.lodMeshes?.map((lodMesh) => {
+      if (lodMesh === void 0) return void 0;
+      const lower = lodMesh.submeshes[drawItemIndex];
+      if (lower === void 0) return void 0;
+      const lowerIndexed = lodMesh.indices !== void 0;
+      const lowerFirst = lowerIndexed ? lower.indexOffset : lodMesh.submeshes.slice(0, drawItemIndex).reduce((offset, entry) => offset + entry.vertexCount, 0);
+      return {
+        first: lowerFirst,
+        count: lowerIndexed ? lower.indexCount : lower.vertexCount,
+        baseVertex: 0
+      };
+    }) : void 0;
+    const withLodRanges = lodRanges?.length !== 0 && lodRanges?.every((range) => range !== void 0) ? { lodRanges } : {};
+    const prepared = legacy ? input.prepare?.(draw, drawMaterial) : hasCpuOnlyMaterialResources(drawMaterial) ? void 0 : (() => {
+      const materialShaderId = drawMaterial.materialShaderId;
+      const artifact = materialShaderId === void 0 ? void 0 : input.getMaterialShaderArtifact?.(
+        materialShaderId,
+        geometry.vertexInputs.some((attribute) => attribute.semantic === "color")
+      );
+      const standardPbr = isStandardPbrMaterialShader(materialShaderId);
+      if (artifact === void 0) {
+        return input.getMaterialShaderArtifact !== void 0 && standardPbr ? new GpuDrivenPreparationError("missing-material-receipt", {
+          reason: "material-receipt-missing",
+          owner: "material",
+          expected: `artifact for ${materialShaderId}`
+        }) : void 0;
+      }
+      const receipt = artifact.receipt;
+      if (receipt === void 0) {
+        return standardPbr ? new GpuDrivenPreparationError("missing-material-receipt", {
+          reason: "material-receipt-missing",
+          owner: "material",
+          expected: `receipt for ${materialShaderId}`
+        }) : void 0;
+      }
+      const skinReceipt = input.baseSnapshot.skin !== void 0 && receipt.skinPaletteAddress !== void 0 ? {
+        identity: input.baseSnapshot.skin.identity,
+        generation: input.baseSnapshot.skin.generation,
+        group: receipt.skinPaletteAddress.group,
+        binding: receipt.skinPaletteAddress.binding,
+        byteOffset: input.baseSnapshot.skin.byteOffset
+      } : void 0;
+      const result = resolvePreparedGpuDrivenDraw({
+        snapshot: { ...input.baseSnapshot, material: drawMaterial },
+        artifact,
+        geometry: { ...geometry, topology: draw.topology, indexed: draw.kind === "indexed" },
+        generation: receipt.generation,
+        draw,
+        ...skinReceipt === void 0 ? {} : { skinReceipt }
+      });
+      return result.ok ? result.value : standardPbr ? result.error : void 0;
+    })();
+    if (prepared instanceof GpuDrivenPreparationError) {
+      return [{ ...draw, preparationError: prepared, ...withLodRanges }];
+    }
+    return [
+      prepared === void 0 ? { ...draw, ...withLodRanges } : { ...draw, prepared, ...withLodRanges }
+    ];
+  });
+}
+
+export { COOKIE_MATRIX_BYTES, COOKIE_SLICE_CAPACITY, COOKIE_SLICE_SIZE, DeviceScope, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, EXTENDED_LIGHTING_TOPOLOGY, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_INDIRECT, GPU_BUFFER_USAGE_MAP_READ, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_UNIFORM, GPU_BUFFER_USAGE_VERTEX, GPU_SHADER_STAGE_COMPUTE, GPU_SHADER_STAGE_FRAGMENT, GPU_SHADER_STAGE_VERTEX, IES_SLICE_CAPACITY, IES_SLICE_HEIGHT, IES_SLICE_WIDTH, LifecycleTransaction, PROBE_BLEND_RECORD_BYTE_SIZE, PROBE_BLEND_RECORD_CAPACITY, PROBE_BLEND_RECORD_STRIDE, SHADOW_CASTER_SHADER_ID, SKIN_MATERIAL_SHADER_ID, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, buildBindGroupLayoutDescriptor, buildGpuDrivenDraws, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, buildPbrMaterialUserRegionEntries, buildPbrPipelineLayouts, buildPbrSkinLayouts, classifySceneDataCoverage, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, createPbrSkinMeshBindGroupEntries, createRenderTargetMaterialSource, createTemporalCoverage, deriveExtendedLightingCapability, extendedLightingSampledTextureCapacityAvailable, getOpaqueResourceIdentity, getTextureIdentity, gpuDrivenDrawKey, gpuDrivenShadowDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, makeZeroCameraFallbackSnapshot, matchPass, materialBindGroupLayoutIdentity, pbrSkinMeshDynamicOffsets, physicalTextureFields, probeBlendRecordOffset, resolvePipelineGroup2Contract, resolveRenderTargetMaterialSource, scanSceneDataCoverage, selectPasses, shadowCasterVariantSet, validateGraphTargetCaptureReadback, worldEntityKey };
+//# sourceMappingURL=chunk-BTWH7BP4.mjs.map
+//# sourceMappingURL=chunk-BTWH7BP4.mjs.map