@forgeax/engine-gltf 0.1.29 → 0.1.31

package/dist/index.mjs

@@ -5,6 +5,7 @@ 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
@@ -1169,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 {
@@ -2122,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) {
@@ -3943,7 +4027,7 @@ async function importGltf(ctx, meshopt) {
   }
   const parsed = await parseDoc(ctx.source, read.value, ctx);
   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,