super-three 0.167.0 → 0.168.0

package/src/nodes/core/StackNode.js

@@ -1,6 +1,6 @@
-import Node, { addNodeClass } from './Node.js';
-import { cond } from '../math/CondNode.js';
-import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { select } from '../math/ConditionalNode.js';
+import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../tsl/TSLBase.js';
 
 class StackNode extends Node {
 
@@ -33,19 +33,19 @@ class StackNode extends Node {
 
 	}
 
-	if( boolNode, method ) {
+	If( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		this._currentCond = cond( boolNode, methodNode );
+		this._currentCond = select( boolNode, methodNode );
 
 		return this.add( this._currentCond );
 
 	}
 
-	elseif( boolNode, method ) {
+	ElseIf( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		const ifNode = cond( boolNode, methodNode );
+		const ifNode = select( boolNode, methodNode );
 
 		this._currentCond.elseNode = ifNode;
 		this._currentCond = ifNode;
@@ -54,7 +54,7 @@ class StackNode extends Node {
 
 	}
 
-	else( method ) {
+	Else( method ) {
 
 		this._currentCond.elseNode = new ShaderNode( method );
 
@@ -80,10 +80,26 @@ class StackNode extends Node {
 
 	}
 
+	//
+
+	else( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .else() has been renamed to .Else().' );
+		return this.Else( ...params );
+
+	}
+
+	elseif( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .elseif() has been renamed to .ElseIf().' );
+		return this.ElseIf( ...params );
+
+	}
+
 }
 
 export default StackNode;
 
-export const stack = nodeProxy( StackNode );
+StackNode.type = /*@__PURE__*/ registerNode( 'Stack', StackNode );
 
-addNodeClass( 'StackNode', StackNode );
+export const stack = /*@__PURE__*/ nodeProxy( StackNode );

package/src/nodes/core/StructTypeNode.js

@@ -1,4 +1,4 @@
-import Node, { addNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 
 class StructTypeNode extends Node {
 
@@ -21,4 +21,4 @@ class StructTypeNode extends Node {
 
 export default StructTypeNode;
 
-addNodeClass( 'StructTypeNode', StructTypeNode );
+StructTypeNode.type = /*@__PURE__*/ registerNode( 'StructType', StructTypeNode );

package/src/nodes/core/TempNode.js

@@ -1,4 +1,4 @@
-import Node, { addNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 
 class TempNode extends Node {
 
@@ -55,4 +55,4 @@ class TempNode extends Node {
 
 export default TempNode;
 
-addNodeClass( 'TempNode', TempNode );
+TempNode.type = /*@__PURE__*/ registerNode( 'Temp', TempNode );

package/src/nodes/core/UniformGroupNode.js

@@ -1,5 +1,4 @@
-import Node from './Node.js';
-import { addNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 
 class UniformGroupNode extends Node {
 
@@ -44,13 +43,13 @@ class UniformGroupNode extends Node {
 
 }
 
-export const uniformGroup = ( name ) => new UniformGroupNode( name );
-export const sharedUniformGroup = ( name ) => new UniformGroupNode( name, true );
+export default UniformGroupNode;
 
-export const frameGroup = sharedUniformGroup( 'frame' );
-export const renderGroup = sharedUniformGroup( 'render' );
-export const objectGroup = uniformGroup( 'object' );
+UniformGroupNode.type = /*@__PURE__*/ registerNode( 'UniformGroup', UniformGroupNode );
 
-export default UniformGroupNode;
+export const uniformGroup = ( name ) => new UniformGroupNode( name );
+export const sharedUniformGroup = ( name ) => new UniformGroupNode( name, true );
 
-addNodeClass( 'UniformGroupNode', UniformGroupNode );
+export const frameGroup = /*@__PURE__*/ sharedUniformGroup( 'frame' );
+export const renderGroup = /*@__PURE__*/ sharedUniformGroup( 'render' );
+export const objectGroup = /*@__PURE__*/ uniformGroup( 'object' );

package/src/nodes/core/UniformNode.js

@@ -1,7 +1,7 @@
+import { registerNode } from './Node.js';
 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 {
 
@@ -95,6 +95,8 @@ class UniformNode extends InputNode {
 
 export default UniformNode;
 
+UniformNode.type = /*@__PURE__*/ registerNode( 'Uniform', UniformNode );
+
 export const uniform = ( arg1, arg2 ) => {
 
 	const nodeType = getConstNodeType( arg2 || arg1 );
@@ -105,5 +107,3 @@ export const uniform = ( arg1, arg2 ) => {
 	return nodeObject( new UniformNode( value, nodeType ) );
 
 };
-
-addNodeClass( 'UniformNode', UniformNode );

package/src/nodes/core/VarNode.js

@@ -1,5 +1,5 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class VarNode extends Node {
 
@@ -48,9 +48,9 @@ class VarNode extends Node {
 
 export default VarNode;
 
-export const temp = nodeProxy( VarNode );
+VarNode.type = /*@__PURE__*/ registerNode( 'Var', 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

@@ -1,6 +1,6 @@
-import Node, { addNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { NodeShaderStage } from './constants.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class VaryingNode extends Node {
 
@@ -97,8 +97,8 @@ class VaryingNode extends Node {
 
 export default VaryingNode;
 
-export const varying = nodeProxy( VaryingNode );
+VaryingNode.type = /*@__PURE__*/ registerNode( 'Varying', VaryingNode );
 
-addNodeElement( 'varying', varying );
+export const varying = /*@__PURE__*/ nodeProxy( VaryingNode );
 
-addNodeClass( 'VaryingNode', VaryingNode );
+addMethodChaining( 'varying', varying );

package/src/nodes/display/AfterImageNode.js

@@ -1,12 +1,14 @@
 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 { passTexture } from './PassNode.js';
 import { uniform } from '../core/UniformNode.js';
 import { sign, max } from '../math/MathNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
 import QuadMesh from '../../renderers/common/QuadMesh.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
 import { Vector2 } from '../../math/Vector2.js';
 import { RenderTarget } from '../../core/RenderTarget.js';
@@ -98,7 +100,7 @@ class AfterImageNode extends TempNode {
 
 		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();
@@ -107,7 +109,7 @@ class AfterImageNode extends TempNode {
 
 		} );
 
-		const afterImg = tslFn( () => {
+		const afterImg = Fn( () => {
 
 			const texelOld = vec4( textureNodeOld );
 			const texelNew = vec4( sampleTexture( uvNode ) );
@@ -119,7 +121,8 @@ 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;
@@ -144,9 +147,6 @@ class AfterImageNode extends TempNode {
 
 }
 
-export const afterImage = ( node, damp ) => nodeObject( new AfterImageNode( nodeObject( node ).toTexture(), damp ) );
-
-addNodeElement( 'afterImage', afterImage );
+export const afterImage = ( node, damp ) => nodeObject( new AfterImageNode( convertToTexture( node ), damp ) );
 
 export default AfterImageNode;
-

package/src/nodes/display/AnaglyphPassNode.js

@@ -0,0 +1,61 @@
+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 {
+
+	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/src/nodes/display/AnamorphicNode.js

@@ -1,12 +1,14 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, float, vec2, vec3 } 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 { 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';
 
 import { Vector2 } from '../../math/Vector2.js';
 import { RenderTarget } from '../../core/RenderTarget.js';
@@ -90,14 +92,14 @@ class AnamorphicNode extends TempNode {
 
 		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();
 
@@ -115,7 +117,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();
 
 		//
@@ -137,9 +140,6 @@ class AnamorphicNode extends TempNode {
 
 }
 
-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 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' }
+	]
+} );

package/src/nodes/display/BloomNode.js

@@ -1,21 +1,22 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeElement, tslFn, nodeObject, float, vec4, int } from '../shadernode/ShaderNode.js';
+import { Fn, nodeObject, float, vec4, int } from '../tsl/TSLBase.js';
 import { mix, smoothstep } from '../math/MathNode.js';
-import { luminance } from './ColorAdjustmentNode.js';
+import { luminance } from './ColorAdjustment.js';
 import { uniform } from '../core/UniformNode.js';
-import { uniforms } from '../accessors/UniformsNode.js';
-import { uv } from '../accessors/UVNode.js';
+import { uniformArray } from '../accessors/UniformArrayNode.js';
+import { uv } from '../accessors/UV.js';
 import { Color } from '../../math/Color.js';
 import { passTexture } from './PassNode.js';
 import { RenderTarget } from '../../core/RenderTarget.js';
 import { HalfFloatType } from '../../constants.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { Vector2 } from '../../math/Vector2.js';
-import { loop } from '../utils/LoopNode.js';
+import { Loop } from '../utils/LoopNode.js';
 import { add } from '../math/OperatorNode.js';
 import QuadMesh from '../../renderers/common/QuadMesh.js';
 import { texture } from '../accessors/TextureNode.js';
 import { Vector3 } from '../../math/Vector3.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
@@ -183,7 +184,7 @@ class BloomNode extends TempNode {
 
 		// luminosity high pass material
 
-		const luminosityHighPass = tslFn( () => {
+		const luminosityHighPass = Fn( () => {
 
 			const texel = this.inputNode;
 			const v = luminance( texel.rgb );
@@ -194,8 +195,9 @@ class BloomNode extends TempNode {
 
 		} );
 
-		this._highPassFilterMaterial = this._highPassFilterMaterial || builder.createNodeMaterial();
+		this._highPassFilterMaterial = this._highPassFilterMaterial || new NodeMaterial();
 		this._highPassFilterMaterial.fragmentNode = luminosityHighPass().context( builder.getSharedContext() );
+		this._highPassFilterMaterial.name = 'Bloom_highPass';
 		this._highPassFilterMaterial.needsUpdate = true;
 
 		// gaussian blur materials
@@ -210,10 +212,10 @@ class BloomNode extends TempNode {
 
 		// composite material
 
-		const bloomFactors = uniforms( [ 1.0, 0.8, 0.6, 0.4, 0.2 ] );
-		const bloomTintColors = uniforms( [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ] );
+		const bloomFactors = uniformArray( [ 1.0, 0.8, 0.6, 0.4, 0.2 ] );
+		const bloomTintColors = uniformArray( [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ] );
 
-		const lerpBloomFactor = tslFn( ( [ factor, radius ] ) => {
+		const lerpBloomFactor = Fn( ( [ factor, radius ] ) => {
 
 			const mirrorFactor = float( 1.2 ).sub( factor );
 			return mix( factor, mirrorFactor, radius );
@@ -228,7 +230,7 @@ class BloomNode extends TempNode {
 		} );
 
 
-		const compositePass = tslFn( () => {
+		const compositePass = Fn( () => {
 
 			const color0 = lerpBloomFactor( bloomFactors.element( 0 ), this.radius ).mul( vec4( bloomTintColors.element( 0 ), 1.0 ) ).mul( this._textureNodeBlur0 );
 			const color1 = lerpBloomFactor( bloomFactors.element( 1 ), this.radius ).mul( vec4( bloomTintColors.element( 1 ), 1.0 ) ).mul( this._textureNodeBlur1 );
@@ -242,8 +244,9 @@ class BloomNode extends TempNode {
 
 		} );
 
-		this._compositeMaterial = this._compositeMaterial || builder.createNodeMaterial();
+		this._compositeMaterial = this._compositeMaterial || new NodeMaterial();
 		this._compositeMaterial.fragmentNode = compositePass().context( builder.getSharedContext() );
+		this._compositeMaterial.name = 'Bloom_comp';
 		this._compositeMaterial.needsUpdate = true;
 
 		//
@@ -283,19 +286,19 @@ class BloomNode extends TempNode {
 		//
 
 		const colorTexture = texture();
-		const gaussianCoefficients = uniforms( coefficients );
+		const gaussianCoefficients = uniformArray( coefficients );
 		const invSize = uniform( new Vector2() );
 		const direction = uniform( new Vector2( 0.5, 0.5 ) );
 
 		const uvNode = uv();
 		const sampleTexel = ( uv ) => colorTexture.uv( uv );
 
-		const seperableBlurPass = tslFn( () => {
+		const seperableBlurPass = Fn( () => {
 
 			const weightSum = gaussianCoefficients.element( 0 ).toVar();
 			const diffuseSum = sampleTexel( uvNode ).rgb.mul( weightSum ).toVar();
 
-			loop( { start: int( 1 ), end: int( kernelRadius ), type: 'int', condition: '<' }, ( { i } ) => {
+			Loop( { start: int( 1 ), end: int( kernelRadius ), type: 'int', condition: '<' }, ( { i } ) => {
 
 				const x = float( i );
 				const w = gaussianCoefficients.element( i );
@@ -305,14 +308,15 @@ class BloomNode extends TempNode {
 				diffuseSum.addAssign( add( sample1, sample2 ).mul( w ) );
 				weightSum.addAssign( float( 2.0 ).mul( w ) );
 
-			} );
+			} );
 
 			return vec4( diffuseSum.div( weightSum ), 1.0 );
 
 		} );
 
-		const seperableBlurMaterial = builder.createNodeMaterial();
+		const seperableBlurMaterial = new NodeMaterial();
 		seperableBlurMaterial.fragmentNode = seperableBlurPass().context( builder.getSharedContext() );
+		seperableBlurMaterial.name = 'Bloom_seperable';
 		seperableBlurMaterial.needsUpdate = true;
 
 		// uniforms
@@ -328,6 +332,4 @@ class BloomNode extends TempNode {
 
 export const bloom = ( node, strength, radius, threshold ) => nodeObject( new BloomNode( nodeObject( node ), strength, radius, threshold ) );
 
-addNodeElement( 'bloom', bloom );
-
 export default BloomNode;

package/src/nodes/display/BumpMapNode.js

@@ -1,15 +1,14 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { uv } from '../accessors/UVNode.js';
-import { normalView } from '../accessors/NormalNode.js';
-import { positionView } from '../accessors/PositionNode.js';
+import { uv } from '../accessors/UV.js';
+import { normalView } from '../accessors/Normal.js';
+import { positionView } from '../accessors/Position.js';
 import { faceDirection } from './FrontFacingNode.js';
-import { addNodeElement, tslFn, nodeProxy, float, vec2 } from '../shadernode/ShaderNode.js';
+import { Fn, nodeProxy, float, vec2 } from '../tsl/TSLBase.js';
 
 // Bump Mapping Unparametrized Surfaces on the GPU by Morten S. Mikkelsen
 // https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf
 
-const dHdxy_fwd = tslFn( ( { textureNode, bumpScale } ) => {
+const dHdxy_fwd = Fn( ( { textureNode, bumpScale } ) => {
 
 	// It's used to preserve the same TextureNode instance
 	const sampleTexture = ( callback ) => textureNode.cache().context( { getUV: ( texNode ) => callback( texNode.uvNode || uv() ), forceUVContext: true } );
@@ -25,7 +24,7 @@ const dHdxy_fwd = tslFn( ( { textureNode, bumpScale } ) => {
 
 // Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)
 
-const perturbNormalArb = tslFn( ( inputs ) => {
+const perturbNormalArb = Fn( ( inputs ) => {
 
 	const { surf_pos, surf_norm, dHdxy } = inputs;
 
@@ -73,8 +72,4 @@ class BumpMapNode extends TempNode {
 
 export default BumpMapNode;
 
-export const bumpMap = nodeProxy( BumpMapNode );
-
-addNodeElement( 'bumpMap', bumpMap );
-
-addNodeClass( 'BumpMapNode', BumpMapNode );
+export const bumpMap = /*@__PURE__*/ nodeProxy( BumpMapNode );

package/src/nodes/display/ColorAdjustment.js

@@ -0,0 +1,46 @@
+import { dot, mix } from '../math/MathNode.js';
+import { add } from '../math/OperatorNode.js';
+import { Fn, float, vec3 } from '../tsl/TSLBase.js';
+import { ColorManagement } from '../../math/ColorManagement.js';
+import { Vector3 } from '../../math/Vector3.js';
+
+export const grayscale = /*@__PURE__*/ Fn( ( [ color ] ) => {
+
+	return luminance( color.rgb );
+
+} );
+
+export const saturation = /*@__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
+
+	return adjustment.mix( luminance( color.rgb ), color.rgb );
+
+} );
+
+export const vibrance = /*@__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
+
+	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 );
+
+} );
+
+export const hue = /*@__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
+
+	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() ) ) ) ) );
+
+} );
+
+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 ) );