@babylonjs/serializers 5.0.0-alpha.9 → 5.0.0-beta.4

package/glTF/2.0/glTFExporter.js

@@ -1,20 +1,17 @@
-import { __spreadArrays } from "tslib";
-import { Vector2, Vector3, Vector4, Quaternion, Matrix } from "@babylonjs/core/Maths/math.vector";
-import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
-import { Tools } from "@babylonjs/core/Misc/tools";
-import { VertexBuffer } from "@babylonjs/core/Meshes/buffer";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
-import { Mesh } from "@babylonjs/core/Meshes/mesh";
-import { LinesMesh } from "@babylonjs/core/Meshes/linesMesh";
-import { InstancedMesh } from "@babylonjs/core/Meshes/instancedMesh";
-import { Material } from "@babylonjs/core/Materials/material";
-import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial";
-import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import { _GLTFMaterialExporter } from "./glTFMaterialExporter";
-import { _GLTFUtilities } from "./glTFUtilities";
-import { GLTFData } from "./glTFData";
-import { _GLTFAnimation } from "./glTFAnimation";
-import { Epsilon } from '@babylonjs/core/Maths/math.constants';
+import { __spreadArray } from "tslib";
+import { Vector2, Vector3, Vector4, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { LinesMesh } from "@babylonjs/core/Meshes/linesMesh.js";
+import { InstancedMesh } from "@babylonjs/core/Meshes/instancedMesh.js";
+import { Material } from "@babylonjs/core/Materials/material.js";
+import { _GLTFMaterialExporter } from "./glTFMaterialExporter.js";
+import { _GLTFUtilities } from "./glTFUtilities.js";
+import { GLTFData } from "./glTFData.js";
+import { _GLTFAnimation } from "./glTFAnimation.js";
 /**
  * Converts Babylon Scene into glTF 2.0.
  * @hidden
@@ -537,7 +534,7 @@ var _Exporter = /** @class */ (function () {
             }
             case VertexBuffer.ColorKind: {
                 var meshMaterial = babylonTransformNode.material;
-                var convertToLinear = meshMaterial ? (meshMaterial instanceof StandardMaterial) : true;
+                var convertToLinear = meshMaterial ? (meshMaterial.getClassName() === "StandardMaterial") : true;
                 var vertexData = stride === 3 ? new Color3() : new Color4();
                 for (var k = 0, length_5 = meshAttributeArray.length / stride; k < length_5; ++k) {
                     index = k * stride;
@@ -863,7 +860,14 @@ var _Exporter = /** @class */ (function () {
             var headerLength = 12;
             var chunkLengthPrefix = 8;
             var jsonLength = jsonText.length;
+            var encodedJsonText;
             var imageByteLength = 0;
+            // make use of TextEncoder when available
+            if (typeof TextEncoder !== "undefined") {
+                var encoder = new TextEncoder();
+                encodedJsonText = encoder.encode(jsonText);
+                jsonLength = encodedJsonText.length;
+            }
             for (var i = 0; i < _this._orderedImageData.length; ++i) {
                 imageByteLength += _this._orderedImageData[i].data.byteLength;
             }
@@ -884,8 +888,22 @@ var _Exporter = /** @class */ (function () {
             jsonChunkBufferView.setUint32(4, 0x4E4F534A, true);
             //json chunk bytes
             var jsonData = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix);
-            for (var i = 0; i < jsonLength; ++i) {
-                jsonData[i] = jsonText.charCodeAt(i);
+            // if TextEncoder was available, we can simply copy the encoded array
+            if (encodedJsonText) {
+                jsonData.set(encodedJsonText);
+            }
+            else {
+                var blankCharCode = "_".charCodeAt(0);
+                for (var i = 0; i < jsonLength; ++i) {
+                    var charCode = jsonText.charCodeAt(i);
+                    // if the character doesn't fit into a single UTF-16 code unit, just put a blank character
+                    if (charCode != jsonText.codePointAt(i)) {
+                        jsonData[i] = blankCharCode;
+                    }
+                    else {
+                        jsonData[i] = charCode;
+                    }
+                }
             }
             //json padding
             var jsonPaddingView = new Uint8Array(jsonChunkBuffer, chunkLengthPrefix + jsonLength);
@@ -1235,7 +1253,7 @@ var _Exporter = /** @class */ (function () {
                             this._materials.push(material);
                             materialIndex = this._materials.length - 1;
                         }
-                        else if (babylonMaterial instanceof MultiMaterial) {
+                        else if (babylonMaterial.getClassName() === "MultiMaterial") {
                             var subMaterial = babylonMaterial.subMaterials[submesh.materialIndex];
                             if (subMaterial) {
                                 babylonMaterial = subMaterial;
@@ -1252,8 +1270,8 @@ var _Exporter = /** @class */ (function () {
                     for (var _d = 0, attributeData_2 = attributeData; _d < attributeData_2.length; _d++) {
                         var attribute = attributeData_2[_d];
                         var attributeKind = attribute.kind;
-                        if (attributeKind === VertexBuffer.UVKind || attributeKind === VertexBuffer.UV2Kind) {
-                            if (glTFMaterial && !this._glTFMaterialExporter._hasTexturesPresent(glTFMaterial)) {
+                        if ((attributeKind === VertexBuffer.UVKind || attributeKind === VertexBuffer.UV2Kind) && !this._options.exportUnusedUVs) {
+                            if (!glTFMaterial || !this._glTFMaterialExporter._hasTexturesPresent(glTFMaterial)) {
                                 continue;
                             }
                         }
@@ -1320,10 +1338,8 @@ var _Exporter = /** @class */ (function () {
                         }
                     }
                     mesh.primitives.push(meshPrimitive);
-                    var promise = this._extensionsPostExportMeshPrimitiveAsync("postExport", meshPrimitive, submesh, binaryWriter);
-                    if (promise) {
-                        promises.push();
-                    }
+                    this._extensionsPostExportMeshPrimitiveAsync("postExport", meshPrimitive, submesh, binaryWriter);
+                    promises.push();
                 }
             }
         }
@@ -1343,13 +1359,8 @@ var _Exporter = /** @class */ (function () {
             }
             // Transform
             var matrix = node.getWorldMatrix();
-            var matrixToLeftHanded = Matrix.Compose(this._convertToRightHandedSystem ? new Vector3(-1, 1, 1) : Vector3.One(), Quaternion.Identity(), Vector3.Zero());
-            var matrixProduct = matrix.multiply(matrixToLeftHanded);
-            var matrixIdentity = Matrix.IdentityReadOnly;
-            for (var i = 0; i < 16; i++) {
-                if (Math.abs(matrixProduct.m[i] - matrixIdentity.m[i]) > Epsilon) {
-                    return false;
-                }
+            if (matrix.determinant() === 1) {
+                return false;
             }
             // Geometry
             if ((node instanceof Mesh && node.geometry !== null) ||
@@ -1375,7 +1386,7 @@ var _Exporter = /** @class */ (function () {
         var glTFNodeIndex;
         var glTFNode;
         var directDescendents;
-        var nodes = __spreadArrays(babylonScene.transformNodes, babylonScene.meshes, babylonScene.lights);
+        var nodes = __spreadArray(__spreadArray(__spreadArray([], babylonScene.transformNodes, true), babylonScene.meshes, true), babylonScene.lights, true);
         var rootNodesToLeftHanded = [];
         this._convertToRightHandedSystem = !babylonScene.useRightHandedSystem;
         this._convertToRightHandedSystemMap = {};
@@ -1401,8 +1412,9 @@ var _Exporter = /** @class */ (function () {
                 });
             }
         });
-        return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(babylonScene.materials, "image/png" /* PNG */, true).then(function () {
-            return _this.createNodeMapAndAnimationsAsync(babylonScene, nodes, binaryWriter).then(function (nodeMap) {
+        var _a = this.getExportNodes(nodes), exportNodes = _a[0], exportMaterials = _a[1];
+        return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* PNG */, true).then(function () {
+            return _this.createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then(function (nodeMap) {
                 return _this.createSkinsAsync(babylonScene, nodeMap, binaryWriter).then(function (skinMap) {
                     _this._nodeMap = nodeMap;
                     _this._totalByteLength = binaryWriter.getByteOffset();
@@ -1467,6 +1479,41 @@ var _Exporter = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Getting the nodes and materials that would be exported.
+     * @param nodes Babylon transform nodes
+     * @returns Array of nodes which would be exported.
+     * @returns Set of materials which would be exported.
+     */
+    _Exporter.prototype.getExportNodes = function (nodes) {
+        var exportNodes = [];
+        var exportMaterials = new Set();
+        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+            var babylonNode = nodes_2[_i];
+            if (!this._options.shouldExportNode || this._options.shouldExportNode(babylonNode)) {
+                exportNodes.push(babylonNode);
+                if (babylonNode.getClassName() === "Mesh") {
+                    var mesh = babylonNode;
+                    if (mesh.material) {
+                        exportMaterials.add(mesh.material);
+                    }
+                }
+                else {
+                    var meshes = babylonNode.getChildMeshes(false);
+                    for (var _a = 0, meshes_1 = meshes; _a < meshes_1.length; _a++) {
+                        var mesh = meshes_1[_a];
+                        if (mesh.material) {
+                            exportMaterials.add(mesh.material);
+                        }
+                    }
+                }
+            }
+            else {
+                "Excluding node " + babylonNode.name;
+            }
+        }
+        return [exportNodes, exportMaterials];
+    };
     /**
      * Creates a mapping of Node unique id to node index and handles animations
      * @param babylonScene Babylon Scene
@@ -1486,41 +1533,35 @@ var _Exporter = /** @class */ (function () {
         };
         var idleGLTFAnimations = [];
         var _loop_1 = function (babylonNode) {
-            if (!this_1._options.shouldExportNode || this_1._options.shouldExportNode(babylonNode)) {
-                promiseChain = promiseChain.then(function () {
-                    var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                    return _this.createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem, nodeMap).then(function (node) {
-                        var promise = _this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap);
-                        if (promise == null) {
-                            Tools.Warn("Not exporting node " + babylonNode.name);
-                            return Promise.resolve();
-                        }
-                        else {
-                            return promise.then(function (node) {
-                                if (!node) {
-                                    return;
-                                }
-                                _this._nodes.push(node);
-                                nodeIndex = _this._nodes.length - 1;
-                                nodeMap[babylonNode.uniqueId] = nodeIndex;
-                                if (!babylonScene.animationGroups.length) {
-                                    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
-                                    if (babylonNode.animations.length) {
-                                        _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
-                                    }
+            promiseChain = promiseChain.then(function () {
+                var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
+                return _this.createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem, nodeMap).then(function (node) {
+                    var promise = _this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap);
+                    if (promise == null) {
+                        Tools.Warn("Not exporting node " + babylonNode.name);
+                        return Promise.resolve();
+                    }
+                    else {
+                        return promise.then(function (node) {
+                            if (!node) {
+                                return;
+                            }
+                            _this._nodes.push(node);
+                            nodeIndex = _this._nodes.length - 1;
+                            nodeMap[babylonNode.uniqueId] = nodeIndex;
+                            if (!babylonScene.animationGroups.length) {
+                                _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
+                                if (babylonNode.animations.length) {
+                                    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate);
                                 }
-                            });
-                        }
-                    });
+                            }
+                        });
+                    }
                 });
-            }
-            else {
-                "Excluding node " + babylonNode.name;
-            }
+            });
         };
-        var this_1 = this;
-        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-            var babylonNode = nodes_2[_i];
+        for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+            var babylonNode = nodes_3[_i];
             _loop_1(babylonNode);
         }
         return promiseChain.then(function () {
@@ -1589,59 +1630,54 @@ var _Exporter = /** @class */ (function () {
      * @returns Node mapping of unique id to index
      */
     _Exporter.prototype.createSkinsAsync = function (babylonScene, nodeMap, binaryWriter) {
+        var _a;
         var promiseChain = Promise.resolve();
         var skinMap = {};
-        var _loop_2 = function (skeleton) {
+        for (var _i = 0, _b = babylonScene.skeletons; _i < _b.length; _i++) {
+            var skeleton = _b[_i];
             // create skin
             var skin = { joints: [] };
             var inverseBindMatrices = [];
-            var skeletonMesh = babylonScene.meshes.find(function (mesh) { mesh.skeleton === skeleton; });
-            skin.skeleton = skeleton.overrideMesh === null ? (skeletonMesh ? nodeMap[skeletonMesh.uniqueId] : undefined) : nodeMap[skeleton.overrideMesh.uniqueId];
             var boneIndexMap = {};
-            var boneIndexMax = -1;
-            var boneIndex = -1;
-            for (var _i = 0, _a = skeleton.bones; _i < _a.length; _i++) {
-                var bone = _a[_i];
-                boneIndex = bone.getIndex();
-                if (boneIndex > -1) {
+            var maxBoneIndex = -1;
+            for (var i = 0; i < skeleton.bones.length; ++i) {
+                var bone = skeleton.bones[i];
+                var boneIndex = (_a = bone.getIndex()) !== null && _a !== void 0 ? _a : i;
+                if (boneIndex !== -1) {
                     boneIndexMap[boneIndex] = bone;
+                    if (boneIndex > maxBoneIndex) {
+                        maxBoneIndex = boneIndex;
+                    }
                 }
-                boneIndexMax = Math.max(boneIndexMax, boneIndex);
             }
-            for (var i = 0; i <= boneIndexMax; ++i) {
-                var bone = boneIndexMap[i];
+            for (var boneIndex = 0; boneIndex <= maxBoneIndex; ++boneIndex) {
+                var bone = boneIndexMap[boneIndex];
+                inverseBindMatrices.push(bone.getInvertedAbsoluteTransform());
                 var transformNode = bone.getTransformNode();
                 if (transformNode) {
-                    var boneMatrix = bone.getInvertedAbsoluteTransform();
-                    if (this_2._convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedMatrixFromRef(boneMatrix);
-                    }
-                    inverseBindMatrices.push(boneMatrix);
                     skin.joints.push(nodeMap[transformNode.uniqueId]);
                 }
+                else {
+                    Tools.Warn("Exporting a bone without a linked transform node is currently unsupported");
+                }
             }
             // create buffer view for inverse bind matrices
             var byteStride = 64; // 4 x 4 matrix of 32 bit float
             var byteLength = inverseBindMatrices.length * byteStride;
             var bufferViewOffset = binaryWriter.getByteOffset();
-            var bufferView = _GLTFUtilities._CreateBufferView(0, bufferViewOffset, byteLength, byteStride, "InverseBindMatrices" + " - " + skeleton.name);
-            this_2._bufferViews.push(bufferView);
-            var bufferViewIndex = this_2._bufferViews.length - 1;
+            var bufferView = _GLTFUtilities._CreateBufferView(0, bufferViewOffset, byteLength, undefined, "InverseBindMatrices" + " - " + skeleton.name);
+            this._bufferViews.push(bufferView);
+            var bufferViewIndex = this._bufferViews.length - 1;
             var bindMatrixAccessor = _GLTFUtilities._CreateAccessor(bufferViewIndex, "InverseBindMatrices" + " - " + skeleton.name, "MAT4" /* MAT4 */, 5126 /* FLOAT */, inverseBindMatrices.length, null, null, null);
-            var inverseBindAccessorIndex = this_2._accessors.push(bindMatrixAccessor) - 1;
+            var inverseBindAccessorIndex = this._accessors.push(bindMatrixAccessor) - 1;
             skin.inverseBindMatrices = inverseBindAccessorIndex;
-            this_2._skins.push(skin);
-            skinMap[skeleton.uniqueId] = this_2._skins.length - 1;
+            this._skins.push(skin);
+            skinMap[skeleton.uniqueId] = this._skins.length - 1;
             inverseBindMatrices.forEach(function (mat) {
                 mat.m.forEach(function (cell) {
                     binaryWriter.setFloat32(cell);
                 });
             });
-        };
-        var this_2 = this;
-        for (var _i = 0, _a = babylonScene.skeletons; _i < _a.length; _i++) {
-            var skeleton = _a[_i];
-            _loop_2(skeleton);
         }
         return promiseChain.then(function () {
             return skinMap;