@xviewer.js/core 1.0.0-alpha.34 → 1.0.0-alpha.36

package/dist/main.js

@@ -706,7 +706,6 @@ class Tween {
     union(headTween, tailTween) {
         this._headTween = headTween;
         this._tailTween = tailTween.chain(this);
-        this._headStart = true;
         return this;
     }
     repeat(times = 0) {
@@ -803,11 +802,13 @@ class Tween {
             if (this._onFinishCallback) {
                 this._onFinishCallback(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) {
+                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);
@@ -830,7 +831,7 @@ class Tween {
                 this._onRepeatCallback(this._object);
             }
             if (this._headTween) {
-                this._headStart = true;
+                this._headTweenStartFired = false;
                 this._initialRepeat = this._repeat;
             }
             this._onEveryStartCallbackFired = false;
@@ -973,7 +974,7 @@ class Tween {
         this._propertiesAreSetUp = false;
         this._headTween = null;
         this._tailTween = null;
-        this._headStart = false;
+        this._headTweenStartFired = false;
         this._goToEnd = false;
     }
 }
@@ -1442,13 +1443,13 @@ 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 { 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 = near;
-        from.far = far;
+        from.fov = lerp$1(from.fov, lens.fov, t);
+        from.near = lens.near;
+        from.far = lens.far;
         if (isLensChanged) {
             from.updateProjectionMatrix();
         }
@@ -1466,6 +1467,28 @@ __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);
@@ -1476,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);
@@ -1491,30 +1514,14 @@ class VirtualCamera extends Component {
         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();
     }
 }
 __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,
@@ -2611,16 +2618,40 @@ 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() {
-        const spherical = this._spherical;
-        const lookAt = new three.Vector3().copy(this.lookAt.position).add(this._lookAtOffset);
-        console.log([
-            `springLength: ${spherical.radius.toFixed(2)}`,
-            `rotation: ${spherical.theta.toFixed(2)}, ${spherical.phi.toFixed(2)}`,
-            `lookAt: ${lookAt.x.toFixed(2)},${lookAt.y.toFixed(2)},${lookAt.z.toFixed(2)}`
-        ].join("\n"));
+    get lookAt() {
+        return this._lookAt;
+    }
+    set lookAt(v) {
+        this._lookAt.copy(v);
+        this._targetLookAt.copy(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);
@@ -2642,16 +2673,12 @@ class FreelookVirtualCamera extends VirtualCamera {
     reset() {
         this._button = -1;
         this._touchID = -1;
-        this._setSpherical(this.node.position, this.lookAtPosition);
-    }
-    get lookAtPosition() {
-        return this._lookAtPosition.copy(this.lookAt.position).add(this._lookAtOffset);
+        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;
@@ -2669,59 +2696,55 @@ class FreelookVirtualCamera extends VirtualCamera {
         switch(this._button){
             case 0:
                 this._calculateRotatelDelta(__rotateDelta, this._preLoc0, __loc0);
-                this._calculateSpherical(__rotateDelta);
+                this._calculateTargetSpringArm(__rotateDelta);
                 break;
             case 1:
             case 2:
                 this._calculatePanDelta(__panDelta, this._preLoc0, __loc0);
-                this._calculateLookAtOffset(__panDelta);
+                this._calculateTargetLookAt(__panDelta);
                 break;
         }
         this._preLoc0.copy(__loc0);
     }
     _onMouseWheel(e) {
-        if (this.lookAt) {
-            if (e.deltaY > 0) {
-                this._targetSpherical.radius *= this._calculateDistanceScale(1 / 0.85);
-            } else if (e.deltaY < 0) {
-                this._targetSpherical.radius *= this._calculateDistanceScale(0.85);
-            }
+        if (e.deltaY > 0) {
+            this._targetSpringLength *= this._calculateDistanceScale(1 / 0.85);
+        } else if (e.deltaY < 0) {
+            this._targetSpringLength *= this._calculateDistanceScale(0.85);
         }
     }
     _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, __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) {
-                this._targetSpherical.radius *= this._calculateDistanceScale(this._preLoc0.distanceTo(this._preLoc1) / __loc0.distanceTo(__loc1));
+                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._calculatePanDelta(__panDelta, __preCenter, __center);
-            this._calculateLookAtOffset(__panDelta);
+            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);
+        } 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._calculateSpherical(__rotateDelta);
+                this._calculateTargetSpringArm(__rotateDelta);
                 this._preLoc0.copy(__loc0);
             }
         }
@@ -2758,7 +2781,7 @@ class FreelookVirtualCamera extends VirtualCamera {
         }
         return out;
     }
-    _calculateLookAtOffset(panDelta) {
+    _calculateTargetLookAt(panDelta) {
         const { __xAxis, __yAxis, __posDelta } = FreelookVirtualCamera;
         __xAxis.setFromMatrixColumn(this.node.matrix, 0);
         __yAxis.setFromMatrixColumn(this.node.matrix, 1);
@@ -2766,46 +2789,43 @@ class FreelookVirtualCamera extends VirtualCamera {
             __yAxis.y = 0;
             __yAxis.normalize();
         }
-        __posDelta.copy(this.node.position).sub(this.lookAtPosition);
+        __posDelta.copy(this.node.position).sub(this.lookAt);
         const length = __posDelta.length() * 2 * tan(degToRad(this.fov * 0.5));
-        return this._targetLookAtOffset.sub(__xAxis.multiplyScalar(panDelta.x * length)).add(__yAxis.multiplyScalar(panDelta.y * length));
+        this._targetLookAt.sub(__xAxis.multiplyScalar(panDelta.x * length)).add(__yAxis.multiplyScalar(panDelta.y * length));
     }
-    _calculateSpherical(rotateDelta, radius) {
-        const spherical = this._targetSpherical;
+    _calculateTargetSpringArm(rotateDelta, radius) {
         if (rotateDelta) {
-            spherical.theta -= rotateDelta.x;
-            spherical.phi += rotateDelta.y;
+            this._targetTheta -= rotateDelta.x;
+            this._targetPhi += rotateDelta.y;
         }
         if (radius) {
-            spherical.radius = radius;
+            this._targetSpringLength = radius;
         }
-        spherical.theta = clamp(spherical.theta, this.thetaMin, this.thetaMax);
-        spherical.phi = clamp(spherical.phi, this.phiMin, this.phiMax);
-        spherical.radius = clamp(spherical.radius, this.distanceMin, this.distanceMax);
-        return spherical;
+        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, rotation, lookAt, fov = this.fov, smoothing = this.smoothing) {
+    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._targetSpherical.radius = springLength;
-        if (rotation) {
-            this._targetSpherical.theta = rotation.x;
-            this._targetSpherical.phi = rotation.y;
-        }
-        this._calculateSpherical();
-        if (lookAt) {
-            this._targetLookAtOffset.copy(lookAt).sub(this.lookAt.position);
-        }
+        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._targetSpherical.theta, dt, smoothing);
-        this._spherical.phi = FInterpTo(this._spherical.phi, this._targetSpherical.phi, dt, smoothing);
-        this._spherical.radius = FInterpTo(this._spherical.radius, this._targetSpherical.radius, dt, smoothing);
-        this.node.position.setFromSpherical(this._spherical).add(this.lookAtPosition);
-        this.fov = FInterpTo(this.fov, this._targetFov, dt, smoothing);
-        VInterpTo(this._lookAtOffset, this._targetLookAtOffset, dt, smoothing);
-        this.node.lookAt(this.lookAtPosition);
+        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);
@@ -2814,30 +2834,28 @@ class FreelookVirtualCamera extends VirtualCamera {
         this._preLoc0 = new three.Vector2();
         this._preLoc1 = new three.Vector2();
         this._spherical = new three.Spherical();
-        this._lookAtPosition = new three.Vector3();
-        this._lookAtOffset = new three.Vector3();
+        this._lookAt = new three.Vector3();
         this._tempSmoothing = 0;
+        this._targetTheta = 0;
+        this._targetPhi = 0;
+        this._targetSpringLength = 1;
         this._targetFov = this.fov;
-        this._targetLookAtOffset = new three.Vector3();
-        this._targetSpherical = new three.Spherical();
+        this._targetLookAt = new three.Vector3();
         this.forbidX = false;
         this.forbidY = false;
         this.forbidZ = false;
         this.forbidPanX = false;
         this.forbidPanY = false;
         this.forbitPanOffsetY = false;
+        this.panSpeed = 1;
+        this.rotateSpeed = 1;
         this.smoothing = 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.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();
@@ -2881,9 +2899,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){