babylonjs-serializers 5.33.0 → 5.33.2

package/babylon.glTF2Serializer.js

@@ -2516,6 +2516,9 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+// Matrix that converts handedness on the X-axis.
+var convertHandednessMatrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Compose(new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3(-1, 1, 1), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.Identity(), core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero());
 /**
  * Converts Babylon Scene into glTF 2.0.
  * @internal
@@ -3910,21 +3913,15 @@ var _Exporter = /** @class */ (function () {
      */
     _Exporter.prototype._isBabylonCoordinateSystemConvertingNode = function (node) {
         if (node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TransformNode) {
-            if (node.name !== "__root__") {
-                return false;
-            }
             // Transform
-            var matrix = node.getWorldMatrix();
-            if (matrix.determinant() === 1) {
+            var matrix = node.getWorldMatrix().multiplyToRef(convertHandednessMatrix, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Matrix[0]);
+            if (!matrix.isIdentity()) {
                 return false;
             }
             // Geometry
             if ((node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh && node.geometry !== null) || (node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.InstancedMesh && node.sourceMesh.geometry !== null)) {
                 return false;
             }
-            if (this._includeCoordinateSystemConversionNodes) {
-                return false;
-            }
             return true;
         }
         return false;
@@ -3954,6 +3951,9 @@ var _Exporter = /** @class */ (function () {
         });
         // Check if root nodes converting to left-handed are present
         babylonScene.rootNodes.forEach(function (rootNode) {
+            if (_this._includeCoordinateSystemConversionNodes) {
+                return;
+            }
             if (_this._isBabylonCoordinateSystemConvertingNode(rootNode)) {
                 rootNodesToLeftHanded.push(rootNode);
                 // Exclude the node from list of nodes to export
@@ -5448,17 +5448,18 @@ var _GLTFMaterialExporter = /** @class */ (function () {
     };
     _GLTFMaterialExporter.prototype._exportTextureInfoAsync = function (babylonTexture, mimeType) {
         return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__awaiter)(this, void 0, void 0, function () {
-            var textureUid, pixels, samplerIndex, textureMimeType, internalTextureToImage, internalTextureUniqueId, imageIndex, size, data, textureInfo;
-            return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__generator)(this, function (_a) {
-                switch (_a.label) {
+            var textureUid, pixels_1, samplerIndex, textureMimeType, internalTextureToImage, internalTextureUniqueId, imageIndexPromise, size_1, textureInfo, _a;
+            var _this = this;
+            return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__generator)(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         textureUid = babylonTexture.uid;
                         if (!(textureUid in this._textureMap)) return [3 /*break*/, 1];
                         return [2 /*return*/, this._textureMap[textureUid]];
                     case 1: return [4 /*yield*/, this._getPixelsFromTexture(babylonTexture)];
                     case 2:
-                        pixels = _a.sent();
-                        if (!pixels) {
+                        pixels_1 = _b.sent();
+                        if (!pixels_1) {
                             return [2 /*return*/, null];
                         }
                         samplerIndex = this._exportTextureSampler(babylonTexture);
@@ -5478,17 +5479,26 @@ var _GLTFMaterialExporter = /** @class */ (function () {
                         internalTextureToImage = this._internalTextureToImage;
                         internalTextureUniqueId = babylonTexture.getInternalTexture().uniqueId;
                         internalTextureToImage[internalTextureUniqueId] || (internalTextureToImage[internalTextureUniqueId] = {});
-                        imageIndex = internalTextureToImage[internalTextureUniqueId][mimeType];
-                        if (!(imageIndex === undefined)) return [3 /*break*/, 4];
-                        size = babylonTexture.getSize();
-                        return [4 /*yield*/, this._getImageDataAsync(pixels, size.width, size.height, mimeType)];
+                        imageIndexPromise = internalTextureToImage[internalTextureUniqueId][mimeType];
+                        if (imageIndexPromise === undefined) {
+                            size_1 = babylonTexture.getSize();
+                            imageIndexPromise = (function () { return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__awaiter)(_this, void 0, void 0, function () {
+                                var data;
+                                return (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__generator)(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this._getImageDataAsync(pixels_1, size_1.width, size_1.height, mimeType)];
+                                        case 1:
+                                            data = _a.sent();
+                                            return [2 /*return*/, this._exportImage(babylonTexture.name, mimeType, data)];
+                                    }
+                                });
+                            }); })();
+                            internalTextureToImage[internalTextureUniqueId][mimeType] = imageIndexPromise;
+                        }
+                        _a = this._exportTextureInfo;
+                        return [4 /*yield*/, imageIndexPromise];
                     case 3:
-                        data = _a.sent();
-                        imageIndex = this._exportImage(babylonTexture.name, mimeType, data);
-                        internalTextureToImage[internalTextureUniqueId][mimeType] = imageIndex;
-                        _a.label = 4;
-                    case 4:
-                        textureInfo = this._exportTextureInfo(imageIndex, samplerIndex, babylonTexture.coordinatesIndex);
+                        textureInfo = _a.apply(this, [_b.sent(), samplerIndex, babylonTexture.coordinatesIndex]);
                         this._textureMap[textureUid] = textureInfo;
                         return [2 /*return*/, textureInfo];
                 }