npm - @playdrop/playdrop-cli - Versions diffs - 0.3.5-build.1 → 0.3.8-build.2 - Mend

@playdrop/playdrop-cli 0.3.5-build.1 → 0.3.8-build.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1288) hide show

package/node_modules/three/examples/jsm/controls/FlyControls.js CHANGED Viewed

@@ -1,325 +1,379 @@
 import {
-	EventDispatcher,
+	Controls,
 	Quaternion,
 	Vector3
 } from 'three';
+/**
+ * Fires when the camera has been transformed by the controls.
+ *
+ * @event FlyControls#change
+ * @type {Object}
+ */
 const _changeEvent = { type: 'change' };
-class FlyControls extends EventDispatcher {
+const _EPS = 0.000001;
+const _tmpQuaternion = new Quaternion();
+/**
+ * This class enables a navigation similar to fly modes in DCC tools like Blender.
+ * You can arbitrarily transform the camera in 3D space without any limitations
+ * (e.g. focus on a specific target).
+ *
+ * @augments Controls
+ * @three_import import { FlyControls } from 'three/addons/controls/FlyControls.js';
+ */
+class FlyControls extends Controls {
+	/**
+	 * Constructs a new controls instance.
+	 *
+	 * @param {Object3D} object - The object that is managed by the controls.
+	 * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+	 */
+	constructor( object, domElement = null ) {
+		super( object, domElement );
+		/**
+		 * The movement speed.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.movementSpeed = 1.0;
-	constructor( object, domElement ) {
+		/**
+		 * The rotation speed.
+		 *
+		 * @type {number}
+		 * @default 0.005
+		 */
+		this.rollSpeed = 0.005;
-		super();
+		/**
+		 * If set to `true`, you can only look around by performing a drag interaction.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.dragToLook = false;
-		this.object = object;
-		this.domElement = domElement;
+		/**
+		 * If set to `true`, the camera automatically moves forward (and does not stop) when initially translated.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.autoForward = false;
-		// API
+		// internals
-		// Set to false to disable this control
-		this.enabled = true;
+		this._moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 };
+		this._moveVector = new Vector3( 0, 0, 0 );
+		this._rotationVector = new Vector3( 0, 0, 0 );
+		this._lastQuaternion = new Quaternion();
+		this._lastPosition = new Vector3();
+		this._status = 0;
-		this.movementSpeed = 1.0;
-		this.rollSpeed = 0.005;
+		// event listeners
-		this.dragToLook = false;
-		this.autoForward = false;
+		this._onKeyDown = onKeyDown.bind( this );
+		this._onKeyUp = onKeyUp.bind( this );
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
-		// disable default target object behavior
+		//
-		// internals
+		if ( domElement !== null ) {
-		const scope = this;
+			this.connect( domElement );
-		const EPS = 0.000001;
+		}
-		const lastQuaternion = new Quaternion();
-		const lastPosition = new Vector3();
+	}
-		this.tmpQuaternion = new Quaternion();
+	connect( element ) {
-		this.status = 0;
+		super.connect( element );
-		this.moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 };
-		this.moveVector = new Vector3( 0, 0, 0 );
-		this.rotationVector = new Vector3( 0, 0, 0 );
+		window.addEventListener( 'keydown', this._onKeyDown );
+		window.addEventListener( 'keyup', this._onKeyUp );
-		this.keydown = function ( event ) {
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
-			if ( event.altKey || this.enabled === false ) {
+	}
-				return;
+	disconnect() {
-			}
+		window.removeEventListener( 'keydown', this._onKeyDown );
+		window.removeEventListener( 'keyup', this._onKeyUp );
-			switch ( event.code ) {
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
-				case 'ShiftLeft':
-				case 'ShiftRight': this.movementSpeedMultiplier = .1; break;
+	}
-				case 'KeyW': this.moveState.forward = 1; break;
-				case 'KeyS': this.moveState.back = 1; break;
+	dispose() {
-				case 'KeyA': this.moveState.left = 1; break;
-				case 'KeyD': this.moveState.right = 1; break;
+		this.disconnect();
-				case 'KeyR': this.moveState.up = 1; break;
-				case 'KeyF': this.moveState.down = 1; break;
+	}
-				case 'ArrowUp': this.moveState.pitchUp = 1; break;
-				case 'ArrowDown': this.moveState.pitchDown = 1; break;
+	update( delta ) {
-				case 'ArrowLeft': this.moveState.yawLeft = 1; break;
-				case 'ArrowRight': this.moveState.yawRight = 1; break;
+		if ( this.enabled === false ) return;
-				case 'KeyQ': this.moveState.rollLeft = 1; break;
-				case 'KeyE': this.moveState.rollRight = 1; break;
+		const object = this.object;
-			}
+		const moveMult = delta * this.movementSpeed;
+		const rotMult = delta * this.rollSpeed;
-			this.updateMovementVector();
-			this.updateRotationVector();
+		object.translateX( this._moveVector.x * moveMult );
+		object.translateY( this._moveVector.y * moveMult );
+		object.translateZ( this._moveVector.z * moveMult );
-		};
+		_tmpQuaternion.set( this._rotationVector.x * rotMult, this._rotationVector.y * rotMult, this._rotationVector.z * rotMult, 1 ).normalize();
+		object.quaternion.multiply( _tmpQuaternion );
-		this.keyup = function ( event ) {
+		if (
+			this._lastPosition.distanceToSquared( object.position ) > _EPS ||
+			8 * ( 1 - this._lastQuaternion.dot( object.quaternion ) ) > _EPS
+		) {
-			if ( this.enabled === false ) return;
+			this.dispatchEvent( _changeEvent );
+			this._lastQuaternion.copy( object.quaternion );
+			this._lastPosition.copy( object.position );
-			switch ( event.code ) {
+		}
-				case 'ShiftLeft':
-				case 'ShiftRight': this.movementSpeedMultiplier = 1; break;
+	}
-				case 'KeyW': this.moveState.forward = 0; break;
-				case 'KeyS': this.moveState.back = 0; break;
+	// private
-				case 'KeyA': this.moveState.left = 0; break;
-				case 'KeyD': this.moveState.right = 0; break;
+	_updateMovementVector() {
-				case 'KeyR': this.moveState.up = 0; break;
-				case 'KeyF': this.moveState.down = 0; break;
+		const forward = ( this._moveState.forward || ( this.autoForward && ! this._moveState.back ) ) ? 1 : 0;
-				case 'ArrowUp': this.moveState.pitchUp = 0; break;
-				case 'ArrowDown': this.moveState.pitchDown = 0; break;
+		this._moveVector.x = ( - this._moveState.left + this._moveState.right );
+		this._moveVector.y = ( - this._moveState.down + this._moveState.up );
+		this._moveVector.z = ( - forward + this._moveState.back );
-				case 'ArrowLeft': this.moveState.yawLeft = 0; break;
-				case 'ArrowRight': this.moveState.yawRight = 0; break;
+		//console.log( 'move:', [ this._moveVector.x, this._moveVector.y, this._moveVector.z ] );
-				case 'KeyQ': this.moveState.rollLeft = 0; break;
-				case 'KeyE': this.moveState.rollRight = 0; break;
+	}
-			}
+	_updateRotationVector() {
-			this.updateMovementVector();
-			this.updateRotationVector();
+		this._rotationVector.x = ( - this._moveState.pitchDown + this._moveState.pitchUp );
+		this._rotationVector.y = ( - this._moveState.yawRight + this._moveState.yawLeft );
+		this._rotationVector.z = ( - this._moveState.rollRight + this._moveState.rollLeft );
-		};
+		//console.log( 'rotate:', [ this._rotationVector.x, this._rotationVector.y, this._rotationVector.z ] );
-		this.pointerdown = function ( event ) {
+	}
-			if ( this.enabled === false ) return;
+	_getContainerDimensions() {
-			if ( this.dragToLook ) {
+		if ( this.domElement != document ) {
-				this.status ++;
+			return {
+				size: [ this.domElement.offsetWidth, this.domElement.offsetHeight ],
+				offset: [ this.domElement.offsetLeft, this.domElement.offsetTop ]
+			};
-			} else {
+		} else {
-				switch ( event.button ) {
+			return {
+				size: [ window.innerWidth, window.innerHeight ],
+				offset: [ 0, 0 ]
+			};
-					case 0: this.moveState.forward = 1; break;
-					case 2: this.moveState.back = 1; break;
+		}
-				}
+	}
-				this.updateMovementVector();
+}
-			}
+function onKeyDown( event ) {
-		};
+	if ( event.altKey || this.enabled === false ) {
-		this.pointermove = function ( event ) {
+		return;
-			if ( this.enabled === false ) return;
+	}
-			if ( ! this.dragToLook || this.status > 0 ) {
+	switch ( event.code ) {
-				const container = this.getContainerDimensions();
-				const halfWidth = container.size[ 0 ] / 2;
-				const halfHeight = container.size[ 1 ] / 2;
+		case 'ShiftLeft':
+		case 'ShiftRight': this.movementSpeedMultiplier = .1; break;
-				this.moveState.yawLeft = - ( ( event.pageX - container.offset[ 0 ] ) - halfWidth ) / halfWidth;
-				this.moveState.pitchDown = ( ( event.pageY - container.offset[ 1 ] ) - halfHeight ) / halfHeight;
+		case 'KeyW': this._moveState.forward = 1; break;
+		case 'KeyS': this._moveState.back = 1; break;
-				this.updateRotationVector();
+		case 'KeyA': this._moveState.left = 1; break;
+		case 'KeyD': this._moveState.right = 1; break;
-			}
+		case 'KeyR': this._moveState.up = 1; break;
+		case 'KeyF': this._moveState.down = 1; break;
-		};
+		case 'ArrowUp': this._moveState.pitchUp = 1; break;
+		case 'ArrowDown': this._moveState.pitchDown = 1; break;
-		this.pointerup = function ( event ) {
+		case 'ArrowLeft': this._moveState.yawLeft = 1; break;
+		case 'ArrowRight': this._moveState.yawRight = 1; break;
-			if ( this.enabled === false ) return;
+		case 'KeyQ': this._moveState.rollLeft = 1; break;
+		case 'KeyE': this._moveState.rollRight = 1; break;
-			if ( this.dragToLook ) {
+	}
-				this.status --;
+	this._updateMovementVector();
+	this._updateRotationVector();
-				this.moveState.yawLeft = this.moveState.pitchDown = 0;
+}
-			} else {
+function onKeyUp( event ) {
-				switch ( event.button ) {
+	if ( this.enabled === false ) return;
-					case 0: this.moveState.forward = 0; break;
-					case 2: this.moveState.back = 0; break;
+	switch ( event.code ) {
-				}
+		case 'ShiftLeft':
+		case 'ShiftRight': this.movementSpeedMultiplier = 1; break;
-				this.updateMovementVector();
+		case 'KeyW': this._moveState.forward = 0; break;
+		case 'KeyS': this._moveState.back = 0; break;
-			}
+		case 'KeyA': this._moveState.left = 0; break;
+		case 'KeyD': this._moveState.right = 0; break;
-			this.updateRotationVector();
+		case 'KeyR': this._moveState.up = 0; break;
+		case 'KeyF': this._moveState.down = 0; break;
-		};
+		case 'ArrowUp': this._moveState.pitchUp = 0; break;
+		case 'ArrowDown': this._moveState.pitchDown = 0; break;
-		this.pointercancel = function () {
+		case 'ArrowLeft': this._moveState.yawLeft = 0; break;
+		case 'ArrowRight': this._moveState.yawRight = 0; break;
-			if ( this.enabled === false ) return;
+		case 'KeyQ': this._moveState.rollLeft = 0; break;
+		case 'KeyE': this._moveState.rollRight = 0; break;
-			if ( this.dragToLook ) {
+	}
-				this.status = 0;
+	this._updateMovementVector();
+	this._updateRotationVector();
-				this.moveState.yawLeft = this.moveState.pitchDown = 0;
+}
-			} else {
+function onPointerDown( event ) {
-				this.moveState.forward = 0;
-				this.moveState.back = 0;
+	if ( this.enabled === false ) return;
-				this.updateMovementVector();
+	if ( this.dragToLook ) {
-			}
+		this._status ++;
-			this.updateRotationVector();
+	} else {
-		};
+		switch ( event.button ) {
-		this.contextMenu = function ( event ) {
+			case 0: this._moveState.forward = 1; break;
+			case 2: this._moveState.back = 1; break;
-			if ( this.enabled === false ) return;
+		}
-			event.preventDefault();
+		this._updateMovementVector();
-		};
+	}
-		this.update = function ( delta ) {
+}
-			if ( this.enabled === false ) return;
+function onPointerMove( event ) {
-			const moveMult = delta * scope.movementSpeed;
-			const rotMult = delta * scope.rollSpeed;
+	if ( this.enabled === false ) return;
-			scope.object.translateX( scope.moveVector.x * moveMult );
-			scope.object.translateY( scope.moveVector.y * moveMult );
-			scope.object.translateZ( scope.moveVector.z * moveMult );
+	if ( ! this.dragToLook || this._status > 0 ) {
-			scope.tmpQuaternion.set( scope.rotationVector.x * rotMult, scope.rotationVector.y * rotMult, scope.rotationVector.z * rotMult, 1 ).normalize();
-			scope.object.quaternion.multiply( scope.tmpQuaternion );
+		const container = this._getContainerDimensions();
+		const halfWidth = container.size[ 0 ] / 2;
+		const halfHeight = container.size[ 1 ] / 2;
-			if (
-				lastPosition.distanceToSquared( scope.object.position ) > EPS ||
-				8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS
-			) {
+		this._moveState.yawLeft = - ( ( event.pageX - container.offset[ 0 ] ) - halfWidth ) / halfWidth;
+		this._moveState.pitchDown = ( ( event.pageY - container.offset[ 1 ] ) - halfHeight ) / halfHeight;
-				scope.dispatchEvent( _changeEvent );
-				lastQuaternion.copy( scope.object.quaternion );
-				lastPosition.copy( scope.object.position );
+		this._updateRotationVector();
-			}
+	}
-		};
+}
+function onPointerUp( event ) {
-		this.updateMovementVector = function () {
+	if ( this.enabled === false ) return;
-			const forward = ( this.moveState.forward || ( this.autoForward && ! this.moveState.back ) ) ? 1 : 0;
+	if ( this.dragToLook ) {
-			this.moveVector.x = ( - this.moveState.left + this.moveState.right );
-			this.moveVector.y = ( - this.moveState.down + this.moveState.up );
-			this.moveVector.z = ( - forward + this.moveState.back );
+		this._status --;
-			//console.log( 'move:', [ this.moveVector.x, this.moveVector.y, this.moveVector.z ] );
+		this._moveState.yawLeft = this._moveState.pitchDown = 0;
-		};
+	} else {
-		this.updateRotationVector = function () {
+		switch ( event.button ) {
-			this.rotationVector.x = ( - this.moveState.pitchDown + this.moveState.pitchUp );
-			this.rotationVector.y = ( - this.moveState.yawRight + this.moveState.yawLeft );
-			this.rotationVector.z = ( - this.moveState.rollRight + this.moveState.rollLeft );
+			case 0: this._moveState.forward = 0; break;
+			case 2: this._moveState.back = 0; break;
-			//console.log( 'rotate:', [ this.rotationVector.x, this.rotationVector.y, this.rotationVector.z ] );
+		}
-		};
+		this._updateMovementVector();
+	}
-		this.getContainerDimensions = function () {
+	this._updateRotationVector();
-			if ( this.domElement != document ) {
+}
-				return {
-					size: [ this.domElement.offsetWidth, this.domElement.offsetHeight ],
-					offset: [ this.domElement.offsetLeft, this.domElement.offsetTop ]
-				};
+function onPointerCancel() {
-			} else {
+	if ( this.enabled === false ) return;
-				return {
-					size: [ window.innerWidth, window.innerHeight ],
-					offset: [ 0, 0 ]
-				};
+	if ( this.dragToLook ) {
-			}
+		this._status = 0;
-		};
+		this._moveState.yawLeft = this._moveState.pitchDown = 0;
-		this.dispose = function () {
+	} else {
-			this.domElement.removeEventListener( 'contextmenu', _contextmenu );
-			this.domElement.removeEventListener( 'pointerdown', _pointerdown );
-			this.domElement.removeEventListener( 'pointermove', _pointermove );
-			this.domElement.removeEventListener( 'pointerup', _pointerup );
-			this.domElement.removeEventListener( 'pointercancel', _pointercancel );
+		this._moveState.forward = 0;
+		this._moveState.back = 0;
-			window.removeEventListener( 'keydown', _keydown );
-			window.removeEventListener( 'keyup', _keyup );
+		this._updateMovementVector();
-		};
+	}
-		const _contextmenu = this.contextMenu.bind( this );
-		const _pointermove = this.pointermove.bind( this );
-		const _pointerdown = this.pointerdown.bind( this );
-		const _pointerup = this.pointerup.bind( this );
-		const _pointercancel = this.pointercancel.bind( this );
-		const _keydown = this.keydown.bind( this );
-		const _keyup = this.keyup.bind( this );
+	this._updateRotationVector();
-		this.domElement.addEventListener( 'contextmenu', _contextmenu );
-		this.domElement.addEventListener( 'pointerdown', _pointerdown );
-		this.domElement.addEventListener( 'pointermove', _pointermove );
-		this.domElement.addEventListener( 'pointerup', _pointerup );
-		this.domElement.addEventListener( 'pointercancel', _pointercancel );
+}
-		window.addEventListener( 'keydown', _keydown );
-		window.addEventListener( 'keyup', _keyup );
+function onContextMenu( event ) {
-		this.updateMovementVector();
-		this.updateRotationVector();
+	if ( this.enabled === false ) return;
-	}
+	event.preventDefault();
 }

package/node_modules/three/examples/jsm/controls/MapControls.js CHANGED Viewed

@@ -2,23 +2,57 @@ import { MOUSE, TOUCH } from 'three';
 import { OrbitControls } from './OrbitControls.js';
-// MapControls performs orbiting, dollying (zooming), and panning.
-// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
-//
-//    Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate
-//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
-//    Pan - left mouse, or arrow keys / touch: one-finger move
+/**
+ * This class is intended for transforming a camera over a map from bird's eye perspective.
+ * The class shares its implementation with {@link OrbitControls} but uses a specific preset
+ * for mouse/touch interaction and disables screen space panning by default.
+ *
+ * - Orbit: Right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate.
+ * - Zoom: Middle mouse, or mousewheel / touch: two-finger spread or squish.
+ * - Pan: Left mouse, or arrow keys / touch: one-finger move.
+ *
+ * @augments OrbitControls
+ * @three_import import { MapControls } from 'three/addons/controls/MapControls.js';
+ */
 class MapControls extends OrbitControls {
 	constructor( object, domElement ) {
 		super( object, domElement );
-		this.screenSpacePanning = false; // pan orthogonal to world-space direction camera.up
+		/**
+		 * Overwritten and set to `false` to pan orthogonal to world-space direction `camera.up`.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.screenSpacePanning = false;
+		/**
+		 * This object contains references to the mouse actions used by the controls.
+		 *
+		 * ```js
+		 * controls.mouseButtons = {
+		 * 	LEFT: THREE.MOUSE.PAN,
+		 * 	MIDDLE: THREE.MOUSE.DOLLY,
+		 * 	RIGHT: THREE.MOUSE.ROTATE
+		 * }
+		 * ```
+		 * @type {Object}
+		 */
 		this.mouseButtons = { LEFT: MOUSE.PAN, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.ROTATE };
+		/**
+		 * This object contains references to the touch actions used by the controls.
+		 *
+		 * ```js
+		 * controls.mouseButtons = {
+		 * 	ONE: THREE.TOUCH.PAN,
+		 * 	TWO: THREE.TOUCH.DOLLY_ROTATE
+		 * }
+		 * ```
+		 * @type {Object}
+		 */
 		this.touches = { ONE: TOUCH.PAN, TWO: TOUCH.DOLLY_ROTATE };
 	}