@forgeax/engine-gltf 0.1.29 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-gltf",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -35,21 +35,21 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-animation": "0.1.29",
-    "@forgeax/engine-geometry": "0.1.29",
-    "@forgeax/engine-import": "0.1.29",
-    "@forgeax/engine-math": "0.1.29",
-    "@forgeax/engine-pack": "0.1.29",
-    "@forgeax/engine-scene": "0.1.29",
-    "@forgeax/engine-types": "0.1.29",
+    "@forgeax/engine-animation": "0.1.30",
+    "@forgeax/engine-geometry": "0.1.30",
+    "@forgeax/engine-import": "0.1.30",
+    "@forgeax/engine-math": "0.1.30",
+    "@forgeax/engine-pack": "0.1.30",
+    "@forgeax/engine-scene": "0.1.30",
+    "@forgeax/engine-types": "0.1.30",
     "@webgpu/types": "^0.1.71",
     "meshoptimizer": "^0.20.0"
   },
   "devDependencies": {
-    "@forgeax/engine-assets-runtime": "0.1.29",
-    "@forgeax/engine-picking": "0.1.29",
-    "@forgeax/engine-render": "0.1.29",
-    "@forgeax/engine-runtime": "0.1.29",
+    "@forgeax/engine-assets-runtime": "0.1.30",
+    "@forgeax/engine-picking": "0.1.30",
+    "@forgeax/engine-render": "0.1.30",
+    "@forgeax/engine-runtime": "0.1.30",
     "@types/node": "^20.14.0"
   },
   "forgeax": {

package/src/__tests__/gltf.unit.test.ts

@@ -1399,6 +1399,73 @@ function unwrapReimport(result: ReturnType<typeof reimportReuseMeta>) {
       });
     });
 
+    it('derives animated bounds through the real glTF import path without metadata', async () => {
+      const binary = new Uint8Array(72);
+      new Float32Array(binary.buffer, 0, 3).set([1, 0, 0]);
+      new Uint16Array(binary.buffer, 12, 4).set([0, 0, 0, 0]);
+      new Float32Array(binary.buffer, 20, 4).set([1, 0, 0, 0]);
+      new Float32Array(binary.buffer, 36, 2).set([0, 1]);
+      new Float32Array(binary.buffer, 44, 6).set([0, 0, 0, 4, 2, 0]);
+      const guid = '019e2cc6-0c86-79da-aa76-b0984c86d493';
+      const source = {
+        asset: { version: '2.0' },
+        buffers: [
+          {
+            byteLength: 72,
+            uri: `data:application/octet-stream;base64,${Buffer.from(binary).toString('base64')}`,
+          },
+        ],
+        bufferViews: [
+          [0, 12],
+          [12, 8],
+          [20, 16],
+          [36, 8],
+          [44, 24],
+        ].map(([byteOffset, byteLength]) => ({ buffer: 0, byteOffset, byteLength })),
+        accessors: [
+          { bufferView: 0, componentType: 5126, count: 1, type: 'VEC3' },
+          { bufferView: 1, componentType: 5123, count: 1, type: 'VEC4' },
+          { bufferView: 2, componentType: 5126, count: 1, type: 'VEC4' },
+          { bufferView: 3, componentType: 5126, count: 2, type: 'SCALAR' },
+          { bufferView: 4, componentType: 5126, count: 2, type: 'VEC3' },
+        ],
+        meshes: [
+          { primitives: [{ mode: 0, attributes: { POSITION: 0, JOINTS_0: 1, WEIGHTS_0: 2 } }] },
+        ],
+        nodes: [
+          { name: 'root', children: [1, 2] },
+          { name: 'mesh', mesh: 0, skin: 0 },
+          { name: 'joint' },
+        ],
+        scenes: [{ nodes: [0] }],
+        scene: 0,
+        skins: [{ joints: [2] }],
+        animations: [
+          {
+            channels: [{ sampler: 0, target: { node: 2, path: 'translation' } }],
+            samplers: [{ input: 3, output: 4, interpolation: 'LINEAR' }],
+          },
+        ],
+      };
+      const produced = unwrap(
+        await gltfImporter.import(
+          makeDataUriCtx({
+            bytes: new TextEncoder().encode(JSON.stringify(source)),
+            subAssets: [{ guid, kind: 'skeleton', sourceIndex: 0 }],
+            decodeCalls: [],
+          }),
+        ),
+      );
+      const skeleton = produced.find((asset) => asset.guid === guid);
+      if (skeleton?.payload.kind !== 'skeleton') throw new Error('missing skeleton');
+      const bounds = skeleton.payload.bounds;
+      if (bounds === undefined) throw new Error('missing imported animation bounds');
+      expect(bounds[0]).toBeLessThanOrEqual(1);
+      expect(bounds[3]).toBeGreaterThanOrEqual(5);
+      expect(bounds[4]).toBeGreaterThanOrEqual(2);
+      expect((bounds[3] ?? NaN) - (bounds[0] ?? NaN)).toBeLessThan(4.01);
+    });
+
     it('imports producer-authored animated skin bounds from importSettings with the SkinAsset', async () => {
       const skeletonGuid = '019e2cc6-0c86-79da-aa76-b0984c86d490';
       const skinGuid = '019e2cc6-0c86-79da-aa76-b0984c86d491';

package/src/animated-bounds.ts

@@ -0,0 +1,94 @@
+import {
+  type AnimatedBoundsMesh,
+  deriveConservativeAnimatedBounds,
+} from '@forgeax/engine-animation/animated-bounds';
+import { buildNodeParentMap, resolveNamedNodePath } from './node-path';
+import type { GltfDoc } from './parse-gltf';
+
+/** Source extras and sidecar bounds have already been applied before this producer runs. */
+export function deriveGltfAnimatedBounds(doc: GltfDoc): GltfDoc {
+  const parents = buildNodeParentMap(doc.nodes);
+  const paths = doc.nodes.map((_, index) => {
+    const path = resolveNamedNodePath(doc.nodes, parents, index);
+    return path.ok ? path.value.join('/') : undefined;
+  });
+  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: number[] = [];
+  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 !== undefined) return skeleton;
+    const meshes: AnimatedBoundsMesh[] = [];
+    for (let index = 0; index < doc.nodes.length; index++) {
+      const node = doc.nodes[index];
+      if (node === undefined) return skeleton;
+      if (node.skinIndex !== skinIndex || node.meshIndex === null) continue;
+      const start = primitiveStarts[node.meshIndex];
+      if (start === undefined) return skeleton;
+      for (const mesh of doc.meshes.slice(
+        start,
+        start + (doc.meshPrimitiveCount?.get(node.meshIndex) ?? 1),
+      )) {
+        if (mesh.joints0 === undefined || mesh.weights0 === undefined) 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 === undefined ? skeleton : { ...skeleton, bounds };
+  });
+  return { ...doc, skeletons };
+}

package/src/gltf-importer.ts

@@ -56,6 +56,7 @@ import {
   resolveMeshMaterialSlotDefaultGuid,
   toShared,
 } from '@forgeax/engine-types';
+import { deriveGltfAnimatedBounds } from './animated-bounds';
 import {
   gltfDocToSceneAsset,
   meshIrToMeshAsset,
@@ -544,7 +545,7 @@ async function importGltf(
   }
   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);
 
   // Pre-derive each images[] row's colorSpace from material slot bindings