@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/controls.js

@@ -0,0 +1,763 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as TWEEN from '@tweenjs/tween.js';
+import * as THREE from 'three';
+import { EventDispatcher } from 'three';
+import { RelativePositionUtils } from '../../../core/utils/relative-position.utils';
+/**
+ This file is a modified version of THREE.OrbitControls
+ Contributors:
+ * @author qiao / https://github.com/qiao
+ * @author mrdoob / http://mrdoob.com
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author erich666 / http://erichaines.com
+ */
+let Controls;
+Controls = function (camera, domElement) {
+    this.camera = camera;
+    this.domElement = (domElement !== undefined) ? domElement : document;
+    // Set to false to disable this control
+    this.enabled = true;
+    // Use to handle long touch behaviour
+    this.longTouchDuration = 600;
+    this.longTouchTimer = null;
+    // "target" sets the location of focus, where the control orbits around
+    // and where it pans with respect to.
+    this.target = new THREE.Vector3();
+    // center is old, deprecated; use "target" instead
+    this.center = this.target;
+    // This option actually enables dollying in and out; left as "zoom" for
+    // backwards compatibility
+    this.noZoom = false;
+    this.zoomSpeed = 1.0;
+    // Limits to how far you can dolly in and out
+    this.minDistance = 0;
+    this.maxDistance = 1500; // Infinity;
+    // Set to true to disable this control
+    this.noRotate = false;
+    this.noRotateHorizontal = false;
+    this.noRotateVertical = false;
+    this.exploreRotateSpeed = Math.PI / 12;
+    this.rotateSpeed = Math.PI / 3;
+    this.exploreMode = false;
+    this.birdsEyeMode = false;
+    this.vrMode = false;
+    this.lookAroundMode = false;
+    this.useGyroscope = false;
+    this.rotateBy = Math.PI / 32;
+    this.moveBy = .3;
+    // Set to true to disable this control
+    this.noPan = false;
+    this.keyPanSpeed = 40.0; // pixels moved per arrow key push
+    // Set to true to automatically rotate around the target
+    this.autoRotate = false;
+    this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60
+    // How far you can orbit vertically, upper and lower limits.
+    // Range is 0 to Math.PI radians.
+    this.minPolarAngle = 0; // radians
+    this.maxPolarAngle = Math.PI / 2; // radians
+    // How far you can orbit horizontally, upper and lower limits.
+    // Range is 0 to Math.PI radians.
+    this.minAzimuthAngle = -Infinity; // radians
+    this.maxAzimuthAngle = Infinity; // radians
+    // Set to true to disable use of the keys
+    this.noKeys = false;
+    // The four arrow keys
+    this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };
+    // internals
+    const scope = this;
+    const changeEvent = { type: 'change' };
+    const EPS = 0.000001;
+    const rotateStart = new THREE.Vector2();
+    const rotateEnd = new THREE.Vector2();
+    const rotateDelta = new THREE.Vector2();
+    const panStart = new THREE.Vector2();
+    const panEnd = new THREE.Vector2();
+    const panDelta = new THREE.Vector2();
+    const dollyStart = new THREE.Vector2();
+    const dollyEnd = new THREE.Vector2();
+    const dollyDelta = new THREE.Vector2();
+    let phiDelta = 0;
+    let thetaDelta = 0;
+    let scale = 1;
+    let pan = new THREE.Vector3();
+    // rotation -PI/2 around the x-axis, used to make up for the difference in three.js coordinates and real world
+    // when using gyroscope to rotate the camera
+    // without it the 'down' direction in the real world would be the same direction as 'forward' in three.js scene
+    const worldTransform = new THREE.Quaternion(-Math.sqrt(0.5), 0, 0, Math.sqrt(0.5));
+    const twoPI = 2 * Math.PI;
+    let worldRotationY = 0;
+    const STATE = {
+        NONE: -1,
+        ROTATE: 0,
+        DOLLY: 1,
+        PAN: 2,
+        TOUCH_ROTATE: 3,
+        TOUCH_DOLLY: 4,
+        TOUCH_PAN: 5,
+        EXPLORE: 7,
+        EXPLORE_DRAG: 8,
+        BIRDS_EYE: 9,
+        BIRDS_EYE_DOLLY: 10,
+        BIRDS_EYE_PAN: 11
+    };
+    let state = STATE.NONE;
+    this.controlsActive = function () {
+        return (state === STATE.NONE);
+    };
+    this.setPan = function (vec3) {
+        pan = vec3;
+        scope.dispatchEvent(changeEvent);
+    };
+    this.getPan = function () {
+        return pan;
+    };
+    this.panTo = function (vec3) {
+        const newTarget = new THREE.Vector3(vec3.x, scope.target.y, vec3.z);
+        const delta = scope.target.clone().sub(newTarget);
+        pan.sub(delta);
+        scope.update();
+    };
+    this.rotateLeft = function (angle) {
+        if (angle === undefined) {
+            angle = getAutoRotationAngle();
+        }
+        if (this.noRotateHorizontal) {
+            thetaDelta = 0;
+        }
+        else {
+            thetaDelta -= angle;
+        }
+    };
+    this.rotateUp = function (angle) {
+        if (angle === undefined) {
+            angle = getAutoRotationAngle();
+        }
+        if (this.noRotateVertical) {
+            phiDelta = 0;
+        }
+        else {
+            phiDelta -= angle;
+        }
+    };
+    // pass in distance in world space to move left
+    this.panLeft = function (distance) {
+        const panOffset = new THREE.Vector3();
+        const te = this.camera.matrix.elements;
+        // get X column of matrix
+        panOffset.set(te[0], 0, te[2]);
+        panOffset.normalize();
+        panOffset.multiplyScalar(-distance);
+        pan.add(panOffset);
+    };
+    // pass in distance in world space to move up
+    this.panUp = function (distance) {
+        const panOffset = new THREE.Vector3();
+        const te = this.camera.matrix.elements;
+        // get Y column of matrix
+        panOffset.set(te[4], 0, te[6]);
+        panOffset.normalize();
+        panOffset.multiplyScalar(distance);
+        pan.add(panOffset);
+    };
+    // main entry point; pass in Vector2 of change desired in pixel space,
+    // right and down are positive
+    this.pan = function (delta) {
+        const element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+        if (scope.camera.fov !== undefined) {
+            // perspective
+            const position = scope.camera.position;
+            const offset = position.clone().sub(scope.target);
+            let targetDistance = offset.length();
+            // half of the fov is center to top of screen
+            targetDistance *= Math.tan((scope.camera.fov / 2) * Math.PI / 180.0);
+            // we actually don't use screenWidth, since perspective camera is fixed to screen height
+            scope.panLeft(2 * delta.x * targetDistance / element.clientHeight);
+            scope.panUp(2 * delta.y * targetDistance / element.clientHeight);
+        }
+        else if (scope.camera.top !== undefined) {
+            // orthographic
+            scope.panLeft(delta.x * (scope.camera.right - scope.camera.left) / element.clientWidth);
+            scope.panUp(delta.y * (scope.camera.top - scope.camera.bottom) / element.clientHeight);
+        }
+        else {
+            // camera neither orthographic or perspective - warn user
+            console.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.');
+        }
+        scope.update();
+    };
+    this.setCamera = function (newCamera) {
+        scope.camera = newCamera;
+    };
+    this.panXY = function (x, y) {
+        scope.pan(new THREE.Vector2(x, y));
+    };
+    this.animateCamera = function (type, change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changing = new THREE.Vector2();
+            const tween = new TWEEN.Tween(changing).to(new THREE.Vector2(change, 0), 200);
+            tween.easing(TWEEN.Easing.Quadratic.In);
+            tween.onUpdate(() => {
+                this.updatePositionTarget(this.camera.position, this.target, { [type]: changing.x });
+            });
+            return new Promise(resolve => tween.onComplete(resolve).start());
+        });
+    };
+    this.animateCameraMovement = function (endPosition, endTarget, endDuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isFinite(endPosition.x) || !isFinite(endPosition.y) || !isFinite(endPosition.z)) {
+                return;
+            }
+            const duration = endDuration !== undefined ? endDuration : .66 * camera.position.distanceTo(endPosition);
+            const position = camera.position.clone();
+            const target = this.target.clone();
+            const targetTween = new TWEEN.Tween(target)
+                .to(endTarget, duration)
+                .easing(TWEEN.Easing.Quadratic.InOut)
+                .onUpdate(() => {
+                this.target = target;
+                this.update();
+                this.dispatchEvent(changeEvent);
+            });
+            const positionTween = new TWEEN.Tween(position)
+                .to(endPosition, duration)
+                .easing(TWEEN.Easing.Quadratic.In)
+                .onUpdate(() => {
+                this.camera.position.copy(position);
+                this.update();
+                this.dispatchEvent(changeEvent);
+            });
+            const targetPromise = new Promise(resolve => {
+                targetTween
+                    .onComplete(() => {
+                    this.update();
+                    this.dispatchEvent(changeEvent);
+                    resolve(targetTween);
+                })
+                    .start();
+            });
+            const positionPromise = new Promise(resolve => {
+                positionTween
+                    .onComplete(() => {
+                    this.update();
+                    this.dispatchEvent(changeEvent);
+                    resolve(positionTween);
+                })
+                    .start();
+            });
+            return Promise.all([targetPromise, positionPromise]);
+        });
+    };
+    this.cameraLeft = function () {
+        return this.animateCamera('rotate', +this.rotateBy);
+    };
+    this.cameraRight = function () {
+        return this.animateCamera('rotate', -this.rotateBy);
+    };
+    this.cameraForward = function () {
+        return this.animateCamera('move', -this.moveBy);
+    };
+    this.cameraBackward = function () {
+        return this.animateCamera('move', +this.moveBy);
+    };
+    this.dollyIn = function (dollyScale) {
+        if (dollyScale === undefined) {
+            dollyScale = getZoomScale();
+        }
+        scale /= dollyScale;
+    };
+    this.dollyOut = function (dollyScale) {
+        if (dollyScale === undefined) {
+            dollyScale = getZoomScale();
+        }
+        scale *= dollyScale;
+    };
+    this.update = function () {
+        this.updatePositionTarget(this.camera.position, this.target);
+    };
+    this.animateMoveTo = function (target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const position = scope.target.clone();
+            const distance = target.distanceTo(position);
+            const tween = new TWEEN.Tween(position).to(target, distance);
+            tween.easing(TWEEN.Easing.Quadratic.Out);
+            tween.onUpdate(scope.moveTo.bind(scope, position));
+            return new Promise(resolve => tween.onComplete(resolve).start());
+        });
+    };
+    this.moveTo = function (vec3) {
+        vec3.setY(scope.target.y);
+        const diff = vec3.clone().sub(scope.target);
+        const offset = scope.camera.position.clone().sub(scope.target);
+        scope.target.add(pan).add(diff);
+        scope.camera.position.copy(scope.target).add(offset);
+        this.update();
+    };
+    this.updatePositionTarget = function (position, target, options) {
+        const { rotate: thetaDiff = thetaDelta, move: moveDiff = 0 } = options || {};
+        // added this line to be able to zoom in further
+        // target.y = this.minDistance;
+        const offset = position.clone().sub(target);
+        // angle from z-axis around y-axis
+        let theta = Math.atan2(offset.x, offset.z);
+        // angle from y-axis
+        let phi = Math.atan2(Math.sqrt(offset.x * offset.x + offset.z * offset.z), offset.y);
+        theta += thetaDiff;
+        phi += phiDelta;
+        let min = this.minAzimuthAngle;
+        let max = this.maxAzimuthAngle;
+        if (isFinite(min) && isFinite(max)) {
+            if (min < -Math.PI) {
+                min += twoPI;
+            }
+            else if (min > Math.PI) {
+                min -= twoPI;
+            }
+            if (max < -Math.PI) {
+                max += twoPI;
+            }
+            else if (max > Math.PI) {
+                max -= twoPI;
+            }
+            if (min <= max) {
+                theta = Math.max(min, Math.min(max, theta));
+            }
+            else {
+                theta = theta > (min + max) / 2 ? Math.max(min, theta) : Math.min(max, theta);
+            }
+        }
+        // restrict phi to be between desired limits
+        phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, phi));
+        // restrict phi to be betwee EPS and PI-EPS
+        phi = Math.max(EPS, Math.min(Math.PI - EPS, phi));
+        let radius = offset.length() * (moveDiff ? Math.abs(moveDiff) : 1) * scale;
+        // restrict radius to be between desired limits
+        radius = Math.max(this.minDistance, Math.min(this.maxDistance, radius));
+        this.target.add(pan);
+        // move target to panned location
+        offset.x = radius * Math.sin(phi) * Math.sin(theta);
+        offset.y = moveDiff ? 0 : radius * Math.cos(phi);
+        offset.z = radius * Math.sin(phi) * Math.cos(theta);
+        if (!moveDiff) {
+            position.copy(this.target).add(offset);
+        }
+        else {
+            if (moveDiff < 0) {
+                this.target.sub(offset);
+                position.sub(offset);
+            }
+            else {
+                this.target.add(offset);
+                position.add(offset);
+            }
+        }
+        if (this.exploreMode && this.useGyroscope && !this.lookAroundMode) {
+            const lookVector = new THREE.Vector3(this.target.x, camera.position.y, this.target.z).sub(camera.position);
+            worldRotationY = Math.atan2(lookVector.x, lookVector.z);
+        }
+        else {
+            this.camera.lookAt(this.target);
+        }
+        thetaDelta = 0;
+        phiDelta = 0;
+        scale = 1;
+        pan.set(0, 0, 0);
+        scope.dispatchEvent(changeEvent);
+    };
+    this.setExploreMode = function (on = true) {
+        this.exploreMode = on;
+        state = on ? STATE.EXPLORE : STATE.NONE;
+    };
+    this.setExploreDragMode = function (on = true) {
+        state = on ? STATE.EXPLORE_DRAG : STATE.EXPLORE;
+    };
+    this.setBirdsEyeMode = function (on = true) {
+        this.birdsEyeMode = on;
+        state = on ? STATE.BIRDS_EYE : STATE.NONE;
+    };
+    this.setVrMode = function (on = true) {
+        this.vrMode = on;
+    };
+    function calculateCameraQuaternion(alpha, beta, gamma) {
+        // get device rotation in euler angles from gyroscope
+        // https://developers.google.com/web/fundamentals/native-hardware/device-orientation/
+        const deviceEuler = new THREE.Euler(beta, alpha + worldRotationY, -gamma, 'YXZ');
+        // create result quaternion from euler angles
+        const result = new THREE.Quaternion();
+        result.setFromEuler(deviceEuler);
+        // calculate necessary rotation to make up for different screen orientation
+        // window.orientation is 0 in portrait mode, 90 or -90 in respective landscape modes
+        const minusHalfAngle = -THREE.MathUtils.degToRad(Number(window.orientation)) / 2;
+        const screenTransform = new THREE.Quaternion(0, Math.sin(minusHalfAngle), 0, Math.cos(minusHalfAngle));
+        result.multiply(screenTransform);
+        // rotate result quaternion to make up difference in world coordinates
+        result.multiply(worldTransform);
+        return result;
+    }
+    function getAutoRotationAngle() {
+        return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+    }
+    function getZoomScale() {
+        return Math.pow(0.95, scope.zoomSpeed);
+    }
+    function onMouseDown(event) {
+        if (!isMouseEventAllowed(event)) {
+            return;
+        }
+        event.preventDefault();
+        const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+        if (state === STATE.BIRDS_EYE ||
+            state === STATE.BIRDS_EYE_DOLLY ||
+            state === STATE.BIRDS_EYE_PAN) {
+            state = STATE.BIRDS_EYE_PAN;
+            panStart.set(mousePos.x, mousePos.y);
+            scope.domElement.addEventListener('mousemove', onMouseMove, false);
+            scope.domElement.addEventListener('mouseup', onMouseUp, false);
+            return;
+        }
+        if (event.button === 0) {
+            if (scope.noRotate === true) {
+                return;
+            }
+            if (state !== STATE.EXPLORE && state !== STATE.EXPLORE_DRAG) {
+                state = STATE.ROTATE;
+            }
+            rotateStart.set(mousePos.x, mousePos.y);
+        }
+        else if (event.button === 1) {
+            if (scope.noZoom === true) {
+                return;
+            }
+            state = STATE.DOLLY;
+            dollyStart.set(mousePos.x, mousePos.y);
+        }
+        else if (event.button === 2) {
+            if (scope.noPan === true) {
+                return;
+            }
+            state = STATE.PAN;
+            panStart.set(mousePos.x, mousePos.y);
+        }
+        // Greggman fix: https://github.com/greggman/three.js/commit/fde9f9917d6d8381f06bf22cdff766029d1761be
+        scope.domElement.addEventListener('mousemove', onMouseMove, false);
+        scope.domElement.addEventListener('mouseup', onMouseUp, false);
+    }
+    function setRotationParameters(endPoint, direction, speed) {
+        const element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+        rotateEnd.copy(endPoint);
+        rotateDelta.subVectors(rotateEnd, rotateStart);
+        // rotating across whole screen goes 360 degrees around
+        scope.rotateLeft(2 * Math.PI * direction * rotateDelta.x / element.clientWidth * speed);
+        // rotating up and down along whole screen attempts to go 360, but limited to 180
+        scope.rotateUp(2 * Math.PI * direction * rotateDelta.y / element.clientHeight * speed);
+        rotateStart.copy(rotateEnd);
+    }
+    function isMouseEventAllowed(event) {
+        const isCanvas = event ? (event.target && event.target.nodeName === 'CANVAS') : true;
+        return isCanvas && scope.enabled;
+    }
+    function originateOnCanvas(event) {
+        return event && event.target && event.target === document.body;
+    }
+    function onMouseMove(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isMouseEventAllowed(event)) {
+                return;
+            }
+            event.preventDefault();
+            const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+            if (state === STATE.ROTATE) {
+                if (scope.noRotate === true) {
+                    return;
+                }
+                setRotationParameters(new THREE.Vector2(mousePos.x, mousePos.y), 1, scope.rotateSpeed);
+                scope.update();
+            }
+            else if (state === STATE.EXPLORE) {
+                if (scope.noRotate === true) {
+                    return;
+                }
+                setRotationParameters(new THREE.Vector2(mousePos.x, mousePos.y), -1, scope.exploreRotateSpeed);
+                scope.update();
+            }
+            else if (state === STATE.EXPLORE_DRAG) {
+                scope.update();
+                return;
+            }
+            else if (state === STATE.DOLLY || state === STATE.BIRDS_EYE_DOLLY) {
+                if (scope.noZoom === true) {
+                    return;
+                }
+                dollyEnd.set(mousePos.x, mousePos.y);
+                dollyDelta.subVectors(dollyEnd, dollyStart);
+                if (dollyDelta.y > 0) {
+                    scope.dollyIn();
+                }
+                else {
+                    scope.dollyOut();
+                }
+                dollyStart.copy(dollyEnd);
+                scope.update();
+            }
+            else if (state === STATE.PAN || state === STATE.BIRDS_EYE_PAN) {
+                if (scope.noPan === true) {
+                    return;
+                }
+                panEnd.set(mousePos.x, mousePos.y);
+                panDelta.subVectors(panEnd, panStart);
+                scope.pan(panDelta);
+                panStart.copy(panEnd);
+                scope.update();
+            }
+        });
+    }
+    function onMouseUp(event) {
+        if (!scope.enabled) {
+            return;
+        }
+        // Greggman fix: https://github.com/greggman/three.js/commit/fde9f9917d6d8381f06bf22cdff766029d1761be
+        scope.domElement.removeEventListener('mousemove', onMouseMove, false);
+        scope.domElement.removeEventListener('mouseup', onMouseUp, false);
+        if (state === STATE.EXPLORE) {
+            return;
+        }
+        if (state === STATE.EXPLORE_DRAG) {
+            state = STATE.EXPLORE;
+            return;
+        }
+        if (state === STATE.BIRDS_EYE || state === STATE.BIRDS_EYE_PAN || state === STATE.BIRDS_EYE_DOLLY) {
+            state = STATE.BIRDS_EYE;
+            return;
+        }
+        state = STATE.NONE;
+    }
+    function onMouseWheel(event) {
+        if (!scope.enabled || scope.noZoom === true) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        if (event.deltaY < 0) {
+            scope.dollyOut();
+        }
+        else {
+            scope.dollyIn();
+        }
+        scope.update();
+    }
+    function onKeyDown(event) {
+        if (scope.enabled === false) {
+            return;
+        }
+        if (scope.noKeys === true) {
+            return;
+        }
+        if (scope.noPan === true) {
+            return;
+        }
+        if (!originateOnCanvas(event)) {
+            return;
+        }
+        switch (event.keyCode) {
+            case scope.keys.UP:
+                if (scope.exploreMode) {
+                    scope.cameraForward();
+                }
+                else {
+                    scope.pan(new THREE.Vector2(0, scope.keyPanSpeed));
+                }
+                break;
+            case scope.keys.BOTTOM:
+                if (scope.exploreMode) {
+                    scope.cameraBackward();
+                }
+                else {
+                    scope.pan(new THREE.Vector2(0, -scope.keyPanSpeed));
+                }
+                break;
+            case scope.keys.LEFT:
+                if (scope.exploreMode) {
+                    scope.cameraLeft();
+                }
+                else {
+                    scope.pan(new THREE.Vector2(scope.keyPanSpeed, 0));
+                }
+                break;
+            case scope.keys.RIGHT:
+                if (scope.exploreMode) {
+                    scope.cameraRight();
+                }
+                else {
+                    scope.pan(new THREE.Vector2(-scope.keyPanSpeed, 0));
+                }
+                break;
+        }
+    }
+    function touchstart(event) {
+        if (!isMouseEventAllowed(event)) {
+            return;
+        }
+        if (state === STATE.BIRDS_EYE ||
+            state === STATE.BIRDS_EYE_DOLLY ||
+            state === STATE.BIRDS_EYE_PAN) {
+            if (event.touches.length === 1 || event.touches.length === 3) {
+                state = STATE.BIRDS_EYE_PAN;
+                panStart.set(event.touches[0].pageX, event.touches[0].pageY);
+            }
+            else if (event.touches.length === 2) {
+                state = STATE.BIRDS_EYE_DOLLY;
+                const dx = event.touches[0].pageX - event.touches[1].pageX;
+                const dy = event.touches[0].pageY - event.touches[1].pageY;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                dollyStart.set(0, distance);
+            }
+            return;
+        }
+        switch (event.touches.length) {
+            case 1: // one-fingered touch: rotate
+                if (scope.noRotate === true) {
+                    return;
+                }
+                scope.longTouchTimer = setTimeout(() => {
+                    scope.lookAroundMode = true;
+                }, scope.longTouchDuration);
+                state = STATE.TOUCH_ROTATE;
+                rotateStart.set(event.touches[0].pageX, event.touches[0].pageY);
+                break;
+            case 2: // two-fingered touch: dolly
+                if (scope.noZoom === true) {
+                    return;
+                }
+                state = STATE.TOUCH_DOLLY;
+                const dx = event.touches[0].pageX - event.touches[1].pageX;
+                const dy = event.touches[0].pageY - event.touches[1].pageY;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                dollyStart.set(0, distance);
+                break;
+            case 3: // three-fingered touch: pan
+                if (scope.noPan === true) {
+                    return;
+                }
+                state = STATE.TOUCH_PAN;
+                panStart.set(event.touches[0].pageX, event.touches[0].pageY);
+                break;
+            default:
+                state = STATE.NONE;
+        }
+    }
+    function touchmove(event) {
+        if (!isMouseEventAllowed(event)) {
+            return;
+        }
+        clearTimeout(scope.longTouchTimer);
+        event.preventDefault();
+        event.stopPropagation();
+        const element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+        // disable use of two or three finger touch gestures in explore mode
+        const touchCountToProcess = scope.exploreMode ? 1 :
+            state === STATE.BIRDS_EYE_PAN && event.touches.length === 1 ? 3 :
+                event.touches.length;
+        switch (touchCountToProcess) {
+            case 1: // one-fingered touch: rotate
+                if (scope.noRotate === true) {
+                    return;
+                }
+                if (state !== STATE.TOUCH_ROTATE) {
+                    return;
+                }
+                rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);
+                rotateDelta.subVectors(rotateEnd, rotateStart);
+                const rotationSpeed = scope.exploreMode
+                    ? scope.exploreRotateSpeed
+                    : scope.rotateSpeed;
+                // rotating across whole screen goes 360 degrees around
+                scope.rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * rotationSpeed);
+                // rotating up and down along whole screen attempts to go 360, but limited to 180
+                scope.rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * rotationSpeed);
+                rotateStart.copy(rotateEnd);
+                break;
+            case 2: // two-fingered touch: dolly
+                if (scope.noZoom === true) {
+                    return;
+                }
+                if (state !== STATE.TOUCH_DOLLY && state !== STATE.BIRDS_EYE_DOLLY) {
+                    return;
+                }
+                const dx = event.touches[0].pageX - event.touches[1].pageX;
+                const dy = event.touches[0].pageY - event.touches[1].pageY;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                dollyEnd.set(0, distance);
+                dollyDelta.subVectors(dollyEnd, dollyStart);
+                if (dollyDelta.y > 0) {
+                    scope.dollyOut();
+                }
+                else {
+                    scope.dollyIn();
+                }
+                dollyStart.copy(dollyEnd);
+                break;
+            case 3: // three-fingered touch: pan
+                if (scope.noPan === true) {
+                    return;
+                }
+                if (state !== STATE.TOUCH_PAN && state !== STATE.BIRDS_EYE_PAN) {
+                    return;
+                }
+                panEnd.set(event.touches[0].pageX, event.touches[0].pageY);
+                panDelta.subVectors(panEnd, panStart);
+                scope.pan(panDelta);
+                panStart.copy(panEnd);
+                break;
+            default:
+                state = STATE.NONE;
+        }
+        scope.update();
+    }
+    function touchend(event) {
+        if (!scope.enabled) {
+            return;
+        }
+        clearTimeout(scope.longTouchTimer);
+        scope.lookAroundMode = false;
+        if (state === STATE.BIRDS_EYE || state === STATE.BIRDS_EYE_PAN || state === STATE.BIRDS_EYE_DOLLY) {
+            state = STATE.BIRDS_EYE;
+            return;
+        }
+        state = STATE.NONE;
+    }
+    function onDeviceMove(event) {
+        if (!scope.exploreMode || scope.vrMode || scope.lookAroundMode) {
+            return;
+        }
+        const alpha = THREE.MathUtils.degToRad(event.alpha || 0);
+        const beta = THREE.MathUtils.degToRad(event.beta || 0);
+        const gamma = THREE.MathUtils.degToRad(event.gamma || 0);
+        if (alpha !== 0 && beta !== 0 && gamma !== 0) {
+            scope.useGyroscope = true;
+            const cameraQuaternion = calculateCameraQuaternion(alpha, beta, gamma);
+            camera.quaternion.slerp(cameraQuaternion, 0.5); // smooth using spherical linear interpolation
+            scope.dispatchEvent(changeEvent);
+        }
+    }
+    this.domElement.addEventListener('contextmenu', function (event) {
+        event.preventDefault();
+    }, false);
+    this.domElement.addEventListener('mousedown', onMouseDown, false);
+    this.domElement.addEventListener('wheel', onMouseWheel, false);
+    this.domElement.addEventListener('touchstart', touchstart, false);
+    this.domElement.addEventListener('touchend', touchend, false);
+    this.domElement.addEventListener('touchmove', touchmove, false);
+    window.addEventListener('deviceorientation', onDeviceMove, false);
+    window.addEventListener('keydown', onKeyDown, false);
+};
+Controls.prototype = Object.create(EventDispatcher.prototype);
+export { Controls };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controls.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/controls.ts"],"names":[],"mappings":"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","sourcesContent":["import * as TWEEN from '@tweenjs/tween.js';\r\nimport * as THREE from 'three';\r\nimport {EventDispatcher} from 'three';\r\nimport {RelativePositionUtils} from '../../../core/utils/relative-position.utils';\r\n\r\n/**\r\n This file is a modified version of THREE.OrbitControls\r\n Contributors:\r\n * @author qiao / https://github.com/qiao\r\n * @author mrdoob / http://mrdoob.com\r\n * @author alteredq / http://alteredqualia.com/\r\n * @author WestLangley / http://github.com/WestLangley\r\n * @author erich666 / http://erichaines.com\r\n */\r\nlet Controls: (camera, domElement) => void;\r\nControls = function (camera, domElement) {\r\n\r\n  this.camera = camera;\r\n  this.domElement = (domElement !== undefined) ? domElement : document;\r\n\r\n  // Set to false to disable this control\r\n  this.enabled = true;\r\n\r\n  // Use to handle long touch behaviour\r\n  this.longTouchDuration = 600;\r\n  this.longTouchTimer = null;\r\n\r\n  // \"target\" sets the location of focus, where the control orbits around\r\n  // and where it pans with respect to.\r\n  this.target = new THREE.Vector3();\r\n  // center is old, deprecated; use \"target\" instead\r\n  this.center = this.target;\r\n\r\n  // This option actually enables dollying in and out; left as \"zoom\" for\r\n  // backwards compatibility\r\n  this.noZoom = false;\r\n  this.zoomSpeed = 1.0;\r\n  // Limits to how far you can dolly in and out\r\n  this.minDistance = 0;\r\n  this.maxDistance = 1500; // Infinity;\r\n\r\n  // Set to true to disable this control\r\n  this.noRotate = false;\r\n  this.noRotateHorizontal = false;\r\n  this.noRotateVertical = false;\r\n  this.exploreRotateSpeed = Math.PI / 12;\r\n  this.rotateSpeed = Math.PI / 3;\r\n\r\n  this.exploreMode = false;\r\n  this.birdsEyeMode = false;\r\n  this.vrMode = false;\r\n  this.lookAroundMode = false;\r\n\r\n  this.useGyroscope = false;\r\n  this.rotateBy = Math.PI / 32;\r\n  this.moveBy = .3;\r\n\r\n  // Set to true to disable this control\r\n  this.noPan = false;\r\n  this.keyPanSpeed = 40.0;\t// pixels moved per arrow key push\r\n\r\n  // Set to true to automatically rotate around the target\r\n  this.autoRotate = false;\r\n  this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\r\n\r\n  // How far you can orbit vertically, upper and lower limits.\r\n  // Range is 0 to Math.PI radians.\r\n  this.minPolarAngle = 0; // radians\r\n  this.maxPolarAngle = Math.PI / 2; // radians\r\n\r\n  // How far you can orbit horizontally, upper and lower limits.\r\n  // Range is 0 to Math.PI radians.\r\n  this.minAzimuthAngle = - Infinity; // radians\r\n  this.maxAzimuthAngle = Infinity; // radians\r\n\r\n  // Set to true to disable use of the keys\r\n  this.noKeys = false;\r\n  // The four arrow keys\r\n  this.keys = {LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40};\r\n\r\n  // internals\r\n\r\n  const scope = this;\r\n\r\n  const changeEvent = {type: 'change'};\r\n\r\n  const EPS = 0.000001;\r\n\r\n  const rotateStart = new THREE.Vector2();\r\n  const rotateEnd = new THREE.Vector2();\r\n  const rotateDelta = new THREE.Vector2();\r\n\r\n  const panStart = new THREE.Vector2();\r\n  const panEnd = new THREE.Vector2();\r\n  const panDelta = new THREE.Vector2();\r\n\r\n  const dollyStart = new THREE.Vector2();\r\n  const dollyEnd = new THREE.Vector2();\r\n  const dollyDelta = new THREE.Vector2();\r\n\r\n  let phiDelta = 0;\r\n  let thetaDelta = 0;\r\n  let scale = 1;\r\n  let pan = new THREE.Vector3();\r\n\r\n  // rotation -PI/2 around the x-axis, used to make up for the difference in three.js coordinates and real world\r\n  // when using gyroscope to rotate the camera\r\n  // without it the 'down' direction in the real world would be the same direction as 'forward' in three.js scene\r\n  const worldTransform = new THREE.Quaternion(-Math.sqrt(0.5), 0, 0, Math.sqrt(0.5));\r\n  const twoPI = 2 * Math.PI;\r\n  let worldRotationY = 0;\r\n\r\n  const STATE = {\r\n    NONE: -1,\r\n    ROTATE: 0,\r\n    DOLLY: 1,\r\n    PAN: 2,\r\n    TOUCH_ROTATE: 3,\r\n    TOUCH_DOLLY: 4,\r\n    TOUCH_PAN: 5,\r\n    EXPLORE: 7,\r\n    EXPLORE_DRAG: 8,\r\n    BIRDS_EYE: 9,\r\n    BIRDS_EYE_DOLLY: 10,\r\n    BIRDS_EYE_PAN: 11\r\n  };\r\n\r\n  let state = STATE.NONE;\r\n\r\n  this.controlsActive = function () {\r\n    return (state === STATE.NONE);\r\n  };\r\n\r\n  this.setPan = function (vec3: THREE.Vector3) {\r\n    pan = vec3;\r\n    scope.dispatchEvent(changeEvent);\r\n  };\r\n\r\n  this.getPan = function (): THREE.Vector3 {\r\n    return pan;\r\n  };\r\n\r\n  this.panTo = function (vec3) {\r\n    const newTarget = new THREE.Vector3(vec3.x, scope.target.y, vec3.z);\r\n    const delta = scope.target.clone().sub(newTarget);\r\n    pan.sub(delta);\r\n    scope.update();\r\n  };\r\n\r\n  this.rotateLeft = function (angle) {\r\n    if (angle === undefined) {\r\n      angle = getAutoRotationAngle();\r\n    }\r\n    if (this.noRotateHorizontal) {\r\n      thetaDelta = 0;\r\n    } else {\r\n      thetaDelta -= angle;\r\n    }\r\n  };\r\n\r\n  this.rotateUp = function (angle) {\r\n    if (angle === undefined) {\r\n      angle = getAutoRotationAngle();\r\n    }\r\n    if (this.noRotateVertical) {\r\n      phiDelta = 0;\r\n    } else {\r\n      phiDelta -= angle;\r\n    }\r\n  };\r\n\r\n  // pass in distance in world space to move left\r\n  this.panLeft = function (distance) {\r\n\r\n    const panOffset = new THREE.Vector3();\r\n    const te = this.camera.matrix.elements;\r\n    // get X column of matrix\r\n    panOffset.set(te[0], 0, te[2]);\r\n    panOffset.normalize();\r\n\r\n    panOffset.multiplyScalar(-distance);\r\n\r\n    pan.add(panOffset);\r\n\r\n  };\r\n\r\n  // pass in distance in world space to move up\r\n  this.panUp = function (distance) {\r\n\r\n    const panOffset = new THREE.Vector3();\r\n    const te = this.camera.matrix.elements;\r\n    // get Y column of matrix\r\n    panOffset.set(te[4], 0, te[6]);\r\n    panOffset.normalize();\r\n    panOffset.multiplyScalar(distance);\r\n\r\n    pan.add(panOffset);\r\n  };\r\n\r\n  // main entry point; pass in Vector2 of change desired in pixel space,\r\n  // right and down are positive\r\n  this.pan = function (delta) {\r\n\r\n    const element = scope.domElement === document ? scope.domElement.body : scope.domElement;\r\n\r\n    if (scope.camera.fov !== undefined) {\r\n\r\n      // perspective\r\n      const position = scope.camera.position;\r\n      const offset = position.clone().sub(scope.target);\r\n      let targetDistance = offset.length();\r\n\r\n      // half of the fov is center to top of screen\r\n      targetDistance *= Math.tan((scope.camera.fov / 2) * Math.PI / 180.0);\r\n      // we actually don't use screenWidth, since perspective camera is fixed to screen height\r\n      scope.panLeft(2 * delta.x * targetDistance / element.clientHeight);\r\n      scope.panUp(2 * delta.y * targetDistance / element.clientHeight);\r\n    } else if (scope.camera.top !== undefined) {\r\n\r\n      // orthographic\r\n      scope.panLeft(delta.x * (scope.camera.right - scope.camera.left) / element.clientWidth);\r\n      scope.panUp(delta.y * (scope.camera.top - scope.camera.bottom) / element.clientHeight);\r\n    } else {\r\n\r\n      // camera neither orthographic or perspective - warn user\r\n      console.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.');\r\n    }\r\n\r\n    scope.update();\r\n  };\r\n\r\n  this.setCamera = function (newCamera: THREE.Camera) {\r\n    scope.camera = newCamera;\r\n  };\r\n\r\n  this.panXY = function (x, y) {\r\n    scope.pan(new THREE.Vector2(x, y));\r\n  };\r\n\r\n  this.animateCamera = async function (type: string, change: number): Promise<TWEEN.Tween> {\r\n    const changing = new THREE.Vector2();\r\n    const tween = new TWEEN.Tween(changing).to(new THREE.Vector2(change, 0), 200);\r\n    tween.easing(TWEEN.Easing.Quadratic.In);\r\n    tween.onUpdate(() => {\r\n      this.updatePositionTarget(this.camera.position, this.target, {[type]: changing.x});\r\n    });\r\n    return new Promise(resolve => tween.onComplete(resolve).start());\r\n  };\r\n\r\n  this.animateCameraMovement = async function (endPosition: THREE.Vector3, endTarget: THREE.Vector3, endDuration?: number): Promise<TWEEN.Tween[]> {\r\n    if (!isFinite(endPosition.x) || !isFinite(endPosition.y) || !isFinite(endPosition.z)) {\r\n      return;\r\n    }\r\n\r\n    const duration = endDuration !== undefined ? endDuration : .66 * camera.position.distanceTo(endPosition);\r\n    const position = camera.position.clone();\r\n    const target = this.target.clone();\r\n    const targetTween = new TWEEN.Tween(target)\r\n      .to(endTarget, duration)\r\n      .easing(TWEEN.Easing.Quadratic.InOut)\r\n      .onUpdate(() => {\r\n        this.target = target;\r\n        this.update();\r\n        this.dispatchEvent(changeEvent);\r\n      });\r\n    const positionTween = new TWEEN.Tween(position)\r\n      .to(endPosition, duration)\r\n      .easing(TWEEN.Easing.Quadratic.In)\r\n      .onUpdate(() => {\r\n        this.camera.position.copy(position);\r\n        this.update();\r\n        this.dispatchEvent(changeEvent);\r\n      });\r\n    const targetPromise = new Promise<TWEEN.Tween>(resolve => {\r\n      targetTween\r\n        .onComplete(() => {\r\n          this.update();\r\n          this.dispatchEvent(changeEvent);\r\n          resolve(targetTween);\r\n        })\r\n        .start();\r\n    });\r\n    const positionPromise = new Promise<TWEEN.Tween>(resolve => {\r\n      positionTween\r\n        .onComplete(() => {\r\n          this.update();\r\n          this.dispatchEvent(changeEvent);\r\n          resolve(positionTween);\r\n        })\r\n        .start();\r\n    });\r\n    return Promise.all([targetPromise, positionPromise]);\r\n  };\r\n\r\n  this.cameraLeft = function (): Promise<TWEEN.Tween> {\r\n    return this.animateCamera('rotate', +this.rotateBy);\r\n  };\r\n\r\n  this.cameraRight = function (): Promise<TWEEN.Tween> {\r\n    return this.animateCamera('rotate', -this.rotateBy);\r\n  };\r\n\r\n  this.cameraForward = function (): Promise<TWEEN.Tween> {\r\n    return this.animateCamera('move', -this.moveBy);\r\n  };\r\n\r\n  this.cameraBackward = function (): Promise<TWEEN.Tween> {\r\n    return this.animateCamera('move', +this.moveBy);\r\n  };\r\n\r\n  this.dollyIn = function (dollyScale) {\r\n    if (dollyScale === undefined) {\r\n      dollyScale = getZoomScale();\r\n    }\r\n\r\n    scale /= dollyScale;\r\n  };\r\n\r\n  this.dollyOut = function (dollyScale) {\r\n    if (dollyScale === undefined) {\r\n      dollyScale = getZoomScale();\r\n    }\r\n\r\n    scale *= dollyScale;\r\n  };\r\n\r\n  this.update = function () {\r\n    this.updatePositionTarget(this.camera.position, this.target);\r\n  };\r\n\r\n  this.animateMoveTo = async function (target: THREE.Vector3): Promise<TWEEN.Tween> {\r\n    const position = scope.target.clone();\r\n    const distance = target.distanceTo(position);\r\n    const tween = new TWEEN.Tween(position).to(target, distance);\r\n    tween.easing(TWEEN.Easing.Quadratic.Out);\r\n    tween.onUpdate(scope.moveTo.bind(scope, position));\r\n    return new Promise(resolve => tween.onComplete(resolve).start());\r\n  };\r\n\r\n  this.moveTo = function (vec3) {\r\n    vec3.setY(scope.target.y);\r\n    const diff = vec3.clone().sub(scope.target);\r\n    const offset = scope.camera.position.clone().sub(scope.target);\r\n    scope.target.add(pan).add(diff);\r\n    scope.camera.position.copy(scope.target).add(offset);\r\n    this.update();\r\n  };\r\n\r\n  this.updatePositionTarget = function (position, target, options) {\r\n    const {\r\n      rotate: thetaDiff = thetaDelta,\r\n      move: moveDiff = 0\r\n    } = options || {};\r\n\r\n    // added this line to be able to zoom in further\r\n    // target.y = this.minDistance;\r\n\r\n    const offset = position.clone().sub(target);\r\n\r\n    // angle from z-axis around y-axis\r\n    let theta = Math.atan2(offset.x, offset.z);\r\n\r\n    // angle from y-axis\r\n    let phi = Math.atan2(Math.sqrt(offset.x * offset.x + offset.z * offset.z), offset.y);\r\n\r\n\r\n    theta += thetaDiff;\r\n    phi += phiDelta;\r\n\r\n    let min = this.minAzimuthAngle;\r\n    let max = this.maxAzimuthAngle;\r\n\r\n    if ( isFinite( min ) && isFinite( max ) ) {\r\n      if ( min < - Math.PI ) { min += twoPI; } else if ( min > Math.PI ) { min -= twoPI; }\r\n      if ( max < - Math.PI ) { max += twoPI; } else if ( max > Math.PI ) { max -= twoPI; }\r\n      if ( min <= max ) {\r\n        theta = Math.max( min, Math.min( max, theta ) );\r\n      } else {\r\n        theta = theta > ( min + max ) / 2 ? Math.max( min, theta ) : Math.min( max, theta );\r\n      }\r\n    }\r\n\r\n    // restrict phi to be between desired limits\r\n    phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, phi));\r\n\r\n    // restrict phi to be betwee EPS and PI-EPS\r\n    phi = Math.max(EPS, Math.min(Math.PI - EPS, phi));\r\n\r\n    let radius = offset.length() * (moveDiff ? Math.abs(moveDiff) : 1) * scale;\r\n\r\n    // restrict radius to be between desired limits\r\n    radius = Math.max(this.minDistance, Math.min(this.maxDistance, radius));\r\n    this.target.add(pan);\r\n\r\n    // move target to panned location\r\n\r\n    offset.x = radius * Math.sin(phi) * Math.sin(theta);\r\n    offset.y = moveDiff ? 0 : radius * Math.cos(phi);\r\n    offset.z = radius * Math.sin(phi) * Math.cos(theta);\r\n\r\n    if (!moveDiff) {\r\n      position.copy(this.target).add(offset);\r\n    } else {\r\n      if (moveDiff < 0) {\r\n        this.target.sub(offset);\r\n        position.sub(offset);\r\n      } else {\r\n        this.target.add(offset);\r\n        position.add(offset);\r\n      }\r\n    }\r\n    if (this.exploreMode && this.useGyroscope && !this.lookAroundMode) {\r\n      const lookVector = new THREE.Vector3(this.target.x, camera.position.y, this.target.z).sub(camera.position);\r\n      worldRotationY = Math.atan2(lookVector.x, lookVector.z);\r\n    } else {\r\n      this.camera.lookAt(this.target);\r\n    }\r\n\r\n    thetaDelta = 0;\r\n    phiDelta = 0;\r\n    scale = 1;\r\n    pan.set(0, 0, 0);\r\n    scope.dispatchEvent(changeEvent);\r\n  };\r\n\r\n  this.setExploreMode = function (on = true) {\r\n    this.exploreMode = on;\r\n    state = on ? STATE.EXPLORE : STATE.NONE;\r\n  };\r\n\r\n  this.setExploreDragMode = function (on = true) {\r\n    state = on ? STATE.EXPLORE_DRAG : STATE.EXPLORE;\r\n  };\r\n\r\n  this.setBirdsEyeMode = function (on = true) {\r\n    this.birdsEyeMode = on;\r\n    state = on ? STATE.BIRDS_EYE : STATE.NONE;\r\n  };\r\n\r\n  this.setVrMode = function (on = true) {\r\n    this.vrMode = on;\r\n  };\r\n\r\n  function calculateCameraQuaternion(alpha: number, beta: number, gamma: number): THREE.Quaternion {\r\n    // get device rotation in euler angles from gyroscope\r\n    // https://developers.google.com/web/fundamentals/native-hardware/device-orientation/\r\n    const deviceEuler = new THREE.Euler(beta, alpha + worldRotationY, -gamma, 'YXZ');\r\n\r\n    // create result quaternion from euler angles\r\n    const result = new THREE.Quaternion();\r\n    result.setFromEuler(deviceEuler);\r\n\r\n    // calculate necessary rotation to make up for different screen orientation\r\n    // window.orientation is 0 in portrait mode, 90 or -90 in respective landscape modes\r\n    const minusHalfAngle = -THREE.MathUtils.degToRad(Number(window.orientation)) / 2;\r\n    const screenTransform = new THREE.Quaternion(0, Math.sin(minusHalfAngle), 0, Math.cos(minusHalfAngle));\r\n    result.multiply(screenTransform);\r\n\r\n    // rotate result quaternion to make up difference in world coordinates\r\n    result.multiply(worldTransform);\r\n\r\n    return result;\r\n  }\r\n\r\n  function getAutoRotationAngle() {\r\n    return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;\r\n  }\r\n\r\n  function getZoomScale() {\r\n    return Math.pow(0.95, scope.zoomSpeed);\r\n  }\r\n\r\n  function onMouseDown(event) {\r\n\r\n    if (!isMouseEventAllowed(event)) {\r\n      return;\r\n    }\r\n    event.preventDefault();\r\n    const mousePos: THREE.Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n\r\n    if (state === STATE.BIRDS_EYE ||\r\n      state === STATE.BIRDS_EYE_DOLLY ||\r\n      state === STATE.BIRDS_EYE_PAN) {\r\n\r\n      state = STATE.BIRDS_EYE_PAN;\r\n      panStart.set(mousePos.x, mousePos.y);\r\n      scope.domElement.addEventListener('mousemove', onMouseMove, false);\r\n      scope.domElement.addEventListener('mouseup', onMouseUp, false);\r\n      return;\r\n    }\r\n    if (event.button === 0) {\r\n      if (scope.noRotate === true) {\r\n        return;\r\n      }\r\n\r\n      if (state !== STATE.EXPLORE && state !== STATE.EXPLORE_DRAG) {\r\n        state = STATE.ROTATE;\r\n      }\r\n\r\n      rotateStart.set(mousePos.x, mousePos.y);\r\n\r\n    } else if (event.button === 1) {\r\n      if (scope.noZoom === true) {\r\n        return;\r\n      }\r\n\r\n      state = STATE.DOLLY;\r\n\r\n      dollyStart.set(mousePos.x, mousePos.y);\r\n\r\n    } else if (event.button === 2) {\r\n      if (scope.noPan === true) {\r\n        return;\r\n      }\r\n\r\n      state = STATE.PAN;\r\n\r\n      panStart.set(mousePos.x, mousePos.y);\r\n    }\r\n\r\n    // Greggman fix: https://github.com/greggman/three.js/commit/fde9f9917d6d8381f06bf22cdff766029d1761be\r\n    scope.domElement.addEventListener('mousemove', onMouseMove, false);\r\n    scope.domElement.addEventListener('mouseup', onMouseUp, false);\r\n\r\n  }\r\n\r\n  function setRotationParameters(endPoint: THREE.Vector2, direction: number, speed: number) {\r\n\r\n    const element = scope.domElement === document ? scope.domElement.body : scope.domElement;\r\n\r\n    rotateEnd.copy(endPoint);\r\n    rotateDelta.subVectors(rotateEnd, rotateStart);\r\n\r\n    // rotating across whole screen goes 360 degrees around\r\n    scope.rotateLeft(2 * Math.PI * direction * rotateDelta.x / element.clientWidth * speed);\r\n    // rotating up and down along whole screen attempts to go 360, but limited to 180\r\n    scope.rotateUp(2 * Math.PI * direction * rotateDelta.y / element.clientHeight * speed);\r\n    rotateStart.copy(rotateEnd);\r\n  }\r\n\r\n  function isMouseEventAllowed(event?: Event): boolean {\r\n    const isCanvas = event ? (event.target && (event.target as Element).nodeName === 'CANVAS') : true;\r\n    return isCanvas && scope.enabled;\r\n  }\r\n\r\n  function originateOnCanvas(event: Event): boolean {\r\n    return event && event.target && event.target === document.body;\r\n  }\r\n\r\n  async function onMouseMove(event) {\r\n\r\n    if (!isMouseEventAllowed(event)) {\r\n      return;\r\n    }\r\n\r\n    event.preventDefault();\r\n    const mousePos: THREE.Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n\r\n    if (state === STATE.ROTATE) {\r\n\r\n      if (scope.noRotate === true) {\r\n        return;\r\n      }\r\n      setRotationParameters(\r\n        new THREE.Vector2(mousePos.x, mousePos.y),\r\n        1,\r\n        scope.rotateSpeed\r\n      );\r\n      scope.update();\r\n\r\n    } else if (state === STATE.EXPLORE) {\r\n\r\n      if (scope.noRotate === true) {\r\n        return;\r\n      }\r\n      setRotationParameters(\r\n        new THREE.Vector2(mousePos.x, mousePos.y),\r\n        -1,\r\n        scope.exploreRotateSpeed\r\n      );\r\n      scope.update();\r\n\r\n    } else if (state === STATE.EXPLORE_DRAG) {\r\n\r\n      scope.update();\r\n      return;\r\n\r\n    } else if (state === STATE.DOLLY || state === STATE.BIRDS_EYE_DOLLY) {\r\n\r\n      if (scope.noZoom === true) {\r\n        return;\r\n      }\r\n\r\n      dollyEnd.set(mousePos.x, mousePos.y);\r\n      dollyDelta.subVectors(dollyEnd, dollyStart);\r\n\r\n      if (dollyDelta.y > 0) {\r\n\r\n        scope.dollyIn();\r\n\r\n      } else {\r\n\r\n        scope.dollyOut();\r\n\r\n      }\r\n\r\n      dollyStart.copy(dollyEnd);\r\n      scope.update();\r\n\r\n    } else if (state === STATE.PAN || state === STATE.BIRDS_EYE_PAN) {\r\n\r\n      if (scope.noPan === true) {\r\n        return;\r\n      }\r\n\r\n      panEnd.set(mousePos.x, mousePos.y);\r\n      panDelta.subVectors(panEnd, panStart);\r\n\r\n      scope.pan(panDelta);\r\n\r\n      panStart.copy(panEnd);\r\n      scope.update();\r\n    }\r\n  }\r\n\r\n  function onMouseUp(event) {\r\n    if (!scope.enabled) {\r\n      return;\r\n    }\r\n\r\n    // Greggman fix: https://github.com/greggman/three.js/commit/fde9f9917d6d8381f06bf22cdff766029d1761be\r\n    scope.domElement.removeEventListener('mousemove', onMouseMove, false);\r\n    scope.domElement.removeEventListener('mouseup', onMouseUp, false);\r\n\r\n    if (state === STATE.EXPLORE) {\r\n      return;\r\n    }\r\n    if (state === STATE.EXPLORE_DRAG) {\r\n      state = STATE.EXPLORE;\r\n      return;\r\n    }\r\n    if (state === STATE.BIRDS_EYE || state === STATE.BIRDS_EYE_PAN || state === STATE.BIRDS_EYE_DOLLY) {\r\n      state = STATE.BIRDS_EYE;\r\n      return;\r\n    }\r\n    state = STATE.NONE;\r\n  }\r\n\r\n\r\n  function onMouseWheel(event) {\r\n    if (!scope.enabled || scope.noZoom === true) {\r\n      return;\r\n    }\r\n\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n\r\n    if (event.deltaY < 0) {\r\n      scope.dollyOut();\r\n    } else {\r\n      scope.dollyIn();\r\n    }\r\n    scope.update();\r\n  }\r\n\r\n  function onKeyDown(event) {\r\n\r\n    if (scope.enabled === false) {\r\n      return;\r\n    }\r\n    if (scope.noKeys === true) {\r\n      return;\r\n    }\r\n    if (scope.noPan === true) {\r\n      return;\r\n    }\r\n    if (!originateOnCanvas(event)) {\r\n      return;\r\n    }\r\n\r\n    switch (event.keyCode) {\r\n\r\n      case scope.keys.UP:\r\n        if (scope.exploreMode) {\r\n          scope.cameraForward();\r\n        } else {\r\n          scope.pan(new THREE.Vector2(0, scope.keyPanSpeed));\r\n        }\r\n        break;\r\n      case scope.keys.BOTTOM:\r\n        if (scope.exploreMode) {\r\n          scope.cameraBackward();\r\n        } else {\r\n          scope.pan(new THREE.Vector2(0, -scope.keyPanSpeed));\r\n        }\r\n        break;\r\n      case scope.keys.LEFT:\r\n        if (scope.exploreMode) {\r\n          scope.cameraLeft();\r\n        } else {\r\n          scope.pan(new THREE.Vector2(scope.keyPanSpeed, 0));\r\n        }\r\n        break;\r\n      case scope.keys.RIGHT:\r\n        if (scope.exploreMode) {\r\n          scope.cameraRight();\r\n        } else {\r\n          scope.pan(new THREE.Vector2(-scope.keyPanSpeed, 0));\r\n        }\r\n        break;\r\n    }\r\n\r\n  }\r\n\r\n  function touchstart(event) {\r\n    if (!isMouseEventAllowed(event)) {\r\n      return;\r\n    }\r\n\r\n    if (state === STATE.BIRDS_EYE ||\r\n      state === STATE.BIRDS_EYE_DOLLY ||\r\n      state === STATE.BIRDS_EYE_PAN) {\r\n      if (event.touches.length === 1 || event.touches.length === 3) {\r\n        state = STATE.BIRDS_EYE_PAN;\r\n        panStart.set(event.touches[0].pageX, event.touches[0].pageY);\r\n      } else if (event.touches.length === 2) {\r\n        state = STATE.BIRDS_EYE_DOLLY;\r\n        const dx = event.touches[0].pageX - event.touches[1].pageX;\r\n        const dy = event.touches[0].pageY - event.touches[1].pageY;\r\n        const distance = Math.sqrt(dx * dx + dy * dy);\r\n        dollyStart.set(0, distance);\r\n      }\r\n      return;\r\n    }\r\n\r\n    switch (event.touches.length) {\r\n\r\n      case 1:\t// one-fingered touch: rotate\r\n        if (scope.noRotate === true) {\r\n          return;\r\n        }\r\n\r\n        scope.longTouchTimer = setTimeout(() => {\r\n          scope.lookAroundMode = true;\r\n        }, scope.longTouchDuration);\r\n\r\n        state = STATE.TOUCH_ROTATE;\r\n        rotateStart.set(event.touches[0].pageX, event.touches[0].pageY);\r\n        break;\r\n\r\n      case 2:\t// two-fingered touch: dolly\r\n        if (scope.noZoom === true) {\r\n          return;\r\n        }\r\n\r\n        state = STATE.TOUCH_DOLLY;\r\n\r\n        const dx = event.touches[0].pageX - event.touches[1].pageX;\r\n        const dy = event.touches[0].pageY - event.touches[1].pageY;\r\n        const distance = Math.sqrt(dx * dx + dy * dy);\r\n        dollyStart.set(0, distance);\r\n        break;\r\n\r\n      case 3: // three-fingered touch: pan\r\n        if (scope.noPan === true) {\r\n          return;\r\n        }\r\n\r\n        state = STATE.TOUCH_PAN;\r\n\r\n        panStart.set(event.touches[0].pageX, event.touches[0].pageY);\r\n        break;\r\n\r\n      default:\r\n        state = STATE.NONE;\r\n\r\n    }\r\n  }\r\n\r\n  function touchmove(event) {\r\n    if (!isMouseEventAllowed(event)) {\r\n      return;\r\n    }\r\n\r\n    clearTimeout(scope.longTouchTimer);\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n\r\n    const element = scope.domElement === document ? scope.domElement.body : scope.domElement;\r\n\r\n    // disable use of two or three finger touch gestures in explore mode\r\n    const touchCountToProcess = scope.exploreMode ? 1 :\r\n      state === STATE.BIRDS_EYE_PAN && event.touches.length === 1 ? 3 :\r\n        event.touches.length;\r\n    switch (touchCountToProcess) {\r\n\r\n      case 1: // one-fingered touch: rotate\r\n        if (scope.noRotate === true) {\r\n          return;\r\n        }\r\n        if (state !== STATE.TOUCH_ROTATE) {\r\n          return;\r\n        }\r\n\r\n        rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);\r\n        rotateDelta.subVectors(rotateEnd, rotateStart);\r\n\r\n        const rotationSpeed = scope.exploreMode\r\n          ? scope.exploreRotateSpeed\r\n          : scope.rotateSpeed;\r\n\r\n        // rotating across whole screen goes 360 degrees around\r\n        scope.rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * rotationSpeed);\r\n        // rotating up and down along whole screen attempts to go 360, but limited to 180\r\n        scope.rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * rotationSpeed);\r\n\r\n        rotateStart.copy(rotateEnd);\r\n        break;\r\n\r\n      case 2: // two-fingered touch: dolly\r\n        if (scope.noZoom === true) {\r\n          return;\r\n        }\r\n        if (state !== STATE.TOUCH_DOLLY && state !== STATE.BIRDS_EYE_DOLLY) {\r\n          return;\r\n        }\r\n\r\n        const dx = event.touches[0].pageX - event.touches[1].pageX;\r\n        const dy = event.touches[0].pageY - event.touches[1].pageY;\r\n        const distance = Math.sqrt(dx * dx + dy * dy);\r\n\r\n        dollyEnd.set(0, distance);\r\n        dollyDelta.subVectors(dollyEnd, dollyStart);\r\n\r\n        if (dollyDelta.y > 0) {\r\n          scope.dollyOut();\r\n        } else {\r\n          scope.dollyIn();\r\n        }\r\n\r\n        dollyStart.copy(dollyEnd);\r\n        break;\r\n\r\n      case 3: // three-fingered touch: pan\r\n        if (scope.noPan === true) {\r\n          return;\r\n        }\r\n        if (state !== STATE.TOUCH_PAN && state !== STATE.BIRDS_EYE_PAN) {\r\n          return;\r\n        }\r\n\r\n        panEnd.set(event.touches[0].pageX, event.touches[0].pageY);\r\n        panDelta.subVectors(panEnd, panStart);\r\n\r\n        scope.pan(panDelta);\r\n\r\n        panStart.copy(panEnd);\r\n        break;\r\n\r\n      default:\r\n        state = STATE.NONE;\r\n    }\r\n    scope.update();\r\n  }\r\n\r\n  function touchend(event?) {\r\n    if (!scope.enabled) {\r\n      return;\r\n    }\r\n\r\n    clearTimeout(scope.longTouchTimer);\r\n    scope.lookAroundMode = false;\r\n\r\n    if (state === STATE.BIRDS_EYE || state === STATE.BIRDS_EYE_PAN || state === STATE.BIRDS_EYE_DOLLY) {\r\n      state = STATE.BIRDS_EYE;\r\n      return;\r\n    }\r\n    state = STATE.NONE;\r\n  }\r\n\r\n  function onDeviceMove(event: DeviceOrientationEvent) {\r\n    if (!scope.exploreMode || scope.vrMode || scope.lookAroundMode) {\r\n      return;\r\n    }\r\n    const alpha = THREE.MathUtils.degToRad(event.alpha || 0);\r\n    const beta = THREE.MathUtils.degToRad(event.beta || 0);\r\n    const gamma = THREE.MathUtils.degToRad(event.gamma || 0);\r\n\r\n    if (alpha !== 0 && beta !== 0 && gamma !== 0) {\r\n      scope.useGyroscope = true;\r\n      const cameraQuaternion = calculateCameraQuaternion(alpha, beta, gamma);\r\n\r\n      camera.quaternion.slerp(cameraQuaternion, 0.5); // smooth using spherical linear interpolation\r\n      scope.dispatchEvent(changeEvent);\r\n    }\r\n  }\r\n\r\n  this.domElement.addEventListener('contextmenu', function (event) {\r\n    event.preventDefault();\r\n  }, false);\r\n  this.domElement.addEventListener('mousedown', onMouseDown, false);\r\n  this.domElement.addEventListener('wheel', onMouseWheel, false);\r\n  this.domElement.addEventListener('touchstart', touchstart, false);\r\n  this.domElement.addEventListener('touchend', touchend, false);\r\n  this.domElement.addEventListener('touchmove', touchmove, false);\r\n  window.addEventListener('deviceorientation', onDeviceMove, false);\r\n  window.addEventListener('keydown', onKeyDown, false);\r\n};\r\nControls.prototype = Object.create(EventDispatcher.prototype);\r\n\r\nexport {Controls};\r\n"]}