@forgeax/engine-render 0.1.28 → 0.1.30

package/dist/{chunk-IQMKJLNU.mjs → chunk-FUUO4UND.mjs}

@@ -1,8 +1,9 @@
-import { LifecycleConstructionError, RenderTargetDescriptorInvalidError } from './chunk-J6KACNOH.mjs';
+import { LifecycleConstructionError, GpuDrivenPreparationError, RenderTargetDescriptorInvalidError } from './chunk-JRBDO2KB.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;
@@ -35,7 +36,7 @@ var DeviceScope = class _DeviceScope {
   owner;
   parent;
   lifecycleState = "active";
-  resources = [];
+  resources = /* @__PURE__ */ new Map();
   children = [];
   constructor(generation, owner, parent) {
     this.generation = generation;
@@ -66,7 +67,7 @@ var DeviceScope = class _DeviceScope {
   }
   ref(kind, value) {
     const ref = new DeviceResourceRef(kind, this.owner, this.generation, value);
-    this.resources.push({ ref, cleanup: () => void 0 });
+    this.resources.set(ref, { ref, cleanup: () => void 0 });
     return ref;
   }
   accepts(ref) {
@@ -76,20 +77,25 @@ var DeviceScope = class _DeviceScope {
     return this.lifecycleState === "active";
   }
   resourceDelta() {
-    return this.resources.length;
+    return this.resources.size;
   }
   /** @internal */
   _adopt(kind, value, cleanup) {
     const ref = new DeviceResourceRef(kind, this.owner, this.generation, value);
-    this.resources.push({
+    this.resources.set(ref, {
       ref,
       cleanup: idempotentCleanup(cleanup)
     });
     return ref;
   }
+  /** @internal Remove ownership only after the resource's cleanup succeeded. */
+  _release(ref) {
+    this.resources.delete(ref);
+  }
   /** @internal */
   _clearResources() {
-    const resources = this.resources.splice(0);
+    const resources = [...this.resources.values()];
+    this.resources.clear();
     for (const resource of resources.reverse()) {
       try {
         const pending = resource.cleanup(resource.ref.value);
@@ -153,7 +159,7 @@ var DeviceScope = class _DeviceScope {
     return {
       owner: this.owner,
       generation: this.generation,
-      resourceCount: this.resources.length
+      resourceCount: this.resources.size
     };
   }
 };
@@ -256,7 +262,7 @@ var IES_SLICE_WIDTH = 256;
 var IES_SLICE_HEIGHT = 128;
 var COOKIE_SLICE_SIZE = 256;
 var COOKIE_MATRIX_BYTES = 32 * 16 * Float32Array.BYTES_PER_ELEMENT;
-var EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES = 20;
+var EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES = 21;
 function extendedLightingSampledTextureCapacityAvailable(maxSampledTexturesPerShaderStage) {
   return maxSampledTexturesPerShaderStage !== void 0 && maxSampledTexturesPerShaderStage >= EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES;
 }
@@ -324,16 +330,21 @@ function validateGraphTargetCaptureReadback(input) {
   const { bytes, expectedByteLength, sentinel, allowZero = false } = input;
   if (bytes.byteLength !== expectedByteLength)
     return { ok: false, code: "capture-readback-length" };
-  if (sentinel?.every((value, index) => bytes[index] === value)) {
+  if (sentinel?.every((value, index2) => bytes[index2] === value)) {
     return { ok: false, code: "capture-readback-untouched-sentinel" };
   }
   if (!allowZero && bytes.every((value) => value === 0)) {
     return { ok: false, code: "capture-readback-empty" };
   }
-  for (let index = 0; index + 1 < bytes.length; index += 2) {
-    const exponent = (bytes[index + 1] ?? 0) >>> 2 & 31;
-    if (exponent === 31) return { ok: false, code: "capture-readback-non-finite" };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let index = 0;
+  for (; index + 3 < bytes.byteLength; index += 4) {
+    const word = view.getUint32(index, true);
+    if ((word & 31744) === 31744 || (word & 2080374784) === 2080374784)
+      return { ok: false, code: "capture-readback-non-finite" };
   }
+  if (index + 1 < bytes.byteLength && (view.getUint16(index, true) & 31744) === 31744)
+    return { ok: false, code: "capture-readback-non-finite" };
   return { ok: true };
 }
 function makeZeroCameraFallbackSnapshot() {
@@ -369,6 +380,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 +432,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 +449,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 +565,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 +634,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 +749,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 +811,17 @@ 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, vertexColorAvailable = 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
+  };
+  if (vertexColorAvailable) defines.VERTEX_COLOR_AVAILABLE = true;
+  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 +881,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 +1074,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 +1110,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 }
           },
           {
@@ -1007,12 +1135,26 @@ function buildBindGroupLayoutDescriptor(spec, options) {
       const afterIbl = [...userRegion, ...appendInjection(userRegion, "ibl")];
       const afterTransmission = [...afterIbl, ...appendInjection(afterIbl, "transmission")];
       const merged = [
-        ...afterTransmission,
+        ...options.caps?.transmissionBackdrop === false ? afterIbl : 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
+        entries: [
+          ...merged,
+          {
+            binding: 47,
+            visibility: GPU_SHADER_STAGE_FRAGMENT,
+            texture: { sampleType: "float", viewDimension: "cube" }
+          }
+        ]
       };
     }
     case "unlit-material": {
@@ -1189,6 +1331,277 @@ 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-IQMKJLNU.mjs.map
-//# sourceMappingURL=chunk-IQMKJLNU.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 === "storage-buffer") return false;
+    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(",")
+    });
+  }
+  const hasAlphaMask = receipt.alphaMask.cutoff.length > 0 || receipt.alphaMask.source.length > 0;
+  if (hasAlphaMask && (receipt.alphaMask.cutoff.length === 0 || receipt.alphaMask.source.length === 0)) {
+    return failure("alpha-mask-mismatch", {
+      reason: "alpha-mask-receipt-missing",
+      owner: "material",
+      expected: "alphaMask.cutoff and alphaMask.source for a masked Pass"
+    });
+  }
+  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,
+      receiptIdentity: receipt.receiptIdentity,
+      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 gpuDrivenMaterialArtifactKey(input) {
+  return [
+    input.material,
+    input.deformation,
+    input.receiptIdentity ?? "<legacy-receipt>",
+    input.receiptGeneration
+  ].join("|");
+}
+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 vertexColorAvailable = geometry.vertexInputs.some(
+        (input2) => input2.semantic === "color"
+      );
+      const sceneIndexProgramKey = Object.entries(
+        drawMaterial.materialSceneIndexProgramKeys ?? {}
+      ).find(
+        ([passName, program]) => program.pass === "forward" && drawMaterial.materialProgramKeys?.[passName] === materialShaderId
+      )?.[1]?.specializationKey;
+      const artifact = materialShaderId === void 0 ? void 0 : input.getMaterialShaderArtifact?.(sceneIndexProgramKey ?? materialShaderId, {
+        vertexColorAvailable,
+        deformation: input.baseSnapshot.skin === void 0 ? "rigid" : "skin",
+        pass: "forward",
+        address: "scene-index"
+      });
+      const requiresReceipt = isCanonicalStandardPbrMaterialShader(materialShaderId) || sceneIndexProgramKey !== void 0;
+      if (artifact === void 0) {
+        return input.getMaterialShaderArtifact !== void 0 && requiresReceipt ? 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 new GpuDrivenPreparationError("missing-material-receipt", {
+          reason: "material-receipt-missing",
+          owner: "material",
+          expected: `receipt for ${materialShaderId}`
+        });
+      }
+      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 selectedArtifact = artifact === void 0 || sceneIndexProgramKey === void 0 || materialShaderId === void 0 ? artifact : {
+        ...artifact,
+        material: materialShaderId,
+        specializationKey: sceneIndexProgramKey
+      };
+      const result = resolvePreparedGpuDrivenDraw({
+        snapshot: { ...input.baseSnapshot, material: drawMaterial },
+        artifact: selectedArtifact ?? artifact,
+        geometry: { ...geometry, topology: draw.topology, indexed: draw.kind === "indexed" },
+        generation: receipt.generation,
+        draw,
+        ...skinReceipt === void 0 ? {} : { skinReceipt }
+      });
+      return result.ok ? result.value : result.error;
+    })();
+    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, gpuDrivenMaterialArtifactKey, gpuDrivenShadowDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, makeZeroCameraFallbackSnapshot, matchPass, materialBindGroupLayoutIdentity, pbrSkinMeshDynamicOffsets, physicalTextureFields, probeBlendRecordOffset, resolvePipelineGroup2Contract, resolveRenderTargetMaterialSource, scanSceneDataCoverage, selectPasses, shadowCasterVariantSet, validateGraphTargetCaptureReadback, worldEntityKey };
+//# sourceMappingURL=chunk-FUUO4UND.mjs.map
+//# sourceMappingURL=chunk-FUUO4UND.mjs.map