opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/controls/TrackballControls.js

@@ -0,0 +1,666 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.TrackballControls = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.TrackballControls = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _changeEvent = {
+    type: 'change'
+  };
+  var _startEvent = {
+    type: 'start'
+  };
+  var _endEvent = {
+    type: 'end'
+  };
+
+  var TrackballControls = /*#__PURE__*/function (_EventDispatcher) {
+    _inherits(TrackballControls, _EventDispatcher);
+
+    var _super = _createSuper(TrackballControls);
+
+    function TrackballControls(object, domElement) {
+      var _this;
+
+      _classCallCheck(this, TrackballControls);
+
+      _this = _super.call(this);
+      if (domElement === undefined) console.warn('THREE.TrackballControls: The second parameter "domElement" is now mandatory.');
+      if (domElement === document) console.error('THREE.TrackballControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+
+      var scope = _assertThisInitialized(_this);
+
+      var STATE = {
+        NONE: -1,
+        ROTATE: 0,
+        ZOOM: 1,
+        PAN: 2,
+        TOUCH_ROTATE: 3,
+        TOUCH_ZOOM_PAN: 4
+      };
+      _this.object = object;
+      _this.domElement = domElement;
+      _this.domElement.style.touchAction = 'none'; // disable touch scroll
+      // API
+
+      _this.enabled = true;
+      _this.screen = {
+        left: 0,
+        top: 0,
+        width: 0,
+        height: 0
+      };
+      _this.rotateSpeed = 1.0;
+      _this.zoomSpeed = 1.2;
+      _this.panSpeed = 0.3;
+      _this.noRotate = false;
+      _this.noZoom = false;
+      _this.noPan = false;
+      _this.staticMoving = false;
+      _this.dynamicDampingFactor = 0.2;
+      _this.minDistance = 0;
+      _this.maxDistance = Infinity;
+      _this.keys = ['KeyA'
+      /*A*/
+      , 'KeyS'
+      /*S*/
+      , 'KeyD'
+      /*D*/
+      ];
+      _this.mouseButtons = {
+        LEFT: _three.MOUSE.ROTATE,
+        MIDDLE: _three.MOUSE.DOLLY,
+        RIGHT: _three.MOUSE.PAN
+      }; // internals
+
+      _this.target = new _three.Vector3();
+      var EPS = 0.000001;
+      var lastPosition = new _three.Vector3();
+      var lastZoom = 1;
+      var _state = STATE.NONE,
+          _keyState = STATE.NONE,
+          _touchZoomDistanceStart = 0,
+          _touchZoomDistanceEnd = 0,
+          _lastAngle = 0;
+
+      var _eye = new _three.Vector3(),
+          _movePrev = new _three.Vector2(),
+          _moveCurr = new _three.Vector2(),
+          _lastAxis = new _three.Vector3(),
+          _zoomStart = new _three.Vector2(),
+          _zoomEnd = new _three.Vector2(),
+          _panStart = new _three.Vector2(),
+          _panEnd = new _three.Vector2(),
+          _pointers = [],
+          _pointerPositions = {}; // for reset
+
+
+      _this.target0 = _this.target.clone();
+      _this.position0 = _this.object.position.clone();
+      _this.up0 = _this.object.up.clone();
+      _this.zoom0 = _this.object.zoom; // methods
+
+      _this.handleResize = function () {
+        var box = scope.domElement.getBoundingClientRect(); // adjustments come from similar code in the jquery offset() function
+
+        var d = scope.domElement.ownerDocument.documentElement;
+        scope.screen.left = box.left + window.pageXOffset - d.clientLeft;
+        scope.screen.top = box.top + window.pageYOffset - d.clientTop;
+        scope.screen.width = box.width;
+        scope.screen.height = box.height;
+      };
+
+      var getMouseOnScreen = function () {
+        var vector = new _three.Vector2();
+        return function getMouseOnScreen(pageX, pageY) {
+          vector.set((pageX - scope.screen.left) / scope.screen.width, (pageY - scope.screen.top) / scope.screen.height);
+          return vector;
+        };
+      }();
+
+      var getMouseOnCircle = function () {
+        var vector = new _three.Vector2();
+        return function getMouseOnCircle(pageX, pageY) {
+          vector.set((pageX - scope.screen.width * 0.5 - scope.screen.left) / (scope.screen.width * 0.5), (scope.screen.height + 2 * (scope.screen.top - pageY)) / scope.screen.width // screen.width intentional
+          );
+          return vector;
+        };
+      }();
+
+      _this.rotateCamera = function () {
+        var axis = new _three.Vector3(),
+            quaternion = new _three.Quaternion(),
+            eyeDirection = new _three.Vector3(),
+            objectUpDirection = new _three.Vector3(),
+            objectSidewaysDirection = new _three.Vector3(),
+            moveDirection = new _three.Vector3();
+        return function rotateCamera() {
+          moveDirection.set(_moveCurr.x - _movePrev.x, _moveCurr.y - _movePrev.y, 0);
+          var angle = moveDirection.length();
+
+          if (angle) {
+            _eye.copy(scope.object.position).sub(scope.target);
+
+            eyeDirection.copy(_eye).normalize();
+            objectUpDirection.copy(scope.object.up).normalize();
+            objectSidewaysDirection.crossVectors(objectUpDirection, eyeDirection).normalize();
+            objectUpDirection.setLength(_moveCurr.y - _movePrev.y);
+            objectSidewaysDirection.setLength(_moveCurr.x - _movePrev.x);
+            moveDirection.copy(objectUpDirection.add(objectSidewaysDirection));
+            axis.crossVectors(moveDirection, _eye).normalize();
+            angle *= scope.rotateSpeed;
+            quaternion.setFromAxisAngle(axis, angle);
+
+            _eye.applyQuaternion(quaternion);
+
+            scope.object.up.applyQuaternion(quaternion);
+
+            _lastAxis.copy(axis);
+
+            _lastAngle = angle;
+          } else if (!scope.staticMoving && _lastAngle) {
+            _lastAngle *= Math.sqrt(1.0 - scope.dynamicDampingFactor);
+
+            _eye.copy(scope.object.position).sub(scope.target);
+
+            quaternion.setFromAxisAngle(_lastAxis, _lastAngle);
+
+            _eye.applyQuaternion(quaternion);
+
+            scope.object.up.applyQuaternion(quaternion);
+          }
+
+          _movePrev.copy(_moveCurr);
+        };
+      }();
+
+      _this.zoomCamera = function () {
+        var factor;
+
+        if (_state === STATE.TOUCH_ZOOM_PAN) {
+          factor = _touchZoomDistanceStart / _touchZoomDistanceEnd;
+          _touchZoomDistanceStart = _touchZoomDistanceEnd;
+
+          if (scope.object.isPerspectiveCamera) {
+            _eye.multiplyScalar(factor);
+          } else if (scope.object.isOrthographicCamera) {
+            scope.object.zoom /= factor;
+            scope.object.updateProjectionMatrix();
+          } else {
+            console.warn('THREE.TrackballControls: Unsupported camera type');
+          }
+        } else {
+          factor = 1.0 + (_zoomEnd.y - _zoomStart.y) * scope.zoomSpeed;
+
+          if (factor !== 1.0 && factor > 0.0) {
+            if (scope.object.isPerspectiveCamera) {
+              _eye.multiplyScalar(factor);
+            } else if (scope.object.isOrthographicCamera) {
+              scope.object.zoom /= factor;
+              scope.object.updateProjectionMatrix();
+            } else {
+              console.warn('THREE.TrackballControls: Unsupported camera type');
+            }
+          }
+
+          if (scope.staticMoving) {
+            _zoomStart.copy(_zoomEnd);
+          } else {
+            _zoomStart.y += (_zoomEnd.y - _zoomStart.y) * this.dynamicDampingFactor;
+          }
+        }
+      };
+
+      _this.panCamera = function () {
+        var mouseChange = new _three.Vector2(),
+            objectUp = new _three.Vector3(),
+            pan = new _three.Vector3();
+        return function panCamera() {
+          mouseChange.copy(_panEnd).sub(_panStart);
+
+          if (mouseChange.lengthSq()) {
+            if (scope.object.isOrthographicCamera) {
+              var scale_x = (scope.object.right - scope.object.left) / scope.object.zoom / scope.domElement.clientWidth;
+              var scale_y = (scope.object.top - scope.object.bottom) / scope.object.zoom / scope.domElement.clientWidth;
+              mouseChange.x *= scale_x;
+              mouseChange.y *= scale_y;
+            }
+
+            mouseChange.multiplyScalar(_eye.length() * scope.panSpeed);
+            pan.copy(_eye).cross(scope.object.up).setLength(mouseChange.x);
+            pan.add(objectUp.copy(scope.object.up).setLength(mouseChange.y));
+            scope.object.position.add(pan);
+            scope.target.add(pan);
+
+            if (scope.staticMoving) {
+              _panStart.copy(_panEnd);
+            } else {
+              _panStart.add(mouseChange.subVectors(_panEnd, _panStart).multiplyScalar(scope.dynamicDampingFactor));
+            }
+          }
+        };
+      }();
+
+      _this.checkDistances = function () {
+        if (!scope.noZoom || !scope.noPan) {
+          if (_eye.lengthSq() > scope.maxDistance * scope.maxDistance) {
+            scope.object.position.addVectors(scope.target, _eye.setLength(scope.maxDistance));
+
+            _zoomStart.copy(_zoomEnd);
+          }
+
+          if (_eye.lengthSq() < scope.minDistance * scope.minDistance) {
+            scope.object.position.addVectors(scope.target, _eye.setLength(scope.minDistance));
+
+            _zoomStart.copy(_zoomEnd);
+          }
+        }
+      };
+
+      _this.update = function () {
+        _eye.subVectors(scope.object.position, scope.target);
+
+        if (!scope.noRotate) {
+          scope.rotateCamera();
+        }
+
+        if (!scope.noZoom) {
+          scope.zoomCamera();
+        }
+
+        if (!scope.noPan) {
+          scope.panCamera();
+        }
+
+        scope.object.position.addVectors(scope.target, _eye);
+
+        if (scope.object.isPerspectiveCamera) {
+          scope.checkDistances();
+          scope.object.lookAt(scope.target);
+
+          if (lastPosition.distanceToSquared(scope.object.position) > EPS) {
+            scope.dispatchEvent(_changeEvent);
+            lastPosition.copy(scope.object.position);
+          }
+        } else if (scope.object.isOrthographicCamera) {
+          scope.object.lookAt(scope.target);
+
+          if (lastPosition.distanceToSquared(scope.object.position) > EPS || lastZoom !== scope.object.zoom) {
+            scope.dispatchEvent(_changeEvent);
+            lastPosition.copy(scope.object.position);
+            lastZoom = scope.object.zoom;
+          }
+        } else {
+          console.warn('THREE.TrackballControls: Unsupported camera type');
+        }
+      };
+
+      _this.reset = function () {
+        _state = STATE.NONE;
+        _keyState = STATE.NONE;
+        scope.target.copy(scope.target0);
+        scope.object.position.copy(scope.position0);
+        scope.object.up.copy(scope.up0);
+        scope.object.zoom = scope.zoom0;
+        scope.object.updateProjectionMatrix();
+
+        _eye.subVectors(scope.object.position, scope.target);
+
+        scope.object.lookAt(scope.target);
+        scope.dispatchEvent(_changeEvent);
+        lastPosition.copy(scope.object.position);
+        lastZoom = scope.object.zoom;
+      }; // listeners
+
+
+      function onPointerDown(event) {
+        if (scope.enabled === false) return;
+
+        if (_pointers.length === 0) {
+          scope.domElement.setPointerCapture(event.pointerId);
+          scope.domElement.addEventListener('pointermove', onPointerMove);
+          scope.domElement.addEventListener('pointerup', onPointerUp);
+        } //
+
+
+        addPointer(event);
+
+        if (event.pointerType === 'touch') {
+          onTouchStart(event);
+        } else {
+          onMouseDown(event);
+        }
+      }
+
+      function onPointerMove(event) {
+        if (scope.enabled === false) return;
+
+        if (event.pointerType === 'touch') {
+          onTouchMove(event);
+        } else {
+          onMouseMove(event);
+        }
+      }
+
+      function onPointerUp(event) {
+        if (scope.enabled === false) return;
+
+        if (event.pointerType === 'touch') {
+          onTouchEnd(event);
+        } else {
+          onMouseUp();
+        } //
+
+
+        removePointer(event);
+
+        if (_pointers.length === 0) {
+          scope.domElement.releasePointerCapture(event.pointerId);
+          scope.domElement.removeEventListener('pointermove', onPointerMove);
+          scope.domElement.removeEventListener('pointerup', onPointerUp);
+        }
+      }
+
+      function onPointerCancel(event) {
+        removePointer(event);
+      }
+
+      function keydown(event) {
+        if (scope.enabled === false) return;
+        window.removeEventListener('keydown', keydown);
+
+        if (_keyState !== STATE.NONE) {
+          return;
+        } else if (event.code === scope.keys[STATE.ROTATE] && !scope.noRotate) {
+          _keyState = STATE.ROTATE;
+        } else if (event.code === scope.keys[STATE.ZOOM] && !scope.noZoom) {
+          _keyState = STATE.ZOOM;
+        } else if (event.code === scope.keys[STATE.PAN] && !scope.noPan) {
+          _keyState = STATE.PAN;
+        }
+      }
+
+      function keyup() {
+        if (scope.enabled === false) return;
+        _keyState = STATE.NONE;
+        window.addEventListener('keydown', keydown);
+      }
+
+      function onMouseDown(event) {
+        if (_state === STATE.NONE) {
+          switch (event.button) {
+            case scope.mouseButtons.LEFT:
+              _state = STATE.ROTATE;
+              break;
+
+            case scope.mouseButtons.MIDDLE:
+              _state = STATE.ZOOM;
+              break;
+
+            case scope.mouseButtons.RIGHT:
+              _state = STATE.PAN;
+              break;
+
+            default:
+              _state = STATE.NONE;
+          }
+        }
+
+        var state = _keyState !== STATE.NONE ? _keyState : _state;
+
+        if (state === STATE.ROTATE && !scope.noRotate) {
+          _moveCurr.copy(getMouseOnCircle(event.pageX, event.pageY));
+
+          _movePrev.copy(_moveCurr);
+        } else if (state === STATE.ZOOM && !scope.noZoom) {
+          _zoomStart.copy(getMouseOnScreen(event.pageX, event.pageY));
+
+          _zoomEnd.copy(_zoomStart);
+        } else if (state === STATE.PAN && !scope.noPan) {
+          _panStart.copy(getMouseOnScreen(event.pageX, event.pageY));
+
+          _panEnd.copy(_panStart);
+        }
+
+        scope.dispatchEvent(_startEvent);
+      }
+
+      function onMouseMove(event) {
+        var state = _keyState !== STATE.NONE ? _keyState : _state;
+
+        if (state === STATE.ROTATE && !scope.noRotate) {
+          _movePrev.copy(_moveCurr);
+
+          _moveCurr.copy(getMouseOnCircle(event.pageX, event.pageY));
+        } else if (state === STATE.ZOOM && !scope.noZoom) {
+          _zoomEnd.copy(getMouseOnScreen(event.pageX, event.pageY));
+        } else if (state === STATE.PAN && !scope.noPan) {
+          _panEnd.copy(getMouseOnScreen(event.pageX, event.pageY));
+        }
+      }
+
+      function onMouseUp() {
+        _state = STATE.NONE;
+        scope.dispatchEvent(_endEvent);
+      }
+
+      function onMouseWheel(event) {
+        if (scope.enabled === false) return;
+        if (scope.noZoom === true) return;
+        event.preventDefault();
+
+        switch (event.deltaMode) {
+          case 2:
+            // Zoom in pages
+            _zoomStart.y -= event.deltaY * 0.025;
+            break;
+
+          case 1:
+            // Zoom in lines
+            _zoomStart.y -= event.deltaY * 0.01;
+            break;
+
+          default:
+            // undefined, 0, assume pixels
+            _zoomStart.y -= event.deltaY * 0.00025;
+            break;
+        }
+
+        scope.dispatchEvent(_startEvent);
+        scope.dispatchEvent(_endEvent);
+      }
+
+      function onTouchStart(event) {
+        trackPointer(event);
+
+        switch (_pointers.length) {
+          case 1:
+            _state = STATE.TOUCH_ROTATE;
+
+            _moveCurr.copy(getMouseOnCircle(_pointers[0].pageX, _pointers[0].pageY));
+
+            _movePrev.copy(_moveCurr);
+
+            break;
+
+          default:
+            // 2 or more
+            _state = STATE.TOUCH_ZOOM_PAN;
+            var dx = _pointers[0].pageX - _pointers[1].pageX;
+            var dy = _pointers[0].pageY - _pointers[1].pageY;
+            _touchZoomDistanceEnd = _touchZoomDistanceStart = Math.sqrt(dx * dx + dy * dy);
+            var x = (_pointers[0].pageX + _pointers[1].pageX) / 2;
+            var y = (_pointers[0].pageY + _pointers[1].pageY) / 2;
+
+            _panStart.copy(getMouseOnScreen(x, y));
+
+            _panEnd.copy(_panStart);
+
+            break;
+        }
+
+        scope.dispatchEvent(_startEvent);
+      }
+
+      function onTouchMove(event) {
+        trackPointer(event);
+
+        switch (_pointers.length) {
+          case 1:
+            _movePrev.copy(_moveCurr);
+
+            _moveCurr.copy(getMouseOnCircle(event.pageX, event.pageY));
+
+            break;
+
+          default:
+            // 2 or more
+            var position = getSecondPointerPosition(event);
+            var dx = event.pageX - position.x;
+            var dy = event.pageY - position.y;
+            _touchZoomDistanceEnd = Math.sqrt(dx * dx + dy * dy);
+            var x = (event.pageX + position.x) / 2;
+            var y = (event.pageY + position.y) / 2;
+
+            _panEnd.copy(getMouseOnScreen(x, y));
+
+            break;
+        }
+      }
+
+      function onTouchEnd(event) {
+        switch (_pointers.length) {
+          case 0:
+            _state = STATE.NONE;
+            break;
+
+          case 1:
+            _state = STATE.TOUCH_ROTATE;
+
+            _moveCurr.copy(getMouseOnCircle(event.pageX, event.pageY));
+
+            _movePrev.copy(_moveCurr);
+
+            break;
+
+          case 2:
+            _state = STATE.TOUCH_ZOOM_PAN;
+
+            _moveCurr.copy(getMouseOnCircle(event.pageX - _movePrev.pageX, event.pageY - _movePrev.pageY));
+
+            _movePrev.copy(_moveCurr);
+
+            break;
+        }
+
+        scope.dispatchEvent(_endEvent);
+      }
+
+      function contextmenu(event) {
+        if (scope.enabled === false) return;
+        event.preventDefault();
+      }
+
+      function addPointer(event) {
+        _pointers.push(event);
+      }
+
+      function removePointer(event) {
+        delete _pointerPositions[event.pointerId];
+
+        for (var i = 0; i < _pointers.length; i++) {
+          if (_pointers[i].pointerId == event.pointerId) {
+            _pointers.splice(i, 1);
+
+            return;
+          }
+        }
+      }
+
+      function trackPointer(event) {
+        var position = _pointerPositions[event.pointerId];
+
+        if (position === undefined) {
+          position = new _three.Vector2();
+          _pointerPositions[event.pointerId] = position;
+        }
+
+        position.set(event.pageX, event.pageY);
+      }
+
+      function getSecondPointerPosition(event) {
+        var pointer = event.pointerId === _pointers[0].pointerId ? _pointers[1] : _pointers[0];
+        return _pointerPositions[pointer.pointerId];
+      }
+
+      _this.dispose = function () {
+        scope.domElement.removeEventListener('contextmenu', contextmenu);
+        scope.domElement.removeEventListener('pointerdown', onPointerDown);
+        scope.domElement.removeEventListener('pointercancel', onPointerCancel);
+        scope.domElement.removeEventListener('wheel', onMouseWheel);
+        scope.domElement.removeEventListener('pointermove', onPointerMove);
+        scope.domElement.removeEventListener('pointerup', onPointerUp);
+        window.removeEventListener('keydown', keydown);
+        window.removeEventListener('keyup', keyup);
+      };
+
+      _this.domElement.addEventListener('contextmenu', contextmenu);
+
+      _this.domElement.addEventListener('pointerdown', onPointerDown);
+
+      _this.domElement.addEventListener('pointercancel', onPointerCancel);
+
+      _this.domElement.addEventListener('wheel', onMouseWheel, {
+        passive: false
+      });
+
+      window.addEventListener('keydown', keydown);
+      window.addEventListener('keyup', keyup);
+
+      _this.handleResize(); // force an update at start
+
+
+      _this.update();
+
+      return _this;
+    }
+
+    return _createClass(TrackballControls);
+  }(_three.EventDispatcher);
+
+  _exports.TrackballControls = TrackballControls;
+});