babylonjs-serializers 5.13.3 → 5.15.0

package/babylon.glTF2Serializer.js

@@ -1591,7 +1591,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/Animations/animationKey */ "core/Maths/math.vector");
+/* 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___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");
 
@@ -1602,6 +1602,8 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
 /**
  * @hidden
  * Enum for handling in tangent and out tangent.
@@ -1625,6 +1627,14 @@ var _TangentType;
 var _GLTFAnimation = /** @class */ (function () {
     function _GLTFAnimation() {
     }
+    /**
+     * Determine if a node is transformable - ie has properties it should be part of animation of transformation.
+     * @param babylonNode the node to test
+     * @returns true if can be animated, false otherwise. False if the parameter is null or undefined.
+     */
+    _GLTFAnimation._IsTransformable = function (babylonNode) {
+        return babylonNode && (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode || babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Camera || babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Light);
+    };
     /**
      * @ignore
      *
@@ -1637,37 +1647,39 @@ var _GLTFAnimation = /** @class */ (function () {
      * @returns nullable IAnimationData
      */
     _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
-        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);
-        }
-        else {
-            if (interpolation === "LINEAR" /* LINEAR */ || interpolation === "STEP" /* STEP */) {
-                _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
-            }
-            else if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
-                _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+        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);
             }
             else {
-                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                if (interpolation === "LINEAR" /* LINEAR */ || interpolation === "STEP" /* STEP */) {
+                    _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                }
+                else if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
+                    _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                }
+                else {
+                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                }
+            }
+            if (inputs.length && outputs.length) {
+                var result = {
+                    inputs: inputs,
+                    outputs: outputs,
+                    samplerInterpolation: interpolation,
+                    inputsMin: shouldBakeAnimation ? minMaxKeyFrames.min : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Tools.FloatRound(minMaxKeyFrames.min / animation.framePerSecond),
+                    inputsMax: shouldBakeAnimation ? minMaxKeyFrames.max : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Tools.FloatRound(minMaxKeyFrames.max / animation.framePerSecond),
+                };
+                return result;
             }
-        }
-        if (inputs.length && outputs.length) {
-            var result = {
-                inputs: inputs,
-                outputs: outputs,
-                samplerInterpolation: interpolation,
-                inputsMin: shouldBakeAnimation ? minMaxKeyFrames.min : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Tools.FloatRound(minMaxKeyFrames.min / animation.framePerSecond),
-                inputsMax: shouldBakeAnimation ? minMaxKeyFrames.max : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Tools.FloatRound(minMaxKeyFrames.max / animation.framePerSecond),
-            };
-            return result;
         }
         return null;
     };
@@ -1729,7 +1741,7 @@ var _GLTFAnimation = /** @class */ (function () {
      */
     _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
         var glTFAnimation;
-        if (babylonNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode) {
+        if (_GLTFAnimation._IsTransformable(babylonNode)) {
             if (babylonNode.animations) {
                 for (var _i = 0, _a = babylonNode.animations; _i < _a.length; _i++) {
                     var animation = _a[_i];
@@ -1836,12 +1848,14 @@ var _GLTFAnimation = /** @class */ (function () {
                     var targetAnimation = animationGroup.targetedAnimations[i];
                     var target = targetAnimation.target;
                     var animation = targetAnimation.animation;
-                    if (target instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode || (target.length === 1 && target[0] instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode)) {
+                    if (this_1._IsTransformable(target) || (target.length === 1 && this_1._IsTransformable(target[0]))) {
                         var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
                         if (animationInfo) {
-                            var babylonTransformNode = target instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode ? target : target[0];
-                            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);
+                            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);
+                            }
                         }
                     }
                     else if (target instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.MorphTarget || (target.length === 1 && target[0] instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.MorphTarget)) {
@@ -1926,6 +1940,7 @@ var _GLTFAnimation = /** @class */ (function () {
                     glTFAnimations.push(glTFAnimation);
                 }
             };
+            var this_1 = this;
             for (var _i = 0, animationGroups_1 = animationGroups; _i < animationGroups_1.length; _i++) {
                 var animationGroup = animationGroups_1[_i];
                 _loop_1(animationGroup);
@@ -2120,10 +2135,14 @@ var _GLTFAnimation = /** @class */ (function () {
         var animationType = animation.dataType;
         var cacheValue;
         inputs.push(time);
-        if (typeof value === "number" && babylonTransformNode instanceof core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.TransformNode) {
-            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
-        }
         if (value) {
+            if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
+                outputs.push([value]);
+                return;
+            }
+            if (typeof value === "number") {
+                value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+            }
             if (animationChannelTargetPath === "rotation" /* ROTATION */) {
                 if (useQuaternion) {
                     quaternionCache = value;
@@ -2140,9 +2159,6 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
                 outputs.push(quaternionCache.asArray());
             }
-            else if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
-                outputs.push([value]);
-            }
             else {
                 // scaling and position animation
                 cacheValue = value;
@@ -2198,33 +2214,32 @@ var _GLTFAnimation = /** @class */ (function () {
         var basePositionRotationOrScale;
         if (animationChannelTargetPath === "rotation" /* ROTATION */) {
             if (useQuaternion) {
-                if (babylonTransformNode.rotationQuaternion) {
-                    basePositionRotationOrScale = babylonTransformNode.rotationQuaternion.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();
-                        }
+                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 {
-                    basePositionRotationOrScale = core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Quaternion.Identity().asArray();
-                }
             }
             else {
-                basePositionRotationOrScale = babylonTransformNode.rotation.asArray();
+                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" /* TRANSLATION */) {
-            basePositionRotationOrScale = babylonTransformNode.position.asArray();
+            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
-            basePositionRotationOrScale = babylonTransformNode.scaling.asArray();
+            var s = babylonTransformNode.scaling;
+            basePositionRotationOrScale = (s !== null && s !== void 0 ? s : core_Maths_math_vector__WEBPACK_IMPORTED_MODULE_0__.Vector3.One()).asArray();
         }
         return basePositionRotationOrScale;
     };