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

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

@@ -9,25 +9,48 @@ import {
 import { Pass, FullScreenQuad } from './Pass.js';
 import { ConvolutionShader } from '../shaders/ConvolutionShader.js';
 
+/**
+ * A pass for a basic Bloom effect.
+ *
+ * {@link UnrealBloomPass} produces a more advanced Bloom but is also
+ * more expensive.
+ *
+ * ```js
+ * const effectBloom = new BloomPass( 0.75 );
+ * composer.addPass( effectBloom );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { BloomPass } from 'three/addons/postprocessing/BloomPass.js';
+ */
 class BloomPass extends Pass {
 
+	/**
+	 * Constructs a new Bloom pass.
+	 *
+	 * @param {number} [strength=1] - The Bloom strength.
+	 * @param {number} [kernelSize=25] - The kernel size.
+	 * @param {number} [sigma=4] - The sigma.
+	 */
 	constructor( strength = 1, kernelSize = 25, sigma = 4 ) {
 
 		super();
 
-		// render targets
-
-		this.renderTargetX = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
-		this.renderTargetX.texture.name = 'BloomPass.x';
-		this.renderTargetY = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
-		this.renderTargetY.texture.name = 'BloomPass.y';
-
 		// combine material
 
+		/**
+		 * The combine pass uniforms.
+		 *
+		 * @type {Object}
+		 */
 		this.combineUniforms = UniformsUtils.clone( CombineShader.uniforms );
-
 		this.combineUniforms[ 'strength' ].value = strength;
 
+		/**
+		 * The combine pass material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
 		this.materialCombine = new ShaderMaterial( {
 
 			name: CombineShader.name,
@@ -43,11 +66,21 @@ class BloomPass extends Pass {
 
 		const convolutionShader = ConvolutionShader;
 
+		/**
+		 * The convolution pass uniforms.
+		 *
+		 * @type {Object}
+		 */
 		this.convolutionUniforms = UniformsUtils.clone( convolutionShader.uniforms );
 
 		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurX;
-		this.convolutionUniforms[ 'cKernel' ].value = ConvolutionShader.buildKernel( sigma );
+		this.convolutionUniforms[ 'cKernel' ].value = buildKernel( sigma );
 
+		/**
+		 * The convolution pass material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
 		this.materialConvolution = new ShaderMaterial( {
 
 			name: convolutionShader.name,
@@ -61,67 +94,101 @@ class BloomPass extends Pass {
 
 		} );
 
+		/**
+		 * Overwritten to disable the swap.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
 		this.needsSwap = false;
 
-		this.fsQuad = new FullScreenQuad( null );
+		// internals
+
+		this._renderTargetX = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
+		this._renderTargetX.texture.name = 'BloomPass.x';
+		this._renderTargetY = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
+		this._renderTargetY.texture.name = 'BloomPass.y';
+
+		this._fsQuad = new FullScreenQuad( null );
 
 	}
 
+	/**
+	 * Performs the Bloom 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 ) {
 
 		if ( maskActive ) renderer.state.buffers.stencil.setTest( false );
 
-		// Render quad with blured scene into texture (convolution pass 1)
+		// Render quad with blurred scene into texture (convolution pass 1)
 
-		this.fsQuad.material = this.materialConvolution;
+		this._fsQuad.material = this.materialConvolution;
 
 		this.convolutionUniforms[ 'tDiffuse' ].value = readBuffer.texture;
 		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurX;
 
-		renderer.setRenderTarget( this.renderTargetX );
+		renderer.setRenderTarget( this._renderTargetX );
 		renderer.clear();
-		this.fsQuad.render( renderer );
+		this._fsQuad.render( renderer );
 
 
-		// Render quad with blured scene into texture (convolution pass 2)
+		// Render quad with blurred scene into texture (convolution pass 2)
 
-		this.convolutionUniforms[ 'tDiffuse' ].value = this.renderTargetX.texture;
+		this.convolutionUniforms[ 'tDiffuse' ].value = this._renderTargetX.texture;
 		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurY;
 
-		renderer.setRenderTarget( this.renderTargetY );
+		renderer.setRenderTarget( this._renderTargetY );
 		renderer.clear();
-		this.fsQuad.render( renderer );
+		this._fsQuad.render( renderer );
 
 		// Render original scene with superimposed blur to texture
 
-		this.fsQuad.material = this.materialCombine;
+		this._fsQuad.material = this.materialCombine;
 
-		this.combineUniforms[ 'tDiffuse' ].value = this.renderTargetY.texture;
+		this.combineUniforms[ 'tDiffuse' ].value = this._renderTargetY.texture;
 
 		if ( maskActive ) renderer.state.buffers.stencil.setTest( true );
 
 		renderer.setRenderTarget( readBuffer );
 		if ( this.clear ) renderer.clear();
-		this.fsQuad.render( renderer );
+		this._fsQuad.render( renderer );
 
 	}
 
+	/**
+	 * Sets the size of the pass.
+	 *
+	 * @param {number} width - The width to set.
+	 * @param {number} height - The height to set.
+	 */
 	setSize( width, height ) {
 
-		this.renderTargetX.setSize( width, height );
-		this.renderTargetY.setSize( width, height );
+		this._renderTargetX.setSize( width, height );
+		this._renderTargetY.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.renderTargetX.dispose();
-		this.renderTargetY.dispose();
+		this._renderTargetX.dispose();
+		this._renderTargetY.dispose();
 
 		this.materialCombine.dispose();
 		this.materialConvolution.dispose();
 
-		this.fsQuad.dispose();
+		this._fsQuad.dispose();
 
 	}
 
@@ -169,4 +236,39 @@ const CombineShader = {
 BloomPass.blurX = new Vector2( 0.001953125, 0.0 );
 BloomPass.blurY = new Vector2( 0.0, 0.001953125 );
 
+
+function gauss( x, sigma ) {
+
+	return Math.exp( - ( x * x ) / ( 2.0 * sigma * sigma ) );
+
+}
+
+function buildKernel( sigma ) {
+
+	// We loop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
+
+	const kMaxKernelSize = 25;
+	let kernelSize = 2 * Math.ceil( sigma * 3.0 ) + 1;
+
+	if ( kernelSize > kMaxKernelSize ) kernelSize = kMaxKernelSize;
+
+	const halfWidth = ( kernelSize - 1 ) * 0.5;
+
+	const values = new Array( kernelSize );
+	let sum = 0.0;
+	for ( let i = 0; i < kernelSize; ++ i ) {
+
+		values[ i ] = gauss( i - halfWidth, sigma );
+		sum += values[ i ];
+
+	}
+
+	// normalize the kernel
+
+	for ( let i = 0; i < kernelSize; ++ i ) values[ i ] /= sum;
+
+	return values;
+
+}
+
 export { BloomPass };

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

@@ -13,16 +13,45 @@ import { Pass, FullScreenQuad } from './Pass.js';
 import { BokehShader } from '../shaders/BokehShader.js';
 
 /**
- * Depth-of-field post-process with bokeh shader
+ * Pass for creating depth of field (DOF) effect.
+ *
+ * ```js
+ * const bokehPass = new BokehPass( scene, camera, {
+ * 	focus: 500
+ * 	aperture: 5,
+ * 	maxblur: 0.01
+ * } );
+ * composer.addPass( bokehPass );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { BokehPass } from 'three/addons/postprocessing/BokehPass.js';
  */
-
 class BokehPass extends Pass {
 
+	/**
+	 * Constructs a new Bokeh pass.
+	 *
+	 * @param {Scene} scene - The scene to render the DOF for.
+	 * @param {Camera} camera - The camera.
+	 * @param {BokehPass~Options} params - The pass options.
+	 */
 	constructor( scene, camera, params ) {
 
 		super();
 
+		/**
+		 * The scene to render the DOF for.
+		 *
+		 * @type {Scene}
+		 */
 		this.scene = scene;
+
+		/**
+		 * The camera.
+		 *
+		 * @type {Camera}
+		 */
 		this.camera = camera;
 
 		const focus = ( params.focus !== undefined ) ? params.focus : 1.0;
@@ -31,26 +60,25 @@ class BokehPass extends Pass {
 
 		// render targets
 
-		this.renderTargetDepth = new WebGLRenderTarget( 1, 1, { // will be resized later
+		this._renderTargetDepth = new WebGLRenderTarget( 1, 1, { // will be resized later
 			minFilter: NearestFilter,
 			magFilter: NearestFilter,
 			type: HalfFloatType
 		} );
 
-		this.renderTargetDepth.texture.name = 'BokehPass.depth';
+		this._renderTargetDepth.texture.name = 'BokehPass.depth';
 
 		// depth material
 
-		this.materialDepth = new MeshDepthMaterial();
-		this.materialDepth.depthPacking = RGBADepthPacking;
-		this.materialDepth.blending = NoBlending;
+		this._materialDepth = new MeshDepthMaterial();
+		this._materialDepth.depthPacking = RGBADepthPacking;
+		this._materialDepth.blending = NoBlending;
 
 		// bokeh material
 
-		const bokehShader = BokehShader;
-		const bokehUniforms = UniformsUtils.clone( bokehShader.uniforms );
+		const bokehUniforms = UniformsUtils.clone( BokehShader.uniforms );
 
-		bokehUniforms[ 'tDepth' ].value = this.renderTargetDepth.texture;
+		bokehUniforms[ 'tDepth' ].value = this._renderTargetDepth.texture;
 
 		bokehUniforms[ 'focus' ].value = focus;
 		bokehUniforms[ 'aspect' ].value = camera.aspect;
@@ -59,26 +87,56 @@ class BokehPass extends Pass {
 		bokehUniforms[ 'nearClip' ].value = camera.near;
 		bokehUniforms[ 'farClip' ].value = camera.far;
 
+		/**
+		 * The pass bokeh material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
 		this.materialBokeh = new ShaderMaterial( {
-			defines: Object.assign( {}, bokehShader.defines ),
+			defines: Object.assign( {}, BokehShader.defines ),
 			uniforms: bokehUniforms,
-			vertexShader: bokehShader.vertexShader,
-			fragmentShader: bokehShader.fragmentShader
+			vertexShader: BokehShader.vertexShader,
+			fragmentShader: BokehShader.fragmentShader
 		} );
 
+		/**
+		 * The pass uniforms.  Use this object if you want to update the
+		 * `focus`, `aperture` or `maxblur` values at runtime.
+		 *
+		 * ```js
+		 * pass.uniforms.focus.value = focus;
+		 * pass.uniforms.aperture.value = aperture;
+		 * pass.uniforms.maxblur.value = maxblur;
+		 * ```
+		 *
+		 * @type {Object}
+		 */
 		this.uniforms = bokehUniforms;
 
-		this.fsQuad = new FullScreenQuad( this.materialBokeh );
+		// internals
+
+		this._fsQuad = new FullScreenQuad( this.materialBokeh );
 
 		this._oldClearColor = new Color();
 
 	}
 
+	/**
+	 * Performs the Bokeh 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*/ ) {
 
 		// Render depth into texture
 
-		this.scene.overrideMaterial = this.materialDepth;
+		this.scene.overrideMaterial = this._materialDepth;
 
 		renderer.getClearColor( this._oldClearColor );
 		const oldClearAlpha = renderer.getClearAlpha();
@@ -87,7 +145,7 @@ class BokehPass extends Pass {
 
 		renderer.setClearColor( 0xffffff );
 		renderer.setClearAlpha( 1.0 );
-		renderer.setRenderTarget( this.renderTargetDepth );
+		renderer.setRenderTarget( this._renderTargetDepth );
 		renderer.clear();
 		renderer.render( this.scene, this.camera );
 
@@ -100,13 +158,13 @@ class BokehPass extends Pass {
 		if ( this.renderToScreen ) {
 
 			renderer.setRenderTarget( null );
-			this.fsQuad.render( renderer );
+			this._fsQuad.render( renderer );
 
 		} else {
 
 			renderer.setRenderTarget( writeBuffer );
 			renderer.clear();
-			this.fsQuad.render( renderer );
+			this._fsQuad.render( renderer );
 
 		}
 
@@ -117,25 +175,44 @@ class BokehPass extends Pass {
 
 	}
 
+	/**
+	 * Sets the size of the pass.
+	 *
+	 * @param {number} width - The width to set.
+	 * @param {number} height - The height to set.
+	 */
 	setSize( width, height ) {
 
 		this.materialBokeh.uniforms[ 'aspect' ].value = width / height;
 
-		this.renderTargetDepth.setSize( width, height );
+		this._renderTargetDepth.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.renderTargetDepth.dispose();
+		this._renderTargetDepth.dispose();
 
-		this.materialDepth.dispose();
+		this._materialDepth.dispose();
 		this.materialBokeh.dispose();
 
-		this.fsQuad.dispose();
+		this._fsQuad.dispose();
 
 	}
 
 }
 
+/**
+ * Constructor options of `BokehPass`.
+ *
+ * @typedef {Object} BokehPass~Options
+ * @property {number} [focus=1] - Defines the effect's focus which is the distance along the camera's look direction in world units.
+ * @property {number} [aperture=0.025] - Defines the effect's aperture.
+ * @property {number} [maxblur=1] - Defines the effect's maximum blur.
+ **/
+
 export { BokehPass };

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

@@ -3,20 +3,71 @@ import {
 } from 'three';
 import { Pass } from './Pass.js';
 
+/**
+ * This class can be used to force a clear operation for the current read or
+ * default framebuffer (when rendering to screen).
+ *
+ * ```js
+ * const clearPass = new ClearPass();
+ * composer.addPass( clearPass );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { ClearPass } from 'three/addons/postprocessing/ClearPass.js';
+ */
 class ClearPass extends Pass {
 
-	constructor( clearColor, clearAlpha ) {
+	/**
+	 * Constructs a new clear pass.
+	 *
+	 * @param {(number|Color|string)} [clearColor=0x000000] - The clear color.
+	 * @param {number} [clearAlpha=0] - The clear alpha.
+	 */
+	constructor( clearColor = 0x000000, clearAlpha = 0 ) {
 
 		super();
 
+		/**
+		 * Overwritten to disable the swap.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
 		this.needsSwap = false;
 
-		this.clearColor = ( clearColor !== undefined ) ? clearColor : 0x000000;
-		this.clearAlpha = ( clearAlpha !== undefined ) ? clearAlpha : 0;
+		/**
+		 * The clear color.
+		 *
+		 * @type {(number|Color|string)}
+		 * @default 0x000000
+		 */
+		this.clearColor = clearColor;
+
+		/**
+		 * The clear alpha.
+		 *
+		 * @type {number}
+		 * @default 0
+		 */
+		this.clearAlpha = clearAlpha;
+
+		// internals
+
 		this._oldClearColor = new Color();
 
 	}
 
+	/**
+	 * Performs the clear operation. This affects the current read or the default framebuffer.
+	 *
+	 * @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 */ ) {
 
 		let oldClearAlpha;

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

@@ -10,30 +10,79 @@ import {
 } from 'three';
 import { Pass } from './Pass.js';
 
+/**
+ * This pass can be used to render a cube texture over the entire screen.
+ *
+ * ```js
+ * const cubeMap = new THREE.CubeTextureLoader().load( urls );
+ *
+ * const cubeTexturePass = new CubeTexturePass( camera, cubemap );
+ * composer.addPass( cubeTexturePass );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { CubeTexturePass } from 'three/addons/postprocessing/CubeTexturePass.js';
+ */
 class CubeTexturePass extends Pass {
 
+	/**
+	 * Constructs a new cube texture pass.
+	 *
+	 * @param {PerspectiveCamera} camera - The camera.
+	 * @param {CubeTexture} tCube - The cube texture to render.
+	 * @param {number} [opacity=1] - The opacity.
+	 */
 	constructor( camera, tCube, opacity = 1 ) {
 
 		super();
 
+		/**
+		 * The camera.
+		 *
+		 * @type {PerspectiveCamera}
+		 */
 		this.camera = camera;
 
+		/**
+		 * The cube texture to render.
+		 *
+		 * @type {CubeTexture}
+		 */
+		this.tCube = tCube;
+
+		/**
+		 * The opacity.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.opacity = opacity;
+
+		/**
+		 * Overwritten to disable the swap.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
 		this.needsSwap = false;
 
-		this.cubeShader = ShaderLib[ 'cube' ];
-		this.cubeMesh = new Mesh(
+		// internals
+
+		const cubeShader = ShaderLib[ 'cube' ];
+
+		this._cubeMesh = new Mesh(
 			new BoxGeometry( 10, 10, 10 ),
 			new ShaderMaterial( {
-				uniforms: UniformsUtils.clone( this.cubeShader.uniforms ),
-				vertexShader: this.cubeShader.vertexShader,
-				fragmentShader: this.cubeShader.fragmentShader,
+				uniforms: UniformsUtils.clone( cubeShader.uniforms ),
+				vertexShader: cubeShader.vertexShader,
+				fragmentShader: cubeShader.fragmentShader,
 				depthTest: false,
 				depthWrite: false,
 				side: BackSide
 			} )
 		);
 
-		Object.defineProperty( this.cubeMesh.material, 'envMap', {
+		Object.defineProperty( this._cubeMesh.material, 'envMap', {
 
 			get: function () {
 
@@ -43,40 +92,52 @@ class CubeTexturePass extends Pass {
 
 		} );
 
-		this.tCube = tCube;
-		this.opacity = opacity;
-
-		this.cubeScene = new Scene();
-		this.cubeCamera = new PerspectiveCamera();
-		this.cubeScene.add( this.cubeMesh );
+		this._cubeScene = new Scene();
+		this._cubeCamera = new PerspectiveCamera();
+		this._cubeScene.add( this._cubeMesh );
 
 	}
 
+	/**
+	 * Performs the cube texture 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*/ ) {
 
 		const oldAutoClear = renderer.autoClear;
 		renderer.autoClear = false;
 
-		this.cubeCamera.projectionMatrix.copy( this.camera.projectionMatrix );
-		this.cubeCamera.quaternion.setFromRotationMatrix( this.camera.matrixWorld );
+		this._cubeCamera.projectionMatrix.copy( this.camera.projectionMatrix );
+		this._cubeCamera.quaternion.setFromRotationMatrix( this.camera.matrixWorld );
 
-		this.cubeMesh.material.uniforms.tCube.value = this.tCube;
-		this.cubeMesh.material.uniforms.tFlip.value = ( this.tCube.isCubeTexture && this.tCube.isRenderTargetTexture === false ) ? - 1 : 1;
-		this.cubeMesh.material.uniforms.opacity.value = this.opacity;
-		this.cubeMesh.material.transparent = ( this.opacity < 1.0 );
+		this._cubeMesh.material.uniforms.tCube.value = this.tCube;
+		this._cubeMesh.material.uniforms.tFlip.value = ( this.tCube.isCubeTexture && this.tCube.isRenderTargetTexture === false ) ? - 1 : 1;
+		this._cubeMesh.material.uniforms.opacity.value = this.opacity;
+		this._cubeMesh.material.transparent = ( this.opacity < 1.0 );
 
 		renderer.setRenderTarget( this.renderToScreen ? null : readBuffer );
 		if ( this.clear ) renderer.clear();
-		renderer.render( this.cubeScene, this.cubeCamera );
+		renderer.render( this._cubeScene, this._cubeCamera );
 
 		renderer.autoClear = oldAutoClear;
 
 	}
 
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever the pass is no longer used in your app.
+	 */
 	dispose() {
 
-		this.cubeMesh.geometry.dispose();
-		this.cubeMesh.material.dispose();
+		this._cubeMesh.geometry.dispose();
+		this._cubeMesh.material.dispose();
 
 	}