@plastic-software/three 0.167.3 → 0.174.0

package/src/nodes/display/AnamorphicNode.js

@@ -1,145 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, Fn, float, vec2, vec3 } from '../shadernode/ShaderNode.js';
-import { Loop } from '../utils/LoopNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { threshold } from './ColorAdjustmentNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { passTexture } from './PassNode.js';
-import QuadMesh from '../../renderers/common/QuadMesh.js';
-
-import { Vector2 } from '../../math/Vector2.js';
-import { RenderTarget } from '../../core/RenderTarget.js';
-
-const _quadMesh = /*@__PURE__*/ new QuadMesh();
-
-class AnamorphicNode extends TempNode {
-
-	constructor( textureNode, tresholdNode, scaleNode, samples ) {
-
-		super( 'vec4' );
-
-		this.textureNode = textureNode;
-		this.tresholdNode = tresholdNode;
-		this.scaleNode = scaleNode;
-		this.colorNode = vec3( 0.1, 0.0, 1.0 );
-		this.samples = samples;
-		this.resolution = new Vector2( 1, 1 );
-
-		this._renderTarget = new RenderTarget();
-		this._renderTarget.texture.name = 'anamorphic';
-
-		this._invSize = uniform( new Vector2() );
-
-		this._textureNode = passTexture( this, this._renderTarget.texture );
-
-		this.updateBeforeType = NodeUpdateType.RENDER;
-
-	}
-
-	getTextureNode() {
-
-		return this._textureNode;
-
-	}
-
-	setSize( width, height ) {
-
-		this._invSize.value.set( 1 / width, 1 / height );
-
-		width = Math.max( Math.round( width * this.resolution.x ), 1 );
-		height = Math.max( Math.round( height * this.resolution.y ), 1 );
-
-		this._renderTarget.setSize( width, height );
-
-	}
-
-	updateBefore( frame ) {
-
-		const { renderer } = frame;
-
-		const textureNode = this.textureNode;
-		const map = textureNode.value;
-
-		this._renderTarget.texture.type = map.type;
-
-		const currentRenderTarget = renderer.getRenderTarget();
-		const currentTexture = textureNode.value;
-
-		_quadMesh.material = this._material;
-
-		this.setSize( map.image.width, map.image.height );
-
-		// render
-
-		renderer.setRenderTarget( this._renderTarget );
-
-		_quadMesh.render( renderer );
-
-		// restore
-
-		renderer.setRenderTarget( currentRenderTarget );
-		textureNode.value = currentTexture;
-
-	}
-
-	setup( builder ) {
-
-		const textureNode = this.textureNode;
-		const uvNode = textureNode.uvNode || uv();
-
-		const sampleTexture = ( uv ) => textureNode.uv( uv );
-
-		const anamorph = Fn( () => {
-
-			const samples = this.samples;
-			const halfSamples = Math.floor( samples / 2 );
-
-			const total = vec3( 0 ).toVar();
-
-			Loop( { start: - halfSamples, end: halfSamples }, ( { i } ) => {
-
-				const softness = float( i ).abs().div( halfSamples ).oneMinus();
-
-				const uv = vec2( uvNode.x.add( this._invSize.x.mul( i ).mul( this.scaleNode ) ), uvNode.y );
-				const color = sampleTexture( uv );
-				const pass = threshold( color, this.tresholdNode ).mul( softness );
-
-				total.addAssign( pass );
-
-			} );
-
-			return total.mul( this.colorNode );
-
-		} );
-
-		//
-
-		const material = this._material || ( this._material = builder.createNodeMaterial() );
-		material.fragmentNode = anamorph();
-
-		//
-
-		const properties = builder.getNodeProperties( this );
-		properties.textureNode = textureNode;
-
-		//
-
-		return this._textureNode;
-
-	}
-
-	dispose() {
-
-		this._renderTarget.dispose();
-
-	}
-
-}
-
-export const anamorphic = ( node, threshold = .9, scale = 3, samples = 32 ) => nodeObject( new AnamorphicNode( nodeObject( node ).toTexture(), nodeObject( threshold ), nodeObject( scale ), samples ) );
-
-addNodeElement( 'anamorphic', anamorphic );
-
-export default AnamorphicNode;
-

package/src/nodes/display/BlendModeNode.js

@@ -1,128 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { /*mix, step,*/ EPSILON } from '../math/MathNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, Fn, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-
-export const BurnNode = Fn( ( { base, blend } ) => {
-
-	const fn = ( c ) => blend[ c ].lessThan( EPSILON ).select( blend[ c ], base[ c ].oneMinus().div( blend[ c ] ).oneMinus().max( 0 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'burnColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const DodgeNode = Fn( ( { base, blend } ) => {
-
-	const fn = ( c ) => blend[ c ].equal( 1.0 ).select( blend[ c ], base[ c ].div( blend[ c ].oneMinus() ).max( 0 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'dodgeColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const ScreenNode = Fn( ( { base, blend } ) => {
-
-	const fn = ( c ) => base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus();
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'screenColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const OverlayNode = Fn( ( { base, blend } ) => {
-
-	const fn = ( c ) => base[ c ].lessThan( 0.5 ).select( base[ c ].mul( blend[ c ], 2.0 ), base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus() );
-	//const fn = ( c ) => mix( base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus(), base[ c ].mul( blend[ c ], 2.0 ), step( base[ c ], 0.5 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'overlayColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-class BlendModeNode extends TempNode {
-
-	constructor( blendMode, baseNode, blendNode ) {
-
-		super();
-
-		this.blendMode = blendMode;
-
-		this.baseNode = baseNode;
-		this.blendNode = blendNode;
-
-	}
-
-	setup() {
-
-		const { blendMode, baseNode, blendNode } = this;
-		const params = { base: baseNode, blend: blendNode };
-
-		let outputNode = null;
-
-		if ( blendMode === BlendModeNode.BURN ) {
-
-			outputNode = BurnNode( params );
-
-		} else if ( blendMode === BlendModeNode.DODGE ) {
-
-			outputNode = DodgeNode( params );
-
-		} else if ( blendMode === BlendModeNode.SCREEN ) {
-
-			outputNode = ScreenNode( params );
-
-		} else if ( blendMode === BlendModeNode.OVERLAY ) {
-
-			outputNode = OverlayNode( params );
-
-		}
-
-		return outputNode;
-
-	}
-
-}
-
-BlendModeNode.BURN = 'burn';
-BlendModeNode.DODGE = 'dodge';
-BlendModeNode.SCREEN = 'screen';
-BlendModeNode.OVERLAY = 'overlay';
-
-export default BlendModeNode;
-
-export const burn = nodeProxy( BlendModeNode, BlendModeNode.BURN );
-export const dodge = nodeProxy( BlendModeNode, BlendModeNode.DODGE );
-export const overlay = nodeProxy( BlendModeNode, BlendModeNode.OVERLAY );
-export const screen = nodeProxy( BlendModeNode, BlendModeNode.SCREEN );
-
-addNodeElement( 'burn', burn );
-addNodeElement( 'dodge', dodge );
-addNodeElement( 'overlay', overlay );
-addNodeElement( 'screen', screen );
-
-addNodeClass( 'BlendModeNode', BlendModeNode );

package/src/nodes/display/ColorAdjustmentNode.js

@@ -1,104 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { dot, mix } from '../math/MathNode.js';
-import { add } from '../math/OperatorNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, Fn, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
-import { ColorManagement } from '../../math/ColorManagement.js';
-import { Vector3 } from '../../math/Vector3.js';
-
-const saturationNode = Fn( ( { color, adjustment } ) => {
-
-	return adjustment.mix( luminance( color.rgb ), color.rgb );
-
-} );
-
-const vibranceNode = Fn( ( { color, adjustment } ) => {
-
-	const average = add( color.r, color.g, color.b ).div( 3.0 );
-
-	const mx = color.r.max( color.g.max( color.b ) );
-	const amt = mx.sub( average ).mul( adjustment ).mul( - 3.0 );
-
-	return mix( color.rgb, mx, amt );
-
-} );
-
-const hueNode = Fn( ( { color, adjustment } ) => {
-
-	const k = vec3( 0.57735, 0.57735, 0.57735 );
-
-	const cosAngle = adjustment.cos();
-
-	return vec3( color.rgb.mul( cosAngle ).add( k.cross( color.rgb ).mul( adjustment.sin() ).add( k.mul( dot( k, color.rgb ).mul( cosAngle.oneMinus() ) ) ) ) );
-
-} );
-
-class ColorAdjustmentNode extends TempNode {
-
-	constructor( method, colorNode, adjustmentNode = float( 1 ) ) {
-
-		super( 'vec3' );
-
-		this.method = method;
-
-		this.colorNode = colorNode;
-		this.adjustmentNode = adjustmentNode;
-
-	}
-
-	setup() {
-
-		const { method, colorNode, adjustmentNode } = this;
-
-		const callParams = { color: colorNode, adjustment: adjustmentNode };
-
-		let outputNode = null;
-
-		if ( method === ColorAdjustmentNode.SATURATION ) {
-
-			outputNode = saturationNode( callParams );
-
-		} else if ( method === ColorAdjustmentNode.VIBRANCE ) {
-
-			outputNode = vibranceNode( callParams );
-
-		} else if ( method === ColorAdjustmentNode.HUE ) {
-
-			outputNode = hueNode( callParams );
-
-		} else {
-
-			console.error( `${ this.type }: Method "${ this.method }" not supported!` );
-
-		}
-
-		return outputNode;
-
-	}
-
-}
-
-ColorAdjustmentNode.SATURATION = 'saturation';
-ColorAdjustmentNode.VIBRANCE = 'vibrance';
-ColorAdjustmentNode.HUE = 'hue';
-
-export default ColorAdjustmentNode;
-
-export const saturation = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.SATURATION );
-export const vibrance = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.VIBRANCE );
-export const hue = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.HUE );
-
-const _luminanceCoefficients = /*#__PURE__*/ new Vector3();
-export const luminance = (
-	color,
-	luminanceCoefficients = vec3( ... ColorManagement.getLuminanceCoefficients( _luminanceCoefficients ) )
-) => dot( color, luminanceCoefficients );
-
-export const threshold = ( color, threshold ) => mix( vec3( 0.0 ), color, luminance( color ).sub( threshold ).max( 0 ) );
-
-addNodeElement( 'saturation', saturation );
-addNodeElement( 'vibrance', vibrance );
-addNodeElement( 'hue', hue );
-addNodeElement( 'threshold', threshold );
-
-addNodeClass( 'ColorAdjustmentNode', ColorAdjustmentNode );

package/src/nodes/display/DenoiseNode.js

@@ -1,198 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, Fn, nodeObject, float, int, vec2, vec3, vec4, mat2, If } from '../shadernode/ShaderNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { uniform } from '../core/UniformNode.js';
-import { uniformArray } from '../accessors/UniformArrayNode.js';
-import { abs, dot, sin, cos, PI, pow, max } from '../math/MathNode.js';
-import { Loop } from '../utils/LoopNode.js';
-import { luminance } from './ColorAdjustmentNode.js';
-import { textureSize } from '../accessors/TextureSizeNode.js';
-import { Vector2 } from '../../math/Vector2.js';
-import { Vector3 } from '../../math/Vector3.js';
-
-class DenoiseNode extends TempNode {
-
-	constructor( textureNode, depthNode, normalNode, noiseNode, camera ) {
-
-		super();
-
-		this.textureNode = textureNode;
-		this.depthNode = depthNode;
-		this.normalNode = normalNode;
-		this.noiseNode = noiseNode;
-
-		this.cameraProjectionMatrixInverse = uniform( camera.projectionMatrixInverse );
-		this.lumaPhi = uniform( 5 );
-		this.depthPhi = uniform( 5 );
-		this.normalPhi = uniform( 5 );
-		this.radius = uniform( 5 );
-		this.index = uniform( 0 );
-
-		this._resolution = uniform( new Vector2() );
-		this._sampleVectors = uniformArray( generatePdSamplePointInitializer( 16, 2, 1 ) );
-
-		this.updateBeforeType = NodeUpdateType.RENDER;
-
-	}
-
-	updateBefore() {
-
-		const map = this.textureNode.value;
-
-		this._resolution.value.set( map.image.width, map.image.height );
-
-	}
-
-	setup() {
-
-		const uvNode = uv();
-
-		const sampleTexture = ( uv ) => this.textureNode.uv( uv );
-		const sampleDepth = ( uv ) => this.depthNode.uv( uv ).x;
-		const sampleNormal = ( uv ) => this.normalNode.uv( uv );
-		const sampleNoise = ( uv ) => this.noiseNode.uv( uv );
-
-		const getViewPosition = Fn( ( [ screenPosition, depth ] ) => {
-
-			screenPosition = vec2( screenPosition.x, screenPosition.y.oneMinus() ).mul( 2.0 ).sub( 1.0 );
-
-			const clipSpacePosition = vec4( vec3( screenPosition, depth ), 1.0 );
-			const viewSpacePosition = vec4( this.cameraProjectionMatrixInverse.mul( clipSpacePosition ) );
-
-			return viewSpacePosition.xyz.div( viewSpacePosition.w );
-
-		} );
-
-		const denoiseSample = Fn( ( [ center, viewNormal, viewPosition, sampleUv ] ) => {
-
-			const texel = sampleTexture( sampleUv );
-			const depth = sampleDepth( sampleUv );
-			const normal = sampleNormal( sampleUv ).rgb.normalize();
-			const neighborColor = texel.rgb;
-			const viewPos = getViewPosition( sampleUv, depth );
-
-			const normalDiff = dot( viewNormal, normal ).toVar();
-			const normalSimilarity = pow( max( normalDiff, 0 ), this.normalPhi ).toVar();
-			const lumaDiff = abs( luminance( neighborColor ).sub( luminance( center ) ) ).toVar();
-			const lumaSimilarity = max( float( 1.0 ).sub( lumaDiff.div( this.lumaPhi ) ), 0 ).toVar();
-			const depthDiff = abs( dot( viewPosition.sub( viewPos ), viewNormal ) ).toVar();
-			const depthSimilarity = max( float( 1.0 ).sub( depthDiff.div( this.depthPhi ) ), 0 );
-			const w = lumaSimilarity.mul( depthSimilarity ).mul( normalSimilarity );
-
-			return vec4( neighborColor.mul( w ), w );
-
-		} );
-
-		const denoise = Fn( ( [ uvNode ] ) => {
-
-			const depth = sampleDepth( uvNode );
-			const viewNormal = sampleNormal( uvNode ).rgb.normalize();
-
-			const texel = sampleTexture( uvNode );
-
-			If( depth.greaterThanEqual( 1.0 ).or( dot( viewNormal, viewNormal ).equal( 0.0 ) ), () => {
-
-				return texel;
-
-			} );
-
-			const center = vec3( texel.rgb );
-
-			const viewPosition = getViewPosition( uvNode, depth );
-
-			const noiseResolution = textureSize( this.noiseNode, 0 );
-			let noiseUv = vec2( uvNode.x, uvNode.y.oneMinus() );
-			noiseUv = noiseUv.mul( this._resolution.div( noiseResolution ) );
-			const noiseTexel = sampleNoise( noiseUv );
-
-			const x = sin( noiseTexel.element( this.index.mod( 4 ).mul( 2 ).mul( PI ) ) );
-			const y = cos( noiseTexel.element( this.index.mod( 4 ).mul( 2 ).mul( PI ) ) );
-
-			const noiseVec = vec2( x, y );
-			const rotationMatrix = mat2( noiseVec.x, noiseVec.y.negate(), noiseVec.x, noiseVec.y );
-
-			const totalWeight = float( 1.0 ).toVar();
-			const denoised = vec3( texel.rgb ).toVar();
-
-			Loop( { start: int( 0 ), end: int( 16 ), type: 'int', condition: '<' }, ( { i } ) => {
-
-				const sampleDir = this._sampleVectors.element( i ).toVar();
-				const offset = rotationMatrix.mul( sampleDir.xy.mul( float( 1.0 ).add( sampleDir.z.mul( this.radius.sub( 1 ) ) ) ) ).div( this._resolution ).toVar();
-				const sampleUv = uvNode.add( offset ).toVar();
-
-				const result = denoiseSample( center, viewNormal, viewPosition, sampleUv );
-
-				denoised.addAssign( result.xyz );
-				totalWeight.addAssign( result.w );
-
-			} );
-
-			If( totalWeight.greaterThan( float( 0 ) ), () => {
-
-				denoised.divAssign( totalWeight );
-
-			} );
-
-			return vec4( denoised, texel.a );
-
-		} ).setLayout( {
-			name: 'denoise',
-			type: 'vec4',
-			inputs: [
-				{ name: 'uv', type: 'vec2' }
-			]
-		} );
-
-		const output = Fn( () => {
-
-			return denoise( uvNode );
-
-		} );
-
-		const outputNode = output();
-
-		return outputNode;
-
-	}
-
-}
-
-function generatePdSamplePointInitializer( samples, rings, radiusExponent ) {
-
-	const poissonDisk = generateDenoiseSamples( samples, rings, radiusExponent );
-
-	const array = [];
-
-	for ( let i = 0; i < samples; i ++ ) {
-
-		const sample = poissonDisk[ i ];
-		array.push( sample );
-
-	}
-
-	return array;
-
-}
-
-function generateDenoiseSamples( numSamples, numRings, radiusExponent ) {
-
-	const samples = [];
-
-	for ( let i = 0; i < numSamples; i ++ ) {
-
-		const angle = 2 * Math.PI * numRings * i / numSamples;
-		const radius = Math.pow( i / ( numSamples - 1 ), radiusExponent );
-		samples.push( new Vector3( Math.cos( angle ), Math.sin( angle ), radius ) );
-
-	}
-
-	return samples;
-
-}
-
-export const denoise = ( node, depthNode, normalNode, noiseNode, camera ) => nodeObject( new DenoiseNode( nodeObject( node ).toTexture(), nodeObject( depthNode ), nodeObject( normalNode ), nodeObject( noiseNode ), camera ) );
-
-addNodeElement( 'denoise', denoise );
-
-export default DenoiseNode;

package/src/nodes/display/DotScreenNode.js

@@ -1,75 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, Fn, vec2, vec3, vec4 } from '../shadernode/ShaderNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { uv } from '../accessors/UVNode.js';
-import { sin, cos } from '../math/MathNode.js';
-import { add } from '../math/OperatorNode.js';
-
-import { Vector2 } from '../../math/Vector2.js';
-
-class DotScreenNode extends TempNode {
-
-	constructor( inputNode, center = new Vector2( 0.5, 0.5 ), angle = 1.57, scale = 1 ) {
-
-		super( 'vec4' );
-
-		this.inputNode = inputNode;
-		this.center = uniform( center );
-		this.angle = uniform( angle );
-		this.scale = uniform( scale );
-
-		this._size = uniform( new Vector2() );
-
-		this.updateBeforeType = NodeUpdateType.RENDER;
-
-	}
-
-	updateBefore( frame ) {
-
-		const { renderer } = frame;
-
-		renderer.getDrawingBufferSize( this._size.value );
-
-	}
-
-	setup() {
-
-		const inputNode = this.inputNode;
-
-		const pattern = Fn( () => {
-
-			const s = sin( this.angle );
-			const c = cos( this.angle );
-
-			const tex = uv().mul( this._size ).sub( this.center );
-			const point = vec2( c.mul( tex.x ).sub( s.mul( tex.y ) ), s.mul( tex.x ).add( c.mul( tex.y ) ) ).mul( this.scale );
-
-			return sin( point.x ).mul( sin( point.y ) ).mul( 4 );
-
-		} );
-
-		const dotScreen = Fn( () => {
-
-			const color = inputNode;
-
-			const average = add( color.r, color.g, color.b ).div( 3 );
-
-			return vec4( vec3( average.mul( 10 ).sub( 5 ).add( pattern() ) ), color.a );
-
-		} );
-
-		const outputNode = dotScreen();
-
-		return outputNode;
-
-	}
-
-}
-
-export const dotScreen = ( node, center, angle, scale ) => nodeObject( new DotScreenNode( nodeObject( node ), center, angle, scale ) );
-
-addNodeElement( 'dotScreen', dotScreen );
-
-export default DotScreenNode;
-