super-three 0.167.0 → 0.169.0

package/src/nodes/display/GTAONode.js

@@ -1,8 +1,8 @@
 import TempNode from '../core/TempNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { textureSize } from '../accessors/TextureSizeNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, nodeObject, tslFn, mat3, vec2, vec3, vec4, float, int, If } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { nodeObject, Fn, mat3, vec2, vec3, vec4, float, int, If } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { DataTexture } from '../../textures/DataTexture.js';
@@ -10,10 +10,12 @@ import { Vector2 } from '../../math/Vector2.js';
 import { Vector3 } from '../../math/Vector3.js';
 import { PI, cos, sin, pow, clamp, abs, max, mix, sqrt, acos, dot, normalize, cross } from '../math/MathNode.js';
 import { div, mul, add, sub } from '../math/OperatorNode.js';
-import { loop } from '../utils/LoopNode.js';
+import { Loop } from '../utils/LoopNode.js';
 import { passTexture } from './PassNode.js';
 import { RepeatWrapping } from '../../constants.js';
 import QuadMesh from '../../renderers/common/QuadMesh.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+
 import { RenderTarget } from '../../core/RenderTarget.js';
 import { Color } from '../../math/Color.js';
 
@@ -23,6 +25,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class GTAONode extends TempNode {
 
+	static get type() {
+
+		return 'GTAONode';
+
+	}
+
 	constructor( depthNode, normalNode, camera ) {
 
 		super();
@@ -106,7 +114,7 @@ class GTAONode extends TempNode {
 		const sampleDepth = ( uv ) => this.depthNode.uv( uv ).x;
 		const sampleNoise = ( uv ) => this.noiseNode.uv( uv );
 
-		const getSceneUvAndDepth = tslFn( ( [ sampleViewPos ] )=> {
+		const getSceneUvAndDepth = Fn( ( [ sampleViewPos ] )=> {
 
 			const sampleClipPos = this.cameraProjectionMatrix.mul( vec4( sampleViewPos, 1.0 ) );
 			let sampleUv = sampleClipPos.xy.div( sampleClipPos.w ).mul( 0.5 ).add( 0.5 ).toVar();
@@ -116,7 +124,7 @@ class GTAONode extends TempNode {
 
 		} );
 
-		const getViewPosition = tslFn( ( [ screenPosition, depth ] ) => {
+		const getViewPosition = Fn( ( [ screenPosition, depth ] ) => {
 
 			screenPosition = vec2( screenPosition.x, screenPosition.y.oneMinus() ).mul( 2.0 ).sub( 1.0 );
 
@@ -127,7 +135,7 @@ class GTAONode extends TempNode {
 
 		} );
 
-		const ao = tslFn( () => {
+		const ao = Fn( () => {
 
 			const depth = sampleDepth( uvNode );
 
@@ -147,12 +155,12 @@ class GTAONode extends TempNode {
 			const bitangent = vec3( tangent.y.mul( - 1.0 ), tangent.x, 0.0 );
 			const kernelMatrix = mat3( tangent, bitangent, vec3( 0.0, 0.0, 1.0 ) );
 
-			const DIRECTIONS = this.SAMPLES.lessThan( 30 ).cond( 3, 5 );
+			const DIRECTIONS = this.SAMPLES.lessThan( 30 ).select( 3, 5 );
 			const STEPS = add( this.SAMPLES, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS );
 
 			const ao = float( 0 ).toVar();
 
-			loop( { start: int( 0 ), end: DIRECTIONS, type: 'int', condition: '<' }, ( { i } ) => {
+			Loop( { start: int( 0 ), end: DIRECTIONS, type: 'int', condition: '<' }, ( { i } ) => {
 
 				const angle = float( i ).div( float( DIRECTIONS ) ).mul( PI );
 				const sampleDir = vec4( cos( angle ), sin( angle ), 0., add( 0.5, mul( 0.5, noiseTexel.w ) ) );
@@ -166,7 +174,7 @@ class GTAONode extends TempNode {
 				const tangentToNormalInSlice = cross( normalInSlice, sliceBitangent );
 				const cosHorizons = vec2( dot( viewDir, tangentToNormalInSlice ), dot( viewDir, tangentToNormalInSlice.negate() ) ).toVar();
 
-				loop( { end: STEPS, type: 'int', name: 'j', condition: '<' }, ( { j } ) => {
+				Loop( { end: STEPS, type: 'int', name: 'j', condition: '<' }, ( { j } ) => {
 
 					const sampleViewOffset = sampleDir.xyz.mul( radiusToUse ).mul( sampleDir.w ).mul( pow( div( float( j ).add( 1.0 ), float( STEPS ) ), this.distanceExponent ) );
 
@@ -206,7 +214,7 @@ class GTAONode extends TempNode {
 				const occlusion = nx.mul( nxb ).add( ny.mul( nyb ) );
 				ao.addAssign( occlusion );
 
-			} );
+			} );
 
 			ao.assign( clamp( ao.div( DIRECTIONS ), 0, 1 ) );
 			ao.assign( pow( ao, this.scale ) );
@@ -215,8 +223,9 @@ class GTAONode extends TempNode {
 
 		} );
 
-		const material = this._material || ( this._material = builder.createNodeMaterial() );
+		const material = this._material || ( this._material = new NodeMaterial() );
 		material.fragmentNode = ao().context( builder.getSharedContext() );
+		material.name = 'GTAO';
 		material.needsUpdate = true;
 
 		//
@@ -233,6 +242,8 @@ class GTAONode extends TempNode {
 
 }
 
+export default GTAONode;
+
 function generateMagicSquareNoise( size = 5 ) {
 
 	const noiseSize = Math.floor( size ) % 2 === 0 ? Math.floor( size ) + 1 : Math.floor( size );
@@ -318,7 +329,3 @@ function generateMagicSquare( size ) {
 }
 
 export const ao = ( depthNode, normalNode, camera ) => nodeObject( new GTAONode( nodeObject( depthNode ), nodeObject( normalNode ), camera ) );
-
-addNodeElement( 'ao', ao );
-
-export default GTAONode;

package/src/nodes/display/GaussianBlurNode.js

@@ -1,14 +1,16 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, float, vec2, vec4 } from '../shadernode/ShaderNode.js';
+import { nodeObject, Fn, float, vec2, vec4 } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { mul } from '../math/OperatorNode.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { passTexture } from './PassNode.js';
 import { uniform } from '../core/UniformNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
 import QuadMesh from '../../renderers/common/QuadMesh.js';
 
 import { Vector2 } from '../../math/Vector2.js';
 import { RenderTarget } from '../../core/RenderTarget.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.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.
@@ -18,6 +20,12 @@ const _quadMesh2 = /*@__PURE__*/ new QuadMesh();
 
 class GaussianBlurNode extends TempNode {
 
+	static get type() {
+
+		return 'GaussianBlurNode';
+
+	}
+
 	constructor( textureNode, directionNode = null, sigma = 2 ) {
 
 		super( 'vec4' );
@@ -129,7 +137,7 @@ class GaussianBlurNode extends TempNode {
 
 		const sampleTexture = ( uv ) => textureNode.uv( uv );
 
-		const blur = tslFn( () => {
+		const blur = Fn( () => {
 
 			const kernelSize = 3 + ( 2 * this.sigma );
 			const gaussianCoefficients = this._getCoefficients( kernelSize );
@@ -161,8 +169,9 @@ class GaussianBlurNode extends TempNode {
 
 		//
 
-		const material = this._material || ( this._material = builder.createNodeMaterial() );
+		const material = this._material || ( this._material = new NodeMaterial() );
 		material.fragmentNode = blur().context( builder.getSharedContext() );
+		material.name = 'Gaussian_blur';
 		material.needsUpdate = true;
 
 		//
@@ -199,9 +208,6 @@ class GaussianBlurNode extends TempNode {
 
 }
 
-export const gaussianBlur = ( node, directionNode, sigma ) => nodeObject( new GaussianBlurNode( nodeObject( node ).toTexture(), directionNode, sigma ) );
-
-addNodeElement( 'gaussianBlur', gaussianBlur );
-
 export default GaussianBlurNode;
 
+export const gaussianBlur = ( node, directionNode, sigma ) => nodeObject( new GaussianBlurNode( convertToTexture( node ), directionNode, sigma ) );

package/src/nodes/display/Lut3DNode.js

@@ -1,10 +1,16 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeElement, tslFn, nodeObject, vec3, vec4, float } from '../shadernode/ShaderNode.js';
+import { Fn, nodeObject, vec3, vec4, float } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
 import { mix } from '../math/MathNode.js';
 
 class Lut3DNode extends TempNode {
 
+	static get type() {
+
+		return 'Lut3DNode';
+
+	}
+
 	constructor( inputNode, lutNode, size, intensityNode ) {
 
 		super();
@@ -22,7 +28,7 @@ class Lut3DNode extends TempNode {
 
 		const sampleLut = ( uv ) => lutNode.uv( uv );
 
-		const lut3D = tslFn( () => {
+		const lut3D = Fn( () => {
 
 			const base = inputNode;
 
@@ -46,8 +52,6 @@ class Lut3DNode extends TempNode {
 
 }
 
-export const lut3D = ( node, lut, size, intensity ) => nodeObject( new Lut3DNode( nodeObject( node ), nodeObject( lut ), size, nodeObject( intensity ) ) );
-
-addNodeElement( 'lut3D', lut3D );
-
 export default Lut3DNode;
+
+export const lut3D = ( node, lut, size, intensity ) => nodeObject( new Lut3DNode( nodeObject( node ), nodeObject( lut ), size, nodeObject( intensity ) ) );

package/src/nodes/display/MotionBlur.js

@@ -0,0 +1,25 @@
+import { float, int, Fn } from '../tsl/TSLBase.js';
+import { Loop } from '../utils/LoopNode.js';
+import { uv } from '../accessors/UV.js';
+
+export const motionBlur = /*@__PURE__*/ Fn( ( [ inputNode, velocity, numSamples = int( 16 ) ] ) => {
+
+	const sampleColor = ( uv ) => inputNode.uv( uv );
+
+	const uvs = uv();
+
+	const colorResult = sampleColor( uvs ).toVar();
+	const fSamples = float( numSamples );
+
+	Loop( { start: int( 1 ), end: numSamples, type: 'int', condition: '<=' }, ( { i } ) => {
+
+		const offset = velocity.mul( float( i ).div( fSamples.sub( 1 ) ).sub( 0.5 ) );
+		colorResult.addAssign( sampleColor( uvs.add( offset ) ) );
+
+	} );
+
+	colorResult.divAssign( fSamples );
+
+	return colorResult;
+
+} );

package/src/nodes/display/NormalMapNode.js

@@ -1,21 +1,19 @@
 import TempNode from '../core/TempNode.js';
 import { add } from '../math/OperatorNode.js';
 
-import { modelNormalMatrix } from '../accessors/ModelNode.js';
-import { normalView } from '../accessors/NormalNode.js';
-import { positionView } from '../accessors/PositionNode.js';
+import { normalView, transformNormalToView } from '../accessors/Normal.js';
+import { positionView } from '../accessors/Position.js';
 import { TBNViewMatrix } from '../accessors/AccessorsUtils.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { faceDirection } from './FrontFacingNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
+import { Fn, nodeProxy, vec3 } from '../tsl/TSLBase.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from '../../constants.js';
 
 // Normal Mapping Without Precomputed Tangents
 // http://www.thetenthplanet.de/archives/1180
 
-const perturbNormal2Arb = tslFn( ( inputs ) => {
+const perturbNormal2Arb = /*@__PURE__*/ Fn( ( inputs ) => {
 
 	const { eye_pos, surf_norm, mapN, uv } = inputs;
 
@@ -41,6 +39,12 @@ const perturbNormal2Arb = tslFn( ( inputs ) => {
 
 class NormalMapNode extends TempNode {
 
+	static get type() {
+
+		return 'NormalMapNode';
+
+	}
+
 	constructor( node, scaleNode = null ) {
 
 		super( 'vec3' );
@@ -68,7 +72,7 @@ class NormalMapNode extends TempNode {
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
 
-			outputNode = modelNormalMatrix.mul( normalMap ).normalize();
+			outputNode = transformNormalToView( normalMap );
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
@@ -99,8 +103,4 @@ class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-export const normalMap = nodeProxy( NormalMapNode );
-
-addNodeElement( 'normalMap', normalMap );
-
-addNodeClass( 'NormalMapNode', NormalMapNode );
+export const normalMap = /*@__PURE__*/ nodeProxy( NormalMapNode );

package/src/nodes/display/ParallaxBarrierPassNode.js

@@ -0,0 +1,58 @@
+import { Fn, If, nodeObject, vec4 } from '../tsl/TSLBase.js';
+import { uv } from '../accessors/UV.js';
+import { mod } from '../math/MathNode.js';
+import { screenCoordinate } from './ScreenNode.js';
+import StereoCompositePassNode from './StereoCompositePassNode.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+
+class ParallaxBarrierPassNode extends StereoCompositePassNode {
+
+	static get type() {
+
+		return 'ParallaxBarrierPassNode';
+
+	}
+
+	constructor( scene, camera ) {
+
+		super( scene, camera );
+
+		this.isParallaxBarrierPassNode = true;
+
+	}
+
+	setup( builder ) {
+
+		const uvNode = uv();
+
+		const parallaxBarrier = Fn( () => {
+
+			const color = vec4().toVar();
+
+			If( mod( screenCoordinate.y, 2 ).greaterThan( 1 ), () => {
+
+				color.assign( this._mapLeft.uv( uvNode ) );
+
+			} ).Else( () => {
+
+				color.assign( this._mapRight.uv( uvNode ) );
+
+			} );
+
+			return color;
+
+		} );
+
+		const material = this._material || ( this._material = new NodeMaterial() );
+		material.fragmentNode = parallaxBarrier().context( builder.getSharedContext() );
+		material.needsUpdate = true;
+
+		return super.setup( builder );
+
+	}
+
+}
+
+export default ParallaxBarrierPassNode;
+
+export const parallaxBarrierPass = ( scene, camera ) => nodeObject( new ParallaxBarrierPassNode( scene, camera ) );

package/src/nodes/display/PassNode.js

@@ -1,8 +1,7 @@
-import { addNodeClass } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { default as TextureNode/*, texture*/ } from '../accessors/TextureNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
 import { viewZToOrthographicDepth, perspectiveDepthToViewZ } from './ViewportDepthNode.js';
 
@@ -15,6 +14,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class PassTextureNode extends TextureNode {
 
+	static get type() {
+
+		return 'PassTextureNode';
+
+	}
+
 	constructor( passNode, texture ) {
 
 		super( texture );
@@ -27,7 +32,7 @@ class PassTextureNode extends TextureNode {
 
 	setup( builder ) {
 
-		this.passNode.build( builder );
+		if ( builder.object.isQuadMesh ) this.passNode.build( builder );
 
 		return super.setup( builder );
 
@@ -43,17 +48,30 @@ class PassTextureNode extends TextureNode {
 
 class PassMultipleTextureNode extends PassTextureNode {
 
-	constructor( passNode, textureName ) {
+	static get type() {
+
+		return 'PassMultipleTextureNode';
+
+	}
+
+	constructor( passNode, textureName, previousTexture = false ) {
 
 		super( passNode, null );
 
 		this.textureName = textureName;
+		this.previousTexture = previousTexture;
+
+	}
+
+	updateTexture() {
+
+		this.value = this.previousTexture ? this.passNode.getPreviousTexture( this.textureName ) : this.passNode.getTexture( this.textureName );
 
 	}
 
 	setup( builder ) {
 
-		this.value = this.passNode.getTexture( this.textureName );
+		this.updateTexture();
 
 		return super.setup( builder );
 
@@ -61,7 +79,7 @@ class PassMultipleTextureNode extends PassTextureNode {
 
 	clone() {
 
-		return new this.constructor( this.passNode, this.textureName );
+		return new this.constructor( this.passNode, this.textureName, this.previousTexture );
 
 	}
 
@@ -69,6 +87,12 @@ class PassMultipleTextureNode extends PassTextureNode {
 
 class PassNode extends TempNode {
 
+	static get type() {
+
+		return 'PassNode';
+
+	}
+
 	constructor( scope, scene, camera, options = {} ) {
 
 		super( 'vec4' );
@@ -104,6 +128,9 @@ class PassNode extends TempNode {
 		this._linearDepthNodes = {};
 		this._viewZNodes = {};
 
+		this._previousTextures = {};
+		this._previousTextureNodes = {};
+
 		this._cameraNear = uniform( 0 );
 		this._cameraFar = uniform( 0 );
 
@@ -155,6 +182,44 @@ class PassNode extends TempNode {
 
 	}
 
+	getPreviousTexture( name ) {
+
+		let texture = this._previousTextures[ name ];
+
+		if ( texture === undefined ) {
+
+			texture = this.getTexture( name ).clone();
+			texture.isRenderTargetTexture = true;
+
+			this._previousTextures[ name ] = texture;
+
+		}
+
+		return texture;
+
+	}
+
+	toggleTexture( name ) {
+
+		const prevTexture = this._previousTextures[ name ];
+
+		if ( prevTexture !== undefined ) {
+
+			const texture = this._textures[ name ];
+
+			const index = this.renderTarget.textures.indexOf( texture );
+			this.renderTarget.textures[ index ] = prevTexture;
+
+			this._textures[ name ] = prevTexture;
+			this._previousTextures[ name ] = texture;
+
+			this._textureNodes[ name ].updateTexture();
+			this._previousTextureNodes[ name ].updateTexture();
+
+		}
+
+	}
+
 	getTextureNode( name = 'output' ) {
 
 		let textureNode = this._textureNodes[ name ];
@@ -162,6 +227,24 @@ class PassNode extends TempNode {
 		if ( textureNode === undefined ) {
 
 			this._textureNodes[ name ] = textureNode = nodeObject( new PassMultipleTextureNode( this, name ) );
+			this._textureNodes[ name ].updateTexture();
+
+		}
+
+		return textureNode;
+
+	}
+
+	getPreviousTextureNode( name = 'output' ) {
+
+		let textureNode = this._previousTextureNodes[ name ];
+
+		if ( textureNode === undefined ) {
+
+			if ( this._textureNodes[ name ] === undefined ) this.getTextureNode( name );
+
+			this._previousTextureNodes[ name ] = textureNode = nodeObject( new PassMultipleTextureNode( this, name, true ) );
+			this._previousTextureNodes[ name ].updateTexture();
 
 		}
 
@@ -240,6 +323,12 @@ class PassNode extends TempNode {
 		this._cameraNear.value = camera.near;
 		this._cameraFar.value = camera.far;
 
+		for ( const name in this._previousTextures ) {
+
+			this.toggleTexture( name );
+
+		}
+
 		renderer.setRenderTarget( this.renderTarget );
 		renderer.setMRT( this._mrt );
 
@@ -287,5 +376,3 @@ export default PassNode;
 export const pass = ( scene, camera, options ) => nodeObject( new PassNode( PassNode.COLOR, scene, camera, options ) );
 export const passTexture = ( pass, texture ) => nodeObject( new PassTextureNode( pass, texture ) );
 export const depthPass = ( scene, camera ) => nodeObject( new PassNode( PassNode.DEPTH, scene, camera ) );
-
-addNodeClass( 'PassNode', PassNode );

package/src/nodes/display/PixelationPassNode.js

@@ -1,6 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { addNodeElement, tslFn, nodeObject, vec2, vec3, float, If } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { Fn, nodeObject, vec2, vec3, float, If } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { dot, clamp, smoothstep, sign, step, floor } from '../math/MathNode.js';
@@ -8,11 +8,19 @@ import { Vector4 } from '../../math/Vector4.js';
 import { output, property } from '../core/PropertyNode.js';
 import PassNode from './PassNode.js';
 import { mrt } from '../core/MRTNode.js';
-import { normalView } from '../accessors/NormalNode.js';
+import { normalView } from '../accessors/Normal.js';
+import { convertToTexture } from '../utils/RTTNode.js';
+
 import { NearestFilter } from '../../constants.js';
 
 class PixelationNode extends TempNode {
 
+	static get type() {
+
+		return 'PixelationNode';
+
+	}
+
 	constructor( textureNode, depthNode, normalNode, pixelSize, normalEdgeStrength, depthEdgeStrength ) {
 
 		super();
@@ -106,7 +114,7 @@ class PixelationNode extends TempNode {
 
 		};
 
-		const pixelation = tslFn( () => {
+		const pixelation = Fn( () => {
 
 			const texel = sampleTexture();
 
@@ -136,7 +144,7 @@ class PixelationNode extends TempNode {
 
 			} );
 
-			const strength = dei.greaterThan( 0 ).cond( float( 1.0 ).sub( dei.mul( this.depthEdgeStrength ) ), nei.mul( this.normalEdgeStrength ).add( 1 ) );
+			const strength = dei.greaterThan( 0 ).select( float( 1.0 ).sub( dei.mul( this.depthEdgeStrength ) ), nei.mul( this.normalEdgeStrength ).add( 1 ) );
 
 			return texel.mul( strength );
 
@@ -150,12 +158,16 @@ class PixelationNode extends TempNode {
 
 }
 
-const pixelation = ( node, depthNode, normalNode, pixelSize = 6, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) => nodeObject( new PixelationNode( nodeObject( node ).toTexture(), nodeObject( depthNode ).toTexture(), nodeObject( normalNode ).toTexture(), nodeObject( pixelSize ), nodeObject( normalEdgeStrength ), nodeObject( depthEdgeStrength ) ) );
-
-addNodeElement( 'pixelation', pixelation );
+const pixelation = ( node, depthNode, normalNode, pixelSize = 6, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) => nodeObject( new PixelationNode( convertToTexture( node ), convertToTexture( depthNode ), convertToTexture( normalNode ), nodeObject( pixelSize ), nodeObject( normalEdgeStrength ), nodeObject( depthEdgeStrength ) ) );
 
 class PixelationPassNode extends PassNode {
 
+	static get type() {
+
+		return 'PixelationPassNode';
+
+	}
+
 	constructor( scene, camera, pixelSize = 6, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) {
 
 		super( 'color', scene, camera, { minFilter: NearestFilter, magFilter: NearestFilter } );

package/src/nodes/display/PosterizeNode.js

@@ -1,9 +1,14 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class PosterizeNode extends TempNode {
 
+	static get type() {
+
+		return 'PosterizeNode';
+
+	}
+
 	constructor( sourceNode, stepsNode ) {
 
 		super();
@@ -25,8 +30,4 @@ class PosterizeNode extends TempNode {
 
 export default PosterizeNode;
 
-export const posterize = nodeProxy( PosterizeNode );
-
-addNodeElement( 'posterize', posterize );
-
-addNodeClass( 'PosterizeNode', PosterizeNode );
+export const posterize = /*@__PURE__*/ nodeProxy( PosterizeNode );

package/src/nodes/display/RGBShiftNode.js

@@ -1,11 +1,18 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, addNodeElement, tslFn, vec2, vec4 } from '../shadernode/ShaderNode.js';
+import { nodeObject, Fn, vec2, vec4 } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { sin, cos } from '../math/MathNode.js';
+import { convertToTexture } from '../utils/RTTNode.js';
 
 class RGBShiftNode extends TempNode {
 
+	static get type() {
+
+		return 'RGBShiftNode';
+
+	}
+
 	constructor( textureNode, amount = 0.005, angle = 0 ) {
 
 		super( 'vec4' );
@@ -24,7 +31,7 @@ class RGBShiftNode extends TempNode {
 
 		const sampleTexture = ( uv ) => textureNode.uv( uv );
 
-		const rgbShift = tslFn( () => {
+		const rgbShift = Fn( () => {
 
 			const offset = vec2( cos( this.angle ), sin( this.angle ) ).mul( this.amount );
 			const cr = sampleTexture( uvNode.add( offset ) );
@@ -41,9 +48,6 @@ class RGBShiftNode extends TempNode {
 
 }
 
-export const rgbShift = ( node, amount, angle ) => nodeObject( new RGBShiftNode( nodeObject( node ).toTexture(), amount, angle ) );
-
-addNodeElement( 'rgbShift', rgbShift );
-
 export default RGBShiftNode;
 
+export const rgbShift = ( node, amount, angle ) => nodeObject( new RGBShiftNode( convertToTexture( node ), amount, angle ) );