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

package/dist/main.js

@@ -1469,7 +1469,7 @@ class VirtualCamera extends Component {
         this.correctPosition = new three.Vector3();
         this.correctRotation = new three.Quaternion();
         this.lookaheadPosition = new three.Vector3();
-        this.trackedObjectOffset = new three.Vector3();
+        this.lookAtOffset = new three.Vector3();
     }
 }
 __decorate([
@@ -2584,11 +2584,10 @@ Perlin._Permutation = [
 
 const { clamp, degToRad } = three.MathUtils;
 const { abs, tan } = Math;
-const VCamFreeLookMode = {
-    FREE: 0,
-    TRANSLATE: 1
-};
 class FreelookVirtualCamera extends VirtualCamera {
+    printInfo() {
+        console.log(this.node.position, this.lookAt.position);
+    }
     onEnable() {
         this.viewer.on(DeviceInput.POINTER_DOWN, this._onPointerDown, this);
         this.viewer.on(DeviceInput.POINTER_UP, this._onPointerUp, this);
@@ -2613,14 +2612,6 @@ class FreelookVirtualCamera extends VirtualCamera {
         this._panDelta.set(0, 0);
         this._distanceDelta = 0;
     }
-    gotoPOI(position, lookAt, duration = 1, easing = Easing.Quadratic.InOut) {
-        this.viewer.killTweensOf(this._tweenPOI);
-        this.viewer.tween(this._tweenPOI).to({
-            position,
-            lookAt,
-            trackedObjectOffset: Vector3_ZERO
-        }, duration).easing(easing).start();
-    }
     _onPointerDown(e) {
         if (SystemInfo.isMobile) return;
         this._button = e.button;
@@ -2632,21 +2623,23 @@ class FreelookVirtualCamera extends VirtualCamera {
     }
     _onPointerMove(e) {
         if (SystemInfo.isMobile) return;
-        FreelookVirtualCamera.__loc0.set(e.pageX, e.pageY);
+        const { __loc0, __moveDelta } = FreelookVirtualCamera;
+        __loc0.set(e.pageX, e.pageY);
         switch(this._button){
             case 0:
-                this._rotateDelta.add(this._calculateRotateDelta(FreelookVirtualCamera.__moveDelta, this._preLoc0, FreelookVirtualCamera.__loc0));
+                this._rotateDelta.add(this._calculateRotateDelta(__moveDelta, this._preLoc0, __loc0));
                 break;
             case 1:
             case 2:
-                this._panDelta.add(this._calculatePanDelta(FreelookVirtualCamera.__moveDelta, this._preLoc0, FreelookVirtualCamera.__loc0));
+                this._panDelta.add(this._calculatePanDelta(__moveDelta, this._preLoc0, __loc0));
                 break;
         }
-        this._preLoc0.copy(FreelookVirtualCamera.__loc0);
+        this._preLoc0.copy(__loc0);
     }
     _onMouseWheel(e) {
+        const { __worldPos } = FreelookVirtualCamera;
         if (this.lookAt) {
-            let dist = FreelookVirtualCamera.__worldPos.copy(this.lookAt.position).add(this.trackedObjectOffset).distanceTo(this.node.position);
+            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);
@@ -2677,11 +2670,13 @@ class FreelookVirtualCamera extends VirtualCamera {
             __loc0.set(touches[rotateTouchID].pageX, touches[rotateTouchID].pageY);
             __loc1.set(touches[rotateTouchID + 1].pageX, touches[rotateTouchID + 1].pageY);
             if (this.lookAt) {
-                let dist = __worldPos.copy(this.lookAt.position).add(this.trackedObjectOffset).distanceTo(this.node.position);
+                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._panDelta.add(this._calculatePanDelta(__moveDelta, __preCenter.copy(this._preLoc0).add(this._preLoc1).multiplyScalar(0.5), __center.copy(__loc0).add(__loc1).multiplyScalar(0.5)));
+            __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._preLoc0.copy(__loc0);
             this._preLoc1.copy(__loc1);
         } else if (touches.length > rotateTouchID) {
@@ -2708,6 +2703,7 @@ class FreelookVirtualCamera extends VirtualCamera {
         if (this.forbidY) {
             out.y = 0;
         }
+        this._tempSmoothing = this.smoothing;
         return out;
     }
     _calculatePanDelta(out, loc0, loc1) {
@@ -2719,51 +2715,52 @@ 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);
+    }
     update(dt) {
         if (!this.lookAt) return;
-        const { __posDelta, __posOffset, __worldPos, __quat, __spherical, __xAxis, __yAxis } = FreelookVirtualCamera;
-        __worldPos.copy(this.lookAt.position).add(this.trackedObjectOffset);
-        switch(this.mode){
-            case VCamFreeLookMode.FREE:
-                if (abs(this._rotateDelta.x) + abs(this._rotateDelta.y) + abs(this._distanceDelta) > 0.001) {
-                    const { __posDelta, __posOffset, __worldPos } = FreelookVirtualCamera;
-                    __quat.setFromUnitVectors(this.node.up, three.Object3D.DEFAULT_UP);
-                    __posDelta.copy(this.node.position).sub(__worldPos);
-                    __posDelta.applyQuaternion(__quat);
-                    __spherical.setFromVector3(__posDelta);
-                    let dampFactor = quarticDamp(1, 0, this.rotateSmoothing, dt);
-                    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));
-                }
-                break;
-            case VCamFreeLookMode.TRANSLATE:
-                if (abs(this._distanceDelta) > 0.001) {
-                    __posDelta.copy(this.node.position).sub(this.lookAt.position);
-                    let dampFactor = quarticDamp(1, 0, this.rotateSmoothing, dt);
-                    let dist0 = __posDelta.length();
-                    this._distanceDelta = clamp(dist0 + this._distanceDelta, this.distanceMin, this.distanceMax) - dist0;
-                    let dist = dist0 + this._distanceDelta * (1 - dampFactor);
-                    this._distanceDelta *= dampFactor;
-                    let pos = __posDelta.normalize().multiplyScalar(dist).add(this.lookAt.position);
-                    __posOffset.copy(pos).sub(this.node.position);
-                    this.trackedObjectOffset.add(__posOffset);
-                    this.node.position.copy(pos);
-                    __worldPos.copy(this.lookAt.position).add(this.trackedObjectOffset);
-                }
-                break;
+        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 (abs(this._panDelta.x) + abs(this._panDelta.y) > 0.001) {
+        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);
@@ -2772,14 +2769,17 @@ class FreelookVirtualCamera extends VirtualCamera {
                 __yAxis.normalize();
             }
             let length = __posDelta.length() * 2 * tan(degToRad(this.fov * 0.5));
-            let dampFactor = quarticDamp(1, 0, this.panSmoothing, dt);
-            let trackedObjectOffset = this.trackedObjectOffset;
-            trackedObjectOffset.sub(__xAxis.multiplyScalar(this._panDelta.x * length * (1 - dampFactor)));
-            trackedObjectOffset.add(__yAxis.multiplyScalar(this._panDelta.y * length * (1 - dampFactor)));
+            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(trackedObjectOffset);
+            __worldPos.copy(this.lookAt.position).add(lookAtOffset);
             this.node.position.copy(__posDelta.add(__worldPos));
         }
+        if (this._lookAtOffsetDelta.manhattanLength() > 0.001) {
+            this.lookAtOffset.add(__offsetDelta.copy(this._lookAtOffsetDelta).multiplyScalar(1 - dampFactor));
+            this._lookAtOffsetDelta.multiplyScalar(dampFactor);
+        }
         this.node.lookAt(__worldPos);
     }
     constructor(...args){
@@ -2791,17 +2791,17 @@ class FreelookVirtualCamera extends VirtualCamera {
         this._preLoc1 = new three.Vector2();
         this._rotateDelta = new three.Vector2();
         this._panDelta = new three.Vector2();
-        this.mode = VCamFreeLookMode.FREE;
+        this._tempSmoothing = 0;
+        this._lookAtOffsetDelta = new three.Vector3();
         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.rotateSmoothing = 0.5;
         this.panSpeed = 2;
-        this.panSmoothing = 0.5;
         this.panScale = new three.Vector3(1, 1, 1);
         this.phiMin = 0.001;
         this.phiMax = Math.PI - 0.001;
@@ -2811,26 +2811,6 @@ class FreelookVirtualCamera extends VirtualCamera {
         this.distanceMax = Infinity;
         this.rotateTouchID = 0;
         this.lookAt = new three.Object3D();
-        this._tweenPOI = {
-            get position () {
-                return this.node.position;
-            },
-            set position (v){
-                this.node.position.copy(v);
-            },
-            get lookAt () {
-                return this.lookAt.position;
-            },
-            set lookAt (v){
-                this.lookAt.position.copy(v);
-            },
-            get trackedObjectOffset () {
-                return this.trackedObjectOffset;
-            },
-            set trackedObjectOffset (v){
-                this.trackedObjectOffset.copy(v);
-            }
-        };
     }
 }
 FreelookVirtualCamera.__loc0 = new three.Vector2();
@@ -2840,16 +2820,11 @@ FreelookVirtualCamera.__preCenter = new three.Vector2();
 FreelookVirtualCamera.__moveDelta = new three.Vector2();
 FreelookVirtualCamera.__worldPos = new three.Vector3();
 FreelookVirtualCamera.__posDelta = new three.Vector3();
-FreelookVirtualCamera.__posOffset = new three.Vector3();
 FreelookVirtualCamera.__xAxis = new three.Vector3();
 FreelookVirtualCamera.__yAxis = new three.Vector3();
 FreelookVirtualCamera.__quat = new three.Quaternion();
 FreelookVirtualCamera.__spherical = new three.Spherical();
-__decorate([
-    property({
-        value: VCamFreeLookMode
-    })
-], FreelookVirtualCamera.prototype, "mode", void 0);
+FreelookVirtualCamera.__offsetDelta = new three.Vector3();
 __decorate([
     property({
         dir: "set"
@@ -2880,6 +2855,9 @@ __decorate([
         dir: "set"
     })
 ], FreelookVirtualCamera.prototype, "forbitPanOffsetY", void 0);
+__decorate([
+    property
+], FreelookVirtualCamera.prototype, "printInfo", null);
 
 class Box extends three.Mesh {
     constructor(...args){