@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/libraries/models/src/fbx/interpreter/animation.js

@@ -0,0 +1,369 @@
+// ============================================================================
+// FBX Animation Interpreter — AnimationStack/Layer/CurveNode/Curve → AnimationData[]
+// ============================================================================
+// Walks the FBX animation graph: AnimationStack → AnimationLayer →
+// AnimationCurveNode → AnimationCurve. Handles multi-clip (multiple stacks),
+// LINEAR/STEP/CUBICSPLINE interpolation, and PreRotation/LclRotation rest
+// extraction for retargeting.
+//
+// Reference: Babylon.js `interpreter/animation.ts` (852 lines).
+//
+import { childNode, FBX_TIME_FACTOR, findNodesInTree, propArray } from "../types.js";
+import { buildObjectIdMap, getObjectId, getObjectName } from "./connections.js";
+import { normalizeNodeName } from "./nodes.js";
+/**
+ * Parse all animation clips from the FBX tree.
+ *
+ * Each AnimationStack becomes one AnimationData clip. Multiple stacks produce
+ * multiple clips (multi-clip support).
+ */
+export function parseAnimations(nodes, graph, diag) {
+    const objectsNode = nodes.find((n) => n.name === "Objects");
+    if (!objectsNode)
+        return [];
+    const objectIdMap = buildObjectIdMap(nodes);
+    // Parse AnimationCurve nodes
+    const curves = new Map();
+    for (const node of findNodesInTree([objectsNode], "AnimationCurve")) {
+        const id = getObjectId(node, `curve_${curves.size}`);
+        const keyTime = propArray(childNode(node, "KeyTime"), 0) ?? [];
+        const keyValue = propArray(childNode(node, "KeyValueFloat"), 0) ?? [];
+        curves.set(id, { id, keyTime, keyValue });
+    }
+    // Parse AnimationCurveNode nodes
+    const curveNodes = new Map();
+    for (const node of findNodesInTree([objectsNode], "AnimationCurveNode")) {
+        const id = getObjectId(node, `curveNode_${curveNodes.size}`);
+        let propertyName = "";
+        // FBX 7400+: type is encoded in the second property (e.g. "T\x00\x01AnimCurveNode")
+        if (node.properties.length >= 2 && node.properties[1].type === "S") {
+            const typeStr = String(node.properties[1].value);
+            if (typeStr.startsWith("T"))
+                propertyName = "Lcl Translation";
+            else if (typeStr.startsWith("R"))
+                propertyName = "Lcl Rotation";
+            else if (typeStr.startsWith("S"))
+                propertyName = "Lcl Scaling";
+        }
+        // Fallback: look for PropertyName child (older FBX formats)
+        if (!propertyName) {
+            const propNode = childNode(node, "PropertyName");
+            if (propNode && propNode.properties.length > 0) {
+                propertyName = String(propNode.properties[0].value);
+            }
+        }
+        // Find connected curves and extract axis from connection property (e.g. "d|X")
+        // Use graph.getChildren() for O(1) lookup instead of scanning all connections
+        const connectedCurveIds = [];
+        const connectedCurveAxes = [];
+        for (const childId of graph.getChildren(id)) {
+            if (!curves.has(childId))
+                continue;
+            connectedCurveIds.push(childId);
+            // Find the connection to get the property (axis info)
+            const conn = graph.getConnectionsToParent(id).find((c) => c.childId === childId);
+            let axis = "X";
+            if (conn?.property) {
+                if (conn.property.includes("|Y") || conn.property.endsWith("Y"))
+                    axis = "Y";
+                else if (conn.property.includes("|Z") || conn.property.endsWith("Z"))
+                    axis = "Z";
+            }
+            connectedCurveAxes.push(axis);
+        }
+        curveNodes.set(id, { id, property: propertyName, curveIds: connectedCurveIds, curveAxes: connectedCurveAxes });
+    }
+    // Parse AnimationLayer nodes
+    const layers = new Map();
+    for (const node of findNodesInTree([objectsNode], "AnimationLayer")) {
+        const id = getObjectId(node, `layer_${layers.size}`);
+        const connectedCurveNodeIds = [];
+        for (const childId of graph.getChildren(id)) {
+            if (curveNodes.has(childId)) {
+                connectedCurveNodeIds.push(childId);
+            }
+        }
+        layers.set(id, { id, curveNodeIds: connectedCurveNodeIds });
+    }
+    // Parse AnimationStack nodes
+    const stacks = [];
+    for (const node of findNodesInTree([objectsNode], "AnimationStack")) {
+        const id = getObjectId(node, `stack_${stacks.length}`);
+        let stackName = `animation_${stacks.length}`;
+        if (node.properties.length >= 2 && node.properties[1].type === "S") {
+            stackName = String(node.properties[1].value);
+        }
+        let localStop = 0;
+        const localStopNode = childNode(node, "LocalStop");
+        if (localStopNode && localStopNode.properties.length > 0) {
+            localStop = localStopNode.properties[0].value;
+        }
+        const connectedLayerIds = [];
+        for (const childId of graph.getChildren(id)) {
+            if (layers.has(childId)) {
+                connectedLayerIds.push(childId);
+            }
+        }
+        stacks.push({ id, name: stackName, localStop, layerIds: connectedLayerIds });
+    }
+    if (stacks.length === 0)
+        return [];
+    // Build curve node → model node mapping via connections
+    const modelNodes = findNodesInTree([objectsNode], "Model");
+    const modelIdToName = new Map();
+    modelNodes.forEach((node) => {
+        const id = getObjectId(node, `model_${modelIdToName.size}`);
+        const rawName = getObjectName(node, `node_${modelIdToName.size}`);
+        modelIdToName.set(id, normalizeNodeName(rawName));
+    });
+    const curveNodeToModel = new Map();
+    for (const [modelId, modelName] of modelIdToName.entries()) {
+        for (const childId of graph.getChildren(modelId)) {
+            if (curveNodes.has(childId)) {
+                curveNodeToModel.set(childId, modelName);
+            }
+        }
+    }
+    // Build curve node → deformer mapping for morph weight animations.
+    // Morph weight animations connect AnimationCurveNode → Deformer via OP
+    // connection with property "DeformPercent".
+    const deformerNodes = findNodesInTree([objectsNode], "Deformer");
+    const deformerIdToName = new Map();
+    deformerNodes.forEach((node) => {
+        const id = getObjectId(node, `deformer_${deformerIdToName.size}`);
+        // Use the deformer's name property if available, otherwise use a generic name
+        const name = getObjectName(node, `deformer_${deformerIdToName.size}`);
+        deformerIdToName.set(id, name);
+    });
+    const curveNodeToDeformer = new Map();
+    for (const [deformerId, deformerName] of deformerIdToName.entries()) {
+        for (const childId of graph.getChildren(deformerId)) {
+            if (curveNodes.has(childId)) {
+                curveNodeToDeformer.set(childId, deformerName);
+            }
+        }
+    }
+    // Extract source rest rotations and pre-rotations for retargeting
+    const sourceRestRotations = new Map();
+    const sourcePreRotations = new Map();
+    const sourceRestTranslations = new Map();
+    for (let _i = 0, _it = modelNodes, _n = _it.length; _i < _n; _i++) {
+        const node = _it[_i];
+        const id = getObjectId(node, `model_${sourceRestRotations.size}`);
+        const rawName = getObjectName(node, `node_${sourceRestRotations.size}`);
+        const modelName = normalizeNodeName(rawName);
+        const props70 = childNode(node, "Properties70");
+        if (!props70)
+            continue;
+        let preRot = null;
+        let lclRot = null;
+        let lclTrans = null;
+        for (let _i = 0, _it = props70.children, _n = _it.length; _i < _n; _i++) {
+            const p = _it[_i];
+            if (p.name !== "P" || p.properties.length < 7)
+                continue;
+            const propName = String(p.properties[0].value);
+            if (propName === "Lcl Rotation" || propName === "PreRotation") {
+                const q = eulerToQuaternion(p.properties[4].value, p.properties[5].value, p.properties[6].value);
+                if (propName === "PreRotation")
+                    preRot = q;
+                else
+                    lclRot = q;
+            }
+            else if (propName === "Lcl Translation") {
+                lclTrans = [
+                    p.properties[4].value,
+                    p.properties[5].value,
+                    p.properties[6].value,
+                ];
+            }
+        }
+        if (preRot)
+            sourcePreRotations.set(modelName, preRot);
+        if (lclRot && preRot) {
+            sourceRestRotations.set(modelName, qmul(preRot, lclRot));
+        }
+        else if (lclRot) {
+            sourceRestRotations.set(modelName, lclRot);
+        }
+        else if (preRot) {
+            sourceRestRotations.set(modelName, preRot);
+        }
+        if (lclTrans)
+            sourceRestTranslations.set(modelName, lclTrans);
+    }
+    diag.debug("animation", `Extracted ${sourceRestRotations.size} source rest rotations`);
+    // Build AnimationData for each stack
+    const animations = [];
+    for (let _i = 0, _it = stacks, _n = _it.length; _i < _n; _i++) {
+        const stack = _it[_i];
+        const channels = [];
+        let maxTime = 0;
+        // Group curve nodes by target model + property type
+        const groupedChannels = new Map();
+        for (let _i = 0, _it = stack.layerIds, _n = _it.length; _i < _n; _i++) {
+            const layerId = _it[_i];
+            const layer = layers.get(layerId);
+            if (!layer)
+                continue;
+            for (let _i = 0, _it = layer.curveNodeIds, _n = _it.length; _i < _n; _i++) {
+                const curveNodeId = _it[_i];
+                const curveNode = curveNodes.get(curveNodeId);
+                if (!curveNode)
+                    continue;
+                // Check if this curve node targets a Model (TRS) or a Deformer (morph weights)
+                const targetNode = curveNodeToModel.get(curveNode.id);
+                const targetDeformer = curveNodeToDeformer.get(curveNode.id);
+                if (!targetNode && !targetDeformer)
+                    continue;
+                // Determine path from property name
+                let path = "translation";
+                const propLower = curveNode.property.toLowerCase();
+                if (targetDeformer || propLower.includes("deformpercent") || propLower.includes("weight")) {
+                    path = "weights";
+                }
+                else if (propLower.includes("lcl translation") || propLower.includes("translation")) {
+                    path = "translation";
+                }
+                else if (propLower.includes("lcl rotation") || propLower.includes("rotation")) {
+                    path = "rotation";
+                }
+                else if (propLower.includes("lcl scaling") || propLower.includes("scaling") || propLower.includes("scale")) {
+                    path = "scale";
+                }
+                const target = targetNode ?? targetDeformer;
+                if (curveNode.curveIds.length === 0)
+                    continue;
+                const groupKey = `${target}:${path}`;
+                let group = groupedChannels.get(groupKey);
+                if (!group) {
+                    group = { targetNode: target, path, curves: [] };
+                    groupedChannels.set(groupKey, group);
+                }
+                for (let ci = 0; ci < curveNode.curveIds.length; ci++) {
+                    const curve = curves.get(curveNode.curveIds[ci]);
+                    if (!curve || curve.keyTime.length === 0)
+                        continue;
+                    const times = [];
+                    for (let t = 0; t < curve.keyTime.length; t++) {
+                        const timeSec = curve.keyTime[t] / FBX_TIME_FACTOR;
+                        times.push(timeSec);
+                        if (timeSec > maxTime)
+                            maxTime = timeSec;
+                    }
+                    const axis = curveNode.curveAxes[ci] || "X";
+                    group.curves.push({ axis, times, values: curve.keyValue });
+                }
+            }
+        }
+        // Build channels from grouped curves
+        for (const group of groupedChannels.values()) {
+            const channel = buildChannel(group, maxTime);
+            if (channel)
+                channels.push(channel);
+        }
+        if (channels.length === 0)
+            continue;
+        animations.push({
+            name: stack.name,
+            duration: maxTime,
+            channels,
+            sourceRestRotations: sourceRestRotations.size > 0 ? sourceRestRotations : undefined,
+            sourcePreRotations: sourcePreRotations.size > 0 ? sourcePreRotations : undefined,
+            sourceRestTranslations: sourceRestTranslations.size > 0 ? sourceRestTranslations : undefined,
+        });
+    }
+    diag.debug("animation", `Parsed ${animations.length} animation clips`);
+    return animations;
+}
+/** Build an AnimationChannel from grouped axis curves. */
+function buildChannel(group, maxTime) {
+    if (group.curves.length === 0)
+        return null;
+    // Sort curves by axis: X, Y, Z
+    const sortedCurves = [...group.curves].sort((a, b) => {
+        const order = { X: 0, Y: 1, Z: 2 };
+        return (order[a.axis] ?? 3) - (order[b.axis] ?? 3);
+    });
+    // Use the first curve's times as the channel times
+    // (FBX curves for the same channel should have matching key times)
+    const times = sortedCurves[0].times;
+    const valueCount = times.length;
+    // For weights path, use single value per keyframe (not 3-axis interleaved)
+    if (group.path === "weights") {
+        const values = new Float32Array(valueCount);
+        for (let i = 0; i < valueCount; i++) {
+            values[i] = sortedCurves[0].values[i] ?? 0;
+        }
+        return {
+            targetNode: group.targetNode,
+            path: "weights",
+            keyframeTimes: new Float32Array(times),
+            keyframeValues: values,
+            interpolation: "LINEAR",
+        };
+    }
+    // Interleave values: [x0, y0, z0, x1, y1, z1, ...]
+    // For rotation channels, convert Euler angles (degrees) to quaternions
+    // (4 values per keyframe) since the animation runtime expects quaternions.
+    let values;
+    if (group.path === "rotation") {
+        values = new Float32Array(valueCount * 4);
+        for (let i = 0; i < valueCount; i++) {
+            const ex = sortedCurves[0]?.values[i] ?? 0;
+            const ey = sortedCurves[1]?.values[i] ?? 0;
+            const ez = sortedCurves[2]?.values[i] ?? 0;
+            const q = eulerToQuaternion(ex, ey, ez);
+            values[i * 4] = q[0];
+            values[i * 4 + 1] = q[1];
+            values[i * 4 + 2] = q[2];
+            values[i * 4 + 3] = q[3];
+        }
+    }
+    else {
+        values = new Float32Array(valueCount * 3);
+        for (let i = 0; i < valueCount; i++) {
+            for (let c = 0; c < sortedCurves.length && c < 3; c++) {
+                const curve = sortedCurves[c];
+                values[i * 3 + c] = curve.values[i] ?? 0;
+            }
+        }
+    }
+    // Determine interpolation — default to LINEAR
+    // (CUBICSPLINE detection would require checking the curve's tangent data)
+    const interpolation = "LINEAR";
+    return {
+        targetNode: group.targetNode,
+        path: group.path,
+        keyframeTimes: new Float32Array(times),
+        keyframeValues: values,
+        interpolation,
+    };
+}
+/** Convert Euler angles (degrees) to a quaternion (FBX default: XYZ extrinsic = ZYX intrinsic). */
+function eulerToQuaternion(exDeg, eyDeg, ezDeg) {
+    const ex = (exDeg * Math.PI) / 180;
+    const ey = (eyDeg * Math.PI) / 180;
+    const ez = (ezDeg * Math.PI) / 180;
+    const cx = Math.cos(ex / 2), sx = Math.sin(ex / 2);
+    const cy = Math.cos(ey / 2), sy = Math.sin(ey / 2);
+    const cz = Math.cos(ez / 2), sz = Math.sin(ez / 2);
+    // q = qz * qy * qx (extrinsic XYZ = FBX default rotation order 0)
+    return [
+        sx * cy * cz - cx * sy * sz,
+        cx * sy * cz + sx * cy * sz,
+        cx * cy * sz - sx * sy * cz,
+        cx * cy * cz + sx * sy * sz,
+    ];
+}
+/** Quaternion multiplication: a * b. */
+function qmul(a, b) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return [
+        aw * bx + ax * bw + ay * bz - az * by,
+        aw * by - ax * bz + ay * bw + az * bx,
+        aw * bz + ax * by - ay * bx + az * bw,
+        aw * bw - ax * bx - ay * by - az * bz,
+    ];
+}

package/dist/libraries/models/src/fbx/interpreter/blend-shapes.js

@@ -0,0 +1,283 @@
+// ============================================================================
+// FBX Blend Shapes Interpreter — morph targets from Geometry shapes
+// ============================================================================
+// Extracts morph target data from FBX blend shape deformers. FBX stores blend
+// shapes in two possible structures:
+//
+// Structure 1 (modern, used by m10_morph):
+//   Deformer (skin) → Deformer (blendshape, has DeformPercent/FullWeights)
+//   → Geometry (morph target, has Indexes + Vertices = delta positions)
+//
+// Structure 2 (classic, with BlendShapeChannel):
+//   BlendShape → BlendShapeChannel → SubDeformer (Geometry.Shape, has Shapes)
+//
+// Reference: Babylon.js `interpreter/blendShapes.ts` (272 lines).
+//
+import { childNode, findNodesInTree, propArray } from "../types.js";
+import { buildObjectIdMap, getObjectId, getObjectName } from "./connections.js";
+/**
+ * Parse blend shape / morph target data from the FBX tree.
+ *
+ * @returns Map of geometry ID → morph target data.
+ */
+export function parseBlendShapes(nodes, graph, diag) {
+    const result = new Map();
+    const objectIdMap = buildObjectIdMap(nodes);
+    // Find all Deformer nodes
+    const deformerNodes = findNodesInTree(nodes, "Deformer");
+    if (deformerNodes.length === 0)
+        return result;
+    // Find BlendShapeChannel and SubDeformer nodes (classic structure)
+    const blendShapeChannels = findNodesInTree(nodes, "BlendShapeChannel");
+    const subDeformerNodes = findNodesInTree(nodes, "SubDeformer");
+    // Try classic structure first (BlendShapeChannel → SubDeformer with Shapes)
+    if (blendShapeChannels.length > 0 && subDeformerNodes.length > 0) {
+        parseClassicBlendShapes(nodes, graph, objectIdMap, result, diag);
+    }
+    // Try modern structure (Deformer with DeformPercent → Geometry with Indexes)
+    if (result.size === 0) {
+        parseModernBlendShapes(nodes, graph, objectIdMap, result, diag);
+    }
+    if (result.size > 0) {
+        diag.debug("blend-shapes", `Parsed ${result.size} geometries with morph targets`);
+    }
+    return result;
+}
+/**
+ * Parse classic blend shapes (BlendShapeChannel → SubDeformer with Shapes).
+ */
+function parseClassicBlendShapes(nodes, graph, objectIdMap, result, diag) {
+    // Find SubDeformer nodes that have Shapes (morph target delta data)
+    const shapeNodes = new Map();
+    for (const node of findNodesInTree(nodes, "SubDeformer")) {
+        const hasShapes = node.children.some((c) => c.name === "Shapes");
+        if (hasShapes) {
+            const id = getObjectId(node, `shape_${shapeNodes.size}`);
+            shapeNodes.set(id, node);
+        }
+    }
+    if (shapeNodes.size === 0)
+        return;
+    // Build BlendShapeChannel → SubDeformer (shape) connections
+    const channelToShape = new Map();
+    for (const [shapeId] of shapeNodes.entries()) {
+        for (const conn of graph.getConnectionsFromChild(shapeId)) {
+            if (conn.type === "OO") {
+                channelToShape.set(conn.parentId, shapeId);
+            }
+        }
+    }
+    // Build BlendShapeChannel name map
+    const channelIdToName = new Map();
+    for (const channelNode of findNodesInTree(nodes, "BlendShapeChannel")) {
+        const id = getObjectId(channelNode, `channel_${channelIdToName.size}`);
+        const name = getObjectName(channelNode, `morph_${channelIdToName.size}`);
+        channelIdToName.set(id, name);
+    }
+    for (const [shapeId, shapeNode] of shapeNodes.entries()) {
+        // Find the BlendShapeChannel that owns this shape
+        let channelId;
+        for (const [chId, shId] of channelToShape.entries()) {
+            if (shId === shapeId) {
+                channelId = chId;
+                break;
+            }
+        }
+        if (!channelId)
+            continue;
+        // Find the BlendShape → Geometry chain
+        let blendShapeId;
+        for (const conn of graph.getConnectionsFromChild(channelId)) {
+            if (conn.type === "OO") {
+                const node = objectIdMap.get(conn.parentId);
+                if (node && node.name === "BlendShape") {
+                    blendShapeId = conn.parentId;
+                    break;
+                }
+            }
+        }
+        if (!blendShapeId)
+            continue;
+        const geometryId = findConnectedGeometry(blendShapeId, graph, objectIdMap);
+        if (!geometryId)
+            continue;
+        const morphTarget = extractMorphTargetFromSubDeformer(shapeNode, channelIdToName.get(channelId) ?? `morph_${result.size}`);
+        if (!morphTarget)
+            continue;
+        addMorphToResult(result, geometryId, morphTarget);
+    }
+}
+/**
+ * Parse modern blend shapes (Deformer with DeformPercent → Geometry with Indexes).
+ *
+ * Structure:
+ *   Deformer (skin, no Indexes) → Geometry (base mesh)
+ *   Deformer (blendshape, has DeformPercent/FullWeights) → Deformer (skin)
+ *   Geometry (morph target, has Indexes + Vertices) → Deformer (blendshape)
+ */
+function parseModernBlendShapes(nodes, graph, objectIdMap, result, diag) {
+    // Find blendshape deformer nodes (have DeformPercent or FullWeights)
+    const blendShapeDeformers = [];
+    for (const node of findNodesInTree(nodes, "Deformer")) {
+        const hasDeformPercent = node.children.some((c) => c.name === "DeformPercent");
+        const fullWeightsNode = childNode(node, "FullWeights");
+        const fullWeights = propArray(fullWeightsNode, 0) ?? [];
+        if (hasDeformPercent || fullWeights.length > 0) {
+            const id = getObjectId(node, `bs_${blendShapeDeformers.length}`);
+            blendShapeDeformers.push({ id, node, fullWeights });
+        }
+    }
+    if (blendShapeDeformers.length === 0)
+        return;
+    for (let _i = 0, _it = blendShapeDeformers, _n = _it.length; _i < _n; _i++) {
+        const bs = _it[_i];
+        // Find the skin deformer connected to this blendshape deformer (either direction)
+        let skinDeformerId;
+        for (const conn of graph.getConnectionsFromChild(bs.id)) {
+            if (conn.type !== "OO")
+                continue;
+            const node = objectIdMap.get(conn.parentId);
+            if (node && node.name === "Deformer") {
+                skinDeformerId = conn.parentId;
+                break;
+            }
+        }
+        if (!skinDeformerId) {
+            for (const conn of graph.getConnectionsToParent(bs.id)) {
+                if (conn.type !== "OO")
+                    continue;
+                const node = objectIdMap.get(conn.childId);
+                if (node && node.name === "Deformer") {
+                    skinDeformerId = conn.childId;
+                    break;
+                }
+            }
+        }
+        if (!skinDeformerId)
+            continue;
+        // Find the base geometry connected to the skin deformer
+        const baseGeometryId = findConnectedGeometry(skinDeformerId, graph, objectIdMap);
+        if (!baseGeometryId)
+            continue;
+        // Find morph target Geometry nodes connected to the blendshape deformer
+        const morphGeometries = [];
+        // Check parents (morph geometry is parent of blendshape)
+        for (const conn of graph.getConnectionsFromChild(bs.id)) {
+            if (conn.type !== "OO")
+                continue;
+            const node = objectIdMap.get(conn.parentId);
+            if (node && node.name === "Geometry" && node.children.some((c) => c.name === "Indexes")) {
+                morphGeometries.push({ id: conn.parentId, node });
+            }
+        }
+        // Check children (morph geometry is child of blendshape)
+        for (const conn of graph.getConnectionsToParent(bs.id)) {
+            if (conn.type !== "OO")
+                continue;
+            const node = objectIdMap.get(conn.childId);
+            if (node && node.name === "Geometry" && node.children.some((c) => c.name === "Indexes")) {
+                morphGeometries.push({ id: conn.childId, node });
+            }
+        }
+        // Extract morph targets from the morph geometry nodes
+        for (let i = 0; i < morphGeometries.length; i++) {
+            const { node: morphGeoNode } = morphGeometries[i];
+            const morphName = getObjectName(morphGeoNode, `morph_${i}`);
+            const morphTarget = extractMorphTargetFromGeometry(morphGeoNode, morphName);
+            if (!morphTarget)
+                continue;
+            addMorphToResult(result, baseGeometryId, morphTarget);
+        }
+    }
+}
+/** Find a Geometry node connected to a deformer (either direction). */
+function findConnectedGeometry(deformerId, graph, objectIdMap) {
+    // Check parents (deformer is child)
+    for (const conn of graph.getConnectionsFromChild(deformerId)) {
+        if (conn.type !== "OO")
+            continue;
+        const node = objectIdMap.get(conn.parentId);
+        if (node && node.name === "Geometry")
+            return conn.parentId;
+    }
+    // Check children (deformer is parent)
+    for (const conn of graph.getConnectionsToParent(deformerId)) {
+        if (conn.type !== "OO")
+            continue;
+        const node = objectIdMap.get(conn.childId);
+        if (node && node.name === "Geometry")
+            return conn.childId;
+    }
+    return undefined;
+}
+/** Add a morph target to the result map for a geometry. */
+function addMorphToResult(result, geometryId, morphTarget) {
+    let geoData = result.get(geometryId);
+    if (!geoData) {
+        geoData = { morphTargets: [], morphTargetNames: [] };
+        result.set(geometryId, geoData);
+    }
+    geoData.morphTargets.push(morphTarget);
+    geoData.morphTargetNames.push(morphTarget.name);
+}
+/** Extract a MorphTargetData from a SubDeformer (shape) node (classic structure). */
+function extractMorphTargetFromSubDeformer(node, name) {
+    const shapes = childNode(node, "Shapes");
+    if (!shapes || shapes.properties.length === 0)
+        return null;
+    const deltaPositions = propArray(shapes, 0);
+    if (!deltaPositions || deltaPositions.length === 0)
+        return null;
+    const normalsNode = childNode(node, "Normals");
+    let deltaNormals;
+    if (normalsNode && normalsNode.properties.length > 0) {
+        const normals = propArray(normalsNode, 0);
+        if (normals && normals.length > 0) {
+            deltaNormals = new Float32Array(normals);
+        }
+    }
+    return {
+        name,
+        deltaPositions: new Float32Array(deltaPositions),
+        deltaNormals,
+    };
+}
+/** Extract a MorphTargetData from a Geometry node (modern structure).
+ * The Geometry node has Indexes (affected vertex indices) and Vertices (delta positions for those vertices). */
+function extractMorphTargetFromGeometry(node, name) {
+    const indexes = propArray(childNode(node, "Indexes"), 0);
+    const vertices = propArray(childNode(node, "Vertices"), 0);
+    if (!indexes || !vertices || indexes.length === 0 || vertices.length === 0)
+        return null;
+    // The Vertices array contains delta positions for the vertices listed in Indexes.
+    // We need to expand to a full-size array (indexed by original vertex index).
+    const maxIdx = Math.max(...indexes);
+    const fullDeltas = new Float32Array((maxIdx + 1) * 3);
+    for (let i = 0; i < indexes.length; i++) {
+        const vi = indexes[i];
+        fullDeltas[vi * 3] = vertices[i * 3] ?? 0;
+        fullDeltas[vi * 3 + 1] = vertices[i * 3 + 1] ?? 0;
+        fullDeltas[vi * 3 + 2] = vertices[i * 3 + 2] ?? 0;
+    }
+    // Check for delta normals
+    const normalsNode = childNode(node, "Normals");
+    let deltaNormals;
+    if (normalsNode && normalsNode.properties.length > 0) {
+        const normals = propArray(normalsNode, 0);
+        if (normals && normals.length === vertices.length) {
+            const fullNormals = new Float32Array((maxIdx + 1) * 3);
+            for (let i = 0; i < indexes.length; i++) {
+                const vi = indexes[i];
+                fullNormals[vi * 3] = normals[i * 3] ?? 0;
+                fullNormals[vi * 3 + 1] = normals[i * 3 + 1] ?? 0;
+                fullNormals[vi * 3 + 2] = normals[i * 3 + 2] ?? 0;
+            }
+            deltaNormals = fullNormals;
+        }
+    }
+    return {
+        name,
+        deltaPositions: fullDeltas,
+        deltaNormals,
+    };
+}