@shapediver/viewer.rendering-engine.animation-engine 3.3.4 → 3.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapediver/viewer.rendering-engine.animation-engine",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "description": "",
   "keywords": [],
   "author": "Michael Oppitz <michael@shapediver.com>",
@@ -10,11 +10,10 @@
     "test": "__tests__"
   },
   "files": [
-    "dist",
-    "src",
     "package.json",
+    "dist/",
     "README.md",
-    "tsconfig.json"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -39,12 +38,12 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@shapediver/viewer.rendering-engine.rendering-engine": "3.3.4",
-    "@shapediver/viewer.shared.node-tree": "3.3.4",
-    "@shapediver/viewer.shared.services": "3.3.4",
-    "@shapediver/viewer.shared.types": "3.3.4",
+    "@shapediver/viewer.rendering-engine.rendering-engine": "3.3.6",
+    "@shapediver/viewer.shared.node-tree": "3.3.6",
+    "@shapediver/viewer.shared.services": "3.3.6",
+    "@shapediver/viewer.shared.types": "3.3.6",
     "@tweenjs/tween.js": "^18.6.4",
     "gl-matrix": "3.3.0"
   },
-  "gitHead": "8193da527b4e3fc4d90181018bd60d6ac70be3e8"
+  "gitHead": "13aea937b128a001e6e93be300674c4a04624c29"
 }

package/src/implementation/AnimationEngine.ts

@@ -1,244 +0,0 @@
-import { mat4, quat, vec3, vec4 } from 'gl-matrix'
-import { ITree, ITreeNode, Tree } from '@shapediver/viewer.shared.node-tree'
-import { AnimationData, GeometryData, IAnimationData } from '@shapediver/viewer.shared.types'
-import { IManager } from '@shapediver/viewer.rendering-engine.rendering-engine';
-import { IAnimationEngine } from '../interfaces/IAnimationEngine';
-
-export class AnimationEngine implements IManager, IAnimationEngine {
-    // #region Properties (3)
-
-    private readonly _tree: ITree = Tree.instance;
-
-    private static _instance: AnimationEngine;
-
-    private _animations: {
-        [key: string]: IAnimationData
-    } = {};
-
-    // #endregion Properties (3)
-
-    // #region Public Static Accessors (1)
-
-    public static get instance() {
-        return this._instance || (this._instance = new this());
-    }
-
-    // #endregion Public Static Accessors (1)
-
-    // #region Public Accessors (1)
-
-    public get animations(): {
-        [key: string]: IAnimationData
-    } 
-    {
-        return this._animations;
-    }
-
-    // #endregion Public Accessors (1)
-
-    // #region Public Methods (3)
-
-    public init(): void { }
-
-    public update(deltaTime: number): boolean {
-        const animations = Object.values(this._animations);
-        let running = false;
-
-        for (let i = 0; i < animations.length; i++) {
-            const animation = animations[i];
-            if (animation.animationTime === -1) {
-                // if we just stopped we need to render one more time
-                running = true;
-                animation.animationTime = 0;
-            }
-            if (!animation.animate) continue;
-            running = true;
-
-            animation.animationTime += deltaTime;
-            if (animation.animationTime / 1000.0 > animation.duration) {
-                if (animation.repeat) {
-                    animation.startAnimation();
-                } else {
-                    animation.stopAnimation();
-                }
-            }
-
-            const animationDuration = animation.duration!;
-            const currentAnimationDeltaTime = (animation.animationTime / 1000.0) % animationDuration;
-
-            for (let j = 0; j < animation.tracks.length; j++) {
-                const track = animation.tracks[j];
-                const id = animation.id + '_' + j;
-                if (currentAnimationDeltaTime < track.times[0] || currentAnimationDeltaTime > track.times[track.times.length - 1]) continue;
-
-                for (let k = 1; k < track.times.length; k++) {
-                    if (currentAnimationDeltaTime < track.times[k] && currentAnimationDeltaTime > track.times[k - 1]) {
-                        const prevAnimation = track.node.transformations.filter(t => t.id === id);
-                        track.node.transformations = track.node.transformations.filter((el) => {
-                            return !prevAnimation.includes(el);
-                        });
-
-                        const factor = (currentAnimationDeltaTime - track.times[k - 1]) / (track.times[k] - track.times[k - 1]);
-
-                        let translationTransformation = track.node.transformations.find(t => t.id === 'gltf_matrix_translation');
-                        if (!translationTransformation) {
-                            translationTransformation = {
-                                id: 'gltf_matrix_translation',
-                                matrix: mat4.create()
-                            }
-                            track.node.transformations.push(translationTransformation)
-                        }
-
-                        let rotationTransformation = track.node.transformations.find(t => t.id === 'gltf_matrix_rotation');
-                        if (!rotationTransformation) {
-                            rotationTransformation = {
-                                id: 'gltf_matrix_rotation',
-                                matrix: mat4.create()
-                            }
-                            track.node.transformations.push(rotationTransformation)
-                        }
-
-                        let scaleTransformation = track.node.transformations.find(t => t.id === 'gltf_matrix_scale');
-                        if (!scaleTransformation) {
-                            scaleTransformation = {
-                                id: 'gltf_matrix_scale',
-                                matrix: mat4.create()
-                            }
-                            track.node.transformations.push(scaleTransformation)
-                        }
-
-                        if (track.path === 'rotation') {
-                            let pivotMatrix: mat4 | undefined, pivotMatrixInverse: mat4 | undefined;
-                            if (track.pivot) {
-                                pivotMatrix = mat4.fromTranslation(mat4.create(), vec3.fromValues(track.pivot[0], track.pivot[1], track.pivot[2]));
-                                pivotMatrixInverse = mat4.fromTranslation(mat4.create(), vec3.fromValues(-track.pivot[0], -track.pivot[1], -track.pivot[2]));
-                            }
-
-                            let quaternion: quat;
-                            if (track.interpolation === 'step') {
-                                quaternion = quat.fromValues(track.values[(k - 1) * 4 + 0], track.values[(k - 1) * 4 + 1], track.values[(k - 1) * 4 + 2], track.values[(k - 1) * 4 + 3]);
-                            } else {
-                                quaternion = quat.slerp(
-                                    vec4.create(),
-                                    vec4.fromValues(track.values[(k - 1) * 4 + 0], track.values[(k - 1) * 4 + 1], track.values[(k - 1) * 4 + 2], track.values[(k - 1) * 4 + 3]),
-                                    vec4.fromValues(track.values[(k) * 4 + 0], track.values[(k) * 4 + 1], track.values[(k) * 4 + 2], track.values[(k) * 4 + 3]),
-                                    factor)
-                            }
-
-                            const rotationMatrix = mat4.fromQuat(mat4.create(), quaternion);
-                            if (pivotMatrix && pivotMatrixInverse) {
-                                rotationTransformation.matrix = mat4.multiply(mat4.create(), mat4.multiply(mat4.create(), pivotMatrix, rotationMatrix), pivotMatrixInverse);
-                            } else {
-                                rotationTransformation.matrix = rotationMatrix;
-                            }
-                        } else if (track.path === 'translation') {
-                            let vector: vec3;
-                            if (track.interpolation === 'step') {
-                                vector = vec3.fromValues(track.values[(k - 1) * 3 + 0], track.values[(k - 1) * 3 + 1], track.values[(k - 1) * 3 + 2]);
-                            } else {
-                                vector = vec3.lerp(
-                                    vec3.create(),
-                                    vec3.fromValues(track.values[(k - 1) * 3 + 0], track.values[(k - 1) * 3 + 1], track.values[(k - 1) * 3 + 2]),
-                                    vec3.fromValues(track.values[(k) * 3 + 0], track.values[(k) * 3 + 1], track.values[(k) * 3 + 2]),
-                                    factor)
-                            }
-                            translationTransformation.matrix = mat4.fromTranslation(mat4.create(), vector);
-                        } else if (track.path === 'scale') {
-                            let pivotMatrix: mat4 | undefined, pivotMatrixInverse: mat4 | undefined;
-                            if (track.pivot) {
-                                pivotMatrix = mat4.fromTranslation(mat4.create(), vec3.fromValues(track.pivot[0], track.pivot[1], track.pivot[2]));
-                                pivotMatrixInverse = mat4.fromTranslation(mat4.create(), vec3.fromValues(-track.pivot[0], -track.pivot[1], -track.pivot[2]));
-                            }
-
-                            let vector: vec3;
-                            if (track.interpolation === 'step') {
-                                vector = vec3.fromValues(track.values[(k - 1) * 3 + 0], track.values[(k - 1) * 3 + 1], track.values[(k - 1) * 3 + 2]);
-                            } else {
-                                vector = vec3.lerp(
-                                    vec3.create(),
-                                    vec3.fromValues(track.values[(k - 1) * 3 + 0], track.values[(k - 1) * 3 + 1], track.values[(k - 1) * 3 + 2]),
-                                    vec3.fromValues(track.values[(k) * 3 + 0], track.values[(k) * 3 + 1], track.values[(k) * 3 + 2]),
-                                    factor)
-                            }
-
-                            const scalingMatrix = mat4.fromScaling(mat4.create(), vector);
-                            if (pivotMatrix && pivotMatrixInverse) {
-                                scaleTransformation.matrix = mat4.multiply(mat4.create(), mat4.multiply(mat4.create(), pivotMatrix, scalingMatrix), pivotMatrixInverse);
-                            } else {
-                                scaleTransformation.matrix = scalingMatrix;
-                            }
-                        } else if (track.path === 'weights') {
-                            let weights: number[] = [];
-                            const weightCount = track.values.length / track.times.length;
-
-                            if (track.interpolation === 'step') {
-                                for (let l = 0; l < weightCount; l++)
-                                    weights.push(track.values[(k - 1) * weightCount + l])
-                            } else {
-                                for (let l = 0; l < weightCount; l++)
-                                    weights.push(track.values[(k - 1) * weightCount + l] * (1.0 - factor) + (factor) * track.values[(k - 1) * weightCount + l]);
-                            }
-
-                            const applyWeights = (node: ITreeNode) => {
-                                for (let l = 0; l < node.data.length; l++)
-                                    if (node.data[l] instanceof GeometryData && (<GeometryData>node.data[l]).morphWeights.length === weightCount)
-                                        (<GeometryData>node.data[l]).morphWeights = weights;
-
-                                for (let l = 0; l < node.children.length; l++)
-                                    applyWeights(node.children[l])
-                            }
-                            applyWeights(track.node);
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-        return running;
-    }
-
-    public updateAnimationData(): void {
-        this._animations = {};
-
-        const animationArray = this.gatherAnimations();
-        const names = animationArray.map(a => a.name);
-
-        for (let i = 0; i < animationArray.length; i++) {
-            const animationName = animationArray[i].name;
-
-            const nameIndices = [];
-            for (let j = 0; j < names.length; j++)
-                if (animationName === names[j])
-                    nameIndices.push(j);
-
-            let animationNameAdjusted = animationName;
-            // name adjustement if the name occurs multiple times
-            if (nameIndices.length > 1) {
-                animationNameAdjusted = animationName + '_' + nameIndices.indexOf(i);
-                // even further name adjustement if the name is even then the same after adjustements (probably will never happen)
-                while (names.includes(animationNameAdjusted))
-                    animationNameAdjusted += "_0";
-            }
-
-            this._animations[animationNameAdjusted] = animationArray[i];
-        }
-    }
-
-    // #endregion Public Methods (3)
-
-    // #region Private Methods (1)
-
-    private gatherAnimations(node: ITreeNode = this._tree.root): AnimationData[] {
-        let out: AnimationData[] = [];
-        for (let i = 0, len = node.data.length; i < len; i++)
-            if (node.data[i] instanceof AnimationData)
-                out.push(<AnimationData>node.data[i])
-
-        for (let i = 0, len = node.children.length; i < len; i++)
-            out = out.concat(this.gatherAnimations(node.children[i]))
-
-        return out;
-    }
-
-    // #endregion Private Methods (1)
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-import { AnimationEngine } from "./implementation/AnimationEngine";
-import { IAnimationEngine } from "./interfaces/IAnimationEngine";
-
-export {
-    IAnimationEngine,
-    AnimationEngine
-}

package/src/interfaces/IAnimationEngine.ts

@@ -1,28 +0,0 @@
-import { IAnimationData } from "@shapediver/viewer.shared.types";
-
-export interface IAnimationEngine {
-    // #region Properties (1)
-
-    animations: {
-        [key: string]: IAnimationData
-    }
-
-    // #endregion Properties (1)
-
-    // #region Public Methods (2)
-
-    /**
-     * Update all animations and progress them according to the specified delta time.
-     * 
-     * returns true, if at least one animation is running
-     * 
-     * @param deltaTime 
-     */
-    update(deltaTime: number): boolean;
-    /**
-     * Traverse the scene tree and gather all the animation data present in it.
-     */
-    updateAnimationData(): void;
-
-    // #endregion Public Methods (2)
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "include": [
-        "./**/*.ts"
-    ],
-    "compilerOptions": {
-        "rootDir": "src",
-        "outDir": "dist"
-    },
-    "exclude": [
-        "__tests__",
-        "node_modules",
-        "dist",
-        "dist-dev",
-        "dist-prod"
-    ]
-}