babylonjs-serializers 6.6.0 → 6.7.0

package/babylonjs.serializers.js

@@ -7,7 +7,7 @@
 		exports["babylonjs-serializers"] = factory(require("babylonjs"));
 	else
 		root["SERIALIZERS"] = factory(root["BABYLON"]);
-})((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), (__WEBPACK_EXTERNAL_MODULE_core_Maths_math_vector__) => {
+})((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), (__WEBPACK_EXTERNAL_MODULE_core_Meshes_mesh__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
@@ -373,7 +373,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "OBJExport": () => (/* binding */ OBJExport)
 /* harmony export */ });
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/tools */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/tools */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__);
 
 
@@ -564,7 +564,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "EXT_mesh_gpu_instancing": () => (/* binding */ EXT_mesh_gpu_instancing)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Buffers/buffer */ "core/Maths/math.vector");
+/* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Buffers/buffer */ "core/Meshes/mesh");
 /* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -713,12 +713,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "KHR_lights_punctual": () => (/* binding */ KHR_lights_punctual)
 /* harmony export */ });
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/logger */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/logger */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var _glTFUtilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../glTFUtilities */ "../../../lts/serializers/dist/glTF/2.0/glTFUtilities.js");
-
-
 
 
 
@@ -771,57 +768,48 @@ var KHR_lights_punctual = /** @class */ (function () {
         var _this = this;
         return new Promise(function (resolve) {
             if (node && babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.ShadowLight) {
-                var babylonLight = babylonNode;
                 var light = void 0;
-                var lightType = babylonLight.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_POINTLIGHT
+                var lightType = babylonNode.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_POINTLIGHT
                     ? "point" /* KHRLightsPunctual_LightType.POINT */
-                    : babylonLight.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_DIRECTIONALLIGHT
+                    : babylonNode.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_DIRECTIONALLIGHT
                         ? "directional" /* KHRLightsPunctual_LightType.DIRECTIONAL */
-                        : babylonLight.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_SPOTLIGHT
+                        : babylonNode.getTypeID() == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.LIGHTTYPEID_SPOTLIGHT
                             ? "spot" /* KHRLightsPunctual_LightType.SPOT */
                             : null;
                 if (lightType == null) {
-                    core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Logger.Warn("".concat(context, ": Light ").concat(babylonLight.name, " is not supported in ").concat(NAME));
+                    core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Logger.Warn("".concat(context, ": Light ").concat(babylonNode.name, " is not supported in ").concat(NAME));
                 }
                 else {
-                    var lightPosition = babylonLight.position.clone();
-                    var convertToRightHandedSystem = _this._exporter._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                    if (!lightPosition.equals(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.Zero())) {
-                        if (convertToRightHandedSystem) {
-                            _glTFUtilities__WEBPACK_IMPORTED_MODULE_2__._GLTFUtilities._GetRightHandedPositionVector3FromRef(lightPosition);
-                        }
-                        node.translation = lightPosition.asArray();
+                    if (!babylonNode.position.equalsToFloats(0, 0, 0)) {
+                        node.translation = babylonNode.position.asArray();
                     }
                     if (lightType !== "point" /* KHRLightsPunctual_LightType.POINT */) {
-                        var localAxis = babylonLight.direction;
-                        var yaw = -Math.atan2(localAxis.z * (_this._exporter._babylonScene.useRightHandedSystem ? -1 : 1), localAxis.x) + Math.PI / 2;
+                        var localAxis = babylonNode.direction;
+                        var yaw = -Math.atan2(localAxis.z, localAxis.x) + Math.PI / 2;
                         var len = Math.sqrt(localAxis.x * localAxis.x + localAxis.z * localAxis.z);
                         var pitch = -Math.atan2(localAxis.y, len);
-                        var lightRotationQuaternion = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRoll(yaw, pitch, 0);
-                        if (convertToRightHandedSystem) {
-                            _glTFUtilities__WEBPACK_IMPORTED_MODULE_2__._GLTFUtilities._GetRightHandedQuaternionFromRef(lightRotationQuaternion);
-                        }
-                        if (!lightRotationQuaternion.equals(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity())) {
+                        var lightRotationQuaternion = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRoll(yaw + Math.PI, pitch, 0);
+                        if (!core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.IsIdentity(lightRotationQuaternion)) {
                             node.rotation = lightRotationQuaternion.asArray();
                         }
                     }
-                    if (babylonLight.falloffType !== core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.FALLOFF_GLTF) {
-                        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Logger.Warn("".concat(context, ": Light falloff for ").concat(babylonLight.name, " does not match the ").concat(NAME, " specification!"));
+                    if (babylonNode.falloffType !== core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light.FALLOFF_GLTF) {
+                        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Logger.Warn("".concat(context, ": Light falloff for ").concat(babylonNode.name, " does not match the ").concat(NAME, " specification!"));
                     }
                     light = {
                         type: lightType,
                     };
-                    if (!babylonLight.diffuse.equals(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Color3.White())) {
-                        light.color = babylonLight.diffuse.asArray();
+                    if (!babylonNode.diffuse.equals(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Color3.White())) {
+                        light.color = babylonNode.diffuse.asArray();
                     }
-                    if (babylonLight.intensity !== 1.0) {
-                        light.intensity = babylonLight.intensity;
+                    if (babylonNode.intensity !== 1.0) {
+                        light.intensity = babylonNode.intensity;
                     }
-                    if (babylonLight.range !== Number.MAX_VALUE) {
-                        light.range = babylonLight.range;
+                    if (babylonNode.range !== Number.MAX_VALUE) {
+                        light.range = babylonNode.range;
                     }
                     if (lightType === "spot" /* KHRLightsPunctual_LightType.SPOT */) {
-                        var babylonSpotLight = babylonLight;
+                        var babylonSpotLight = babylonNode;
                         if (babylonSpotLight.angle !== Math.PI / 2.0) {
                             if (light.spot == null) {
                                 light.spot = {};
@@ -835,11 +823,9 @@ var KHR_lights_punctual = /** @class */ (function () {
                             light.spot.innerConeAngle = babylonSpotLight.innerAngle / 2.0;
                         }
                     }
-                    if (_this._lights == null) {
-                        _this._lights = {
-                            lights: [],
-                        };
-                    }
+                    _this._lights || (_this._lights = {
+                        lights: [],
+                    });
                     _this._lights.lights.push(light);
                     var lightReference = {
                         light: _this._lights.lights.length - 1,
@@ -849,52 +835,41 @@ var KHR_lights_punctual = /** @class */ (function () {
                     if (parentBabylonNode && parentBabylonNode.getChildren().length == 1) {
                         var parentNode = _this._exporter._nodes[nodeMap[parentBabylonNode.uniqueId]];
                         if (parentNode) {
-                            var parentNodeLocalMatrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Matrix[0];
-                            var parentInvertNodeLocalMatrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Matrix[1];
-                            var parentNodeLocalTranslation = parentNode.translation
-                                ? new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(parentNode.translation[0], parentNode.translation[1], parentNode.translation[2])
-                                : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.Zero();
-                            var parentNodeLocalRotation = parentNode.rotation
-                                ? new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion(parentNode.rotation[0], parentNode.rotation[1], parentNode.rotation[2], parentNode.rotation[3])
-                                : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity();
-                            var parentNodeLocalScale = parentNode.scale ? new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(parentNode.scale[0], parentNode.scale[1], parentNode.scale[2]) : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.One();
-                            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Matrix.ComposeToRef(parentNodeLocalScale, parentNodeLocalRotation, parentNodeLocalTranslation, parentNodeLocalMatrix);
-                            parentNodeLocalMatrix.invertToRef(parentInvertNodeLocalMatrix);
-                            // Convert light local matrix to local matrix relative to grandparent, facing -Z
-                            var lightLocalMatrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Matrix[2];
-                            var nodeLocalTranslation = node.translation ? new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(node.translation[0], node.translation[1], node.translation[2]) : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.Zero();
-                            // Undo directional light positional offset
-                            if (babylonLight instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.DirectionalLight) {
-                                nodeLocalTranslation.subtractInPlace(_this._exporter._babylonScene.useRightHandedSystem
-                                    ? babylonLight.direction
-                                    : _glTFUtilities__WEBPACK_IMPORTED_MODULE_2__._GLTFUtilities._GetRightHandedPositionVector3(babylonLight.direction));
+                            var parentTranslation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArrayToRef(parentNode.translation || [0, 0, 0], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Vector3[0]);
+                            var parentRotation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArrayToRef(parentNode.rotation || [0, 0, 0, 1], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Quaternion[0]);
+                            var parentScale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArrayToRef(parentNode.scale || [1, 1, 1], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Vector3[1]);
+                            var parentMatrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Matrix.ComposeToRef(parentScale, parentRotation, parentTranslation, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Matrix[0]);
+                            var translation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArrayToRef(node.translation || [0, 0, 0], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Vector3[2]);
+                            var rotation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArrayToRef(node.rotation || [0, 0, 0, 1], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Quaternion[1]);
+                            var matrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Matrix.ComposeToRef(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.OneReadOnly, rotation, translation, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Matrix[1]);
+                            parentMatrix.multiplyToRef(matrix, matrix);
+                            matrix.decompose(parentScale, parentRotation, parentTranslation);
+                            if (parentTranslation.equalsToFloats(0, 0, 0)) {
+                                delete parentNode.translation;
+                            }
+                            else {
+                                parentNode.translation = parentTranslation.asArray();
+                            }
+                            if (core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.IsIdentity(parentRotation)) {
+                                delete parentNode.rotation;
                             }
-                            var nodeLocalRotation = _this._exporter._babylonScene.useRightHandedSystem ? core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity() : new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion(0, 1, 0, 0);
-                            if (node.rotation) {
-                                nodeLocalRotation.multiplyInPlace(new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion(node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3]));
+                            else {
+                                parentNode.rotation = parentRotation.asArray();
+                            }
+                            if (parentScale.equalsToFloats(1, 1, 1)) {
+                                delete parentNode.scale;
                             }
-                            var nodeLocalScale = node.scale ? new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(node.scale[0], node.scale[1], node.scale[2]) : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.One();
-                            core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Matrix.ComposeToRef(nodeLocalScale, nodeLocalRotation, nodeLocalTranslation, lightLocalMatrix);
-                            lightLocalMatrix.multiplyToRef(parentInvertNodeLocalMatrix, lightLocalMatrix);
-                            var parentNewScale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Vector3[0];
-                            var parentNewRotationQuaternion = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Quaternion[0];
-                            var parentNewTranslation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TmpVectors.Vector3[1];
-                            lightLocalMatrix.decompose(parentNewScale, parentNewRotationQuaternion, parentNewTranslation);
-                            parentNode.scale = parentNewScale.asArray();
-                            parentNode.rotation = parentNewRotationQuaternion.asArray();
-                            parentNode.translation = parentNewTranslation.asArray();
-                            if (parentNode.extensions == null) {
-                                parentNode.extensions = {};
+                            else {
+                                parentNode.scale = parentScale.asArray();
                             }
+                            parentNode.extensions || (parentNode.extensions = {});
                             parentNode.extensions[NAME] = lightReference;
                             // Do not export the original node
                             resolve(null);
                             return;
                         }
                     }
-                    if (node.extensions == null) {
-                        node.extensions = {};
-                    }
+                    node.extensions || (node.extensions = {});
                     node.extensions[NAME] = lightReference;
                 }
             }
@@ -920,7 +895,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_anisotropy": () => (/* binding */ KHR_materials_anisotropy)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrBaseMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrBaseMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1004,7 +979,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_clearcoat": () => (/* binding */ KHR_materials_clearcoat)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Misc/tools */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Misc/tools */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1111,7 +1086,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_emissive_strength": () => (/* binding */ KHR_materials_emissive_strength)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1180,7 +1155,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_ior": () => (/* binding */ KHR_materials_ior)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1249,7 +1224,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_iridescence": () => (/* binding */ KHR_materials_iridescence)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrBaseMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrBaseMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrBaseMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1340,7 +1315,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_sheen": () => (/* binding */ KHR_materials_sheen)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1430,7 +1405,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_specular": () => (/* binding */ KHR_materials_specular)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1532,7 +1507,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_transmission": () => (/* binding */ KHR_materials_transmission)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/PBR/pbrMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1625,7 +1600,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_unlit": () => (/* binding */ KHR_materials_unlit)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/standardMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/standardMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1693,7 +1668,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_materials_volume": () => (/* binding */ KHR_materials_volume)
 /* harmony export */ });
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
-/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Maths/math.color */ "core/Maths/math.vector");
+/* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Maths/math.color */ "core/Meshes/mesh");
 /* harmony import */ var core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Materials_PBR_pbrMaterial__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -1797,7 +1772,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "KHR_texture_transform": () => (/* binding */ KHR_texture_transform)
 /* harmony export */ });
-/* harmony import */ var core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/tools */ "core/Maths/math.vector");
+/* harmony import */ var core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Misc/tools */ "core/Meshes/mesh");
 /* harmony import */ var core_Misc_tools__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Misc_tools__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _glTFExporter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../glTFExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFExporter.js");
 
@@ -1954,7 +1929,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "_GLTFAnimation": () => (/* binding */ _GLTFAnimation)
 /* harmony export */ });
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Lights/light */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Lights/light */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFUtilities */ "../../../lts/serializers/dist/glTF/2.0/glTFUtilities.js");
 
@@ -2005,32 +1980,30 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param babylonTransformNode - BabylonJS mesh.
      * @param animation - animation.
      * @param animationChannelTargetPath - The target animation channel.
-     * @param convertToRightHandedSystem - Specifies if the values should be converted to right-handed.
      * @param useQuaternion - Specifies if quaternions are used.
      * @returns nullable IAnimationData
      */
-    _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
+    _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, useQuaternion, animationSampleRate) {
         if (this._IsTransformable(babylonTransformNode)) {
             var inputs = [];
             var outputs = [];
             var keyFrames = animation.getKeys();
             var minMaxKeyFrames = _GLTFAnimation._CalculateMinMaxKeyFrames(keyFrames);
             var interpolationOrBake = _GLTFAnimation._DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion);
-            var frameDelta = minMaxKeyFrames.max - minMaxKeyFrames.min;
             var interpolation = interpolationOrBake.interpolationType;
             var shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
             if (shouldBakeAnimation) {
-                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, useQuaternion);
             }
             else {
                 if (interpolation === "LINEAR" /* AnimationSamplerInterpolation.LINEAR */ || interpolation === "STEP" /* AnimationSamplerInterpolation.STEP */) {
-                    _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion);
                 }
                 else if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
-                    _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion);
                 }
                 else {
-                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, useQuaternion);
                 }
             }
             if (inputs.length && outputs.length) {
@@ -2099,10 +2072,9 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate, shouldExportAnimation) {
+    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         var glTFAnimation;
         if (_GLTFAnimation._IsTransformable(babylonNode)) {
             if (babylonNode.animations) {
@@ -2118,7 +2090,7 @@ var _GLTFAnimation = /** @class */ (function () {
                             samplers: [],
                             channels: [],
                         };
-                        _GLTFAnimation._AddAnimation("".concat(animation.name), animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                        _GLTFAnimation._AddAnimation("".concat(animation.name), animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate);
                         if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                             idleGLTFAnimations.push(glTFAnimation);
                         }
@@ -2138,10 +2110,9 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate, shouldExportAnimation) {
+    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         var glTFAnimation;
         if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Mesh) {
             var morphTargetManager = babylonNode.morphTargetManager;
@@ -2175,7 +2146,7 @@ var _GLTFAnimation = /** @class */ (function () {
                                 samplers: [],
                                 channels: [],
                             };
-                            _GLTFAnimation._AddAnimation(animation.name, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, combinedAnimation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate, morphTargetManager.numTargets);
+                            _GLTFAnimation._AddAnimation(animation.name, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, combinedAnimation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, morphTargetManager.numTargets);
                             if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                                 idleGLTFAnimations.push(glTFAnimation);
                             }
@@ -2195,10 +2166,9 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystemMap
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups = function (babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate, shouldExportAnimation) {
+    _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups = function (babylonScene, glTFAnimations, nodeMap, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         var _a;
         var glTFAnimation;
         if (babylonScene.animationGroups) {
@@ -2225,8 +2195,7 @@ var _GLTFAnimation = /** @class */ (function () {
                         if (animationInfo) {
                             var babylonTransformNode = this_1._IsTransformable(target) ? target : this_1._IsTransformable(target[0]) ? target[0] : null;
                             if (babylonTransformNode) {
-                                var convertToRightHandedSystem = convertToRightHandedSystemMap[babylonTransformNode.uniqueId];
-                                _GLTFAnimation._AddAnimation("".concat(animation.name), glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                                _GLTFAnimation._AddAnimation("".concat(animation.name), glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate);
                             }
                         }
                     }
@@ -2308,7 +2277,7 @@ var _GLTFAnimation = /** @class */ (function () {
                     combinedAnimationGroup.setKeys(animationKeys);
                     var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
                     if (animationInfo) {
-                        _GLTFAnimation._AddAnimation("".concat(animationGroup.name, "_").concat(mesh.name, "_MorphWeightAnimation"), glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, false, animationInfo.useQuaternion, animationSampleRate, morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets);
+                        _GLTFAnimation._AddAnimation("".concat(animationGroup.name, "_").concat(mesh.name, "_MorphWeightAnimation"), glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets);
                     }
                 });
                 if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
@@ -2322,8 +2291,8 @@ var _GLTFAnimation = /** @class */ (function () {
             }
         }
     };
-    _GLTFAnimation._AddAnimation = function (name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, useQuaternion, animationSampleRate, morphAnimationChannels) {
-        var animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate);
+    _GLTFAnimation._AddAnimation = function (name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, useQuaternion, animationSampleRate, morphAnimationChannels) {
+        var animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, useQuaternion, animationSampleRate);
         var bufferView;
         var accessor;
         var keyframeAccessorIndex;
@@ -2407,10 +2376,9 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param minMaxFrames
      * @param minMaxFrames.min
      * @param minMaxFrames.max
-     * @param convertToRightHandedSystem converts the values to right-handed
      * @param useQuaternion specifies if quaternions should be used
      */
-    _GLTFAnimation._CreateBakedAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, convertToRightHandedSystem, useQuaternion) {
+    _GLTFAnimation._CreateBakedAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, useQuaternion) {
         var value;
         var quaternionCache = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity();
         var previousTime = null;
@@ -2464,7 +2432,7 @@ var _GLTFAnimation = /** @class */ (function () {
                         loopMode: animation.loopMode,
                     };
                     value = animation._interpolate(f, state);
-                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, useQuaternion);
                 }
             }
         }
@@ -2472,23 +2440,17 @@ var _GLTFAnimation = /** @class */ (function () {
             minMaxFrames.max = maxUsedFrame;
         }
     };
-    _GLTFAnimation._ConvertFactorToVector3OrQuaternion = function (factor, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
-        var basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+    _GLTFAnimation._ConvertFactorToVector3OrQuaternion = function (factor, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion) {
+        var basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, useQuaternion);
         // handles single component x, y, z or w component animation by using a base property and animating over a component.
         var property = animation.targetProperty.split(".");
-        var componentName = property ? property[1] : ""; // x, y, or z component
+        var componentName = property ? property[1] : ""; // x, y, z, or w component
         var value = useQuaternion ? core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray(basePositionRotationOrScale).normalize() : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArray(basePositionRotationOrScale);
         switch (componentName) {
-            case "x": {
-                value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
-                break;
-            }
-            case "y": {
-                value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
-                break;
-            }
+            case "x":
+            case "y":
             case "z": {
-                value[componentName] = convertToRightHandedSystem && !useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
+                value[componentName] = factor;
                 break;
             }
             case "w": {
@@ -2501,7 +2463,7 @@ var _GLTFAnimation = /** @class */ (function () {
         }
         return value;
     };
-    _GLTFAnimation._SetInterpolatedValue = function (babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    _GLTFAnimation._SetInterpolatedValue = function (babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, useQuaternion) {
         var cacheValue;
         inputs.push(time);
         if (animationChannelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */) {
@@ -2509,7 +2471,7 @@ var _GLTFAnimation = /** @class */ (function () {
             return;
         }
         if (animation.dataType === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_FLOAT) {
-            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion);
         }
         if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
             if (useQuaternion) {
@@ -2519,24 +2481,11 @@ var _GLTFAnimation = /** @class */ (function () {
                 cacheValue = value;
                 core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRollToRef(cacheValue.y, cacheValue.x, cacheValue.z, quaternionCache);
             }
-            if (convertToRightHandedSystem) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionFromRef(quaternionCache);
-                if (!babylonTransformNode.parent) {
-                    quaternionCache = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(quaternionCache);
-                }
-            }
             outputs.push(quaternionCache.asArray());
         }
         else {
             // scaling and position animation
             cacheValue = value;
-            if (convertToRightHandedSystem && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedPositionVector3FromRef(cacheValue);
-                if (!babylonTransformNode.parent) {
-                    cacheValue.x *= -1;
-                    cacheValue.z *= -1;
-                }
-            }
             outputs.push(cacheValue.asArray());
         }
     };
@@ -2545,17 +2494,15 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param babylonTransformNode BabylonJS mesh
      * @param animation BabylonJS animation
      * @param animationChannelTargetPath The target animation channel
-     * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
-    _GLTFAnimation._CreateLinearOrStepAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    _GLTFAnimation._CreateLinearOrStepAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion) {
         for (var _i = 0, _a = animation.getKeys(); _i < _a.length; _i++) {
             var keyFrame = _a[_i];
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion);
         }
     };
     /**
@@ -2566,42 +2513,31 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
-    _GLTFAnimation._CreateCubicSplineAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    _GLTFAnimation._CreateCubicSplineAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion) {
         animation.getKeys().forEach(function (keyFrame) {
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
+            _GLTFAnimation._AddSplineTangent(_TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, useQuaternion);
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion);
+            _GLTFAnimation._AddSplineTangent(_TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, useQuaternion);
         });
     };
-    _GLTFAnimation._GetBasePositionRotationOrScale = function (babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+    _GLTFAnimation._GetBasePositionRotationOrScale = function (babylonTransformNode, animationChannelTargetPath, useQuaternion) {
         var basePositionRotationOrScale;
         if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
             if (useQuaternion) {
                 var q = babylonTransformNode.rotationQuaternion;
                 basePositionRotationOrScale = (q !== null && q !== void 0 ? q : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity()).asArray();
-                if (convertToRightHandedSystem) {
-                    _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionArrayFromRef(basePositionRotationOrScale);
-                    if (!babylonTransformNode.parent) {
-                        basePositionRotationOrScale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray(basePositionRotationOrScale)).asArray();
-                    }
-                }
             }
             else {
                 var r = babylonTransformNode.rotation;
                 basePositionRotationOrScale = (r !== null && r !== void 0 ? r : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.Zero()).asArray();
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedNormalArray3FromRef(basePositionRotationOrScale);
             }
         }
         else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
             var p = babylonTransformNode.position;
             basePositionRotationOrScale = (p !== null && p !== void 0 ? p : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.Zero()).asArray();
-            if (convertToRightHandedSystem) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedPositionArray3FromRef(basePositionRotationOrScale);
-            }
         }
         else {
             // scale
@@ -2617,35 +2553,18 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param outputs
      * @param animationChannelTargetPath
      * @param babylonTransformNode
-     * @param convertToRightHandedSystem
      * @param useQuaternion
      */
-    _GLTFAnimation._AddKeyframeValue = function (keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
-        var value;
+    _GLTFAnimation._AddKeyframeValue = function (keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion) {
         var newPositionRotationOrScale;
         var animationType = animation.dataType;
         if (animationType === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_VECTOR3) {
-            value = keyFrame.value.asArray();
+            var value = keyFrame.value.asArray();
             if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
                 var array = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArray(value);
                 var rotationQuaternion = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRoll(array.y, array.x, array.z);
-                if (convertToRightHandedSystem) {
-                    _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-                    if (!babylonTransformNode.parent) {
-                        rotationQuaternion = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(rotationQuaternion);
-                    }
-                }
                 value = rotationQuaternion.asArray();
             }
-            else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                if (convertToRightHandedSystem) {
-                    _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedNormalArray3FromRef(value);
-                    if (!babylonTransformNode.parent) {
-                        value[0] *= -1;
-                        value[2] *= -1;
-                    }
-                }
-            }
             outputs.push(value); // scale  vector.
         }
         else if (animationType === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_FLOAT) {
@@ -2654,42 +2573,20 @@ var _GLTFAnimation = /** @class */ (function () {
             }
             else {
                 // handles single component x, y, z or w component animation by using a base property and animating over a component.
-                newPositionRotationOrScale = this._ConvertFactorToVector3OrQuaternion(keyFrame.value, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+                newPositionRotationOrScale = this._ConvertFactorToVector3OrQuaternion(keyFrame.value, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion);
                 if (newPositionRotationOrScale) {
                     if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
                         var posRotScale = useQuaternion
                             ? newPositionRotationOrScale
                             : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRoll(newPositionRotationOrScale.y, newPositionRotationOrScale.x, newPositionRotationOrScale.z).normalize();
-                        if (convertToRightHandedSystem) {
-                            _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionFromRef(posRotScale);
-                            if (!babylonTransformNode.parent) {
-                                posRotScale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(posRotScale);
-                            }
-                        }
                         outputs.push(posRotScale.asArray());
                     }
-                    else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                        if (convertToRightHandedSystem) {
-                            _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedNormalVector3FromRef(newPositionRotationOrScale);
-                            if (!babylonTransformNode.parent) {
-                                newPositionRotationOrScale.x *= -1;
-                                newPositionRotationOrScale.z *= -1;
-                            }
-                        }
-                    }
                     outputs.push(newPositionRotationOrScale.asArray());
                 }
             }
         }
         else if (animationType === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_QUATERNION) {
-            value = keyFrame.value.normalize().asArray();
-            if (convertToRightHandedSystem) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionArrayFromRef(value);
-                if (!babylonTransformNode.parent) {
-                    value = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray(value)).asArray();
-                }
-            }
-            outputs.push(value);
+            outputs.push(keyFrame.value.normalize().asArray());
         }
         else {
             core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Tools.Error("glTFAnimation: Unsupported key frame values for animation!");
@@ -2757,9 +2654,8 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param keyFrame The key frame with the animation data
      * @param frameDelta Time difference between two frames used to scale the tangent by the frame delta
      * @param useQuaternion Specifies if quaternions are used
-     * @param convertToRightHandedSystem Specifies if the values should be converted to right-handed
      */
-    _GLTFAnimation._AddSplineTangent = function (babylonTransformNode, tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem) {
+    _GLTFAnimation._AddSplineTangent = function (tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, useQuaternion) {
         var tangent;
         var tangentValue = tangentType === _TangentType.INTANGENT ? keyFrame.inTangent : keyFrame.outTangent;
         if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
@@ -2772,12 +2668,6 @@ var _GLTFAnimation = /** @class */ (function () {
                         var array = tangentValue;
                         tangent = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.RotationYawPitchRoll(array.y, array.x, array.z).asArray();
                     }
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedQuaternionArrayFromRef(tangent);
-                        if (!babylonTransformNode.parent) {
-                            tangent = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray([0, 1, 0, 0]).multiply(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray(tangent)).asArray();
-                        }
-                    }
                 }
                 else {
                     tangent = [0, 0, 0, 0];
@@ -2794,15 +2684,6 @@ var _GLTFAnimation = /** @class */ (function () {
             else {
                 if (tangentValue) {
                     tangent = tangentValue.asArray();
-                    if (convertToRightHandedSystem) {
-                        if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                            _glTFUtilities__WEBPACK_IMPORTED_MODULE_1__._GLTFUtilities._GetRightHandedPositionArray3FromRef(tangent);
-                            if (!babylonTransformNode.parent) {
-                                tangent[0] *= -1; // x
-                                tangent[2] *= -1; // z
-                            }
-                        }
-                    }
                 }
                 else {
                     tangent = [0, 0, 0];
@@ -2910,7 +2791,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "_Exporter": () => (/* binding */ _Exporter)
 /* harmony export */ });
 /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.js");
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/multiMaterial */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/multiMaterial */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _glTFMaterialExporter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFMaterialExporter */ "../../../lts/serializers/dist/glTF/2.0/glTFMaterialExporter.js");
 /* harmony import */ var _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./glTFUtilities */ "../../../lts/serializers/dist/glTF/2.0/glTFUtilities.js");
@@ -2937,6 +2818,54 @@ __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());
+function isNoopNode(node, useRightHandedSystem) {
+    if (!(node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TransformNode)) {
+        return false;
+    }
+    // Transform
+    if (useRightHandedSystem) {
+        var matrix = node.getWorldMatrix();
+        if (!matrix.isIdentity()) {
+            return false;
+        }
+    }
+    else {
+        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) || (node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.InstancedMesh && node.sourceMesh.geometry)) {
+        return false;
+    }
+    return true;
+}
+function convertNodeHandedness(node) {
+    var translation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArrayToRef(node.translation || [0, 0, 0], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Vector3[0]);
+    var rotation = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArrayToRef(node.rotation || [0, 0, 0, 1], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Quaternion[0]);
+    var scale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArrayToRef(node.scale || [1, 1, 1], 0, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Vector3[1]);
+    var matrix = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.ComposeToRef(scale, rotation, translation, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Matrix[0]).multiplyToRef(convertHandednessMatrix, core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TmpVectors.Matrix[0]);
+    matrix.decompose(scale, rotation, translation);
+    if (translation.equalsToFloats(0, 0, 0)) {
+        delete node.translation;
+    }
+    else {
+        node.translation = translation.asArray();
+    }
+    if (core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.IsIdentity(rotation)) {
+        delete node.rotation;
+    }
+    else {
+        node.rotation = rotation.asArray();
+    }
+    if (scale.equalsToFloats(1, 1, 1)) {
+        delete node.scale;
+    }
+    else {
+        node.scale = scale.asArray();
+    }
+}
 /**
  * Converts Babylon Scene into glTF 2.0.
  * @internal
@@ -2948,10 +2877,6 @@ var _Exporter = /** @class */ (function () {
      * @param options Options to modify the behavior of the exporter
      */
     function _Exporter(babylonScene, options) {
-        /*
-         * Specifies if root Babylon empty nodes that act as a coordinate space transform should be included in export
-         */
-        this._includeCoordinateSystemConversionNodes = false;
         this._extensions = {};
         this._glTF = {
             asset: { generator: "Babylon.js v".concat(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Engine.Version), version: "2.0" },
@@ -2977,8 +2902,7 @@ var _Exporter = /** @class */ (function () {
         this._imageData = {};
         this._orderedImageData = [];
         this._options = options || {};
-        this._animationSampleRate = options && options.animationSampleRate ? options.animationSampleRate : 1 / 60;
-        this._includeCoordinateSystemConversionNodes = options && options.includeCoordinateSystemConversionNodes ? true : false;
+        this._animationSampleRate = this._options.animationSampleRate || 1 / 60;
         this._glTFMaterialExporter = new _glTFMaterialExporter__WEBPACK_IMPORTED_MODULE_2__._GLTFMaterialExporter(this);
         this._loadExtensions();
     }
@@ -3157,28 +3081,24 @@ var _Exporter = /** @class */ (function () {
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
      * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderVertexAttributeDataBasedOnPrimitiveMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
-        if (convertToRightHandedSystem && sideOrientation === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.ClockWiseSideOrientation) {
-            switch (primitiveMode) {
-                case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleFillMode: {
-                    this._reorderTriangleFillMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleStripDrawMode: {
-                    this._reorderTriangleStripDrawMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
-                case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleFanDrawMode: {
-                    this._reorderTriangleFanMode(submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem);
-                    break;
-                }
+    _Exporter.prototype._reorderVertexAttributeDataBasedOnPrimitiveMode = function (submesh, primitiveMode, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
+        switch (primitiveMode) {
+            case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleFillMode: {
+                this._reorderTriangleFillMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
+            }
+            case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleStripDrawMode: {
+                this._reorderTriangleStripDrawMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
+            }
+            case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleFanDrawMode: {
+                this._reorderTriangleFanMode(submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter);
+                break;
             }
         }
     };
@@ -3186,15 +3106,12 @@ var _Exporter = /** @class */ (function () {
      * Reorders the vertex attributes in the correct triangle mode order .  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleFillMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._reorderTriangleFillMode = function (submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             var stride = vertexBuffer.byteStride / core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -3255,7 +3172,7 @@ var _Exporter = /** @class */ (function () {
                         core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
                     }
                 }
-                this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+                this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, binaryWriter);
             }
         }
         else {
@@ -3266,15 +3183,12 @@ var _Exporter = /** @class */ (function () {
      * Reorders the vertex attributes in the correct triangle strip order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleStripDrawMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._reorderTriangleStripDrawMode = function (submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             var stride = vertexBuffer.byteStride / core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -3316,7 +3230,7 @@ var _Exporter = /** @class */ (function () {
                     core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
                 }
             }
-            this._writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+            this._writeVertexAttributeData(vertexData, byteOffset + 12, vertexBufferKind, binaryWriter);
         }
         else {
             core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("reorderTriangleStripDrawMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
@@ -3326,15 +3240,12 @@ var _Exporter = /** @class */ (function () {
      * Reorders the vertex attributes in the correct triangle fan order.  This is necessary when indices are not available and the winding order is
      * clock-wise during export to glTF
      * @param submesh BabylonJS submesh
-     * @param primitiveMode Primitive mode of the mesh
-     * @param sideOrientation the winding order of the submesh
      * @param vertexBufferKind The type of vertex attribute
      * @param meshAttributeArray The vertex attribute data
      * @param byteOffset The offset to the binary data
      * @param binaryWriter The binary data for the glTF file
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._reorderTriangleFanMode = function (submesh, primitiveMode, sideOrientation, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._reorderTriangleFanMode = function (submesh, vertexBufferKind, meshAttributeArray, byteOffset, binaryWriter) {
         var vertexBuffer = this._getVertexBufferFromMesh(vertexBufferKind, submesh.getMesh());
         if (vertexBuffer) {
             var stride = vertexBuffer.byteStride / core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.GetTypeByteLength(vertexBuffer.type);
@@ -3378,7 +3289,7 @@ var _Exporter = /** @class */ (function () {
                     core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Unsupported Vertex Buffer type: ".concat(vertexBufferKind));
                 }
             }
-            this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem);
+            this._writeVertexAttributeData(vertexData, byteOffset, vertexBufferKind, binaryWriter);
         }
         else {
             core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("reorderTriangleFanMode: Vertex buffer kind ".concat(vertexBufferKind, " not present!"));
@@ -3389,29 +3300,11 @@ var _Exporter = /** @class */ (function () {
      * @param vertices The vertices to write to the binary writer
      * @param byteOffset The offset into the binary writer to overwrite binary data
      * @param vertexAttributeKind The vertex attribute type
-     * @param meshAttributeArray The vertex attribute data
      * @param binaryWriter The writer containing the binary data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._writeVertexAttributeData = function (vertices, byteOffset, vertexAttributeKind, meshAttributeArray, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._writeVertexAttributeData = function (vertices, byteOffset, vertexAttributeKind, binaryWriter) {
         for (var _i = 0, vertices_1 = vertices; _i < vertices_1.length; _i++) {
             var vertex = vertices_1[_i];
-            if (convertToRightHandedSystem && !(vertexAttributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.ColorKind) && !(vertex instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector2)) {
-                if (vertex instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3) {
-                    if (vertexAttributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.NormalKind) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedNormalVector3FromRef(vertex);
-                    }
-                    else if (vertexAttributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.PositionKind) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedPositionVector3FromRef(vertex);
-                    }
-                    else {
-                        core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Error("Unsupported vertex attribute kind!");
-                    }
-                }
-                else {
-                    _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedVector4FromRef(vertex);
-                }
-            }
             if (vertexAttributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.NormalKind) {
                 vertex.normalize();
             }
@@ -3433,10 +3326,9 @@ var _Exporter = /** @class */ (function () {
      * @param meshAttributeArray Array containing the attribute data
      * @param stride Specifies the space between data
      * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @param babylonTransformNode
      */
-    _Exporter.prototype._writeAttributeData = function (vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, convertToRightHandedSystem, babylonTransformNode) {
+    _Exporter.prototype._writeAttributeData = function (vertexBufferKind, attributeComponentKind, meshAttributeArray, stride, binaryWriter, babylonTransformNode) {
         var vertexAttributes = [];
         var index;
         switch (vertexBufferKind) {
@@ -3444,9 +3336,6 @@ var _Exporter = /** @class */ (function () {
                 for (var k = 0, length_2 = meshAttributeArray.length / stride; k < length_2; ++k) {
                     index = k * stride;
                     var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedPositionVector3FromRef(vertexData);
-                    }
                     vertexAttributes.push(vertexData.asArray());
                 }
                 break;
@@ -3455,11 +3344,7 @@ var _Exporter = /** @class */ (function () {
                 for (var k = 0, length_3 = meshAttributeArray.length / stride; k < length_3; ++k) {
                     index = k * stride;
                     var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedNormalVector3FromRef(vertexData);
-                    }
-                    vertexData.normalize();
-                    vertexAttributes.push(vertexData.asArray());
+                    vertexAttributes.push(vertexData.normalize().asArray());
                 }
                 break;
             }
@@ -3467,9 +3352,6 @@ var _Exporter = /** @class */ (function () {
                 for (var k = 0, length_4 = meshAttributeArray.length / stride; k < length_4; ++k) {
                     index = k * stride;
                     var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector4.FromArray(meshAttributeArray, index);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedVector4FromRef(vertexData);
-                    }
                     _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._NormalizeTangentFromRef(vertexData);
                     vertexAttributes.push(vertexData.asArray());
                 }
@@ -3502,7 +3384,8 @@ var _Exporter = /** @class */ (function () {
             case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.UV2Kind: {
                 for (var k = 0, length_6 = meshAttributeArray.length / stride; k < length_6; ++k) {
                     index = k * stride;
-                    vertexAttributes.push(convertToRightHandedSystem ? [meshAttributeArray[index], meshAttributeArray[index + 1]] : [meshAttributeArray[index], meshAttributeArray[index + 1]]);
+                    var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector2.FromArray(meshAttributeArray, index);
+                    vertexAttributes.push(vertexData.asArray());
                 }
                 break;
             }
@@ -3571,10 +3454,9 @@ var _Exporter = /** @class */ (function () {
      * @param morphTargetAttributeArray
      * @param stride Specifies the space between data
      * @param binaryWriter The buffer to write the binary data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @param minMax
      */
-    _Exporter.prototype.writeMorphTargetAttributeData = function (vertexBufferKind, attributeComponentKind, meshPrimitive, morphTarget, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, convertToRightHandedSystem, minMax) {
+    _Exporter.prototype.writeMorphTargetAttributeData = function (vertexBufferKind, attributeComponentKind, meshPrimitive, meshAttributeArray, morphTargetAttributeArray, stride, binaryWriter, minMax) {
         var vertexAttributes = [];
         var index;
         var difference = new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3();
@@ -3586,9 +3468,6 @@ var _Exporter = /** @class */ (function () {
                     var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(meshAttributeArray, index);
                     var morphData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(morphTargetAttributeArray, index);
                     difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedPositionVector3FromRef(difference);
-                    }
                     if (minMax) {
                         minMax.min.copyFromFloats(Math.min(difference.x, minMax.min.x), Math.min(difference.y, minMax.min.y), Math.min(difference.z, minMax.min.z));
                         minMax.max.copyFromFloats(Math.max(difference.x, minMax.max.x), Math.max(difference.y, minMax.max.y), Math.max(difference.z, minMax.max.z));
@@ -3600,14 +3479,9 @@ var _Exporter = /** @class */ (function () {
             case core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.NormalKind: {
                 for (var k = meshPrimitive.verticesStart; k < meshPrimitive.verticesCount; ++k) {
                     index = meshPrimitive.indexStart + k * stride;
-                    var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(meshAttributeArray, index);
-                    vertexData.normalize();
-                    var morphData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(morphTargetAttributeArray, index);
-                    morphData.normalize();
+                    var vertexData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(meshAttributeArray, index).normalize();
+                    var morphData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(morphTargetAttributeArray, index).normalize();
                     difference = morphData.subtractToRef(vertexData, difference);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedNormalVector3FromRef(difference);
-                    }
                     vertexAttributes.push(difference.asArray());
                 }
                 break;
@@ -3620,9 +3494,6 @@ var _Exporter = /** @class */ (function () {
                     var morphData = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector4.FromArray(morphTargetAttributeArray, index);
                     _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._NormalizeTangentFromRef(morphData);
                     difference4 = morphData.subtractToRef(vertexData, difference4);
-                    if (convertToRightHandedSystem) {
-                        _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedVector4FromRef(difference4);
-                    }
                     vertexAttributes.push([difference4.x, difference4.y, difference4.z]);
                 }
                 break;
@@ -3784,7 +3655,7 @@ var _Exporter = /** @class */ (function () {
     _Exporter.prototype._generateBinaryAsync = function () {
         var _this = this;
         var binaryWriter = new _BinaryWriter(4);
-        return this._createSceneAsync(this._babylonScene, binaryWriter).then(function () {
+        return this._createSceneAsync(binaryWriter).then(function () {
             if (_this._localEngine) {
                 _this._localEngine.dispose();
             }
@@ -3903,16 +3774,13 @@ var _Exporter = /** @class */ (function () {
      * Sets the TRS for each node
      * @param node glTF Node for storing the transformation data
      * @param babylonTransformNode Babylon mesh used as the source for the transformation data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setNodeTransformation = function (node, babylonTransformNode, convertToRightHandedSystem) {
+    _Exporter.prototype._setNodeTransformation = function (node, babylonTransformNode) {
         if (!babylonTransformNode.getPivotPoint().equalsToFloats(0, 0, 0)) {
             core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Pivot points are not supported in the glTF serializer");
         }
         if (!babylonTransformNode.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem
-                ? _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedPositionVector3(babylonTransformNode.position).asArray()
-                : babylonTransformNode.position.asArray();
+            node.translation = babylonTransformNode.position.asArray();
         }
         if (!babylonTransformNode.scaling.equalsToFloats(1, 1, 1)) {
             node.scale = babylonTransformNode.scaling.asArray();
@@ -3922,21 +3790,15 @@ var _Exporter = /** @class */ (function () {
             rotationQuaternion.multiplyInPlace(babylonTransformNode.rotationQuaternion);
         }
         if (!core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
     };
-    _Exporter.prototype._setCameraTransformation = function (node, babylonCamera, convertToRightHandedSystem) {
+    _Exporter.prototype._setCameraTransformation = function (node, babylonCamera) {
         if (!babylonCamera.position.equalsToFloats(0, 0, 0)) {
-            node.translation = convertToRightHandedSystem ? _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedPositionVector3(babylonCamera.position).asArray() : babylonCamera.position.asArray();
+            node.translation = babylonCamera.position.asArray();
         }
         var rotationQuaternion = babylonCamera.rotationQuaternion; // we target the local transformation if one.
         if (rotationQuaternion && !core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.IsIdentity(rotationQuaternion)) {
-            if (convertToRightHandedSystem) {
-                _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-            }
             node.rotation = rotationQuaternion.normalize().asArray();
         }
     };
@@ -3956,9 +3818,8 @@ var _Exporter = /** @class */ (function () {
      * @param babylonTransformNode The Babylon mesh to get the vertices data from
      * @param binaryWriter The buffer to write the bufferview data to
      * @param byteStride
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._createBufferViewKind = function (kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride, convertToRightHandedSystem) {
+    _Exporter.prototype._createBufferViewKind = function (kind, attributeComponentKind, babylonTransformNode, binaryWriter, byteStride) {
         var bufferMesh = babylonTransformNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh
             ? babylonTransformNode
             : babylonTransformNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.InstancedMesh
@@ -3972,7 +3833,7 @@ var _Exporter = /** @class */ (function () {
                 var byteLength = vertexData.length * typeByteLength;
                 var bufferView = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, byteStride, kind + " - " + bufferMesh.name);
                 this._bufferViews.push(bufferView);
-                this._writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, convertToRightHandedSystem, babylonTransformNode);
+                this._writeAttributeData(kind, attributeComponentKind, vertexData, byteStride / typeByteLength, binaryWriter, babylonTransformNode);
             }
         }
     };
@@ -3982,9 +3843,8 @@ var _Exporter = /** @class */ (function () {
      * @param meshPrimitive
      * @param babylonMorphTarget the morph target to be exported
      * @param binaryWriter The buffer to write the bufferview data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setMorphTargetAttributes = function (babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._setMorphTargetAttributes = function (babylonSubMesh, meshPrimitive, babylonMorphTarget, binaryWriter) {
         if (babylonMorphTarget) {
             if (!meshPrimitive.targets) {
                 meshPrimitive.targets = [];
@@ -4003,7 +3863,7 @@ var _Exporter = /** @class */ (function () {
                 var accessor = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "NORMAL", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.NORMAL = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.NormalKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexNormals, morphNormals, byteStride / 4, binaryWriter, convertToRightHandedSystem);
+                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.NormalKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexNormals, morphNormals, byteStride / 4, binaryWriter);
             }
             if (babylonMorphTarget.hasPositions) {
                 var vertexPositions = mesh.getVerticesData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.PositionKind, undefined, undefined, true);
@@ -4018,7 +3878,7 @@ var _Exporter = /** @class */ (function () {
                 var accessor = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "POSITION", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.POSITION = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.PositionKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexPositions, morphPositions, byteStride / 4, binaryWriter, convertToRightHandedSystem, minMax);
+                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.PositionKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexPositions, morphPositions, byteStride / 4, binaryWriter, minMax);
                 accessor.min = minMax.min.asArray();
                 accessor.max = minMax.max.asArray();
             }
@@ -4034,7 +3894,7 @@ var _Exporter = /** @class */ (function () {
                 var accessor = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CreateAccessor(bufferViewIndex, babylonMorphTarget.name + " - " + "TANGENT", "VEC3" /* AccessorType.VEC3 */, 5126 /* AccessorComponentType.FLOAT */, count, 0, null, null);
                 this._accessors.push(accessor);
                 target.TANGENT = this._accessors.length - 1;
-                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.TangentKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, babylonMorphTarget, vertexTangents, morphTangents, byteStride / 4, binaryWriter, convertToRightHandedSystem);
+                this.writeMorphTargetAttributeData(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.TangentKind, 5126 /* AccessorComponentType.FLOAT */, babylonSubMesh, vertexTangents, morphTangents, byteStride / 4, binaryWriter);
             }
             meshPrimitive.targets.push(target);
         }
@@ -4154,10 +4014,8 @@ var _Exporter = /** @class */ (function () {
      * @param mesh glTF Mesh object to store the primitive attribute information
      * @param babylonTransformNode Babylon mesh to get the primitive attribute data from
      * @param binaryWriter Buffer to write the attribute data to
-     * @param convertToRightHandedSystem Converts the values to right-handed
      */
-    _Exporter.prototype._setPrimitiveAttributesAsync = function (mesh, babylonTransformNode, binaryWriter, convertToRightHandedSystem) {
-        var _a;
+    _Exporter.prototype._setPrimitiveAttributesAsync = function (mesh, babylonTransformNode, binaryWriter) {
         var promises = [];
         var bufferMesh = null;
         var bufferView;
@@ -4198,7 +4056,7 @@ var _Exporter = /** @class */ (function () {
                     if (attribute.byteStride === 12) {
                         attribute.accessorType = "VEC3" /* AccessorType.VEC3 */;
                     }
-                    this._createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride, convertToRightHandedSystem);
+                    this._createBufferViewKind(attributeKind, attributeComponentKind, babylonTransformNode, binaryWriter, attribute.byteStride);
                     attribute.bufferViewIndex = this._bufferViews.length - 1;
                     vertexAttributeBufferViews[attributeKind] = attribute.bufferViewIndex;
                 }
@@ -4217,8 +4075,8 @@ var _Exporter = /** @class */ (function () {
             }
             if (bufferMesh.subMeshes) {
                 // go through all mesh primitives (submeshes)
-                for (var _b = 0, _c = bufferMesh.subMeshes; _b < _c.length; _b++) {
-                    var submesh = _c[_b];
+                for (var _a = 0, _b = bufferMesh.subMeshes; _a < _b.length; _a++) {
+                    var submesh = _b[_a];
                     var babylonMaterial = submesh.getMaterial() || bufferMesh.getScene().defaultMaterial;
                     var materialIndex = null;
                     if (babylonMaterial) {
@@ -4249,8 +4107,8 @@ var _Exporter = /** @class */ (function () {
                     var glTFMaterial = materialIndex != null ? this._materials[materialIndex] : null;
                     var meshPrimitive = { attributes: {} };
                     this._setPrimitiveMode(meshPrimitive, primitiveMode);
-                    for (var _d = 0, attributeData_2 = attributeData; _d < attributeData_2.length; _d++) {
-                        var attribute = attributeData_2[_d];
+                    for (var _c = 0, attributeData_2 = attributeData; _c < attributeData_2.length; _c++) {
+                        var attribute = attributeData_2[_c];
                         var attributeKind = attribute.kind;
                         if ((attributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.UVKind || attributeKind === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.UV2Kind) && !this._options.exportUnusedUVs) {
                             if (!glTFMaterial || !this._glTFMaterialExporter._hasTexturesPresent(glTFMaterial)) {
@@ -4267,7 +4125,7 @@ var _Exporter = /** @class */ (function () {
                                     // check to see if bufferviewindex has a numeric value assigned.
                                     minMax = { min: null, max: null };
                                     if (attributeKind == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.VertexBuffer.PositionKind) {
-                                        minMax = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride, convertToRightHandedSystem);
+                                        minMax = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CalculateMinMaxPositions(vertexData, 0, vertexData.length / stride);
                                     }
                                     var accessor = _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__._GLTFUtilities._CreateAccessor(bufferViewIndex, attributeKind + " - " + babylonTransformNode.name, attribute.accessorType, attribute.accessorComponentType, vertexData.length / stride, 0, minMax.min, minMax.max);
                                     this._accessors.push(accessor);
@@ -4284,10 +4142,7 @@ var _Exporter = /** @class */ (function () {
                     }
                     if (materialIndex != null && Object.keys(meshPrimitive.attributes).length > 0) {
                         var sideOrientation = bufferMesh.overrideMaterialSideOrientation !== null ? bufferMesh.overrideMaterialSideOrientation : babylonMaterial.sideOrientation;
-                        if ((sideOrientation == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.ClockWiseSideOrientation && this._babylonScene.useRightHandedSystem) ||
-                            (sideOrientation == core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.ClockWiseSideOrientation &&
-                                convertToRightHandedSystem &&
-                                bufferMesh.overrideMaterialSideOrientation !== ((_a = bufferMesh.material) === null || _a === void 0 ? void 0 : _a.sideOrientation))) {
+                        if (sideOrientation === (this._babylonScene.useRightHandedSystem ? core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.ClockWiseSideOrientation : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Material.CounterClockWiseSideOrientation)) {
                             var byteOffset = indexBufferViewIndex != null ? this._bufferViews[indexBufferViewIndex].byteOffset : null;
                             if (byteOffset == null) {
                                 byteOffset = 0;
@@ -4300,15 +4155,12 @@ var _Exporter = /** @class */ (function () {
                                 this._reorderIndicesBasedOnPrimitiveMode(submesh, primitiveMode, babylonIndices, byteOffset, binaryWriter);
                             }
                             else {
-                                for (var _e = 0, attributeData_3 = attributeData; _e < attributeData_3.length; _e++) {
-                                    var attribute = attributeData_3[_e];
+                                for (var _d = 0, attributeData_3 = attributeData; _d < attributeData_3.length; _d++) {
+                                    var attribute = attributeData_3[_d];
                                     var vertexData = bufferMesh.getVerticesData(attribute.kind, undefined, undefined, true);
                                     if (vertexData) {
-                                        var byteOffset_1 = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset;
-                                        if (!byteOffset_1) {
-                                            byteOffset_1 = 0;
-                                        }
-                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, sideOrientation, attribute.kind, vertexData, byteOffset_1, binaryWriter, convertToRightHandedSystem);
+                                        var byteOffset_1 = this._bufferViews[vertexAttributeBufferViews[attribute.kind]].byteOffset || 0;
+                                        this._reorderVertexAttributeDataBasedOnPrimitiveMode(submesh, primitiveMode, attribute.kind, vertexData, byteOffset_1, binaryWriter);
                                     }
                                 }
                             }
@@ -4319,7 +4171,7 @@ var _Exporter = /** @class */ (function () {
                         var target = void 0;
                         for (var i = 0; i < morphTargetManager.numTargets; ++i) {
                             target = morphTargetManager.getTarget(i);
-                            this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter, convertToRightHandedSystem);
+                            this._setMorphTargetAttributes(submesh, meshPrimitive, target, binaryWriter);
                         }
                     }
                     mesh.primitives.push(meshPrimitive);
@@ -4332,80 +4184,44 @@ var _Exporter = /** @class */ (function () {
             /* do nothing */
         });
     };
-    /**
-     * Check if the node is used to convert its descendants from a right handed coordinate system to the Babylon scene's coordinate system.
-     * @param node The node to check
-     * @returns True if the node is used to convert its descendants from right-handed to left-handed. False otherwise
-     */
-    _Exporter.prototype._isBabylonCoordinateSystemConvertingNode = function (node) {
-        if (node instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TransformNode) {
-            // Transform
-            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;
-            }
-            return true;
-        }
-        return false;
-    };
     /**
      * Creates a glTF scene based on the array of meshes
      * Returns the the total byte offset
      * @param babylonScene Babylon scene to get the mesh data from
      * @param binaryWriter Buffer to write binary data to
      */
-    _Exporter.prototype._createSceneAsync = function (babylonScene, binaryWriter) {
+    _Exporter.prototype._createSceneAsync = function (binaryWriter) {
         var _this = this;
+        var _a;
         var scene = { nodes: [] };
         var glTFNodeIndex;
         var glTFNode;
         var directDescendents;
-        var nodes = (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)([], babylonScene.transformNodes, true), babylonScene.meshes, true), babylonScene.lights, true), babylonScene.cameras, true);
-        var rootNodesToLeftHanded = [];
-        this._convertToRightHandedSystem = !babylonScene.useRightHandedSystem;
-        this._convertToRightHandedSystemMap = {};
+        var nodes = (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)((0,tslib__WEBPACK_IMPORTED_MODULE_0__.__spreadArray)([], this._babylonScene.transformNodes, true), this._babylonScene.meshes, true), this._babylonScene.lights, true), this._babylonScene.cameras, true);
+        var removedRootNodes = new Set();
         // Scene metadata
-        if (babylonScene.metadata) {
+        if (this._babylonScene.metadata) {
             if (this._options.metadataSelector) {
-                scene.extras = this._options.metadataSelector(babylonScene.metadata);
+                scene.extras = this._options.metadataSelector(this._babylonScene.metadata);
             }
-            else if (babylonScene.metadata.gltf) {
-                scene.extras = babylonScene.metadata.gltf.extras;
+            else if (this._babylonScene.metadata.gltf) {
+                scene.extras = this._babylonScene.metadata.gltf.extras;
             }
         }
-        // Set default values for all nodes
-        babylonScene.rootNodes.forEach(function (rootNode) {
-            _this._convertToRightHandedSystemMap[rootNode.uniqueId] = _this._convertToRightHandedSystem;
-            rootNode.getDescendants(false).forEach(function (descendant) {
-                _this._convertToRightHandedSystemMap[descendant.uniqueId] = _this._convertToRightHandedSystem;
-            });
-        });
-        // 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
-                var indexRootNode = nodes.indexOf(rootNode);
-                if (indexRootNode !== -1) {
-                    // should always be true
-                    nodes.splice(indexRootNode, 1);
+        // Remove no-op root nodes
+        if (((_a = this._options.removeNoopRootNodes) !== null && _a !== void 0 ? _a : true) && !this._options.includeCoordinateSystemConversionNodes) {
+            for (var _i = 0, _b = this._babylonScene.rootNodes; _i < _b.length; _i++) {
+                var rootNode = _b[_i];
+                if (isNoopNode(rootNode, this._babylonScene.useRightHandedSystem)) {
+                    removedRootNodes.add(rootNode);
+                    // Exclude the node from list of nodes to export
+                    nodes.splice(nodes.indexOf(rootNode), 1);
                 }
-                // Cancel conversion to right handed system
-                rootNode.getDescendants(false).forEach(function (descendant) {
-                    _this._convertToRightHandedSystemMap[descendant.uniqueId] = false;
-                });
             }
-        });
+        }
         // Export babylon cameras to glTFCamera
         var cameraMap = new Map();
-        babylonScene.cameras.forEach(function (camera) {
+        this._babylonScene.cameras.forEach(function (camera) {
             if (!_this._options.shouldExportNode || _this._options.shouldExportNode(camera)) {
                 var glTFCamera = {
                     type: camera.mode === core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Camera.PERSPECTIVE_CAMERA ? "perspective" /* CameraType.PERSPECTIVE */ : "orthographic" /* CameraType.ORTHOGRAPHIC */,
@@ -4435,10 +4251,10 @@ var _Exporter = /** @class */ (function () {
                 _this._cameras.push(glTFCamera);
             }
         });
-        var _a = this._getExportNodes(nodes), exportNodes = _a[0], exportMaterials = _a[1];
+        var _c = this._getExportNodes(nodes), exportNodes = _c[0], exportMaterials = _c[1];
         return this._glTFMaterialExporter._convertMaterialsToGLTFAsync(exportMaterials, "image/png" /* ImageMimeType.PNG */, true).then(function () {
-            return _this._createNodeMapAndAnimationsAsync(babylonScene, exportNodes, binaryWriter).then(function (nodeMap) {
-                return _this._createSkinsAsync(babylonScene, nodeMap, binaryWriter).then(function (skinMap) {
+            return _this._createNodeMapAndAnimationsAsync(exportNodes, binaryWriter).then(function (nodeMap) {
+                return _this._createSkinsAsync(nodeMap, binaryWriter).then(function (skinMap) {
                     _this._nodeMap = nodeMap;
                     _this._totalByteLength = binaryWriter.getByteOffset();
                     if (_this._totalByteLength == undefined) {
@@ -4461,28 +4277,20 @@ var _Exporter = /** @class */ (function () {
                             if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Camera) {
                                 glTFNode.camera = cameraMap.get(babylonNode);
                             }
-                            if (!babylonNode.parent || rootNodesToLeftHanded.indexOf(babylonNode.parent) !== -1) {
-                                if (_this._options.shouldExportNode && !_this._options.shouldExportNode(babylonNode)) {
-                                    core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Log("Omitting " + babylonNode.name + " from scene.");
+                            if (_this._options.shouldExportNode && !_this._options.shouldExportNode(babylonNode)) {
+                                core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Log("Omitting " + babylonNode.name + " from scene.");
+                            }
+                            else {
+                                if (!babylonNode.parent && !_this._babylonScene.useRightHandedSystem) {
+                                    convertNodeHandedness(glTFNode);
                                 }
-                                else {
-                                    var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                                    if (convertToRightHandedSystem) {
-                                        if (glTFNode.translation) {
-                                            glTFNode.translation[2] *= -1;
-                                            glTFNode.translation[0] *= -1;
-                                        }
-                                        glTFNode.rotation = glTFNode.rotation
-                                            ? core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray([0, 1, 0, 0]).multiply(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(glTFNode.rotation)).asArray()
-                                            : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray([0, 1, 0, 0]).asArray();
-                                    }
+                                if (!babylonNode.parent || removedRootNodes.has(babylonNode.parent)) {
                                     scene.nodes.push(glTFNodeIndex);
                                 }
                             }
                             if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh) {
-                                var babylonMesh = babylonNode;
-                                if (babylonMesh.skeleton) {
-                                    glTFNode.skin = skinMap[babylonMesh.skeleton.uniqueId];
+                                if (babylonNode.skeleton) {
+                                    glTFNode.skin = skinMap[babylonNode.skeleton.uniqueId];
                                 }
                             }
                             directDescendents = babylonNode.getDescendants(true);
@@ -4544,12 +4352,11 @@ var _Exporter = /** @class */ (function () {
     };
     /**
      * Creates a mapping of Node unique id to node index and handles animations
-     * @param babylonScene Babylon Scene
      * @param nodes Babylon transform nodes
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _Exporter.prototype._createNodeMapAndAnimationsAsync = function (babylonScene, nodes, binaryWriter) {
+    _Exporter.prototype._createNodeMapAndAnimationsAsync = function (nodes, binaryWriter) {
         var _this = this;
         var promiseChain = Promise.resolve();
         var nodeMap = {};
@@ -4562,8 +4369,7 @@ var _Exporter = /** @class */ (function () {
         var idleGLTFAnimations = [];
         var _loop_1 = function (babylonNode) {
             promiseChain = promiseChain.then(function () {
-                var convertToRightHandedSystem = _this._convertToRightHandedSystemMap[babylonNode.uniqueId];
-                return _this._createNodeAsync(babylonNode, binaryWriter, convertToRightHandedSystem).then(function (node) {
+                return _this._createNodeAsync(babylonNode, binaryWriter).then(function (node) {
                     var promise = _this._extensionsPostExportNodeAsync("createNodeAsync", node, babylonNode, nodeMap, binaryWriter);
                     if (promise == null) {
                         core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Not exporting node ".concat(babylonNode.name));
@@ -4577,10 +4383,10 @@ var _Exporter = /** @class */ (function () {
                             _this._nodes.push(node);
                             nodeIndex = _this._nodes.length - 1;
                             nodeMap[babylonNode.uniqueId] = nodeIndex;
-                            if (!babylonScene.animationGroups.length) {
-                                _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate, _this._options.shouldExportAnimation);
+                            if (!_this._babylonScene.animationGroups.length) {
+                                _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, _this._animationSampleRate, _this._options.shouldExportAnimation);
                                 if (babylonNode.animations.length) {
-                                    _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, convertToRightHandedSystem, _this._animationSampleRate, _this._options.shouldExportAnimation);
+                                    _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, _this._animationSampleRate, _this._options.shouldExportAnimation);
                                 }
                             }
                         });
@@ -4601,8 +4407,8 @@ var _Exporter = /** @class */ (function () {
                     _this._animations.push(idleGLTFAnimation);
                 }
             });
-            if (babylonScene.animationGroups.length) {
-                _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, _this._animations, nodeMap, _this._nodes, binaryWriter, _this._bufferViews, _this._accessors, _this._convertToRightHandedSystemMap, _this._animationSampleRate, _this._options.shouldExportAnimation);
+            if (_this._babylonScene.animationGroups.length) {
+                _glTFAnimation__WEBPACK_IMPORTED_MODULE_5__._GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups(_this._babylonScene, _this._animations, nodeMap, binaryWriter, _this._bufferViews, _this._accessors, _this._animationSampleRate, _this._options.shouldExportAnimation);
             }
             return nodeMap;
         });
@@ -4611,10 +4417,9 @@ var _Exporter = /** @class */ (function () {
      * Creates a glTF node from a Babylon mesh
      * @param babylonNode Source Babylon mesh
      * @param binaryWriter Buffer for storing geometry data
-     * @param convertToRightHandedSystem Converts the values to right-handed
      * @returns glTF node
      */
-    _Exporter.prototype._createNodeAsync = function (babylonNode, binaryWriter, convertToRightHandedSystem) {
+    _Exporter.prototype._createNodeAsync = function (babylonNode, binaryWriter) {
         var _this = this;
         return Promise.resolve().then(function () {
             // create node to hold translation/rotation/scale and the mesh
@@ -4626,7 +4431,7 @@ var _Exporter = /** @class */ (function () {
             }
             if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.TransformNode) {
                 // Set transformation
-                _this._setNodeTransformation(node, babylonNode, convertToRightHandedSystem);
+                _this._setNodeTransformation(node, babylonNode);
                 if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh) {
                     var morphTargetManager = babylonNode.morphTargetManager;
                     if (morphTargetManager && morphTargetManager.numTargets > 0) {
@@ -4636,7 +4441,7 @@ var _Exporter = /** @class */ (function () {
                         }
                     }
                 }
-                return _this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter, convertToRightHandedSystem).then(function () {
+                return _this._setPrimitiveAttributesAsync(mesh, babylonNode, binaryWriter).then(function () {
                     if (mesh.primitives.length) {
                         _this._meshes.push(mesh);
                         node.mesh = _this._meshes.length - 1;
@@ -4645,7 +4450,7 @@ var _Exporter = /** @class */ (function () {
                 });
             }
             else if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Camera) {
-                _this._setCameraTransformation(node, babylonNode, convertToRightHandedSystem);
+                _this._setCameraTransformation(node, babylonNode);
                 return node;
             }
             else {
@@ -4660,11 +4465,11 @@ var _Exporter = /** @class */ (function () {
      * @param binaryWriter Buffer to write binary data to
      * @returns Node mapping of unique id to index
      */
-    _Exporter.prototype._createSkinsAsync = function (babylonScene, nodeMap, binaryWriter) {
+    _Exporter.prototype._createSkinsAsync = function (nodeMap, binaryWriter) {
         var _a;
         var promiseChain = Promise.resolve();
         var skinMap = {};
-        for (var _i = 0, _b = babylonScene.skeletons; _i < _b.length; _i++) {
+        for (var _i = 0, _b = this._babylonScene.skeletons; _i < _b.length; _i++) {
             var skeleton = _b[_i];
             if (skeleton.bones.length <= 0) {
                 continue;
@@ -4993,7 +4798,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "_GLTFMaterialExporter": () => (/* binding */ _GLTFMaterialExporter)
 /* harmony export */ });
 /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.js");
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Misc/dumpTools */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Misc/dumpTools */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__);
 
 
@@ -6097,7 +5902,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "_GLTFUtilities": () => (/* binding */ _GLTFUtilities)
 /* harmony export */ });
-/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Maths/math.vector */ "core/Maths/math.vector");
+/* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Maths/math.vector */ "core/Meshes/mesh");
 /* harmony import */ var core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__);
 
 /**
@@ -6158,10 +5963,9 @@ var _GLTFUtilities = /** @class */ (function () {
      * @param positions Positions array of a mesh
      * @param vertexStart Starting vertex offset to calculate min and max values
      * @param vertexCount Number of vertices to check for min and max values
-     * @param convertToRightHandedSystem
      * @returns min number array and max number array
      */
-    _GLTFUtilities._CalculateMinMaxPositions = function (positions, vertexStart, vertexCount, convertToRightHandedSystem) {
+    _GLTFUtilities._CalculateMinMaxPositions = function (positions, vertexStart, vertexCount) {
         var min = [Infinity, Infinity, Infinity];
         var max = [-Infinity, -Infinity, -Infinity];
         var positionStrideSize = 3;
@@ -6172,9 +5976,6 @@ var _GLTFUtilities = /** @class */ (function () {
             for (var i = vertexStart, length_1 = vertexStart + vertexCount; i < length_1; ++i) {
                 indexOffset = positionStrideSize * i;
                 position = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArray(positions, indexOffset);
-                if (convertToRightHandedSystem) {
-                    _GLTFUtilities._GetRightHandedPositionVector3FromRef(position);
-                }
                 vector = position.asArray();
                 for (var j = 0; j < positionStrideSize; ++j) {
                     var num = vector[j];
@@ -6190,82 +5991,6 @@ var _GLTFUtilities = /** @class */ (function () {
         }
         return { min: min, max: max };
     };
-    /**
-     * Converts a new right-handed Vector3
-     * @param vector vector3 array
-     * @returns right-handed Vector3
-     */
-    _GLTFUtilities._GetRightHandedPositionVector3 = function (vector) {
-        return new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(vector.x, vector.y, -vector.z);
-    };
-    /**
-     * Converts a Vector3 to right-handed
-     * @param vector Vector3 to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedPositionVector3FromRef = function (vector) {
-        vector.z *= -1;
-    };
-    /**
-     * Converts a three element number array to right-handed
-     * @param vector number array to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedPositionArray3FromRef = function (vector) {
-        vector[2] *= -1;
-    };
-    /**
-     * Converts a new right-handed Vector3
-     * @param vector vector3 array
-     * @returns right-handed Vector3
-     */
-    _GLTFUtilities._GetRightHandedNormalVector3 = function (vector) {
-        return new core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3(vector.x, vector.y, -vector.z);
-    };
-    /**
-     * Converts a Vector3 to right-handed
-     * @param vector Vector3 to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedNormalVector3FromRef = function (vector) {
-        vector.z *= -1;
-    };
-    /**
-     * Converts a three element number array to right-handed
-     * @param vector number array to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedNormalArray3FromRef = function (vector) {
-        vector[2] *= -1;
-    };
-    /**
-     * Converts a Vector4 to right-handed
-     * @param vector Vector4 to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedVector4FromRef = function (vector) {
-        vector.z *= -1;
-        vector.w *= -1;
-    };
-    /**
-     * Converts a Vector4 to right-handed
-     * @param vector Vector4 to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedArray4FromRef = function (vector) {
-        vector[2] *= -1;
-        vector[3] *= -1;
-    };
-    /**
-     * Converts a Quaternion to right-handed
-     * @param quaternion Source quaternion to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedQuaternionFromRef = function (quaternion) {
-        quaternion.x *= -1;
-        quaternion.y *= -1;
-    };
-    /**
-     * Converts a Quaternion to right-handed
-     * @param quaternion Source quaternion to convert to right-handed
-     */
-    _GLTFUtilities._GetRightHandedQuaternionArrayFromRef = function (quaternion) {
-        quaternion[0] *= -1;
-        quaternion[1] *= -1;
-    };
     _GLTFUtilities._NormalizeTangentFromRef = function (tangent) {
         var length = Math.sqrt(tangent.x * tangent.x + tangent.y * tangent.y + tangent.z * tangent.z);
         if (length > 0) {
@@ -6664,7 +6389,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "STLExport": () => (/* binding */ STLExport)
 /* harmony export */ });
-/* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Maths/math.vector */ "core/Maths/math.vector");
+/* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! core/Maths/math.vector */ "core/Meshes/mesh");
 /* harmony import */ var core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_Meshes_mesh__WEBPACK_IMPORTED_MODULE_0__);
 
 
@@ -6814,13 +6539,13 @@ var STLExport = /** @class */ (function () {
 
 /***/ }),
 
-/***/ "core/Maths/math.vector":
+/***/ "core/Meshes/mesh":
 /*!****************************************************************************************************!*\
   !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
   \****************************************************************************************************/
 /***/ ((module) => {
 
-module.exports = __WEBPACK_EXTERNAL_MODULE_core_Maths_math_vector__;
+module.exports = __WEBPACK_EXTERNAL_MODULE_core_Meshes_mesh__;
 
 /***/ })