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

package/node_modules/three/examples/jsm/physics/RapierPhysics.js

@@ -1,6 +1,6 @@
 import { Clock, Vector3, Quaternion, Matrix4 } from 'three';
 
-const RAPIER_PATH = 'https://cdn.skypack.dev/@dimforge/rapier3d-compat@0.11.2';
+const RAPIER_PATH = 'https://cdn.skypack.dev/@dimforge/rapier3d-compat@0.17.3';
 
 const frameRate = 60;
 
@@ -9,13 +9,22 @@ const ZERO = new Vector3();
 
 let RAPIER = null;
 
-function getCollider( geometry ) {
+function getShape( geometry ) {
 
 	const parameters = geometry.parameters;
 
 	// TODO change type to is*
 
-	if ( geometry.type === 'BoxGeometry' ) {
+	if ( geometry.type === 'RoundedBoxGeometry' ) {
+
+		const sx = parameters.width !== undefined ? parameters.width / 2 : 0.5;
+		const sy = parameters.height !== undefined ? parameters.height / 2 : 0.5;
+		const sz = parameters.depth !== undefined ? parameters.depth / 2 : 0.5;
+		const radius = parameters.radius !== undefined ? parameters.radius : 0.1;
+
+		return RAPIER.ColliderDesc.roundCuboid( sx - radius, sy - radius, sz - radius, radius );
+
+	} else if ( geometry.type === 'BoxGeometry' ) {
 
 		const sx = parameters.width !== undefined ? parameters.width / 2 : 0.5;
 		const sy = parameters.height !== undefined ? parameters.height / 2 : 0.5;
@@ -28,22 +37,70 @@ function getCollider( geometry ) {
 		const radius = parameters.radius !== undefined ? parameters.radius : 1;
 		return RAPIER.ColliderDesc.ball( radius );
 
+	} else if ( geometry.type === 'CylinderGeometry' ) {
+
+		const radius = parameters.radiusBottom !== undefined ? parameters.radiusBottom : 0.5;
+		const length = parameters.height !== undefined ? parameters.height : 0.5;
+
+		return RAPIER.ColliderDesc.cylinder( length / 2, radius );
+
+	} else if ( geometry.type === 'CapsuleGeometry' ) {
+
+		const radius = parameters.radius !== undefined ? parameters.radius : 0.5;
+		const length = parameters.height !== undefined ? parameters.height : 0.5;
+
+		return RAPIER.ColliderDesc.capsule( length / 2, radius );
+
+	} else if ( geometry.type === 'BufferGeometry' ) {
+
+		const vertices = [];
+		const vertex = new Vector3();
+		const position = geometry.getAttribute( 'position' );
+
+		for ( let i = 0; i < position.count; i ++ ) {
+
+			vertex.fromBufferAttribute( position, i );
+			vertices.push( vertex.x, vertex.y, vertex.z );
+
+		}
+
+		// if the buffer is non-indexed, generate an index buffer
+		const indices = geometry.getIndex() === null
+			? Uint32Array.from( Array( parseInt( vertices.length / 3 ) ).keys() )
+			: geometry.getIndex().array;
+
+		return RAPIER.ColliderDesc.trimesh( vertices, indices );
+
 	}
 
 	return null;
 
 }
 
+/**
+ * @classdesc Can be used to include Rapier as a Physics engine into
+ * `three.js` apps. The API can be initialized via:
+ * ```js
+ * const physics = await RapierPhysics();
+ * ```
+ * The component automatically imports Rapier from a CDN so make sure
+ * to use the component with an active Internet connection.
+ *
+ * @name RapierPhysics
+ * @class
+ * @hideconstructor
+ * @three_import import { RapierPhysics } from 'three/addons/physics/RapierPhysics.js';
+ */
 async function RapierPhysics() {
 
 	if ( RAPIER === null ) {
 
-		RAPIER = await import( RAPIER_PATH );
+		RAPIER = await import( `${RAPIER_PATH}` );
 		await RAPIER.init();
 
 	}
 
-	// Docs: https://rapier.rs/docs/api/javascript/JavaScript3D/	
+	// Docs: https://rapier.rs/docs/api/javascript/JavaScript3D/
 
 	const gravity = new Vector3( 0.0, - 9.81, 0.0 );
 	const world = new RAPIER.World( gravity );
@@ -77,21 +134,47 @@ async function RapierPhysics() {
 
 	function addMesh( mesh, mass = 0, restitution = 0 ) {
 
-		const shape = getCollider( mesh.geometry );
+		const shape = getShape( mesh.geometry );
 
 		if ( shape === null ) return;
 
 		shape.setMass( mass );
 		shape.setRestitution( restitution );
 
-		const body = mesh.isInstancedMesh
-							? createInstancedBody( mesh, mass, shape )
-							: createBody( mesh.position, mesh.quaternion, mass, shape );
+		const { body, collider } = mesh.isInstancedMesh
+			? createInstancedBody( mesh, mass, shape )
+			: createBody( mesh.position, mesh.quaternion, mass, shape );
+
+		if ( ! mesh.userData.physics ) mesh.userData.physics = {};
+
+		mesh.userData.physics.body = body;
+		mesh.userData.physics.collider = collider;
 
 		if ( mass > 0 ) {
 
 			meshes.push( mesh );
-			meshMap.set( mesh, body );
+			meshMap.set( mesh, { body, collider } );
+
+		}
+
+	}
+
+	function removeMesh( mesh ) {
+
+		const index = meshes.indexOf( mesh );
+
+		if ( index !== - 1 ) {
+
+			meshes.splice( index, 1 );
+			meshMap.delete( mesh );
+
+			if ( ! mesh.userData.physics ) return;
+
+			const body = mesh.userData.physics.body;
+			const collider = mesh.userData.physics.collider;
+
+			if ( body ) removeBody( body );
+			if ( collider ) removeCollider( collider );
 
 		}
 
@@ -102,15 +185,18 @@ async function RapierPhysics() {
 		const array = mesh.instanceMatrix.array;
 
 		const bodies = [];
+		const colliders = [];
 
 		for ( let i = 0; i < mesh.count; i ++ ) {
 
 			const position = _vector.fromArray( array, i * 16 + 12 );
-			bodies.push( createBody( position, null, mass, shape ) );
+			const { body, collider } = createBody( position, null, mass, shape );
+			bodies.push( body );
+			colliders.push( collider );
 
 		}
 
-		return bodies;
+		return { body: bodies, collider: colliders };
 
 	}
 
@@ -121,15 +207,51 @@ async function RapierPhysics() {
 		if ( quaternion !== null ) desc.setRotation( quaternion );
 
 		const body = world.createRigidBody( desc );
-		world.createCollider( shape, body );
+		const collider = world.createCollider( shape, body );
 
-		return body;
+		return { body, collider };
+
+	}
+
+	function removeBody( body ) {
+
+		if ( Array.isArray( body ) ) {
+
+			for ( let i = 0; i < body.length; i ++ ) {
+
+				world.removeRigidBody( body[ i ] );
+
+			}
+
+		} else {
+
+			world.removeRigidBody( body );
+
+		}
+
+	}
+
+	function removeCollider( collider ) {
+
+		if ( Array.isArray( collider ) ) {
+
+			for ( let i = 0; i < collider.length; i ++ ) {
+
+				world.removeCollider( collider[ i ] );
+
+			}
+
+		} else {
+
+			world.removeCollider( collider );
+
+		}
 
 	}
 
 	function setMeshPosition( mesh, position, index = 0 ) {
 
-		let body = meshMap.get( mesh );
+		let { body } = meshMap.get( mesh );
 
 		if ( mesh.isInstancedMesh ) {
 
@@ -145,7 +267,7 @@ async function RapierPhysics() {
 
 	function setMeshVelocity( mesh, velocity, index = 0 ) {
 
-		let body = meshMap.get( mesh );
+		let { body } = meshMap.get( mesh );
 
 		if ( mesh.isInstancedMesh ) {
 
@@ -157,6 +279,24 @@ async function RapierPhysics() {
 
 	}
 
+	function addHeightfield( mesh, width, depth, heights, scale ) {
+
+		const shape = RAPIER.ColliderDesc.heightfield( width, depth, heights, scale );
+
+		const bodyDesc = RAPIER.RigidBodyDesc.fixed();
+		bodyDesc.setTranslation( mesh.position.x, mesh.position.y, mesh.position.z );
+		bodyDesc.setRotation( mesh.quaternion );
+
+		const body = world.createRigidBody( bodyDesc );
+		world.createCollider( shape, body );
+
+		if ( ! mesh.userData.physics ) mesh.userData.physics = {};
+		mesh.userData.physics.body = body;
+
+		return body;
+
+	}
+
 	//
 
 	const clock = new Clock();
@@ -175,7 +315,7 @@ async function RapierPhysics() {
 			if ( mesh.isInstancedMesh ) {
 
 				const array = mesh.instanceMatrix.array;
-				const bodies = meshMap.get( mesh );
+				const { body: bodies } = meshMap.get( mesh );
 
 				for ( let j = 0; j < bodies.length; j ++ ) {
 
@@ -193,7 +333,7 @@ async function RapierPhysics() {
 
 			} else {
 
-				const body = meshMap.get( mesh );
+				const { body } = meshMap.get( mesh );
 
 				mesh.position.copy( body.translation() );
 				mesh.quaternion.copy( body.rotation() );
@@ -209,10 +349,82 @@ async function RapierPhysics() {
 	setInterval( step, 1000 / frameRate );
 
 	return {
+		RAPIER,
+		world,
+		/**
+		 * Adds the given scene to this physics simulation. Only meshes with a
+		 * `physics` object in their {@link Object3D#userData} field will be honored.
+		 * The object can be used to store the mass and restitution of the mesh. E.g.:
+		 * ```js
+		 * box.userData.physics = { mass: 1, restitution: 0 };
+		 * ```
+		 *
+		 * @method
+		 * @name RapierPhysics#addScene
+		 * @param {Object3D} scene The scene or any type of 3D object to add.
+		 */
 		addScene: addScene,
+
+		/**
+		 * Adds the given mesh to this physics simulation.
+		 *
+		 * @method
+		 * @name RapierPhysics#addMesh
+		 * @param {Mesh} mesh The mesh to add.
+		 * @param {number} [mass=0] The mass in kg of the mesh.
+		 * @param {number} [restitution=0] The restitution/friction of the mesh.
+		 */
 		addMesh: addMesh,
+
+		/**
+		 * Removes the given mesh from this physics simulation.
+		 *
+		 * @method
+		 * @name RapierPhysics#removeMesh
+		 * @param {Mesh} mesh The mesh to remove.
+		 */
+		removeMesh: removeMesh,
+
+		/**
+		 * Set the position of the given mesh which is part of the physics simulation. Calling this
+		 * method will reset the current simulated velocity of the mesh.
+		 *
+		 * @method
+		 * @name RapierPhysics#setMeshPosition
+		 * @param {Mesh} mesh The mesh to update the position for.
+		 * @param {Vector3} position - The new position.
+		 * @param {number} [index=0] - If the mesh is instanced, the index represents the instanced ID.
+		 */
 		setMeshPosition: setMeshPosition,
-		setMeshVelocity: setMeshVelocity
+
+		/**
+		 * Set the velocity of the given mesh which is part of the physics simulation.
+		 *
+		 * @method
+		 * @name RapierPhysics#setMeshVelocity
+		 * @param {Mesh} mesh The mesh to update the velocity for.
+		 * @param {Vector3} velocity - The new velocity.
+		 * @param {number} [index=0] - If the mesh is instanced, the index represents the instanced ID.
+		 */
+		setMeshVelocity: setMeshVelocity,
+
+		/**
+		 * Adds a heightfield terrain to the physics simulation.
+		 * 
+		 * @method
+		 * @name RapierPhysics#addHeightfield
+		 * @param {Mesh} mesh - The Three.js mesh representing the terrain.
+		 * @param {number} width - The number of vertices along the width (x-axis) of the heightfield.
+		 * @param {number} depth - The number of vertices along the depth (z-axis) of the heightfield.
+		 * @param {Float32Array} heights - Array of height values for each vertex in the heightfield.
+		 * @param {Object} scale - Scale factors for the heightfield dimensions.
+		 * @param {number} scale.x - Scale factor for width.
+		 * @param {number} scale.y - Scale factor for height.
+		 * @param {number} scale.z - Scale factor for depth.
+		 * @returns {RigidBody} The created Rapier rigid body for the heightfield.
+		 */
+		addHeightfield: addHeightfield
+
 	};
 
 }

package/node_modules/three/examples/jsm/postprocessing/AfterimagePass.js

@@ -1,65 +1,136 @@
 import {
 	HalfFloatType,
-	MeshBasicMaterial,
 	NearestFilter,
+	NoBlending,
 	ShaderMaterial,
 	UniformsUtils,
 	WebGLRenderTarget
 } from 'three';
 import { Pass, FullScreenQuad } from './Pass.js';
+import { CopyShader } from '../shaders/CopyShader.js';
 import { AfterimageShader } from '../shaders/AfterimageShader.js';
 
+/**
+ * Pass for a basic after image effect.
+ *
+ * ```js
+ * const afterimagePass = new AfterimagePass( 0.9 );
+ * composer.addPass( afterimagePass );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { AfterimagePass } from 'three/addons/postprocessing/AfterimagePass.js';
+ */
 class AfterimagePass extends Pass {
 
+	/**
+	 * Constructs a new after image pass.
+	 *
+	 * @param {number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
+	 */
 	constructor( damp = 0.96 ) {
 
 		super();
 
-		this.shader = AfterimageShader;
+		/**
+		 * The pass uniforms. Use this object if you want to update the
+		 * `damp` value at runtime.
+		 * ```js
+		 * pass.uniforms.damp.value = 0.9;
+		 * ```
+		 *
+		 * @type {Object}
+		 */
+		this.uniforms = UniformsUtils.clone( AfterimageShader.uniforms );
+
+		this.damp = damp;
+
+		/**
+		 * The composition material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.compFsMaterial = new ShaderMaterial( {
 
-		this.uniforms = UniformsUtils.clone( this.shader.uniforms );
+			uniforms: this.uniforms,
+			vertexShader: AfterimageShader.vertexShader,
+			fragmentShader: AfterimageShader.fragmentShader
 
-		this.uniforms[ 'damp' ].value = damp;
+		} );
 
-		this.textureComp = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
+		/**
+		 * The copy material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.copyFsMaterial = new ShaderMaterial( {
+			uniforms: UniformsUtils.clone( CopyShader.uniforms ),
+			vertexShader: CopyShader.vertexShader,
+			fragmentShader: CopyShader.fragmentShader,
+			blending: NoBlending,
+			depthTest: false,
+			depthWrite: false
+		} );
+
+		// internals
+
+		this._textureComp = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
 			magFilter: NearestFilter,
 			type: HalfFloatType
 		} );
 
-		this.textureOld = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
+		this._textureOld = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
 			magFilter: NearestFilter,
 			type: HalfFloatType
 		} );
 
-		this.compFsMaterial = new ShaderMaterial( {
+		this._compFsQuad = new FullScreenQuad( this.compFsMaterial );
+		this._copyFsQuad = new FullScreenQuad( this.copyFsMaterial );
 
-			uniforms: this.uniforms,
-			vertexShader: this.shader.vertexShader,
-			fragmentShader: this.shader.fragmentShader
+	}
 
-		} );
+	/**
+	 * The damping intensity, from 0.0 to 1.0. A higher value means a stronger after image effect.
+	 *
+	 * @type {number}
+	 */
+	get damp() {
+
+		return this.uniforms[ 'damp' ].value;
+
+	}
 
-		this.compFsQuad = new FullScreenQuad( this.compFsMaterial );
+	set damp( value ) {
 
-		this.copyFsMaterial = new MeshBasicMaterial();
-		this.copyFsQuad = new FullScreenQuad( this.copyFsMaterial );
+		this.uniforms[ 'damp' ].value = value;
 
 	}
 
+	/**
+	 * Performs the after image pass.
+	 *
+	 * @param {WebGLRenderer} renderer - The renderer.
+	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
+	 * destination for the pass.
+	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
+	 * previous pass from this buffer.
+	 * @param {number} deltaTime - The delta time in seconds.
+	 * @param {boolean} maskActive - Whether masking is active or not.
+	 */
 	render( renderer, writeBuffer, readBuffer/*, deltaTime, maskActive*/ ) {
 
-		this.uniforms[ 'tOld' ].value = this.textureOld.texture;
+		this.uniforms[ 'tOld' ].value = this._textureOld.texture;
 		this.uniforms[ 'tNew' ].value = readBuffer.texture;
 
-		renderer.setRenderTarget( this.textureComp );
-		this.compFsQuad.render( renderer );
+		renderer.setRenderTarget( this._textureComp );
+		this._compFsQuad.render( renderer );
 
-		this.copyFsQuad.material.map = this.textureComp.texture;
+		this._copyFsQuad.material.uniforms.tDiffuse.value = this._textureComp.texture;
 
 		if ( this.renderToScreen ) {
 
 			renderer.setRenderTarget( null );
-			this.copyFsQuad.render( renderer );
+			this._copyFsQuad.render( renderer );
 
 		} else {
 
@@ -67,35 +138,45 @@ class AfterimagePass extends Pass {
 
 			if ( this.clear ) renderer.clear();
 
-			this.copyFsQuad.render( renderer );
+			this._copyFsQuad.render( renderer );
 
 		}
 
 		// Swap buffers.
-		const temp = this.textureOld;
-		this.textureOld = this.textureComp;
-		this.textureComp = temp;
+		const temp = this._textureOld;
+		this._textureOld = this._textureComp;
+		this._textureComp = temp;
 		// Now textureOld contains the latest image, ready for the next frame.
 
 	}
 
+	/**
+	 * Sets the size of the pass.
+	 *
+	 * @param {number} width - The width to set.
+	 * @param {number} height - The height to set.
+	 */
 	setSize( width, height ) {
 
-		this.textureComp.setSize( width, height );
-		this.textureOld.setSize( width, height );
+		this._textureComp.setSize( width, height );
+		this._textureOld.setSize( width, height );
 
 	}
 
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever the pass is no longer used in your app.
+	 */
 	dispose() {
 
-		this.textureComp.dispose();
-		this.textureOld.dispose();
+		this._textureComp.dispose();
+		this._textureOld.dispose();
 
 		this.compFsMaterial.dispose();
 		this.copyFsMaterial.dispose();
 
-		this.compFsQuad.dispose();
-		this.copyFsQuad.dispose();
+		this._compFsQuad.dispose();
+		this._copyFsQuad.dispose();
 
 	}