@forgeax/engine-gltf 0.1.28 → 0.1.30

package/dist/index.mjs

@@ -1,10 +1,11 @@
-import { err, ok, createMaterialError, standardMaterialParameters, reconcileMeshMaterialSlotTopology, MESH_MATERIAL_SLOT_SOURCE_OVERRIDE_PAYLOAD_SCHEMA, STANDARD_MATERIAL_PARAM_SCHEMA, STANDARD_PHYSICAL_PARAMETER_NAMES, STANDARD_TRANSMISSION_PARAMETER_NAMES, ImportError, STANDARD_LAYER_PARAMETER_GROUPS, IMPORT_ERROR_HINTS, toShared, resolveMeshMaterialSlotDefaultGuid } from '@forgeax/engine-types';
+import { err, ok, createMaterialError, standardMaterialParameters, reconcileMeshMaterialSlotTopology, MESH_MATERIAL_SLOT_SOURCE_OVERRIDE_PAYLOAD_SCHEMA, STANDARD_MATERIAL_PARAM_SCHEMA, STANDARD_PHYSICAL_PARAMETER_NAMES, STANDARD_TRANSMISSION_PARAMETER_NAMES, ImportError, STANDARD_LAYER_PARAMETER_GROUPS, IMPORT_ERROR_HINTS, parseConservativeAnimatedBounds, readConservativeAnimatedBounds, toShared, resolveMeshMaterialSlotDefaultGuid } from '@forgeax/engine-types';
 export { err, ok } from '@forgeax/engine-types';
 import { computeTangentVec4, packInterleavedVertexAttributes } from '@forgeax/engine-geometry';
 import { box3, mat4, vec3, quat } from '@forgeax/engine-math';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { deriveDefaultLodScreenCoverages, reconcileMeshLodMeta } from '@forgeax/engine-import';
 import { packMeshBinV4 } from '@forgeax/engine-import/mesh-bin';
+import { deriveConservativeAnimatedBounds } from '@forgeax/engine-animation/animated-bounds';
 import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
 
 // src/errors.ts
@@ -716,7 +717,7 @@ function composeMat4(out, tx, ty, tz, qx, qy, qz, qw, sx, sy, sz) {
 function gltfDocToSceneAsset(doc, ctx) {
   const sceneIr = doc.scenes[doc.defaultSceneIndex];
   const resultNodes = [];
-  if (sceneIr === void 0) return { kind: "scene", entities: [] };
+  if (sceneIr === void 0) return { kind: "scene", entities: {} };
   const importedLights = doc.lights ?? doc.extensions?.KHR_lights_punctual?.lights ?? [];
   const animationTargetIds = /* @__PURE__ */ new Map();
   for (const clip of doc.animationClips) {
@@ -809,7 +810,10 @@ function gltfDocToSceneAsset(doc, ctx) {
       components.MeshRenderer = { materials: [] };
     }
     if (ir.instancing !== void 0) {
-      components.Instances = { transforms: ir.instancing.transforms };
+      const collectionId = ctx.instanceCollectionIdsByNodeIndex?.get(gltfNodeIdx);
+      if (collectionId !== void 0) {
+        components.Instances = { collectionId };
+      }
     }
     if (isCamera) {
       components.Camera = {
@@ -837,10 +841,20 @@ function gltfDocToSceneAsset(doc, ctx) {
     for (let i = 0; i < 16; i++) parentWorld[i] = savedParent[i] ?? 0;
   };
   for (const rootIdx of sceneIr.nodes) visit(rootIdx, null);
-  const frozen = resultNodes.map((n) => ({
-    localId: n.localId,
-    components: n.components
-  }));
+  const keyByLocalId = /* @__PURE__ */ new Map();
+  for (const node of resultNodes) keyByLocalId.set(node.localIdx, `node-${node.localIdx}`);
+  const entities = {};
+  for (const node of resultNodes) {
+    const components = { ...node.components };
+    const childOf = components.ChildOf;
+    if (childOf !== void 0 && typeof childOf.parent === "number") {
+      const parentKey = keyByLocalId.get(childOf.parent);
+      if (parentKey === void 0)
+        throw new Error(`gltfDocToSceneAsset: missing parent node ${childOf.parent}`);
+      components.ChildOf = { ...childOf, parent: parentKey };
+    }
+    entities[`node-${node.localIdx}`] = { components };
+  }
   const lightFacts = importedLights.map((light) => ({
     kind: light.type,
     intensity: light.intensity,
@@ -849,7 +863,7 @@ function gltfDocToSceneAsset(doc, ctx) {
   }));
   return {
     kind: "scene",
-    entities: frozen,
+    entities,
     ...lightFacts.length === 0 ? {} : { lights: lightFacts }
   };
 }
@@ -1156,6 +1170,118 @@ function checkExtensions(json) {
   return ok({ unsupportedUsed });
 }
 
+// src/node-path.ts
+function buildNodeParentMap(nodes) {
+  const parents = /* @__PURE__ */ new Map();
+  for (let index = 0; index < nodes.length; index++) {
+    for (const child of nodes[index]?.children ?? []) parents.set(child, index);
+  }
+  return parents;
+}
+function resolveNamedNodePath(nodes, parents, nodeIndex) {
+  const reversed = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = nodeIndex;
+  while (current !== void 0) {
+    if (visited.has(current)) {
+      return { ok: false, reason: "hierarchy-cycle", nodeIndex: current };
+    }
+    visited.add(current);
+    const name = nodes[current]?.name;
+    if (name === void 0 || name.length === 0) {
+      return { ok: false, reason: "name-missing", nodeIndex: current };
+    }
+    reversed.push(name);
+    current = parents.get(current);
+  }
+  return { ok: true, value: reversed.reverse() };
+}
+
+// src/animated-bounds.ts
+function deriveGltfAnimatedBounds(doc) {
+  const parents = buildNodeParentMap(doc.nodes);
+  const paths = doc.nodes.map((_, index) => {
+    const path = resolveNamedNodePath(doc.nodes, parents, index);
+    return path.ok ? path.value.join("/") : void 0;
+  });
+  const nodes = doc.nodes.map((node, index) => ({
+    ...node.transform,
+    parent: parents.get(index) ?? null
+  }));
+  const channels = doc.animationClips.flatMap(
+    (clip) => clip.channels.flatMap(
+      (channel) => channel.property === "weights" ? [] : [
+        {
+          node: channel.targetNodeIndex,
+          property: channel.property,
+          values: channel.sampler.output,
+          interpolation: channel.sampler.interpolation
+        }
+      ]
+    )
+  );
+  const primitiveStarts = [];
+  let offset = 0;
+  for (const count of doc.meshPrimitiveCount?.values() ?? doc.meshes.map(() => 1)) {
+    primitiveStarts.push(offset);
+    offset += count;
+  }
+  const skeletons = doc.skeletons.map((skeleton, skinIndex) => {
+    if (skeleton.bounds !== void 0) return skeleton;
+    const meshes = [];
+    for (let index = 0; index < doc.nodes.length; index++) {
+      const node = doc.nodes[index];
+      if (node === void 0) return skeleton;
+      if (node.skinIndex !== skinIndex || node.meshIndex === null) continue;
+      const start = primitiveStarts[node.meshIndex];
+      if (start === void 0) return skeleton;
+      for (const mesh of doc.meshes.slice(
+        start,
+        start + (doc.meshPrimitiveCount?.get(node.meshIndex) ?? 1)
+      )) {
+        if (mesh.joints0 === void 0 || mesh.weights0 === void 0) return skeleton;
+        let maxMorphWeight = Math.max(
+          0,
+          ...Array.from(node.morphWeights ?? mesh.morphWeights ?? [], Math.abs)
+        );
+        for (const clip of doc.animationClips)
+          for (const channel of clip.channels)
+            if (channel.targetNodeIndex === index && channel.property === "weights")
+              for (const weight of channel.sampler.output)
+                maxMorphWeight = Math.max(maxMorphWeight, Math.abs(weight));
+        const morphExtent = Float32Array.from(
+          mesh.positions,
+          (_, component) => (mesh.morphTargets ?? []).reduce(
+            (sum, target) => sum + Math.abs(target.position?.[component] ?? 0) * maxMorphWeight,
+            0
+          )
+        );
+        meshes.push({
+          node: index,
+          positions: mesh.positions,
+          joints: mesh.joints0,
+          weights: mesh.weights0,
+          morphExtent
+        });
+      }
+    }
+    const jointNodes = skeleton.jointPaths.map((path) => paths.indexOf(path));
+    if (jointNodes.some(
+      (node, index) => node < 0 || paths.lastIndexOf(skeleton.jointPaths[index]) !== node
+    ))
+      return skeleton;
+    const bounds = deriveConservativeAnimatedBounds({
+      nodes,
+      channels,
+      jointNodes,
+      inverseBindMatrices: skeleton.inverseBindMatrices,
+      meshes
+    });
+    return bounds === void 0 ? skeleton : { ...skeleton, bounds };
+  });
+  return { ...doc, skeletons };
+}
+
 // src/data-uri.ts
 var DATA_URI_BASE64_RE = /^data:[^;,]*(?:;[^,;]+)*;base64,(.*)$/;
 var Base64DecodeError = class extends Error {
@@ -2109,35 +2235,6 @@ async function projectMeshoptBufferViews(inputViews, inputBuffers, extensionsReq
   }
   return ok({ bufferViews, buffers, decodedCount });
 }
-
-// src/node-path.ts
-function buildNodeParentMap(nodes) {
-  const parents = /* @__PURE__ */ new Map();
-  for (let index = 0; index < nodes.length; index++) {
-    for (const child of nodes[index]?.children ?? []) parents.set(child, index);
-  }
-  return parents;
-}
-function resolveNamedNodePath(nodes, parents, nodeIndex) {
-  const reversed = [];
-  const visited = /* @__PURE__ */ new Set();
-  let current = nodeIndex;
-  while (current !== void 0) {
-    if (visited.has(current)) {
-      return { ok: false, reason: "hierarchy-cycle", nodeIndex: current };
-    }
-    visited.add(current);
-    const name = nodes[current]?.name;
-    if (name === void 0 || name.length === 0) {
-      return { ok: false, reason: "name-missing", nodeIndex: current };
-    }
-    reversed.push(name);
-    current = parents.get(current);
-  }
-  return { ok: true, value: reversed.reverse() };
-}
-
-// src/parse-animation.ts
 var ANIMATION_ACCESSOR_TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
 function parseAnimation(animationsJson, nodesJson, accessors, bufferViews, buffers) {
   if (animationsJson === void 0 || animationsJson.length === 0) {
@@ -2303,8 +2400,6 @@ function parseAnimation(animationsJson, nodesJson, accessors, bufferViews, buffe
   }
   return ok(clips);
 }
-
-// src/parse-skin.ts
 var MAX_JOINTS = 256;
 var SKIN_ACCESSOR_TYPES = ["MAT4"];
 function identityMat4() {
@@ -2385,10 +2480,14 @@ function parseSkin(skinsJson, nodesJson, accessors, bufferViews, buffers) {
       if (!pathResult.ok) return err(pathResult.error);
       jointPaths.push(pathResult.value.join("/"));
     }
+    const bounds = parseConservativeAnimatedBounds(
+      skin.extras?.forgeax?.conservativeAnimatedBounds
+    );
     records.push({
       jointCount: joints.length,
       inverseBindMatrices: ibm,
-      jointPaths
+      jointPaths,
+      ...bounds === void 0 ? {} : { bounds }
     });
   }
   return ok(records);
@@ -3599,6 +3698,16 @@ function isGlbBytes(source) {
 function publishesCatalogProduct(input) {
   return input.importSettings.geometry !== "procedural";
 }
+function applyImportSettingsBounds(doc, importSettings) {
+  let changed = false;
+  const skeletons = doc.skeletons.map((record, sourceIndex) => {
+    const bounds = readConservativeAnimatedBounds(importSettings, sourceIndex);
+    if (bounds === void 0 || record.bounds !== void 0) return record;
+    changed = true;
+    return { ...record, bounds };
+  });
+  return changed ? { ...doc, skeletons } : doc;
+}
 function previousMaterialSlotTopology(ctx, meshSourceKey) {
   if (meshSourceKey === void 0) return void 0;
   const value = ctx.sourceOverrides?.[meshSourceKey]?.materialSlots;
@@ -3918,7 +4027,7 @@ async function importGltf(ctx, meshopt) {
   }
   const parsed = await parseDoc(ctx.source, read.value, ctx);
   if (!parsed.ok) return parsed;
-  const doc = parsed.value;
+  const doc = deriveGltfAnimatedBounds(applyImportSettingsBounds(parsed.value, ctx.importSettings));
   const maps = buildHandleMaps(ctx.subAssets, doc);
   const imageColorSpaces = deriveTextureColorSpace({
     imageCount: (doc.images ?? []).length,
@@ -4217,7 +4326,7 @@ async function importGltf(ctx, meshopt) {
               fieldName: prov.fieldName,
               ...prov.arrayIndex !== void 0 ? { arrayIndex: prov.arrayIndex } : {}
             },
-            sceneEntityId: prov.sceneEntityId
+            sceneEntityKey: prov.sceneEntityKey
           };
         }
         return { guid };
@@ -4228,19 +4337,19 @@ async function importGltf(ctx, meshopt) {
       });
       const handleValueProvenance = /* @__PURE__ */ new Map();
       const skeletonGuidProvenance = /* @__PURE__ */ new Map();
-      for (const entity of scene.entities) {
+      for (const [sceneEntityKey, entity] of Object.entries(scene.entities)) {
         const comps = entity.components;
         const mf = comps.MeshFilter;
         if (mf !== void 0 && typeof mf.assetHandle === "number") {
           handleValueProvenance.set(mf.assetHandle, {
-            sceneEntityId: entity.localId,
+            sceneEntityKey,
             componentName: "MeshFilter",
             fieldName: "assetHandle"
           });
         }
         const skin = comps.Skin;
         if (skin !== void 0 && typeof skin.skeleton === "string") {
-          skeletonGuidProvenance.set(skin.skeleton, { sceneEntityId: entity.localId });
+          skeletonGuidProvenance.set(skin.skeleton, { sceneEntityKey });
         }
       }
       const meshGuidList = [...maps.meshGuidByIndex.values()];
@@ -4258,7 +4367,7 @@ async function importGltf(ctx, meshopt) {
             skProv !== void 0 ? {
               guid,
               sourceField: { componentName: "Skin", fieldName: "skeleton" },
-              sceneEntityId: skProv.sceneEntityId
+              sceneEntityKey: skProv.sceneEntityKey
             } : { guid }
           );
           cursor++;
@@ -4288,7 +4397,8 @@ async function importGltf(ctx, meshopt) {
       const payload = {
         kind: "skeleton",
         inverseBindMatrices: rec.inverseBindMatrices,
-        jointCount: rec.jointCount
+        jointCount: rec.jointCount,
+        ...rec.bounds === void 0 ? {} : { bounds: rec.bounds }
       };
       out.push({ guid: sub.guid, kind: "skeleton", payload, refs: [], artifacts: {} });
     } else if (sub.kind === "skin") {