@xviewer.js/core 1.0.0-alpha.33 → 1.0.0-alpha.35

package/dist/main.js

@@ -143,87 +143,96 @@ function getClassInstance(constructor, args = []) {
 
 /**
  * The Ease class provides a collection of easing functions for use with tween.js.
- */ var Easing = {
-    Linear: {
-        None: function(amount) {
+ */ const Easing = Object.freeze({
+    Linear: Object.freeze({
+        None (amount) {
+            return amount;
+        },
+        In (amount) {
+            return amount;
+        },
+        Out (amount) {
+            return amount;
+        },
+        InOut (amount) {
             return amount;
         }
-    },
-    Quadratic: {
-        In: function(amount) {
+    }),
+    Quadratic: Object.freeze({
+        In (amount) {
             return amount * amount;
         },
-        Out: function(amount) {
+        Out (amount) {
             return amount * (2 - amount);
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if ((amount *= 2) < 1) {
                 return 0.5 * amount * amount;
             }
             return -0.5 * (--amount * (amount - 2) - 1);
         }
-    },
-    Cubic: {
-        In: function(amount) {
+    }),
+    Cubic: Object.freeze({
+        In (amount) {
             return amount * amount * amount;
         },
-        Out: function(amount) {
+        Out (amount) {
             return --amount * amount * amount + 1;
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if ((amount *= 2) < 1) {
                 return 0.5 * amount * amount * amount;
             }
             return 0.5 * ((amount -= 2) * amount * amount + 2);
         }
-    },
-    Quartic: {
-        In: function(amount) {
+    }),
+    Quartic: Object.freeze({
+        In (amount) {
             return amount * amount * amount * amount;
         },
-        Out: function(amount) {
+        Out (amount) {
             return 1 - --amount * amount * amount * amount;
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if ((amount *= 2) < 1) {
                 return 0.5 * amount * amount * amount * amount;
             }
             return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
         }
-    },
-    Quintic: {
-        In: function(amount) {
+    }),
+    Quintic: Object.freeze({
+        In (amount) {
             return amount * amount * amount * amount * amount;
         },
-        Out: function(amount) {
+        Out (amount) {
             return --amount * amount * amount * amount * amount + 1;
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if ((amount *= 2) < 1) {
                 return 0.5 * amount * amount * amount * amount * amount;
             }
             return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
         }
-    },
-    Sinusoidal: {
-        In: function(amount) {
-            return 1 - Math.cos(amount * Math.PI / 2);
+    }),
+    Sinusoidal: Object.freeze({
+        In (amount) {
+            return 1 - Math.sin((1.0 - amount) * Math.PI / 2);
         },
-        Out: function(amount) {
+        Out (amount) {
             return Math.sin(amount * Math.PI / 2);
         },
-        InOut: function(amount) {
-            return 0.5 * (1 - Math.cos(Math.PI * amount));
+        InOut (amount) {
+            return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
         }
-    },
-    Exponential: {
-        In: function(amount) {
+    }),
+    Exponential: Object.freeze({
+        In (amount) {
             return amount === 0 ? 0 : Math.pow(1024, amount - 1);
         },
-        Out: function(amount) {
+        Out (amount) {
             return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if (amount === 0) {
                 return 0;
             }
@@ -235,23 +244,23 @@ function getClassInstance(constructor, args = []) {
             }
             return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
         }
-    },
-    Circular: {
-        In: function(amount) {
+    }),
+    Circular: Object.freeze({
+        In (amount) {
             return 1 - Math.sqrt(1 - amount * amount);
         },
-        Out: function(amount) {
+        Out (amount) {
             return Math.sqrt(1 - --amount * amount);
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if ((amount *= 2) < 1) {
                 return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
             }
             return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
         }
-    },
-    Elastic: {
-        In: function(amount) {
+    }),
+    Elastic: Object.freeze({
+        In (amount) {
             if (amount === 0) {
                 return 0;
             }
@@ -260,7 +269,7 @@ function getClassInstance(constructor, args = []) {
             }
             return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
         },
-        Out: function(amount) {
+        Out (amount) {
             if (amount === 0) {
                 return 0;
             }
@@ -269,7 +278,7 @@ function getClassInstance(constructor, args = []) {
             }
             return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if (amount === 0) {
                 return 0;
             }
@@ -282,29 +291,29 @@ function getClassInstance(constructor, args = []) {
             }
             return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
         }
-    },
-    Back: {
-        In: function(amount) {
-            var s = 1.70158;
-            return amount * amount * ((s + 1) * amount - s);
+    }),
+    Back: Object.freeze({
+        In (amount) {
+            const s = 1.70158;
+            return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
         },
-        Out: function(amount) {
-            var s = 1.70158;
-            return --amount * amount * ((s + 1) * amount + s) + 1;
+        Out (amount) {
+            const s = 1.70158;
+            return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
         },
-        InOut: function(amount) {
-            var s = 1.70158 * 1.525;
+        InOut (amount) {
+            const s = 1.70158 * 1.525;
             if ((amount *= 2) < 1) {
                 return 0.5 * (amount * amount * ((s + 1) * amount - s));
             }
             return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
         }
-    },
-    Bounce: {
-        In: function(amount) {
+    }),
+    Bounce: Object.freeze({
+        In (amount) {
             return 1 - Easing.Bounce.Out(1 - amount);
         },
-        Out: function(amount) {
+        Out (amount) {
             if (amount < 1 / 2.75) {
                 return 7.5625 * amount * amount;
             } else if (amount < 2 / 2.75) {
@@ -315,107 +324,43 @@ function getClassInstance(constructor, args = []) {
                 return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
             }
         },
-        InOut: function(amount) {
+        InOut (amount) {
             if (amount < 0.5) {
                 return Easing.Bounce.In(amount * 2) * 0.5;
             }
             return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
         }
-    }
-};
-var now;
-// Include a performance.now polyfill.
-// In node.js, use process.hrtime.
-// eslint-disable-next-line
-// @ts-ignore
-if (typeof self === 'undefined' && typeof process !== 'undefined' && process.hrtime) {
-    now = function() {
-        // eslint-disable-next-line
-        // @ts-ignore
-        var time = process.hrtime();
-        // Convert [seconds, nanoseconds] to milliseconds.
-        return time[0] * 1000 + time[1] / 1000000;
-    };
-} else if (typeof self !== 'undefined' && self.performance !== undefined && self.performance.now !== undefined) {
-    // This must be bound, because directly assigning this function
-    // leads to an invocation exception in Chrome.
-    now = self.performance.now.bind(self.performance);
-} else if (Date.now !== undefined) {
-    now = Date.now;
-} else {
-    now = function() {
-        return new Date().getTime();
-    };
-}
-function now$1() {
-    return now() * 0.001;
-}
-/**
- * Controlling groups of tweens
- *
- * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
- * In these cases, you may want to create your own smaller groups of tween
- */ var Group = /** @class */ function() {
-    function Group() {
-        this._tweens = {};
-        this._tweensAddedDuringUpdate = {};
-    }
-    Group.prototype.getAll = function() {
-        var _this = this;
-        return Object.keys(this._tweens).map(function(tweenId) {
-            return _this._tweens[tweenId];
-        });
-    };
-    Group.prototype.removeAll = function() {
-        this._tweens = {};
-    };
-    Group.prototype.add = function(tween) {
-        this._tweens[tween.getId()] = tween;
-        this._tweensAddedDuringUpdate[tween.getId()] = tween;
-    };
-    Group.prototype.remove = function(tween) {
-        delete this._tweens[tween.getId()];
-        delete this._tweensAddedDuringUpdate[tween.getId()];
-    };
-    Group.prototype.update = function(time, preserve) {
-        if (time === void 0) {
-            time = now$1();
-        }
-        if (preserve === void 0) {
-            preserve = false;
-        }
-        var tweenIds = Object.keys(this._tweens);
-        if (tweenIds.length === 0) {
-            return false;
-        }
-        // Tweens are updated in "batches". If you add a new tween during an
-        // update, then the new tween will be updated in the next batch.
-        // If you remove a tween during an update, it may or may not be updated.
-        // However, if the removed tween was added during the current batch,
-        // then it will not be updated.
-        while(tweenIds.length > 0){
-            this._tweensAddedDuringUpdate = {};
-            for(var i = 0; i < tweenIds.length; i++){
-                var tween = this._tweens[tweenIds[i]];
-                var autoStart = !preserve;
-                if (tween && tween.update(time, autoStart) === false && !preserve) {
-                    delete this._tweens[tweenIds[i]];
+    }),
+    generatePow (power = 4) {
+        power = power < Number.EPSILON ? Number.EPSILON : power;
+        power = power > 10000 ? 10000 : power;
+        return {
+            In (amount) {
+                return amount ** power;
+            },
+            Out (amount) {
+                return 1 - (1 - amount) ** power;
+            },
+            InOut (amount) {
+                if (amount < 0.5) {
+                    return (amount * 2) ** power / 2;
                 }
+                return (1 - (2 - amount * 2) ** power) / 2 + 0.5;
             }
-            tweenIds = Object.keys(this._tweensAddedDuringUpdate);
-        }
-        return true;
-    };
-    return Group;
-}();
+        };
+    }
+});
+
 /**
  *
- */ var Interpolation = {
+ */ /**
+ *
+ */ const Interpolation = {
     Linear: function(v, k) {
-        var m = v.length - 1;
-        var f = m * k;
-        var i = Math.floor(f);
-        var fn = Interpolation.Utils.Linear;
+        const m = v.length - 1;
+        const f = m * k;
+        const i = Math.floor(f);
+        const fn = Interpolation.Utils.Linear;
         if (k < 0) {
             return fn(v[0], v[1], f);
         }
@@ -425,20 +370,20 @@ function now$1() {
         return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
     },
     Bezier: function(v, k) {
-        var b = 0;
-        var n = v.length - 1;
-        var pw = Math.pow;
-        var bn = Interpolation.Utils.Bernstein;
-        for(var i = 0; i <= n; i++){
+        let b = 0;
+        const n = v.length - 1;
+        const pw = Math.pow;
+        const bn = Interpolation.Utils.Bernstein;
+        for(let i = 0; i <= n; i++){
             b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
         }
         return b;
     },
     CatmullRom: function(v, k) {
-        var m = v.length - 1;
-        var f = m * k;
-        var i = Math.floor(f);
-        var fn = Interpolation.Utils.CatmullRom;
+        const m = v.length - 1;
+        let f = m * k;
+        let i = Math.floor(f);
+        const fn = Interpolation.Utils.CatmullRom;
         if (v[0] === v[m]) {
             if (k < 0) {
                 i = Math.floor(f = m * (1 + k));
@@ -459,19 +404,19 @@ function now$1() {
             return (p1 - p0) * t + p0;
         },
         Bernstein: function(n, i) {
-            var fc = Interpolation.Utils.Factorial;
+            const fc = Interpolation.Utils.Factorial;
             return fc(n) / fc(i) / fc(n - i);
         },
         Factorial: function() {
-            var a = [
+            const a = [
                 1
             ];
             return function(n) {
-                var s = 1;
+                let s = 1;
                 if (a[n]) {
                     return a[n];
                 }
-                for(var i = n; i > 1; i--){
+                for(let i = n; i > 1; i--){
                     s *= i;
                 }
                 a[n] = s;
@@ -479,77 +424,112 @@ function now$1() {
             };
         }(),
         CatmullRom: function(p0, p1, p2, p3, t) {
-            var v0 = (p2 - p0) * 0.5;
-            var v1 = (p3 - p1) * 0.5;
-            var t2 = t * t;
-            var t3 = t * t2;
+            const v0 = (p2 - p0) * 0.5;
+            const v1 = (p3 - p1) * 0.5;
+            const t2 = t * t;
+            const t3 = t * t2;
             return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
         }
     }
 };
+
+const now = ()=>performance.now() * 0.001;
+
 /**
- * Utils
- */ var Sequence = /** @class */ function() {
-    function Sequence() {}
-    Sequence.nextId = function() {
-        return Sequence._nextId++;
-    };
-    Sequence._nextId = 0;
-    return Sequence;
-}();
-var mainGroup = new Group();
-/**
- * Tween.js - Licensed under the MIT license
- * https://github.com/tweenjs/tween.js
- * ----------------------------------------------
+ * Controlling groups of tweens
  *
- * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
- * Thank you all, you're awesome!
- */ var Tween = /** @class */ function() {
-    function Tween(_object, _group) {
-        if (_group === void 0) {
-            _group = mainGroup;
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */ class Group {
+    getAll() {
+        return Object.keys(this._tweens).map((tweenId)=>{
+            return this._tweens[tweenId];
+        });
+    }
+    removeAll() {
+        this._tweens = {};
+    }
+    add(tween) {
+        this._tweens[tween.getId()] = tween;
+        this._tweensAddedDuringUpdate[tween.getId()] = tween;
+    }
+    remove(tween) {
+        delete this._tweens[tween.getId()];
+        delete this._tweensAddedDuringUpdate[tween.getId()];
+    }
+    update(time = now(), preserve = false) {
+        let tweenIds = Object.keys(this._tweens);
+        if (tweenIds.length === 0) {
+            return false;
         }
-        this._object = _object;
-        this._group = _group;
-        this._isPaused = false;
-        this._pauseStart = 0;
-        this._valuesStart = {};
-        this._valuesEnd = {};
-        this._valuesStartRepeat = {};
-        this._duration = 0;
-        this._initialRepeat = 0;
-        this._repeat = 0;
-        this._yoyo = false;
-        this._isPlaying = false;
-        this._reversed = false;
-        this._delayTime = 0;
-        this._startTime = 0;
-        this._easingFunction = Easing.Linear.None;
-        this._interpolationFunction = Interpolation.Linear;
-        this._chainedTweens = [];
-        this._onStartCallbackFired = false;
-        this._id = Sequence.nextId();
-        this._isChainStopped = false;
-        this._goToEnd = false;
-        this._headTween = null;
-        this._tailTween = null;
-        this._headStart = false;
+        // Tweens are updated in "batches". If you add a new tween during an
+        // update, then the new tween will be updated in the next batch.
+        // If you remove a tween during an update, it may or may not be updated.
+        // However, if the removed tween was added during the current batch,
+        // then it will not be updated.
+        while(tweenIds.length > 0){
+            this._tweensAddedDuringUpdate = {};
+            for(let i = 0; i < tweenIds.length; i++){
+                const tween = this._tweens[tweenIds[i]];
+                const autoStart = !preserve;
+                if (tween && tween.update(time, autoStart) === false && !preserve) {
+                    delete this._tweens[tweenIds[i]];
+                }
+            }
+            tweenIds = Object.keys(this._tweensAddedDuringUpdate);
+        }
+        return true;
     }
-    Tween.prototype.getId = function() {
+    constructor(){
+        this._tweens = {};
+        this._tweensAddedDuringUpdate = {};
+    }
+}
+
+const mainGroup = new Group();
+
+/**
+ * Utils
+ */ class Sequence {
+    static nextId() {
+        return Sequence._nextId++;
+    }
+}
+Sequence._nextId = 0;
+
+class Tween {
+    getId() {
         return this._id;
-    };
-    Tween.prototype.isPlaying = function() {
+    }
+    isPlaying() {
         return this._isPlaying;
-    };
-    Tween.prototype.isPaused = function() {
+    }
+    isPaused() {
         return this._isPaused;
-    };
-    Tween.prototype.duration = function(d) {
-        this._duration = d;
+    }
+    getDuration() {
+        return this._duration;
+    }
+    from(properties) {
+        this._valuesStart = Object.create(properties);
         return this;
-    };
-    Tween.prototype.start = function(time) {
+    }
+    to(target, duration = 1) {
+        if (this._isPlaying) throw new Error('Can not call Tween.to() while Tween is already started or paused. Stop the Tween first.');
+        this._valuesEnd = target;
+        this._propertiesAreSetUp = false;
+        this._duration = duration < 0 ? 0 : duration;
+        return this;
+    }
+    duration(duration = 1) {
+        this._duration = duration < 0 ? 0 : duration;
+        return this;
+    }
+    dynamic(dynamic = false) {
+        this._isDynamic = dynamic;
+        return this;
+    }
+    start(time = now(), overrideStartingValues = false) {
         if (this._isPlaying) {
             return this;
         }
@@ -560,7 +540,7 @@ var mainGroup = new Group();
             // If we were reversed (f.e. using the yoyo feature) then we need to
             // flip the tween direction back to forward.
             this._reversed = false;
-            for(var property in this._valuesStartRepeat){
+            for(const property in this._valuesStartRepeat){
                 this._swapEndStartRepeatValues(property);
                 this._valuesStart[property] = this._valuesStartRepeat[property];
             }
@@ -568,18 +548,31 @@ var mainGroup = new Group();
         this._isPlaying = true;
         this._isPaused = false;
         this._onStartCallbackFired = false;
+        this._onEveryStartCallbackFired = false;
         this._isChainStopped = false;
-        this._startTime = time !== undefined ? typeof time === 'string' ? now$1() + parseFloat(time) : time : now$1();
+        this._startTime = time;
         this._startTime += this._delayTime;
-        this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat);
+        if (!this._propertiesAreSetUp || overrideStartingValues) {
+            this._propertiesAreSetUp = true;
+            // If dynamic is not enabled, clone the end values instead of using the passed-in end values.
+            if (!this._isDynamic) {
+                const tmp = {};
+                for(const prop in this._valuesEnd)tmp[prop] = this._valuesEnd[prop];
+                this._valuesEnd = tmp;
+            }
+            this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
+        }
         return this;
-    };
-    Tween.prototype._setupProperties = function(_object, _valuesStart, _valuesEnd, _valuesStartRepeat) {
-        for(var property in _valuesEnd){
-            var startValue = _object[property];
-            var startValueIsArray = Array.isArray(startValue);
-            var propType = startValueIsArray ? 'array' : typeof startValue;
-            var isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]);
+    }
+    startFromCurrentValues(time) {
+        return this.start(time, true);
+    }
+    _setupProperties(_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
+        for(const property in _valuesEnd){
+            const startValue = _object[property];
+            const startValueIsArray = Array.isArray(startValue);
+            const propType = startValueIsArray ? 'array' : typeof startValue;
+            let isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]);
             // If `to()` specifies a property that doesn't exist in the source object,
             // we should not set that property in the object
             if (propType === 'undefined' || propType === 'function') {
@@ -587,39 +580,57 @@ var mainGroup = new Group();
             }
             // Check if an Array was provided as property value
             if (isInterpolationList) {
-                var endValues = _valuesEnd[property];
+                const endValues = _valuesEnd[property];
                 if (endValues.length === 0) {
                     continue;
                 }
-                // handle an array of relative values
-                endValues = endValues.map(this._handleRelativeValue.bind(this, startValue));
-                // Create a local copy of the Array with the start value at the front
-                _valuesEnd[property] = [
+                // Handle an array of relative values.
+                // Creates a local copy of the Array with the start value at the front
+                const temp = [
                     startValue
-                ].concat(endValues);
+                ];
+                for(let i = 0, l = endValues.length; i < l; i += 1){
+                    const value = this._handleRelativeValue(startValue, endValues[i]);
+                    if (isNaN(value)) {
+                        isInterpolationList = false;
+                        console.warn('Found invalid interpolation list. Skipping.');
+                        break;
+                    }
+                    temp.push(value);
+                }
+                if (isInterpolationList) {
+                    // if (_valuesStart[property] === undefined) { // handle end values only the first time. NOT NEEDED? setupProperties is now guarded by _propertiesAreSetUp.
+                    _valuesEnd[property] = temp;
+                // }
+                }
             }
             // handle the deepness of the values
             if ((propType === 'object' || startValueIsArray) && startValue && !isInterpolationList) {
                 _valuesStart[property] = startValueIsArray ? [] : {};
-                // eslint-disable-next-line
-                for(var prop in startValue){
-                    // eslint-disable-next-line
-                    // @ts-ignore FIXME?
-                    _valuesStart[property][prop] = startValue[prop];
+                const nestedObject = startValue;
+                for(const prop in nestedObject){
+                    _valuesStart[property][prop] = nestedObject[prop];
                 }
-                _valuesStartRepeat[property] = startValueIsArray ? [] : {}; // TODO? repeat nested values? And yoyo? And array values?
-                // eslint-disable-next-line
-                // @ts-ignore FIXME?
-                this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property]);
+                // TODO? repeat nested values? And yoyo? And array values?
+                _valuesStartRepeat[property] = startValueIsArray ? [] : {};
+                let endValues = _valuesEnd[property];
+                // If dynamic is not enabled, clone the end values instead of using the passed-in end values.
+                if (!this._isDynamic) {
+                    const tmp = {};
+                    for(const prop in endValues)tmp[prop] = endValues[prop];
+                    _valuesEnd[property] = endValues = tmp;
+                }
+                this._setupProperties(nestedObject, _valuesStart[property], endValues, _valuesStartRepeat[property], overrideStartingValues);
             } else {
-                // Save the starting value, but only once.
-                if (typeof _valuesStart[property] === 'undefined') {
+                // Save the starting value, but only once unless override is requested.
+                if (typeof _valuesStart[property] === 'undefined' || overrideStartingValues) {
                     _valuesStart[property] = startValue;
                 }
                 if (!startValueIsArray) {
                     // eslint-disable-next-line
                     // @ts-ignore FIXME?
-                    _valuesStart[property] *= 1.0; // Ensures we're using numbers, not strings
+                    _valuesStart[property] *= 1.0 // Ensures we're using numbers, not strings
+                    ;
                 }
                 if (isInterpolationList) {
                     // eslint-disable-next-line
@@ -630,8 +641,8 @@ var mainGroup = new Group();
                 }
             }
         }
-    };
-    Tween.prototype.stop = function() {
+    }
+    stop() {
         if (!this._isChainStopped) {
             this._isChainStopped = true;
             this.stopChainedTweens();
@@ -647,16 +658,13 @@ var mainGroup = new Group();
             this._onStopCallback(this._object);
         }
         return this;
-    };
-    Tween.prototype.end = function() {
+    }
+    end() {
         this._goToEnd = true;
         this.update(Infinity);
         return this;
-    };
-    Tween.prototype.pause = function(time) {
-        if (time === void 0) {
-            time = now$1();
-        }
+    }
+    pause(time = now()) {
         if (this._isPaused || !this._isPlaying) {
             return this;
         }
@@ -665,11 +673,8 @@ var mainGroup = new Group();
         // eslint-disable-next-line
         this._group && this._group.remove(this);
         return this;
-    };
-    Tween.prototype.resume = function(time) {
-        if (time === void 0) {
-            time = now$1();
-        }
+    }
+    resume(time = now()) {
         if (!this._isPaused || !this._isPlaying) {
             return this;
         }
@@ -679,124 +684,97 @@ var mainGroup = new Group();
         // eslint-disable-next-line
         this._group && this._group.add(this);
         return this;
-    };
-    Tween.prototype.stopChainedTweens = function() {
-        for(var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
+    }
+    stopChainedTweens() {
+        for(let i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
             this._chainedTweens[i].stop();
         }
-        this._chainedTweens = [];
         return this;
-    };
-    Tween.prototype.group = function(group) {
+    }
+    group(group = mainGroup) {
         this._group = group;
         return this;
-    };
-    Tween.prototype.call = function(callback) {
+    }
+    call(callback) {
         this._onFinishCallback = callback;
         return this;
-    };
-    Tween.prototype.from = function(properties) {
-        this._valuesStart = Object.create(properties);
-        return this;
-    };
-    Tween.prototype.to = function(properties, duration) {
-        // TODO? restore this, then update the 07_dynamic_to example to set fox
-        // tween's to on each update. That way the behavior is opt-in (there's
-        // currently no opt-out).
-        // for (const prop in properties) this._valuesEnd[prop] = properties[prop]
-        this._valuesEnd = Object.create(properties);
-        if (duration !== undefined) {
-            this._duration = duration;
-        }
-        this._chainedTween = this;
-        return this;
-    };
-    Tween.prototype.delay = function(amount) {
+    }
+    delay(amount = 0) {
         this._delayTime = amount;
         return this;
-    };
-    Tween.prototype.union = function(headTween, tailTween) {
+    }
+    union(headTween, tailTween) {
         this._headTween = headTween;
         this._tailTween = tailTween.chain(this);
-        this._headStart = true;
         return this;
-    };
-    Tween.prototype.repeat = function(times) {
+    }
+    repeat(times = 0) {
         this._initialRepeat = times;
         this._repeat = times;
         return this;
-    };
-    Tween.prototype.repeatDelay = function(amount) {
+    }
+    repeatDelay(amount) {
         this._repeatDelayTime = amount;
         return this;
-    };
-    Tween.prototype.yoyo = function(yoyo) {
+    }
+    yoyo(yoyo = false) {
         this._yoyo = yoyo;
         return this;
-    };
-    Tween.prototype.easing = function(easingFunction) {
+    }
+    easing(easingFunction = Easing.Linear.None) {
         this._easingFunction = easingFunction;
         return this;
-    };
-    Tween.prototype.interpolation = function(interpolationFunction) {
+    }
+    interpolation(interpolationFunction = Interpolation.Linear) {
         this._interpolationFunction = interpolationFunction;
         return this;
-    };
-    Tween.prototype.chain = function() {
-        var tweens = [];
-        for(var _i = 0; _i < arguments.length; _i++){
-            tweens[_i] = arguments[_i];
-        }
+    }
+    // eslint-disable-next-line
+    chain(...tweens) {
         this._chainedTweens = tweens;
         return this;
-    };
-    Tween.prototype.unchain = function() {
-        for(var _i = 0; _i < arguments.length; _i++){
-            let index = this._chainedTweens.findIndex((v)=>v == arguments[_i]);
-            if (index > -1) {
-                this._chainedTweens.splice(index, 1);
-            }
-        }
+    }
+    unchain(...tweens) {
+        tweens.forEach((tween)=>{
+            let index = this._chainedTweens.findIndex((v)=>v === tween);
+            if (index > -1) this._chainedTweens.splice(index, 1);
+        });
         return this;
-    };
-    Tween.prototype.onStart = function(callback) {
+    }
+    onStart(callback) {
         this._onStartCallback = callback;
         return this;
-    };
-    Tween.prototype.onUpdate = function(callback) {
+    }
+    onEveryStart(callback) {
+        this._onEveryStartCallback = callback;
+        return this;
+    }
+    onUpdate(callback) {
         this._onUpdateCallback = callback;
         return this;
-    };
-    Tween.prototype.onRepeat = function(callback) {
+    }
+    onRepeat(callback) {
         this._onRepeatCallback = callback;
         return this;
-    };
-    Tween.prototype.onComplete = function(callback) {
+    }
+    onComplete(callback) {
         this._onCompleteCallback = callback;
         return this;
-    };
-    Tween.prototype.onStop = function(callback) {
+    }
+    onStop(callback) {
         this._onStopCallback = callback;
         return this;
-    };
+    }
     /**
-     * @returns true if the tween is still playing after the update, false
-     * otherwise (calling update on a paused tween still returns true because
-     * it is still playing, just paused).
-     */ Tween.prototype.update = function(time, autoStart) {
-        if (time === void 0) {
-            time = now$1();
-        }
-        if (autoStart === void 0) {
-            autoStart = true;
-        }
+	 * @returns true if the tween is still playing after the update, false
+	 * otherwise (calling update on a paused tween still returns true because
+	 * it is still playing, just paused).
+	 */ update(time = now(), autoStart = true) {
         if (this._isPaused) return true;
-        var property;
-        var elapsed;
-        var endTime = this._startTime + this._duration;
+        const endTime = this._startTime + this._duration;
         if (!this._goToEnd && !this._isPlaying) {
             if (time > endTime) return false;
-            if (autoStart) this.start(time);
+            if (autoStart) this.start(time, true);
         }
         this._goToEnd = false;
         if (time < this._startTime) {
@@ -808,85 +786,126 @@ var mainGroup = new Group();
             }
             this._onStartCallbackFired = true;
         }
-        elapsed = (time - this._startTime) / this._duration;
-        elapsed = this._duration === 0 || elapsed > 1 ? 1 : elapsed;
-        var value = this._easingFunction(elapsed);
-        // properties transformations
+        if (this._onEveryStartCallbackFired === false) {
+            if (this._onEveryStartCallback) {
+                this._onEveryStartCallback(this._object);
+            }
+            this._onEveryStartCallbackFired = true;
+        }
+        const elapsedTime = time - this._startTime;
+        var _this__repeatDelayTime;
+        const durationAndDelay = this._duration + ((_this__repeatDelayTime = this._repeatDelayTime) != null ? _this__repeatDelayTime : this._delayTime);
+        const totalTime = this._duration + this._repeat * durationAndDelay;
+        const elapsed = this._calculateElapsedPortion(elapsedTime, durationAndDelay, totalTime);
+        const value = this._easingFunction(elapsed);
+        if (elapsed === 1) {
+            if (this._onFinishCallback) {
+                this._onFinishCallback(this._object);
+            }
+            if (this._headTween) {
+                if (this._headTweenStartFired === false) {
+                    this._headTweenStartFired = true;
+                    this._headTween.start(this._startTime + this._duration);
+                    this._isPlaying = false;
+                    return false;
+                }
+            }
+        }
+        const status = this._calculateCompletionStatus(elapsedTime, durationAndDelay);
+        if (status === 'repeat') {
+            // the current update is happening after the instant the tween repeated
+            this._processRepetition(elapsedTime, durationAndDelay);
+        }
         this._updateProperties(this._object, this._valuesStart, this._valuesEnd, value);
+        if (status === 'about-to-repeat') {
+            // the current update is happening at the exact instant the tween is going to repeat
+            // the values should match the end of the tween, not the beginning,
+            // that's why _processRepetition happens after _updateProperties
+            this._processRepetition(elapsedTime, durationAndDelay);
+        }
         if (this._onUpdateCallback) {
             this._onUpdateCallback(this._object, elapsed);
         }
-        if (elapsed === 1) {
-            if (this._onFinishCallback) {
-                this._onFinishCallback(this._object);
+        if (status === 'repeat' || status === 'about-to-repeat') {
+            if (this._onRepeatCallback) {
+                this._onRepeatCallback(this._object);
             }
-            if (this._headTween && this._headStart) {
-                this._headTween.start(this._startTime + this._duration);
-                this._headStart = false;
-                this._isPlaying = false;
-                return false;
+            if (this._headTween) {
+                this._headTweenStartFired = false;
+                this._initialRepeat = this._repeat;
             }
-            if (this._repeat > 0) {
-                if (isFinite(this._repeat)) {
-                    this._repeat--;
-                }
-                // Reassign starting values, restart by making startTime = now
-                for(property in this._valuesStartRepeat){
-                    if (!this._yoyo && typeof this._valuesEnd[property] === 'string') {
-                        this._valuesStartRepeat[property] = // eslint-disable-next-line
-                        // @ts-ignore FIXME?
-                        this._valuesStartRepeat[property] + parseFloat(this._valuesEnd[property]);
-                    }
-                    if (this._yoyo) {
-                        this._swapEndStartRepeatValues(property);
-                    }
-                    this._valuesStart[property] = this._valuesStartRepeat[property];
-                }
-                if (this._yoyo) {
-                    this._reversed = !this._reversed;
-                }
-                if (this._repeatDelayTime !== undefined) {
-                    this._startTime = time + this._repeatDelayTime;
-                } else {
-                    this._startTime = time + this._delayTime;
-                }
-                if (this._onRepeatCallback) {
-                    this._onRepeatCallback(this._object);
-                }
-                if (this._headTween) {
-                    this._headStart = true;
-                    this._initialRepeat = this._repeat;
-                }
-                return true;
-            } else {
-                if (this._tailTween) {
-                    this._tailTween.unchain(this);
-                }
-                if (this._onCompleteCallback) {
-                    this._onCompleteCallback(this._object);
-                }
-                for(var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
-                    // Make the chained tweens start exactly at the time they should,
-                    // even if the `update()` method was called way past the duration of the tween
-                    this._chainedTweens[i].start(this._startTime + this._duration);
-                }
-                this._isPlaying = false;
-                return false;
+            this._onEveryStartCallbackFired = false;
+        } else if (status === 'completed') {
+            this._isPlaying = false;
+            if (this._tailTween) {
+                this._tailTween.unchain(this);
+            }
+            if (this._onCompleteCallback) {
+                this._onCompleteCallback(this._object);
+            }
+            for(let i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++){
+                // Make the chained tweens start exactly at the time they should,
+                // even if the `update()` method was called way past the duration of the tween
+                this._chainedTweens[i].start(this._startTime + this._duration, false);
             }
         }
-        return true;
-    };
-    Tween.prototype._updateProperties = function(_object, _valuesStart, _valuesEnd, value) {
-        for(var property in _valuesEnd){
+        return status !== 'completed';
+    }
+    _calculateElapsedPortion(elapsedTime, durationAndDelay, totalTime) {
+        if (this._duration === 0 || elapsedTime > totalTime) {
+            return 1;
+        }
+        const timeIntoCurrentRepeat = elapsedTime % durationAndDelay;
+        const portion = Math.min(timeIntoCurrentRepeat / this._duration, 1);
+        if (portion === 0 && elapsedTime !== 0 && elapsedTime % this._duration === 0) {
+            return 1;
+        }
+        return portion;
+    }
+    _calculateCompletionStatus(elapsedTime, durationAndDelay) {
+        if (this._duration !== 0 && elapsedTime < this._duration) {
+            return 'playing';
+        }
+        if (this._repeat <= 0) {
+            return 'completed';
+        }
+        if (elapsedTime === this._duration) {
+            return 'about-to-repeat';
+        }
+        return 'repeat';
+    }
+    _processRepetition(elapsedTime, durationAndDelay) {
+        const completeCount = Math.min(durationAndDelay > 0 ? Math.trunc((elapsedTime - this._duration) / durationAndDelay) + 1 : 1, this._repeat);
+        if (isFinite(this._repeat)) {
+            this._repeat -= completeCount;
+        }
+        // Reassign starting values, restart by making startTime = now
+        for(const property in this._valuesStartRepeat){
+            const valueEnd = this._valuesEnd[property];
+            if (!this._yoyo && typeof valueEnd === 'string') {
+                this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(valueEnd);
+            }
+            if (this._yoyo) {
+                this._swapEndStartRepeatValues(property);
+            }
+            this._valuesStart[property] = this._valuesStartRepeat[property];
+        }
+        if (this._yoyo) {
+            this._reversed = !this._reversed;
+        }
+        this._startTime += durationAndDelay * completeCount;
+    }
+    _updateProperties(_object, _valuesStart, _valuesEnd, value) {
+        for(const property in _valuesEnd){
             // Don't update properties that do not exist in the source object
             if (_valuesStart[property] === undefined) {
                 continue;
             }
-            var start = _valuesStart[property] || 0;
-            var end = _valuesEnd[property];
-            var startIsArray = Array.isArray(_object[property]);
-            var endIsArray = Array.isArray(end);
-            var isInterpolationList = !startIsArray && endIsArray;
+            const start = _valuesStart[property] || 0;
+            let end = _valuesEnd[property];
+            const startIsArray = Array.isArray(_object[property]);
+            const endIsArray = Array.isArray(end);
+            const isInterpolationList = !startIsArray && endIsArray;
             if (isInterpolationList) {
                 _object[property] = this._interpolationFunction(end, value);
             } else if (typeof end === 'object' && end) {
@@ -908,29 +927,57 @@ var mainGroup = new Group();
                 }
             }
         }
-    };
-    Tween.prototype._handleRelativeValue = function(start, end) {
+    }
+    _handleRelativeValue(start, end) {
         if (typeof end !== 'string') {
             return end;
         }
         if (end.charAt(0) === '+' || end.charAt(0) === '-') {
             return start + parseFloat(end);
-        } else {
-            return parseFloat(end);
         }
-    };
-    Tween.prototype._swapEndStartRepeatValues = function(property) {
-        var tmp = this._valuesStartRepeat[property];
-        var endValue = this._valuesEnd[property];
+        return parseFloat(end);
+    }
+    _swapEndStartRepeatValues(property) {
+        const tmp = this._valuesStartRepeat[property];
+        const endValue = this._valuesEnd[property];
         if (typeof endValue === 'string') {
             this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
         } else {
             this._valuesStartRepeat[property] = this._valuesEnd[property];
         }
         this._valuesEnd[property] = tmp;
-    };
-    return Tween;
-}();
+    }
+    constructor(_object, _group = mainGroup){
+        this._object = _object;
+        this._group = _group;
+        this._isPaused = false;
+        this._pauseStart = 0;
+        this._valuesStart = {};
+        this._valuesEnd = {};
+        this._valuesStartRepeat = {};
+        this._duration = 0;
+        this._isDynamic = false;
+        this._initialRepeat = 0;
+        this._repeat = 0;
+        this._yoyo = false;
+        this._isPlaying = false;
+        this._reversed = false;
+        this._delayTime = 0;
+        this._startTime = 0;
+        this._easingFunction = Easing.Linear.None;
+        this._interpolationFunction = Interpolation.Linear;
+        this._chainedTweens = [];
+        this._onStartCallbackFired = false;
+        this._onEveryStartCallbackFired = false;
+        this._id = Sequence.nextId();
+        this._isChainStopped = false;
+        this._propertiesAreSetUp = false;
+        this._headTween = null;
+        this._tailTween = null;
+        this._headTweenStartFired = false;
+        this._goToEnd = false;
+    }
+}
 
 class TweenChain {
     start() {
@@ -946,7 +993,7 @@ class TweenChain {
         return this;
     }
     union() {
-        this._chainedTween = this._tween = new Tween(this._object).union(this._tween, this._chainedTween);
+        this._chainedTween = this._tween = new Tween(this._object, this._group).union(this._tween, this._chainedTween);
         return this;
     }
     call(callback) {
@@ -993,9 +1040,6 @@ class TweenManager {
     update(time) {
         this._group.update(time);
     }
-    tween(target) {
-        return new Tween(target, this._group);
-    }
     timeline(target) {
         return new TweenChain(target, this._group);
     }
@@ -1399,22 +1443,16 @@ class CinestationBrain extends Component {
     }
     _lerpToMainCamera(vcam, t) {
         const from = this.node, to = vcam;
-        const { fov, near, far, finalPosition, finalRotation } = to;
-        const isLensChanged = from.fov != fov || from.near != near || from.far != far;
-        const isTransformChanged = !from.position.equals(finalPosition) || !from.quaternion.equals(finalRotation);
-        const isChanged = isLensChanged || isTransformChanged;
+        const { lens, finalPosition, finalRotation } = to;
+        const isLensChanged = from.fov != lens.fov || from.near != lens.near || from.far != lens.far;
         from.position.lerp(finalPosition, t);
         from.quaternion.slerp(finalRotation, t);
-        from.fov = lerp$1(from.fov, fov, t);
-        from.near = lerp$1(from.near, near, t);
-        from.far = lerp$1(from.far, far, t);
+        from.fov = lerp$1(from.fov, lens.fov, t);
+        from.near = lens.near;
+        from.far = lens.far;
         if (isLensChanged) {
             from.updateProjectionMatrix();
         }
-        if (this._isChanged !== isChanged) {
-            this._isChanged = isChanged;
-            this.onChanged && this.onChanged(isChanged);
-        }
     }
     constructor(...args){
         super(...args);
@@ -1422,15 +1460,35 @@ class CinestationBrain extends Component {
         this._vcamSolo = null;
         this._vcams = [];
         this._lerpTime = 0;
-        this._isChanged = false;
         this.brainBlend = new CinestationBlendDefinition();
-        this.onChanged = null;
     }
 }
 __decorate([
     property
 ], CinestationBrain.prototype, "brainBlend", void 0);
 
+class Lens {
+    constructor(){
+        this.fov = 45;
+        this.near = 0.1;
+        this.far = 1000;
+    }
+}
+__decorate([
+    property({
+        dir: "lens"
+    })
+], Lens.prototype, "fov", void 0);
+__decorate([
+    property({
+        dir: "lens"
+    })
+], Lens.prototype, "near", void 0);
+__decorate([
+    property({
+        dir: "lens"
+    })
+], Lens.prototype, "far", void 0);
 class VirtualCamera extends Component {
     get finalPosition() {
         return this._finalPosition.copy(this.node.position).add(this.correctPosition);
@@ -1441,9 +1499,9 @@ class VirtualCamera extends Component {
     onLoad() {
         this.node.isCamera = true;
         const camera = this.viewer.camera;
-        this.fov = camera.fov;
-        this.near = camera.near;
-        this.far = camera.far;
+        this.lens.fov = camera.fov;
+        this.lens.near = camera.near;
+        this.lens.far = camera.far;
         this.node.position.set(0, 0, 4);
         this.brain = this.viewer.getComponent(camera, CinestationBrain, true);
         this.brain.addCamera(this);
@@ -1451,42 +1509,19 @@ class VirtualCamera extends Component {
     onDestroy() {
         this.brain.removeCamera(this);
     }
-    update(dt) {
-        if (this.lookAt) {
-            this.node.lookAt(this.lookAt.position);
-        }
-    }
     constructor(...args){
         super(...args);
         this._finalPosition = new three.Vector3();
         this._finalRotation = new three.Quaternion();
         this.priority = 10;
-        this.lookAt = null;
-        this.follow = null;
-        this.fov = 45;
-        this.near = 0.1;
-        this.far = 1000;
+        this.lens = new Lens();
         this.correctPosition = new three.Vector3();
         this.correctRotation = new three.Quaternion();
-        this.lookaheadPosition = new three.Vector3();
-        this.lookAtOffset = new three.Vector3();
     }
 }
 __decorate([
-    property({
-        dir: "lens"
-    })
-], VirtualCamera.prototype, "fov", void 0);
-__decorate([
-    property({
-        dir: "lens"
-    })
-], VirtualCamera.prototype, "near", void 0);
-__decorate([
-    property({
-        dir: "lens"
-    })
-], VirtualCamera.prototype, "far", void 0);
+    property
+], VirtualCamera.prototype, "lens", void 0);
 
 const PressState = {
     NONE: 1 << 0,
@@ -2583,10 +2618,39 @@ Perlin._Permutation = [
 ];
 
 const { clamp, degToRad } = three.MathUtils;
-const { abs, tan } = Math;
+const { abs, tan, PI } = Math;
+const PI2 = PI * 2;
+const ESP = 0.001;
 class FreelookVirtualCamera extends VirtualCamera {
-    printInfo() {
-        console.log(this.node.position, this.lookAt.position);
+    get lookAt() {
+        return this._lookAt;
+    }
+    set lookAt(v) {
+        this._lookAt = this._targetLookAt = v;
+    }
+    get springLength() {
+        return this._spherical.radius;
+    }
+    set springLength(v) {
+        this._spherical.radius = this._targetSpringLength = v;
+    }
+    get theta() {
+        return this._spherical.theta;
+    }
+    set theta(v) {
+        this._spherical.theta = this._targetTheta = v;
+    }
+    get phi() {
+        return this._spherical.phi;
+    }
+    set phi(v) {
+        this._spherical.phi = this._targetPhi = v;
+    }
+    get fov() {
+        return this.lens.fov;
+    }
+    set fov(v) {
+        this.lens.fov = this._targetFov = v;
     }
     onEnable() {
         this.viewer.on(DeviceInput.POINTER_DOWN, this._onPointerDown, this);
@@ -2608,9 +2672,13 @@ class FreelookVirtualCamera extends VirtualCamera {
     reset() {
         this._button = -1;
         this._touchID = -1;
-        this._rotateDelta.set(0, 0);
-        this._panDelta.set(0, 0);
-        this._distanceDelta = 0;
+        this._setSpherical(this.node.position, this.lookAt);
+    }
+    _setSpherical(position, lookAt) {
+        const { __posDelta } = FreelookVirtualCamera;
+        __posDelta.copy(position).sub(lookAt);
+        this._spherical.setFromVector3(__posDelta);
+        this._targetSpherical.copy(this._spherical);
     }
     _onPointerDown(e) {
         if (SystemInfo.isMobile) return;
@@ -2623,77 +2691,75 @@ class FreelookVirtualCamera extends VirtualCamera {
     }
     _onPointerMove(e) {
         if (SystemInfo.isMobile) return;
-        const { __loc0, __moveDelta } = FreelookVirtualCamera;
+        const { __loc0, __panDelta, __rotateDelta } = FreelookVirtualCamera;
         __loc0.set(e.pageX, e.pageY);
         switch(this._button){
             case 0:
-                this._rotateDelta.add(this._calculateRotateDelta(__moveDelta, this._preLoc0, __loc0));
+                this._calculateRotatelDelta(__rotateDelta, this._preLoc0, __loc0);
+                this._calculateTargetSpringArm(__rotateDelta);
                 break;
             case 1:
             case 2:
-                this._panDelta.add(this._calculatePanDelta(__moveDelta, this._preLoc0, __loc0));
+                this._calculatePanDelta(__panDelta, this._preLoc0, __loc0);
+                this._calculateTargetLookAt(__panDelta);
                 break;
         }
         this._preLoc0.copy(__loc0);
     }
     _onMouseWheel(e) {
-        const { __worldPos } = FreelookVirtualCamera;
         if (this.lookAt) {
-            let dist = __worldPos.copy(this.lookAt.position).add(this.lookAtOffset).distanceTo(this.node.position);
-            let distNew = dist + this._distanceDelta;
             if (e.deltaY > 0) {
-                distNew *= this._calculateDistanceScale(1 / 0.85);
+                this._targetSpringLength *= this._calculateDistanceScale(1 / 0.85);
             } else if (e.deltaY < 0) {
-                distNew *= this._calculateDistanceScale(0.85);
+                this._targetSpringLength *= this._calculateDistanceScale(0.85);
             }
-            this._distanceDelta = distNew - dist;
         }
     }
     _onTouchStart(e) {
         if (!SystemInfo.isMobile) return;
         let touches = e.touches;
-        let rotateTouchID = this.rotateTouchID;
-        if (touches.length > rotateTouchID + 1) {
-            this._preLoc0.set(touches[rotateTouchID].pageX, touches[rotateTouchID].pageY);
-            this._preLoc1.set(touches[rotateTouchID + 1].pageX, touches[rotateTouchID + 1].pageY);
-        } else if (touches.length > rotateTouchID) {
-            this._touchID = touches[rotateTouchID].identifier;
-            this._preLoc0.set(touches[rotateTouchID].pageX, touches[rotateTouchID].pageY);
+        if (touches.length > 1) {
+            this._preLoc0.set(touches[0].pageX, touches[0].pageY);
+            this._preLoc1.set(touches[1].pageX, touches[1].pageY);
+        } else if (touches.length > 0) {
+            this._touchID = touches[0].identifier;
+            this._preLoc0.set(touches[0].pageX, touches[0].pageY);
         }
     }
     _onTouchMove(e) {
         if (!SystemInfo.isMobile) return;
-        const { __loc0, __loc1, __worldPos, __moveDelta, __preCenter, __center } = FreelookVirtualCamera;
+        const { __loc0, __loc1, __panDelta, __rotateDelta, __preCenter, __center } = FreelookVirtualCamera;
         let touches = e.touches;
-        let rotateTouchID = this.rotateTouchID;
-        if (touches.length > rotateTouchID + 1) {
-            __loc0.set(touches[rotateTouchID].pageX, touches[rotateTouchID].pageY);
-            __loc1.set(touches[rotateTouchID + 1].pageX, touches[rotateTouchID + 1].pageY);
+        if (touches.length > 1) {
+            __loc0.set(touches[0].pageX, touches[0].pageY);
+            __loc1.set(touches[1].pageX, touches[1].pageY);
             if (this.lookAt) {
-                let dist = __worldPos.copy(this.lookAt.position).add(this.lookAtOffset).distanceTo(this.node.position);
-                let distNew = (dist + this._distanceDelta) * this._calculateDistanceScale(this._preLoc0.distanceTo(this._preLoc1) / __loc0.distanceTo(__loc1));
-                this._distanceDelta = distNew - dist;
+                this._targetSpringLength *= this._calculateDistanceScale(this._preLoc0.distanceTo(this._preLoc1) / __loc0.distanceTo(__loc1));
             }
             __preCenter.copy(this._preLoc0).add(this._preLoc1).multiplyScalar(0.5);
             __center.copy(__loc0).add(__loc1).multiplyScalar(0.5);
-            this._panDelta.add(this._calculatePanDelta(__moveDelta, __preCenter, __center));
+            this._calculatePanDelta(__panDelta, __preCenter, __center);
+            this._calculateTargetLookAt(__panDelta);
             this._preLoc0.copy(__loc0);
             this._preLoc1.copy(__loc1);
-        } else if (touches.length > rotateTouchID) {
-            if (this._touchID === touches[rotateTouchID].identifier) {
-                __loc0.set(touches[rotateTouchID].pageX, touches[rotateTouchID].pageY);
-                this._rotateDelta.add(this._calculateRotateDelta(__moveDelta, this._preLoc0, __loc0));
+        } else if (touches.length > 0) {
+            if (this._touchID === touches[0].identifier) {
+                __loc0.set(touches[0].pageX, touches[0].pageY);
+                this._calculateRotatelDelta(__rotateDelta, this._preLoc0, __loc0);
+                this._calculateTargetSpringArm(__rotateDelta);
                 this._preLoc0.copy(__loc0);
             }
         }
     }
     _calculateDistanceScale(scale) {
+        this._tempSmoothing = this.smoothing;
         if (this.forbidZ) {
             scale = 1;
         }
         return scale;
     }
-    _calculateRotateDelta(out, loc0, loc1) {
+    _calculateRotatelDelta(out, loc0, loc1) {
+        this._tempSmoothing = this.smoothing;
         const domElement = this.viewer.canvas;
         out.copy(loc1).sub(loc0).multiplyScalar(this.rotateSpeed * 2 * Math.PI / domElement.height);
         out.y = -out.y;
@@ -2703,10 +2769,10 @@ class FreelookVirtualCamera extends VirtualCamera {
         if (this.forbidY) {
             out.y = 0;
         }
-        this._tempSmoothing = this.smoothing;
         return out;
     }
     _calculatePanDelta(out, loc0, loc1) {
+        this._tempSmoothing = this.smoothing;
         const domElement = this.viewer.canvas;
         out.copy(loc1).sub(loc0).multiplyScalar(this.panSpeed / domElement.height);
         if (this.forbidPanX) {
@@ -2715,116 +2781,97 @@ class FreelookVirtualCamera extends VirtualCamera {
         if (this.forbidPanY) {
             out.y = 0;
         }
-        this._tempSmoothing = this.smoothing;
         return out;
     }
-    gotoPOI(position, lookAt, smoothing = 1) {
-        const { __posDelta, __worldPos, __quat, __spherical } = FreelookVirtualCamera;
-        __quat.setFromUnitVectors(this.node.up, three.Object3D.DEFAULT_UP);
-        __posDelta.copy(position).sub(lookAt);
-        __posDelta.applyQuaternion(__quat);
-        __spherical.setFromVector3(__posDelta);
-        const { theta, phi, radius } = __spherical;
-        __worldPos.copy(this.lookAt.position).add(this.lookAtOffset);
-        __posDelta.copy(this.node.position).sub(__worldPos);
-        __posDelta.applyQuaternion(__quat);
-        __spherical.setFromVector3(__posDelta);
-        const dx = theta - __spherical.theta;
-        const dy = phi - __spherical.phi;
-        const dz = radius - __spherical.radius;
-        this._rotateDelta.x = -dx;
-        this._rotateDelta.y = dy;
-        this._distanceDelta = dz;
-        this._tempSmoothing = smoothing;
-        this._lookAtOffsetDelta.copy(lookAt).sub(this.lookAt.position).sub(this.lookAtOffset);
+    _calculateTargetLookAt(panDelta) {
+        const { __xAxis, __yAxis, __posDelta } = FreelookVirtualCamera;
+        __xAxis.setFromMatrixColumn(this.node.matrix, 0);
+        __yAxis.setFromMatrixColumn(this.node.matrix, 1);
+        if (this.forbitPanOffsetY) {
+            __yAxis.y = 0;
+            __yAxis.normalize();
+        }
+        __posDelta.copy(this.node.position).sub(this.lookAt);
+        const length = __posDelta.length() * 2 * tan(degToRad(this.fov * 0.5));
+        this._targetLookAt.sub(__xAxis.multiplyScalar(panDelta.x * length)).add(__yAxis.multiplyScalar(panDelta.y * length));
     }
-    update(dt) {
-        if (!this.lookAt) return;
-        const dampFactor = exponentialDamp(1, 0, this._tempSmoothing, dt);
-        const { __posDelta, __offsetDelta, __worldPos, __quat, __spherical, __xAxis, __yAxis } = FreelookVirtualCamera;
-        __worldPos.copy(this.lookAt.position).add(this.lookAtOffset);
-        if (this._rotateDelta.manhattanLength() + abs(this._distanceDelta) > 0.001) {
-            __quat.setFromUnitVectors(this.node.up, three.Object3D.DEFAULT_UP);
-            __posDelta.copy(this.node.position).sub(__worldPos);
-            __posDelta.applyQuaternion(__quat);
-            __spherical.setFromVector3(__posDelta);
-            this._rotateDelta.x = __spherical.theta - clamp(__spherical.theta - this._rotateDelta.x, this.thetaMin, this.thetaMax);
-            __spherical.theta = __spherical.theta - this._rotateDelta.x * (1 - dampFactor);
-            this._rotateDelta.y = clamp(__spherical.phi + this._rotateDelta.y, this.phiMin, this.phiMax) - __spherical.phi;
-            __spherical.phi = clamp(__spherical.phi + this._rotateDelta.y * (1 - dampFactor), 0.001, Math.PI - 0.001);
-            this._distanceDelta = clamp(__spherical.radius + this._distanceDelta, this.distanceMin, this.distanceMax) - __spherical.radius;
-            __spherical.radius = __spherical.radius + this._distanceDelta * (1 - dampFactor);
-            this._rotateDelta.multiplyScalar(dampFactor);
-            this._distanceDelta *= dampFactor;
-            __posDelta.setFromSpherical(__spherical);
-            __posDelta.applyQuaternion(__quat.invert());
-            this.node.position.copy(__posDelta.add(__worldPos));
-        }
-        if (this._panDelta.manhattanLength() > 0.001) {
-            __posDelta.copy(this.node.position).sub(__worldPos);
-            __xAxis.setFromMatrixColumn(this.node.matrix, 0);
-            __yAxis.setFromMatrixColumn(this.node.matrix, 1);
-            if (this.forbitPanOffsetY) {
-                __yAxis.y = 0;
-                __yAxis.normalize();
-            }
-            let length = __posDelta.length() * 2 * tan(degToRad(this.fov * 0.5));
-            let lookAtOffset = this.lookAtOffset;
-            lookAtOffset.sub(__xAxis.multiplyScalar(this._panDelta.x * length * (1 - dampFactor)));
-            lookAtOffset.add(__yAxis.multiplyScalar(this._panDelta.y * length * (1 - dampFactor)));
-            this._panDelta.multiplyScalar(dampFactor);
-            __worldPos.copy(this.lookAt.position).add(lookAtOffset);
-            this.node.position.copy(__posDelta.add(__worldPos));
+    _calculateTargetSpringArm(rotateDelta, radius) {
+        if (rotateDelta) {
+            this._targetTheta -= rotateDelta.x;
+            this._targetPhi += rotateDelta.y;
         }
-        if (this._lookAtOffsetDelta.manhattanLength() > 0.001) {
-            this.lookAtOffset.add(__offsetDelta.copy(this._lookAtOffsetDelta).multiplyScalar(1 - dampFactor));
-            this._lookAtOffsetDelta.multiplyScalar(dampFactor);
+        if (radius) {
+            this._targetSpringLength = radius;
         }
-        this.node.lookAt(__worldPos);
+        this._targetTheta = clamp(this._targetTheta, this.thetaMin, this.thetaMax);
+        this._targetPhi = clamp(this._targetPhi, this.phiMin, this.phiMax);
+        this._targetSpringLength = clamp(this._targetSpringLength, this.distanceMin, this.distanceMax);
+    }
+    gotoPOI({ springLength = this._targetSpringLength, theta = this._targetTheta, phi = this._targetPhi, lookAt = this.lookAt, fov = this.lens.fov, smoothing = this.smoothing }) {
+        this._targetFov = fov;
+        this._tempSmoothing = smoothing;
+        this._targetSpringLength = springLength;
+        this._targetPhi = phi;
+        this._targetTheta = theta;
+        this._calculateTargetSpringArm();
+        const theta0 = three.MathUtils.euclideanModulo(this._spherical.theta, PI2);
+        const theta1 = theta0 - PI2;
+        this._spherical.theta = abs(theta0 - this._targetTheta) < abs(theta1 - this._targetTheta) ? theta0 : theta1;
+        this._targetLookAt.copy(lookAt);
+    }
+    update(dt) {
+        const smoothing = this._tempSmoothing;
+        this._spherical.theta = FInterpTo(this._spherical.theta, this._targetTheta, dt, smoothing);
+        this._spherical.phi = FInterpTo(this._spherical.phi, this._targetPhi, dt, smoothing);
+        this._spherical.radius = FInterpTo(this._spherical.radius, this._targetSpringLength, dt, smoothing);
+        this.lens.fov = FInterpTo(this.lens.fov, this._targetFov, dt, smoothing);
+        VInterpTo(this._lookAt, this._targetLookAt, dt, smoothing);
+        this.node.position.setFromSpherical(this._spherical).add(this.lookAt);
+        this.node.lookAt(this._lookAt);
     }
     constructor(...args){
         super(...args);
         this._button = -1;
         this._touchID = -1;
-        this._distanceDelta = 0;
         this._preLoc0 = new three.Vector2();
         this._preLoc1 = new three.Vector2();
-        this._rotateDelta = new three.Vector2();
-        this._panDelta = new three.Vector2();
+        this._spherical = new three.Spherical();
+        this._lookAt = new three.Vector3();
         this._tempSmoothing = 0;
-        this._lookAtOffsetDelta = new three.Vector3();
+        this._targetTheta = 0;
+        this._targetPhi = 0;
+        this._targetSpringLength = 1;
+        this._targetFov = this.fov;
+        this._targetLookAt = new three.Vector3();
+        this._targetSpherical = new three.Spherical();
         this.forbidX = false;
         this.forbidY = false;
         this.forbidZ = false;
         this.forbidPanX = false;
         this.forbidPanY = false;
         this.forbitPanOffsetY = false;
-        this.smoothing = 0.5;
-        this.rotateSpeed = 2;
-        this.panSpeed = 2;
-        this.panScale = new three.Vector3(1, 1, 1);
-        this.phiMin = 0.001;
-        this.phiMax = Math.PI - 0.001;
+        this.panSpeed = 1;
+        this.rotateSpeed = 1;
+        this.smoothing = 5;
+        this.phiMin = ESP;
+        this.phiMax = Math.PI - ESP;
         this.thetaMin = -Infinity;
         this.thetaMax = Infinity;
-        this.distanceMin = 0.001;
+        this.distanceMin = ESP;
         this.distanceMax = Infinity;
-        this.rotateTouchID = 0;
-        this.lookAt = new three.Object3D();
     }
 }
 FreelookVirtualCamera.__loc0 = new three.Vector2();
 FreelookVirtualCamera.__loc1 = new three.Vector2();
 FreelookVirtualCamera.__center = new three.Vector2();
 FreelookVirtualCamera.__preCenter = new three.Vector2();
-FreelookVirtualCamera.__moveDelta = new three.Vector2();
-FreelookVirtualCamera.__worldPos = new three.Vector3();
+FreelookVirtualCamera.__panDelta = new three.Vector2();
+FreelookVirtualCamera.__panTarget = new three.Vector2();
+FreelookVirtualCamera.__rotateDelta = new three.Vector2();
 FreelookVirtualCamera.__posDelta = new three.Vector3();
 FreelookVirtualCamera.__xAxis = new three.Vector3();
 FreelookVirtualCamera.__yAxis = new three.Vector3();
 FreelookVirtualCamera.__quat = new three.Quaternion();
-FreelookVirtualCamera.__spherical = new three.Spherical();
-FreelookVirtualCamera.__offsetDelta = new three.Vector3();
 __decorate([
     property({
         dir: "set"
@@ -2855,9 +2902,83 @@ __decorate([
         dir: "set"
     })
 ], FreelookVirtualCamera.prototype, "forbitPanOffsetY", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "panSpeed", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "rotateSpeed", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "smoothing", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "phiMin", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "phiMax", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "thetaMin", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "thetaMax", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "distanceMin", void 0);
+__decorate([
+    property({
+        dir: "set",
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "distanceMax", void 0);
+__decorate([
+    property({
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "lookAt", null);
+__decorate([
+    property({
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "springLength", null);
+__decorate([
+    property({
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "theta", null);
+__decorate([
+    property({
+        step: 0.01
+    })
+], FreelookVirtualCamera.prototype, "phi", null);
 __decorate([
     property
-], FreelookVirtualCamera.prototype, "printInfo", null);
+], FreelookVirtualCamera.prototype, "fov", null);
 
 class Box extends three.Mesh {
     constructor(...args){
@@ -4571,9 +4692,6 @@ class Viewer extends EventEmitter {
         this.addNode(node, props);
         return node;
     }
-    tween(target) {
-        return this._tweenManager.tween(target);
-    }
     timeline(target) {
         return this._tweenManager.timeline(target);
     }