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/nodes/display/GaussianBlurNode.js DELETED Viewed

@@ -1,190 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, float, vec2, vec4 } from '../shadernode/ShaderNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { mul } from '../math/OperatorNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { texturePass } from './PassNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { Vector2, RenderTarget } from 'three';
-import QuadMesh from '../../objects/QuadMesh.js';
-// WebGPU: The use of a single QuadMesh for both gaussian blur passes results in a single RenderObject with a SampledTexture binding that
-// alternates between source textures and triggers creation of new BindGroups and BindGroupLayouts every frame.
-const quadMesh1 = new QuadMesh();
-const quadMesh2 = new QuadMesh();
-class GaussianBlurNode extends TempNode {
-	constructor( textureNode, sigma = 2 ) {
-		super( 'vec4' );
-		this.textureNode = textureNode;
-		this.sigma = sigma;
-		this.directionNode = vec2( 1 );
-		this._invSize = uniform( new Vector2() );
-		this._passDirection = uniform( new Vector2() );
-		this._horizontalRT = new RenderTarget();
-		this._horizontalRT.texture.name = 'GaussianBlurNode.horizontal';
-		this._verticalRT = new RenderTarget();
-		this._verticalRT.texture.name = 'GaussianBlurNode.vertical';
-		this._textureNode = texturePass( this, this._verticalRT.texture );
-		this.updateBeforeType = NodeUpdateType.RENDER;
-		this.resolution = new Vector2( 1, 1 );
-	}
-	setSize( width, height ) {
-		width = Math.max( Math.round( width * this.resolution.x ), 1 );
-		height = Math.max( Math.round( height * this.resolution.y ), 1 );
-		this._invSize.value.set( 1 / width, 1 / height );
-		this._horizontalRT.setSize( width, height );
-		this._verticalRT.setSize( width, height );
-	}
-	updateBefore( frame ) {
-		const { renderer } = frame;
-		const textureNode = this.textureNode;
-		const map = textureNode.value;
-		const currentRenderTarget = renderer.getRenderTarget();
-		const currentTexture = textureNode.value;
-		quadMesh1.material = this._material;
-		quadMesh2.material = this._material;
-		this.setSize( map.image.width, map.image.height );
-		const textureType = map.type;
-		this._horizontalRT.texture.type = textureType;
-		this._verticalRT.texture.type = textureType;
-		// horizontal
-		renderer.setRenderTarget( this._horizontalRT );
-		this._passDirection.value.set( 1, 0 );
-		quadMesh1.render( renderer );
-		// vertical
-		textureNode.value = this._horizontalRT.texture;
-		renderer.setRenderTarget( this._verticalRT );
-		this._passDirection.value.set( 0, 1 );
-		quadMesh2.render( renderer );
-		// restore
-		renderer.setRenderTarget( currentRenderTarget );
-		textureNode.value = currentTexture;
-	}
-	getTextureNode() {
-		return this._textureNode;
-	}
-	setup( builder ) {
-		const textureNode = this.textureNode;
-		if ( textureNode.isTextureNode !== true ) {
-			console.error( 'GaussianBlurNode requires a TextureNode.' );
-			return vec4();
-		}
-		//
-		const uvNode = textureNode.uvNode || uv();
-		const sampleTexture = ( uv ) => textureNode.cache().context( { getUV: () => uv, forceUVContext: true } );
-		const blur = tslFn( () => {
-			const kernelSize = 3 + ( 2 * this.sigma );
-			const gaussianCoefficients = this._getCoefficients( kernelSize );
-			const invSize = this._invSize;
-			const direction = vec2( this.directionNode ).mul( this._passDirection );
-			const weightSum = float( gaussianCoefficients[ 0 ] ).toVar();
-			const diffuseSum = vec4( sampleTexture( uvNode ).mul( weightSum ) ).toVar();
-			for ( let i = 1; i < kernelSize; i ++ ) {
-				const x = float( i );
-				const w = float( gaussianCoefficients[ i ] );
-				const uvOffset = vec2( direction.mul( invSize.mul( x ) ) ).toVar();
-				const sample1 = vec4( sampleTexture( uvNode.add( uvOffset ) ) );
-				const sample2 = vec4( sampleTexture( uvNode.sub( uvOffset ) ) );
-				diffuseSum.addAssign( sample1.add( sample2 ).mul( w ) );
-				weightSum.addAssign( mul( 2.0, w ) );
-			}
-			return diffuseSum.div( weightSum );
-		} );
-		//
-		const material = this._material || ( this._material = builder.createNodeMaterial() );
-		material.fragmentNode = blur();
-		//
-		const properties = builder.getNodeProperties( this );
-		properties.textureNode = textureNode;
-		//
-		return this._textureNode;
-	}
-	_getCoefficients( kernelRadius ) {
-		const coefficients = [];
-		for ( let i = 0; i < kernelRadius; i ++ ) {
-			coefficients.push( 0.39894 * Math.exp( - 0.5 * i * i / ( kernelRadius * kernelRadius ) ) / kernelRadius );
-		}
-		return coefficients;
-	}
-}
-export const gaussianBlur = ( node, sigma ) => nodeObject( new GaussianBlurNode( nodeObject( node ), sigma ) );
-addNodeElement( 'gaussianBlur', gaussianBlur );
-export default GaussianBlurNode;

package/node_modules/three/examples/jsm/nodes/display/NormalMapNode.js DELETED Viewed

@@ -1,108 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { add } from '../math/OperatorNode.js';
-import { bitangentView } from '../accessors/BitangentNode.js';
-import { modelNormalMatrix } from '../accessors/ModelNode.js';
-import { normalView } from '../accessors/NormalNode.js';
-import { positionView } from '../accessors/PositionNode.js';
-import { tangentView } from '../accessors/TangentNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { faceDirection } from './FrontFacingNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeProxy, vec3, mat3 } from '../shadernode/ShaderNode.js';
-import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
-// Normal Mapping Without Precomputed Tangents
-// http://www.thetenthplanet.de/archives/1180
-const perturbNormal2Arb = tslFn( ( inputs ) => {
-	const { eye_pos, surf_norm, mapN, uv } = inputs;
-	const q0 = eye_pos.dFdx();
-	const q1 = eye_pos.dFdy();
-	const st0 = uv.dFdx();
-	const st1 = uv.dFdy();
-	const N = surf_norm; // normalized
-	const q1perp = q1.cross( N );
-	const q0perp = N.cross( q0 );
-	const T = q1perp.mul( st0.x ).add( q0perp.mul( st1.x ) );
-	const B = q1perp.mul( st0.y ).add( q0perp.mul( st1.y ) );
-	const det = T.dot( T ).max( B.dot( B ) );
-	const scale = faceDirection.mul( det.inverseSqrt() );
-	return add( T.mul( mapN.x, scale ), B.mul( mapN.y, scale ), N.mul( mapN.z ) ).normalize();
-} );
-class NormalMapNode extends TempNode {
-	constructor( node, scaleNode = null ) {
-		super( 'vec3' );
-		this.node = node;
-		this.scaleNode = scaleNode;
-		this.normalMapType = TangentSpaceNormalMap;
-	}
-	setup( builder ) {
-		const { normalMapType, scaleNode } = this;
-		let normalMap = this.node.mul( 2.0 ).sub( 1.0 );
-		if ( scaleNode !== null ) {
-			normalMap = vec3( normalMap.xy.mul( scaleNode ), normalMap.z );
-		}
-		let outputNode = null;
-		if ( normalMapType === ObjectSpaceNormalMap ) {
-			outputNode = modelNormalMatrix.mul( normalMap ).normalize();
-		} else if ( normalMapType === TangentSpaceNormalMap ) {
-			const tangent = builder.hasGeometryAttribute( 'tangent' );
-			if ( tangent === true ) {
-				outputNode = TBNViewMatrix.mul( normalMap ).normalize();
-			} else {
-				outputNode = perturbNormal2Arb( {
-					eye_pos: positionView,
-					surf_norm: normalView,
-					mapN: normalMap,
-					uv: uv()
-				} );
-			}
-		}
-		return outputNode;
-	}
-}
-export default NormalMapNode;
-export const normalMap = nodeProxy( NormalMapNode );
-export const TBNViewMatrix = mat3( tangentView, bitangentView, normalView );
-addNodeElement( 'normalMap', normalMap );
-addNodeClass( 'NormalMapNode', NormalMapNode );

package/node_modules/three/examples/jsm/nodes/display/PassNode.js DELETED Viewed

@@ -1,183 +0,0 @@
-import { addNodeClass } from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import TextureNode from '../accessors/TextureNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { viewZToOrthographicDepth, perspectiveDepthToViewZ } from './ViewportDepthNode.js';
-import { RenderTarget, Vector2, HalfFloatType, DepthTexture, NoToneMapping/*, FloatType*/ } from 'three';
-class PassTextureNode extends TextureNode {
-	constructor( passNode, texture ) {
-		super( texture );
-		this.passNode = passNode;
-		this.setUpdateMatrix( false );
-	}
-	setup( builder ) {
-		this.passNode.build( builder );
-		return super.setup( builder );
-	}
-	clone() {
-		return new this.constructor( this.passNode, this.value );
-	}
-}
-class PassNode extends TempNode {
-	constructor( scope, scene, camera ) {
-		super( 'vec4' );
-		this.scope = scope;
-		this.scene = scene;
-		this.camera = camera;
-		this._pixelRatio = 1;
-		this._width = 1;
-		this._height = 1;
-		const depthTexture = new DepthTexture();
-		depthTexture.isRenderTargetTexture = true;
-		//depthTexture.type = FloatType;
-		depthTexture.name = 'PostProcessingDepth';
-		const renderTarget = new RenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
-		renderTarget.texture.name = 'PostProcessing';
-		renderTarget.depthTexture = depthTexture;
-		this.renderTarget = renderTarget;
-		this.updateBeforeType = NodeUpdateType.FRAME;
-		this._textureNode = nodeObject( new PassTextureNode( this, renderTarget.texture ) );
-		this._depthTextureNode = nodeObject( new PassTextureNode( this, depthTexture ) );
-		this._depthNode = null;
-		this._cameraNear = uniform( 0 );
-		this._cameraFar = uniform( 0 );
-		this.isPassNode = true;
-	}
-	isGlobal() {
-		return true;
-	}
-	getTextureNode() {
-		return this._textureNode;
-	}
-	getTextureDepthNode() {
-		return this._depthTextureNode;
-	}
-	getDepthNode() {
-		if ( this._depthNode === null ) {
-			const cameraNear = this._cameraNear;
-			const cameraFar = this._cameraFar;
-			this._depthNode = viewZToOrthographicDepth( perspectiveDepthToViewZ( this._depthTextureNode, cameraNear, cameraFar ), cameraNear, cameraFar );
-		}
-		return this._depthNode;
-	}
-	setup() {
-		return this.scope === PassNode.COLOR ? this.getTextureNode() : this.getDepthNode();
-	}
-	updateBefore( frame ) {
-		const { renderer } = frame;
-		const { scene, camera } = this;
-		this._pixelRatio = renderer.getPixelRatio();
-		const size = renderer.getSize( new Vector2() );
-		this.setSize( size.width, size.height );
-		const currentToneMapping = renderer.toneMapping;
-		const currentToneMappingNode = renderer.toneMappingNode;
-		const currentRenderTarget = renderer.getRenderTarget();
-		this._cameraNear.value = camera.near;
-		this._cameraFar.value = camera.far;
-		renderer.toneMapping = NoToneMapping;
-		renderer.toneMappingNode = null;
-		renderer.setRenderTarget( this.renderTarget );
-		renderer.render( scene, camera );
-		renderer.toneMapping = currentToneMapping;
-		renderer.toneMappingNode = currentToneMappingNode;
-		renderer.setRenderTarget( currentRenderTarget );
-	}
-	setSize( width, height ) {
-		this._width = width;
-		this._height = height;
-		const effectiveWidth = this._width * this._pixelRatio;
-		const effectiveHeight = this._height * this._pixelRatio;
-		this.renderTarget.setSize( effectiveWidth, effectiveHeight );
-	}
-	setPixelRatio( pixelRatio ) {
-		this._pixelRatio = pixelRatio;
-		this.setSize( this._width, this._height );
-	}
-	dispose() {
-		this.renderTarget.dispose();
-	}
-}
-PassNode.COLOR = 'color';
-PassNode.DEPTH = 'depth';
-export default PassNode;
-export const pass = ( scene, camera ) => nodeObject( new PassNode( PassNode.COLOR, scene, camera ) );
-export const texturePass = ( pass, texture ) => nodeObject( new PassTextureNode( pass, texture ) );
-export const depthPass = ( scene, camera ) => nodeObject( new PassNode( PassNode.DEPTH, scene, camera ) );
-addNodeClass( 'PassNode', PassNode );

package/node_modules/three/examples/jsm/nodes/display/PosterizeNode.js DELETED Viewed

@@ -1,32 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
-class PosterizeNode extends TempNode {
-	constructor( sourceNode, stepsNode ) {
-		super();
-		this.sourceNode = sourceNode;
-		this.stepsNode = stepsNode;
-	}
-	setup() {
-		const { sourceNode, stepsNode } = this;
-		return sourceNode.mul( stepsNode ).floor().div( stepsNode );
-	}
-}
-export default PosterizeNode;
-export const posterize = nodeProxy( PosterizeNode );
-addNodeElement( 'posterize', posterize );
-addNodeClass( 'PosterizeNode', PosterizeNode );

package/node_modules/three/examples/jsm/nodes/display/ToneMappingNode.js DELETED Viewed

@@ -1,184 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { tslFn, nodeObject, float, mat3, vec3 } from '../shadernode/ShaderNode.js';
-import { NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping } from 'three';
-import { clamp, log2, max, pow } from '../math/MathNode.js';
-import { mul } from '../math/OperatorNode.js';
-// exposure only
-const LinearToneMappingNode = tslFn( ( { color, exposure } ) => {
-	return color.mul( exposure ).clamp();
-} );
-// source: https://www.cs.utah.edu/docs/techreports/2002/pdf/UUCS-02-001.pdf
-const ReinhardToneMappingNode = tslFn( ( { color, exposure } ) => {
-	color = color.mul( exposure );
-	return color.div( color.add( 1.0 ) ).clamp();
-} );
-// source: http://filmicworlds.com/blog/filmic-tonemapping-operators/
-const OptimizedCineonToneMappingNode = tslFn( ( { color, exposure } ) => {
-	// optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
-	color = color.mul( exposure );
-	color = color.sub( 0.004 ).max( 0.0 );
-	const a = color.mul( color.mul( 6.2 ).add( 0.5 ) );
-	const b = color.mul( color.mul( 6.2 ).add( 1.7 ) ).add( 0.06 );
-	return a.div( b ).pow( 2.2 );
-} );
-// source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
-const RRTAndODTFit = tslFn( ( { color } ) => {
-	const a = color.mul( color.add( 0.0245786 ) ).sub( 0.000090537 );
-	const b = color.mul( color.add( 0.4329510 ).mul( 0.983729 ) ).add( 0.238081 );
-	return a.div( b );
-} );
-// source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
-const ACESFilmicToneMappingNode = tslFn( ( { color, exposure } ) => {
-	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-	const ACESInputMat = mat3(
-		0.59719, 0.35458, 0.04823,
-		0.07600, 0.90834, 0.01566,
-		0.02840, 0.13383, 0.83777
-	);
-	// ODT_SAT => XYZ => D60_2_D65 => sRGB
-	const ACESOutputMat = mat3(
-		1.60475, - 0.53108, - 0.07367,
-		- 0.10208, 1.10813, - 0.00605,
-		- 0.00327, - 0.07276, 1.07602
-	);
-	color = color.mul( exposure ).div( 0.6 );
-	color = ACESInputMat.mul( color );
-	// Apply RRT and ODT
-	color = RRTAndODTFit( { color } );
-	color = ACESOutputMat.mul( color );
-	// Clamp to [0, 1]
-	return color.clamp();
-} );
-const LINEAR_REC2020_TO_LINEAR_SRGB = mat3( vec3( 1.6605, - 0.1246, - 0.0182 ), vec3( - 0.5876, 1.1329, - 0.1006 ), vec3( - 0.0728, - 0.0083, 1.1187 ) );
-const LINEAR_SRGB_TO_LINEAR_REC2020 = mat3( vec3( 0.6274, 0.0691, 0.0164 ), vec3( 0.3293, 0.9195, 0.0880 ), vec3( 0.0433, 0.0113, 0.8956 ) );
-const agxDefaultContrastApprox = tslFn( ( [ x_immutable ] ) => {
-	const x = vec3( x_immutable ).toVar();
-	const x2 = vec3( x.mul( x ) ).toVar();
-	const x4 = vec3( x2.mul( x2 ) ).toVar();
-	return float( 15.5 ).mul( x4.mul( x2 ) ).sub( mul( 40.14, x4.mul( x ) ) ).add( mul( 31.96, x4 ).sub( mul( 6.868, x2.mul( x ) ) ).add( mul( 0.4298, x2 ).add( mul( 0.1191, x ).sub( 0.00232 ) ) ) );
-} );
-const AGXToneMappingNode = tslFn( ( { color, exposure } ) => {
-	const colortone = vec3( color ).toVar();
-	const AgXInsetMatrix = mat3( vec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ), vec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ), vec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 ) );
-	const AgXOutsetMatrix = mat3( vec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ), vec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ), vec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 ) );
-	const AgxMinEv = float( - 12.47393 );
-	const AgxMaxEv = float( 4.026069 );
-	colortone.mulAssign( exposure );
-	colortone.assign( LINEAR_SRGB_TO_LINEAR_REC2020.mul( colortone ) );
-	colortone.assign( AgXInsetMatrix.mul( colortone ) );
-	colortone.assign( max( colortone, 1e-10 ) );
-	colortone.assign( log2( colortone ) );
-	colortone.assign( colortone.sub( AgxMinEv ).div( AgxMaxEv.sub( AgxMinEv ) ) );
-	colortone.assign( clamp( colortone, 0.0, 1.0 ) );
-	colortone.assign( agxDefaultContrastApprox( colortone ) );
-	colortone.assign( AgXOutsetMatrix.mul( colortone ) );
-	colortone.assign( pow( max( vec3( 0.0 ), colortone ), vec3( 2.2 ) ) );
-	colortone.assign( LINEAR_REC2020_TO_LINEAR_SRGB.mul( colortone ) );
-	colortone.assign( clamp( colortone, 0.0, 1.0 ) );
-	return colortone;
-} );
-const toneMappingLib = {
-	[ LinearToneMapping ]: LinearToneMappingNode,
-	[ ReinhardToneMapping ]: ReinhardToneMappingNode,
-	[ CineonToneMapping ]: OptimizedCineonToneMappingNode,
-	[ ACESFilmicToneMapping ]: ACESFilmicToneMappingNode,
-	[ AgXToneMapping ]: AGXToneMappingNode
-};
-class ToneMappingNode extends TempNode {
-	constructor( toneMapping = NoToneMapping, exposureNode = float( 1 ), colorNode = null ) {
-		super( 'vec3' );
-		this.toneMapping = toneMapping;
-		this.exposureNode = exposureNode;
-		this.colorNode = colorNode;
-	}
-	getCacheKey() {
-		let cacheKey = super.getCacheKey();
-		cacheKey = '{toneMapping:' + this.toneMapping + ',nodes:' + cacheKey + '}';
-		return cacheKey;
-	}
-	setup( builder ) {
-		const colorNode = this.colorNode || builder.context.color;
-		const toneMapping = this.toneMapping;
-		if ( toneMapping === NoToneMapping ) return colorNode;
-		const toneMappingParams = { exposure: this.exposureNode, color: colorNode };
-		const toneMappingNode = toneMappingLib[ toneMapping ];
-		let outputNode = null;
-		if ( toneMappingNode ) {
-			outputNode = toneMappingNode( toneMappingParams );
-		} else {
-			console.error( 'ToneMappingNode: Unsupported Tone Mapping configuration.', toneMapping );
-			outputNode = colorNode;
-		}
-		return outputNode;
-	}
-}
-export default ToneMappingNode;
-export const toneMapping = ( mapping, exposure, color ) => nodeObject( new ToneMappingNode( mapping, nodeObject( exposure ), nodeObject( color ) ) );
-addNodeClass( 'ToneMappingNode', ToneMappingNode );