super-three 0.167.0 → 0.169.0

package/src/nodes/display/ColorSpaceNode.js

@@ -1,108 +1,114 @@
 import TempNode from '../core/TempNode.js';
-import { mix } from '../math/MathNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeObject, nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeObject, vec4 } from '../tsl/TSLCore.js';
 
 import { LinearSRGBColorSpace, SRGBColorSpace } from '../../constants.js';
+import { ColorManagement } from '../../math/ColorManagement.js';
 
-const sRGBToLinearShader = tslFn( ( inputs ) => {
+const WORKING_COLOR_SPACE = 'WorkingColorSpace';
+const OUTPUT_COLOR_SPACE = 'OutputColorSpace';
 
-	const { value } = inputs;
-	const { rgb } = value;
+function getColorSpaceName( colorSpace ) {
 
-	const a = rgb.mul( 0.9478672986 ).add( 0.0521327014 ).pow( 2.4 );
-	const b = rgb.mul( 0.0773993808 );
-	const factor = rgb.lessThanEqual( 0.04045 );
+	let method = null;
 
-	const rgbResult = mix( a, b, factor );
+	if ( colorSpace === LinearSRGBColorSpace ) {
 
-	return vec4( rgbResult, value.a );
+		method = 'Linear';
 
-} );
+	} else if ( colorSpace === SRGBColorSpace ) {
 
-const LinearTosRGBShader = tslFn( ( inputs ) => {
+		method = 'sRGB';
 
-	const { value } = inputs;
-	const { rgb } = value;
+	}
 
-	const a = rgb.pow( 0.41666 ).mul( 1.055 ).sub( 0.055 );
-	const b = rgb.mul( 12.92 );
-	const factor = rgb.lessThanEqual( 0.0031308 );
+	return method;
 
-	const rgbResult = mix( a, b, factor );
+}
 
-	return vec4( rgbResult, value.a );
+export function getColorSpaceMethod( source, target ) {
 
-} );
+	return getColorSpaceName( source ) + 'To' + getColorSpaceName( target );
 
-const getColorSpaceMethod = ( colorSpace ) => {
+}
 
-	let method = null;
+class ColorSpaceNode extends TempNode {
 
-	if ( colorSpace === LinearSRGBColorSpace ) {
+	static get type() {
 
-		method = 'Linear';
+		return 'ColorSpaceNode';
 
-	} else if ( colorSpace === SRGBColorSpace ) {
+	}
 
-		method = 'sRGB';
+	constructor( colorNode, source, target ) {
 
-	}
+		super( 'vec4' );
 
-	return method;
+		this.colorNode = colorNode;
+		this.source = source;
+		this.target = target;
 
-};
+	}
 
-const getMethod = ( source, target ) => {
+	getColorSpace( builder, colorSpace ) {
 
-	return getColorSpaceMethod( source ) + 'To' + getColorSpaceMethod( target );
+		if ( colorSpace === WORKING_COLOR_SPACE ) {
 
-};
+			return ColorManagement.workingColorSpace;
 
-class ColorSpaceNode extends TempNode {
+		} else if ( colorSpace === OUTPUT_COLOR_SPACE ) {
 
-	constructor( method, node ) {
+			return builder.context.outputColorSpace || builder.renderer.outputColorSpace;
 
-		super( 'vec4' );
+		}
 
-		this.method = method;
-		this.node = node;
+		return colorSpace;
 
 	}
 
-	setup() {
+	setup( builder ) {
 
-		const { method, node } = this;
+		const { renderer } = builder;
+		const { colorNode } = this;
 
-		if ( method === ColorSpaceNode.LINEAR_TO_LINEAR )
-			return node;
+		const source = this.getColorSpace( builder, this.source );
+		const target = this.getColorSpace( builder, this.target );
 
-		return Methods[ method ]( { value: node } );
+		if ( source === target ) return colorNode;
 
-	}
+		const colorSpace = getColorSpaceMethod( source, target );
 
-}
+		let outputNode = null;
+
+		const colorSpaceFn = renderer.nodes.library.getColorSpaceFunction( colorSpace );
+
+		if ( colorSpaceFn !== null ) {
 
-ColorSpaceNode.LINEAR_TO_LINEAR = 'LinearToLinear';
-ColorSpaceNode.LINEAR_TO_sRGB = 'LinearTosRGB';
-ColorSpaceNode.sRGB_TO_LINEAR = 'sRGBToLinear';
+			outputNode = vec4( colorSpaceFn( colorNode.rgb ), colorNode.a );
 
-const Methods = {
-	[ ColorSpaceNode.LINEAR_TO_sRGB ]: LinearTosRGBShader,
-	[ ColorSpaceNode.sRGB_TO_LINEAR ]: sRGBToLinearShader
-};
+		} else {
+
+			console.error( 'ColorSpaceNode: Unsupported Color Space configuration.', colorSpace );
+
+			outputNode = colorNode;
+
+		}
+
+		return outputNode;
+
+	}
+
+}
 
 export default ColorSpaceNode;
 
-export const linearToColorSpace = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( LinearSRGBColorSpace, colorSpace ), nodeObject( node ) ) );
-export const colorSpaceToLinear = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( colorSpace, LinearSRGBColorSpace ), nodeObject( node ) ) );
+export const toOutputColorSpace = ( node ) => nodeObject( new ColorSpaceNode( nodeObject( node ), WORKING_COLOR_SPACE, OUTPUT_COLOR_SPACE ) );
+export const toWorkingColorSpace = ( node ) => nodeObject( new ColorSpaceNode( nodeObject( node ), OUTPUT_COLOR_SPACE, WORKING_COLOR_SPACE ) );
 
-export const linearTosRGB = nodeProxy( ColorSpaceNode, ColorSpaceNode.LINEAR_TO_sRGB );
-export const sRGBToLinear = nodeProxy( ColorSpaceNode, ColorSpaceNode.sRGB_TO_LINEAR );
+export const workingToColorSpace = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( nodeObject( node ), WORKING_COLOR_SPACE, colorSpace ) );
+export const colorSpaceToWorking = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( nodeObject( node ), colorSpace, WORKING_COLOR_SPACE ) );
 
-addNodeElement( 'linearTosRGB', linearTosRGB );
-addNodeElement( 'sRGBToLinear', sRGBToLinear );
-addNodeElement( 'linearToColorSpace', linearToColorSpace );
-addNodeElement( 'colorSpaceToLinear', colorSpaceToLinear );
+addMethodChaining( 'toOutputColorSpace', toOutputColorSpace );
+addMethodChaining( 'toWorkingColorSpace', toWorkingColorSpace );
 
-addNodeClass( 'ColorSpaceNode', ColorSpaceNode );
+addMethodChaining( 'workingToColorSpace', workingToColorSpace );
+addMethodChaining( 'colorSpaceToWorking', colorSpaceToWorking );

package/src/nodes/display/DenoiseNode.js

@@ -1,18 +1,26 @@
 import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, tslFn, nodeObject, float, int, vec2, vec3, vec4, mat2, If } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { Fn, nodeObject, float, int, vec2, vec3, vec4, mat2, If } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
-import { uniforms } from '../accessors/UniformsNode.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 { Loop } from '../utils/LoopNode.js';
+import { luminance } from './ColorAdjustment.js';
 import { textureSize } from '../accessors/TextureSizeNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
+
 import { Vector2 } from '../../math/Vector2.js';
 import { Vector3 } from '../../math/Vector3.js';
 
 class DenoiseNode extends TempNode {
 
+	static get type() {
+
+		return 'DenoiseNode';
+
+	}
+
 	constructor( textureNode, depthNode, normalNode, noiseNode, camera ) {
 
 		super();
@@ -30,7 +38,7 @@ class DenoiseNode extends TempNode {
 		this.index = uniform( 0 );
 
 		this._resolution = uniform( new Vector2() );
-		this._sampleVectors = uniforms( generatePdSamplePointInitializer( 16, 2, 1 ) );
+		this._sampleVectors = uniformArray( generatePdSamplePointInitializer( 16, 2, 1 ) );
 
 		this.updateBeforeType = NodeUpdateType.RENDER;
 
@@ -53,7 +61,7 @@ class DenoiseNode extends TempNode {
 		const sampleNormal = ( uv ) => this.normalNode.uv( uv );
 		const sampleNoise = ( uv ) => this.noiseNode.uv( uv );
 
-		const getViewPosition = tslFn( ( [ screenPosition, depth ] ) => {
+		const getViewPosition = Fn( ( [ screenPosition, depth ] ) => {
 
 			screenPosition = vec2( screenPosition.x, screenPosition.y.oneMinus() ).mul( 2.0 ).sub( 1.0 );
 
@@ -64,7 +72,7 @@ class DenoiseNode extends TempNode {
 
 		} );
 
-		const denoiseSample = tslFn( ( [ center, viewNormal, viewPosition, sampleUv ] ) => {
+		const denoiseSample = Fn( ( [ center, viewNormal, viewPosition, sampleUv ] ) => {
 
 			const texel = sampleTexture( sampleUv );
 			const depth = sampleDepth( sampleUv );
@@ -84,7 +92,7 @@ class DenoiseNode extends TempNode {
 
 		} );
 
-		const denoise = tslFn( ( [ uvNode ] ) => {
+		const denoise = Fn( ( [ uvNode ] ) => {
 
 			const depth = sampleDepth( uvNode );
 			const viewNormal = sampleNormal( uvNode ).rgb.normalize();
@@ -115,7 +123,7 @@ class DenoiseNode extends TempNode {
 			const totalWeight = float( 1.0 ).toVar();
 			const denoised = vec3( texel.rgb ).toVar();
 
-			loop( { start: int( 0 ), end: int( 16 ), type: 'int', condition: '<' }, ( { i } ) => {
+			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();
@@ -126,7 +134,7 @@ class DenoiseNode extends TempNode {
 				denoised.addAssign( result.xyz );
 				totalWeight.addAssign( result.w );
 
-			} );
+			} );
 
 			If( totalWeight.greaterThan( float( 0 ) ), () => {
 
@@ -144,7 +152,7 @@ class DenoiseNode extends TempNode {
 			]
 		} );
 
-		const output = tslFn( () => {
+		const output = Fn( () => {
 
 			return denoise( uvNode );
 
@@ -158,6 +166,8 @@ class DenoiseNode extends TempNode {
 
 }
 
+export default DenoiseNode;
+
 function generatePdSamplePointInitializer( samples, rings, radiusExponent ) {
 
 	const poissonDisk = generateDenoiseSamples( samples, rings, radiusExponent );
@@ -191,8 +201,4 @@ function generateDenoiseSamples( numSamples, numRings, radiusExponent ) {
 
 }
 
-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;
+export const denoise = ( node, depthNode, normalNode, noiseNode, camera ) => nodeObject( new DenoiseNode( convertToTexture( node ), nodeObject( depthNode ), nodeObject( normalNode ), nodeObject( noiseNode ), camera ) );

package/src/nodes/display/DepthOfFieldNode.js

@@ -1,12 +1,19 @@
 import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, tslFn, nodeObject, vec2, vec4 } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { Fn, nodeObject, vec2, vec4 } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { clamp } from '../math/MathNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
 
 class DepthOfFieldNode extends TempNode {
 
+	static get type() {
+
+		return 'DepthOfFieldNode';
+
+	}
+
 	constructor( textureNode, viewZNode, focusNode, apertureNode, maxblurNode ) {
 
 		super();
@@ -39,7 +46,7 @@ class DepthOfFieldNode extends TempNode {
 
 		const sampleTexture = ( uv ) => textureNode.uv( uv );
 
-		const dof = tslFn( () => {
+		const dof = Fn( () => {
 
 			const aspectcorrect = vec2( 1.0, this._aspect );
 
@@ -112,8 +119,6 @@ class DepthOfFieldNode extends TempNode {
 
 }
 
-export const dof = ( node, viewZNode, focus = 1, aperture = 0.025, maxblur = 1 ) => nodeObject( new DepthOfFieldNode( nodeObject( node ).toTexture(), nodeObject( viewZNode ), nodeObject( focus ), nodeObject( aperture ), nodeObject( maxblur ) ) );
-
-addNodeElement( 'dof', dof );
-
 export default DepthOfFieldNode;
+
+export const dof = ( node, viewZNode, focus = 1, aperture = 0.025, maxblur = 1 ) => nodeObject( new DepthOfFieldNode( convertToTexture( node ), nodeObject( viewZNode ), nodeObject( focus ), nodeObject( aperture ), nodeObject( maxblur ) ) );

package/src/nodes/display/DotScreenNode.js

@@ -1,15 +1,21 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, vec2, vec3, vec4 } from '../shadernode/ShaderNode.js';
+import { nodeObject, Fn, vec2, vec3, vec4 } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { sin, cos } from '../math/MathNode.js';
 import { add } from '../math/OperatorNode.js';
+import { screenSize } from './ScreenNode.js';
 
 import { Vector2 } from '../../math/Vector2.js';
 
 class DotScreenNode extends TempNode {
 
+	static get type() {
+
+		return 'DotScreenNode';
+
+	}
+
 	constructor( inputNode, center = new Vector2( 0.5, 0.5 ), angle = 1.57, scale = 1 ) {
 
 		super( 'vec4' );
@@ -19,37 +25,25 @@ class DotScreenNode extends TempNode {
 		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 = tslFn( () => {
+		const pattern = Fn( () => {
 
 			const s = sin( this.angle );
 			const c = cos( this.angle );
 
-			const tex = uv().mul( this._size ).sub( this.center );
+			const tex = uv().mul( screenSize ).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 = tslFn( () => {
+		const dotScreen = Fn( () => {
 
 			const color = inputNode;
 
@@ -67,9 +61,6 @@ class DotScreenNode extends TempNode {
 
 }
 
-export const dotScreen = ( node, center, angle, scale ) => nodeObject( new DotScreenNode( nodeObject( node ), center, angle, scale ) );
-
-addNodeElement( 'dotScreen', dotScreen );
-
 export default DotScreenNode;
 
+export const dotScreen = ( node, center, angle, scale ) => nodeObject( new DotScreenNode( nodeObject( node ), center, angle, scale ) );

package/src/nodes/display/FXAANode.js

@@ -1,16 +1,23 @@
 import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, tslFn, nodeObject, float, vec2, vec4, int, If } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { Fn, nodeObject, float, vec2, vec4, int, If } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { abs, max, min, mix, pow } from '../math/MathNode.js';
 import { sub } from '../math/OperatorNode.js';
-import { loop, Break } from '../utils/LoopNode.js';
+import { Loop, Break } from '../utils/LoopNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
 
 import { Vector2 } from '../../math/Vector2.js';
 
 class FXAANode extends TempNode {
 
+	static get type() {
+
+		return 'FXAANode';
+
+	}
+
 	constructor( textureNode ) {
 
 		super();
@@ -77,7 +84,7 @@ class FXAANode extends TempNode {
 
 		const NUM_SAMPLES = int( 5 );
 
-		const contrast = tslFn( ( [ a_immutable, b_immutable ] ) => {
+		const contrast = Fn( ( [ a_immutable, b_immutable ] ) => {
 
 			// assumes colors have premultipliedAlpha, so that the calculated color contrast is scaled by alpha
 
@@ -91,7 +98,7 @@ class FXAANode extends TempNode {
 
 		// FXAA3 QUALITY - PC
 
-		const FxaaPixelShader = tslFn( ( [ uv, fxaaQualityRcpFrame, fxaaQualityEdgeThreshold, fxaaQualityinvEdgeThreshold ] ) => {
+		const FxaaPixelShader = Fn( ( [ uv, fxaaQualityRcpFrame, fxaaQualityEdgeThreshold, fxaaQualityinvEdgeThreshold ] ) => {
 
 			const rgbaM = FxaaTexTop( uv ).toVar();
 			const rgbaS = FxaaTexOff( uv, vec2( 0.0, - 1.0 ), fxaaQualityRcpFrame.xy ).toVar();
@@ -130,8 +137,8 @@ class FXAANode extends TempNode {
 
 				// locate the edge
 
-				const x = contrastE.greaterThan( contrastW ).cond( 1, - 1 ).toVar();
-				const y = contrastS.greaterThan( contrastN ).cond( 1, - 1 ).toVar();
+				const x = contrastE.greaterThan( contrastW ).select( 1, - 1 ).toVar();
+				const y = contrastS.greaterThan( contrastN ).select( 1, - 1 ).toVar();
 
 				const dirToEdge = vec2( x, y ).toVar();
 				// . 2 .      . 1 .
@@ -184,7 +191,7 @@ class FXAANode extends TempNode {
 				offNP.x.assign( 0 );
 				offNP.y.assign( fxaaQualityRcpFrame.y );
 
-			 } ).else( () => {
+			 } ).Else( () => {
 
 				offNP.x.assign( fxaaQualityRcpFrame.x );
 				offNP.y.assign( 0 );
@@ -212,7 +219,7 @@ class FXAANode extends TempNode {
 			const iterationsUsedN = int( 0 ).toVar();
 			const iterationsUsedP = int( 0 ).toVar();
 
-			loop( NUM_SAMPLES, ( { i } ) => {
+			Loop( NUM_SAMPLES, ( { i } ) => {
 
 				const increment = i.add( 1 ).toVar();
 
@@ -233,7 +240,7 @@ class FXAANode extends TempNode {
 
 					iterationsUsedN.assign( i );
 
-				} );
+				} );
 
 				If( doneP.equal( 0 ), () => {
 
@@ -252,7 +259,7 @@ class FXAANode extends TempNode {
 
 					iterationsUsedP.assign( i );
 
-				} );
+				} );
 
 				If( doneN.equal( 1 ).or( doneP.equal( 1 ) ), () => {
 
@@ -303,7 +310,7 @@ class FXAANode extends TempNode {
 			]
 		} );
 
-		const fxaa = tslFn( () => {
+		const fxaa = Fn( () => {
 
 			const edgeDetectionQuality = float( 0.2 );
 			const invEdgeDetectionQuality = float( 1 ).div( edgeDetectionQuality );
@@ -320,8 +327,6 @@ class FXAANode extends TempNode {
 
 }
 
-export const fxaa = ( node ) => nodeObject( new FXAANode( nodeObject( node ).toTexture() ) );
-
-addNodeElement( 'fxaa', fxaa );
-
 export default FXAANode;
+
+export const fxaa = ( node ) => nodeObject( new FXAANode( convertToTexture( node ) ) );

package/src/nodes/display/FilmNode.js

@@ -1,11 +1,17 @@
 import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, tslFn, nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { Fn, nodeProxy, vec4 } from '../tsl/TSLBase.js';
 import { mix, fract, clamp, rand } from '../math/MathNode.js';
 import { timerLocal } from '../utils/TimerNode.js';
 
 class FilmNode extends TempNode {
 
+	static get type() {
+
+		return 'FilmNode';
+
+	}
+
 	constructor( inputNode, intensityNode = null, uvNode = null ) {
 
 		super();
@@ -20,7 +26,7 @@ class FilmNode extends TempNode {
 
 		const uvNode = this.uvNode || uv();
 
-		const film = tslFn( () => {
+		const film = Fn( () => {
 
 			const base = this.inputNode.rgb;
 			const noise = rand( fract( uvNode.add( timerLocal() ) ) );
@@ -45,8 +51,6 @@ class FilmNode extends TempNode {
 
 }
 
-export const film = nodeProxy( FilmNode );
-
-addNodeElement( 'film', film );
-
 export default FilmNode;
+
+export const film = /*@__PURE__*/ nodeProxy( FilmNode );

package/src/nodes/display/FrontFacingNode.js

@@ -1,10 +1,16 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeImmutable, float } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { nodeImmutable, float } from '../tsl/TSLBase.js';
 
 import { BackSide, WebGLCoordinateSystem } from '../../constants.js';
 
 class FrontFacingNode extends Node {
 
+	static get type() {
+
+		return 'FrontFacingNode';
+
+	}
+
 	constructor() {
 
 		super( 'bool' );
@@ -35,7 +41,5 @@ class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-export const frontFacing = nodeImmutable( FrontFacingNode );
-export const faceDirection = float( frontFacing ).mul( 2.0 ).sub( 1.0 );
-
-addNodeClass( 'FrontFacingNode', FrontFacingNode );
+export const frontFacing = /*@__PURE__*/ nodeImmutable( FrontFacingNode );
+export const faceDirection = /*@__PURE__*/ float( frontFacing ).mul( 2.0 ).sub( 1.0 );