@needle-tools/three 0.162.12 → 0.169.2

package/{examples/jsm → src}/nodes/core/UniformNode.js

@@ -1,20 +1,34 @@
 import InputNode from './InputNode.js';
 import { objectGroup } from './UniformGroupNode.js';
-import { addNodeClass } from './Node.js';
-import { nodeObject, getConstNodeType } from '../shadernode/ShaderNode.js';
+import { nodeObject, getConstNodeType } from '../tsl/TSLCore.js';
 
 class UniformNode extends InputNode {
 
+	static get type() {
+
+		return 'UniformNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( value, nodeType );
 
 		this.isUniformNode = true;
 
+		this.name = '';
 		this.groupNode = objectGroup;
 
 	}
 
+	label( name ) {
+
+		this.name = name;
+
+		return this;
+
+	}
+
 	setGroup( group ) {
 
 		this.groupNode = group;
@@ -35,6 +49,26 @@ class UniformNode extends InputNode {
 
 	}
 
+	onUpdate( callback, updateType ) {
+
+		const self = this.getSelf();
+
+		callback = callback.bind( self );
+
+		return super.onUpdate( ( frame ) => {
+
+			const value = callback( frame, self );
+
+			if ( value !== undefined ) {
+
+				this.value = value;
+
+			}
+
+	 	}, updateType );
+
+	}
+
 	generate( builder, output ) {
 
 		const type = this.getNodeType( builder );
@@ -53,7 +87,7 @@ class UniformNode extends InputNode {
 
 		const sharedNodeType = sharedNode.getInputType( builder );
 
-		const nodeUniform = builder.getUniformFromNode( sharedNode, sharedNodeType, builder.shaderStage, builder.context.label );
+		const nodeUniform = builder.getUniformFromNode( sharedNode, sharedNodeType, builder.shaderStage, this.name || builder.context.label );
 		const propertyName = builder.getPropertyName( nodeUniform );
 
 		if ( builder.context.label !== undefined ) delete builder.context.label;
@@ -76,5 +110,3 @@ export const uniform = ( arg1, arg2 ) => {
 	return nodeObject( new UniformNode( value, nodeType ) );
 
 };
-
-addNodeClass( 'UniformNode', UniformNode );

package/{examples/jsm → src}/nodes/core/VarNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class VarNode extends Node {
 
+	static get type() {
+
+		return 'VarNode';
+
+	}
+
 	constructor( node, name = null ) {
 
 		super();
@@ -10,13 +16,9 @@ class VarNode extends Node {
 		this.node = node;
 		this.name = name;
 
-		this.isVarNode = true;
-
-	}
-
-	isGlobal() {
+		this.global = true;
 
-		return true;
+		this.isVarNode = true;
 
 	}
 
@@ -42,7 +44,7 @@ class VarNode extends Node {
 
 		const snippet = node.build( builder, nodeVar.type );
 
-		builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+		builder.addLineFlowCode( `${propertyName} = ${snippet}`, this );
 
 		return propertyName;
 
@@ -52,9 +54,7 @@ class VarNode extends Node {
 
 export default VarNode;
 
-export const temp = nodeProxy( VarNode );
-
-addNodeElement( 'temp', temp ); // @TODO: Will be removed in the future
-addNodeElement( 'toVar', ( ...params ) => temp( ...params ).append() );
+export const temp = /*@__PURE__*/ nodeProxy( VarNode );
 
-addNodeClass( 'VarNode', VarNode );
+addMethodChaining( 'temp', temp ); // @TODO: Will be removed in the future
+addMethodChaining( 'toVar', ( ...params ) => temp( ...params ).append() );

package/src/nodes/core/VaryingNode.js

@@ -0,0 +1,108 @@
+import Node from './Node.js';
+import { NodeShaderStage } from './constants.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
+
+class VaryingNode extends Node {
+
+	static get type() {
+
+		return 'VaryingNode';
+
+	}
+
+	constructor( node, name = null ) {
+
+		super();
+
+		this.node = node;
+		this.name = name;
+
+		this.isVaryingNode = true;
+
+	}
+
+	isGlobal() {
+
+		return true;
+
+	}
+
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
+
+	}
+
+	getNodeType( builder ) {
+
+		// VaryingNode is auto type
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	setupVarying( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		let varying = properties.varying;
+
+		if ( varying === undefined ) {
+
+			const name = this.name;
+			const type = this.getNodeType( builder );
+
+			properties.varying = varying = builder.getVaryingFromNode( this, name, type );
+			properties.node = this.node;
+
+		}
+
+		// this property can be used to check if the varying can be optimized for a variable
+		varying.needsInterpolation || ( varying.needsInterpolation = ( builder.shaderStage === 'fragment' ) );
+
+		return varying;
+
+	}
+
+	setup( builder ) {
+
+		this.setupVarying( builder );
+
+	}
+
+	analyze( builder ) {
+
+		this.setupVarying( builder );
+
+		return this.node.analyze( builder );
+
+	}
+
+	generate( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+		const varying = this.setupVarying( builder );
+
+		if ( properties.propertyName === undefined ) {
+
+			const type = this.getNodeType( builder );
+			const propertyName = builder.getPropertyName( varying, NodeShaderStage.VERTEX );
+
+			// force node run in vertex stage
+			builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, this.node, type, propertyName );
+
+			properties.propertyName = propertyName;
+
+		}
+
+		return builder.getPropertyName( varying );
+
+	}
+
+}
+
+export default VaryingNode;
+
+export const varying = /*@__PURE__*/ nodeProxy( VaryingNode );
+
+addMethodChaining( 'varying', varying );

package/{examples/jsm → src}/nodes/display/AfterImageNode.js

@@ -1,18 +1,30 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, float, vec4 } from '../shadernode/ShaderNode.js';
+import { nodeObject, Fn, float, vec4 } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { texture } from '../accessors/TextureNode.js';
-import { texturePass } from './PassNode.js';
+import { passTexture } from './PassNode.js';
 import { uniform } from '../core/UniformNode.js';
-import { RenderTarget } from 'three';
 import { sign, max } from '../math/MathNode.js';
-import QuadMesh from '../../objects/QuadMesh.js';
+import { convertToTexture } from '../utils/RTTNode.js';
+import QuadMesh from '../../renderers/common/QuadMesh.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
-const quadMeshComp = new QuadMesh();
+import { Vector2 } from '../../math/Vector2.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+
+const _size = /*@__PURE__*/ new Vector2();
+
+const _quadMeshComp = /*@__PURE__*/ new QuadMesh();
 
 class AfterImageNode extends TempNode {
 
+	static get type() {
+
+		return 'AfterImageNode';
+
+	}
+
 	constructor( textureNode, damp = 0.96 ) {
 
 		super( textureNode );
@@ -27,7 +39,7 @@ class AfterImageNode extends TempNode {
 		this._oldRT = new RenderTarget();
 		this._oldRT.texture.name = 'AfterImageNode.old';
 
-		this._textureNode = texturePass( this, this._compRT.texture );
+		this._textureNode = passTexture( this, this._compRT.texture );
 
 		this.updateBeforeType = NodeUpdateType.RENDER;
 
@@ -58,6 +70,10 @@ class AfterImageNode extends TempNode {
 		this._compRT.texture.type = textureType;
 		this._oldRT.texture.type = textureType;
 
+		renderer.getDrawingBufferSize( _size );
+
+		this.setSize( _size.x, _size.y );
+
 		const currentRenderTarget = renderer.getRenderTarget();
 		const currentTexture = textureNode.value;
 
@@ -65,16 +81,13 @@ class AfterImageNode extends TempNode {
 
 		// comp
 		renderer.setRenderTarget( this._compRT );
-		quadMeshComp.render( renderer );
+		_quadMeshComp.render( renderer );
 
 		// Swap the textures
 		const temp = this._oldRT;
 		this._oldRT = this._compRT;
 		this._compRT = temp;
 
-		// set size before swapping fails
-		this.setSize( map.image.width, map.image.height );
-
 		renderer.setRenderTarget( currentRenderTarget );
 		textureNode.value = currentTexture;
 
@@ -85,23 +98,15 @@ class AfterImageNode extends TempNode {
 		const textureNode = this.textureNode;
 		const textureNodeOld = this.textureNodeOld;
 
-		if ( textureNode.isTextureNode !== true ) {
-
-			console.error( 'AfterImageNode requires a TextureNode.' );
-
-			return vec4();
-
-		}
-
 		//
 
 		const uvNode = textureNode.uvNode || uv();
 
 		textureNodeOld.uvNode = uvNode;
 
-		const sampleTexture = ( uv ) => textureNode.cache().context( { getUV: () => uv, forceUVContext: true } );
+		const sampleTexture = ( uv ) => textureNode.uv( uv );
 
-		const when_gt = tslFn( ( [ x_immutable, y_immutable ] ) => {
+		const when_gt = Fn( ( [ x_immutable, y_immutable ] ) => {
 
 			const y = float( y_immutable ).toVar();
 			const x = vec4( x_immutable ).toVar();
@@ -110,7 +115,7 @@ class AfterImageNode extends TempNode {
 
 		} );
 
-		const afterImg = tslFn( () => {
+		const afterImg = Fn( () => {
 
 			const texelOld = vec4( textureNodeOld );
 			const texelNew = vec4( sampleTexture( uvNode ) );
@@ -122,10 +127,11 @@ class AfterImageNode extends TempNode {
 
 		//
 
-		const materialComposed = this._materialComposed || ( this._materialComposed = builder.createNodeMaterial() );
+		const materialComposed = this._materialComposed || ( this._materialComposed = new NodeMaterial() );
+		materialComposed.name = 'AfterImage';
 		materialComposed.fragmentNode = afterImg();
 
-		quadMeshComp.material = materialComposed;
+		_quadMeshComp.material = materialComposed;
 
 		//
 
@@ -138,11 +144,15 @@ class AfterImageNode extends TempNode {
 
 	}
 
-}
+	dispose() {
 
-export const afterImage = ( node, damp ) => nodeObject( new AfterImageNode( nodeObject( node ), damp ) );
+		this._compRT.dispose();
+		this._oldRT.dispose();
 
-addNodeElement( 'afterImage', afterImage );
+	}
 
-export default AfterImageNode;
+}
 
+export const afterImage = ( node, damp ) => nodeObject( new AfterImageNode( convertToTexture( node ), damp ) );
+
+export default AfterImageNode;

package/src/nodes/display/AnaglyphPassNode.js

@@ -0,0 +1,67 @@
+import { Fn, nodeObject, vec4 } from '../tsl/TSLBase.js';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { uniform } from '../core/UniformNode.js';
+import { uv } from '../accessors/UV.js';
+import { clamp, max } from '../math/MathNode.js';
+import StereoCompositePassNode from './StereoCompositePassNode.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+
+class AnaglyphPassNode extends StereoCompositePassNode {
+
+	static get type() {
+
+		return 'AnaglyphPassNode';
+
+	}
+
+	constructor( scene, camera ) {
+
+		super( scene, camera );
+
+		this.isAnaglyphPassNode = true;
+
+		// Dubois matrices from https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.7.6968&rep=rep1&type=pdf#page=4
+
+		this._colorMatrixLeft = uniform( new Matrix3().fromArray( [
+			0.456100, - 0.0400822, - 0.0152161,
+			0.500484, - 0.0378246, - 0.0205971,
+			0.176381, - 0.0157589, - 0.00546856
+		] ) );
+
+		this._colorMatrixRight = uniform( new Matrix3().fromArray( [
+			- 0.0434706, 0.378476, - 0.0721527,
+			- 0.0879388, 0.73364, - 0.112961,
+			- 0.00155529, - 0.0184503, 1.2264
+		] ) );
+
+	}
+
+	setup( builder ) {
+
+		const uvNode = uv();
+
+		const anaglyph = Fn( () => {
+
+			const colorL = this._mapLeft.uv( uvNode );
+			const colorR = this._mapRight.uv( uvNode );
+
+			const color = clamp( this._colorMatrixLeft.mul( colorL.rgb ).add( this._colorMatrixRight.mul( colorR.rgb ) ) );
+
+			return vec4( color.rgb, max( colorL.a, colorR.a ) );
+
+		} );
+
+		const material = this._material || ( this._material = new NodeMaterial() );
+		material.fragmentNode = anaglyph().context( builder.getSharedContext() );
+		material.name = 'Anaglyph';
+		material.needsUpdate = true;
+
+		return super.setup( builder );
+
+	}
+
+}
+
+export default AnaglyphPassNode;
+
+export const anaglyphPass = ( scene, camera ) => nodeObject( new AnaglyphPassNode( scene, camera ) );

package/{examples/jsm → src}/nodes/display/AnamorphicNode.js

@@ -1,18 +1,28 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, float, vec2, vec3, vec4 } from '../shadernode/ShaderNode.js';
-import { loop } from '../utils/LoopNode.js';
+import { nodeObject, Fn, float, vec2, vec3 } from '../tsl/TSLBase.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 { texturePass } from './PassNode.js';
-import { Vector2, RenderTarget } from 'three';
-import QuadMesh from '../../objects/QuadMesh.js';
+import { threshold } from './ColorAdjustment.js';
+import { uv } from '../accessors/UV.js';
+import { passTexture } from './PassNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
+import QuadMesh from '../../renderers/common/QuadMesh.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
-const quadMesh = new QuadMesh();
+import { Vector2 } from '../../math/Vector2.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+
+const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
 class AnamorphicNode extends TempNode {
 
+	static get type() {
+
+		return 'AnamorphicNode';
+
+	}
+
 	constructor( textureNode, tresholdNode, scaleNode, samples ) {
 
 		super( 'vec4' );
@@ -29,7 +39,7 @@ class AnamorphicNode extends TempNode {
 
 		this._invSize = uniform( new Vector2() );
 
-		this._textureNode = texturePass( this, this._renderTarget.texture );
+		this._textureNode = passTexture( this, this._renderTarget.texture );
 
 		this.updateBeforeType = NodeUpdateType.RENDER;
 
@@ -64,7 +74,7 @@ class AnamorphicNode extends TempNode {
 		const currentRenderTarget = renderer.getRenderTarget();
 		const currentTexture = textureNode.value;
 
-		quadMesh.material = this._material;
+		_quadMesh.material = this._material;
 
 		this.setSize( map.image.width, map.image.height );
 
@@ -72,7 +82,7 @@ class AnamorphicNode extends TempNode {
 
 		renderer.setRenderTarget( this._renderTarget );
 
-		quadMesh.render( renderer );
+		_quadMesh.render( renderer );
 
 		// restore
 
@@ -84,29 +94,18 @@ class AnamorphicNode extends TempNode {
 	setup( builder ) {
 
 		const textureNode = this.textureNode;
-
-		if ( textureNode.isTextureNode !== true ) {
-
-			console.error( 'AnamorphNode requires a TextureNode.' );
-
-			return vec4();
-
-		}
-
-		//
-
 		const uvNode = textureNode.uvNode || uv();
 
-		const sampleTexture = ( uv ) => textureNode.cache().context( { getUV: () => uv, forceUVContext: true } );
+		const sampleTexture = ( uv ) => textureNode.uv( uv );
 
-		const anamorph = tslFn( () => {
+		const anamorph = Fn( () => {
 
 			const samples = this.samples;
 			const halfSamples = Math.floor( samples / 2 );
 
 			const total = vec3( 0 ).toVar();
 
-			loop( { start: - halfSamples, end: halfSamples }, ( { i } ) => {
+			Loop( { start: - halfSamples, end: halfSamples }, ( { i } ) => {
 
 				const softness = float( i ).abs().div( halfSamples ).oneMinus();
 
@@ -124,7 +123,8 @@ class AnamorphicNode extends TempNode {
 
 		//
 
-		const material = this._material || ( this._material = builder.createNodeMaterial() );
+		const material = this._material || ( this._material = new NodeMaterial() );
+		material.name = 'Anamorphic';
 		material.fragmentNode = anamorph();
 
 		//
@@ -138,11 +138,14 @@ class AnamorphicNode extends TempNode {
 
 	}
 
-}
+	dispose() {
 
-export const anamorphic = ( node, threshold = .9, scale = 3, samples = 32 ) => nodeObject( new AnamorphicNode( nodeObject( node ), nodeObject( threshold ), nodeObject( scale ), samples ) );
+		this._renderTarget.dispose();
 
-addNodeElement( 'anamorphic', anamorphic );
+	}
 
-export default AnamorphicNode;
+}
 
+export const anamorphic = ( node, threshold = .9, scale = 3, samples = 32 ) => nodeObject( new AnamorphicNode( convertToTexture( node ), nodeObject( threshold ), nodeObject( scale ), samples ) );
+
+export default AnamorphicNode;

package/src/nodes/display/BleachBypass.js

@@ -0,0 +1,26 @@
+import { float, Fn, vec3, vec4 } from '../tsl/TSLBase.js';
+import { min, max, mix } from '../math/MathNode.js';
+import { luminance } from './ColorAdjustment.js';
+
+export const bleach = /*@__PURE__*/ Fn( ( [ color, opacity = 1 ] ) => {
+
+	const base = color;
+	const lum = luminance( base.rgb );
+	const blend = vec3( lum );
+
+	const L = min( 1.0, max( 0.0, float( 10.0 ).mul( lum.sub( 0.45 ) ) ) );
+
+	const result1 = blend.mul( base.rgb ).mul( 2.0 );
+	const result2 = float( 2.0 ).mul( blend.oneMinus() ).mul( base.rgb.oneMinus() ).oneMinus();
+
+	const newColor = mix( result1, result2, L );
+
+	const A2 = base.a.mul( opacity );
+
+	const mixRGB = A2.mul( newColor.rgb );
+
+	mixRGB.addAssign( base.rgb.mul( A2.oneMinus() ) );
+
+	return vec4( mixRGB, base.a );
+
+} );

package/src/nodes/display/BlendMode.js

@@ -0,0 +1,54 @@
+import { Fn } from '../tsl/TSLBase.js';
+import { mix, min, step } from '../math/MathNode.js';
+
+export const burn = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
+
+	return min( 1.0, base.oneMinus().div( blend ) ).oneMinus();
+
+} ).setLayout( {
+	name: 'burnBlend',
+	type: 'vec3',
+	inputs: [
+		{ name: 'base', type: 'vec3' },
+		{ name: 'blend', type: 'vec3' }
+	]
+} );
+
+export const dodge = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
+
+	return min( base.div( blend.oneMinus() ), 1.0 );
+
+} ).setLayout( {
+	name: 'dodgeBlend',
+	type: 'vec3',
+	inputs: [
+		{ name: 'base', type: 'vec3' },
+		{ name: 'blend', type: 'vec3' }
+	]
+} );
+
+export const screen = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
+
+	return base.oneMinus().mul( blend.oneMinus() ).oneMinus();
+
+} ).setLayout( {
+	name: 'screenBlend',
+	type: 'vec3',
+	inputs: [
+		{ name: 'base', type: 'vec3' },
+		{ name: 'blend', type: 'vec3' }
+	]
+} );
+
+export const overlay = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
+
+	return mix( base.mul( 2.0 ).mul( blend ), base.oneMinus().mul( 2.0 ).mul( blend.oneMinus() ).oneMinus(), step( 0.5, base ) );
+
+} ).setLayout( {
+	name: 'overlayBlend',
+	type: 'vec3',
+	inputs: [
+		{ name: 'base', type: 'vec3' },
+		{ name: 'blend', type: 'vec3' }
+	]
+} );