@babylonjs/loaders 9.20.0 → 9.21.0

package/glTF/2.0/Extensions/objectModelMapping.js

@@ -3,14 +3,32 @@ import { Matrix, Quaternion, Vector2 } from "@babylonjs/core/Maths/math.vector.p
 import { Constants } from "@babylonjs/core/Engines/constants.js";
 import { Color4 } from "@babylonjs/core/Maths/math.color.pure.js";
 import { SpotLight } from "@babylonjs/core/Lights/spotLight.pure.js";
+import { FlowGraphInteger } from "@babylonjs/core/FlowGraph/CustomTypes/flowGraphInteger.pure.js";
 import { GLTFPathToObjectConverter } from "./gltfPathToObjectConverter.js";
-const nodesTree = {
-    length: {
-        type: "number",
-        get: (nodes) => nodes.length,
-        getTarget: (nodes) => nodes.map((node) => node._babylonTransformNode),
+/**
+ * Builds an accessor for an array `length` pointer (e.g. `/nodes.length`, `/meshes/{}/primitives.length`).
+ *
+ * The KHR object model types these `length` values as `int`, so the accessor reports the count as a
+ * {@link FlowGraphInteger} (type {@link FlowGraphTypes.Integer}). Keeping the representation an integer
+ * at the source lets integer-typed consumers such as `FlowGraphIntToFloat` accept the precise
+ * `RichTypeFlowGraphInteger` instead of a widened `RichTypeAny`.
+ * @param getLength returns the raw count for the addressed array; may be `undefined` when the array is not addressable
+ * @param getTarget returns the Babylon object(s) backing the array
+ * @returns an object accessor whose value is the count as a {@link FlowGraphInteger}
+ */
+function _CreateLengthAccessor(getLength, getTarget) {
+    return {
+        type: "FlowGraphInteger" /* FlowGraphTypes.Integer */,
+        get: (target) => {
+            const length = getLength(target);
+            return length === undefined ? undefined : FlowGraphInteger.FromValue(length);
+        },
+        getTarget,
         getPropertyName: [() => "length"],
-    },
+    };
+}
+const nodesTree = {
+    length: _CreateLengthAccessor((nodes) => nodes.length, (nodes) => nodes.map((node) => node._babylonTransformNode)),
     __array__: {
         __target__: true,
         translation: {
@@ -35,24 +53,60 @@ const nodesTree = {
             getPropertyName: [() => "scaling"],
         },
         weights: {
-            length: {
-                type: "number",
-                get: (node) => node._numMorphTargets,
-                getTarget: (node) => node._babylonTransformNode,
-                getPropertyName: [() => "influence"],
-            },
+            // Skip glTF objectTree traversal — weights may be undefined on the glTF node
+            // but accessible via the Babylon MorphTargetManager on the INode's meshes
+            __passThroughTarget__: true,
+            length: _CreateLengthAccessor((node) => {
+                const found = _findNodeMorphTargets(node);
+                return found ? found.mtm.numTargets : node?.mesh !== undefined ? 0 : undefined;
+            }, (node) => node?._babylonTransformNode),
             __array__: {
                 __target__: true,
                 type: "number",
-                get: (node, index) => (index !== undefined ? node._primitiveBabylonMeshes?.[0].morphTargetManager?.getTarget(index).influence : undefined),
-                // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),
-                getTarget: (node) => node._babylonTransformNode,
+                get: (node, index) => {
+                    const found = _findNodeMorphTargets(node);
+                    if (found && index !== undefined && index >= 0 && index < found.mtm.numTargets) {
+                        return _roundFloat32Artifact(found.mtm.getTarget(index).influence);
+                    }
+                    return undefined;
+                },
+                set: (value, node, index) => {
+                    const numValue = typeof value === "number" ? value : typeof value?.value === "number" ? value.value : value;
+                    const found = _findNodeMorphTargets(node);
+                    if (!found || index === undefined || index < 0 || index >= found.mtm.numTargets) {
+                        return;
+                    }
+                    // Fan out to every mesh that shares this morph target manager so
+                    // multi-primitive meshes stay in sync.
+                    for (const mesh of found.meshes) {
+                        const target = mesh.morphTargetManager?.getTarget(index);
+                        if (target) {
+                            target.influence = numValue;
+                        }
+                    }
+                },
+                getTarget: (node, index) => {
+                    const found = _findNodeMorphTargets(node);
+                    if (found && index !== undefined && index >= 0 && index < found.mtm.numTargets) {
+                        return found.mtm.getTarget(index);
+                    }
+                    return node?._babylonTransformNode;
+                },
                 getPropertyName: [() => "influence"],
             },
             type: "number[]",
-            get: (node, index) => [0], // TODO: get the weights correctly
-            // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),
-            getTarget: (node) => node._babylonTransformNode,
+            get: (node) => {
+                const found = _findNodeMorphTargets(node);
+                if (!found) {
+                    return [];
+                }
+                const weights = [];
+                for (let i = 0; i < found.mtm.numTargets; i++) {
+                    weights.push(_roundFloat32Artifact(found.mtm.getTarget(i).influence));
+                }
+                return weights;
+            },
+            getTarget: (node) => node?._babylonTransformNode,
             getPropertyName: [() => "influence"],
         },
         // readonly!
@@ -88,6 +142,45 @@ const nodesTree = {
             getTarget: (node) => node._babylonTransformNode,
             isReadOnly: true,
         },
+        camera: {
+            type: "string",
+            // Per KHR_interactivity Object Model: read-only ref pointing to the
+            // attached camera, encoded as a JSON Pointer string. Empty string
+            // when no camera is attached (the spec's null-ref convention).
+            get: (node) => (node.camera !== undefined ? `/cameras/${node.camera}` : ""),
+            getTarget: (node) => node,
+            isReadOnly: true,
+        },
+        mesh: {
+            type: "string",
+            get: (node) => (node.mesh !== undefined ? `/meshes/${node.mesh}` : ""),
+            getTarget: (node) => node,
+            isReadOnly: true,
+        },
+        skin: {
+            type: "string",
+            get: (node) => (node.skin !== undefined ? `/skins/${node.skin}` : ""),
+            getTarget: (node) => node,
+            isReadOnly: true,
+        },
+        parent: {
+            type: "string",
+            get: (node) => (node.parent && node.parent.index !== undefined ? `/nodes/${node.parent.index}` : ""),
+            getTarget: (node) => node,
+            isReadOnly: true,
+        },
+        children: {
+            length: _CreateLengthAccessor((children) => children?.length ?? 0, (children) => children ?? []),
+            __array__: {
+                __target__: true,
+                type: "string",
+                // The wrapping converter passes the indexed child value (an
+                // INode index); convert it to a JSON Pointer ref string.
+                get: (childIndex) => (typeof childIndex === "number" ? `/nodes/${childIndex}` : ""),
+                getTarget: () => ({ __nodeIndex: true }),
+                isReadOnly: true,
+            },
+        },
         extensions: {
             EXT_lights_ies: {
                 multiplier: {
@@ -139,24 +232,50 @@ const nodesTree = {
     },
 };
 const animationsTree = {
-    length: {
-        type: "number",
-        get: (animations) => animations.length,
-        getTarget: (animations) => animations.map((animation) => animation._babylonAnimationGroup),
-        getPropertyName: [() => "length"],
+    length: _CreateLengthAccessor((animations) => animations.length, (animations) => animations.map((animation) => animation._babylonAnimationGroup)),
+    __array__: {
+        // Indexed access to the animation, surfaced as a JSON Pointer ref string so blocks like
+        // ``animation/start`` can consume it directly. Uses the animation's own ``index`` property
+        // (populated by the loader's ArrayItem.Assign step) so the ref is resolved without needing
+        // a separate index payload from the path converter.
+        __target__: true,
+        type: "string",
+        get: (animation) => (animation && typeof animation.index === "number" ? `/animations/${animation.index}` : ""),
+        getTarget: (animation) => animation._babylonAnimationGroup,
+        isReadOnly: true,
     },
-    __array__: {},
 };
 const meshesTree = {
-    length: {
-        type: "number",
-        get: (meshes) => meshes.length,
-        getTarget: (meshes) => meshes.map((mesh) => mesh.primitives[0]._instanceData?.babylonSourceMesh),
-        getPropertyName: [() => "length"],
+    length: _CreateLengthAccessor((meshes) => meshes.length, (meshes) => meshes.map((mesh) => mesh.primitives[0]._instanceData?.babylonSourceMesh)),
+    __array__: {
+        __target__: true,
+        primitives: {
+            length: _CreateLengthAccessor((primitives) => primitives?.length ?? 0, (primitives) => primitives ?? []),
+            __array__: {
+                __target__: true,
+                material: {
+                    type: "string",
+                    // Read-only ref to the assigned material, JSON Pointer encoded.
+                    get: (primitive) => (primitive.material !== undefined ? `/materials/${primitive.material}` : ""),
+                    getTarget: (primitive) => primitive,
+                    isReadOnly: true,
+                },
+            },
+        },
+        weights: {
+            length: _CreateLengthAccessor((weights) => weights?.length ?? 0, (weights) => weights ?? []),
+            __array__: {
+                __target__: true,
+                type: "number",
+                get: (weightValue) => weightValue,
+                getTarget: () => ({ __weightValue: true }),
+                isReadOnly: true,
+            },
+        },
     },
-    __array__: {},
 };
 const camerasTree = {
+    length: _CreateLengthAccessor((cameras) => cameras.length, (cameras) => cameras.map((camera) => camera._babylonCamera)),
     __array__: {
         __target__: true,
         orthographic: {
@@ -254,8 +373,33 @@ const camerasTree = {
     },
 };
 const materialsTree = {
+    length: _CreateLengthAccessor((materials) => materials.length, (materials) => materials.map((material) => material._data?.[Constants.MATERIAL_TriangleFillMode]?.babylonMaterial)),
     __array__: {
         __target__: true,
+        doubleSided: {
+            type: "boolean",
+            get: (material, index, payload) => !GetMaterial(material, index, payload)?.backFaceCulling,
+            set: (value, material, index, payload) => {
+                const mat = GetMaterial(material, index, payload);
+                if (mat) {
+                    mat.backFaceCulling = !value;
+                }
+            },
+            getTarget: (material, index, payload) => GetMaterial(material, index, payload),
+            getPropertyName: [() => "backFaceCulling"],
+        },
+        alphaCutoff: {
+            type: "number",
+            get: (material, index, payload) => GetMaterial(material, index, payload)?.alphaCutOff,
+            set: (value, material, index, payload) => {
+                const mat = GetMaterial(material, index, payload);
+                if (mat) {
+                    mat.alphaCutOff = value;
+                }
+            },
+            getTarget: (material, index, payload) => GetMaterial(material, index, payload),
+            getPropertyName: [() => "alphaCutOff"],
+        },
         emissiveFactor: {
             type: "Color3",
             get: (material, index, payload) => GetMaterial(material, index, payload).emissiveColor,
@@ -357,18 +501,24 @@ const materialsTree = {
             KHR_materials_anisotropy: {
                 anisotropyStrength: {
                     type: "number",
-                    get: (material, index, payload) => GetMaterial(material, index, payload).anisotropy.intensity,
+                    get: (material, index, payload) => GetMaterial(material, index, payload)?.anisotropy?.intensity,
                     set: (value, material, index, payload) => {
-                        GetMaterial(material, index, payload).anisotropy.intensity = value;
+                        const mat = GetMaterial(material, index, payload);
+                        if (mat) {
+                            mat.anisotropy.intensity = value;
+                        }
                     },
                     getTarget: (material, index, payload) => GetMaterial(material, index, payload),
                     getPropertyName: [() => "anisotropy.intensity"],
                 },
                 anisotropyRotation: {
                     type: "number",
-                    get: (material, index, payload) => GetMaterial(material, index, payload).anisotropy.angle,
+                    get: (material, index, payload) => GetMaterial(material, index, payload)?.anisotropy?.angle,
                     set: (value, material, index, payload) => {
-                        GetMaterial(material, index, payload).anisotropy.angle = value;
+                        const mat = GetMaterial(material, index, payload);
+                        if (mat) {
+                            mat.anisotropy.angle = value;
+                        }
                     },
                     getTarget: (material, index, payload) => GetMaterial(material, index, payload),
                     getPropertyName: [() => "anisotropy.angle"],
@@ -500,7 +650,7 @@ const materialsTree = {
                 },
                 sheenRoughnessTexture: {
                     extensions: {
-                        KHR_texture_transform: GenerateTextureMap("sheen", "thicknessTexture"),
+                        KHR_texture_transform: GenerateTextureMap("sheen", "textureRoughness"),
                     },
                 },
             },
@@ -540,7 +690,10 @@ const materialsTree = {
                 },
                 transmissionTexture: {
                     extensions: {
-                        KHR_texture_transform: GenerateTextureMap("subSurface", "refractionIntensityTexture"),
+                        KHR_texture_transform: GenerateTextureMap("subSurface", "refractionIntensityTexture", {
+                            extensionKey: "KHR_materials_transmission",
+                            texturePath: ["transmissionTexture"],
+                        }),
                     },
                 },
             },
@@ -553,7 +706,10 @@ const materialsTree = {
                 },
                 diffuseTransmissionTexture: {
                     extensions: {
-                        KHR_texture_transform: GenerateTextureMap("subSurface", "translucencyIntensityTexture"),
+                        KHR_texture_transform: GenerateTextureMap("subSurface", "translucencyIntensityTexture", {
+                            extensionKey: "KHR_materials_diffuse_transmission",
+                            texturePath: ["diffuseTransmissionTexture"],
+                        }),
                     },
                 },
                 diffuseTransmissionColorFactor: {
@@ -564,7 +720,10 @@ const materialsTree = {
                 },
                 diffuseTransmissionColorTexture: {
                     extensions: {
-                        KHR_texture_transform: GenerateTextureMap("subSurface", "translucencyColorTexture"),
+                        KHR_texture_transform: GenerateTextureMap("subSurface", "translucencyColorTexture", {
+                            extensionKey: "KHR_materials_diffuse_transmission",
+                            texturePath: ["diffuseTransmissionColorTexture"],
+                        }),
                     },
                 },
             },
@@ -589,7 +748,7 @@ const materialsTree = {
                 },
                 thicknessTexture: {
                     extensions: {
-                        KHR_texture_transform: GenerateTextureMap("subSurface", "thicknessTexture"),
+                        KHR_texture_transform: GenerateTextureMap("subSurface", "thicknessTexture", { extensionKey: "KHR_materials_volume", texturePath: ["thicknessTexture"] }),
                     },
                 },
             },
@@ -599,12 +758,7 @@ const materialsTree = {
 const extensionsTree = {
     KHR_lights_punctual: {
         lights: {
-            length: {
-                type: "number",
-                get: (lights) => lights.length,
-                getTarget: (lights) => lights.map((light) => light._babylonLight),
-                getPropertyName: [(_lights) => "length"],
-            },
+            length: _CreateLengthAccessor((lights) => lights.length, (lights) => lights.map((light) => light._babylonLight)),
             __array__: {
                 __target__: true,
                 color: {
@@ -649,12 +803,7 @@ const extensionsTree = {
     },
     EXT_lights_area: {
         lights: {
-            length: {
-                type: "number",
-                get: (lights) => lights.length,
-                getTarget: (lights) => lights.map((light) => light._babylonLight),
-                getPropertyName: [(_lights) => "length"],
-            },
+            length: _CreateLengthAccessor((lights) => lights.length, (lights) => lights.map((light) => light._babylonLight)),
             __array__: {
                 __target__: true,
                 color: {
@@ -692,22 +841,12 @@ const extensionsTree = {
     },
     EXT_lights_ies: {
         lights: {
-            length: {
-                type: "number",
-                get: (lights) => lights.length,
-                getTarget: (lights) => lights.map((light) => light._babylonLight),
-                getPropertyName: [(_lights) => "length"],
-            },
+            length: _CreateLengthAccessor((lights) => lights.length, (lights) => lights.map((light) => light._babylonLight)),
         },
     },
     EXT_lights_image_based: {
         lights: {
-            length: {
-                type: "number",
-                get: (lights) => lights.length,
-                getTarget: (lights) => lights.map((light) => light._babylonTexture),
-                getPropertyName: [(_lights) => "length"],
-            },
+            length: _CreateLengthAccessor((lights) => lights.length, (lights) => lights.map((light) => light._babylonTexture)),
             __array__: {
                 __target__: true,
                 intensity: {
@@ -746,7 +885,159 @@ function GetTexture(material, payload, textureType, textureInObject) {
 function GetMaterial(material, _index, payload) {
     return material._data?.[payload?.fillMode ?? Constants.MATERIAL_TriangleFillMode]?.babylonMaterial;
 }
-function GenerateTextureMap(textureType, textureInObject) {
+function _getNodeMorphTargetManager(node) {
+    const tn = node?._babylonTransformNode;
+    if (!tn) {
+        return undefined;
+    }
+    // Single primitive: transform node IS the mesh with morphTargetManager
+    if (tn.morphTargetManager) {
+        return tn.morphTargetManager;
+    }
+    // Multiple primitives: check each primitive mesh and its source
+    const primMeshes = node._primitiveBabylonMeshes;
+    if (primMeshes) {
+        for (const mesh of primMeshes) {
+            if (mesh?.morphTargetManager) {
+                return mesh.morphTargetManager;
+            }
+            // Check source mesh for instanced meshes
+            if (mesh?.sourceMesh?.morphTargetManager) {
+                return mesh.sourceMesh.morphTargetManager;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * KHR_interactivity test assets routinely use a glTF hierarchy where the
+ * **parent** node has no `mesh` but a descendant does. The Khronos morph-weight
+ * tests query `/nodes/<parent>/weights/*` and expect the result to come from
+ * the morph targets of the first descendant mesh. To support this we walk the
+ * Babylon-side scene graph below the queried INode looking for a Mesh that has
+ * a morphTargetManager.
+ *
+ * For multi-primitive meshes (one INode → several Babylon meshes parented to a
+ * wrapper TransformNode) we also collect the sibling primitives so a `set`
+ * touches every mesh that shares the manager.
+ * @param node the glTF node to start the lookup from
+ * @returns the active morph target manager and every Babylon mesh that shares
+ * it, or `undefined` when no morph target manager is reachable from the node.
+ */
+function _findNodeMorphTargets(node) {
+    const tn = node?._babylonTransformNode;
+    if (!tn) {
+        return undefined;
+    }
+    // Direct: this node's own mesh has a morph target manager.
+    const directMtm = _getNodeMorphTargetManager(node);
+    if (directMtm && node._primitiveBabylonMeshes && node._primitiveBabylonMeshes.length > 0) {
+        return { mtm: directMtm, meshes: node._primitiveBabylonMeshes };
+    }
+    // Fallback: search descendants in the Babylon scene graph for the first
+    // mesh that has a morph target manager, then collect every sibling mesh
+    // that shares it (covers the multi-primitive case).
+    const descendants = tn.getDescendants(false);
+    for (const desc of descendants) {
+        const candidate = desc;
+        const mtm = candidate.morphTargetManager ?? candidate.sourceMesh?.morphTargetManager;
+        if (!mtm) {
+            continue;
+        }
+        const meshes = [];
+        const parent = candidate.parent;
+        if (parent) {
+            for (const sib of parent.getChildMeshes(true)) {
+                const sibMtm = sib.morphTargetManager ?? sib.sourceMesh?.morphTargetManager;
+                if (sibMtm === mtm) {
+                    meshes.push(sib);
+                }
+            }
+        }
+        if (meshes.length === 0) {
+            meshes.push(candidate);
+        }
+        return { mtm, meshes };
+    }
+    return undefined;
+}
+/**
+ * Collapse float32-precision artifacts back to the closest "clean" double.
+ *
+ * glTF stores numbers as JSON, but tools usually serialize float32 morph weights
+ * with their full double-precision text — `0.1` becomes `0.10000000149011612`.
+ * KHR_interactivity tests then compare the read-back weight via strict `math/eq`
+ * against literals like `0.1`, which fails because the two doubles aren't bitwise
+ * equal. Rounding the value to 7 significant figures (the precision of a float32)
+ * recovers the original "clean" double for any value that survived a float32
+ * round-trip while leaving genuinely high-precision doubles essentially intact.
+ * @param v the value to round
+ * @returns the rounded value, or the input unchanged if it is not finite
+ */
+function _roundFloat32Artifact(v) {
+    if (!Number.isFinite(v)) {
+        return v;
+    }
+    return parseFloat(v.toPrecision(7));
+}
+/**
+ * Read the KHR_texture_transform object stored in the source glTF JSON for a
+ * texture-info that lives under one of the material's extensions, creating
+ * empty parent objects on demand so callers can write through it. Returns
+ * `undefined` when the input shape is incompatible.
+ * @param material the source IMaterial owning the extension
+ * @param gltfPath the path describing where the texture-info lives
+ * @param createMissing when true, create missing parent objects so writes succeed
+ * @returns the glTF-side KHR_texture_transform object, or undefined
+ */
+function _gltfTextureTransform(material, gltfPath, createMissing) {
+    if (!material) {
+        return undefined;
+    }
+    let extensions = material.extensions;
+    if (!extensions) {
+        if (!createMissing) {
+            return undefined;
+        }
+        extensions = {};
+        material.extensions = extensions;
+    }
+    let cursor = extensions[gltfPath.extensionKey];
+    if (!cursor) {
+        if (!createMissing) {
+            return undefined;
+        }
+        cursor = {};
+        extensions[gltfPath.extensionKey] = cursor;
+    }
+    for (const key of gltfPath.texturePath) {
+        let next = cursor[key];
+        if (!next) {
+            if (!createMissing) {
+                return undefined;
+            }
+            next = {};
+            cursor[key] = next;
+        }
+        cursor = next;
+    }
+    if (!cursor.extensions) {
+        if (!createMissing) {
+            return undefined;
+        }
+        cursor.extensions = {};
+    }
+    let xform = cursor.extensions.KHR_texture_transform;
+    if (!xform) {
+        if (!createMissing) {
+            return undefined;
+        }
+        xform = {};
+        cursor.extensions.KHR_texture_transform = xform;
+    }
+    return xform;
+}
+function GenerateTextureMap(textureType, textureInObject, gltfPath) {
     return {
         offset: {
             componentsCount: 2,
@@ -754,12 +1045,29 @@ function GenerateTextureMap(textureType, textureInObject) {
             type: "Vector2",
             get: (material, _index, payload) => {
                 const texture = GetTexture(material, payload, textureType, textureInObject);
-                return new Vector2(texture?.uOffset, texture?.vOffset);
+                if (texture) {
+                    return new Vector2(texture.uOffset, texture.vOffset);
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, false);
+                    const o = xform?.offset;
+                    return new Vector2(o?.[0] ?? 0, o?.[1] ?? 0);
+                }
+                return new Vector2(0, 0);
             },
             getTarget: GetMaterial,
             set: (value, material, _index, payload) => {
                 const texture = GetTexture(material, payload, textureType, textureInObject);
-                ((texture.uOffset = value.x), (texture.vOffset = value.y));
+                if (texture) {
+                    texture.uOffset = value.x;
+                    texture.vOffset = value.y;
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, true);
+                    if (xform) {
+                        xform.offset = [value.x, value.y];
+                    }
+                }
             },
             getPropertyName: [
                 () => `${textureType}${textureInObject ? "." + textureInObject : ""}.uOffset`,
@@ -768,9 +1076,30 @@ function GenerateTextureMap(textureType, textureInObject) {
         },
         rotation: {
             type: "number",
-            get: (material, _index, payload) => GetTexture(material, payload, textureType, textureInObject)?.wAng,
+            get: (material, _index, payload) => {
+                const texture = GetTexture(material, payload, textureType, textureInObject);
+                if (texture) {
+                    return texture.wAng;
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, false);
+                    return xform?.rotation ?? 0;
+                }
+                return 0;
+            },
             getTarget: GetMaterial,
-            set: (value, material, _index, payload) => (GetTexture(material, payload, textureType, textureInObject).wAng = value),
+            set: (value, material, _index, payload) => {
+                const texture = GetTexture(material, payload, textureType, textureInObject);
+                if (texture) {
+                    texture.wAng = value;
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, true);
+                    if (xform) {
+                        xform.rotation = value;
+                    }
+                }
+            },
             getPropertyName: [() => `${textureType}${textureInObject ? "." + textureInObject : ""}.wAng`],
         },
         scale: {
@@ -778,12 +1107,29 @@ function GenerateTextureMap(textureType, textureInObject) {
             type: "Vector2",
             get: (material, _index, payload) => {
                 const texture = GetTexture(material, payload, textureType, textureInObject);
-                return new Vector2(texture?.uScale, texture?.vScale);
+                if (texture) {
+                    return new Vector2(texture.uScale, texture.vScale);
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, false);
+                    const s = xform?.scale;
+                    return new Vector2(s?.[0] ?? 1, s?.[1] ?? 1);
+                }
+                return new Vector2(1, 1);
             },
             getTarget: GetMaterial,
             set: (value, material, index, payload) => {
                 const texture = GetTexture(material, payload, textureType, textureInObject);
-                ((texture.uScale = value.x), (texture.vScale = value.y));
+                if (texture) {
+                    texture.uScale = value.x;
+                    texture.vScale = value.y;
+                }
+                if (gltfPath) {
+                    const xform = _gltfTextureTransform(material, gltfPath, true);
+                    if (xform) {
+                        xform.scale = [value.x, value.y];
+                    }
+                }
             },
             getPropertyName: [
                 () => `${textureType}${textureInObject ? "." + textureInObject : ""}.uScale`,
@@ -792,13 +1138,69 @@ function GenerateTextureMap(textureType, textureInObject) {
         },
     };
 }
+const scenesTree = {
+    length: _CreateLengthAccessor((scenes) => scenes.length, (scenes) => scenes),
+    __array__: {
+        __target__: true,
+        nodes: {
+            length: _CreateLengthAccessor((nodes) => nodes?.length ?? 0, (nodes) => nodes ?? []),
+            __array__: {
+                __target__: true,
+                type: "string",
+                // Indexed scene root: the underlying value is the INode index;
+                // KHR_interactivity expects a ref-typed JSON Pointer string.
+                get: (nodeIndex) => (typeof nodeIndex === "number" ? `/nodes/${nodeIndex}` : ""),
+                getTarget: () => ({ __nodeIndex: true }),
+                isReadOnly: true,
+            },
+        },
+    },
+};
+const skinsTree = {
+    length: _CreateLengthAccessor((skins) => skins.length, (skins) => skins.map((skin) => skin._data?.babylonSkeleton)),
+    __array__: {
+        __target__: true,
+        joints: {
+            length: _CreateLengthAccessor((joints) => joints?.length ?? 0, (joints) => joints ?? []),
+            __array__: {
+                __target__: true,
+                type: "string",
+                // Indexed skin joint: returns a ref to the joint node.
+                get: (jointIndex) => (typeof jointIndex === "number" ? `/nodes/${jointIndex}` : ""),
+                getTarget: () => ({ __nodeIndex: true }),
+                isReadOnly: true,
+            },
+        },
+        skeleton: {
+            type: "string",
+            // Skin's skeleton root: returns a ref to the root node, or empty
+            // (null ref) when no skeleton root is declared.
+            get: (skin) => {
+                const skeleton = skin.skeleton;
+                return typeof skeleton === "number" ? `/nodes/${skeleton}` : "";
+            },
+            getTarget: (skin) => skin,
+            isReadOnly: true,
+        },
+    },
+};
 const objectModelMapping = {
+    scene: {
+        __target__: true,
+        type: "number",
+        get: (sceneIndex) => sceneIndex ?? 0,
+        getTarget: () => ({ __gltfRoot: true }),
+        isReadOnly: true,
+        getPropertyName: [() => "scene"],
+    },
     cameras: camerasTree,
     nodes: nodesTree,
     materials: materialsTree,
     extensions: extensionsTree,
     animations: animationsTree,
     meshes: meshesTree,
+    scenes: scenesTree,
+    skins: skinsTree,
 };
 /**
  * get a path-to-object converter for the given glTF tree