@aibee/owlly 1.0.25

package/src/external/orbit-controls.ts

@@ -0,0 +1,1070 @@
+/* eslint-disable max-len, no-continue, @typescript-eslint/no-explicit-any, no-underscore-dangle, func-names, @typescript-eslint/no-this-alias, no-console */
+import { Externals, NS_THREE } from '../owlly/stage/externals';
+
+class OrbitControls extends NS_THREE.EventDispatcher {
+  object: NS_THREE.PerspectiveCamera | NS_THREE.OrthographicCamera;
+
+  domElement: any;
+
+  enabled: boolean;
+
+  target: NS_THREE.Vector3;
+
+  minDistance: number;
+
+  maxDistance: number;
+
+  minZoom: number;
+
+  maxZoom: number;
+
+  minPolarAngle: number;
+
+  maxPolarAngle: number;
+
+  minAzimuthAngle: number;
+
+  maxAzimuthAngle: number;
+
+  enableDamping: boolean;
+
+  dampingFactor: number;
+
+  enableZoom: boolean;
+
+  zoomSpeed: number;
+
+  enableRotate: boolean;
+
+  rotateSpeed: number;
+
+  enablePan: boolean;
+
+  panSpeed: number;
+
+  screenSpacePanning: boolean;
+
+  keyPanSpeed: number;
+
+  autoRotate: boolean;
+
+  autoRotateSpeed: number;
+
+  keys: any;
+
+  mouseButtons: any;
+
+  touches: any;
+
+  target0: NS_THREE.Vector3;
+
+  position0: NS_THREE.Vector3;
+
+  zoom0: number;
+
+  _domElementKeyEvents: any;
+
+  getPolarAngle: Function;
+
+  getAzimuthalAngle: Function;
+
+  listenToKeyEvents: Function;
+
+  saveState: Function;
+
+  reset: Function;
+
+  update: Function;
+
+  dispose: Function;
+
+  enableKeys: boolean;
+
+  constructor(object: NS_THREE.PerspectiveCamera | NS_THREE.OrthographicCamera, domElement: any) {
+    super();
+
+    const { THREE } = Externals.getInstance();
+
+    if (domElement === undefined) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
+    if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+
+    this.object = object;
+    this.domElement = domElement;
+
+    // Set to false to disable this control
+    this.enabled = true;
+
+    // "target" sets the location of focus, where the object orbits around
+    this.target = new THREE.Vector3();
+
+    // How far you can dolly in and out ( PerspectiveCamera only )
+    this.minDistance = 0;
+    this.maxDistance = Infinity;
+
+    // How far you can zoom in and out ( OrthographicCamera only )
+    this.minZoom = 0;
+    this.maxZoom = Infinity;
+
+    // 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; // radians
+
+    // How far you can orbit horizontally, upper and lower limits.
+    // If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI )
+    this.minAzimuthAngle = -Infinity; // radians
+    this.maxAzimuthAngle = Infinity; // radians
+
+    // Set to true to enable damping (inertia)
+    // If damping is enabled, you must call controls.update() in your animation loop
+    this.enableDamping = false;
+    this.dampingFactor = 0.05;
+
+    // This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+    // Set to false to disable zooming
+    this.enableZoom = true;
+    this.zoomSpeed = 1.0;
+
+    // Set to false to disable rotating
+    this.enableRotate = true;
+    this.rotateSpeed = 1.0;
+
+    // Set to false to disable panning
+    this.enablePan = true;
+    this.panSpeed = 1.0;
+    this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up
+    this.keyPanSpeed = 7.0; // pixels moved per arrow key push
+
+    // Set to true to automatically rotate around the target
+    // If auto-rotate is enabled, you must call controls.update() in your animation loop
+    this.autoRotate = false;
+    this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60
+
+    this.enableKeys = false;
+
+    // The four arrow keys
+    this.keys = {
+      LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40,
+    };
+
+    // Mouse buttons
+    this.mouseButtons = { LEFT: THREE.MOUSE.ROTATE, MIDDLE: THREE.MOUSE.DOLLY, RIGHT: THREE.MOUSE.PAN };
+
+    // Touch fingers
+    this.touches = { ONE: THREE.TOUCH.ROTATE, TWO: THREE.TOUCH.DOLLY_PAN };
+
+    // for reset
+    this.target0 = this.target.clone();
+    this.position0 = this.object.position.clone();
+    this.zoom0 = this.object.zoom;
+
+    // the target DOM element for key events
+    this._domElementKeyEvents = null;
+
+    //
+    // internals
+    //
+
+    const scope = this;
+
+    const changeEvent = { type: 'change' };
+    const startEvent = { type: 'start' };
+    const endEvent = { type: 'end' };
+
+    const STATE = {
+      NONE: -1,
+      ROTATE: 0,
+      DOLLY: 1,
+      PAN: 2,
+      TOUCH_ROTATE: 3,
+      TOUCH_PAN: 4,
+      TOUCH_DOLLY_PAN: 5,
+      TOUCH_DOLLY_ROTATE: 6,
+    };
+
+    let state = STATE.NONE;
+
+    const EPS = 0.000001;
+
+    // current position in spherical coordinates
+    const spherical = new THREE.Spherical();
+    const sphericalDelta = new THREE.Spherical();
+
+    let scale = 1;
+    const panOffset = new THREE.Vector3();
+    let zoomChanged = false;
+
+    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();
+
+    function getAutoRotationAngle(): any {
+      return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+    }
+
+    function getZoomScale(): any {
+      return Math.pow(0.95, scope.zoomSpeed); // eslint-disable-line
+    }
+
+    function rotateLeft(angle: any): any {
+      sphericalDelta.theta -= angle;
+    }
+
+    function rotateUp(angle: any): any {
+      sphericalDelta.phi -= angle;
+    }
+
+    const panLeft = (function (): any {
+      const v = new THREE.Vector3();
+
+      return function (distance: any, objectMatrix: any): any {
+        v.setFromMatrixColumn(objectMatrix, 0); // get X column of objectMatrix
+        v.multiplyScalar(-distance);
+
+        panOffset.add(v);
+      };
+    }());
+
+    const panUp = (function (): any {
+      const v = new THREE.Vector3();
+
+      return function (distance: any, objectMatrix: any): any {
+        if (scope.screenSpacePanning === true) {
+          v.setFromMatrixColumn(objectMatrix, 1);
+        } else {
+          v.setFromMatrixColumn(objectMatrix, 0);
+          v.crossVectors(scope.object.up, v);
+        }
+
+        v.multiplyScalar(distance);
+
+        panOffset.add(v);
+      };
+    }());
+
+    // deltaX and deltaY are in pixels; right and down are positive
+    const pan = (function (): any {
+      const offset = new THREE.Vector3();
+
+      return function (deltaX: any, deltaY: any): any {
+        const element = scope.domElement;
+
+        if ((scope.object as NS_THREE.PerspectiveCamera).isPerspectiveCamera) {
+          // perspective
+          const { position } = scope.object;
+          offset.copy(position).sub(scope.target);
+          let targetDistance = offset.length();
+
+          // half of the fov is center to top of screen
+          targetDistance *= Math.tan(((scope.object as NS_THREE.PerspectiveCamera).fov / 2) * Math.PI / 180.0);
+
+          // we use only clientHeight here so aspect ratio does not distort speed
+          panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
+          panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
+        } else if ((scope.object as NS_THREE.OrthographicCamera).isOrthographicCamera) {
+          const ortho = (scope.object as NS_THREE.OrthographicCamera);
+          // orthographic
+          panLeft(deltaX * (ortho.right - ortho.left) / ortho.zoom / element.clientWidth, ortho.matrix);
+          panUp(deltaY * (ortho.top - ortho.bottom) / ortho.zoom / element.clientHeight, ortho.matrix);
+        } else {
+          // camera neither orthographic nor perspective
+          console.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.');
+          scope.enablePan = false;
+        }
+      };
+    }());
+
+    function dollyOut(dollyScale: any): any {
+      if ((scope.object as NS_THREE.PerspectiveCamera).isPerspectiveCamera) {
+        scale /= dollyScale;
+      } else if ((scope.object as NS_THREE.OrthographicCamera).isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
+      } else {
+        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');
+        scope.enableZoom = false;
+      }
+    }
+
+    function dollyIn(dollyScale: any): any {
+      if ((scope.object as NS_THREE.PerspectiveCamera).isPerspectiveCamera) {
+        scale *= dollyScale;
+      } else if ((scope.object as NS_THREE.OrthographicCamera).isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
+      } else {
+        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');
+        scope.enableZoom = false;
+      }
+    }
+
+    //
+    // event callbacks - update the object state
+    //
+
+    function handleMouseDownRotate(event: any): any {
+      rotateStart.set(event.clientX, event.clientY);
+    }
+
+    function handleMouseDownDolly(event: any): any {
+      dollyStart.set(event.clientX, event.clientY);
+    }
+
+    function handleMouseDownPan(event: any): any {
+      panStart.set(event.clientX, event.clientY);
+    }
+
+    function handleMouseMoveRotate(event: any): any {
+      rotateEnd.set(event.clientX, event.clientY);
+
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+
+      const element = scope.domElement;
+
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); // yes, height
+
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+
+      rotateStart.copy(rotateEnd);
+
+      scope.update();
+    }
+
+    function handleMouseMoveDolly(event: any): any {
+      dollyEnd.set(event.clientX, event.clientY);
+
+      dollyDelta.subVectors(dollyEnd, dollyStart);
+
+      if (dollyDelta.y > 0) {
+        dollyOut(getZoomScale());
+      } else if (dollyDelta.y < 0) {
+        dollyIn(getZoomScale());
+      }
+
+      dollyStart.copy(dollyEnd);
+
+      scope.update();
+    }
+
+    function handleMouseMovePan(event: any): any {
+      panEnd.set(event.clientX, event.clientY);
+
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+
+      pan(panDelta.x, panDelta.y);
+
+      panStart.copy(panEnd);
+
+      scope.update();
+    }
+
+    function handleMouseUp(/* event */): any {
+
+      // no-op
+
+    }
+
+    function handleMouseWheel(event: any): any {
+      if (event.deltaY < 0) {
+        dollyIn(getZoomScale());
+      } else if (event.deltaY > 0) {
+        dollyOut(getZoomScale());
+      }
+
+      scope.update();
+    }
+
+    function handleKeyDown(event: any): any {
+      let needsUpdate = false;
+
+      switch (event.keyCode) {
+        case scope.keys.UP:
+          pan(0, scope.keyPanSpeed);
+          needsUpdate = true;
+          break;
+
+        case scope.keys.BOTTOM:
+          pan(0, -scope.keyPanSpeed);
+          needsUpdate = true;
+          break;
+
+        case scope.keys.LEFT:
+          pan(scope.keyPanSpeed, 0);
+          needsUpdate = true;
+          break;
+
+        case scope.keys.RIGHT:
+          pan(-scope.keyPanSpeed, 0);
+          needsUpdate = true;
+          break;
+        default: break;
+      }
+
+      if (needsUpdate) {
+        // prevent the browser from scrolling on cursor keys
+        event.preventDefault();
+
+        scope.update();
+      }
+    }
+
+    function handleTouchStartRotate(event: any): any {
+      if (event.touches.length === 1) {
+        rotateStart.set(event.touches[0].pageX, event.touches[0].pageY);
+      } else {
+        const x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX);
+        const y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY);
+
+        rotateStart.set(x, y);
+      }
+    }
+
+    function handleTouchStartPan(event: any): any {
+      if (event.touches.length === 1) {
+        panStart.set(event.touches[0].pageX, event.touches[0].pageY);
+      } else {
+        const x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX);
+        const y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY);
+
+        panStart.set(x, y);
+      }
+    }
+
+    function handleTouchStartDolly(event: any): any {
+      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);
+    }
+
+    function handleTouchStartDollyPan(event: any): any {
+      if (scope.enableZoom) handleTouchStartDolly(event);
+
+      if (scope.enablePan) handleTouchStartPan(event);
+    }
+
+    function handleTouchStartDollyRotate(event: any): any {
+      if (scope.enableZoom) handleTouchStartDolly(event);
+
+      if (scope.enableRotate) handleTouchStartRotate(event);
+    }
+
+    function handleTouchMoveRotate(event: any): any {
+      if (event.touches.length === 1) {
+        rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);
+      } else {
+        const x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX);
+        const y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY);
+
+        rotateEnd.set(x, y);
+      }
+
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+
+      const element = scope.domElement;
+
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); // yes, height
+
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+
+      rotateStart.copy(rotateEnd);
+    }
+
+    function handleTouchMovePan(event: any): any {
+      if (event.touches.length === 1) {
+        panEnd.set(event.touches[0].pageX, event.touches[0].pageY);
+      } else {
+        const x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX);
+        const y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY);
+
+        panEnd.set(x, y);
+      }
+
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+
+      pan(panDelta.x, panDelta.y);
+
+      panStart.copy(panEnd);
+    }
+
+    function handleTouchMoveDolly(event: any): any {
+      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);
+
+      // eslint-disable-next-line
+      dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
+
+      dollyOut(dollyDelta.y);
+
+      dollyStart.copy(dollyEnd);
+    }
+
+    function handleTouchMoveDollyPan(event: any): any {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+
+      if (scope.enablePan) handleTouchMovePan(event);
+    }
+
+    function handleTouchMoveDollyRotate(event: any): any {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+
+      if (scope.enableRotate) handleTouchMoveRotate(event);
+    }
+
+    function handleTouchEnd(/* event */): any {
+
+      // no-op
+
+    }
+
+    //
+    // event handlers - FSM: listen for events and reset state
+    //
+
+    function onPointerDown(event: any): any {
+      if (scope.enabled === false) return;
+
+      switch (event.pointerType) {
+        case 'mouse':
+        case 'pen':
+          onMouseDown(event); // eslint-disable-line @typescript-eslint/no-use-before-define
+          break;
+
+        // TODO touch
+        default: break;
+      }
+    }
+
+    function onPointerMove(event: any): any {
+      if (scope.enabled === false) return;
+
+      switch (event.pointerType) {
+        case 'mouse':
+        case 'pen':
+          onMouseMove(event); // eslint-disable-line @typescript-eslint/no-use-before-define
+          break;
+
+        // TODO touch
+        default: break;
+      }
+    }
+
+    function onPointerUp(event: any): any {
+      switch (event.pointerType) {
+        case 'mouse':
+        case 'pen':
+          onMouseUp(); // eslint-disable-line @typescript-eslint/no-use-before-define
+          break;
+
+        // TODO touch
+        default: break;
+      }
+    }
+
+    function onMouseDown(event: any): any {
+      // Prevent the browser from scrolling.
+      event.preventDefault();
+
+      // Manually set the focus since calling preventDefault above
+      // prevents the browser from setting it automatically.
+
+      // eslint-disable-next-line
+      scope.domElement.focus ? scope.domElement.focus() : window.focus();
+
+      let mouseAction;
+
+      switch (event.button) {
+        case 0:
+
+          mouseAction = scope.mouseButtons.LEFT;
+          break;
+
+        case 1:
+
+          mouseAction = scope.mouseButtons.MIDDLE;
+          break;
+
+        case 2:
+
+          mouseAction = scope.mouseButtons.RIGHT;
+          break;
+
+        default:
+
+          mouseAction = -1;
+      }
+
+      switch (mouseAction) {
+        case THREE.MOUSE.DOLLY:
+
+          if (scope.enableZoom === false) return;
+
+          handleMouseDownDolly(event);
+
+          state = STATE.DOLLY;
+
+          break;
+
+        case THREE.MOUSE.ROTATE:
+
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enablePan === false) return;
+
+            handleMouseDownPan(event);
+
+            state = STATE.PAN;
+          } else {
+            if (scope.enableRotate === false) return;
+
+            handleMouseDownRotate(event);
+
+            state = STATE.ROTATE;
+          }
+
+          break;
+
+        case THREE.MOUSE.PAN:
+
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enableRotate === false) return;
+
+            handleMouseDownRotate(event);
+
+            state = STATE.ROTATE;
+          } else {
+            if (scope.enablePan === false) return;
+
+            handleMouseDownPan(event);
+
+            state = STATE.PAN;
+          }
+
+          break;
+
+        default:
+
+          state = STATE.NONE;
+      }
+
+      if (state !== STATE.NONE) {
+        scope.domElement.ownerDocument.addEventListener('pointermove', onPointerMove);
+        scope.domElement.ownerDocument.addEventListener('pointerup', onPointerUp);
+
+        scope.dispatchEvent(startEvent);
+      }
+    }
+
+    function onMouseMove(event: any): any {
+      if (scope.enabled === false) return;
+
+      event.preventDefault();
+
+      switch (state) {
+        case STATE.ROTATE:
+
+          if (scope.enableRotate === false) return;
+
+          handleMouseMoveRotate(event);
+
+          break;
+
+        case STATE.DOLLY:
+
+          if (scope.enableZoom === false) return;
+
+          handleMouseMoveDolly(event);
+
+          break;
+
+        case STATE.PAN:
+
+          if (scope.enablePan === false) return;
+
+          handleMouseMovePan(event);
+
+          break;
+        default: break;
+      }
+    }
+
+    function onMouseUp(): any {
+      scope.domElement.ownerDocument.removeEventListener('pointermove', onPointerMove);
+      scope.domElement.ownerDocument.removeEventListener('pointerup', onPointerUp);
+
+      if (scope.enabled === false) return;
+
+      handleMouseUp();
+
+      scope.dispatchEvent(endEvent);
+
+      state = STATE.NONE;
+    }
+
+    function onMouseWheel(event: any): any {
+      if (scope.enabled === false || scope.enableZoom === false || (state !== STATE.NONE && state !== STATE.ROTATE)) return;
+
+      event.preventDefault();
+
+      scope.dispatchEvent(startEvent);
+
+      handleMouseWheel(event);
+
+      scope.dispatchEvent(endEvent);
+    }
+
+    function onKeyDown(event: any): any {
+      if (scope.enabled === false || scope.enablePan === false || scope.enableKeys === false) return;
+
+      handleKeyDown(event);
+    }
+
+    function onTouchStart(event: any): any {
+      if (scope.enabled === false) return;
+
+      event.preventDefault(); // prevent scrolling
+
+      switch (event.touches.length) {
+        case 1:
+
+          switch (scope.touches.ONE) {
+            case THREE.TOUCH.ROTATE:
+
+              if (scope.enableRotate === false) return;
+
+              handleTouchStartRotate(event);
+
+              state = STATE.TOUCH_ROTATE;
+
+              break;
+
+            case THREE.TOUCH.PAN:
+
+              if (scope.enablePan === false) return;
+
+              handleTouchStartPan(event);
+
+              state = STATE.TOUCH_PAN;
+
+              break;
+
+            default:
+
+              state = STATE.NONE;
+          }
+
+          break;
+
+        case 2:
+
+          switch (scope.touches.TWO) {
+            case THREE.TOUCH.DOLLY_PAN:
+
+              if (scope.enableZoom === false && scope.enablePan === false) return;
+
+              handleTouchStartDollyPan(event);
+
+              state = STATE.TOUCH_DOLLY_PAN;
+
+              break;
+
+            case THREE.TOUCH.DOLLY_ROTATE:
+
+              if (scope.enableZoom === false && scope.enableRotate === false) return;
+
+              handleTouchStartDollyRotate(event);
+
+              state = STATE.TOUCH_DOLLY_ROTATE;
+
+              break;
+
+            default:
+
+              state = STATE.NONE;
+          }
+
+          break;
+
+        default:
+
+          state = STATE.NONE;
+      }
+
+      if (state !== STATE.NONE) {
+        scope.dispatchEvent(startEvent);
+      }
+    }
+
+    function onTouchMove(event: any): any {
+      if (scope.enabled === false) return;
+
+      event.preventDefault(); // prevent scrolling
+
+      switch (state) {
+        case STATE.TOUCH_ROTATE:
+
+          if (scope.enableRotate === false) return;
+
+          handleTouchMoveRotate(event);
+
+          scope.update();
+
+          break;
+
+        case STATE.TOUCH_PAN:
+
+          if (scope.enablePan === false) return;
+
+          handleTouchMovePan(event);
+
+          scope.update();
+
+          break;
+
+        case STATE.TOUCH_DOLLY_PAN:
+
+          if (scope.enableZoom === false && scope.enablePan === false) return;
+
+          handleTouchMoveDollyPan(event);
+
+          scope.update();
+
+          break;
+
+        case STATE.TOUCH_DOLLY_ROTATE:
+
+          if (scope.enableZoom === false && scope.enableRotate === false) return;
+
+          handleTouchMoveDollyRotate(event);
+
+          scope.update();
+
+          break;
+
+        default:
+
+          state = STATE.NONE;
+      }
+    }
+
+    function onTouchEnd(): any {
+      if (scope.enabled === false) return;
+
+      handleTouchEnd();
+
+      scope.dispatchEvent(endEvent);
+
+      state = STATE.NONE;
+    }
+
+    function onContextMenu(event: any): any {
+      if (scope.enabled === false) return;
+
+      event.preventDefault();
+    }
+
+    //
+
+    scope.domElement.addEventListener('contextmenu', onContextMenu);
+
+    scope.domElement.addEventListener('pointerdown', onPointerDown);
+    scope.domElement.addEventListener('wheel', onMouseWheel);
+
+    scope.domElement.addEventListener('touchstart', onTouchStart);
+    scope.domElement.addEventListener('touchend', onTouchEnd);
+    scope.domElement.addEventListener('touchmove', onTouchMove);
+
+    //
+    // public methods
+    //
+
+    this.getPolarAngle = function (): any {
+      return spherical.phi;
+    };
+
+    this.getAzimuthalAngle = function (): any {
+      return spherical.theta;
+    };
+
+    // eslint-disable-next-line no-shadow
+    this.listenToKeyEvents = function (domElement: any): any {
+      domElement.addEventListener('keydown', onKeyDown);
+      this._domElementKeyEvents = domElement;
+    };
+
+    this.saveState = function (): any {
+      scope.target0.copy(scope.target);
+      scope.position0.copy(scope.object.position);
+      scope.zoom0 = scope.object.zoom;
+    };
+
+    this.reset = function (): any {
+      scope.target.copy(scope.target0);
+      scope.object.position.copy(scope.position0);
+      scope.object.zoom = scope.zoom0;
+
+      scope.object.updateProjectionMatrix();
+      scope.dispatchEvent(changeEvent);
+
+      scope.update();
+
+      state = STATE.NONE;
+    };
+
+    // this method is exposed, but perhaps it would be better if we can make it private...
+    this.update = (function (): any {
+      const offset = new THREE.Vector3();
+
+      // so camera.up is the orbit axis
+      const quat = new THREE.Quaternion().setFromUnitVectors(object.up, new THREE.Vector3(0, 1, 0));
+      const quatInverse = quat.clone().invert();
+
+      const lastPosition = new THREE.Vector3();
+      const lastQuaternion = new THREE.Quaternion();
+
+      const twoPI = 2 * Math.PI;
+
+      return function update(): any {
+        const { position } = scope.object;
+
+        offset.copy(position).sub(scope.target);
+
+        // rotate offset to "y-axis-is-up" space
+        offset.applyQuaternion(quat);
+
+        // angle from z-axis around y-axis
+        spherical.setFromVector3(offset);
+
+        if (scope.autoRotate && state === STATE.NONE) {
+          rotateLeft(getAutoRotationAngle());
+        }
+
+        if (scope.enableDamping) {
+          spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+          spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+        } else {
+          spherical.theta += sphericalDelta.theta;
+          spherical.phi += sphericalDelta.phi;
+        }
+
+        // restrict theta to be between desired limits
+
+        let min = scope.minAzimuthAngle;
+        let max = scope.maxAzimuthAngle;
+
+        if (Number.isFinite(min) && Number.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) {
+            spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+          } else {
+            spherical.theta = (spherical.theta > (min + max) / 2)
+              ? Math.max(min, spherical.theta)
+              : Math.min(max, spherical.theta);
+          }
+        }
+
+        // restrict phi to be between desired limits
+        spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
+
+        spherical.makeSafe();
+
+        spherical.radius *= scale;
+
+        // restrict radius to be between desired limits
+        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
+
+        // move target to panned location
+
+        if (scope.enableDamping === true) {
+          scope.target.addScaledVector(panOffset, scope.dampingFactor);
+        } else {
+          scope.target.add(panOffset);
+        }
+
+        offset.setFromSpherical(spherical);
+
+        // rotate offset back to "camera-up-vector-is-up" space
+        offset.applyQuaternion(quatInverse);
+
+        position.copy(scope.target).add(offset);
+
+        scope.object.lookAt(scope.target);
+
+        if (scope.enableDamping === true) {
+          sphericalDelta.theta *= (1 - scope.dampingFactor);
+          sphericalDelta.phi *= (1 - scope.dampingFactor);
+
+          panOffset.multiplyScalar(1 - scope.dampingFactor);
+        } else {
+          sphericalDelta.set(0, 0, 0);
+
+          panOffset.set(0, 0, 0);
+        }
+
+        scale = 1;
+
+        // update condition is:
+        // min(camera displacement, camera rotation in radians)^2 > EPS
+        // using small-angle approximation cos(x/2) = 1 - x^2 / 8
+
+        if (zoomChanged
+            || lastPosition.distanceToSquared(scope.object.position) > EPS
+            || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
+          scope.dispatchEvent(changeEvent);
+
+          lastPosition.copy(scope.object.position);
+          lastQuaternion.copy(scope.object.quaternion);
+          zoomChanged = false;
+
+          return true;
+        }
+
+        return false;
+      };
+    }());
+
+    this.dispose = function (): any {
+      scope.domElement.removeEventListener('contextmenu', onContextMenu);
+
+      scope.domElement.removeEventListener('pointerdown', onPointerDown);
+      scope.domElement.removeEventListener('wheel', onMouseWheel);
+
+      scope.domElement.removeEventListener('touchstart', onTouchStart);
+      scope.domElement.removeEventListener('touchend', onTouchEnd);
+      scope.domElement.removeEventListener('touchmove', onTouchMove);
+
+      scope.domElement.ownerDocument.removeEventListener('pointermove', onPointerMove);
+      scope.domElement.ownerDocument.removeEventListener('pointerup', onPointerUp);
+
+      if (scope._domElementKeyEvents !== null) {
+        scope._domElementKeyEvents.removeEventListener('keydown', onKeyDown);
+      }
+
+      // scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+    };
+
+    // force an update at start
+
+    this.update();
+  }
+}
+
+export { OrbitControls };