@babylonjs/loaders 7.17.2 → 7.19.0

package/glTF/2.0/glTFLoader.js

@@ -614,7 +614,9 @@ export class GLTFLoader {
             }
             assign(babylonTransformNode);
         };
-        if (node.mesh == undefined || node.skin != undefined) {
+        const hasMesh = node.mesh != undefined;
+        const hasSkin = this._parent.loadSkins && node.skin != undefined;
+        if (!hasMesh || hasSkin) {
             const nodeName = node.name || `node${node.index}`;
             this._babylonScene._blockEntityCollection = !!this._assetContainer;
             const transformNode = new TransformNode(nodeName, this._babylonScene);
@@ -628,12 +630,8 @@ export class GLTFLoader {
             }
             loadNode(transformNode);
         }
-        if (node.mesh != undefined) {
-            if (node.skin == undefined) {
-                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
-                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));
-            }
-            else {
+        if (hasMesh) {
+            if (hasSkin) {
                 // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
                 // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the
                 // transform, which effectively ignores the transform of the skinned mesh, as per spec.
@@ -668,6 +666,10 @@ export class GLTFLoader {
                     }));
                 }));
             }
+            else {
+                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
+                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));
+            }
         }
         this.logClose();
         return Promise.all(promises).then(() => {
@@ -888,7 +890,7 @@ export class GLTFLoader {
         });
     }
     _createMorphTargets(context, node, mesh, primitive, babylonMesh) {
-        if (!primitive.targets) {
+        if (!primitive.targets || !this._parent.loadMorphTargets) {
             return;
         }
         if (node._numMorphTargets == undefined) {
@@ -911,7 +913,7 @@ export class GLTFLoader {
         }
     }
     _loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry) {
-        if (!primitive.targets) {
+        if (!primitive.targets || !this._parent.loadMorphTargets) {
             return Promise.resolve();
         }
         const promises = new Array();
@@ -998,6 +1000,9 @@ export class GLTFLoader {
         babylonNode.scaling = scaling;
     }
     _loadSkinAsync(context, node, skin, assign) {
+        if (!this._parent.loadSkins) {
+            return Promise.resolve();
+        }
         const extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
         if (extensionPromise) {
             return extensionPromise;
@@ -1086,6 +1091,7 @@ export class GLTFLoader {
         }
     }
     _loadBone(node, skin, babylonSkeleton, babylonBones) {
+        node._isJoint = true;
         let babylonBone = babylonBones[node.index];
         if (babylonBone) {
             return babylonBone;
@@ -1263,13 +1269,18 @@ export class GLTFLoader {
             return Promise.resolve();
         }
         const targetNode = ArrayItem.Get(`${context}/target/node`, this._gltf.nodes, channel.target.node);
+        const channelTargetPath = channel.target.path;
+        const pathIsWeights = channelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */;
         // Ignore animations that have no animation targets.
-        if ((channel.target.path === "weights" /* AnimationChannelTargetPath.WEIGHTS */ && !targetNode._numMorphTargets) ||
-            (channel.target.path !== "weights" /* AnimationChannelTargetPath.WEIGHTS */ && !targetNode._babylonTransformNode)) {
+        if ((pathIsWeights && !targetNode._numMorphTargets) || (!pathIsWeights && !targetNode._babylonTransformNode)) {
+            return Promise.resolve();
+        }
+        // Don't load node animations if disabled.
+        if (!this._parent.loadNodeAnimations && !pathIsWeights && !targetNode._isJoint) {
             return Promise.resolve();
         }
         let properties;
-        switch (channel.target.path) {
+        switch (channelTargetPath) {
             case "translation" /* AnimationChannelTargetPath.TRANSLATION */: {
                 properties = nodeAnimationData.translation;
                 break;