@onerjs/serializers 8.23.8 → 8.23.10

package/glTF/2.0/glTFAnimation.js

@@ -17,11 +17,11 @@ var _TangentType;
     /**
      * Specifies that input tangents are used.
      */
-    _TangentType[(_TangentType["INTANGENT"] = 0)] = "INTANGENT";
+    _TangentType[_TangentType["INTANGENT"] = 0] = "INTANGENT";
     /**
      * Specifies that output tangents are used.
      */
-    _TangentType[(_TangentType["OUTTANGENT"] = 1)] = "OUTTANGENT";
+    _TangentType[_TangentType["OUTTANGENT"] = 1] = "OUTTANGENT";
 })(_TangentType || (_TangentType = {}));
 /**
  * @internal
@@ -56,38 +56,17 @@ export class _GLTFAnimation {
             const interpolation = interpolationOrBake.interpolationType;
             const shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
             if (shouldBakeAnimation) {
-                _GLTFAnimation._CreateBakedAnimation(
-                    babylonTransformNode,
-                    animation,
-                    animationChannelTargetPath,
-                    minMaxKeyFrames.min,
-                    minMaxKeyFrames.max,
-                    animation.framePerSecond,
-                    animationSampleRate,
-                    inputs,
-                    outputs,
-                    minMaxKeyFrames,
-                    useQuaternion
-                );
-            } else {
+                _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, inputs, outputs, useQuaternion);
-                } else if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
+                }
+                else if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
                     _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion);
-                } else {
-                    _GLTFAnimation._CreateBakedAnimation(
-                        babylonTransformNode,
-                        animation,
-                        animationChannelTargetPath,
-                        minMaxKeyFrames.min,
-                        minMaxKeyFrames.max,
-                        animation.framePerSecond,
-                        animationSampleRate,
-                        inputs,
-                        outputs,
-                        minMaxKeyFrames,
-                        useQuaternion
-                    );
+                }
+                else {
+                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, useQuaternion);
                 }
             }
             if (inputs.length && outputs.length) {
@@ -105,7 +84,7 @@ export class _GLTFAnimation {
     }
     static _DeduceAnimationInfo(animation) {
         let animationChannelTargetPath = null;
-        let dataAccessorType = "VEC3"; /* AccessorType.VEC3 */
+        let dataAccessorType = "VEC3" /* AccessorType.VEC3 */;
         let useQuaternion = false;
         const property = animation.targetProperty.split(".");
         switch (property[0]) {
@@ -139,7 +118,8 @@ export class _GLTFAnimation {
         }
         if (animationChannelTargetPath) {
             return { animationChannelTargetPath: animationChannelTargetPath, dataAccessorType: dataAccessorType, useQuaternion: useQuaternion };
-        } else {
+        }
+        else {
             Tools.Error("animation channel target path and data accessor type could be deduced");
         }
         return null;
@@ -157,19 +137,7 @@ export class _GLTFAnimation {
      * @param accessors
      * @param animationSampleRate
      */
-    static _CreateNodeAnimationFromNodeAnimations(
-        babylonNode,
-        runtimeGLTFAnimation,
-        idleGLTFAnimations,
-        nodeMap,
-        nodes,
-        bufferManager,
-        bufferViews,
-        accessors,
-        animationSampleRate,
-        useRightHanded,
-        shouldExportAnimation
-    ) {
+    static _CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, bufferManager, bufferViews, accessors, animationSampleRate, useRightHanded, shouldExportAnimation) {
         let glTFAnimation;
         if (_GLTFAnimation._IsTransformable(babylonNode)) {
             if (babylonNode.animations) {
@@ -184,21 +152,7 @@ export class _GLTFAnimation {
                             samplers: [],
                             channels: [],
                         };
-                        _GLTFAnimation._AddAnimation(
-                            `${animation.name}`,
-                            animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation,
-                            babylonNode,
-                            animation,
-                            animationInfo.dataAccessorType,
-                            animationInfo.animationChannelTargetPath,
-                            nodeMap,
-                            bufferManager,
-                            bufferViews,
-                            accessors,
-                            animationInfo.useQuaternion,
-                            animationSampleRate,
-                            useRightHanded
-                        );
+                        _GLTFAnimation._AddAnimation(`${animation.name}`, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, bufferManager, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, useRightHanded);
                         if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                             idleGLTFAnimations.push(glTFAnimation);
                         }
@@ -220,19 +174,7 @@ export class _GLTFAnimation {
      * @param accessors
      * @param animationSampleRate
      */
-    static _CreateMorphTargetAnimationFromMorphTargetAnimations(
-        babylonNode,
-        runtimeGLTFAnimation,
-        idleGLTFAnimations,
-        nodeMap,
-        nodes,
-        bufferManager,
-        bufferViews,
-        accessors,
-        animationSampleRate,
-        useRightHanded,
-        shouldExportAnimation
-    ) {
+    static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, bufferManager, bufferViews, accessors, animationSampleRate, useRightHanded, shouldExportAnimation) {
         let glTFAnimation;
         if (babylonNode instanceof Mesh) {
             const morphTargetManager = babylonNode.morphTargetManager;
@@ -243,14 +185,7 @@ export class _GLTFAnimation {
                         if (shouldExportAnimation && !shouldExportAnimation(animation)) {
                             continue;
                         }
-                        const combinedAnimation = new Animation(
-                            `${animation.name}`,
-                            "influence",
-                            animation.framePerSecond,
-                            animation.dataType,
-                            animation.loopMode,
-                            animation.enableBlending
-                        );
+                        const combinedAnimation = new Animation(`${animation.name}`, "influence", animation.framePerSecond, animation.dataType, animation.loopMode, animation.enableBlending);
                         const combinedAnimationKeys = [];
                         const animationKeys = animation.getKeys();
                         for (let j = 0; j < animationKeys.length; ++j) {
@@ -258,7 +193,8 @@ export class _GLTFAnimation {
                             for (let k = 0; k < morphTargetManager.numTargets; ++k) {
                                 if (k == i) {
                                     combinedAnimationKeys.push(animationKey);
-                                } else {
+                                }
+                                else {
                                     combinedAnimationKeys.push({ frame: animationKey.frame, value: 0 });
                                 }
                             }
@@ -271,22 +207,7 @@ export class _GLTFAnimation {
                                 samplers: [],
                                 channels: [],
                             };
-                            _GLTFAnimation._AddAnimation(
-                                animation.name,
-                                animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation,
-                                babylonNode,
-                                combinedAnimation,
-                                animationInfo.dataAccessorType,
-                                animationInfo.animationChannelTargetPath,
-                                nodeMap,
-                                bufferManager,
-                                bufferViews,
-                                accessors,
-                                animationInfo.useQuaternion,
-                                animationSampleRate,
-                                useRightHanded,
-                                morphTargetManager.numTargets
-                            );
+                            _GLTFAnimation._AddAnimation(animation.name, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, combinedAnimation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, bufferManager, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, useRightHanded, morphTargetManager.numTargets);
                             if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                                 idleGLTFAnimations.push(glTFAnimation);
                             }
@@ -308,17 +229,7 @@ export class _GLTFAnimation {
      * @param accessors
      * @param animationSampleRate
      */
-    static _CreateNodeAndMorphAnimationFromAnimationGroups(
-        babylonScene,
-        glTFAnimations,
-        nodeMap,
-        bufferManager,
-        bufferViews,
-        accessors,
-        animationSampleRate,
-        leftHandedNodes,
-        shouldExportAnimation
-    ) {
+    static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, glTFAnimations, nodeMap, bufferManager, bufferViews, accessors, animationSampleRate, leftHandedNodes, shouldExportAnimation) {
         let glTFAnimation;
         if (babylonScene.animationGroups) {
             const animationGroups = babylonScene.animationGroups;
@@ -346,24 +257,11 @@ export class _GLTFAnimation {
                         if (animationInfo) {
                             const babylonTransformNode = this._IsTransformable(target) ? target : this._IsTransformable(target[0]) ? target[0] : null;
                             if (babylonTransformNode) {
-                                _GLTFAnimation._AddAnimation(
-                                    `${animation.name}`,
-                                    glTFAnimation,
-                                    babylonTransformNode,
-                                    animation,
-                                    animationInfo.dataAccessorType,
-                                    animationInfo.animationChannelTargetPath,
-                                    nodeMap,
-                                    bufferManager,
-                                    bufferViews,
-                                    accessors,
-                                    animationInfo.useQuaternion,
-                                    animationSampleRate,
-                                    convertToRightHanded
-                                );
+                                _GLTFAnimation._AddAnimation(`${animation.name}`, glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, bufferManager, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, convertToRightHanded);
                             }
                         }
-                    } else if (target instanceof MorphTarget || (target.length === 1 && target[0] instanceof MorphTarget)) {
+                    }
+                    else if (target instanceof MorphTarget || (target.length === 1 && target[0] instanceof MorphTarget)) {
                         const animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
                         if (animationInfo) {
                             const babylonMorphTarget = target instanceof MorphTarget ? target : target[0];
@@ -391,7 +289,8 @@ export class _GLTFAnimation {
                                 }
                             }
                         }
-                    } else {
+                    }
+                    else {
                         // this is the place for the KHR_animation_pointer.
                     }
                 }
@@ -419,17 +318,11 @@ export class _GLTFAnimation {
                                 const morphTargetAnimation = animationsByMorphTarget.get(morphTarget);
                                 if (morphTargetAnimation) {
                                     if (!combinedAnimationGroup) {
-                                        combinedAnimationGroup = new Animation(
-                                            `${animationGroup.name}_${mesh.name}_MorphWeightAnimation`,
-                                            "influence",
-                                            morphTargetAnimation.framePerSecond,
-                                            Animation.ANIMATIONTYPE_FLOAT,
-                                            morphTargetAnimation.loopMode,
-                                            morphTargetAnimation.enableBlending
-                                        );
+                                        combinedAnimationGroup = new Animation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, "influence", morphTargetAnimation.framePerSecond, Animation.ANIMATIONTYPE_FLOAT, morphTargetAnimation.loopMode, morphTargetAnimation.enableBlending);
                                     }
                                     animationKeys.push(morphTargetAnimation.getKeys()[i]);
-                                } else {
+                                }
+                                else {
                                     animationKeys.push({
                                         frame: animationGroup.from + (animationGroupFrameDiff / numAnimationKeys) * i,
                                         value: morphTarget.influence,
@@ -443,22 +336,7 @@ export class _GLTFAnimation {
                     combinedAnimationGroup.setKeys(animationKeys);
                     const animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
                     if (animationInfo) {
-                        _GLTFAnimation._AddAnimation(
-                            `${animationGroup.name}_${mesh.name}_MorphWeightAnimation`,
-                            glTFAnimation,
-                            mesh,
-                            combinedAnimationGroup,
-                            animationInfo.dataAccessorType,
-                            animationInfo.animationChannelTargetPath,
-                            nodeMap,
-                            bufferManager,
-                            bufferViews,
-                            accessors,
-                            animationInfo.useQuaternion,
-                            animationSampleRate,
-                            false,
-                            morphTargetManager?.numTargets
-                        );
+                        _GLTFAnimation._AddAnimation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, bufferManager, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, false, morphTargetManager?.numTargets);
                     }
                 });
                 if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
@@ -467,22 +345,7 @@ export class _GLTFAnimation {
             }
         }
     }
-    static _AddAnimation(
-        name,
-        glTFAnimation,
-        babylonTransformNode,
-        animation,
-        dataAccessorType,
-        animationChannelTargetPath,
-        nodeMap,
-        bufferManager,
-        bufferViews,
-        accessors,
-        useQuaternion,
-        animationSampleRate,
-        convertToRightHanded,
-        morphAnimationChannels
-    ) {
+    static _AddAnimation(name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, bufferManager, bufferViews, accessors, useQuaternion, animationSampleRate, convertToRightHanded, morphAnimationChannels) {
         const animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, useQuaternion, animationSampleRate);
         let bufferView;
         let accessor;
@@ -513,17 +376,10 @@ export class _GLTFAnimation {
             // Create buffer view and accessor for key frames.
             const inputData = new Float32Array(animationData.inputs);
             bufferView = bufferManager.createBufferView(inputData);
-            accessor = bufferManager.createAccessor(
-                bufferView,
-                "SCALAR" /* AccessorType.SCALAR */,
-                5126 /* AccessorComponentType.FLOAT */,
-                animationData.inputs.length,
-                undefined,
-                {
-                    min: [animationData.inputsMin],
-                    max: [animationData.inputsMax],
-                }
-            );
+            accessor = bufferManager.createAccessor(bufferView, "SCALAR" /* AccessorType.SCALAR */, 5126 /* AccessorComponentType.FLOAT */, animationData.inputs.length, undefined, {
+                min: [animationData.inputsMin],
+                max: [animationData.inputsMax],
+            });
             accessors.push(accessor);
             keyframeAccessorIndex = accessors.length - 1;
             // Perform conversions on keyed values while also building their buffer.
@@ -546,7 +402,8 @@ export class _GLTFAnimation {
                     case "rotation" /* AnimationChannelTargetPath.ROTATION */:
                         if (output.length === 4) {
                             Quaternion.FromArrayToRef(output, 0, rotationQuaternion);
-                        } else {
+                        }
+                        else {
                             outputToWrite = new Array(4); // Will need 4, not 3, for a quaternion
                             Vector3.FromArrayToRef(output, 0, eulerVec3);
                             Quaternion.FromEulerVectorToRef(eulerVec3, rotationQuaternion);
@@ -622,18 +479,22 @@ export class _GLTFAnimation {
                     if (i === 0) {
                         // set the first frame to itself
                         endFrame = currKeyFrame.frame;
-                    } else {
+                    }
+                    else {
                         continue;
                     }
-                } else {
+                }
+                else {
                     endFrame = nextKeyFrame.frame;
                 }
-            } else {
+            }
+            else {
                 // at the last key frame
                 prevKeyFrame = keyFrames[i - 1];
                 if ((currKeyFrame.value.equals && currKeyFrame.value.equals(prevKeyFrame.value)) || currKeyFrame.value === prevKeyFrame.value) {
                     continue;
-                } else {
+                }
+                else {
                     endFrame = maxFrame;
                 }
             }
@@ -695,12 +556,14 @@ export class _GLTFAnimation {
         if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
             if (useQuaternion) {
                 quaternionCache = value;
-            } else {
+            }
+            else {
                 cacheValue = value;
                 Quaternion.RotationYawPitchRollToRef(cacheValue.y, cacheValue.x, cacheValue.z, quaternionCache);
             }
             outputs.push(quaternionCache.asArray());
-        } else {
+        }
+        else {
             // scaling and position animation
             cacheValue = value;
             outputs.push(cacheValue.asArray());
@@ -733,23 +596,9 @@ export class _GLTFAnimation {
     static _CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion) {
         animation.getKeys().forEach(function (keyFrame) {
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddSplineTangent(
-                _TangentType.INTANGENT,
-                outputs,
-                animationChannelTargetPath,
-                "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */,
-                keyFrame,
-                useQuaternion
-            );
+            _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._AddSplineTangent(_TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, useQuaternion);
         });
     }
     static _GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, useQuaternion) {
@@ -758,14 +607,17 @@ export class _GLTFAnimation {
             if (useQuaternion) {
                 const q = babylonTransformNode.rotationQuaternion;
                 basePositionRotationOrScale = (q ?? Quaternion.Identity()).asArray();
-            } else {
+            }
+            else {
                 const r = babylonTransformNode.rotation;
                 basePositionRotationOrScale = (r ?? Vector3.Zero()).asArray();
             }
-        } else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
+        }
+        else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
             const p = babylonTransformNode.position;
             basePositionRotationOrScale = (p ?? Vector3.Zero()).asArray();
-        } else {
+        }
+        else {
             // scale
             const s = babylonTransformNode.scaling;
             basePositionRotationOrScale = (s ?? Vector3.One()).asArray();
@@ -792,10 +644,12 @@ export class _GLTFAnimation {
                 value = rotationQuaternion.asArray();
             }
             outputs.push(value); // scale  vector.
-        } else if (animationType === Animation.ANIMATIONTYPE_FLOAT) {
+        }
+        else if (animationType === Animation.ANIMATIONTYPE_FLOAT) {
             if (animationChannelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */) {
                 outputs.push([keyFrame.value]);
-            } else {
+            }
+            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, useQuaternion);
                 if (newPositionRotationOrScale) {
@@ -808,9 +662,11 @@ export class _GLTFAnimation {
                     outputs.push(newPositionRotationOrScale.asArray());
                 }
             }
-        } else if (animationType === Animation.ANIMATIONTYPE_QUATERNION) {
+        }
+        else if (animationType === Animation.ANIMATIONTYPE_QUATERNION) {
             outputs.push(keyFrame.value.normalize().asArray());
-        } else {
+        }
+        else {
             Tools.Error("glTFAnimation: Unsupported key frame values for animation!");
         }
     }
@@ -837,23 +693,25 @@ export class _GLTFAnimation {
                         shouldBakeAnimation = true;
                         break;
                     }
-                } else {
+                }
+                else {
                     interpolationType = "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */;
                 }
-            } else {
+            }
+            else {
                 if (interpolationType) {
-                    if (
-                        interpolationType === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */ ||
-                        (key.interpolation && key.interpolation === 1 /* AnimationKeyInterpolation.STEP */ && interpolationType !== "STEP") /* AnimationSamplerInterpolation.STEP */
-                    ) {
+                    if (interpolationType === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */ ||
+                        (key.interpolation && key.interpolation === 1 /* AnimationKeyInterpolation.STEP */ && interpolationType !== "STEP" /* AnimationSamplerInterpolation.STEP */)) {
                         interpolationType = "LINEAR" /* AnimationSamplerInterpolation.LINEAR */;
                         shouldBakeAnimation = true;
                         break;
                     }
-                } else {
+                }
+                else {
                     if (key.interpolation && key.interpolation === 1 /* AnimationKeyInterpolation.STEP */) {
                         interpolationType = "STEP" /* AnimationSamplerInterpolation.STEP */;
-                    } else {
+                    }
+                    else {
                         interpolationType = "LINEAR" /* AnimationSamplerInterpolation.LINEAR */;
                     }
                 }
@@ -882,23 +740,29 @@ export class _GLTFAnimation {
                 if (tangentValue) {
                     if (useQuaternion) {
                         tangent = tangentValue.asArray();
-                    } else {
+                    }
+                    else {
                         const array = tangentValue;
                         tangent = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z).asArray();
                     }
-                } else {
+                }
+                else {
                     tangent = [0, 0, 0, 0];
                 }
-            } else if (animationChannelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */) {
+            }
+            else if (animationChannelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */) {
                 if (tangentValue) {
                     tangent = [tangentValue];
-                } else {
+                }
+                else {
                     tangent = [0];
                 }
-            } else {
+            }
+            else {
                 if (tangentValue) {
                     tangent = tangentValue.asArray();
-                } else {
+                }
+                else {
                     tangent = [0, 0, 0];
                 }
             }