@babylonjs/loaders 9.26.0 → 9.26.1

package/FBX/interpreter/fbxInterpreter.js

@@ -1,18 +1,38 @@
 /* eslint-disable @typescript-eslint/naming-convention, jsdoc/require-param, jsdoc/require-returns */
-import { findDocumentNode, findChildByName, getPropertyValue, cleanFBXName } from "../types/fbxTypes.js";
+import { extractNodeTransform } from "./nodeTransform.js";
+import { extractUserProperties, getPropertyEntries, extractPropertyTemplates, getPropertyTemplate, resolveNumberProperty, resolvePropertyValue, resolveVector3Property, } from "./propertyTemplates.js";
+import { findDocumentNode, findChildByName, getPropertyValue, cleanFBXName, getNodeArray } from "../types/fbxTypes.js";
 import { resolveConnections, getChildren } from "./connections.js";
 import { extractGeometry } from "./geometry.js";
-import { extractMaterial } from "./materials.js";
+import { extractLineGeometry, extractNurbsCurveGeometry, nurbsSurfaceToGeometry } from "./nurbs.js";
+import { isLegacyDocument, upgradeLegacyDocument } from "./legacyDocument.js";
+import { extractConstraints } from "./constraints.js";
+import { extractMaterial, extractTextureRef } from "./materials.js";
 import { extractSkins } from "./skeleton.js";
 import { resolveRigs } from "./rig.js";
 import { extractAnimations } from "./animation.js";
 import { extractBlendShapes } from "./blendShapes.js";
 import { extractSceneDiagnostics } from "./sceneDiagnostics.js";
-import { extractPropertyTemplates, getPropertyTemplate, resolveNumberProperty, resolvePropertyValue, resolveVector3Property, } from "./propertyTemplates.js";
 /**
- * Interpret a parsed FBX document into scene data.
+ * Tessellated NURBS vertices carry no control point mapping, so skin clusters and blend shapes bound to the surface
+ * cannot be applied; they are reported and the surface is imported undeformed.
  */
-export function interpretFBX(doc) {
+function flagNurbsDeformers(objectMap, geometryId, geometry) {
+    const kinds = getChildren(objectMap, geometryId, "Deformer")
+        .map((d) => getPropertyValue(d.node, 2) ?? "")
+        .filter((kind) => kind === "Skin" || kind === "BlendShape");
+    if (kinds.length === 0) {
+        return;
+    }
+    geometry.diagnostics.push({
+        type: "nurbs-deformer-ignored",
+        message: `${Array.from(new Set(kinds)).join(" and ")} deformer on NURBS surface '${geometry.name}' is ignored: the tessellated mesh has no control point mapping.`,
+    });
+}
+export function interpretFBX(doc, options = {}) {
+    if (isLegacyDocument(doc)) {
+        doc = upgradeLegacyDocument(doc);
+    }
     const objectMap = resolveConnections(doc);
     const propertyTemplates = extractPropertyTemplates(doc);
     // Extract global settings
@@ -24,32 +44,70 @@ export function interpretFBX(doc) {
             materials.push(extractMaterial(node, id, objectMap, propertyTemplates));
         }
     }
+    attachLegacyLayerTextures(objectMap, materials, propertyTemplates);
     // Extract all geometries
     const geometries = [];
+    const curves = [];
     for (const [id, node] of Array.from(objectMap.objects)) {
         if (node.name === "Geometry") {
             const subType = getPropertyValue(node, 2);
             if (subType === "Mesh") {
-                geometries.push(extractGeometry(node, id));
+                const geometry = extractGeometry(node, id);
+                // Edge-only or empty meshes have nothing to render; keep the node but drop the mesh.
+                if (geometry.positions.length > 0 && geometry.indices.length > 0) {
+                    geometries.push(geometry);
+                }
+            }
+            else if (subType === "NurbsSurface") {
+                const geometry = nurbsSurfaceToGeometry(node, id, options.nurbsSubdivision);
+                if (geometry) {
+                    flagNurbsDeformers(objectMap, id, geometry);
+                    geometries.push(geometry);
+                }
+            }
+            else if (subType === "TrimNurbsSurface") {
+                // The trimmed surface is rendered untrimmed: the underlying NurbsSurface is a child of the trim.
+                const surfaceChild = getChildren(objectMap, id, "Geometry").find((child) => getPropertyValue(child.node, 2) === "NurbsSurface");
+                const geometry = surfaceChild ? nurbsSurfaceToGeometry(surfaceChild.node, id, options.nurbsSubdivision) : null;
+                if (geometry) {
+                    flagNurbsDeformers(objectMap, id, geometry);
+                    geometry.diagnostics.push({
+                        type: "nurbs-trim-ignored",
+                        message: `Trim curves of NURBS surface '${geometry.name}' are ignored; the surface is rendered untrimmed.`,
+                    });
+                    geometries.push(geometry);
+                }
+            }
+            else if (subType === "NurbsCurve") {
+                curves.push(extractNurbsCurveGeometry(node, id));
+            }
+            else if (subType === "Line") {
+                curves.push(extractLineGeometry(node, id));
             }
         }
     }
     // Extract skeleton/skinning data
-    const skins = extractSkins(objectMap);
+    const skins = extractSkins(objectMap, propertyTemplates);
     const rigs = resolveRigs(objectMap, skins);
     // Extract blend shape data
     const blendShapes = extractBlendShapes(objectMap);
     // Extract animation data
-    const animations = extractAnimations(objectMap);
+    const animations = extractAnimations(objectMap, doc, { rebaseKeyframes: options.rebaseKeyframes ?? true });
     // Extract cameras and lights from NodeAttribute objects
     const cameras = extractCameras(objectMap, propertyTemplates);
     const lights = extractLights(objectMap, propertyTemplates);
     const diagnostics = extractSceneDiagnostics(objectMap);
+    const constraints = extractConstraints(objectMap);
     // Build model hierarchy
-    const rootModels = buildModelHierarchy(objectMap, geometries, materials, propertyTemplates);
+    const rootModels = buildModelHierarchy(objectMap, geometries, curves, materials, propertyTemplates);
+    const { displayLayers, selectionSets } = extractCollections(objectMap, rootModels);
     return {
         rootModels,
+        displayLayers,
+        selectionSets,
+        constraints,
         geometries,
+        curves,
         materials,
         skins,
         rigs,
@@ -61,12 +119,115 @@ export function interpretFBX(doc) {
         ...globalSettings,
     };
 }
+// ── Legacy textures ────────────────────────────────────────────────────────────
+/**
+ * Pre-7000 files connect textures to the Model and select them per polygon through the mesh's LayerElementTexture
+ * (TextureId indexes the model's textures), instead of connecting textures to material properties. Assign those
+ * textures to the diffuse slot of the material used by the same polygons.
+ */
+function attachLegacyLayerTextures(objectMap, materials, templates) {
+    const materialById = new Map(materials.map((m) => [m.id, m]));
+    const textureTemplate = getPropertyTemplate(templates, "Texture", "FbxFileTexture") ?? getPropertyTemplate(templates, "Texture");
+    for (const [modelId, modelNode] of Array.from(objectMap.objects)) {
+        if (modelNode.name !== "Model") {
+            continue;
+        }
+        const textureChildren = getChildren(objectMap, modelId, "Texture");
+        if (textureChildren.length === 0) {
+            continue;
+        }
+        const modelMaterials = getChildren(objectMap, modelId, "Material")
+            .filter((c) => !c.propertyName)
+            .map((c) => materialById.get(c.id))
+            .filter((m) => m !== undefined);
+        if (modelMaterials.length === 0) {
+            continue;
+        }
+        const geometryNode = getChildren(objectMap, modelId, "Geometry")[0]?.node ?? modelNode;
+        const materialLayer = findChildByName(geometryNode, "LayerElementMaterial");
+        const materialIds = materialLayer ? getNodeArray(findChildByName(materialLayer, "Materials")) : null;
+        // Each texture kind has its own layer element: LayerElementTexture (diffuse), LayerElementEmissiveTextures,
+        // LayerElementSpecularTextures, LayerElementBumpTextures, ...
+        const slotForElement = (elementName) => {
+            const kind = elementName.replace(/^LayerElement/, "").replace(/Textures?$/, "");
+            switch (kind) {
+                case "":
+                case "Diffuse":
+                    return { prop: "DiffuseColor", fbx: "diffuseColor", pbr: "baseColor" };
+                case "Emissive":
+                    return { prop: "EmissiveColor", fbx: "emissionColor", pbr: "emissionColor" };
+                case "Specular":
+                    return { prop: "SpecularColor", fbx: "specularColor", pbr: "specularColor" };
+                case "Ambient":
+                    return { prop: "AmbientColor", fbx: "ambientColor", pbr: "ambientOcclusion" };
+                case "Bump":
+                case "NormalMap":
+                    return { prop: "NormalMap", fbx: "normalMap", pbr: "normalMap" };
+                case "Transparent":
+                    return { prop: "TransparentColor", fbx: "transparencyColor", pbr: "opacity" };
+                case "Reflection":
+                    return { prop: "ReflectionColor", fbx: "reflectionColor", pbr: "specularColor" };
+                case "Shininess":
+                    return { prop: "ShininessExponent", fbx: "specularExponent", pbr: "roughness" };
+                case "Displacement":
+                    return { prop: "DisplacementColor", fbx: "displacement", pbr: "displacementMap" };
+                default:
+                    return null;
+            }
+        };
+        const layerElements = geometryNode.children.filter((c) => /^LayerElement\w*Textures?$/.test(c.name));
+        const textureRefs = textureChildren.map(({ id, node }) => extractTextureRef(id, node, undefined, objectMap, textureTemplate));
+        const assign = (materialIndex, textureIndex, slot) => {
+            var _a, _b, _c, _d;
+            const material = modelMaterials[materialIndex];
+            const source = textureRefs[textureIndex];
+            if (!material || !source || material.textures.some((t) => t.propertyName === slot.prop)) {
+                return;
+            }
+            const ref = { ...source, propertyName: slot.prop };
+            material.textures.push(ref);
+            const fbxMap = ((_a = material.model.fbx)[_b = slot.fbx] ?? (_a[_b] = { valueComponents: 0, textureEnabled: false }));
+            fbxMap.texture = ref;
+            fbxMap.textureEnabled = true;
+            const pbrMap = ((_c = material.model.pbr)[_d = slot.pbr] ?? (_c[_d] = { valueComponents: 0, textureEnabled: false }));
+            pbrMap.texture = ref;
+            pbrMap.textureEnabled = true;
+        };
+        if (layerElements.length === 0) {
+            // No layer element: a single texture on a single-material model is the diffuse map.
+            if (modelMaterials.length === 1 && textureRefs.length === 1) {
+                assign(0, 0, slotForElement("LayerElementTexture"));
+            }
+            continue;
+        }
+        for (const element of layerElements) {
+            const slot = slotForElement(element.name);
+            const textureIds = getNodeArray(findChildByName(element, "TextureId"));
+            if (!slot || !textureIds || textureIds.length === 0) {
+                continue;
+            }
+            const polygonCount = Math.max(textureIds.length, materialIds?.length ?? 0);
+            for (let poly = 0; poly < polygonCount; poly++) {
+                const texIndex = textureIds[Math.min(poly, textureIds.length - 1)];
+                const matIndex = materialIds && materialIds.length > 0 ? materialIds[Math.min(poly, materialIds.length - 1)] : 0;
+                if (texIndex >= 0) {
+                    assign(matIndex, texIndex, slot);
+                }
+            }
+        }
+    }
+}
 // ── Model Hierarchy ────────────────────────────────────────────────────────────
-function buildModelHierarchy(objectMap, geometries, materials, propertyTemplates) {
+const MAX_MODEL_DEPTH = 512;
+function buildModelHierarchy(objectMap, geometries, curves, materials, propertyTemplates) {
     const geometryMap = new Map();
     for (const g of geometries) {
         geometryMap.set(g.id, g);
     }
+    const curveMap = new Map();
+    for (const c of curves) {
+        curveMap.set(c.id, c);
+    }
     const materialMap = new Map();
     for (const m of materials) {
         materialMap.set(m.id, m);
@@ -74,20 +235,44 @@ function buildModelHierarchy(objectMap, geometries, materials, propertyTemplates
     // Find root models (those connected to ID 0, which is the scene root)
     const rootChildren = objectMap.childrenOf.get(0) ?? [];
     const rootModels = [];
+    const rootIds = new Set();
+    const buildStack = new Set();
     for (const { id } of rootChildren) {
         const node = objectMap.objects.get(id);
-        if (node && node.name === "Model") {
-            rootModels.push(buildModel(id, node, objectMap, geometryMap, materialMap, propertyTemplates));
+        if (node && node.name === "Model" && !rootIds.has(id)) {
+            rootIds.add(id);
+            rootModels.push(buildModel(id, node, objectMap, geometryMap, curveMap, materialMap, propertyTemplates, buildStack));
+        }
+    }
+    // Models without any Model (or scene root) parent connection also live at the root, as in the FBX SDK.
+    // Typical examples are the default "Producer" cameras and the camera switcher written by Maya, MotionBuilder
+    // and Blender in 6.x files, which are never connected.
+    const hasModelParent = new Set();
+    for (const conn of objectMap.connections) {
+        if (conn.type !== "OO") {
+            continue;
+        }
+        const parentNode = objectMap.objects.get(conn.parentId);
+        if (conn.parentId === 0 || parentNode?.name === "Model") {
+            hasModelParent.add(conn.childId);
+        }
+    }
+    for (const [id, node] of Array.from(objectMap.objects)) {
+        if (node.name === "Model" && !hasModelParent.has(id) && !rootIds.has(id)) {
+            rootIds.add(id);
+            rootModels.push(buildModel(id, node, objectMap, geometryMap, curveMap, materialMap, propertyTemplates, buildStack));
         }
     }
     return rootModels;
 }
-function buildModel(modelId, modelNode, objectMap, geometryMap, materialMap, propertyTemplates) {
+function buildModel(modelId, modelNode, objectMap, geometryMap, curveMap, materialMap, propertyTemplates, buildStack) {
     const name = cleanFBXName(getPropertyValue(modelNode, 1) ?? "Model");
+    buildStack.add(modelId);
     const subType = getPropertyValue(modelNode, 2) ?? "Null";
     // Find attached geometry
     const geomChildren = getChildren(objectMap, modelId, "Geometry");
-    const geometry = geomChildren.length > 0 ? geometryMap.get(geomChildren[0].id) : undefined;
+    const geometry = geomChildren.map((child) => geometryMap.get(child.id)).find((g) => g !== undefined);
+    const curve = geomChildren.map((child) => curveMap.get(child.id)).find((c) => c !== undefined);
     // Find attached materials
     const matChildren = getChildren(objectMap, modelId, "Material");
     const modelMaterials = [];
@@ -100,16 +285,52 @@ function buildModel(modelId, modelNode, objectMap, geometryMap, materialMap, pro
     // Extract transform
     const transform = extractTransform(modelNode, getPropertyTemplate(propertyTemplates, "Model", "FbxNode") ?? getPropertyTemplate(propertyTemplates, "Model"));
     // Recursively build child models
-    const childModelNodes = getChildren(objectMap, modelId, "Model");
+    // Only object-object connections express parenting; OP connections (look-at targets, constraint sources) do not.
+    const childModelNodes = getChildren(objectMap, modelId, "Model").filter((child) => !child.propertyName);
     const children = [];
+    const cycleDiagnostics = [];
     for (const { id, node } of childModelNodes) {
-        children.push(buildModel(id, node, objectMap, geometryMap, materialMap, propertyTemplates));
+        if (buildStack.size > MAX_MODEL_DEPTH) {
+            cycleDiagnostics.push(`Model hierarchy deeper than ${MAX_MODEL_DEPTH} levels; deeper children were skipped.`);
+            break;
+        }
+        if (buildStack.has(id)) {
+            // Malformed files (duplicate ids, recursive connections) can make a model its own ancestor.
+            cycleDiagnostics.push(`Model connection cycle detected at '${cleanFBXName(getPropertyValue(node, 1) ?? "")}'; the recursive child was skipped.`);
+            continue;
+        }
+        children.push(buildModel(id, node, objectMap, geometryMap, curveMap, materialMap, propertyTemplates, buildStack));
     }
+    buildStack.delete(modelId);
     // Extract culling
     const cullingNode = modelNode.children.find((c) => c.name === "Culling");
     const cullingOff = cullingNode ? getPropertyValue(cullingNode, 0) === "CullingOff" : false;
     // Extract user-defined custom properties
     const customProperties = extractCustomProperties(modelNode);
+    // LOD groups carry their thresholds on the LodGroup node attribute
+    let lodGroup;
+    if (subType === "LodGroup") {
+        const attribute = getChildren(objectMap, modelId, "NodeAttribute").find((a) => getPropertyValue(a.node, 2) === "LodGroup");
+        const entries = attribute ? getPropertyEntries(attribute.node) : [];
+        const thresholds = [];
+        const displayLevels = [];
+        for (let i = 0;; i++) {
+            const entry = entries.find((e) => e.name === `Thresholds|Level${i}`);
+            if (!entry) {
+                break;
+            }
+            thresholds.push(typeof entry.values[0] === "number" ? entry.values[0] : 0);
+        }
+        for (let i = 0;; i++) {
+            const entry = entries.find((e) => e.name === `DisplayLevels|Level${i}`);
+            if (!entry) {
+                break;
+            }
+            displayLevels.push(typeof entry.values[0] === "number" ? entry.values[0] : 0);
+        }
+        const relativeEntry = entries.find((e) => e.name === "ThresholdsUsedAsPercentage");
+        lodGroup = { thresholds, relative: !!relativeEntry && relativeEntry.values[0] !== 0 && relativeEntry.values[0] !== false, displayLevels };
+    }
     return {
         id: modelId,
         name,
@@ -119,47 +340,87 @@ function buildModel(modelId, modelNode, objectMap, geometryMap, materialMap, pro
         children,
         cullingOff,
         customProperties,
+        lodGroup,
+        curve,
         ...transform,
+        diagnostics: [...transform.diagnostics, ...cycleDiagnostics],
     };
 }
-function extractTransform(modelNode, template) {
-    const translation = resolveVector3Property(modelNode, template, "Lcl Translation", [0, 0, 0]);
-    const rotation = resolveVector3Property(modelNode, template, "Lcl Rotation", [0, 0, 0]);
-    const scale = resolveVector3Property(modelNode, template, "Lcl Scaling", [1, 1, 1]);
-    const preRotation = resolveVector3Property(modelNode, template, "PreRotation", [0, 0, 0]);
-    const postRotation = resolveVector3Property(modelNode, template, "PostRotation", [0, 0, 0]);
-    const rotationPivot = resolveVector3Property(modelNode, template, "RotationPivot", [0, 0, 0]);
-    const scalingPivot = resolveVector3Property(modelNode, template, "ScalingPivot", [0, 0, 0]);
-    const rotationOffset = resolveVector3Property(modelNode, template, "RotationOffset", [0, 0, 0]);
-    const scalingOffset = resolveVector3Property(modelNode, template, "ScalingOffset", [0, 0, 0]);
-    const geometricTranslation = resolveVector3Property(modelNode, template, "GeometricTranslation", [0, 0, 0]);
-    const geometricRotation = resolveVector3Property(modelNode, template, "GeometricRotation", [0, 0, 0]);
-    const geometricScaling = resolveVector3Property(modelNode, template, "GeometricScaling", [1, 1, 1]);
-    const rotationOrder = resolveNumberProperty(modelNode, template, "RotationOrder", 0);
-    const inheritType = resolveNumberProperty(modelNode, template, "InheritType", 1);
-    const diagnostics = inheritType !== 1 && inheritType !== 2
-        ? [
-            `InheritType ${inheritType} is parsed and preserved; runtime parent-scale inheritance remains gated to avoid changing existing visual behavior without a fixture-specific baseline.`,
-        ]
-        : [];
-    return {
-        translation,
-        rotation,
-        scale,
-        preRotation,
-        postRotation,
-        rotationPivot,
-        scalingPivot,
-        rotationOffset,
-        scalingOffset,
-        geometricTranslation,
-        geometricRotation,
-        geometricScaling,
-        rotationOrder,
-        inheritType,
-        diagnostics,
+/** Display layers and selection sets: which models belong to which collection. */
+function extractCollections(objectMap, rootModels) {
+    const modelById = new Map();
+    const walk = (models) => {
+        for (const m of models) {
+            modelById.set(m.id, m);
+            walk(m.children);
+        }
     };
+    walk(rootModels);
+    const displayLayers = [];
+    const selectionSets = [];
+    for (const [id, node] of Array.from(objectMap.objects)) {
+        if (node.name === "CollectionExclusive") {
+            const entries = getPropertyEntries(node);
+            const num = (name, fallback) => {
+                const v = entries.find((e) => e.name === name)?.values[0];
+                return typeof v === "number" ? v : typeof v === "boolean" ? (v ? 1 : 0) : fallback;
+            };
+            const colorValues = entries.find((e) => e.name === "Color")?.values;
+            const color = colorValues && typeof colorValues[0] === "number" && typeof colorValues[1] === "number" && typeof colorValues[2] === "number"
+                ? [colorValues[0], colorValues[1], colorValues[2]]
+                : [0.8, 0.8, 0.8];
+            const layer = {
+                id,
+                name: cleanFBXName(getPropertyValue(node, 1) ?? "DisplayLayer"),
+                show: num("Show", 1) !== 0,
+                freeze: num("Freeze", 0) !== 0,
+                color,
+                modelIds: getChildren(objectMap, id, "Model").map((c) => c.id),
+            };
+            displayLayers.push(layer);
+            for (const modelId of layer.modelIds) {
+                const model = modelById.get(modelId);
+                if (model) {
+                    model.displayLayer = layer;
+                }
+            }
+        }
+        else if (node.name === "SelectionSet" || (node.name === "Collection" && getPropertyValue(node, 2) === "SelectionSet")) {
+            const members = [];
+            for (const child of getChildren(objectMap, id)) {
+                if (child.node.name === "Model") {
+                    members.push({ modelId: child.id, includeNode: true });
+                }
+                else if (child.node.name === "SelectionNode") {
+                    const indices = (name) => {
+                        const arrayNode = findChildByName(child.node, name);
+                        if (!arrayNode) {
+                            return undefined;
+                        }
+                        return Array.from(getNodeArray(arrayNode));
+                    };
+                    const inSet = findChildByName(child.node, "IsTheNodeInSet")?.properties[0]?.value;
+                    for (const target of getChildren(objectMap, child.id, "Model")) {
+                        members.push({
+                            modelId: target.id,
+                            includeNode: inSet === undefined || inSet === 1 || inSet === true,
+                            vertices: indices("VertexIndexArray"),
+                            edges: indices("EdgeIndexArray"),
+                            faces: indices("PolygonIndexArray"),
+                        });
+                    }
+                }
+            }
+            selectionSets.push({ id, name: cleanFBXName(getPropertyValue(node, 1) ?? "SelectionSet"), members });
+        }
+    }
+    return { displayLayers, selectionSets };
+}
+function extractTransform(modelNode, template) {
+    return extractNodeTransform(modelNode, template);
 }
+// Frame rates per FBX TimeMode enum value (eDefaultMode, eFrames120, ... eFrames59dot94).
+const TIME_MODE_FPS = [30, 120, 100, 60, 50, 48, 30, 30, 29.97, 29.97, 25, 24, 1000, 23.976, 24, 96, 72, 59.94];
 function extractGlobalSettings(doc) {
     const defaults = {
         upAxis: 1,
@@ -169,21 +430,16 @@ function extractGlobalSettings(doc) {
         coordAxis: 0,
         coordAxisSign: 1,
         unitScaleFactor: 1,
+        frameRate: 30,
     };
     const gsNode = findDocumentNode(doc, "GlobalSettings");
     if (!gsNode) {
         return defaults;
     }
-    const props70 = gsNode.children.find((c) => c.name === "Properties70");
-    if (!props70) {
-        return defaults;
-    }
-    for (const p of props70.children) {
-        if (p.name !== "P") {
-            continue;
-        }
-        const propName = getPropertyValue(p, 0);
-        const value = toNumber(p.properties[4]?.value);
+    let timeMode = 0;
+    let customFrameRate = 24;
+    for (const { name: propName, values } of getPropertyEntries(gsNode)) {
+        const value = toNumber(values[0]);
         if (propName && value !== undefined) {
             switch (propName) {
                 case "UpAxis":
@@ -207,9 +463,21 @@ function extractGlobalSettings(doc) {
                 case "UnitScaleFactor":
                     defaults.unitScaleFactor = value;
                     break;
+                case "TimeMode":
+                    timeMode = value;
+                    break;
+                case "CustomFrameRate":
+                    customFrameRate = value;
+                    break;
             }
         }
     }
+    if (timeMode === 14) {
+        defaults.frameRate = customFrameRate > 0 ? customFrameRate : 24;
+    }
+    else {
+        defaults.frameRate = TIME_MODE_FPS[timeMode] ?? 30;
+    }
     return defaults;
 }
 // ── Cameras & Lights ──────────────────────────────────────────────────────────
@@ -235,38 +503,17 @@ const SYSTEM_PROPERTIES = new Set([
     "lockInfluenceWeights",
 ]);
 function extractCustomProperties(modelNode) {
-    const props70 = findChildByName(modelNode, "Properties70");
-    if (!props70) {
+    // Properties flagged "U" are user-defined. Some writers (MotionBuilder) flag their own template properties
+    // as user properties too, so the well-known node properties are filtered out again.
+    const flagged = extractUserProperties(modelNode);
+    if (!flagged) {
         return undefined;
     }
-    const custom = {};
     let hasAny = false;
-    for (const p of props70.children) {
-        if (p.name !== "P") {
-            continue;
-        }
-        const propName = getPropertyValue(p, 0);
-        if (!propName || SYSTEM_PROPERTIES.has(propName)) {
-            continue;
-        }
-        // Accept user-defined properties (type starts with something other than standard types)
-        // Standard FBX types: "KString", "Number", "double", "int", "bool", "Lcl"...
-        // User properties often have types like "KString", but are in the UDP (User Defined Properties) section
-        // Heuristic: if not in SYSTEM_PROPERTIES set, it's user-defined
-        const val = p.properties[4]?.value;
-        if (val === undefined) {
-            continue;
-        }
-        if (typeof val === "string") {
-            custom[propName] = val;
-            hasAny = true;
-        }
-        else if (typeof val === "number") {
-            custom[propName] = val;
-            hasAny = true;
-        }
-        else if (typeof val === "boolean") {
-            custom[propName] = val;
+    const custom = {};
+    for (const name of Object.keys(flagged)) {
+        if (!SYSTEM_PROPERTIES.has(name)) {
+            custom[name] = flagged[name];
             hasAny = true;
         }
     }
@@ -329,7 +576,6 @@ function extractCameras(objectMap, templates) {
         const name = cleanFBXName(getPropertyValue(parentNode, 1) ?? "Camera");
         const nearPlane = resolveNumberProperty(node, cameraTemplate, "NearPlane", 0.1);
         const farPlane = resolveNumberProperty(node, cameraTemplate, "FarPlane", 10000);
-        const aspectRatio = resolveCameraAspectRatio(node, cameraTemplate);
         const projectionType = resolveNumberProperty(node, cameraTemplate, "CameraProjectionType", 0) === 1 || resolveNumberProperty(node, cameraTemplate, "ProjectionType", 0) === 1
             ? "orthographic"
             : "perspective";
@@ -338,7 +584,9 @@ function extractCameras(objectMap, templates) {
         const filmHeight = toNumber(resolvePropertyValue(node, cameraTemplate, "FilmHeight")) ?? toNumber(resolvePropertyValue(node, cameraTemplate, "ApertureHeight"));
         const orthoZoom = toNumber(resolvePropertyValue(node, cameraTemplate, "OrthoZoom"));
         const roll = toNumber(resolvePropertyValue(node, cameraTemplate, "Roll"));
-        const fieldOfView = resolveCameraFieldOfView(node, cameraTemplate, aspectRatio, focalLength, filmHeight);
+        const resolved = resolveCameraParameters(node, cameraTemplate);
+        const aspectRatio = resolved.aspectRatio;
+        const fieldOfView = resolved.fovDegY;
         const diagnostics = [];
         if (projectionType === "orthographic" && orthoZoom === undefined) {
             diagnostics.push("Orthographic camera has no OrthoZoom; runtime orthographic bounds use a fallback.");
@@ -348,8 +596,14 @@ function extractCameras(objectMap, templates) {
         }
         cameras.push({
             modelId: parent.id,
+            attributeId: id,
+            userProperties: extractUserProperties(node),
             name,
             fieldOfView,
+            fieldOfViewX: resolved.fovDegX,
+            apertureMode: resolved.apertureMode,
+            apertureSizeInch: resolved.apertureSizeInch,
+            orthographicSize: resolved.orthographicSize,
             nearPlane,
             farPlane,
             aspectRatio,
@@ -408,6 +662,13 @@ function extractLights(objectMap, templates) {
         }
         lights.push({
             modelId: parent.id,
+            attributeId: id,
+            userProperties: extractUserProperties(node),
+            nearAttenuationStart: toNumber(resolvePropertyValue(node, lightTemplate, "NearAttenuationStart")),
+            nearAttenuationEnd: toNumber(resolvePropertyValue(node, lightTemplate, "NearAttenuationEnd")),
+            farAttenuationStart: toNumber(resolvePropertyValue(node, lightTemplate, "FarAttenuationStart")),
+            farAttenuationEnd: toNumber(resolvePropertyValue(node, lightTemplate, "FarAttenuationEnd")),
+            areaLightShape: toNumber(resolvePropertyValue(node, lightTemplate, "AreaLightShape")),
             name,
             lightType,
             color,
@@ -442,34 +703,131 @@ function toBoolean(value) {
     }
     return undefined;
 }
-function resolveCameraAspectRatio(node, template) {
-    const filmAspectRatio = toNumber(resolvePropertyValue(node, template, "FilmAspectRatio"));
-    if (filmAspectRatio !== undefined && filmAspectRatio > 0) {
-        return filmAspectRatio;
+/** Film back sizes in thousandths of an inch per FBX ApertureFormat enum value. */
+const APERTURE_FORMATS = [
+    [1000, 1000],
+    [404, 295],
+    [493, 292],
+    [864, 630],
+    [816, 612],
+    [980, 735],
+    [825, 446],
+    [864, 732],
+    [2066, 906],
+    [1485, 991],
+    [2080, 1480],
+    [2772, 2072],
+];
+/**
+ * Resolves the camera's projection parameters the way the FBX SDK does: aspect ratio from AspectWidth/Height and
+ * the aspect mode, aperture (film gate) from the film size, squeeze ratio and gate fit, and the horizontal and
+ * vertical field of view from the aperture mode (horizontal, vertical, both, or focal length).
+ */
+function resolveCameraParameters(node, template) {
+    const num = (name, fallback) => toNumber(resolvePropertyValue(node, template, name)) ?? fallback;
+    const aspectMode = num("AspectRatioMode", 0);
+    const apertureMode = num("ApertureMode", 2);
+    const apertureFormat = Math.max(0, Math.min(APERTURE_FORMATS.length - 1, Math.round(num("ApertureFormat", 0))));
+    const gateFit = num("GateFit", 0);
+    let aspectX = num("AspectW", 0);
+    let aspectY = num("AspectH", 0);
+    aspectX = num("AspectWidth", aspectX);
+    aspectY = num("AspectHeight", aspectY);
+    const fov = num("FieldOfView", 0);
+    const fovX = num("FieldOfViewX", 0);
+    const fovY = num("FieldOfViewY", 0);
+    const focalLength = num("FocalLength", 0);
+    const orthoExtent = 30 * num("OrthoZoom", 1);
+    const format = APERTURE_FORMATS[apertureFormat];
+    let filmX = num("FilmWidth", format[0] * 0.001);
+    let filmY = num("FilmHeight", format[1] * 0.001);
+    const squeeze = num("FilmSqueezeRatio", apertureFormat === 7 ? 2 : 1);
+    if (aspectX <= 0 && aspectY <= 0) {
+        aspectX = filmX > 0 ? filmX : 1;
+        aspectY = filmY > 0 ? filmY : 1;
     }
-    const aspectWidth = toNumber(resolvePropertyValue(node, template, "AspectWidth"));
-    const aspectHeight = toNumber(resolvePropertyValue(node, template, "AspectHeight"));
-    if (aspectWidth !== undefined && aspectHeight !== undefined && aspectWidth > 0 && aspectHeight > 0) {
-        return aspectWidth / aspectHeight;
+    else if (aspectX <= 0) {
+        aspectX = filmX > 0 && filmY > 0 ? (aspectY / filmY) * filmX : aspectY;
     }
-    return 0;
-}
-function resolveCameraFieldOfView(node, template, aspectRatio, focalLength, filmHeight) {
-    const verticalFov = toNumber(resolvePropertyValue(node, template, "FieldOfViewY")) ?? toNumber(resolvePropertyValue(node, template, "FieldOfView"));
-    if (verticalFov !== undefined) {
-        return verticalFov;
+    else if (aspectY <= 0) {
+        aspectY = filmX > 0 && filmY > 0 ? (aspectX / filmX) * filmY : aspectX;
     }
-    const horizontalFov = toNumber(resolvePropertyValue(node, template, "FieldOfViewX"));
-    if (horizontalFov !== undefined) {
-        if (aspectRatio > 0) {
-            return radiansToDegrees(2 * Math.atan(Math.tan(degreesToRadians(horizontalFov) / 2) / aspectRatio));
-        }
-        return horizontalFov;
+    filmY *= squeeze;
+    let resX = aspectX;
+    let resY = aspectY;
+    switch (aspectMode) {
+        case 3: // fixed width
+            resX = aspectX;
+            resY = aspectX * aspectY;
+            break;
+        case 4: // fixed height
+            resX = aspectY * aspectX;
+            resY = aspectY;
+            break;
+        default:
+            break;
+    }
+    const aspectRatio = resY !== 0 ? resX / resY : 1;
+    const filmRatio = filmY !== 0 ? filmX / filmY : 1;
+    let effectiveFit = gateFit;
+    if (effectiveFit === 3) {
+        effectiveFit = aspectRatio > filmRatio ? 2 : 1;
+    }
+    else if (effectiveFit === 4) {
+        effectiveFit = aspectRatio < filmRatio ? 2 : 1;
+    }
+    let apertureX = filmX;
+    let apertureY = filmY;
+    let orthoX = orthoExtent;
+    let orthoY = orthoExtent;
+    switch (effectiveFit) {
+        case 1: // vertical
+            apertureX = filmY * aspectRatio;
+            apertureY = filmY;
+            orthoX = orthoExtent * aspectRatio;
+            break;
+        case 2: // horizontal
+            apertureX = filmX;
+            apertureY = filmX / aspectRatio;
+            orthoY = orthoExtent / aspectRatio;
+            break;
+        default:
+            break;
     }
-    if (focalLength !== undefined && focalLength > 0 && filmHeight !== undefined && filmHeight > 0) {
-        return radiansToDegrees(2 * Math.atan((filmHeight * 25.4) / (2 * focalLength)));
+    filmX = apertureX;
+    void filmX;
+    const d2r = Math.PI / 180;
+    const r2d = 180 / Math.PI;
+    let tanX;
+    let tanY;
+    switch (apertureMode) {
+        case 0:
+            tanX = Math.tan(fovX * d2r * 0.5);
+            tanY = Math.tan(fovY * d2r * 0.5);
+            break;
+        case 1:
+            tanX = Math.tan(fov * d2r * 0.5);
+            tanY = tanX / aspectRatio;
+            break;
+        case 3: {
+            const focalInch = focalLength / 25.4;
+            tanX = focalInch > 0 ? (apertureX / focalInch) * 0.5 : Math.tan(fov * d2r * 0.5) * aspectRatio;
+            tanY = focalInch > 0 ? (apertureY / focalInch) * 0.5 : Math.tan(fov * d2r * 0.5);
+            break;
+        }
+        default:
+            tanY = Math.tan(fov * d2r * 0.5);
+            tanX = tanY * aspectRatio;
+            break;
     }
-    return 45;
+    return {
+        fovDegX: Math.atan(tanX) * r2d * 2,
+        fovDegY: Math.atan(tanY) * r2d * 2,
+        aspectRatio,
+        apertureMode,
+        apertureSizeInch: [apertureX, apertureY],
+        orthographicSize: [orthoX, orthoY],
+    };
 }
 function collectUnknownLocalProperties(node, known) {
     const unknown = new Set();
@@ -487,10 +845,4 @@ function collectUnknownLocalProperties(node, known) {
     }
     return Array.from(unknown).sort();
 }
-function degreesToRadians(degrees) {
-    return (degrees * Math.PI) / 180;
-}
-function radiansToDegrees(radians) {
-    return (radians * 180) / Math.PI;
-}
 //# sourceMappingURL=fbxInterpreter.js.map