@forgeax/engine-fbx 0.1.2

package/src/parse-animation-clip.ts

@@ -0,0 +1,271 @@
+// parse-animation-clip.ts — M5 t50: TS bridge for animation clip POD data.
+//
+// Consumes the C++ JSON POD clips section emitted by binding.cc
+// (WriteAnimationData), linear-resamples each channel to a fixed fps,
+// produces AnimationClipPod (types SSOT per requirements AC-07).
+//
+// Input schema (from JSON.parse of binding output) — flat per-channel timeline:
+//   clips?: [{
+//     name?: string,
+//     duration: number,
+//     channels: [{
+//       targetNode: string,
+//       property: 'translation'|'rotation'|'scale'|'weights',
+//       keyTimes: number[],     // ascending, seconds
+//       keyValues: number[],    // interleaved, stride 3/4 or weightCount
+//       weightCount?: number,   // required for 'weights'
+//     }],
+//   }]
+//
+// The binding emits rotation as a real unit quaternion sampled from
+// node->EvaluateLocalTransform(t).GetQ() (NOT raw euler-degree curves), so the
+// bridge only resamples + re-normalizes; it never euler-converts.
+//
+// Processing:
+//   linear resample: evaluate the strided keyValues at each framestep (1/fps)
+//   rotation: per-component lerp then normalize (nlerp); runtime slerps further
+//   output: AnimationClipPod.channels[].sampler.{input,output,interpolation:LINEAR}
+
+import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
+import type {
+  AnimationChannelPod,
+  AnimationClipPod,
+  AnimationSamplerPod,
+} from '@forgeax/engine-types';
+import { err, type FbxError, fbxErr, ok, type Result } from './errors.js';
+import { buildFbxNodePaths } from './parse-scene.js';
+
+export interface FbxRawAnimChannel {
+  readonly targetNode: string;
+  readonly property: 'translation' | 'rotation' | 'scale' | 'weights';
+  /** Ascending key timestamps in seconds. */
+  readonly keyTimes?: number[];
+  /** Interleaved key values, stride 3/4 or weightCount for morph weights. */
+  readonly keyValues?: number[];
+  /** Number of morph weight elements in each sampled key. */
+  readonly weightCount?: number;
+}
+
+export interface FbxRawClip {
+  readonly name?: string;
+  readonly duration: number;
+  readonly channels: readonly FbxRawAnimChannel[];
+}
+
+export interface FbxRawAnimDoc {
+  readonly clips?: readonly FbxRawClip[];
+}
+
+const DEFAULT_FPS = 30;
+
+/**
+ * Linear-interpolate a strided keyValues stream at time t into `out`.
+ *
+ * keyTimes is ascending; keyValues holds `stride` floats per key. Clamps to
+ * the first/last key outside the range. For rotation (stride 4) the result is
+ * a per-component lerp; the caller normalizes it (nlerp) — runtime playback
+ * slerps further, so import-time nlerp is sufficient to keep unit length.
+ */
+function sampleStrided(
+  keyTimes: readonly number[],
+  keyValues: readonly number[],
+  stride: number,
+  t: number,
+  out: number[],
+  rotation: boolean,
+): void {
+  const n = keyTimes.length;
+  if (n === 0) {
+    for (let c = 0; c < stride; c++) out[c] = rotation && c === 3 ? 1 : 0;
+    return;
+  }
+  const first = keyTimes[0] as number;
+  const lastIdx = n - 1;
+  const last = keyTimes[lastIdx] as number;
+  if (t <= first) {
+    for (let c = 0; c < stride; c++) out[c] = keyValues[c] ?? 0;
+    return;
+  }
+  if (t >= last) {
+    for (let c = 0; c < stride; c++) out[c] = keyValues[lastIdx * stride + c] ?? 0;
+    return;
+  }
+  // Find bracket [i-1, i].
+  let i = 1;
+  while (i < n && (keyTimes[i] as number) < t) i++;
+  const t0 = keyTimes[i - 1] as number;
+  const t1 = keyTimes[i] as number;
+  const frac = t1 > t0 ? (t - t0) / (t1 - t0) : 0;
+  const b0 = (i - 1) * stride;
+  const b1 = i * stride;
+  for (let c = 0; c < stride; c++) {
+    const v0 = keyValues[b0 + c] ?? 0;
+    const v1 = keyValues[b1 + c] ?? 0;
+    out[c] = v0 + (v1 - v0) * frac;
+  }
+}
+
+/**
+ * Build a per-frame sampler for one channel: resample the flat strided
+ * keyValues onto a uniform timeline at the given fps. Rotation channels are
+ * re-normalized per frame so the lerp output stays a unit quaternion.
+ */
+function buildSampler(ch: FbxRawAnimChannel, duration: number, fps: number): AnimationSamplerPod {
+  const frameInterval = 1 / fps;
+  const frameCount = Math.floor(duration * fps) + 1;
+
+  const input = new Float32Array(frameCount);
+  for (let f = 0; f < frameCount; f++) {
+    input[f] = f * frameInterval;
+  }
+
+  const stride =
+    ch.property === 'rotation' ? 4 : ch.property === 'weights' ? (ch.weightCount ?? 0) : 3;
+  if (ch.property === 'weights' && (!Number.isInteger(stride) || stride < 1 || stride > 8)) {
+    throw new Error('fbx-morph-invalid: weight channel count must be an integer in [1, 8]');
+  }
+  const output = new Float32Array(frameCount * stride);
+
+  const keyTimes = ch.keyTimes ?? [];
+  const keyValues = ch.keyValues ?? [];
+  if (keyTimes.length > 0 && keyValues.length !== keyTimes.length * stride) {
+    throw new Error('fbx-morph-invalid: animation key value width does not match key times');
+  }
+  const tmp = new Array<number>(stride);
+
+  for (let f = 0; f < frameCount; f++) {
+    const t = input[f] as number;
+    sampleStrided(keyTimes, keyValues, stride, t, tmp, ch.property === 'rotation');
+    const base = f * stride;
+    if (ch.property === 'rotation') {
+      const len = Math.hypot(tmp[0] ?? 0, tmp[1] ?? 0, tmp[2] ?? 0, tmp[3] ?? 0);
+      const inv = len > 0 ? 1 / len : 0;
+      output[base + 0] = (tmp[0] ?? 0) * inv;
+      output[base + 1] = (tmp[1] ?? 0) * inv;
+      output[base + 2] = (tmp[2] ?? 0) * inv;
+      output[base + 3] = len > 0 ? (tmp[3] ?? 0) * inv : 1;
+    } else {
+      for (let c = 0; c < stride; c++) output[base + c] = tmp[c] ?? 0;
+    }
+  }
+
+  return { input, output, interpolation: 'LINEAR' };
+}
+
+function buildChannel(ch: FbxRawAnimChannel, duration: number, fps: number): AnimationChannelPod {
+  return {
+    targetId: deriveAnimationTargetId(ch.targetNode.split('/')),
+    property: ch.property,
+    sampler: buildSampler(ch, duration, fps),
+  };
+}
+
+interface FbxAnimationNode {
+  readonly name: string;
+  readonly children: readonly number[];
+}
+
+export function resolveAnimationTargetIds(
+  nodes: readonly FbxAnimationNode[],
+  clips: readonly FbxRawClip[],
+): Result<void, FbxError> {
+  const nodesByPath = new Map<string, number[]>();
+  const nodePaths = buildFbxNodePaths(nodes);
+  const cycle = nodePaths.find((path) => !path.ok && path.reason === 'hierarchy-cycle');
+  if (cycle && !cycle.ok) {
+    return err(
+      fbxErr('fbx-animation-target-invalid', {
+        reason: 'hierarchy-cycle',
+        nodeIndex: cycle.nodeIndex,
+      }),
+    );
+  }
+  const hasAmbiguousName = nodePaths.some((path) => !path.ok);
+  for (let index = 0; index < nodePaths.length; index++) {
+    const result = nodePaths[index];
+    if (result === undefined || !result.ok) continue;
+    const path = result.value.join('/');
+    const matches = nodesByPath.get(path) ?? [];
+    matches.push(index);
+    nodesByPath.set(path, matches);
+  }
+
+  const pathById = new Map<string, string>();
+  for (let clipIndex = 0; clipIndex < clips.length; clipIndex++) {
+    const clip = clips[clipIndex];
+    if (clip === undefined) continue;
+    for (let channelIndex = 0; channelIndex < clip.channels.length; channelIndex++) {
+      const channel = clip.channels[channelIndex];
+      if (channel === undefined) continue;
+      const segments = channel.targetNode.split('/');
+      if (segments.some((segment) => segment.length === 0)) {
+        return err(
+          fbxErr('fbx-animation-target-invalid', {
+            reason: 'path-invalid',
+            clipIndex,
+            channelIndex,
+            targetNode: channel.targetNode,
+          }),
+        );
+      }
+      const matches = nodesByPath.get(channel.targetNode);
+      if (matches === undefined) {
+        return err(
+          fbxErr('fbx-animation-target-invalid', {
+            reason: hasAmbiguousName ? 'name-missing' : 'path-not-found',
+            clipIndex,
+            channelIndex,
+            targetNode: channel.targetNode,
+          }),
+        );
+      }
+      if (matches.length !== 1) {
+        return err(
+          fbxErr('fbx-animation-target-invalid', {
+            reason: 'path-duplicate',
+            clipIndex,
+            channelIndex,
+            targetNode: channel.targetNode,
+          }),
+        );
+      }
+      const id = deriveAnimationTargetId(segments);
+      const previous = pathById.get(id);
+      if (previous !== undefined && previous !== channel.targetNode) {
+        return err(
+          fbxErr('fbx-animation-target-invalid', {
+            reason: 'id-collision',
+            clipIndex,
+            channelIndex,
+            targetNode: channel.targetNode,
+          }),
+        );
+      }
+      pathById.set(id, channel.targetNode);
+    }
+  }
+  return ok(undefined);
+}
+
+/**
+ * Parse animation clips from a C++ JSON POD document.
+ * Performs merge-keys + linear resample at the requested fps
+ * (default 30). OOS-9: Hermite tangent data is discarded.
+ *
+ * Returns an empty array when the document has no clip data.
+ */
+export function parseAnimationClips(
+  doc: FbxRawAnimDoc,
+  fps: number = DEFAULT_FPS,
+): AnimationClipPod[] {
+  const clips = doc.clips;
+  if (!clips || clips.length === 0) return [];
+
+  return clips.map((clip): AnimationClipPod => {
+    return {
+      ...(clip.name !== undefined && { name: clip.name }),
+      duration: clip.duration,
+      channels: clip.channels.map((ch) => buildChannel(ch, clip.duration, fps)),
+    };
+  });
+}

package/src/parse-material.ts

@@ -0,0 +1,140 @@
+// parse-material.ts — FBX JSON POD to MaterialPod bridge (t40).
+//
+// Material mapping priority (plan-strategy §D-3):
+//  1. StingrayPBS → channels mapped directly (baseColor/metallic/roughness)
+//  2. Phong        → Family A formula: roughness = 1 - sqrt(shininess/100)
+//                    baseColor = diffuse, metallic = 0
+//  3. Lambert      → same formula as Phong (max_gloss=100 default)
+//  4. Fallback     → default grey PBR: baseColor=[0.5,0.5,0.5], metal=0, rough=0.5
+
+import type { MaterialPod, MaterialTextureBindingPod } from '@forgeax/engine-types';
+
+export interface FbxRawTextureBinding {
+  readonly slot: MaterialTextureBindingPod['slot'];
+  readonly textureIndex: number;
+  readonly texCoord?: number;
+}
+
+/** JSON shape emitted by binding.cc WriteMaterials for a single material. */
+export interface FbxRawMaterial {
+  readonly name?: string;
+  readonly kind: 'stingray-pbs' | 'phong' | 'lambert' | 'fallback';
+  readonly baseColor?: readonly [number, number, number];
+  readonly diffuse?: readonly [number, number, number];
+  readonly shininess?: number;
+  readonly specular?: readonly [number, number, number];
+  readonly textureBindings?: readonly FbxRawTextureBinding[];
+  readonly stingrayProps?: {
+    readonly baseColor?: readonly [number, number, number];
+    readonly metallic?: number;
+    readonly roughness?: number;
+    readonly emissive?: readonly [number, number, number];
+  };
+}
+
+function clamp(v: number, lo: number, hi: number): number {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+
+/** Family A formula: roughness = 1 - sqrt(shininess / maxGloss), clamped [0, 1]. */
+function phongRoughness(shininess: number, maxGloss = 100): number {
+  return clamp(1 - Math.sqrt(shininess / maxGloss), 0, 1);
+}
+
+/**
+ * Parse a single FBX raw material JSON node into a MaterialPod.
+ *
+ * The caller (fbx-importer.ts) iterates the top-level `materials` array
+ * from the C++ binding JSON output.
+ */
+export function parseMaterial(raw: FbxRawMaterial, sourceIndex: number): MaterialPod {
+  void sourceIndex; // reserved for future cross-referencing
+
+  const textureBindings = raw.textureBindings?.map((binding) => ({
+    slot: binding.slot,
+    textureIndex: binding.textureIndex,
+    ...(binding.texCoord === undefined ? {} : { texCoord: binding.texCoord }),
+  }));
+  const textureFields: Pick<
+    MaterialPod,
+    | 'textureBindings'
+    | 'baseColorTextureIndex'
+    | 'metallicRoughnessTextureIndex'
+    | 'normalTextureIndex'
+    | 'occlusionTextureIndex'
+    | 'emissiveTextureIndex'
+    | 'specularTintTextureIndex'
+  > =
+    textureBindings === undefined || textureBindings.length === 0
+      ? {}
+      : {
+          textureBindings,
+          ...Object.fromEntries(
+            textureBindings.map((binding) => [
+              binding.slot === 'baseColorTexture'
+                ? 'baseColorTextureIndex'
+                : binding.slot === 'metallicRoughnessTexture'
+                  ? 'metallicRoughnessTextureIndex'
+                  : binding.slot === 'normalTexture'
+                    ? 'normalTextureIndex'
+                    : binding.slot === 'occlusionTexture'
+                      ? 'occlusionTextureIndex'
+                      : binding.slot === 'emissiveTexture'
+                        ? 'emissiveTextureIndex'
+                        : 'specularTintTextureIndex',
+              binding.textureIndex,
+            ]),
+          ),
+        };
+
+  switch (raw.kind) {
+    case 'stingray-pbs': {
+      const sp = raw.stingrayProps ?? {};
+      return {
+        ...(raw.name !== undefined && { name: raw.name }),
+        baseColorFactor: [
+          sp.baseColor?.[0] ?? 0.5,
+          sp.baseColor?.[1] ?? 0.5,
+          sp.baseColor?.[2] ?? 0.5,
+          1,
+        ],
+        metallicFactor: sp.metallic ?? 0,
+        roughnessFactor: sp.roughness ?? 0.5,
+        ...textureFields,
+      };
+    }
+
+    case 'phong': {
+      const d = raw.diffuse ?? raw.baseColor ?? [0.5, 0.5, 0.5];
+      const gloss = raw.shininess ?? 100;
+      return {
+        ...(raw.name !== undefined && { name: raw.name }),
+        baseColorFactor: [d[0] ?? 0.5, d[1] ?? 0.5, d[2] ?? 0.5, 1],
+        metallicFactor: 0,
+        roughnessFactor: phongRoughness(gloss),
+        ...textureFields,
+      };
+    }
+
+    case 'lambert': {
+      const d = raw.diffuse ?? raw.baseColor ?? [0.5, 0.5, 0.5];
+      return {
+        ...(raw.name !== undefined && { name: raw.name }),
+        baseColorFactor: [d[0] ?? 0.5, d[1] ?? 0.5, d[2] ?? 0.5, 1],
+        metallicFactor: 0,
+        roughnessFactor: 0.5, // lambert has no specular → default roughness
+        ...textureFields,
+      };
+    }
+
+    default: {
+      // fallback: no recognized material type
+      return {
+        baseColorFactor: [0.5, 0.5, 0.5, 1],
+        metallicFactor: 0,
+        roughnessFactor: 0.5,
+        ...textureFields,
+      };
+    }
+  }
+}

package/src/parse-mesh.ts

@@ -0,0 +1,223 @@
+// parse-mesh.ts — FBX JSON POD to MeshPod bridge (t28).
+
+import type { MeshPod, MorphTarget } from '@forgeax/engine-types';
+
+const MORPH_MAX_TARGETS = 8;
+const MORPH_MAX_ATTRIBUTES = 8;
+
+export interface FbxRawMesh {
+  readonly name?: string;
+  readonly vertices: number[];
+  readonly indices?: number[];
+  readonly attributes: Record<string, number[]>;
+  readonly polygonCount: number;
+  readonly sourceIndex: number;
+  readonly materialIndex: number;
+  readonly morphTargets?: readonly {
+    readonly position?: number[];
+    readonly normal?: number[];
+    readonly tangent?: number[];
+  }[];
+  readonly morphWeights?: number[];
+}
+
+export interface FbxRawDocument {
+  readonly meshes?: readonly FbxRawMesh[];
+}
+
+// feat-20260629-multi-uv-set-support m1-w6: TEXCOORD key prefix for attribute
+// naming. Used by both parse-mesh (de-index path) and to-asset-pack (consumer).
+const TEXCOORD_PREFIX = 'TEXCOORD_';
+
+// FBX maps positions per control-point but normals / UVs per polygon-vertex
+// (per index corner). When an attribute's element count equals the index count
+// (and not the position count), it is corner-mapped and must be de-indexed:
+// expand to one vertex per corner so positions / normals / uvs stay parallel
+// (the layout buildMeshAsset and the engine vertex buffer assume). A glTF-style
+// mesh (attributes already per-vertex) skips this path untouched.
+function isCornerMapped(
+  attrLen: number,
+  components: number,
+  posCount: number,
+  idxCount: number,
+): boolean {
+  const elems = attrLen / components;
+  return idxCount > 0 && elems === idxCount && elems !== posCount;
+}
+
+export function parseMesh(raw: FbxRawMesh, sourceIndex: number): MeshPod {
+  const rawIndices = raw.indices && raw.indices.length > 0 ? raw.indices : undefined;
+  const posCount = raw.vertices.length / 3;
+  const idxCount = rawIndices?.length ?? 0;
+  const normal = raw.attributes.NORMAL;
+  const rawMorphTargets = raw.morphTargets ?? [];
+  const morphAttributeCount = rawMorphTargets.reduce(
+    (count, target) =>
+      count + (target.position ? 1 : 0) + (target.normal ? 1 : 0) + (target.tangent ? 1 : 0),
+    0,
+  );
+  if (rawMorphTargets.length > MORPH_MAX_TARGETS || morphAttributeCount > MORPH_MAX_ATTRIBUTES) {
+    throw new Error('fbx-morph-invalid: morph target or attribute limit exceeded');
+  }
+  if (
+    rawMorphTargets.some(
+      (target) =>
+        target.position === undefined &&
+        target.normal === undefined &&
+        target.tangent === undefined,
+    )
+  ) {
+    throw new Error('fbx-morph-invalid: every target must contain POSITION, NORMAL, or TANGENT');
+  }
+  const morphTargets = rawMorphTargets.map((target): MorphTarget => {
+    const out: {
+      position?: Float32Array;
+      normal?: Float32Array;
+      tangent?: Float32Array;
+    } = {};
+    for (const [key, values, components] of [
+      ['position', target.position, 3],
+      ['normal', target.normal, 3],
+      ['tangent', target.tangent, 4],
+    ] as const) {
+      if (values === undefined) continue;
+      if (values.length !== posCount * components) {
+        throw new Error(`fbx-morph-invalid: ${key} length does not match vertex count`);
+      }
+      out[key] = new Float32Array(values);
+    }
+    return out;
+  });
+  if (raw.morphWeights !== undefined && raw.morphWeights.length !== morphTargets.length) {
+    throw new Error('fbx-morph-invalid: default weight count does not match target count');
+  }
+
+  // Determine if any attribute is corner-mapped (NORMAL or any TEXCOORD_n).
+  const normalCorner = normal !== undefined && isCornerMapped(normal.length, 3, posCount, idxCount);
+  const uvCornerMap = new Map<string, boolean>();
+  for (const key of Object.keys(raw.attributes)) {
+    if (key.startsWith(TEXCOORD_PREFIX)) {
+      const arr = raw.attributes[key];
+      if (arr !== undefined && isCornerMapped(arr.length, 2, posCount, idxCount)) {
+        uvCornerMap.set(key, true);
+      }
+    }
+  }
+  const hasAnyCorner = normalCorner || uvCornerMap.size > 0;
+
+  if (rawIndices !== undefined && hasAnyCorner) {
+    // De-index: one expanded vertex per corner. Position pulled through the
+    // index; corner-mapped attributes copied straight; per-vertex attributes
+    // gathered through the index. New index buffer is the identity sequence.
+    const expandedPos = new Float32Array(idxCount * 3);
+    const expandedNormal = normal !== undefined ? new Float32Array(idxCount * 3) : undefined;
+    // feat-20260629-multi-uv-set-support m1-w6: expand all TEXCOORD_n sets.
+    const expandedUvs = new Map<string, Float32Array>();
+    for (const key of Object.keys(raw.attributes)) {
+      if (key.startsWith(TEXCOORD_PREFIX)) {
+        expandedUvs.set(key, new Float32Array(idxCount * 2));
+      }
+    }
+    const expandedMorphTargets = morphTargets.map((target) => {
+      const expanded: {
+        position?: Float32Array;
+        normal?: Float32Array;
+        tangent?: Float32Array;
+      } = {};
+      for (const [key, values, components] of [
+        ['position', target.position, 3],
+        ['normal', target.normal, 3],
+        ['tangent', target.tangent, 4],
+      ] as const) {
+        if (values === undefined) continue;
+        const output = new Float32Array(idxCount * components);
+        for (let corner = 0; corner < idxCount; corner++) {
+          const vi = rawIndices[corner] ?? 0;
+          for (let component = 0; component < components; component++) {
+            output[corner * components + component] = values[vi * components + component] ?? 0;
+          }
+        }
+        expanded[key] = output;
+      }
+      return expanded;
+    });
+    for (let corner = 0; corner < idxCount; corner++) {
+      const vi = rawIndices[corner] ?? 0;
+      expandedPos[corner * 3 + 0] = raw.vertices[vi * 3 + 0] ?? 0;
+      expandedPos[corner * 3 + 1] = raw.vertices[vi * 3 + 1] ?? 0;
+      expandedPos[corner * 3 + 2] = raw.vertices[vi * 3 + 2] ?? 0;
+      if (normal !== undefined && expandedNormal !== undefined) {
+        const src = normalCorner ? corner : vi;
+        expandedNormal[corner * 3 + 0] = normal[src * 3 + 0] ?? 0;
+        expandedNormal[corner * 3 + 1] = normal[src * 3 + 1] ?? 0;
+        expandedNormal[corner * 3 + 2] = normal[src * 3 + 2] ?? 0;
+      }
+      for (const [key, expanded] of expandedUvs) {
+        const srcArr = raw.attributes[key];
+        if (srcArr !== undefined) {
+          const src = uvCornerMap.get(key) ? corner : vi;
+          expanded[corner * 2 + 0] = srcArr[src * 2 + 0] ?? 0;
+          expanded[corner * 2 + 1] = srcArr[src * 2 + 1] ?? 0;
+        }
+      }
+    }
+    const identity = new Uint32Array(idxCount);
+    for (let i = 0; i < idxCount; i++) identity[i] = i;
+    const expandedAttrs: Record<string, Float32Array> = {};
+    if (expandedNormal !== undefined) expandedAttrs.NORMAL = expandedNormal;
+    for (const [key, val] of expandedUvs) {
+      expandedAttrs[key] = val;
+    }
+    return {
+      ...(raw.name !== undefined ? { name: raw.name } : {}),
+      vertices: expandedPos,
+      indices: identity,
+      attributes: expandedAttrs,
+      submeshes: [
+        {
+          topology: 'triangle-list' as const,
+          indexOffset: 0,
+          indexCount: idxCount,
+          vertexCount: idxCount,
+          materialIndex: raw.materialIndex >= 0 ? raw.materialIndex : null,
+        },
+      ],
+      sourceIndex,
+      ...(expandedMorphTargets.length === 0 ? {} : { morphTargets: expandedMorphTargets }),
+      ...(raw.morphWeights === undefined
+        ? {}
+        : { morphWeights: new Float32Array(raw.morphWeights) }),
+    };
+  }
+
+  const vertices = new Float32Array(raw.vertices);
+  const indices = rawIndices ? new Uint16Array(rawIndices) : undefined;
+
+  const attributes: Record<string, Float32Array | Uint16Array | Uint32Array> = {};
+  for (const [key, arr] of Object.entries(raw.attributes)) {
+    attributes[key] = new Float32Array(arr);
+  }
+
+  const indexCount = indices?.length ?? 0;
+
+  const submeshes = [
+    {
+      topology: 'triangle-list' as const,
+      indexOffset: 0,
+      indexCount,
+      vertexCount: vertices.length / 3,
+      materialIndex: raw.materialIndex >= 0 ? raw.materialIndex : null,
+    },
+  ];
+
+  return {
+    ...(raw.name !== undefined ? { name: raw.name } : {}),
+    vertices,
+    ...(indices ? { indices } : {}),
+    attributes,
+    submeshes,
+    sourceIndex,
+    ...(morphTargets.length === 0 ? {} : { morphTargets }),
+    ...(raw.morphWeights === undefined ? {} : { morphWeights: new Float32Array(raw.morphWeights) }),
+  };
+}