@babylonjs/loaders 9.26.0 → 9.26.1

package/FBX/fbxFileLoader.pure.js

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/naming-convention, jsdoc/require-param, jsdoc/require-returns */
 import { RegisterSceneLoaderPlugin, } from "@babylonjs/core/Loading/sceneLoader.js";
 import { Mesh } from "@babylonjs/core/Meshes/mesh.pure.js";
+import { LinesMesh } from "@babylonjs/core/Meshes/linesMesh.pure.js";
 import { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
 import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
 import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.pure.js";
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.pure.js";
 import { Material } from "@babylonjs/core/Materials/material.js";
 import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.pure.js";
 import { Texture } from "@babylonjs/core/Materials/Textures/texture.pure.js";
@@ -26,8 +28,10 @@ import { GetMimeType } from "@babylonjs/core/Misc/fileTools.pure.js";
 import { parseBinaryFBX } from "./parsers/fbxBinaryParser.js";
 import { parseAsciiFBX } from "./parsers/fbxAsciiParser.js";
 import { interpretFBX } from "./interpreter/fbxInterpreter.js";
-import { sampleFBXCurveAtTime } from "./interpreter/animation.js";
-import { computeFBXGeometricDeltaMatrix, computeFBXGeometricMatrix, computeFBXGeometricNormalMatrix, computeFBXLocalMatrix } from "./interpreter/transform.js";
+import { FBXConstraintBehavior } from "./fbxConstraintBehavior.js";
+import { isPbrShaderType, mapColor, mapScalar } from "./interpreter/materialModel.js";
+import { evaluateLayeredChannel, evaluateLayeredProperty, isChannelSteppedAt, sampleFBXCurveAtTime, } from "./interpreter/animation.js";
+import { computeFBXGeometricDeltaMatrix, computeFBXGeometricMatrix, computeFBXGeometricNormalMatrix, computeFBXLocalMatrix, eulerToMatrix, eulerToMatrixXYZ, } from "./interpreter/transform.js";
 import { FBXFileLoaderMetadata } from "./fbxFileLoader.metadata.js";
 const FBX_ASCII_MAGIC = "; FBX";
 const FBX_BINARY_MAGIC = "Kaydara FBX Binary";
@@ -53,8 +57,36 @@ export class FBXFileLoader {
         this._bindRestBones = new WeakSet();
         this._sourceBonesBySkeleton = new WeakMap();
         this._scaleCompensationHelpersBySkeleton = new WeakMap();
+        /** Frame rate of the file being loaded (GlobalSettings TimeMode); animation is baked at this rate. */
+        this._frameRate = 30;
+        /** Layers of the animation stack currently being converted; used by the transform samplers. */
+        this._activeLayers = [];
+        /** Parent model per model id, for inherit-mode aware sampling. */
+        this._parentModelById = new Map();
+        /** Curve nodes per model id for the stack currently being converted. */
+        this._curveNodesByModelId = new Map();
+        /** Helper nodes inserted above models whose InheritType is not RSrs. */
+        this._inheritScaleHelpers = new Map();
+        /** First mesh built per (geometry, geometric transform), for geometry sharing between instances. */
+        this._meshByGeometryKey = new Map();
+        /** Instance mesh -> source mesh whose geometry it shares. */
+        this._instanceSource = new Map();
+        /** Property curve nodes that were mapped onto Babylon animations; their "not evaluated" diagnostics are dropped. */
+        this._evaluatedCurveNodeIds = new Set();
+        this._rigBoneModelIds = new Set();
+        const full = options.preset === "full";
         this._options = {
+            preset: full ? "full" : "compatible",
             normalMapCoordinateSystem: options.normalMapCoordinateSystem ?? "y-up",
+            materials: options.materials ?? (full ? "auto" : "standard"),
+            unitScale: options.unitScale ?? "preserve",
+            shareGeometry: options.shareGeometry ?? full,
+            onWarning: options.onWarning ?? (() => { }),
+            nurbsSubdivision: options.nurbsSubdivision ?? 0,
+            curves: options.curves ?? (full ? "lines" : "skip"),
+            constraints: options.constraints ?? (full ? "apply" : "metadata"),
+            rebaseAnimations: options.rebaseAnimations ?? !full,
+            attachCamerasAndLights: options.attachCamerasAndLights ?? full,
         };
     }
     /**
@@ -76,9 +108,9 @@ export class FBXFileLoader {
      * @returns A promise containing the loaded meshes, particle systems, skeletons, animation groups, transform nodes, geometries, and lights
      */
     async importMeshAsync(meshesNames, scene, data, rootUrl, _onProgress, _fileName) {
-        const doc = this._parse(data);
-        const fbxScene = interpretFBX(doc);
-        return this._buildScene(fbxScene, scene, rootUrl, meshesNames);
+        const fbxScene = this._parseAndInterpret(data);
+        const result = this._buildScene(fbxScene, scene, rootUrl, meshesNames);
+        return result;
     }
     /**
      * Loads all FBX content into the scene.
@@ -90,8 +122,7 @@ export class FBXFileLoader {
      * @returns A promise that resolves when loading is complete
      */
     async loadAsync(scene, data, rootUrl, _onProgress, _fileName) {
-        const doc = this._parse(data);
-        const fbxScene = interpretFBX(doc);
+        const fbxScene = this._parseAndInterpret(data);
         this._buildScene(fbxScene, scene, rootUrl, null);
     }
     /**
@@ -104,8 +135,7 @@ export class FBXFileLoader {
      * @returns A promise containing the loaded asset container
      */
     async loadAssetContainerAsync(scene, data, rootUrl, _onProgress, _fileName) {
-        const doc = this._parse(data);
-        const fbxScene = interpretFBX(doc);
+        const fbxScene = this._parseAndInterpret(data);
         const container = new AssetContainer(scene);
         // Build the scene into a temporary holder, then move results to container
         const result = this._buildScene(fbxScene, scene, rootUrl, null);
@@ -134,6 +164,10 @@ export class FBXFileLoader {
             this._addTextureToContainer(texture, container);
         }
         for (const mesh of result.meshes) {
+            // Lines meshes own an internal colour shader; it is not an asset of the file.
+            if (mesh instanceof LinesMesh) {
+                continue;
+            }
             this._addMaterialToContainer(mesh.material, container);
         }
         // Remove all added objects from the scene (container owns them)
@@ -142,6 +176,17 @@ export class FBXFileLoader {
         return container;
     }
     // ── Parsing ────────────────────────────────────────────────────────────
+    /**
+     * Parses and interprets the file. Parsing is synchronous, so no progress events are emitted: the scene loader's
+     * progress callback reports download bytes and must not be fed synthetic counts.
+     */
+    _parseAndInterpret(data) {
+        const doc = this._parse(data);
+        return interpretFBX(doc, {
+            nurbsSubdivision: this._options.nurbsSubdivision > 0 ? this._options.nurbsSubdivision : undefined,
+            rebaseKeyframes: this._options.rebaseAnimations,
+        });
+    }
     _parse(data) {
         if (data instanceof ArrayBuffer) {
             return this._parseFromArrayBuffer(data);
@@ -163,9 +208,11 @@ export class FBXFileLoader {
         if (header.startsWith(FBX_BINARY_MAGIC)) {
             return parseBinaryFBX(buffer);
         }
-        // Try ASCII
+        // Try ASCII. Most files start with "; FBX x.y.z project file", but the header comment is optional:
+        // some exporters start straight at FBXHeaderExtension or even at Objects.
         const text = new TextDecoder("utf-8").decode(buffer);
-        if (text.trimStart().startsWith(FBX_ASCII_MAGIC)) {
+        const head = text.substring(0, 4096);
+        if (head.trimStart().startsWith(FBX_ASCII_MAGIC) || /^\s*(?:;[^\n]*\n\s*)*(?:FBXHeaderExtension|Definitions|Objects|Connections)\s*:/.test(head)) {
             return parseAsciiFBX(text);
         }
         throw new Error("FBXFileLoader: unrecognized FBX format");
@@ -173,6 +220,8 @@ export class FBXFileLoader {
     // ── Scene Building ─────────────────────────────────────────────────────
     _buildScene(fbxScene, scene, rootUrl, meshesNames) {
         const nameFilter = this._buildNameFilter(meshesNames);
+        this._frameRate = fbxScene.frameRate > 0 ? fbxScene.frameRate : 30;
+        this._inheritScaleHelpers = new Map();
         // Create materials
         const materialCache = new Map();
         for (const matData of fbxScene.materials) {
@@ -189,6 +238,12 @@ export class FBXFileLoader {
         for (const skin of fbxScene.skins) {
             skinById.set(skin.id, skin);
         }
+        this._rigBoneModelIds = new Set();
+        for (const rig of fbxScene.rigs) {
+            for (const bone of rig.bones) {
+                this._rigBoneModelIds.add(bone.modelId);
+            }
+        }
         for (const rig of fbxScene.rigs) {
             const skeleton = this._createSkeleton(rig.id, rig.bones, scene);
             skeletons.push(skeleton);
@@ -205,13 +260,17 @@ export class FBXFileLoader {
         }
         // Collect model data for animation sampling.
         const modelIdToData = new Map();
-        const collectModelData = (models) => {
+        this._parentModelById = new Map();
+        const collectModelData = (models, parent) => {
             for (const m of models) {
                 modelIdToData.set(m.id, m);
-                collectModelData(m.children);
+                if (parent) {
+                    this._parentModelById.set(m.id, parent);
+                }
+                collectModelData(m.children, m);
             }
         };
-        collectModelData(fbxScene.rootModels);
+        collectModelData(fbxScene.rootModels, null);
         const cullingConflictMaterialIds = FBXFileLoader._collectCullingConflictMaterialIds(fbxScene.rootModels);
         const cullingMaterialCloneCache = new Map();
         // Build the FBX hierarchy under the same handedness conversion root that
@@ -223,6 +282,17 @@ export class FBXFileLoader {
             rootNode.rotation.y = Math.PI;
             rootNode.scaling.z = -1;
         }
+        // FBX units: one file unit is UnitScaleFactor centimeters.
+        const unitScale = this._options.unitScale;
+        const cmPerTargetUnit = unitScale === "preserve" ? 0 : unitScale === "meters" ? 100 : unitScale;
+        if (cmPerTargetUnit > 0 && fbxScene.unitScaleFactor > 0) {
+            const factor = fbxScene.unitScaleFactor / cmPerTargetUnit;
+            rootNode.scaling.scaleInPlace(factor);
+        }
+        rootNode.metadata = { ...(rootNode.metadata ?? {}), fbxUnitScaleFactor: fbxScene.unitScaleFactor, fbxFrameRate: fbxScene.frameRate };
+        this._meshByGeometryKey = new Map();
+        this._instanceSource = new Map();
+        this._evaluatedCurveNodeIds = new Set();
         const meshes = [];
         const transformNodes = [rootNode];
         let assetRoot = rootNode;
@@ -256,59 +326,56 @@ export class FBXFileLoader {
                     boneTransformNodes.add(transformNode);
                 }
             }
-            for (const boneData of rig.bones) {
-                if (!boneData.isCluster) {
-                    continue;
-                }
-                const boneNode = modelIdToNode.get(boneData.modelId);
-                const bone = this._getSourceBone(skeleton, boneData.index);
-                if (!boneNode || !bone) {
-                    continue;
-                }
-                // Find direct children of this bone's TransformNode that aren't bones themselves
-                for (const child of [...boneNode.getChildren()]) {
-                    const childTransform = child;
-                    if (!boneTransformNodes.has(childTransform)) {
-                        const childWorld = childTransform.computeWorldMatrix(true).clone();
-                        const boneReferenceWorld = FBXFileLoader._getBoneReferenceWorldMatrix(skeleton, bone, boneReferenceNode, skinnedMesh);
-                        const boneReferenceWorldInv = new Matrix();
-                        boneReferenceWorld.invertToRef(boneReferenceWorldInv);
-                        const childLocalToBone = childWorld.multiply(boneReferenceWorldInv);
-                        childTransform.parent = null;
-                        childTransform.attachToBone(bone, boneReferenceNode);
-                        FBXFileLoader._applyMatrixToTransform(childTransform, childLocalToBone);
-                    }
-                }
-            }
+            // Children of joints (props, end effectors, meshes) stay parented to the joint's TransformNode. Bones are
+            // linked to those nodes, so the hierarchy already follows the animation; attaching to the bone's skinning
+            // matrix would move them into the skinned mesh's space instead of the node's.
+            void boneTransformNodes;
+            void boneReferenceNode;
         }
         // Apply blend shapes (morph targets) to meshes
         if (fbxScene.blendShapes.length > 0) {
             this._applyBlendShapes(fbxScene.blendShapes, meshes, scene);
-        }
-        // Create animation groups
-        const animationGroups = [];
-        for (const animStack of fbxScene.animations) {
-            const group = this._createAnimationGroup(animStack, fbxScene.rigs, skeletonByRigId, scene, modelIdToNode, modelIdToData, meshes);
-            if (group) {
-                animationGroups.push(group);
+            for (const [instance, source] of Array.from(this._instanceSource)) {
+                if (source.morphTargetManager && !instance.morphTargetManager) {
+                    instance.morphTargetManager = source.morphTargetManager;
+                }
             }
         }
         // Create cameras
         const cameras = [];
+        const cameraByAttributeId = new Map();
         for (const camData of fbxScene.cameras) {
             const cam = this._createCamera(camData, modelIdToNode, scene);
             if (cam) {
                 cameras.push(cam);
+                cameraByAttributeId.set(camData.attributeId, cam);
             }
         }
         // Create lights
         const sceneLights = [];
+        const lightByAttributeId = new Map();
         for (const lightData of fbxScene.lights) {
             const light = this._createLight(lightData, modelIdToNode, scene);
             if (light) {
                 sceneLights.push(light);
+                lightByAttributeId.set(lightData.attributeId, light);
+            }
+        }
+        this._applyConstraints(fbxScene, modelIdToNode, rootNode, scene);
+        // Create animation groups
+        const animationGroups = [];
+        for (const animStack of fbxScene.animations) {
+            const group = this._createAnimationGroup(animStack, fbxScene.rigs, skeletonByRigId, scene, modelIdToNode, modelIdToData, meshes, {
+                cameraByAttributeId,
+                lightByAttributeId,
+                materialCache,
+            });
+            if (group) {
+                animationGroups.push(group);
             }
         }
+        // Reported last so that property curves the animation groups picked up are not flagged as unevaluated.
+        this._reportDiagnostics(fbxScene, rootNode, modelIdToNode);
         return {
             meshes,
             particleSystems: [],
@@ -398,18 +465,60 @@ export class FBXFileLoader {
         }
         return Matrix.FromValues(basisRows[0][0], basisRows[0][1], basisRows[0][2], 0, basisRows[1][0], basisRows[1][1], basisRows[1][2], 0, basisRows[2][0], basisRows[2][1], basisRows[2][2], 0, 0, 0, 0, 1);
     }
-    _buildModel(model, scene, parent, assetRoot, parentFBXWorldMatrix, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache) {
+    _buildModel(model, scene, parentNode, assetRoot, parentFBXWorldMatrix, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache) {
+        let parent = parentNode;
         const localMatrix = FBXFileLoader._computeFBXModelLocalMatrix(model);
         const fbxWorldMatrix = localMatrix.multiply(parentFBXWorldMatrix);
-        if (model.geometry && model.subType === "Mesh" && (!nameFilter || nameFilter(model.name))) {
-            // Create mesh
-            const skeleton = skeletonByGeometryId.get(model.geometry.id);
-            const skin = skinByGeometryId.get(model.geometry.id);
-            const skinBinding = skinBindingByGeometryId.get(model.geometry.id);
+        // Nodes with RrSs / Rrs inheritance do not inherit their parent's scale the normal way. Insert a helper that
+        // cancels the parent scale and re-express the local transform in that unscaled frame (see ufbx's
+        // inherit-mode evaluation). Skeleton bones with Rrs are handled by the rig code instead.
+        const parentModel = this._parentModelById.get(model.id);
+        const parentModelNode = parentModel ? modelIdToNode.get(parentModel.id) : undefined;
+        if (parent &&
+            parentModel &&
+            parentModelNode &&
+            parent === parentModelNode &&
+            model.inheritType !== 1 &&
+            !this._isRigBone(model.id) &&
+            !this._isRigBone(parentModel.id) &&
+            !(parentModel.geometry && skinByGeometryId.has(parentModel.geometry.id))) {
+            // The helper sits beside the parent and carries the parent's rotation and translation with unit scale,
+            // i.e. the parent's "unscaled" frame. This avoids inverting the parent scale (which may be zero).
+            const helper = new TransformNode(`${model.name}__fbx_inheritScale`, scene);
+            helper.parent = parentModelNode.parent;
+            helper.position.copyFrom(parentModelNode.position);
+            helper.rotationQuaternion = parentModelNode.rotationQuaternion ? parentModelNode.rotationQuaternion.clone() : Quaternion.FromEulerVector(parentModelNode.rotation);
+            helper.scaling.set(1, 1, 1);
+            transformNodes.push(helper);
+            this._inheritScaleHelpers.set(model.id, helper);
+            parent = helper;
+        }
+        if (model.geometry && model.geometry.indices.length > 0 && (!nameFilter || nameFilter(model.name))) {
+            // Create mesh. Tessellated NURBS carry no control point mapping, so their deformers are not applied
+            // (the interpreter reports them).
+            const deformable = model.geometry.controlPointIndices !== null;
+            const skeleton = deformable ? skeletonByGeometryId.get(model.geometry.id) : undefined;
+            const skin = deformable ? skinByGeometryId.get(model.geometry.id) : undefined;
+            const skinBinding = deformable ? skinBindingByGeometryId.get(model.geometry.id) : undefined;
             if (skeleton && skin) {
                 skeleton.needInitialSkinMatrix = true;
             }
-            const mesh = this._createMesh(model, model.geometry, scene, skeleton, skin, skinBinding);
+            // Models referencing the same geometry (with the same geometric transform) share one Babylon geometry.
+            const geometryKey = `${model.geometry.id}|${model.geometricTranslation.join(",")}|${model.geometricRotation.join(",")}|${model.geometricScaling.join(",")}`;
+            const source = !skeleton && this._options.shareGeometry ? this._meshByGeometryKey.get(geometryKey) : undefined;
+            let mesh;
+            if (source) {
+                mesh = source.clone(model.name, null, true);
+                mesh.sideOrientation = source.sideOrientation;
+                mesh.metadata = { ...(source.metadata ?? {}), fbxInstanceOf: source.name };
+                this._instanceSource.set(mesh, source);
+            }
+            else {
+                mesh = this._createMesh(model, model.geometry, scene, skeleton, skin, skinBinding);
+                if (!skeleton) {
+                    this._meshByGeometryKey.set(geometryKey, mesh);
+                }
+            }
             // For skinned meshes: keep bind/pose math in FBX space, but parent
             // the rendered mesh under the same conversion root as non-skinned
             // meshes. The pose matrix cancels the real FBX mesh transform only;
@@ -426,7 +535,7 @@ export class FBXFileLoader {
                 if (parent) {
                     mesh.parent = parent;
                 }
-                FBXFileLoader._applyFBXTransform(mesh, model);
+                this._applyRestTRS(mesh, model);
             }
             // Apply material(s)
             if (model.materials.length > 1 && model.geometry?.materialIndices) {
@@ -451,8 +560,21 @@ export class FBXFileLoader {
                 this._buildModel(child, scene, mesh, assetRoot, fbxWorldMatrix, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache);
             }
         }
+        else if (model.curve && this._options.curves !== "skip" && model.curve.polylines.length > 0 && (!nameFilter || nameFilter(model.name))) {
+            const lines = this._createLinesMesh(model, model.curve, scene);
+            if (parent) {
+                lines.parent = parent;
+            }
+            this._applyRestTRS(lines, model);
+            meshes.push(lines);
+            modelIdToNode.set(model.id, lines);
+            FBXFileLoader._applyModelMetadata(lines, model);
+            for (const child of model.children) {
+                this._buildModel(child, scene, lines, assetRoot, fbxWorldMatrix, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache);
+            }
+        }
         else {
-            if (model.geometry && model.subType === "Mesh" && nameFilter && !FBXFileLoader._modelSubtreeMatchesNameFilter(model, nameFilter)) {
+            if ((model.geometry || model.curve) && nameFilter && !FBXFileLoader._modelSubtreeMatchesNameFilter(model, nameFilter)) {
                 return;
             }
             // Transform node (Null type or no geometry)
@@ -461,7 +583,7 @@ export class FBXFileLoader {
                 transformNode.parent = parent;
             }
             // Apply full FBX transform chain
-            FBXFileLoader._applyFBXTransform(transformNode, model);
+            this._applyRestTRS(transformNode, model);
             transformNodes.push(transformNode);
             modelIdToNode.set(model.id, transformNode);
             FBXFileLoader._applyModelMetadata(transformNode, model);
@@ -469,6 +591,7 @@ export class FBXFileLoader {
             for (const child of model.children) {
                 this._buildModel(child, scene, transformNode, assetRoot, fbxWorldMatrix, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache);
             }
+            FBXFileLoader._applyLodGroup(model, modelIdToNode);
         }
     }
     _linkSkeletonsToTransformNodes(rigs, skeletonByRigId, modelIdToNode, transformNodes, scene) {
@@ -512,14 +635,117 @@ export class FBXFileLoader {
         return false;
     }
     static _applyModelMetadata(node, model) {
-        if (!model.customProperties && model.diagnostics.length === 0) {
+        if (!model.customProperties && model.diagnostics.length === 0 && !model.displayLayer && !model.lodGroup) {
             return;
         }
         node.metadata = {
             ...(node.metadata ?? {}),
-            ...(model.customProperties ? { fbxCustomProperties: model.customProperties } : {}),
+            ...(model.customProperties ? { fbxCustomProperties: model.customProperties, fbxUserProperties: model.customProperties } : {}),
             ...(model.diagnostics.length > 0 ? { fbxDiagnostics: model.diagnostics } : {}),
+            ...(model.displayLayer
+                ? { fbxDisplayLayer: { name: model.displayLayer.name, show: model.displayLayer.show, freeze: model.displayLayer.freeze, color: model.displayLayer.color } }
+                : {}),
+            ...(model.lodGroup ? { fbxLodGroup: model.lodGroup } : {}),
+        };
+        // Hidden display layers hide their members, as in the authoring application.
+        if (model.displayLayer && !model.displayLayer.show) {
+            node.setEnabled(false);
+        }
+    }
+    /**
+     * Wires a LodGroup's children as Babylon LOD levels: the first child holds the highest detail; every further
+     * child replaces it beyond the group's threshold distance (or screen coverage when thresholds are percentages).
+     * Each child's display mode is honoured first: level 1 (show) stays visible outside the LOD chain, level 2
+     * (hide) is disabled, and only level 0 (use LOD) children take part in the distance switching.
+     */
+    static _applyLodGroup(model, modelIdToNode) {
+        const lod = model.lodGroup;
+        if (!lod) {
+            return;
+        }
+        const lodChildren = [];
+        for (let level = 0; level < model.children.length; level++) {
+            const child = model.children[level];
+            const display = lod.displayLevels[level] ?? 0;
+            if (display === 2) {
+                modelIdToNode.get(child.id)?.setEnabled(false);
+            }
+            else if (display === 0) {
+                lodChildren.push({ child, level });
+            }
+        }
+        if (lodChildren.length < 2) {
+            return;
+        }
+        const meshesOf = (child) => {
+            const node = modelIdToNode.get(child.id);
+            if (!node) {
+                return [];
+            }
+            const meshes = node instanceof Mesh ? [node] : [];
+            for (const m of node.getChildMeshes(false)) {
+                if (m instanceof Mesh) {
+                    meshes.push(m);
+                }
+            }
+            return meshes;
         };
+        const base = meshesOf(lodChildren[0].child);
+        for (let i = 1; i < lodChildren.length; i++) {
+            const level = lodChildren[i].level;
+            const levelMeshes = meshesOf(lodChildren[i].child);
+            const threshold = lod.thresholds[level - 1] ?? lod.thresholds[lod.thresholds.length - 1] ?? 0;
+            for (let i = 0; i < base.length; i++) {
+                const target = levelMeshes[i] ?? null;
+                if (lod.relative) {
+                    base[i].useLODScreenCoverage = true;
+                    base[i].addLODLevel(threshold / 100, target);
+                }
+                else {
+                    base[i].addLODLevel(threshold, target);
+                }
+                if (target) {
+                    target.metadata = { ...(target.metadata ?? {}), fbxLodLevel: level };
+                }
+            }
+        }
+    }
+    /** Builds a lines mesh from Line or tessellated NurbsCurve geometry, applying the model's geometric transform. */
+    _createLinesMesh(model, curve, scene) {
+        const lines = new LinesMesh(model.name, scene);
+        const positions = [];
+        const indices = [];
+        for (const polyline of curve.polylines) {
+            const count = polyline.length / 3;
+            if (count < 2) {
+                continue;
+            }
+            const base = positions.length / 3;
+            for (let i = 0; i < polyline.length; i++) {
+                positions.push(polyline[i]);
+            }
+            for (let i = 0; i < count - 1; i++) {
+                indices.push(base + i, base + i + 1);
+            }
+        }
+        const geometricMatrix = FBXFileLoader._computeFBXGeometricMatrix(model.geometricTranslation, model.geometricRotation, model.geometricScaling);
+        if (!geometricMatrix.equals(Matrix.Identity())) {
+            for (let i = 0; i < positions.length; i += 3) {
+                const v = Vector3.TransformCoordinates(new Vector3(positions[i], positions[i + 1], positions[i + 2]), geometricMatrix);
+                positions[i] = v.x;
+                positions[i + 1] = v.y;
+                positions[i + 2] = v.z;
+            }
+        }
+        const vertexData = new VertexData();
+        vertexData.positions = positions;
+        vertexData.indices = indices;
+        vertexData.applyToMesh(lines);
+        if (curve.color) {
+            lines.color = new Color3(curve.color[0], curve.color[1], curve.color[2]);
+        }
+        lines.metadata = { ...(lines.metadata ?? {}), fbxCurveType: curve.kind, fbxCurveSegments: curve.polylines.length };
+        return lines;
     }
     _createMesh(model, geomData, scene, skeleton, skin, skinBinding) {
         const mesh = new Mesh(model.name, scene);
@@ -651,6 +877,18 @@ export class FBXFileLoader {
      */
     _applyMultiMaterial(mesh, model, materialCache, scene, cullingConflictMaterialIds, cullingMaterialCloneCache) {
         const matIndices = model.geometry.materialIndices;
+        const recorded = mesh.metadata?.fbxSubMeshMaterialIndices;
+        if (recorded) {
+            // Instance of an already split mesh: the index buffer and sub-meshes are shared; only the materials differ.
+            const multiMat = new MultiMaterial(model.name + "_multi", scene);
+            for (const matIdx of recorded) {
+                const fbxMat = model.materials[matIdx];
+                const mat = fbxMat ? materialCache.get(fbxMat.id) : undefined;
+                multiMat.subMaterials.push(mat ? FBXFileLoader._getModelMaterial(mat, model, cullingMaterialCloneCache, cullingConflictMaterialIds.has(fbxMat.id)) : null);
+            }
+            mesh.material = multiMat;
+            return;
+        }
         const indices = mesh.getIndices();
         if (!indices) {
             return;
@@ -707,6 +945,7 @@ export class FBXFileLoader {
             const range = subMeshRanges[i];
             new SubMesh(i, 0, vertexCount, range.start, range.count, mesh);
         }
+        mesh.metadata = { ...(mesh.metadata ?? {}), fbxSubMeshMaterialIndices: sortedMatIndices };
     }
     static _collectCullingConflictMaterialIds(models) {
         // Deliberately scan the full scene, not just name-filtered models. This
@@ -750,7 +989,7 @@ export class FBXFileLoader {
         if (cached) {
             return cached;
         }
-        const clone = material.clone(`${material.name}_CullingOff`);
+        const clone = material.clone(`${material.name}_CullingOff`) ?? material;
         clone.backFaceCulling = false;
         cullingCloneCache?.set(material, clone);
         return clone;
@@ -761,26 +1000,40 @@ export class FBXFileLoader {
         }
         if (material instanceof MultiMaterial) {
             for (const subMaterial of material.subMaterials) {
-                if (subMaterial instanceof StandardMaterial) {
+                if (subMaterial instanceof StandardMaterial || subMaterial instanceof PBRMaterial) {
                     this._applyStandardMaterialUVSetCoordinates(subMaterial, geometry);
                 }
             }
             return;
         }
-        if (material instanceof StandardMaterial) {
+        if (material instanceof StandardMaterial || material instanceof PBRMaterial) {
             this._applyStandardMaterialUVSetCoordinates(material, geometry);
         }
     }
     _applyStandardMaterialUVSetCoordinates(material, geometry) {
-        for (const texture of [
-            material.diffuseTexture,
-            material.bumpTexture,
-            material.emissiveTexture,
-            material.ambientTexture,
-            material.specularTexture,
-            material.opacityTexture,
-            material.reflectionTexture,
-        ]) {
+        for (const texture of material instanceof PBRMaterial
+            ? [
+                material.albedoTexture,
+                material.bumpTexture,
+                material.emissiveTexture,
+                material.ambientTexture,
+                material.metallicTexture,
+                material.reflectivityTexture,
+                material.microSurfaceTexture,
+                material.opacityTexture,
+                material.clearCoat.texture,
+                material.clearCoat.bumpTexture,
+                material.sheen.texture,
+            ]
+            : [
+                material.diffuseTexture,
+                material.bumpTexture,
+                material.emissiveTexture,
+                material.ambientTexture,
+                material.specularTexture,
+                material.opacityTexture,
+                material.reflectionTexture,
+            ]) {
             if (!texture) {
                 continue;
             }
@@ -804,26 +1057,26 @@ export class FBXFileLoader {
         if (!assignedMat) {
             return;
         }
-        if (assignedMat instanceof StandardMaterial) {
-            if (!assignedMat.diffuseTexture) {
-                const clone = assignedMat.clone(`${assignedMat.name}_VertexColor`);
+        const unmodulated = (mat) => {
+            if (mat instanceof StandardMaterial && !mat.diffuseTexture) {
+                const clone = mat.clone(`${mat.name}_VertexColor`);
                 clone.diffuseColor = new Color3(1, 1, 1);
-                mesh.material = clone;
+                return clone;
             }
-            return;
-        }
+            if (mat instanceof PBRMaterial && !mat.albedoTexture) {
+                const clone = mat.clone(`${mat.name}_VertexColor`);
+                clone.albedoColor = new Color3(1, 1, 1);
+                return clone;
+            }
+            return mat;
+        };
         if (assignedMat instanceof MultiMaterial) {
             const multiMat = new MultiMaterial(`${assignedMat.name}_VertexColor`, scene);
-            multiMat.subMaterials = assignedMat.subMaterials.map((sub) => {
-                if (sub instanceof StandardMaterial && !sub.diffuseTexture) {
-                    const clone = sub.clone(`${sub.name}_VertexColor`);
-                    clone.diffuseColor = new Color3(1, 1, 1);
-                    return clone;
-                }
-                return sub;
-            });
+            multiMat.subMaterials = assignedMat.subMaterials.map((sub) => (sub ? unmodulated(sub) : sub));
             mesh.material = multiMat;
+            return;
         }
+        mesh.material = unmodulated(assignedMat);
     }
     /**
      * Build per-polygon-vertex bone indices and weights from the control-point-based skin data.
@@ -900,6 +1153,278 @@ export class FBXFileLoader {
         };
     }
     _createMaterial(matData, scene, rootUrl) {
+        const mode = this._options.materials;
+        const usePbr = mode === "pbr" || (mode === "auto" && isPbrShaderType(matData.model.shaderType));
+        const material = usePbr ? this._createPbrMaterial(matData, scene, rootUrl) : this._createStandardMaterial(matData, scene, rootUrl);
+        material.metadata = {
+            ...(material.metadata ?? {}),
+            ...(matData.userProperties ? { fbxUserProperties: matData.userProperties } : {}),
+            fbxShaderType: matData.model.shaderType,
+            fbxFeatures: Object.fromEntries(Object.entries(matData.model.features).map(([k, v]) => [k, v?.enabled ?? false])),
+        };
+        return material;
+    }
+    _createPbrMaterial(matData, scene, rootUrl) {
+        const material = new PBRMaterial(matData.name, scene);
+        const pbr = matData.model.pbr;
+        const features = matData.model.features;
+        const enabled = (name) => features[name]?.enabled ?? false;
+        const specGloss = matData.model.shaderType === "3dsMaxPbrSpecGloss";
+        const scaleColor = (c, f) => c ? new Color3(c[0] * (f ?? 1), c[1] * (f ?? 1), c[2] * (f ?? 1)) : undefined;
+        // Base colour
+        const baseColor = mapColor(pbr.baseColor);
+        material.albedoColor = scaleColor(baseColor, pbr.baseColor?.texture ? 1 : mapScalar(pbr.baseFactor)) ?? Color3.White();
+        // Metal / rough or spec / gloss workflow
+        if (specGloss) {
+            material.metallic = null;
+            material.roughness = null;
+            material.reflectivityColor = scaleColor(mapColor(pbr.specularColor), 1) ?? Color3.White();
+            material.microSurface = mapScalar(pbr.glossiness) ?? 1 - (mapScalar(pbr.roughness) ?? 0.5);
+        }
+        else {
+            material.metallic = enabled("metalness") ? (mapScalar(pbr.metalness) ?? 0) : 0;
+            material.roughness = mapScalar(pbr.roughness) ?? (pbr.glossiness?.value ? 1 - pbr.glossiness.value[0] : 0.5);
+            if (enabled("specular") && pbr.specularFactor?.value) {
+                material.metallicF0Factor = mapScalar(pbr.specularFactor) ?? 1;
+            }
+            if (enabled("specular")) {
+                const specularColor = mapColor(pbr.specularColor);
+                if (specularColor) {
+                    material.metallicReflectanceColor = new Color3(specularColor[0], specularColor[1], specularColor[2]);
+                }
+            }
+        }
+        // Emission
+        const emission = scaleColor(mapColor(pbr.emissionColor), pbr.emissionColor?.texture ? 1 : mapScalar(pbr.emissionFactor));
+        if (emission && enabled("emission")) {
+            material.emissiveColor = emission;
+        }
+        else if (emission && (emission.r > 0 || emission.g > 0 || emission.b > 0)) {
+            material.emissiveColor = emission;
+        }
+        // Opacity / transparency
+        const opacity = mapColor(pbr.opacity);
+        if (opacity && enabled("opacity")) {
+            material.alpha = (opacity[0] + opacity[1] + opacity[2]) / 3;
+        }
+        else if (!isPbrShaderType(matData.model.shaderType)) {
+            material.alpha = FBXFileLoader._alphaFromClassicTransparency(matData);
+        }
+        if (material.alpha < 1) {
+            material.transparencyMode = Material.MATERIAL_ALPHABLEND;
+        }
+        // Transmission (refraction)
+        const transmission = mapScalar(pbr.transmissionFactor) ?? 0;
+        if (enabled("transmission") && isPbrShaderType(matData.model.shaderType) && transmission > 0) {
+            material.subSurface.isRefractionEnabled = true;
+            material.subSurface.refractionIntensity = transmission;
+            const tint = mapColor(pbr.transmissionColor);
+            if (tint) {
+                material.subSurface.tintColor = new Color3(tint[0], tint[1], tint[2]);
+            }
+            const ior = mapScalar(pbr.specularIor);
+            if (ior && enabled("ior")) {
+                material.subSurface.indexOfRefraction = ior;
+            }
+        }
+        else {
+            const ior = mapScalar(pbr.specularIor);
+            if (ior && enabled("ior") && ior > 1) {
+                material.indexOfRefraction = ior;
+            }
+        }
+        // Clear coat
+        const coat = mapScalar(pbr.coatFactor) ?? 0;
+        if ((enabled("coat") && coat > 0) || pbr.coatFactor?.texture) {
+            material.clearCoat.isEnabled = true;
+            material.clearCoat.intensity = coat;
+            const coatRough = mapScalar(pbr.coatRoughness);
+            if (coatRough !== undefined) {
+                material.clearCoat.roughness = coatRough;
+            }
+            const coatIor = mapScalar(pbr.coatIor);
+            if (coatIor !== undefined && coatIor > 1) {
+                material.clearCoat.indexOfRefraction = coatIor;
+            }
+            const coatColor = mapColor(pbr.coatColor);
+            if (coatColor && (coatColor[0] !== 1 || coatColor[1] !== 1 || coatColor[2] !== 1)) {
+                material.clearCoat.isTintEnabled = true;
+                material.clearCoat.tintColor = new Color3(coatColor[0], coatColor[1], coatColor[2]);
+            }
+        }
+        // Sheen
+        const sheen = mapScalar(pbr.sheenFactor) ?? 0;
+        if ((enabled("sheen") && sheen > 0) || pbr.sheenColor?.texture) {
+            material.sheen.isEnabled = true;
+            material.sheen.intensity = sheen;
+            const sheenColor = mapColor(pbr.sheenColor);
+            if (sheenColor) {
+                material.sheen.color = new Color3(sheenColor[0], sheenColor[1], sheenColor[2]);
+            }
+            const sheenRough = mapScalar(pbr.sheenRoughness);
+            if (sheenRough !== undefined) {
+                material.sheen.roughness = sheenRough;
+            }
+        }
+        if (enabled("unlit")) {
+            material.unlit = true;
+        }
+        if (enabled("doubleSided")) {
+            material.backFaceCulling = false;
+        }
+        // Textures
+        const textureFor = (map, isNormal = false) => {
+            if (!map?.texture || !map.textureEnabled) {
+                return null;
+            }
+            const texture = FBXFileLoader._createTexture(map.texture, scene, rootUrl, isNormal);
+            if (texture) {
+                FBXFileLoader._applyTextureSettings(texture, map.texture);
+            }
+            return texture;
+        };
+        const albedo = textureFor(pbr.baseColor);
+        if (albedo) {
+            material.albedoTexture = albedo;
+        }
+        const normal = textureFor(pbr.normalMap, true);
+        if (normal) {
+            material.bumpTexture = normal;
+            this._configureNormalTexture(normal, material);
+        }
+        const emissiveTex = textureFor(pbr.emissionColor);
+        if (emissiveTex) {
+            material.emissiveTexture = emissiveTex;
+            if (!emission || (emission.r === 0 && emission.g === 0 && emission.b === 0)) {
+                material.emissiveColor = Color3.White();
+            }
+        }
+        const ao = textureFor(pbr.ambientOcclusion);
+        if (ao) {
+            material.ambientTexture = ao;
+            material.useAmbientInGrayScale = true;
+        }
+        if (specGloss) {
+            const spec = textureFor(pbr.specularColor);
+            if (spec) {
+                material.reflectivityTexture = spec;
+            }
+            const gloss = textureFor(pbr.glossiness) ?? textureFor(pbr.roughness);
+            if (gloss) {
+                material.microSurfaceTexture = gloss;
+            }
+        }
+        else {
+            // Babylon reads metalness and roughness from one texture (B = metal, G = rough). Grayscale maps have
+            // identical channels, so either map works alone; two different maps cannot both be honoured. The choice
+            // is made on the references so that only the texture actually used is created.
+            const metalRef = pbr.metalness?.textureEnabled ? pbr.metalness.texture : undefined;
+            const roughSource = pbr.roughness?.textureEnabled && pbr.roughness.texture ? pbr.roughness : pbr.glossiness?.textureEnabled && pbr.glossiness.texture ? pbr.glossiness : undefined;
+            const roughRef = roughSource?.texture;
+            const sameTexture = !!metalRef && !!roughRef && metalRef.id === roughRef.id;
+            let usesMetalTexture = false;
+            if (metalRef && (sameTexture || !roughRef)) {
+                const metalTex = textureFor(pbr.metalness);
+                if (metalTex) {
+                    usesMetalTexture = true;
+                    material.metallicTexture = metalTex;
+                    material.useMetallnessFromMetallicTextureBlue = true;
+                    material.useRoughnessFromMetallicTextureGreen = sameTexture;
+                    material.useRoughnessFromMetallicTextureAlpha = false;
+                }
+            }
+            else if (roughRef) {
+                const roughTex = textureFor(roughSource);
+                if (roughTex) {
+                    material.metallicTexture = roughTex;
+                    material.useMetallnessFromMetallicTextureBlue = false;
+                    material.useRoughnessFromMetallicTextureGreen = true;
+                    material.useRoughnessFromMetallicTextureAlpha = false;
+                    if (metalRef) {
+                        material.metadata = { ...(material.metadata ?? {}), fbxDroppedMetalnessTexture: metalRef.relativeFileName };
+                    }
+                }
+            }
+            // A roughness-only texture keeps the scalar metalness; a metalness texture needs metallic = 1 to show.
+            if (usesMetalTexture && material.metallic === 0) {
+                material.metallic = 1;
+            }
+        }
+        if (pbr.opacity?.texture && pbr.opacity.textureEnabled) {
+            if (albedo && pbr.opacity.texture.id === pbr.baseColor?.texture?.id) {
+                material.useAlphaFromAlbedoTexture = true;
+                material.transparencyMode = Material.MATERIAL_ALPHATESTANDBLEND;
+            }
+            else {
+                const opacityTex = textureFor(pbr.opacity);
+                if (opacityTex) {
+                    material.opacityTexture = opacityTex;
+                    material.transparencyMode = Material.MATERIAL_ALPHATESTANDBLEND;
+                }
+            }
+        }
+        if (material.clearCoat.isEnabled) {
+            const coatTex = textureFor(pbr.coatFactor);
+            if (coatTex) {
+                material.clearCoat.texture = coatTex;
+            }
+            const coatNormal = textureFor(pbr.coatNormal, true);
+            if (coatNormal) {
+                material.clearCoat.bumpTexture = coatNormal;
+            }
+        }
+        if (material.sheen.isEnabled) {
+            const sheenTex = textureFor(pbr.sheenColor);
+            if (sheenTex) {
+                material.sheen.texture = sheenTex;
+            }
+        }
+        return material;
+    }
+    /** Alpha of a classic Lambert/Phong material: Opacity when present, otherwise 1 - TransparentColor * TransparencyFactor. */
+    static _alphaFromClassicTransparency(matData) {
+        const props = matData.properties;
+        if (props.opacity !== undefined) {
+            return props.opacity;
+        }
+        const factor = mapScalar(matData.model.fbx.transparencyFactor);
+        if (factor === undefined) {
+            return 1;
+        }
+        const color = mapColor(matData.model.fbx.transparencyColor);
+        const amount = color ? (color[0] + color[1] + color[2]) / 3 : 1;
+        return Math.min(1, Math.max(0, 1 - amount * factor));
+    }
+    static _applyTextureSettings(texture, tex) {
+        if (tex.uvTranslation) {
+            texture.uOffset = tex.uvTranslation[0];
+            texture.vOffset = tex.uvTranslation[1];
+        }
+        if (tex.uvScaling) {
+            texture.uScale = tex.uvScaling[0];
+            texture.vScale = tex.uvScaling[1];
+        }
+        if (tex.uvRotation !== undefined) {
+            texture.wAng = tex.uvRotation * (Math.PI / 180);
+        }
+        if (tex.uvSetIndex !== undefined) {
+            texture.coordinatesIndex = tex.uvSetIndex;
+        }
+        if (tex.wrapU !== undefined) {
+            texture.wrapU = tex.wrapU === 1 ? Texture.CLAMP_ADDRESSMODE : Texture.WRAP_ADDRESSMODE;
+        }
+        if (tex.wrapV !== undefined) {
+            texture.wrapV = tex.wrapV === 1 ? Texture.CLAMP_ADDRESSMODE : Texture.WRAP_ADDRESSMODE;
+        }
+        if (tex.uvSetName || tex.layeredTextureId !== undefined) {
+            texture.metadata = {
+                ...(texture.metadata ?? {}),
+                ...(tex.uvSetName ? { fbxUVSetName: tex.uvSetName } : {}),
+                ...(tex.layeredTextureId !== undefined ? { fbxLayeredTextureId: tex.layeredTextureId } : {}),
+            };
+        }
+    }
+    _createStandardMaterial(matData, scene, rootUrl) {
         const material = new StandardMaterial(matData.name, scene);
         const props = matData.properties;
         const hasTexture = (...slots) => matData.textures.some((texture) => slots.includes(texture.propertyName));
@@ -922,12 +1447,7 @@ export class FBXFileLoader {
             const emissiveFactor = hasTexture("EmissiveColor", "Emissive") ? 1 : (props.emissiveFactor ?? 1);
             material.emissiveColor = new Color3(props.emissiveColor[0] * emissiveFactor, props.emissiveColor[1] * emissiveFactor, props.emissiveColor[2] * emissiveFactor);
         }
-        if (props.opacity !== undefined) {
-            material.alpha = props.opacity;
-        }
-        else if (props.transparencyFactor !== undefined) {
-            material.alpha = 1 - props.transparencyFactor;
-        }
+        material.alpha = FBXFileLoader._alphaFromClassicTransparency(matData);
         if (material.alpha < 1) {
             material.transparencyMode = Material.MATERIAL_ALPHABLEND;
         }
@@ -991,27 +1511,7 @@ export class FBXFileLoader {
                     // Shininess map — no direct StandardMaterial slot
                     break;
             }
-            // Apply UV transforms
-            if (tex.uvTranslation) {
-                texture.uOffset = tex.uvTranslation[0];
-                texture.vOffset = tex.uvTranslation[1];
-            }
-            if (tex.uvScaling) {
-                texture.uScale = tex.uvScaling[0];
-                texture.vScale = tex.uvScaling[1];
-            }
-            if (tex.uvRotation !== undefined) {
-                texture.wAng = tex.uvRotation * (Math.PI / 180);
-            }
-            if (tex.uvSetIndex !== undefined) {
-                texture.coordinatesIndex = tex.uvSetIndex;
-            }
-            if (tex.uvSetName) {
-                texture.metadata = {
-                    ...(texture.metadata ?? {}),
-                    fbxUVSetName: tex.uvSetName,
-                };
-            }
+            FBXFileLoader._applyTextureSettings(texture, tex);
         }
         return material;
     }
@@ -1273,6 +1773,8 @@ export class FBXFileLoader {
         const position = Vector3.TransformCoordinates(Vector3.Zero(), worldMatrix);
         const camera = new FreeCamera(camData.name, position, scene);
         camera.fov = camData.fieldOfView * (Math.PI / 180);
+        camera.fovMode = Camera.FOVMODE_VERTICAL_FIXED;
+        void position;
         camera.minZ = camData.nearPlane;
         camera.maxZ = camData.farPlane;
         camera.metadata = {
@@ -1285,25 +1787,44 @@ export class FBXFileLoader {
                 orthoZoom: camData.orthoZoom,
                 roll: camData.roll,
                 aspectRatio: camData.aspectRatio,
+                fieldOfViewX: camData.fieldOfViewX,
+                apertureMode: camData.apertureMode,
+                apertureSizeInch: camData.apertureSizeInch,
+                userProperties: camData.userProperties,
                 unknownProperties: camData.unknownProperties,
                 diagnostics: camData.diagnostics,
             },
         };
         if (camData.projectionType === "orthographic") {
-            const orthoHeight = camData.orthoZoom && camData.orthoZoom > 0 ? camData.orthoZoom : 1;
-            const aspect = camData.aspectRatio > 0 ? camData.aspectRatio : 1;
             camera.mode = Camera.ORTHOGRAPHIC_CAMERA;
-            camera.orthoTop = orthoHeight / 2;
-            camera.orthoBottom = -orthoHeight / 2;
-            camera.orthoRight = (orthoHeight * aspect) / 2;
-            camera.orthoLeft = -(orthoHeight * aspect) / 2;
-        }
-        // FBX cameras look down their local +X axis. Derive the world-space look-at target from the
-        // node's world matrix using point transforms so the file's handedness conversion (the
-        // left-handed root applies scaling.z = -1) is reproduced correctly. Transforming a direction
-        // with the rotation alone would mirror it under that reflection and aim the camera wrongly.
-        const target = Vector3.TransformCoordinates(new Vector3(1, 0, 0), worldMatrix);
-        camera.setTarget(target);
+            camera.orthoTop = camData.orthographicSize[1] / 2;
+            camera.orthoBottom = -camData.orthographicSize[1] / 2;
+            camera.orthoRight = camData.orthographicSize[0] / 2;
+            camera.orthoLeft = -camData.orthographicSize[0] / 2;
+        }
+        // FBX cameras look down their local +X axis. When attached, the camera is parented to its node so it follows
+        // the node's animation, and oriented with a fixed local rotation (camera forward +Z -> node +X), with the FBX
+        // Roll applied around the view axis first. Otherwise it is placed in world space, unparented.
+        if (parentNode && this._options.attachCamerasAndLights) {
+            // The handedness conversion at the root mirrors every node's world matrix. A camera cannot render through
+            // a mirrored parent (its view matrix would flip the image and the winding), so when the node's world
+            // determinant is negative the camera hangs from a pivot whose own mirror cancels it.
+            let cameraParent = parentNode;
+            if (worldMatrix.determinant() < 0) {
+                const pivot = new TransformNode(`${camData.name}__fbx_cameraPivot`, scene);
+                pivot.parent = parentNode;
+                pivot.scaling.set(1, 1, -1);
+                cameraParent = pivot;
+            }
+            camera.parent = cameraParent;
+            camera.position.set(0, 0, 0);
+            const roll = ((camData.roll ?? 0) * Math.PI) / 180;
+            camera.rotationQuaternion = Quaternion.FromRotationMatrix(Matrix.RotationZ(roll).multiply(Matrix.RotationY(Math.PI / 2)));
+        }
+        else {
+            const target = Vector3.TransformCoordinates(new Vector3(1, 0, 0), worldMatrix);
+            camera.setTarget(target);
+        }
         return camera;
     }
     _createLight(lightData, modelIdToNode, scene) {
@@ -1318,26 +1839,44 @@ export class FBXFileLoader {
         const forwardPoint = Vector3.TransformCoordinates(new Vector3(0, 0, -1), worldMatrix);
         const direction = forwardPoint.subtract(position).normalize();
         let light;
+        // When attached, the light is parented to its node (so it follows animation) and its position and direction
+        // are expressed in node-local space: origin and local -Z. Otherwise it is placed in world space, unparented.
+        const attach = !!parentNode && this._options.attachCamerasAndLights;
+        const localPosition = attach ? Vector3.Zero() : position;
+        const localDirection = attach ? new Vector3(0, 0, -1) : direction;
         switch (lightData.lightType) {
             case 1: // Directional
-                light = new DirectionalLight(lightData.name, direction, scene);
+                light = new DirectionalLight(lightData.name, localDirection, scene);
                 light.diffuse = color;
                 light.intensity = lightData.intensity;
                 break;
             case 2: {
                 // Spot
                 const angle = lightData.coneAngle * (Math.PI / 180);
-                light = new SpotLight(lightData.name, position, direction, angle, 2, scene);
+                light = new SpotLight(lightData.name, localPosition, localDirection, angle, 2, scene);
                 light.diffuse = color;
                 light.intensity = lightData.intensity;
+                if (lightData.innerAngle !== undefined) {
+                    light.innerAngle = Math.min(angle, (lightData.innerAngle * Math.PI) / 180);
+                }
                 break;
             }
-            default: // Point (0)
-                light = new PointLight(lightData.name, position, scene);
+            default: // Point (0), Area (3) and Volume (4) approximated as point lights
+                light = new PointLight(lightData.name, localPosition, scene);
                 light.diffuse = color;
                 light.intensity = lightData.intensity;
                 break;
         }
+        if (attach && parentNode) {
+            light.parent = parentNode;
+            // Babylon only resolves a parented light's world position and direction during rendering; do it now
+            // so getAbsolutePosition() and transformedDirection are usable straight after loading.
+            light.computeTransformedInformation();
+        }
+        light.specular = color;
+        if (lightData.enableFarAttenuation && lightData.farAttenuationEnd !== undefined && lightData.farAttenuationEnd > 0) {
+            light.range = lightData.farAttenuationEnd;
+        }
         light.metadata = {
             ...(light.metadata ?? {}),
             fbxLight: {
@@ -1349,6 +1888,10 @@ export class FBXFileLoader {
                 enableNearAttenuation: lightData.enableNearAttenuation,
                 enableFarAttenuation: lightData.enableFarAttenuation,
                 castShadows: lightData.castShadows,
+                farAttenuationStart: lightData.farAttenuationStart,
+                farAttenuationEnd: lightData.farAttenuationEnd,
+                areaLightShape: lightData.areaLightShape,
+                userProperties: lightData.userProperties,
                 unknownProperties: lightData.unknownProperties,
                 diagnostics: lightData.diagnostics,
             },
@@ -1363,11 +1906,12 @@ export class FBXFileLoader {
         const authoredAbsoluteMatrices = [];
         const authoredRuntimeLocalMatrices = [];
         // Compute authored Lcl matrices for bones that do not carry FBX bind data.
+        const authoredInheritScales = FBXFileLoader._computeBoneInheritScales(bones, bones.map((b) => b.scale));
         for (let i = 0; i < bones.length; i++) {
             const boneData = bones[i];
             const authoredLocal = FBXFileLoader._computeFBXLocalMatrix(boneData.translation, boneData.rotation, boneData.scale, boneData.preRotation, boneData.postRotation, boneData.rotationPivot, boneData.scalingPivot, boneData.rotationOffset, boneData.scalingOffset, boneData.rotationOrder);
             authoredLocalMatrices[i] = authoredLocal;
-            authoredRuntimeLocalMatrices[i] = FBXFileLoader._computeFBXRuntimeLocalMatrix(bones, authoredLocal, i);
+            authoredRuntimeLocalMatrices[i] = FBXFileLoader._computeFBXRuntimeLocalMatrix(bones, authoredLocal, i, authoredInheritScales);
         }
         authoredAbsoluteMatrices.push(...FBXFileLoader._computeFBXAbsoluteMatrices(bones, authoredRuntimeLocalMatrices));
         const absoluteBindMatrices = bones.map((boneData, index) => boneData.transformLinkMatrix
@@ -1391,11 +1935,12 @@ export class FBXFileLoader {
         // Only bones with that scale disagreement need their animation curves
         // remapped into bind-rest space; ordinary child curves are already in
         // the expected local animation space.
+        const restInheritScales = FBXFileLoader._computeBoneInheritScales(bones, bones.map((b) => b.scale));
         for (let i = 0; i < bones.length; i++) {
             let localMatrix = useBindAsRest ? localBindMatrices[i] : authoredRuntimeLocalMatrices[i];
             let parentBone = bones[i].parentIndex >= 0 ? sourceBones[bones[i].parentIndex] : null;
-            if (!useBindAsRest && bones[i].inheritType === 2 && bones[i].parentIndex >= 0 && parentBone) {
-                const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(authoredLocalMatrices[i], bones[bones[i].parentIndex].scale);
+            if (!useBindAsRest && bones[i].inheritType !== 1 && bones[i].parentIndex >= 0 && parentBone) {
+                const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(authoredLocalMatrices[i], restInheritScales[bones[i].parentIndex], FBXFileLoader._getBoneInheritedScale(bones, i, restInheritScales));
                 const helper = new Bone(`${bones[i].name}__fbx_scaleCompensation`, skeleton, parentBone, split.helperLocalMatrix, split.helperLocalMatrix.clone(), Matrix.Identity(), -1);
                 helper.metadata = {
                     ...(helper.metadata ?? {}),
@@ -1430,6 +1975,9 @@ export class FBXFileLoader {
         }
         return skeleton;
     }
+    _isRigBone(modelId) {
+        return this._rigBoneModelIds.has(modelId);
+    }
     _getSourceBone(skeleton, sourceIndex) {
         return this._sourceBonesBySkeleton.get(skeleton)?.[sourceIndex] ?? skeleton.bones[sourceIndex];
     }
@@ -1448,22 +1996,69 @@ export class FBXFileLoader {
         }
         return absoluteMatrices;
     }
-    static _computeFBXRuntimeLocalMatrix(bones, localMatrix, index, parentScaleOverride) {
+    /**
+     * Effective ("inherit") scale of every bone, following the FBX SDK: the local scale for RSrs bones, and for
+     * RrSs / Rrs bones the local scale multiplied by the scale of the bone's inherit-scale node (the parent for RrSs,
+     * the parent's inherit-scale node for Rrs). Bones are ordered parents first.
+     */
+    static _computeBoneInheritScales(bones, ownScales) {
+        const result = [];
+        for (let i = 0; i < bones.length; i++) {
+            const own = ownScales[i];
+            const inheritedFrom = FBXFileLoader._getBoneInheritScaleNode(bones, i);
+            if (inheritedFrom < 0 || inheritedFrom >= i) {
+                result[i] = [own[0], own[1], own[2]];
+            }
+            else {
+                const p = result[inheritedFrom];
+                result[i] = [own[0] * p[0], own[1] * p[1], own[2] * p[2]];
+            }
+        }
+        return result;
+    }
+    static _getBoneInheritScaleNode(bones, index) {
         const parentIndex = bones[index].parentIndex;
-        if (bones[index].inheritType !== 2 || parentIndex < 0) {
+        if (parentIndex < 0) {
+            return -1;
+        }
+        if (bones[index].inheritType === 0) {
+            return parentIndex;
+        }
+        if (bones[index].inheritType === 2) {
+            return FBXFileLoader._getBoneInheritScaleNode(bones, parentIndex);
+        }
+        return -1;
+    }
+    /** Scale a bone inherits into its own scale (RrSs chains), or unit scale. */
+    static _getBoneInheritedScale(bones, index, inheritScales) {
+        const node = FBXFileLoader._getBoneInheritScaleNode(bones, index);
+        return node >= 0 ? inheritScales[node] : [1, 1, 1];
+    }
+    static _computeFBXRuntimeLocalMatrix(bones, localMatrix, index, inheritScales) {
+        const parentIndex = bones[index].parentIndex;
+        if (bones[index].inheritType === 1 || parentIndex < 0) {
             return localMatrix;
         }
-        const parentScale = parentScaleOverride ?? bones[parentIndex].scale;
-        return FBXFileLoader._applyParentScaleCompensation(localMatrix, parentScale);
+        const scales = inheritScales ??
+            FBXFileLoader._computeBoneInheritScales(bones, bones.map((b) => b.scale));
+        return FBXFileLoader._applyParentScaleCompensation(localMatrix, scales[parentIndex], FBXFileLoader._getBoneInheritedScale(bones, index, scales));
     }
-    static _applyParentScaleCompensation(localMatrix, parentScale) {
-        const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(localMatrix, parentScale);
+    static _applyParentScaleCompensation(localMatrix, parentScale, inheritedScale) {
+        const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(localMatrix, parentScale, inheritedScale);
         return split.boneLocalMatrix.multiply(split.helperLocalMatrix);
     }
-    static _splitParentScaleCompensatedLocalMatrix(localMatrix, parentScale) {
+    /**
+     * Splits a bone's FBX local matrix into a helper (which cancels the parent scale and carries the translation,
+     * so the translation still follows the parent scale as the SDK does) and the bone's own rotation/scale. For RrSs
+     * bones the inherited scale is folded into the bone scale.
+     */
+    static _splitParentScaleCompensatedLocalMatrix(localMatrix, parentScale, inheritedScale) {
         const translation = localMatrix.getTranslation();
-        const boneLocalMatrix = localMatrix.clone();
+        let boneLocalMatrix = localMatrix.clone();
         boneLocalMatrix.setTranslation(Vector3.Zero());
+        if (inheritedScale && (inheritedScale[0] !== 1 || inheritedScale[1] !== 1 || inheritedScale[2] !== 1)) {
+            boneLocalMatrix = Matrix.Scaling(inheritedScale[0], inheritedScale[1], inheritedScale[2]).multiply(boneLocalMatrix);
+        }
         const helperLocalMatrix = Matrix.Compose(FBXFileLoader._getInverseScaleVector(parentScale), Quaternion.Identity(), translation);
         return { boneLocalMatrix, helperLocalMatrix };
     }
@@ -1529,34 +2124,16 @@ export class FBXFileLoader {
             rotationOrder,
         });
     }
-    /**
-     * Apply the FBX transform chain to a Babylon TransformNode or Mesh.
-     * Decomposes the full local matrix into position/rotation/scale.
-     */
-    static _applyFBXTransform(node, model) {
-        const localMatrix = FBXFileLoader._computeFBXModelLocalMatrix(model);
-        // Decompose into TRS
-        const s = new Vector3();
-        const r = new Quaternion();
-        const t = new Vector3();
-        localMatrix.decompose(s, r, t);
-        node.position = t;
-        node.rotationQuaternion = r;
-        node.scaling = s;
+    _applyRestTRS(node, model) {
+        const trs = FBXFileLoader._computeLocalTRS(model, model.translation, model.rotation, model.scale);
+        this._adjustTRSForInheritMode(model, trs, undefined);
+        node.position = trs.position;
+        node.rotationQuaternion = trs.rotationQuaternion;
+        node.scaling = trs.scaling;
     }
     static _computeFBXModelLocalMatrix(model) {
         return FBXFileLoader._computeFBXLocalMatrix(model.translation, model.rotation, model.scale, model.preRotation, model.postRotation, model.rotationPivot, model.scalingPivot, model.rotationOffset, model.scalingOffset, model.rotationOrder);
     }
-    static _getBoneReferenceWorldMatrix(skeleton, bone, referenceNode, skinnedMesh) {
-        if (skinnedMesh) {
-            skeleton.getTransformMatrices(skinnedMesh);
-        }
-        else {
-            skeleton.prepare(true);
-        }
-        referenceNode.computeWorldMatrix(true);
-        return bone.getFinalMatrix().multiply(referenceNode.getWorldMatrix());
-    }
     static _applyMatrixToTransform(node, matrix) {
         const s = new Vector3();
         const r = new Quaternion();
@@ -1566,10 +2143,25 @@ export class FBXFileLoader {
         node.rotationQuaternion = r;
         node.scaling = s;
     }
-    _createAnimationGroup(animStack, rigs, skeletonByRigId, scene, modelIdToNode, modelIdToData, meshes) {
-        if (animStack.curveNodes.length === 0) {
+    _createAnimationGroup(animStack, rigs, skeletonByRigId, scene, modelIdToNode, modelIdToData, meshes, propertyTargets) {
+        // Stacks may animate only properties (visibility, light colour...) without any transform curve.
+        if (animStack.curveNodes.length === 0 && !animStack.unsupportedCurveNodes.some((c) => c.targetId !== null && c.curves.length > 0)) {
             return null;
         }
+        this._activeLayers = animStack.layers;
+        this._curveNodesByModelId = new Map();
+        for (const curveNode of animStack.curveNodes) {
+            if (curveNode.type === "DeformPercent") {
+                continue;
+            }
+            const list = this._curveNodesByModelId.get(curveNode.targetModelId);
+            if (list) {
+                list.push(curveNode);
+            }
+            else {
+                this._curveNodesByModelId.set(curveNode.targetModelId, [curveNode]);
+            }
+        }
         const animGroup = new AnimationGroup(animStack.name, scene);
         const animatedBoneTargetProperties = new Map();
         const addBoneAnimation = (animation, bone) => {
@@ -1635,7 +2227,7 @@ export class FBXFileLoader {
         // authored Lcl curves remapped onto the bind-rest local space.
         const inheritedRigModelIds = new Set();
         for (const rig of rigs) {
-            const inheritType2ModelIds = new Set(rig.bones.filter((bone) => bone.inheritType === 2).map((bone) => bone.modelId));
+            const inheritType2ModelIds = new Set(rig.bones.filter((bone) => bone.inheritType !== 1 && bone.parentIndex >= 0).map((bone) => bone.modelId));
             if (inheritType2ModelIds.size === 0) {
                 continue;
             }
@@ -1686,9 +2278,79 @@ export class FBXFileLoader {
                 animGroup.addTargetedAnimation(animation, node);
             }
         }
-        // Process blend shape (morph target) animations
+        // Inherit-scale helpers follow the inverse of their parent's (possibly animated) scale. Children of animated
+        // parents also need re-sampling even when they carry no curves of their own, since their local transform
+        // depends on the parent scale.
+        for (const [modelId, helper] of Array.from(this._inheritScaleHelpers)) {
+            const modelData = modelIdToData.get(modelId);
+            const parentModel = modelData ? this._parentModelById.get(modelId) : undefined;
+            if (!modelData || !parentModel) {
+                continue;
+            }
+            const fps = this._frameRate;
+            // The helper mirrors the parent's animated rotation/translation (its own curves plus any inherited scale
+            // that feeds its translation), with unit scale.
+            const parentCurves = [
+                ...(this._curveNodesByModelId.get(parentModel.id) ?? []),
+                ...this._collectInheritScaleCurves(parentModel).filter((cn) => cn.targetModelId !== parentModel.id),
+            ];
+            if (parentCurves.length > 0) {
+                const baseTimes = collectAnimationSampleTimes(parentCurves, fps, animStack.startTime, animStack.stopTime);
+                const sampleParent = (time) => this._computeInheritAwareLocalMatrix(parentModel, this._sampleModelLocalMatrix(parentModel, this._curveNodesByModelId.get(parentModel.id) ?? [], time), time);
+                const times = FBXFileLoader._refineSampleTimes(baseTimes, sampleParent);
+                const posKeys = [];
+                const rotKeys = [];
+                let prevQuat = null;
+                for (const time of times) {
+                    const sc = new Vector3();
+                    const rq = new Quaternion();
+                    const tr = new Vector3();
+                    sampleParent(time).decompose(sc, rq, tr);
+                    if (prevQuat && Quaternion.Dot(prevQuat, rq) < 0) {
+                        rq.scaleInPlace(-1);
+                    }
+                    prevQuat = rq;
+                    posKeys.push({ frame: time * fps, value: tr });
+                    rotKeys.push({ frame: time * fps, value: rq });
+                }
+                if (!this._isVector3KeysConstant(posKeys)) {
+                    const anim = new Animation(`${helper.name}_position`, "position", fps, Animation.ANIMATIONTYPE_VECTOR3, Animation.ANIMATIONLOOPMODE_CYCLE);
+                    anim.setKeys(posKeys);
+                    animGroup.addTargetedAnimation(anim, helper);
+                }
+                if (!areQuaternionKeysConstant(rotKeys)) {
+                    const anim = new Animation(`${helper.name}_rotation`, "rotationQuaternion", fps, Animation.ANIMATIONTYPE_QUATERNION, Animation.ANIMATIONLOOPMODE_CYCLE);
+                    anim.setKeys(rotKeys);
+                    animGroup.addTargetedAnimation(anim, helper);
+                }
+            }
+            // The child's own local transform depends on the parent scale; re-sample it when that scale animates.
+            const scaleCurves = this._collectInheritScaleCurves(parentModel);
+            const node = modelIdToNode.get(modelId);
+            if (node && scaleCurves.length > 0 && !nonBoneCurves.has(modelId) && !boneCurves.has(modelId)) {
+                for (const animation of this._buildNodeAnimations([], node.name, modelData, animStack.startTime, animStack.stopTime, scaleCurves)) {
+                    animGroup.addTargetedAnimation(animation, node);
+                }
+            }
+        }
+        // Process blend shape (morph target) animations. Every layer animating a channel contributes to one
+        // influence animation evaluated through the layer stack.
+        const blendShapeGroups = new Map();
         for (const curveNode of blendShapeCurves) {
-            const targetChannelId = curveNode.targetModelId;
+            const group = blendShapeGroups.get(curveNode.targetModelId);
+            if (group) {
+                group.push(curveNode);
+            }
+            else {
+                blendShapeGroups.set(curveNode.targetModelId, [curveNode]);
+            }
+        }
+        for (const [targetChannelId, group] of Array.from(blendShapeGroups)) {
+            group.sort((a, b) => a.layerIndex - b.layerIndex);
+            const sources = group.filter((cn) => cn.curves.length > 0).map((cn) => ({ layerIndex: cn.layerIndex, curves: cn.curves }));
+            if (sources.length === 0) {
+                continue;
+            }
             // Find the morph target with matching channel ID across all meshes
             let targetFound = false;
             for (const mesh of meshes) {
@@ -1698,15 +2360,15 @@ export class FBXFileLoader {
                 const metadata = mesh.metadata;
                 const channelTargets = metadata?.fbxBlendShapeChannelTargets;
                 const targetInfo = channelTargets?.get(targetChannelId);
-                if (targetInfo && curveNode.curves.length > 0) {
-                    const fps = 30;
+                if (targetInfo) {
+                    const fps = this._frameRate;
                     for (let shapeIndex = 0; shapeIndex < targetInfo.targetIndices.length; shapeIndex++) {
                         const target = mesh.morphTargetManager.getTarget(targetInfo.targetIndices[shapeIndex]);
                         if (!target) {
                             continue;
                         }
                         const anim = new Animation(`${target.name}_influence`, "influence", fps, Animation.ANIMATIONTYPE_FLOAT, Animation.ANIMATIONLOOPMODE_CYCLE);
-                        const keys = buildScalarAnimationKeys(curveNode.curves[0], fps, animStack.startTime, animStack.stopTime, (value) => calculateBlendShapeInfluences(value, targetInfo.fullWeights, targetInfo.targetIndices.length)[shapeIndex] ?? 0);
+                        const keys = this._layeredScalarKeys(sources, animStack, (value) => calculateBlendShapeInfluences(value, targetInfo.fullWeights, targetInfo.targetIndices.length)[shapeIndex] ?? 0);
                         anim.setKeys(keys);
                         animGroup.addTargetedAnimation(anim, target);
                     }
@@ -1722,26 +2384,53 @@ export class FBXFileLoader {
                     continue;
                 }
                 const target = mesh.morphTargetManager.getTarget(targetIndex);
-                if (target && curveNode.curves.length > 0) {
-                    const fps = 30;
+                if (target) {
+                    const fps = this._frameRate;
                     const anim = new Animation(`${target.name}_influence`, "influence", fps, Animation.ANIMATIONTYPE_FLOAT, Animation.ANIMATIONLOOPMODE_CYCLE);
-                    const keys = buildScalarAnimationKeys(curveNode.curves[0], fps, animStack.startTime, animStack.stopTime, (value) => value / 100);
-                    anim.setKeys(keys);
+                    anim.setKeys(this._layeredScalarKeys(sources, animStack, (value) => value / 100));
                     animGroup.addTargetedAnimation(anim, target);
                     targetFound = true;
                 }
             }
         }
+        // Animated non-transform properties: visibility, camera, light and material parameters. Curve nodes of
+        // several layers that animate the same property are evaluated together through the layer stack.
+        const propertyGroups = new Map();
+        for (const curveNode of animStack.unsupportedCurveNodes) {
+            if (curveNode.targetId === null || curveNode.curves.length === 0) {
+                continue;
+            }
+            const key = `${curveNode.targetId}|${curveNode.propertyName ?? curveNode.type}`;
+            const group = propertyGroups.get(key);
+            if (group) {
+                group.push(curveNode);
+            }
+            else {
+                propertyGroups.set(key, [curveNode]);
+            }
+        }
+        for (const group of Array.from(propertyGroups.values())) {
+            group.sort((a, b) => a.layerIndex - b.layerIndex);
+            const built = this._buildPropertyAnimations(group, animStack, modelIdToNode, propertyTargets);
+            if (built.length > 0) {
+                for (const curveNode of group) {
+                    this._evaluatedCurveNodeIds.add(curveNode.id);
+                }
+            }
+            for (const { animation, target } of built) {
+                animGroup.addTargetedAnimation(animation, target);
+            }
+        }
         // Normalize the animation group
         if (animGroup.targetedAnimations.length > 0) {
-            animGroup.normalize(animStack.startTime * 30, animStack.stopTime * 30);
+            animGroup.normalize(animStack.startTime * this._frameRate, animStack.stopTime * this._frameRate);
             return animGroup;
         }
         animGroup.dispose();
         return null;
     }
     _buildInheritedRigBoneAnimations(rig, skeleton, boneCurves, modelIdToData, compensatedModelIds, startTime, stopTime) {
-        const fps = 30;
+        const fps = this._frameRate;
         const sampledModelIds = new Set();
         for (let i = 0; i < rig.bones.length; i++) {
             if (!compensatedModelIds.has(rig.bones[i].modelId)) {
@@ -1752,10 +2441,18 @@ export class FBXFileLoader {
             }
         }
         const rigCurveNodes = rig.bones.filter((bone) => sampledModelIds.has(bone.modelId)).flatMap((bone) => boneCurves.get(bone.modelId) ?? []);
-        const times = collectAnimationSampleTimes(rigCurveNodes, fps, startTime, stopTime);
+        let times = collectAnimationSampleTimes(rigCurveNodes, fps, startTime, stopTime);
         if (times.length === 0) {
             return [];
         }
+        for (const boneData of rig.bones) {
+            const md = modelIdToData.get(boneData.modelId);
+            const cn = boneCurves.get(boneData.modelId) ?? [];
+            if (!sampledModelIds.has(boneData.modelId) || !md || cn.length === 0) {
+                continue;
+            }
+            times = FBXFileLoader._refineSampleTimes(times, (time) => this._sampleModelLocalMatrix(md, cn, time));
+        }
         const keysByBone = rig.bones.map(() => ({
             posKeys: [],
             rotKeys: [],
@@ -1796,14 +2493,15 @@ export class FBXFileLoader {
                 const curveNodes = boneCurves.get(boneData.modelId) ?? [];
                 return modelData ? this._sampleModelScale(modelData, curveNodes, time) : boneData.scale;
             });
+            const sampledInheritScales = FBXFileLoader._computeBoneInheritScales(rig.bones, sampledScales);
             const frame = time * fps;
             for (let i = 0; i < localMatrices.length; i++) {
                 if (!compensatedModelIds.has(rig.bones[i].modelId)) {
                     continue;
                 }
                 const parentIndex = rig.bones[i].parentIndex;
-                const parentScale = parentIndex >= 0 ? sampledScales[parentIndex] : rig.bones[i].scale;
-                const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(localMatrices[i], parentScale);
+                const parentScale = parentIndex >= 0 ? sampledInheritScales[parentIndex] : rig.bones[i].scale;
+                const split = FBXFileLoader._splitParentScaleCompensatedLocalMatrix(localMatrices[i], parentScale, FBXFileLoader._getBoneInheritedScale(rig.bones, i, sampledInheritScales));
                 FBXFileLoader._pushMatrixKeys(keysByBone[i], frame, split.boneLocalMatrix);
                 FBXFileLoader._pushMatrixKeys(keysByHelper[i], frame, split.helperLocalMatrix);
             }
@@ -1881,58 +2579,46 @@ export class FBXFileLoader {
      * Build animations for a non-bone node, correctly handling pivots.
      * Computes the full FBX transform matrix at each keyframe and decomposes into TRS.
      */
-    _buildNodeAnimations(curveNodes, nodeName, modelData, startTime, stopTime) {
-        const fps = 30;
+    _buildNodeAnimations(curveNodes, nodeName, modelData, startTime, stopTime, extraTimeCurves = []) {
+        const fps = this._frameRate;
         // Separate curves by type
-        const tNode = curveNodes.find((cn) => cn.type === "T");
         const rNode = curveNodes.find((cn) => cn.type === "R");
-        const sNode = curveNodes.find((cn) => cn.type === "S");
-        const times = collectAnimationSampleTimes(curveNodes, fps, startTime, stopTime);
-        if (times.length === 0) {
+        const baseTimes = collectAnimationSampleTimes([...curveNodes, ...extraTimeCurves], fps, startTime, stopTime);
+        if (baseTimes.length === 0) {
             return [];
         }
-        // Get curve accessors
-        const txCurve = tNode?.curves.find((c) => c.channel === "d|X");
-        const tyCurve = tNode?.curves.find((c) => c.channel === "d|Y");
-        const tzCurve = tNode?.curves.find((c) => c.channel === "d|Z");
-        const rxCurve = rNode?.curves.find((c) => c.channel === "d|X");
-        const ryCurve = rNode?.curves.find((c) => c.channel === "d|Y");
-        const rzCurve = rNode?.curves.find((c) => c.channel === "d|Z");
-        const sxCurve = sNode?.curves.find((c) => c.channel === "d|X");
-        const syCurve = sNode?.curves.find((c) => c.channel === "d|Y");
-        const szCurve = sNode?.curves.find((c) => c.channel === "d|Z");
-        // Build keyframes by computing the full matrix at each time
+        const sampleTRS = (time) => {
+            const sampled = this._sampleModelTRS(modelData, curveNodes, time);
+            const trs = FBXFileLoader._computeLocalTRS(modelData, sampled.translation, sampled.rotation, sampled.scale);
+            this._adjustTRSForInheritMode(modelData, trs, time);
+            return trs;
+        };
+        const times = FBXFileLoader._refineSampleTimes(baseTimes, (time) => {
+            const trs = sampleTRS(time);
+            return Matrix.Compose(trs.scaling, trs.rotationQuaternion, trs.position);
+        });
+        // Build keyframes by computing the local transform at each time
         const posKeys = [];
         const rotKeys = [];
         const sclKeys = [];
         let prevQuat = null;
         for (const time of times) {
             const frame = time * fps;
-            // Sample animated values, falling back to model's base values
-            const tx = sampleFBXCurveAtTime(txCurve, time) ?? modelData.translation[0];
-            const ty = sampleFBXCurveAtTime(tyCurve, time) ?? modelData.translation[1];
-            const tz = sampleFBXCurveAtTime(tzCurve, time) ?? modelData.translation[2];
-            const rx = sampleFBXCurveAtTime(rxCurve, time) ?? modelData.rotation[0];
-            const ry = sampleFBXCurveAtTime(ryCurve, time) ?? modelData.rotation[1];
-            const rz = sampleFBXCurveAtTime(rzCurve, time) ?? modelData.rotation[2];
-            const sx = sampleFBXCurveAtTime(sxCurve, time) ?? modelData.scale[0];
-            const sy = sampleFBXCurveAtTime(syCurve, time) ?? modelData.scale[1];
-            const sz = sampleFBXCurveAtTime(szCurve, time) ?? modelData.scale[2];
-            // Compute the full FBX local transform matrix with pivots
-            const localMatrix = FBXFileLoader._computeFBXLocalMatrix([tx, ty, tz], [rx, ry, rz], [sx, sy, sz], modelData.preRotation, modelData.postRotation, modelData.rotationPivot, modelData.scalingPivot, modelData.rotationOffset, modelData.scalingOffset, modelData.rotationOrder);
-            // Decompose into TRS
-            const s = new Vector3();
-            const r = new Quaternion();
-            const t = new Vector3();
-            localMatrix.decompose(s, r, t);
+            const trs = sampleTRS(time);
+            const s = trs.scaling;
+            const r = trs.rotationQuaternion;
+            const t = trs.position;
+            const stepT = isChannelSteppedAt(curveNodes, "T", time);
+            const stepR = isChannelSteppedAt(curveNodes, "R", time);
+            const stepS = isChannelSteppedAt(curveNodes, "S", time);
             // Ensure quaternion continuity
             if (prevQuat && Quaternion.Dot(prevQuat, r) < 0) {
                 r.scaleInPlace(-1);
             }
             prevQuat = r;
-            posKeys.push({ frame, value: t });
-            rotKeys.push({ frame, value: r });
-            sclKeys.push({ frame, value: s });
+            posKeys.push(stepT ? { frame, value: t, interpolation: 1 /* AnimationKeyInterpolation.STEP */ } : { frame, value: t });
+            rotKeys.push(stepR ? { frame, value: r, interpolation: 1 /* AnimationKeyInterpolation.STEP */ } : { frame, value: r });
+            sclKeys.push(stepS ? { frame, value: s, interpolation: 1 /* AnimationKeyInterpolation.STEP */ } : { frame, value: s });
         }
         const animations = [];
         // Only create position animation if it's not constant
@@ -1955,6 +2641,404 @@ export class FBXFileLoader {
         }
         return animations;
     }
+    /**
+     * Baked keys are interpolated linearly by Babylon. Between two frames an FBX cubic segment can deviate from that
+     * line, so sample times are refined (midpoints inserted, up to two levels) wherever the interpolated transform
+     * differs noticeably from the curve. Flat and linear segments stay at frame resolution.
+     */
+    static _refineSampleTimes(times, sample, maxDepth = 2) {
+        const decompose = (time) => {
+            const s = new Vector3();
+            const r = new Quaternion();
+            const t = new Vector3();
+            sample(time).decompose(s, r, t);
+            return { s, r, t };
+        };
+        const out = [];
+        const refine = (t0, t1, d0, d1, depth) => {
+            if (depth >= maxDepth) {
+                return;
+            }
+            const tm = (t0 + t1) * 0.5;
+            if (!(tm > t0 && tm < t1)) {
+                return;
+            }
+            const dm = decompose(tm);
+            const lerpT = Vector3.Lerp(d0.t, d1.t, 0.5);
+            const lerpS = Vector3.Lerp(d0.s, d1.s, 0.5);
+            const slerpR = Quaternion.Slerp(d0.r, d1.r, 0.5);
+            const posErr = Vector3.Distance(lerpT, dm.t);
+            const sclErr = Vector3.Distance(lerpS, dm.s);
+            const dot = Math.min(1, Math.abs(Quaternion.Dot(slerpR, dm.r)));
+            const angErr = 2 * Math.acos(dot);
+            const posTol = 1e-4 * (1 + Math.max(Math.abs(dm.t.x), Math.abs(dm.t.y), Math.abs(dm.t.z)));
+            const sclTol = 1e-4 * (1 + Math.max(Math.abs(dm.s.x), Math.abs(dm.s.y), Math.abs(dm.s.z)));
+            if (posErr > posTol || sclErr > sclTol || angErr > 0.0005) {
+                refine(t0, tm, d0, dm, depth + 1);
+                out.push(tm);
+                refine(tm, t1, dm, d1, depth + 1);
+            }
+        };
+        let prev = times.length > 0 ? decompose(times[0]) : null;
+        for (let i = 0; i < times.length; i++) {
+            out.push(times[i]);
+            if (i + 1 < times.length && prev) {
+                const next = decompose(times[i + 1]);
+                refine(times[i], times[i + 1], prev, next, 0);
+                prev = next;
+            }
+        }
+        return out;
+    }
+    /**
+     * Keys of a scalar property animated by one or more layers: the authored keys when a single layer drives it,
+     * otherwise the frame grid evaluated through the layer stack.
+     * @param sources - Per-layer curves of the property (each with at least one curve)
+     * @param animStack - Stack being converted
+     * @param mapValue - Conversion from the FBX value to the Babylon property value
+     * @returns Animation keys
+     */
+    _layeredScalarKeys(sources, animStack, mapValue) {
+        const fps = this._frameRate;
+        if (sources.length === 0) {
+            return [];
+        }
+        if (sources.length === 1) {
+            return buildScalarAnimationKeys(sources[0].curves[0], fps, animStack.startTime, animStack.stopTime, mapValue);
+        }
+        const channel = sources[0].curves[0].channel;
+        const times = collectAnimationSampleTimes(sources.map((source) => ({ type: "other", targetModelId: 0, curves: Array.from(source.curves), layerIndex: source.layerIndex })), fps, animStack.startTime, animStack.stopTime);
+        return times.map((time) => ({ frame: time * fps, value: mapValue(evaluateLayeredProperty(sources, animStack.layers, [channel], [0], time)[0]) }));
+    }
+    /**
+     * Maps an animated FBX property (anything other than node transforms and blend shape weights) onto the Babylon
+     * property that carries it: mesh visibility, camera field of view and clip planes, light intensity, colour and
+     * cone angles, and material colours, alpha, roughness and metalness. `group` holds the curve nodes of every
+     * layer animating that property, in layer order; several layers are evaluated through the layer stack.
+     */
+    _buildPropertyAnimations(group, animStack, modelIdToNode, targets) {
+        const fps = this._frameRate;
+        const curveNode = group[0];
+        const prop = curveNode.propertyName ?? curveNode.type;
+        const targetId = curveNode.targetId;
+        const out = [];
+        const scalarCurve = curveNode.curves.find((c) => c.channel === "d|X") ?? curveNode.curves[0];
+        const defaults = curveNode.defaultValues;
+        const layered = group.length > 1;
+        const sources = group.map((cn) => ({ layerIndex: cn.layerIndex, curves: cn.curves, defaultValues: cn.defaultValues }));
+        const sampleTimes = () => collectAnimationSampleTimes(group.map((cn) => ({ type: "other", targetModelId: targetId, curves: cn.curves, layerIndex: cn.layerIndex })), fps, animStack.startTime, animStack.stopTime);
+        const vectorSamples = (staticValue) => {
+            const cx = curveNode.curves.find((c) => c.channel === "d|X");
+            const cy = curveNode.curves.find((c) => c.channel === "d|Y");
+            const cz = curveNode.curves.find((c) => c.channel === "d|Z");
+            return sampleTimes().map((time) => ({
+                frame: time * fps,
+                values: layered
+                    ? evaluateLayeredProperty(sources, animStack.layers, ["d|X", "d|Y", "d|Z"], staticValue, time)
+                    : [sampleFBXCurveAtTime(cx, time) ?? staticValue[0], sampleFBXCurveAtTime(cy, time) ?? staticValue[1], sampleFBXCurveAtTime(cz, time) ?? staticValue[2]],
+            }));
+        };
+        const scalarKeys = (map, step = false) => {
+            const keys = layered
+                ? sampleTimes().map((time) => ({
+                    frame: time * fps,
+                    value: map(evaluateLayeredProperty(sources, animStack.layers, [scalarCurve.channel], [defaults[scalarCurve.channel] ?? 0], time)[0]),
+                }))
+                : buildScalarAnimationKeys(scalarCurve, fps, animStack.startTime, animStack.stopTime, map);
+            if (step) {
+                for (const key of keys) {
+                    key.interpolation = 1 /* AnimationKeyInterpolation.STEP */;
+                    delete key.inTangent;
+                    delete key.outTangent;
+                }
+            }
+            return keys;
+        };
+        const colorKeys = () => vectorSamples([defaults["d|X"] ?? 1, defaults["d|Y"] ?? 1, defaults["d|Z"] ?? 1]).map(({ frame, values }) => ({
+            frame,
+            value: new Color3(values[0], values[1], values[2]),
+        }));
+        const add = (target, property, type, keys, name) => {
+            if (keys.length === 0) {
+                return;
+            }
+            const animation = new Animation(`${name}_${property}`, property, fps, type, Animation.ANIMATIONLOOPMODE_CYCLE);
+            animation.setKeys(keys);
+            out.push({ animation, target });
+        };
+        const node = modelIdToNode.get(targetId);
+        if (node) {
+            if (prop === "Visibility" && node instanceof Mesh) {
+                add(node, "visibility", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => Math.min(1, Math.max(0, v)), true), node.name);
+                return out;
+            }
+            // Animated user properties drive the value stored in the node's metadata.
+            const userProperties = node.metadata?.fbxUserProperties;
+            if (userProperties && prop in userProperties) {
+                const hasVector = curveNode.curves.some((c) => c.channel === "d|Y" || c.channel === "d|Z");
+                if (hasVector) {
+                    const current = userProperties[prop];
+                    const base = Array.isArray(current) ? current : [0, 0, 0];
+                    userProperties[prop] = new Vector3(base[0] ?? 0, base[1] ?? 0, base[2] ?? 0);
+                    const keys = vectorSamples([base[0] ?? 0, base[1] ?? 0, base[2] ?? 0]).map(({ frame, values }) => ({
+                        frame,
+                        value: new Vector3(values[0], values[1], values[2]),
+                    }));
+                    add(node, `metadata.fbxUserProperties.${prop}`, Animation.ANIMATIONTYPE_VECTOR3, keys, node.name);
+                }
+                else {
+                    if (typeof userProperties[prop] === "boolean") {
+                        userProperties[prop] = userProperties[prop] ? 1 : 0;
+                    }
+                    add(node, `metadata.fbxUserProperties.${prop}`, Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), node.name);
+                }
+            }
+            return out;
+        }
+        const camera = targets.cameraByAttributeId.get(targetId);
+        if (camera) {
+            const meta = camera.metadata?.fbxCamera;
+            const aspect = meta?.aspectRatio || 1;
+            const apertureMode = meta?.apertureMode ?? 2;
+            switch (prop) {
+                case "FieldOfView":
+                    // Vertical unless the camera's aperture mode declares FieldOfView as horizontal.
+                    add(camera, "fov", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => (apertureMode === 1 ? 2 * Math.atan(Math.tan((v * Math.PI) / 360) / aspect) : (v * Math.PI) / 180)), camera.name);
+                    break;
+                case "FieldOfViewY":
+                    add(camera, "fov", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => (v * Math.PI) / 180), camera.name);
+                    break;
+                case "FieldOfViewX":
+                    if (apertureMode !== 0) {
+                        add(camera, "fov", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => 2 * Math.atan(Math.tan((v * Math.PI) / 360) / aspect)), camera.name);
+                    }
+                    break;
+                case "FocalLength": {
+                    const apertureY = meta?.apertureSizeInch?.[1];
+                    if (apertureY && apertureMode === 3) {
+                        add(camera, "fov", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => 2 * Math.atan((apertureY / Math.max(v / 25.4, 1e-6)) * 0.5)), camera.name);
+                    }
+                    break;
+                }
+                case "NearPlane":
+                    add(camera, "minZ", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), camera.name);
+                    break;
+                case "FarPlane":
+                    add(camera, "maxZ", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), camera.name);
+                    break;
+                default:
+                    break;
+            }
+            return out;
+        }
+        const light = targets.lightByAttributeId.get(targetId);
+        if (light) {
+            switch (prop) {
+                case "Intensity":
+                    add(light, "intensity", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v / 100), light.name);
+                    break;
+                case "Color":
+                    add(light, "diffuse", Animation.ANIMATIONTYPE_COLOR3, colorKeys(), light.name);
+                    break;
+                case "OuterAngle":
+                case "ConeAngle":
+                    if (light instanceof SpotLight) {
+                        add(light, "angle", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => (v * Math.PI) / 180), light.name);
+                    }
+                    break;
+                case "InnerAngle":
+                    if (light instanceof SpotLight) {
+                        add(light, "innerAngle", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => (v * Math.PI) / 180), light.name);
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return out;
+        }
+        const material = targets.materialCache.get(targetId);
+        if (material) {
+            const isPbr = material instanceof PBRMaterial;
+            const short = prop.substring(prop.lastIndexOf("|") + 1);
+            if (prop === "DiffuseColor" || prop === "Diffuse" || short === "baseColor" || short === "base_color" || short === "color") {
+                add(material, isPbr ? "albedoColor" : "diffuseColor", Animation.ANIMATIONTYPE_COLOR3, colorKeys(), material.name);
+            }
+            else if (prop === "EmissiveColor" ||
+                prop === "Emissive" ||
+                short === "emissionColor" ||
+                short === "emission_color" ||
+                short === "emissive" ||
+                short === "emit_color") {
+                add(material, "emissiveColor", Animation.ANIMATIONTYPE_COLOR3, colorKeys(), material.name);
+            }
+            else if (prop === "Opacity") {
+                add(material, "alpha", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), material.name);
+            }
+            else if (prop === "TransparencyFactor" || prop === "TransparentFactor") {
+                add(material, "alpha", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => 1 - v), material.name);
+            }
+            else if (isPbr && (short === "roughness" || short === "specular_roughness" || short === "specularRoughness")) {
+                add(material, "roughness", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), material.name);
+            }
+            else if (isPbr && (short === "metalness" || short === "metallic" || short === "base_metalness")) {
+                add(material, "metallic", Animation.ANIMATIONTYPE_FLOAT, scalarKeys((v) => v), material.name);
+            }
+            else if (!isPbr && prop === "SpecularColor") {
+                add(material, "specularColor", Animation.ANIMATIONTYPE_COLOR3, colorKeys(), material.name);
+            }
+            return out;
+        }
+        return out;
+    }
+    /** Records constraints on their nodes and, unless disabled, attaches the runtime behavior that solves them. */
+    _applyConstraints(fbxScene, modelIdToNode, rootNode, scene) {
+        const nodeName = (id) => (id === undefined ? undefined : modelIdToNode.get(id)?.name);
+        const upSign = fbxScene.upAxisSign >= 0 ? 1 : -1;
+        const sceneUp = new Vector3(fbxScene.upAxis === 0 ? upSign : 0, fbxScene.upAxis === 1 ? upSign : 0, fbxScene.upAxis === 2 ? upSign : 0);
+        const summaries = [];
+        for (const c of fbxScene.constraints) {
+            const summary = {
+                name: c.name,
+                type: c.type,
+                node: nodeName(c.nodeId),
+                targets: c.targets.map((t) => ({ node: nodeName(t.modelId), weight: t.weight })),
+                weight: c.weight,
+                active: c.active,
+                ...(c.type === "singleChainIK" ? { firstJoint: nodeName(c.ikFirstJointId), endJoint: nodeName(c.ikEndJointId), effector: nodeName(c.ikEffectorId) } : {}),
+            };
+            summaries.push(summary);
+            const node = c.nodeId !== undefined ? modelIdToNode.get(c.nodeId) : undefined;
+            if (!node) {
+                continue;
+            }
+            const existing = (node.metadata?.fbxConstraints ?? []);
+            node.metadata = { ...(node.metadata ?? {}), fbxConstraints: [...existing, summary] };
+            if (this._options.constraints !== "apply" || c.type === "singleChainIK" || c.type === "unknown") {
+                continue;
+            }
+            const targets = [];
+            for (const t of c.targets) {
+                const targetNode = modelIdToNode.get(t.modelId);
+                if (!targetNode) {
+                    continue;
+                }
+                const d2r = Math.PI / 180;
+                const offset = c.type === "parent"
+                    ? Matrix.Compose(new Vector3(...t.offsetScale), Quaternion.FromRotationMatrix(eulerToMatrixXYZ(t.offsetRotation[0] * d2r, t.offsetRotation[1] * d2r, t.offsetRotation[2] * d2r)), new Vector3(...t.offsetTranslation))
+                    : Matrix.Identity();
+                targets.push({ node: targetNode, weight: t.weight, offset });
+            }
+            if (targets.length === 0) {
+                continue;
+            }
+            const upNode = c.worldUpNodeId !== undefined ? (modelIdToNode.get(c.worldUpNodeId) ?? null) : null;
+            node.addBehavior(new FBXConstraintBehavior(c, { root: rootNode, targets, upNode, sceneUp }));
+        }
+        if (summaries.length > 0) {
+            rootNode.metadata = { ...(rootNode.metadata ?? {}), fbxConstraints: summaries };
+        }
+    }
+    /** Collects every recoverable issue the interpreter recorded, stores it on the root node and notifies the caller. */
+    _reportDiagnostics(fbxScene, rootNode, modelIdToNode) {
+        const warnings = [];
+        const push = (source, d, objectName) => {
+            const message = typeof d === "string" ? d : (d?.message ?? JSON.stringify(d));
+            warnings.push({ source, message, objectName, details: typeof d === "string" ? undefined : d });
+        };
+        for (const d of fbxScene.diagnostics) {
+            // Objects with several parents (shared materials, textures, instanced geometry) are normal in FBX.
+            if (d.subType === "duplicate-parent") {
+                continue;
+            }
+            push("scene", d, d.objectName ?? d.nodeName);
+        }
+        for (const g of fbxScene.geometries) {
+            for (const d of g.diagnostics) {
+                push("geometry", d, g.name);
+            }
+        }
+        for (const c of fbxScene.curves) {
+            for (const d of c.diagnostics) {
+                push("geometry", d, c.name);
+            }
+        }
+        for (const skin of fbxScene.skins) {
+            for (const d of skin.diagnostics) {
+                push("skin", d);
+            }
+            for (const bone of skin.bones) {
+                for (const d of bone.diagnostics) {
+                    push("skin", d, bone.name);
+                }
+            }
+        }
+        for (const rig of fbxScene.rigs) {
+            for (const w of rig.warnings) {
+                push("rig", w);
+            }
+        }
+        for (const stack of fbxScene.animations) {
+            for (const d of stack.diagnostics) {
+                if (d.type === "unsupported-curve-node" && d.curveNodeId !== undefined && this._evaluatedCurveNodeIds.has(d.curveNodeId)) {
+                    continue;
+                }
+                push("animation", d, stack.name);
+            }
+        }
+        for (const cam of fbxScene.cameras) {
+            for (const d of cam.diagnostics) {
+                push("camera", d, cam.name);
+            }
+        }
+        for (const light of fbxScene.lights) {
+            for (const d of light.diagnostics) {
+                push("light", d, light.name);
+            }
+        }
+        const walk = (models) => {
+            for (const m of models) {
+                for (const d of m.diagnostics) {
+                    push("model", d, m.name);
+                }
+                walk(m.children);
+            }
+        };
+        walk(fbxScene.rootModels);
+        rootNode.metadata = {
+            ...(rootNode.metadata ?? {}),
+            fbxDiagnostics: warnings,
+            fbxDisplayLayers: fbxScene.displayLayers.map((l) => ({ name: l.name, show: l.show, freeze: l.freeze, color: l.color })),
+            fbxSelectionSets: fbxScene.selectionSets.map((set) => ({
+                name: set.name,
+                members: set.members.map((m) => ({
+                    node: modelIdToNode.get(m.modelId)?.name ?? String(m.modelId),
+                    includeNode: m.includeNode,
+                    ...(m.vertices ? { vertices: m.vertices } : {}),
+                    ...(m.edges ? { edges: m.edges } : {}),
+                    ...(m.faces ? { faces: m.faces } : {}),
+                })),
+            })),
+        };
+        for (const warning of warnings) {
+            this._options.onWarning(warning);
+        }
+    }
+    /** Curve nodes affecting the inherit scale of a model: its own scale curves and those of its inherit-scale chain. */
+    _collectInheritScaleCurves(modelData) {
+        const result = [];
+        let current = modelData;
+        const seen = new Set();
+        while (current && !seen.has(current.id)) {
+            seen.add(current.id);
+            for (const cn of this._curveNodesByModelId.get(current.id) ?? []) {
+                if (cn.type === "S") {
+                    result.push(cn);
+                }
+            }
+            current = this._getInheritScaleNode(current);
+        }
+        return result;
+    }
     _isVector3KeysConstant(keys) {
         if (keys.length < 2) {
             return true;
@@ -1968,43 +3052,126 @@ export class FBXFileLoader {
         }
         return true;
     }
+    /** Samples the animated Lcl Translation / Rotation / Scaling of a model, blending all layers of the active stack. */
+    _sampleModelTRS(modelData, curveNodes, time) {
+        const layers = this._activeLayers;
+        return {
+            translation: evaluateLayeredChannel(curveNodes, layers, "T", modelData.translation, modelData.rotationOrder, time),
+            rotation: evaluateLayeredChannel(curveNodes, layers, "R", modelData.rotation, modelData.rotationOrder, time),
+            scale: evaluateLayeredChannel(curveNodes, layers, "S", modelData.scale, modelData.rotationOrder, time),
+        };
+    }
+    /**
+     * Local position/rotation/scale of a model from FBX Lcl values. Without pivots and offsets the components map
+     * directly (rotation = pre * lcl * post⁻¹), which keeps zero and negative scales exact. With pivots the full
+     * matrix is built and decomposed.
+     */
+    static _computeLocalTRS(modelData, translation, rotation, scale) {
+        const nz = (v) => v[0] !== 0 || v[1] !== 0 || v[2] !== 0;
+        const d2r = Math.PI / 180;
+        let rotM = eulerToMatrix(rotation[0] * d2r, rotation[1] * d2r, rotation[2] * d2r, modelData.rotationOrder);
+        if (nz(modelData.preRotation)) {
+            rotM = rotM.multiply(eulerToMatrixXYZ(modelData.preRotation[0] * d2r, modelData.preRotation[1] * d2r, modelData.preRotation[2] * d2r));
+        }
+        if (nz(modelData.postRotation)) {
+            const post = eulerToMatrixXYZ(modelData.postRotation[0] * d2r, modelData.postRotation[1] * d2r, modelData.postRotation[2] * d2r);
+            const postInv = new Matrix();
+            post.invertToRef(postInv);
+            rotM = postInv.multiply(rotM);
+        }
+        let position = new Vector3(translation[0], translation[1], translation[2]);
+        if (nz(modelData.rotationPivot) || nz(modelData.scalingPivot) || nz(modelData.rotationOffset) || nz(modelData.scalingOffset)) {
+            // Pivots and offsets only move the translation: the linear part of the FBX local matrix is always S·R.
+            position = FBXFileLoader._computeFBXLocalMatrix(translation, rotation, scale, modelData.preRotation, modelData.postRotation, modelData.rotationPivot, modelData.scalingPivot, modelData.rotationOffset, modelData.scalingOffset, modelData.rotationOrder).getTranslation();
+        }
+        return {
+            position,
+            rotationQuaternion: Quaternion.FromRotationMatrix(rotM),
+            scaling: new Vector3(scale[0], scale[1], scale[2]),
+        };
+    }
+    /** Applies inherit-mode adjustments to a local TRS (see _computeInheritAwareLocalMatrix). */
+    _adjustTRSForInheritMode(modelData, trs, time) {
+        const parent = this._parentModelById.get(modelData.id);
+        if (modelData.inheritType === 1 || !parent) {
+            return;
+        }
+        const parentScale = this._getInheritScale(parent, time);
+        trs.position.x *= parentScale[0];
+        trs.position.y *= parentScale[1];
+        trs.position.z *= parentScale[2];
+        const inheritNode = this._getInheritScaleNode(modelData);
+        if (inheritNode) {
+            const inherited = this._getInheritScale(inheritNode, time);
+            trs.scaling.x *= inherited[0];
+            trs.scaling.y *= inherited[1];
+            trs.scaling.z *= inherited[2];
+        }
+    }
     _sampleModelLocalMatrix(modelData, curveNodes, time, scaleOverride) {
-        const tNode = curveNodes.find((cn) => cn.type === "T");
-        const rNode = curveNodes.find((cn) => cn.type === "R");
-        const sNode = curveNodes.find((cn) => cn.type === "S");
-        const txCurve = tNode?.curves.find((c) => c.channel === "d|X");
-        const tyCurve = tNode?.curves.find((c) => c.channel === "d|Y");
-        const tzCurve = tNode?.curves.find((c) => c.channel === "d|Z");
-        const rxCurve = rNode?.curves.find((c) => c.channel === "d|X");
-        const ryCurve = rNode?.curves.find((c) => c.channel === "d|Y");
-        const rzCurve = rNode?.curves.find((c) => c.channel === "d|Z");
-        const sxCurve = sNode?.curves.find((c) => c.channel === "d|X");
-        const syCurve = sNode?.curves.find((c) => c.channel === "d|Y");
-        const szCurve = sNode?.curves.find((c) => c.channel === "d|Z");
-        return FBXFileLoader._computeFBXLocalMatrix([
-            sampleFBXCurveAtTime(txCurve, time) ?? modelData.translation[0],
-            sampleFBXCurveAtTime(tyCurve, time) ?? modelData.translation[1],
-            sampleFBXCurveAtTime(tzCurve, time) ?? modelData.translation[2],
-        ], [
-            sampleFBXCurveAtTime(rxCurve, time) ?? modelData.rotation[0],
-            sampleFBXCurveAtTime(ryCurve, time) ?? modelData.rotation[1],
-            sampleFBXCurveAtTime(rzCurve, time) ?? modelData.rotation[2],
-        ], scaleOverride ?? [
-            sampleFBXCurveAtTime(sxCurve, time) ?? modelData.scale[0],
-            sampleFBXCurveAtTime(syCurve, time) ?? modelData.scale[1],
-            sampleFBXCurveAtTime(szCurve, time) ?? modelData.scale[2],
-        ], modelData.preRotation, modelData.postRotation, modelData.rotationPivot, modelData.scalingPivot, modelData.rotationOffset, modelData.scalingOffset, modelData.rotationOrder);
+        const trs = this._sampleModelTRS(modelData, curveNodes, time);
+        return FBXFileLoader._computeFBXLocalMatrix(trs.translation, trs.rotation, scaleOverride ?? trs.scale, modelData.preRotation, modelData.postRotation, modelData.rotationPivot, modelData.scalingPivot, modelData.rotationOffset, modelData.scalingOffset, modelData.rotationOrder);
     }
     _sampleModelScale(modelData, curveNodes, time) {
-        const sNode = curveNodes.find((cn) => cn.type === "S");
-        const sxCurve = sNode?.curves.find((c) => c.channel === "d|X");
-        const syCurve = sNode?.curves.find((c) => c.channel === "d|Y");
-        const szCurve = sNode?.curves.find((c) => c.channel === "d|Z");
-        return [
-            sampleFBXCurveAtTime(sxCurve, time) ?? modelData.scale[0],
-            sampleFBXCurveAtTime(syCurve, time) ?? modelData.scale[1],
-            sampleFBXCurveAtTime(szCurve, time) ?? modelData.scale[2],
-        ];
+        return evaluateLayeredChannel(curveNodes, this._activeLayers, "S", modelData.scale, modelData.rotationOrder, time);
+    }
+    /**
+     * Effective scale of a model for inherit-mode math (`inherit_scale` in ufbx terms): its own local scale, multiplied
+     * componentwise by the inherited scale when the model uses RrSs inheritance. `time` samples animation; undefined
+     * uses the rest pose.
+     */
+    _getInheritScale(modelData, time) {
+        if (!modelData) {
+            return [1, 1, 1];
+        }
+        const own = time === undefined ? modelData.scale : this._sampleModelScale(modelData, this._curveNodesByModelId.get(modelData.id) ?? [], time);
+        const inheritNode = this._getInheritScaleNode(modelData);
+        if (!inheritNode) {
+            return [own[0], own[1], own[2]];
+        }
+        const parentScale = this._getInheritScale(inheritNode, time);
+        return [own[0] * parentScale[0], own[1] * parentScale[1], own[2] * parentScale[2]];
+    }
+    /** RrSs nodes inherit scale from their parent; Rrs nodes skip their immediate parent (chaining through Rrs parents). */
+    _getInheritScaleNode(modelData) {
+        const parent = this._parentModelById.get(modelData.id);
+        if (!parent) {
+            return undefined;
+        }
+        if (modelData.inheritType === 0) {
+            return parent;
+        }
+        if (modelData.inheritType === 2) {
+            return this._getInheritScaleNode(parent);
+        }
+        return undefined;
+    }
+    /**
+     * Local matrix of a model relative to its Babylon parent frame, accounting for inherit modes. For RSrs (the
+     * default) this is the FBX local matrix. For RrSs / Rrs the node sits under a helper that removes the parent's
+     * scale, so translation is pre-scaled by the parent scale and (for RrSs) scale accumulates componentwise.
+     */
+    _computeInheritAwareLocalMatrix(modelData, localMatrix, time) {
+        const parent = this._parentModelById.get(modelData.id);
+        if (modelData.inheritType === 1 || !parent) {
+            return localMatrix;
+        }
+        const s = new Vector3();
+        const r = new Quaternion();
+        const t = new Vector3();
+        localMatrix.decompose(s, r, t);
+        const parentScale = this._getInheritScale(parent, time);
+        t.x *= parentScale[0];
+        t.y *= parentScale[1];
+        t.z *= parentScale[2];
+        const inheritNode = this._getInheritScaleNode(modelData);
+        if (inheritNode) {
+            const inherited = this._getInheritScale(inheritNode, time);
+            s.x *= inherited[0];
+            s.y *= inherited[1];
+            s.z *= inherited[2];
+        }
+        return Matrix.Compose(s, r, t);
     }
     /**
      * Build matrix-baked bone animation from full FBX local transforms.
@@ -2012,25 +3179,13 @@ export class FBXFileLoader {
      * the same FBX local transform chain as the source skeleton.
      */
     _buildBoneAnimations(curveNodes, boneName, modelData, startTime, stopTime, bindLocalMatrix) {
-        const fps = 30;
-        // Separate curves by type
-        const tNode = curveNodes.find((cn) => cn.type === "T");
+        const fps = this._frameRate;
         const rNode = curveNodes.find((cn) => cn.type === "R");
-        const sNode = curveNodes.find((cn) => cn.type === "S");
-        const times = collectAnimationSampleTimes(curveNodes, fps, startTime, stopTime);
-        if (times.length === 0) {
+        const baseTimes = collectAnimationSampleTimes(curveNodes, fps, startTime, stopTime);
+        if (baseTimes.length === 0) {
             return [];
         }
-        // Get curve accessors
-        const txCurve = tNode?.curves.find((c) => c.channel === "d|X");
-        const tyCurve = tNode?.curves.find((c) => c.channel === "d|Y");
-        const tzCurve = tNode?.curves.find((c) => c.channel === "d|Z");
-        const rxCurve = rNode?.curves.find((c) => c.channel === "d|X");
-        const ryCurve = rNode?.curves.find((c) => c.channel === "d|Y");
-        const rzCurve = rNode?.curves.find((c) => c.channel === "d|Z");
-        const sxCurve = sNode?.curves.find((c) => c.channel === "d|X");
-        const syCurve = sNode?.curves.find((c) => c.channel === "d|Y");
-        const szCurve = sNode?.curves.find((c) => c.channel === "d|Z");
+        const times = FBXFileLoader._refineSampleTimes(baseTimes, (time) => this._sampleModelLocalMatrix(modelData, curveNodes, time));
         const posKeys = [];
         const rotKeys = [];
         const sclKeys = [];
@@ -2043,18 +3198,8 @@ export class FBXFileLoader {
         }
         for (const time of times) {
             const frame = time * fps;
-            // Sample animated values, falling back to model's base values
-            const tx = sampleFBXCurveAtTime(txCurve, time) ?? modelData.translation[0];
-            const ty = sampleFBXCurveAtTime(tyCurve, time) ?? modelData.translation[1];
-            const tz = sampleFBXCurveAtTime(tzCurve, time) ?? modelData.translation[2];
-            const rx = sampleFBXCurveAtTime(rxCurve, time) ?? modelData.rotation[0];
-            const ry = sampleFBXCurveAtTime(ryCurve, time) ?? modelData.rotation[1];
-            const rz = sampleFBXCurveAtTime(rzCurve, time) ?? modelData.rotation[2];
-            const sx = sampleFBXCurveAtTime(sxCurve, time) ?? modelData.scale[0];
-            const sy = sampleFBXCurveAtTime(syCurve, time) ?? modelData.scale[1];
-            const sz = sampleFBXCurveAtTime(szCurve, time) ?? modelData.scale[2];
-            // Compute the full FBX local matrix from animated Lcl values
-            const localMatrix = FBXFileLoader._computeFBXLocalMatrix([tx, ty, tz], [rx, ry, rz], [sx, sy, sz], modelData.preRotation, modelData.postRotation, modelData.rotationPivot, modelData.scalingPivot, modelData.rotationOffset, modelData.scalingOffset, modelData.rotationOrder);
+            // Compute the full FBX local matrix from animated Lcl values, blending all layers
+            const localMatrix = this._sampleModelLocalMatrix(modelData, curveNodes, time);
             const correctedLocalMatrix = restLocalInverse && bindLocalMatrix ? bindLocalMatrix.multiply(restLocalInverse).multiply(localMatrix) : localMatrix;
             const s = new Vector3();
             const r = new Quaternion();
@@ -2372,17 +3517,31 @@ function calculateBlendShapeInfluences(deformPercent, fullWeights, shapeCount) {
 function clamp01(value) {
     return Math.max(0, Math.min(1, value));
 }
+/** Interior frames kept between two keys when the segment is cubic or extrapolated. */
+const MAX_DENSE_SEGMENT_SAMPLES = 512;
+/** Interior frames kept between two keys when every curve is linear or constant there. */
+const MAX_LINEAR_SEGMENT_SAMPLES = 32;
+/** Upper bound on samples per animated node, beyond which the frame stride grows. */
+const MAX_SAMPLES_PER_TARGET = 100000;
+/**
+ * Times at which the animation is baked: every key time plus the frame grid between keys. Segments where every
+ * curve is linear or constant only get a few interior frames (Babylon interpolates linearly between the baked
+ * keys), cubic or extrapolated segments get the full frame grid up to a cap, so day-long clips with a handful of
+ * keys do not explode into millions of samples.
+ */
 function collectAnimationSampleTimes(curveNodes, fps, startTime, stopTime) {
     let minTime = Number.POSITIVE_INFINITY;
     let maxTime = Number.NEGATIVE_INFINITY;
-    const sourceTimes = new Set();
+    const anchorSet = new Set();
+    const curves = [];
     for (const curveNode of curveNodes) {
         for (const curve of curveNode.curves) {
+            curves.push(curve);
             for (const key of curve.keys) {
                 minTime = Math.min(minTime, key.time);
                 maxTime = Math.max(maxTime, key.time);
                 if (key.time >= startTime && key.time <= stopTime) {
-                    sourceTimes.add(key.time);
+                    anchorSet.add(key.time);
                 }
             }
         }
@@ -2392,13 +3551,81 @@ function collectAnimationSampleTimes(curveNodes, fps, startTime, stopTime) {
     }
     const rangeStart = stopTime > startTime ? startTime : minTime;
     const rangeStop = stopTime > startTime ? stopTime : maxTime;
-    const times = new Set([rangeStart, rangeStop, ...Array.from(sourceTimes)]);
-    const startFrame = Math.ceil(rangeStart * fps);
-    const stopFrame = Math.floor(rangeStop * fps);
-    for (let frame = startFrame; frame <= stopFrame; frame++) {
-        times.add(frame / fps);
+    anchorSet.add(rangeStart);
+    anchorSet.add(rangeStop);
+    const anchors = Array.from(anchorSet)
+        .filter((t) => t >= rangeStart && t <= rangeStop)
+        .sort((a, b) => a - b);
+    // A segment needs the dense grid when any curve is cubic there or extrapolates a non-constant pattern.
+    const segmentIsDense = (t0) => {
+        for (const curve of curves) {
+            const keys = curve.keys;
+            if (keys.length === 0) {
+                continue;
+            }
+            if (t0 < keys[0].time) {
+                if (curve.preExtrapolation && curve.preExtrapolation.mode !== "constant") {
+                    return true;
+                }
+                continue;
+            }
+            if (t0 >= keys[keys.length - 1].time) {
+                if (curve.postExtrapolation && curve.postExtrapolation.mode !== "constant") {
+                    return true;
+                }
+                continue;
+            }
+            let lo = 0;
+            let hi = keys.length - 1;
+            while (hi - lo > 1) {
+                const mid = (lo + hi) >> 1;
+                if (keys[mid].time <= t0) {
+                    lo = mid;
+                }
+                else {
+                    hi = mid;
+                }
+            }
+            if (keys[lo].interpolation === "cubic") {
+                return true;
+            }
+        }
+        return false;
+    };
+    const times = [];
+    const totalFrames = Math.floor(rangeStop * fps) - Math.ceil(rangeStart * fps) + 1;
+    const stride = Math.max(1, Math.ceil(totalFrames / MAX_SAMPLES_PER_TARGET));
+    for (let i = 0; i < anchors.length; i++) {
+        const t0 = anchors[i];
+        times.push(t0);
+        if (i + 1 >= anchors.length) {
+            break;
+        }
+        const t1 = anchors[i + 1];
+        const firstFrame = Math.floor(t0 * fps) + 1;
+        const lastFrame = Math.ceil(t1 * fps) - 1;
+        const interior = lastFrame - firstFrame + 1;
+        if (interior <= 0) {
+            continue;
+        }
+        const cap = segmentIsDense(t0) ? MAX_DENSE_SEGMENT_SAMPLES : MAX_LINEAR_SEGMENT_SAMPLES;
+        const step = Math.max(stride, Math.ceil(interior / cap));
+        for (let frame = firstFrame; frame <= lastFrame; frame += step) {
+            times.push(frame / fps);
+        }
+    }
+    const sorted = times.sort((a, b) => a - b);
+    // Key times and frame times can differ by floating point noise; keep one sample per instant.
+    const deduped = [];
+    for (const t of sorted) {
+        if (t < rangeStart - 1e-9 || t > rangeStop + 1e-9) {
+            continue;
+        }
+        if (deduped.length === 0 || t - deduped[deduped.length - 1] > 1e-9) {
+            deduped.push(t);
+        }
     }
-    return Array.from(times).sort((a, b) => a - b);
+    return deduped;
 }
 function areQuaternionKeysConstant(keys) {
     if (keys.length < 2) {
@@ -2428,6 +3655,10 @@ function buildScalarAnimationKeys(curve, fps, startTime, stopTime, mapValue) {
                 time: range.start,
                 value: sampleFBXCurveAtTime(curve, range.start) ?? 0,
                 interpolation: "linear",
+                leftDx: 0,
+                leftDy: 0,
+                rightDx: 0,
+                rightDy: 0,
             },
             frame: range.start * fps,
             value: mapValue(sampleFBXCurveAtTime(curve, range.start) ?? 0),
@@ -2439,6 +3670,10 @@ function buildScalarAnimationKeys(curve, fps, startTime, stopTime, mapValue) {
                 time: range.stop,
                 value: sampleFBXCurveAtTime(curve, range.stop) ?? 0,
                 interpolation: "linear",
+                leftDx: 0,
+                leftDy: 0,
+                rightDx: 0,
+                rightDy: 0,
             },
             frame: range.stop * fps,
             value: mapValue(sampleFBXCurveAtTime(curve, range.stop) ?? 0),