@forgeax/engine-gltf 0.1.29 → 0.1.30

package/README.md

@@ -228,7 +228,7 @@ When `ImporterRegistry` + `runImport` consumes a glTF source, malformed base64 i
 > Two submodules: `parse-skin.ts` (skin index dedupe via UUIDv5 + IBM decoding + jointPath derivation) + `parse-animation.ts` (LINEAR/STEP samplers, CUBICSPLINE/morph fail-fast). Called inside `parseGltfWithBin` -> `toAssetPack` which extends sub-asset output from 3 kinds (mesh/material/scene) to 6 (+ skeleton + skin + animation-clip).
 
 - **Limitations**: CUBICSPLINE interpolation not supported; morph weight animation not supported; jointPath resolution uses leaf-name first-match (same-name sibling is warn-only).
-- **Animated skin bounds** are producer-authored facts. The primary source is `skins[].extras.forgeax.conservativeAnimatedBounds`; `importSettings.conservativeAnimatedBounds[sourceIndex]` is accepted only when source extras do not provide bounds. The importer publishes the six-float bounds on `SkeletonAsset`. If both sources are absent, bounds remain absent and Render keeps the skin on the `cpu-deformation` lane; no BindPose AABB is derived as an animation-bound fallback.
+- **Animated skin bounds** are producer-authored facts. The primary source is `skins[].extras.forgeax.conservativeAnimatedBounds`; `importSettings.conservativeAnimatedBounds[sourceIndex]` is accepted only when source extras do not provide bounds. The importer publishes the six-float bounds on `SkeletonAsset`. When both sources are absent, the import producer derives a conservative enclosure from mesh influences, inverse bind matrices, node TRS, morph deltas, and every imported animation clip. The shared [animation enclosure contract](../animation/README.md#imported-animation-bounds) covers intervals between keys and convex clip blends. Incomplete or singular inputs keep bounds absent and retain the `cpu-deformation` lane. The raw parser remains a source IR; the importer publishes the derived metadata.
 
 ## 4-step runtime recipe (apps/hello/gltf, M5)
 

package/dist/animated-bounds.d.ts

@@ -0,0 +1,4 @@
+import type { GltfDoc } from './parse-gltf';
+/** Source extras and sidecar bounds have already been applied before this producer runs. */
+export declare function deriveGltfAnimatedBounds(doc: GltfDoc): GltfDoc;
+//# sourceMappingURL=animated-bounds.d.ts.map

package/dist/animated-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animated-bounds.d.ts","sourceRoot":"","sources":["../src/animated-bounds.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,4FAA4F;AAC5F,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAqF9D"}

package/dist/gltf-importer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-importer.d.ts","sourceRoot":"","sources":["../src/gltf-importer.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAEV,QAAQ,EAIR,QAAQ,EAMT,MAAM,uBAAuB,CAAC;AAmB/B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAqB,MAAM,iBAAiB,CAAC;AAwUlF,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,OAAO,EACZ,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/C,kBAAkB,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAa,GAC1D,SAAS,QAAQ,EAAE,CA2CrB;AA6oBD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,8BAA8B,GAAG,QAAQ,CAMrF;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,EAAE,QAA+B,CAAC"}
+{"version":3,"file":"gltf-importer.d.ts","sourceRoot":"","sources":["../src/gltf-importer.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAEV,QAAQ,EAIR,QAAQ,EAMT,MAAM,uBAAuB,CAAC;AAoB/B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAqB,MAAM,iBAAiB,CAAC;AAwUlF,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,OAAO,EACZ,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/C,kBAAkB,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAa,GAC1D,SAAS,QAAQ,EAAE,CA2CrB;AA6oBD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,8BAA8B,GAAG,QAAQ,CAMrF;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,EAAE,QAA+B,CAAC"}

package/dist/importer-entry.mjs

@@ -3,11 +3,124 @@ import { deriveDefaultLodScreenCoverages } from '@forgeax/engine-import';
 import { packMeshBinV4 } from '@forgeax/engine-import/mesh-bin';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { ImportError, readConservativeAnimatedBounds, toShared, err, ok, reconcileMeshMaterialSlotTopology, IMPORT_ERROR_HINTS, resolveMeshMaterialSlotDefaultGuid, createMaterialError, standardMaterialParameters, STANDARD_MATERIAL_PARAM_SCHEMA, STANDARD_PHYSICAL_PARAMETER_NAMES, STANDARD_TRANSMISSION_PARAMETER_NAMES, STANDARD_LAYER_PARAMETER_GROUPS, parseConservativeAnimatedBounds } from '@forgeax/engine-types';
+import { deriveConservativeAnimatedBounds } from '@forgeax/engine-animation/animated-bounds';
 import { computeTangentVec4, packInterleavedVertexAttributes } from '@forgeax/engine-geometry';
 import { box3, mat4, vec3, quat } from '@forgeax/engine-math';
 import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
 
 // src/importer-entry.ts
+
+// 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 };
+}
 var GLTF_MESHOPT_MODES = ["ATTRIBUTES", "TRIANGLES", "INDICES"];
 var GLTF_MESHOPT_FILTERS = ["NONE", "OCTAHEDRAL", "QUATERNION", "EXPONENTIAL"];
 var gltfErrorPolicy = {
@@ -2102,35 +2215,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) {
@@ -3564,7 +3648,7 @@ async function importGltf(ctx, meshopt) {
   }
   const parsed = await parseDoc(ctx.source, read.value, ctx, meshopt);
   if (!parsed.ok) return parsed;
-  const doc = applyImportSettingsBounds(parsed.value, ctx.importSettings);
+  const doc = deriveGltfAnimatedBounds(applyImportSettingsBounds(parsed.value, ctx.importSettings));
   const maps = buildHandleMaps(ctx.subAssets, doc);
   const imageColorSpaces = deriveTextureColorSpace({
     imageCount: (doc.images ?? []).length,