@babylonjs/loaders 9.26.0 → 9.26.1

package/FBX/interpreter/animation.js

@@ -1,32 +1,32 @@
 /* eslint-disable @typescript-eslint/naming-convention, jsdoc/require-param, jsdoc/require-returns */
-import { findChildByName, getPropertyValue, cleanFBXName } from "../types/fbxTypes.js";
+import { findChildByName, findDocumentNode, getNodeArray, getPropertyValue, cleanFBXName } from "../types/fbxTypes.js";
 import { getChildren } from "./connections.js";
-/** FBX time units: 46186158000 ticks per second */
-const FBX_TIME_UNIT = 46186158000;
+import { getPropertyEntries } from "./propertyTemplates.js";
+import { FBX_TIME_UNIT, buildKeyframes, evaluateCurve, keyframesFromSlopes, parseExtrapolation, combineLayerValue, } from "./animationCurve.js";
+export { FBX_TIME_UNIT } from "./animationCurve.js";
+export { combineLayerValue, evaluateCurve, eulerToQuat, quatToEuler } from "./animationCurve.js";
 const KEY_ATTR_DATA_STRIDE = 4;
-const SAMPLED_CURVE_MIN_KEY_COUNT = 8;
-const SAMPLED_CURVE_MAX_INTERVAL_SECONDS = 1 / 23;
-const SAMPLED_CURVE_UNIFORM_TOLERANCE_RATIO = 0.05;
-const SAMPLED_CURVE_LINEAR_DEVIATION_RATIO = 0.01;
-const SAMPLED_CURVE_LINEAR_DEVIATION_ABSOLUTE = 1e-4;
-const SAMPLED_CURVE_DEGENERATE_SLOPE_ABSOLUTE = 1e-5;
-const SAMPLED_CURVE_COMMON_FPS = [24, 25, 30, 48, 50, 60, 100, 120];
 /**
  * Extract all animation stacks from the FBX scene.
  */
-export function extractAnimations(objectMap) {
+export function extractAnimations(objectMap, doc, options = {}) {
     const stacks = [];
+    const rebaseKeyframes = options.rebaseKeyframes ?? true;
     for (const [id, node] of Array.from(objectMap.objects)) {
         if (node.name === "AnimationStack") {
-            const stack = extractAnimStack(id, node, objectMap);
+            const stack = extractAnimStack(id, node, objectMap, rebaseKeyframes);
             if (stack) {
                 stacks.push(stack);
             }
         }
     }
+    // Pre-7000 files have no AnimationStack objects; their animation lives in the top-level Takes block.
+    if (stacks.length === 0 && doc) {
+        stacks.push(...extractLegacyTakes(doc, objectMap, rebaseKeyframes));
+    }
     return stacks;
 }
-function extractAnimStack(stackId, stackNode, objectMap) {
+function extractAnimStack(stackId, stackNode, objectMap, rebaseKeyframes) {
     const name = cleanFBXName(getPropertyValue(stackNode, 1) ?? "Animation");
     const declaredTimeSpan = extractAnimationStackTimeSpan(stackNode);
     // Find AnimationLayer children of this stack
@@ -40,43 +40,49 @@ function extractAnimStack(stackId, stackNode, objectMap) {
     const layers = [];
     const diagnostics = [];
     let minTime = Infinity;
-    let maxTime = 0;
+    let maxTime = -Infinity;
     for (const { id: layerId, node: layerNode } of layerEntries) {
         // Extract layer properties
         const layerName = cleanFBXName(getPropertyValue(layerNode, 1) ?? "Layer");
         let weight = 100;
         let blendMode = 0;
-        const props70 = findChildByName(layerNode, "Properties70");
-        if (props70) {
-            for (const p of props70.children) {
-                if (p.name !== "P") {
-                    continue;
-                }
-                const pName = getPropertyValue(p, 0);
-                if (pName === "Weight") {
-                    const v = p.properties[4]?.value;
-                    if (typeof v === "number") {
-                        weight = v;
-                    }
-                }
-                else if (pName === "BlendMode") {
-                    const v = p.properties[4]?.value;
-                    if (typeof v === "number") {
-                        blendMode = v;
-                    }
-                }
+        let rotationAccumulationMode = 0;
+        let scaleAccumulationMode = 0;
+        for (const entry of getPropertyEntries(layerNode)) {
+            const v = entry.values[0];
+            if (typeof v !== "number") {
+                continue;
+            }
+            if (entry.name === "Weight") {
+                weight = v;
+            }
+            else if (entry.name === "BlendMode") {
+                blendMode = v;
+            }
+            else if (entry.name === "RotationAccumulationMode") {
+                rotationAccumulationMode = v;
+            }
+            else if (entry.name === "ScaleAccumulationMode") {
+                scaleAccumulationMode = v;
             }
         }
+        const layerIndex = layers.length;
         // AnimationCurveNodes are children of the layer
         const curveNodeEntries = getChildren(objectMap, layerId, "AnimationCurveNode");
         const layerCurveNodes = [];
         const layerUnsupportedCurveNodes = [];
         const layerDiagnostics = [];
+        let layerWeightCurve;
         for (const { id: curveNodeId, node: curveNodeNode } of curveNodeEntries) {
-            const curveNodeData = extractCurveNode(curveNodeId, curveNodeNode, objectMap);
+            const curveNodeData = extractCurveNode(curveNodeId, curveNodeNode, objectMap, layerIndex);
             if (!curveNodeData) {
-                const unsupported = extractUnsupportedCurveNode(curveNodeId, curveNodeNode, objectMap);
+                const unsupported = extractUnsupportedCurveNode(curveNodeId, curveNodeNode, objectMap, layerIndex);
                 if (unsupported) {
+                    // The layer's own Weight property can be animated; it drives blending rather than a target.
+                    if (unsupported.targetId === layerId && unsupported.propertyName === "Weight" && unsupported.curves.length > 0) {
+                        layerWeightCurve = unsupported.curves[0];
+                        continue;
+                    }
                     scanCurveTimes(unsupported.curves, (time) => {
                         if (time < minTime) {
                             minTime = time;
@@ -119,6 +125,8 @@ function extractAnimStack(stackId, stackNode, objectMap) {
             weight,
             normalizedWeight: weight / 100,
             blendMode,
+            blend: makeLayerBlend(blendMode, weight, rotationAccumulationMode, scaleAccumulationMode),
+            weightCurve: layerWeightCurve,
             curveNodes: layerCurveNodes,
             unsupportedCurveNodes: layerUnsupportedCurveNodes,
             diagnostics: layerDiagnostics,
@@ -127,33 +135,15 @@ function extractAnimStack(stackId, stackNode, objectMap) {
     if (allCurveNodes.length === 0 && allUnsupportedCurveNodes.length === 0) {
         return null;
     }
-    if (layers.length > 1) {
-        diagnostics.push({
-            type: "multiple-animation-layers",
-            message: "Multiple animation layers are preserved, but runtime blending is not yet evaluated.",
-        });
-    }
-    for (const layer of layers) {
-        if (layer.blendMode !== 0) {
-            const diagnostic = {
-                type: "unsupported-layer-blend-mode",
-                message: `Animation layer blend mode ${layer.blendMode} is preserved but not yet blended at runtime.`,
-                layerName: layer.name,
-            };
-            layer.diagnostics.push(diagnostic);
-            diagnostics.push(diagnostic);
-        }
-        if (layer.weight !== 100) {
-            const diagnostic = {
-                type: "partial-layer-weight",
-                message: `Animation layer weight ${layer.weight} is preserved but not yet applied at runtime.`,
-                layerName: layer.name,
-            };
-            layer.diagnostics.push(diagnostic);
-            diagnostics.push(diagnostic);
-        }
-    }
-    const timeOffset = minTime > 0 && isFinite(minTime) ? minTime : 0;
+    return finalizeAnimStack(name, layers, allCurveNodes, allUnsupportedCurveNodes, diagnostics, minTime, maxTime, declaredTimeSpan, rebaseKeyframes);
+}
+/**
+ * Resolves the clip span from the declared time span or the key range and, when requested, rebases key times so
+ * the first key sits at zero.
+ */
+function finalizeAnimStack(name, layers, allCurveNodes, allUnsupportedCurveNodes, diagnostics, minTime, maxTime, declaredTimeSpan, rebaseKeyframes) {
+    const hasKeys = isFinite(minTime) && isFinite(maxTime);
+    const timeOffset = rebaseKeyframes && hasKeys && minTime > 0 ? minTime : 0;
     // Rebase all keyframe times so the animation starts at 0
     if (timeOffset > 0) {
         for (const cn of allCurveNodes) {
@@ -172,11 +162,14 @@ function extractAnimStack(stackId, stackNode, objectMap) {
         }
         maxTime -= timeOffset;
     }
-    const declaredStart = declaredTimeSpan ? Math.max(declaredTimeSpan.start - timeOffset, 0) : 0;
+    const declaredStart = declaredTimeSpan ? (rebaseKeyframes ? Math.max(declaredTimeSpan.start - timeOffset, 0) : declaredTimeSpan.start) : 0;
     const declaredStop = declaredTimeSpan ? Math.max(declaredTimeSpan.stop - timeOffset, declaredStart) : 0;
     const hasDeclaredDuration = declaredStop > declaredStart;
-    const startTime = hasDeclaredDuration ? declaredStart : 0;
-    const stopTime = hasDeclaredDuration ? declaredStop : maxTime;
+    // Without a declared span the clip covers its keys (a clip whose keys are all negative ends before zero).
+    const keyStart = hasKeys ? minTime - timeOffset : 0;
+    const keyStop = hasKeys ? maxTime : 0;
+    const startTime = hasDeclaredDuration ? declaredStart : rebaseKeyframes ? Math.min(0, keyStart) : keyStart;
+    const stopTime = hasDeclaredDuration ? declaredStop : Math.max(keyStop, startTime);
     return {
         name,
         startTime,
@@ -209,24 +202,39 @@ function extractAnimationStackTimeSpan(stackNode) {
     }
     return stop !== null ? { start, stop } : null;
 }
-function extractCurveNode(curveNodeId, curveNodeNode, objectMap) {
+function extractCurveNode(curveNodeId, curveNodeNode, objectMap, layerIndex) {
     const typeName = cleanFBXName(getPropertyValue(curveNodeNode, 1) ?? "");
+    const rawDefaults = extractCurveNodeDefaultValues(curveNodeNode);
+    const defaultValues = "d|X" in rawDefaults || "d|Y" in rawDefaults || "d|Z" in rawDefaults ? [rawDefaults["d|X"] ?? 0, rawDefaults["d|Y"] ?? 0, rawDefaults["d|Z"] ?? 0] : undefined;
     // Handle T (translation), R (rotation), S (scale) targeting Models
     if (typeName === "T" || typeName === "R" || typeName === "S") {
         const targetModelId = findCurveNodeTarget(curveNodeId, objectMap);
         if (targetModelId === null) {
             return null;
         }
+        // A curve node without curves still contributes its default values to layer blending (Maya writes such
+        // nodes on the base layer when only additive layers animate a property).
         const curves = extractCurves(curveNodeId, objectMap);
-        if (curves.length === 0) {
+        if (curves.length === 0 && !defaultValues) {
             return null;
         }
         return {
             type: typeName,
             targetModelId,
             curves,
+            layerIndex,
+            defaultValues,
         };
     }
+    // FBX 7.1 writes blend shape weight curves against the geometry, named after the shape channel
+    const geometryChannelId = findCurveNodeGeometryShapeChannel(curveNodeId, objectMap);
+    if (geometryChannelId !== null) {
+        const curves = extractCurves(curveNodeId, objectMap);
+        if (curves.length === 0) {
+            return null;
+        }
+        return { type: "DeformPercent", targetModelId: geometryChannelId, curves, layerIndex, defaultValues };
+    }
     // Handle DeformPercent targeting BlendShapeChannels
     if (typeName === "DeformPercent") {
         const targetId = findCurveNodeBlendShapeTarget(curveNodeId, objectMap);
@@ -241,11 +249,13 @@ function extractCurveNode(curveNodeId, curveNodeNode, objectMap) {
             type: "DeformPercent",
             targetModelId: targetId,
             curves,
+            layerIndex,
+            defaultValues,
         };
     }
     return null;
 }
-function extractUnsupportedCurveNode(curveNodeId, curveNodeNode, objectMap) {
+function extractUnsupportedCurveNode(curveNodeId, curveNodeNode, objectMap, layerIndex) {
     const typeName = cleanFBXName(getPropertyValue(curveNodeNode, 1) ?? "");
     const curves = extractCurves(curveNodeId, objectMap);
     const defaultValues = extractCurveNodeDefaultValues(curveNodeNode);
@@ -264,6 +274,7 @@ function extractUnsupportedCurveNode(curveNodeId, curveNodeNode, objectMap) {
     return {
         type: typeName,
         id: curveNodeId,
+        layerIndex,
         targetId,
         propertyName,
         curveCount: curves.length,
@@ -295,6 +306,29 @@ function findCurveNodeTarget(curveNodeId, objectMap) {
     }
     return null;
 }
+/** When a curve node is connected to a Geometry through a property named like one of its blend shape channels. */
+function findCurveNodeGeometryShapeChannel(curveNodeId, objectMap) {
+    for (const conn of objectMap.connections) {
+        if (conn.childId !== curveNodeId || conn.type !== "OP" || !conn.propertyName) {
+            continue;
+        }
+        const parentNode = objectMap.objects.get(conn.parentId);
+        if (!parentNode || parentNode.name !== "Geometry") {
+            continue;
+        }
+        for (const deformer of getChildren(objectMap, conn.parentId, "Deformer")) {
+            if (getPropertyValue(deformer.node, 2) !== "BlendShape") {
+                continue;
+            }
+            for (const channel of getChildren(objectMap, deformer.id, "Deformer")) {
+                if (getPropertyValue(channel.node, 2) === "BlendShapeChannel" && cleanFBXName(getPropertyValue(channel.node, 1) ?? "") === conn.propertyName) {
+                    return channel.id;
+                }
+            }
+        }
+    }
+    return null;
+}
 /**
  * Find the BlendShapeChannel that a DeformPercent AnimationCurveNode targets.
  */
@@ -340,8 +374,7 @@ function extractCurves(curveNodeId, objectMap) {
             const channel = conn.propertyName ?? "d|X";
             const keys = extractKeyframes(curveNode);
             if (keys.length > 0) {
-                const isSampled = isSampledAnimationCurve(curveNode, keys);
-                curves.push({ channel, keys: isSampled ? makeLinearSampleKeys(keys) : keys, isSampled });
+                curves.push({ channel, keys, ...extractCurveExtrapolation(curveNode) });
             }
         }
     }
@@ -353,8 +386,7 @@ function extractCurves(curveNodeId, objectMap) {
         for (let i = 0; i < ooChildren.length && i < 3; i++) {
             const keys = extractKeyframes(ooChildren[i].node);
             if (keys.length > 0) {
-                const isSampled = isSampledAnimationCurve(ooChildren[i].node, keys);
-                curves.push({ channel: channelNames[i], keys: isSampled ? makeLinearSampleKeys(keys) : keys, isSampled });
+                curves.push({ channel: channelNames[i], keys, ...extractCurveExtrapolation(ooChildren[i].node) });
             }
         }
     }
@@ -387,11 +419,11 @@ function extractKeyframes(curveNode) {
     if (!keyTimeNode || !keyValueNode) {
         return [];
     }
-    const keyTimes = toInt64Array(keyTimeNode.properties[0]?.value);
-    const keyValues = toFloat32Array(keyValueNode.properties[0]?.value);
-    const keyAttrFlags = toInt32Array(findChildByName(curveNode, "KeyAttrFlags")?.properties[0]?.value);
-    const keyAttrData = toFloat32Array(findChildByName(curveNode, "KeyAttrDataFloat")?.properties[0]?.value);
-    const keyAttrRefCount = toInt32Array(findChildByName(curveNode, "KeyAttrRefCount")?.properties[0]?.value);
+    const keyTimes = toInt64Array(getNodeArray(keyTimeNode));
+    const keyValues = toFloat32Array(getNodeArray(keyValueNode));
+    const keyAttrFlags = toInt32Array(getNodeArray(findChildByName(curveNode, "KeyAttrFlags")));
+    const keyAttrData = toFloat32Array(getNodeArray(findChildByName(curveNode, "KeyAttrDataFloat")));
+    const keyAttrRefCount = toInt32Array(getNodeArray(findChildByName(curveNode, "KeyAttrRefCount")));
     if (!keyTimes || !keyValues) {
         return [];
     }
@@ -399,109 +431,50 @@ function extractKeyframes(curveNode) {
         return [];
     }
     const keyAttributeIndices = buildKeyAttributeIndices(keyTimes.length, keyAttrFlags, keyAttrRefCount);
-    const keys = [];
-    for (let i = 0; i < keyTimes.length; i++) {
+    return buildKeyframes(keyTimes, keyValues, (i) => {
         const attrIndex = keyAttributeIndices[i];
         const flag = attrIndex >= 0 ? (keyAttrFlags?.[attrIndex] ?? 0) : 0;
         const dataOffset = attrIndex * KEY_ATTR_DATA_STRIDE;
-        keys.push({
-            time: Number(keyTimes[i]) / FBX_TIME_UNIT,
-            value: keyValues[i],
-            interpolation: getInterpolationType(flag),
-            constantMode: (flag & 0x00000100) !== 0 ? "next" : "standard",
-            rightSlope: getFiniteKeyAttrData(keyAttrData, dataOffset),
-            nextLeftSlope: getFiniteKeyAttrData(keyAttrData, dataOffset + 1),
-        });
-    }
-    return keys;
+        return {
+            flags: flag,
+            data: [
+                getFiniteKeyAttrData(keyAttrData, dataOffset) ?? 0,
+                getFiniteKeyAttrData(keyAttrData, dataOffset + 1) ?? 0,
+                getFiniteKeyAttrData(keyAttrData, dataOffset + 2) ?? 0,
+                getFiniteKeyAttrData(keyAttrData, dataOffset + 3) ?? 0,
+            ],
+        };
+    });
 }
-function isSampledAnimationCurve(curveNode, keys) {
-    const rawName = getPropertyValue(curveNode, 1) ?? "";
-    return cleanFBXName(rawName) === "FbxMayaSample Curve" || isFrameBakedSampledCurve(keys);
+function extractCurveExtrapolation(curveNode) {
+    const read = (name) => {
+        const node = findChildByName(curveNode, name);
+        return parseExtrapolation(findChildByName(node ?? curveNode, "Type")?.properties[0]?.value, findChildByName(node ?? curveNode, "Repetition")?.properties[0]?.value);
+    };
+    return { preExtrapolation: read("Pre-Extrapolation"), postExtrapolation: read("Post-Extrapolation") };
 }
-/**
- * Determines whether a key sequence appears to be a uniformly frame-baked sampled curve.
- * @param keys - Keyframes to inspect
- * @returns true if the keys look like sampled frame data rather than authored interpolation
- */
-export function isFrameBakedSampledCurve(keys) {
-    if (keys.length < SAMPLED_CURVE_MIN_KEY_COUNT) {
-        return false;
-    }
-    const deltas = [];
-    for (let i = 1; i < keys.length; i++) {
-        const delta = keys[i].time - keys[i - 1].time;
-        if (!(delta > 0)) {
-            return false;
-        }
-        deltas.push(delta);
-    }
-    const averageDelta = deltas.reduce((sum, delta) => sum + delta, 0) / deltas.length;
-    if (averageDelta > SAMPLED_CURVE_MAX_INTERVAL_SECONDS) {
-        return false;
-    }
-    const uniformTolerance = Math.max(1e-6, averageDelta * SAMPLED_CURVE_UNIFORM_TOLERANCE_RATIO);
-    if (deltas.some((delta) => Math.abs(delta - averageDelta) > uniformTolerance)) {
-        return false;
-    }
-    const sampledFps = 1 / averageDelta;
-    const matchesCommonFps = SAMPLED_CURVE_COMMON_FPS.some((fps) => Math.abs(sampledFps - fps) <= Math.max(0.25, fps * 0.02));
-    if (!matchesCommonFps) {
-        return false;
-    }
-    return !hasMeaningfulCubicTangents(keys);
-}
-function makeLinearSampleKeys(keys) {
-    return keys.map((key) => ({
-        time: key.time,
-        value: key.value,
-        interpolation: "linear",
-    }));
-}
-function hasMeaningfulCubicTangents(keys) {
-    let hasCubicSegment = false;
-    let hasCompleteTangents = true;
-    let allSlopesDegenerate = true;
-    let minValue = Number.POSITIVE_INFINITY;
-    let maxValue = Number.NEGATIVE_INFINITY;
-    let maxLinearDeviation = 0;
-    for (const key of keys) {
-        minValue = Math.min(minValue, key.value);
-        maxValue = Math.max(maxValue, key.value);
-    }
-    for (let i = 0; i < keys.length - 1; i++) {
-        const key = keys[i];
-        const nextKey = keys[i + 1];
-        if (key.interpolation !== "cubic") {
-            continue;
-        }
-        hasCubicSegment = true;
-        const segmentDuration = nextKey.time - key.time;
-        if (!(segmentDuration > 0)) {
-            continue;
-        }
-        const linearSlope = (nextKey.value - key.value) / segmentDuration;
-        const rightSlope = key.rightSlope;
-        const nextLeftSlope = key.nextLeftSlope;
-        if (rightSlope === undefined || nextLeftSlope === undefined) {
-            hasCompleteTangents = false;
-            continue;
-        }
-        if (Math.abs(rightSlope) > SAMPLED_CURVE_DEGENERATE_SLOPE_ABSOLUTE || Math.abs(nextLeftSlope) > SAMPLED_CURVE_DEGENERATE_SLOPE_ABSOLUTE) {
-            allSlopesDegenerate = false;
-        }
-        for (const t of [0.25, 0.5, 0.75]) {
-            const cubic = cubicHermite(key.value, nextKey.value, rightSlope, nextLeftSlope, segmentDuration, t);
-            const linear = key.value + t * segmentDuration * linearSlope;
-            maxLinearDeviation = Math.max(maxLinearDeviation, Math.abs(cubic - linear));
-        }
+function makeLayerBlend(blendMode, weight, rotationAccumulationMode, scaleAccumulationMode) {
+    let blended = false;
+    let additive = false;
+    switch (blendMode) {
+        case 0:
+            blended = true;
+            additive = true;
+            break;
+        case 2:
+            blended = true;
+            break;
+        default:
+            break;
+    }
+    let w = weight / 100;
+    if (w < 0) {
+        w = 0;
     }
-    if (!hasCubicSegment || !hasCompleteTangents || allSlopesDegenerate) {
-        return false;
+    if (w > 0.99999) {
+        w = 1;
     }
-    const range = maxValue - minValue;
-    const deviationTolerance = Math.max(SAMPLED_CURVE_LINEAR_DEVIATION_ABSOLUTE, range * SAMPLED_CURVE_LINEAR_DEVIATION_RATIO);
-    return maxLinearDeviation > deviationTolerance;
+    return { blended, additive, composeRotation: rotationAccumulationMode === 0, composeScale: scaleAccumulationMode === 0, weight: w };
 }
 /**
  * Samples an FBX animation curve at a specific time.
@@ -513,36 +486,7 @@ export function sampleFBXCurveAtTime(curveData, time) {
     if (!curveData || curveData.keys.length === 0) {
         return null;
     }
-    const keys = curveData.keys;
-    if (time <= keys[0].time) {
-        return keys[0].value;
-    }
-    if (time >= keys[keys.length - 1].time) {
-        return keys[keys.length - 1].value;
-    }
-    for (let i = 0; i < keys.length - 1; i++) {
-        const key = keys[i];
-        const nextKey = keys[i + 1];
-        if (time < key.time || time > nextKey.time) {
-            continue;
-        }
-        if (nextKey.time === key.time) {
-            return key.value;
-        }
-        if (key.interpolation === "constant") {
-            return key.constantMode === "next" ? nextKey.value : key.value;
-        }
-        const segmentDuration = nextKey.time - key.time;
-        const t = (time - key.time) / segmentDuration;
-        if (key.interpolation === "cubic" && !curveData.isSampled) {
-            const linearSlope = (nextKey.value - key.value) / segmentDuration;
-            const rightSlope = key.rightSlope ?? linearSlope;
-            const nextLeftSlope = key.nextLeftSlope ?? linearSlope;
-            return cubicHermite(key.value, nextKey.value, rightSlope, nextLeftSlope, segmentDuration, t);
-        }
-        return key.value + t * (nextKey.value - key.value);
-    }
-    return keys[keys.length - 1].value;
+    return evaluateCurve(curveData, time, curveData.keys[0].value);
 }
 // ── Utilities ──────────────────────────────────────────────────────────────────
 function toInt64Array(value) {
@@ -617,18 +561,6 @@ function buildKeyAttributeIndices(keyCount, keyAttrFlags, keyAttrRefCount) {
     }
     return Array.from({ length: keyCount }, (_, i) => Math.min(i, keyAttrFlags.length - 1));
 }
-function getInterpolationType(flag) {
-    if ((flag & 0x00000008) !== 0) {
-        return "cubic";
-    }
-    if ((flag & 0x00000004) !== 0) {
-        return "linear";
-    }
-    if ((flag & 0x00000002) !== 0) {
-        return "constant";
-    }
-    return "linear";
-}
 function getFiniteKeyAttrData(keyAttrData, index) {
     if (!keyAttrData || index < 0 || index >= keyAttrData.length) {
         return undefined;
@@ -636,13 +568,478 @@ function getFiniteKeyAttrData(keyAttrData, index) {
     const value = keyAttrData[index];
     return Number.isFinite(value) ? value : undefined;
 }
-function cubicHermite(value0, value1, slope0, slope1, segmentDuration, t) {
-    const t2 = t * t;
-    const t3 = t2 * t;
-    const h00 = 2 * t3 - 3 * t2 + 1;
-    const h10 = t3 - 2 * t2 + t;
-    const h01 = -2 * t3 + 3 * t2;
-    const h11 = t3 - t2;
-    return h00 * value0 + h10 * segmentDuration * slope0 + h01 * value1 + h11 * segmentDuration * slope1;
+// ── Legacy Takes (FBX 5.x / 6.x) ───────────────────────────────────────────────
+/**
+ * Pre-7000 files store animation in a top-level `Takes` block instead of AnimationStack/Layer/CurveNode objects:
+ *
+ *   Takes: { Take: "name" { LocalTime: start, stop
+ *     Model: "Model::joint1" { Channel: "Transform" { Channel: "T" { Channel: "X" { Default, KeyVer, KeyCount, Key } } } } } }
+ *
+ * Each take becomes one animation stack with a single layer. Models are matched through the same legacy string ids
+ * that the connection resolver synthesizes for 6.x objects.
+ */
+export function extractLegacyTakes(doc, objectMap, rebaseKeyframes = true) {
+    const takesNode = findDocumentNode(doc, "Takes");
+    if (!takesNode) {
+        return [];
+    }
+    // Take entries name models by their full "Class::Name" string; older writers may use the bare name.
+    const legacyIds = new Map();
+    const legacyIdsByCleanName = new Map();
+    for (const entry of objectMap.objectEntries) {
+        if (entry.legacyName !== undefined && !entry.synthetic && !legacyIds.has(entry.legacyName)) {
+            legacyIds.set(entry.legacyName, entry.id);
+            const clean = cleanFBXName(entry.legacyName);
+            if (!legacyIdsByCleanName.has(clean)) {
+                legacyIdsByCleanName.set(clean, entry.id);
+            }
+        }
+    }
+    const stacks = [];
+    let syntheticId = -1000000;
+    for (const take of takesNode.children) {
+        if (take.name !== "Take") {
+            continue;
+        }
+        const name = cleanFBXName(getPropertyValue(take, 0) ?? "Take");
+        const timeSpan = readLegacyTimeSpan(findChildByName(take, "LocalTime")) ?? readLegacyTimeSpan(findChildByName(take, "ReferenceTime"));
+        const curveNodes = [];
+        const unsupportedCurveNodes = [];
+        let minTime = Infinity;
+        let maxTime = -Infinity;
+        const track = (curves) => {
+            for (const curve of curves) {
+                for (const key of curve.keys) {
+                    if (key.time < minTime) {
+                        minTime = key.time;
+                    }
+                    if (key.time > maxTime) {
+                        maxTime = key.time;
+                    }
+                }
+            }
+        };
+        for (const model of take.children) {
+            if (model.name !== "Model") {
+                continue;
+            }
+            const rawModelName = getPropertyValue(model, 0) ?? "";
+            const targetModelId = legacyIds.get(rawModelName) ?? legacyIdsByCleanName.get(cleanFBXName(rawModelName));
+            if (targetModelId === undefined) {
+                continue;
+            }
+            for (const channel of model.children) {
+                if (channel.name !== "Channel") {
+                    continue;
+                }
+                const channelName = getPropertyValue(channel, 0) ?? "";
+                if (channelName === "Transform") {
+                    for (const sub of channel.children) {
+                        if (sub.name !== "Channel") {
+                            continue;
+                        }
+                        const subName = getPropertyValue(sub, 0);
+                        if (subName !== "T" && subName !== "R" && subName !== "S") {
+                            continue;
+                        }
+                        const curves = readLegacyCompoundChannel(sub, doc.version);
+                        if (curves.length > 0) {
+                            track(curves);
+                            curveNodes.push({ type: subName, targetModelId, curves, layerIndex: 0 });
+                        }
+                    }
+                }
+                else {
+                    const curves = readLegacyCompoundChannel(channel, doc.version);
+                    if (curves.length > 0) {
+                        track(curves);
+                        // Blend shape weights are channels named after the shape ("name (Shape)" before 6.0).
+                        const shapeChannelId = findLegacyShapeChannel(objectMap, targetModelId, channelName);
+                        if (shapeChannelId !== undefined) {
+                            curveNodes.push({ type: "DeformPercent", targetModelId: shapeChannelId, curves, layerIndex: 0 });
+                            continue;
+                        }
+                        // Light and camera properties live on the synthesized node attribute.
+                        const attributeId = LEGACY_ATTRIBUTE_CHANNELS.has(channelName) ? getChildren(objectMap, targetModelId, "NodeAttribute")[0]?.id : undefined;
+                        unsupportedCurveNodes.push({
+                            type: channelName,
+                            id: syntheticId--,
+                            layerIndex: 0,
+                            targetId: attributeId ?? targetModelId,
+                            propertyName: channelName,
+                            curveCount: curves.length,
+                            curves,
+                            defaultValues: {},
+                        });
+                    }
+                }
+            }
+        }
+        if (curveNodes.length === 0 && unsupportedCurveNodes.length === 0) {
+            continue;
+        }
+        const layer = {
+            name: "BaseLayer",
+            weight: 100,
+            normalizedWeight: 1,
+            blendMode: 0,
+            blend: makeLayerBlend(0, 100, 0, 0),
+            curveNodes,
+            unsupportedCurveNodes,
+            diagnostics: [],
+        };
+        stacks.push(finalizeAnimStack(name, [layer], curveNodes, unsupportedCurveNodes, [], minTime, maxTime, timeSpan, rebaseKeyframes));
+    }
+    return stacks;
+}
+/** Take channel names that animate light or camera attribute properties rather than the model itself. */
+const LEGACY_ATTRIBUTE_CHANNELS = new Set([
+    "Color",
+    "Intensity",
+    "OuterAngle",
+    "InnerAngle",
+    "ConeAngle",
+    "HotSpot",
+    "FieldOfView",
+    "FieldOfViewX",
+    "FieldOfViewY",
+    "FocalLength",
+    "NearPlane",
+    "FarPlane",
+    "OrthoZoom",
+    "Roll",
+    "FilmWidth",
+    "FilmHeight",
+]);
+/** Finds the synthesized BlendShapeChannel of a legacy model whose shape is named like the take channel. */
+function findLegacyShapeChannel(objectMap, modelId, channelName) {
+    const suffix = " (Shape)";
+    const name = channelName.endsWith(suffix) ? channelName.slice(0, -suffix.length) : channelName;
+    for (const geometry of getChildren(objectMap, modelId, "Geometry")) {
+        for (const deformer of getChildren(objectMap, geometry.id, "Deformer")) {
+            if (getPropertyValue(deformer.node, 2) !== "BlendShape") {
+                continue;
+            }
+            for (const channel of getChildren(objectMap, deformer.id, "Deformer")) {
+                if (getPropertyValue(channel.node, 2) === "BlendShapeChannel" && cleanFBXName(getPropertyValue(channel.node, 1) ?? "") === name) {
+                    return channel.id;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function readLegacyTimeSpan(node) {
+    if (!node) {
+        return null;
+    }
+    const start = fbxTimeToSeconds(node.properties[0]?.value);
+    const stop = fbxTimeToSeconds(node.properties[1]?.value);
+    return start !== null && stop !== null ? { start, stop } : null;
+}
+/** A channel either holds keys directly (scalar property) or has X/Y/Z child channels (vector property). */
+function readLegacyCompoundChannel(node, version) {
+    const hasKeys = (n) => n.children.some((c) => c.name === "Key" || c.name === "Default");
+    if (hasKeys(node)) {
+        const keys = decodeLegacyKeys(node, version);
+        return keys.length > 0 ? [{ channel: "d|X", keys, ...extractCurveExtrapolation(node) }] : [];
+    }
+    const curves = [];
+    for (const child of node.children) {
+        if (child.name !== "Channel" || !hasKeys(child)) {
+            continue;
+        }
+        const axis = getPropertyValue(child, 0) ?? "X";
+        const keys = decodeLegacyKeys(child, version);
+        if (keys.length > 0) {
+            curves.push({ channel: `d|${axis}`, keys, ...extractCurveExtrapolation(child) });
+        }
+        if (curves.length === 3) {
+            break;
+        }
+    }
+    return curves;
+}
+/**
+ * Decodes the heterogeneous legacy `Key:` list (int64 times, double values and bare mode characters).
+ * The layout per key is `time, value, mode[, params...]`, mirroring the FBX SDK's pre-7000 key encoding.
+ */
+function decodeLegacyKeys(channel, version) {
+    const keyNode = findChildByName(channel, "Key");
+    if (!keyNode) {
+        return [];
+    }
+    const vals = keyNode.properties.map((p) => p.value);
+    const num = (v) => (typeof v === "number" ? v : typeof v === "boolean" ? (v ? 1 : 0) : NaN);
+    const chr = (v) => (typeof v === "string" ? v : typeof v === "number" ? String.fromCharCode(v) : typeof v === "boolean" ? (v ? "\x01" : "\0") : "?");
+    let keyVer = toNumber(findChildByName(channel, "KeyVer")?.properties[0]?.value) ?? 0;
+    if (keyVer <= 0) {
+        keyVer = version < 5000 ? 4003 : version < 6000 ? 4004 : 4005;
+    }
+    const keyCount = toNumber(findChildByName(channel, "KeyCount")?.properties[0]?.value) ?? 0;
+    const times = [];
+    const values = [];
+    const interp = [];
+    const constNext = [];
+    const leftSlope = [];
+    const rightSlope = [];
+    const leftWeight = [];
+    const rightWeight = [];
+    const autoFlag = [];
+    let pendingLeft = 0;
+    let pendingLeftWeight = 1 / 3;
+    let p = 0;
+    for (let i = 0; i < keyCount; i++) {
+        if (p + 3 > vals.length) {
+            break;
+        }
+        const time = num(vals[p]) / FBX_TIME_UNIT;
+        const value = num(vals[p + 1]);
+        const mode = chr(vals[p + 2]);
+        p += 3;
+        let right = 0;
+        let nextLeft = 0;
+        let weightRight = 1 / 3;
+        let nextWeightLeft = 1 / 3;
+        let auto = false;
+        let kind = "cubic";
+        let isNext = false;
+        if (mode === "U") {
+            const slopeMode = chr(vals[p]);
+            p += 1;
+            let numWeights = 1;
+            if (slopeMode === "s" || slopeMode === "b") {
+                right = num(vals[p]);
+                nextLeft = num(vals[p + 1]);
+                p += 2;
+                if (keyVer === 4003) {
+                    numWeights = 0;
+                }
+            }
+            else if (slopeMode === "a") {
+                auto = true;
+                if (keyVer <= 4004) {
+                    numWeights = 0;
+                }
+            }
+            else if (slopeMode === "p" || slopeMode === "q") {
+                auto = true;
+                p += 2;
+                numWeights = keyVer <= 4004 ? 1 : 2;
+            }
+            else if (slopeMode === "t") {
+                auto = true;
+                p += 3;
+                numWeights = 0;
+            }
+            else if (slopeMode === "d") {
+                auto = true;
+                p += 1;
+            }
+            else {
+                break;
+            }
+            for (; numWeights > 0; numWeights--) {
+                const weightMode = chr(vals[p]);
+                p += 1;
+                if (weightMode === "n" || weightMode === "c") {
+                    // automatic weights
+                }
+                else if (weightMode === "a") {
+                    weightRight = num(vals[p]);
+                    nextWeightLeft = num(vals[p + 1]);
+                    p += 2;
+                }
+                else if (weightMode === "l") {
+                    nextWeightLeft = num(vals[p]);
+                    p += 1;
+                }
+                else if (weightMode === "r") {
+                    weightRight = num(vals[p]);
+                    p += 1;
+                }
+                else {
+                    p = vals.length;
+                    break;
+                }
+            }
+        }
+        else if (mode === "L") {
+            kind = "linear";
+        }
+        else if (mode === "C") {
+            kind = "constant";
+            if (keyVer >= 4004) {
+                isNext = chr(vals[p]) === "n";
+                p += 1;
+            }
+        }
+        else {
+            break;
+        }
+        times.push(time);
+        values.push(value);
+        interp.push(kind);
+        constNext.push(isNext);
+        leftSlope.push(pendingLeft);
+        rightSlope.push(right);
+        leftWeight.push(pendingLeftWeight);
+        rightWeight.push(weightRight);
+        autoFlag.push(auto);
+        pendingLeft = nextLeft;
+        pendingLeftWeight = nextWeightLeft;
+    }
+    // Resolve automatic and linear tangents now that neighbouring keys are known.
+    for (let i = 0; i < times.length; i++) {
+        if (autoFlag[i]) {
+            const s = i > 0 && i + 1 < times.length
+                ? solveLegacyAutoTangent(times[i - 1], times[i], times[i + 1], values[i - 1], values[i], values[i + 1], leftWeight[i], rightWeight[i])
+                : 0;
+            leftSlope[i] = s;
+            rightSlope[i] = s;
+        }
+        if (interp[i] === "linear" && i + 1 < times.length) {
+            const dt = times[i + 1] - times[i];
+            const s = dt > 0 ? (values[i + 1] - values[i]) / dt : 0;
+            rightSlope[i] = s;
+            if (!autoFlag[i + 1]) {
+                leftSlope[i + 1] = s;
+            }
+        }
+    }
+    return keyframesFromSlopes(times, values, interp, constNext, leftSlope, rightSlope, leftWeight, rightWeight);
+}
+/** Time-independent auto tangent with progressive clamping and 1/3 weights, as the SDK computes legacy 'a' keys. */
+function solveLegacyAutoTangent(t0, t1, t2, v0, v1, v2, weightLeft, weightRight) {
+    if (!(t2 > t0)) {
+        return 0;
+    }
+    const slope = (v2 - v0) / (t2 - t0);
+    const sign = slope >= 0 ? 1 : -1;
+    let abs = sign * slope;
+    const rangeLeft = weightLeft * (t1 - t0);
+    const rangeRight = weightRight * (t2 - t1);
+    let maxLeft = rangeLeft > 0 ? (sign * (v1 - v0)) / rangeLeft : 0;
+    let maxRight = rangeRight > 0 ? (sign * (v2 - v1)) / rangeRight : 0;
+    if (!(maxLeft > 0)) {
+        maxLeft = 0;
+    }
+    if (!(maxRight > 0)) {
+        maxRight = 0;
+    }
+    abs = Math.min(abs, maxLeft, maxRight);
+    return sign * abs;
+}
+// ── Layered evaluation ─────────────────────────────────────────────────────────
+/**
+ * Evaluates one transform channel (T, R or S) of a target at `time`, blending every animation layer of the stack the
+ * way the FBX SDK does: the first layer animating the channel replaces the static value, later layers are combined
+ * according to their blend mode, weight and accumulation modes.
+ * @param curveNodes - Curve nodes targeting this model (any layers, any types)
+ * @param layers - Stack layers, in order
+ * @param type - Channel to evaluate
+ * @param staticValue - Value when nothing animates the channel
+ * @param rotationOrder - Rotation order of the target (for rotation composition)
+ * @param time - Time in seconds
+ */
+export function evaluateLayeredChannel(curveNodes, layers, type, staticValue, rotationOrder, time) {
+    let result = [staticValue[0], staticValue[1], staticValue[2]];
+    for (let layerIndex = 0; layerIndex < Math.max(layers.length, 1); layerIndex++) {
+        const node = curveNodes.find((cn) => cn.type === type && cn.layerIndex === layerIndex);
+        if (!node) {
+            continue;
+        }
+        const defaults = node.defaultValues ?? result;
+        const value = [
+            evaluateCurve(node.curves.find((c) => c.channel === "d|X"), time, defaults[0]),
+            evaluateCurve(node.curves.find((c) => c.channel === "d|Y"), time, defaults[1]),
+            evaluateCurve(node.curves.find((c) => c.channel === "d|Z"), time, defaults[2]),
+        ];
+        const layer = layers[layerIndex];
+        // The base layer replaces the static value; every other layer blends onto the running result, even when the
+        // base layer does not animate this channel (then it blends with the static value), as in the SDK.
+        if (layerIndex === 0 || !layer) {
+            result = value;
+        }
+        else {
+            let blend = layer.blend;
+            if (layer.weightCurve && blend.blended) {
+                let w = evaluateCurve(layer.weightCurve, time, layer.weight) / 100;
+                w = w < 0 ? 0 : w > 0.99999 ? 1 : w;
+                blend = { ...blend, weight: w };
+            }
+            result = combineLayerValue(result, value, blend, type, rotationOrder);
+        }
+    }
+    return result;
+}
+/**
+ * Evaluates an animated property through the animation layers: the base layer replaces the static value, every
+ * further layer blends onto the running result according to its blend mode and (possibly animated) weight, like
+ * `evaluateLayeredChannel` does for transforms.
+ * @param sources - Per-layer curves of the property
+ * @param layers - Stack layers, in order
+ * @param channels - Channel names to evaluate, in output order
+ * @param staticValue - Value per channel when nothing animates it
+ * @param time - Time in seconds
+ * @returns One value per channel
+ */
+export function evaluateLayeredProperty(sources, layers, channels, staticValue, time) {
+    const result = channels.map((_, i) => staticValue[i] ?? 0);
+    for (let layerIndex = 0; layerIndex < Math.max(layers.length, 1); layerIndex++) {
+        const source = sources.find((s) => s.layerIndex === layerIndex);
+        if (!source) {
+            continue;
+        }
+        const value = channels.map((channel, i) => evaluateCurve(source.curves.find((c) => c.channel === channel), time, source.defaultValues?.[channel] ?? result[i]));
+        const layer = layers[layerIndex];
+        if (layerIndex === 0 || !layer) {
+            for (let i = 0; i < result.length; i++) {
+                result[i] = value[i];
+            }
+            continue;
+        }
+        let blend = layer.blend;
+        if (layer.weightCurve && blend.blended) {
+            let w = evaluateCurve(layer.weightCurve, time, layer.weight) / 100;
+            w = w < 0 ? 0 : w > 0.99999 ? 1 : w;
+            blend = { ...blend, weight: w };
+        }
+        for (let i = 0; i < result.length; i++) {
+            result[i] = combineLayerValue([result[i], 0, 0], [value[i], 0, 0], blend, "other", 0)[0];
+        }
+    }
+    return result;
+}
+/**
+ * True when every curve of the given channel is inside a constant (stepped) segment at `time`, so a baked key at
+ * that time should hold its value instead of interpolating towards the next sample.
+ */
+export function isChannelSteppedAt(curveNodes, type, time) {
+    let sawCurve = false;
+    for (const node of curveNodes) {
+        if (node.type !== type) {
+            continue;
+        }
+        for (const curve of node.curves) {
+            const keys = curve.keys;
+            if (keys.length < 2) {
+                continue;
+            }
+            sawCurve = true;
+            // Outside the key range the curve extrapolates continuously; only interior constant segments step.
+            if (time < keys[0].time || time >= keys[keys.length - 1].time) {
+                return false;
+            }
+            let i = 0;
+            while (i + 1 < keys.length && keys[i + 1].time <= time) {
+                i++;
+            }
+            if (keys[i].interpolation !== "constant") {
+                return false;
+            }
+        }
+    }
+    return sawCurve;
 }
 //# sourceMappingURL=animation.js.map