super-three 0.168.0 → 0.169.0

package/src/nodes/display/ScreenNode.js

@@ -0,0 +1,181 @@
+import Node from '../core/Node.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../core/UniformNode.js';
+import { Fn, nodeImmutable, vec2 } from '../tsl/TSLBase.js';
+
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector4 } from '../../math/Vector4.js';
+
+let screenSizeVec, viewportVec;
+
+class ScreenNode extends Node {
+
+	static get type() {
+
+		return 'ScreenNode';
+
+	}
+
+	constructor( scope ) {
+
+		super();
+
+		this.scope = scope;
+
+		this.isViewportNode = true;
+
+	}
+
+	getNodeType() {
+
+		if ( this.scope === ScreenNode.VIEWPORT ) return 'vec4';
+		else return 'vec2';
+
+	}
+
+	getUpdateType() {
+
+		let updateType = NodeUpdateType.NONE;
+
+		if ( this.scope === ScreenNode.SIZE || this.scope === ScreenNode.VIEWPORT ) {
+
+			updateType = NodeUpdateType.RENDER;
+
+		}
+
+		this.updateType = updateType;
+
+		return updateType;
+
+	}
+
+	update( { renderer } ) {
+
+		const renderTarget = renderer.getRenderTarget();
+
+		if ( this.scope === ScreenNode.VIEWPORT ) {
+
+			if ( renderTarget !== null ) {
+
+				viewportVec.copy( renderTarget.viewport );
+
+			} else {
+
+				renderer.getViewport( viewportVec );
+
+				viewportVec.multiplyScalar( renderer.getPixelRatio() );
+
+			}
+
+		} else {
+
+			if ( renderTarget !== null ) {
+
+				screenSizeVec.width = renderTarget.width;
+				screenSizeVec.height = renderTarget.height;
+
+			} else {
+
+				renderer.getDrawingBufferSize( screenSizeVec );
+
+			}
+
+		}
+
+	}
+
+	setup( /*builder*/ ) {
+
+		const scope = this.scope;
+
+		let output = null;
+
+		if ( scope === ScreenNode.SIZE ) {
+
+			output = uniform( screenSizeVec || ( screenSizeVec = new Vector2() ) );
+
+		} else if ( scope === ScreenNode.VIEWPORT ) {
+
+			output = uniform( viewportVec || ( viewportVec = new Vector4() ) );
+
+		} else {
+
+			output = vec2( screenCoordinate.div( screenSize ) );
+
+		}
+
+		return output;
+
+	}
+
+	generate( builder ) {
+
+		if ( this.scope === ScreenNode.COORDINATE ) {
+
+			let coord = builder.getFragCoord();
+
+			if ( builder.isFlipY() ) {
+
+				// follow webgpu standards
+
+				const size = builder.getNodeProperties( screenSize ).outputNode.build( builder );
+
+				coord = `${ builder.getType( 'vec2' ) }( ${ coord }.x, ${ size }.y - ${ coord }.y )`;
+
+			}
+
+			return coord;
+
+		}
+
+		return super.generate( builder );
+
+	}
+
+}
+
+ScreenNode.COORDINATE = 'coordinate';
+ScreenNode.VIEWPORT = 'viewport';
+ScreenNode.SIZE = 'size';
+ScreenNode.UV = 'uv';
+
+export default ScreenNode;
+
+// Screen
+
+export const screenUV = /*@__PURE__*/ nodeImmutable( ScreenNode, ScreenNode.UV );
+export const screenSize = /*@__PURE__*/ nodeImmutable( ScreenNode, ScreenNode.SIZE );
+export const screenCoordinate = /*@__PURE__*/ nodeImmutable( ScreenNode, ScreenNode.COORDINATE );
+
+// Viewport
+
+export const viewport = /*@__PURE__*/ nodeImmutable( ScreenNode, ScreenNode.VIEWPORT );
+export const viewportSize = viewport.zw;
+export const viewportCoordinate = /*@__PURE__*/ screenCoordinate.sub( viewport.xy );
+export const viewportUV = /*@__PURE__*/ viewportCoordinate.div( viewportSize );
+
+// Deprecated
+
+export const viewportResolution = /*@__PURE__*/ ( Fn( () => { // @deprecated, r169
+
+	console.warn( 'TSL.ViewportNode: "viewportResolution" is deprecated. Use "screenSize" instead.' );
+
+	return screenSize;
+
+}, 'vec2' ).once() )();
+
+export const viewportTopLeft = /*@__PURE__*/ ( Fn( () => { // @deprecated, r168
+
+	console.warn( 'TSL.ViewportNode: "viewportTopLeft" is deprecated. Use "screenUV" instead.' );
+
+	return screenUV;
+
+}, 'vec2' ).once() )();
+
+export const viewportBottomLeft = /*@__PURE__*/ ( Fn( () => { // @deprecated, r168
+
+	console.warn( 'TSL.ViewportNode: "viewportBottomLeft" is deprecated. Use "screenUV.flipY()" instead.' );
+
+	return screenUV.flipY();
+
+}, 'vec2' ).once() )();

package/src/nodes/display/SobelOperatorNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { luminance } from './ColorAdjustment.js';
@@ -12,6 +11,12 @@ import { Vector2 } from '../../math/Vector2.js';
 
 class SobelOperatorNode extends TempNode {
 
+	static get type() {
+
+		return 'SobelOperatorNode';
+
+	}
+
 	constructor( textureNode ) {
 
 		super();
@@ -118,6 +123,4 @@ class SobelOperatorNode extends TempNode {
 
 export default SobelOperatorNode;
 
-SobelOperatorNode.type = /*@__PURE__*/ registerNode( 'SobelOperator', SobelOperatorNode );
-
 export const sobel = ( node ) => nodeObject( new SobelOperatorNode( convertToTexture( node ) ) );

package/src/nodes/display/StereoCompositePassNode.js

@@ -1,5 +1,4 @@
 
-import { registerNode } from '../core/Node.js';
 import PassNode from './PassNode.js';
 import { StereoCamera } from '../../cameras/StereoCamera.js';
 import { HalfFloatType, LinearFilter, NearestFilter } from '../../constants.js';
@@ -13,6 +12,12 @@ const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
 class StereoCompositePassNode extends PassNode {
 
+	static get type() {
+
+		return 'StereoCompositePassNode';
+
+	}
+
 	constructor( scene, camera ) {
 
 		super( PassNode.COLOR, scene, camera );
@@ -103,5 +108,3 @@ class StereoCompositePassNode extends PassNode {
 }
 
 export default StereoCompositePassNode;
-
-StereoCompositePassNode.type = /*@__PURE__*/ registerNode( 'StereoCompositePass', StereoCompositePassNode );

package/src/nodes/display/StereoPassNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import PassNode from './PassNode.js';
 import { Vector2 } from '../../math/Vector2.js';
@@ -8,6 +7,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class StereoPassNode extends PassNode {
 
+	static get type() {
+
+		return 'StereoPassNode';
+
+	}
+
 	constructor( scene, camera ) {
 
 		super( PassNode.COLOR, scene, camera );
@@ -75,6 +80,4 @@ class StereoPassNode extends PassNode {
 
 export default StereoPassNode;
 
-StereoPassNode.type = /*@__PURE__*/ registerNode( 'StereoPass', StereoPassNode );
-
 export const stereoPass = ( scene, camera ) => nodeObject( new StereoPassNode( scene, camera ) );

package/src/nodes/display/ToneMappingFunctions.js

@@ -5,12 +5,12 @@ import { mul, sub, div } from '../math/OperatorNode.js';
 
 // exposure only
 
-export const LinearToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const linearToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	return color.mul( exposure ).clamp();
 
 } ).setLayout( {
-	name: 'LinearToneMapping',
+	name: 'linearToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },
@@ -20,14 +20,14 @@ export const LinearToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 // source: https://www.cs.utah.edu/docs/techreports/2002/pdf/UUCS-02-001.pdf
 
-export const ReinhardToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const reinhardToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	color = color.mul( exposure );
 
 	return color.div( color.add( 1.0 ) ).clamp();
 
 } ).setLayout( {
-	name: 'ReinhardToneMapping',
+	name: 'reinhardToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },
@@ -37,7 +37,7 @@ export const ReinhardToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) =>
 
 // source: http://filmicworlds.com/blog/filmic-tonemapping-operators/
 
-export const CineonToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const cineonToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	// filmic operator by Jim Hejl and Richard Burgess-Dawson
 	color = color.mul( exposure );
@@ -49,7 +49,7 @@ export const CineonToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 	return a.div( b ).pow( 2.2 );
 
 } ).setLayout( {
-	name: 'CineonToneMapping',
+	name: 'cineonToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },
@@ -70,7 +70,7 @@ const RRTAndODTFit = /*@__PURE__*/ Fn( ( [ color ] ) => {
 
 // source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
 
-export const ACESFilmicToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const acesFilmicToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
 	const ACESInputMat = mat3(
@@ -99,7 +99,7 @@ export const ACESFilmicToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) =
 	return color.clamp();
 
 } ).setLayout( {
-	name: 'ACESFilmicToneMapping',
+	name: 'acesFilmicToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },
@@ -120,7 +120,7 @@ const agxDefaultContrastApprox = /*@__PURE__*/ Fn( ( [ x_immutable ] ) => {
 
 } );
 
-export const AgXToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const agxToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	const colortone = vec3( color ).toVar();
 	const AgXInsetMatrix = mat3( vec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ), vec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ), vec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 ) );
@@ -143,7 +143,7 @@ export const AgXToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 	return colortone;
 
 } ).setLayout( {
-	name: 'AgXToneMapping',
+	name: 'agxToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },
@@ -153,7 +153,7 @@ export const AgXToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 // https://modelviewer.dev/examples/tone-mapping
 
-export const NeutralToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
+export const neutralToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 
 	const StartCompression = float( 0.8 - 0.04 );
 	const Desaturation = float( 0.15 );
@@ -181,7 +181,7 @@ export const NeutralToneMapping = /*@__PURE__*/ Fn( ( [ color, exposure ] ) => {
 	return mix( color, vec3( newPeak ), g );
 
 } ).setLayout( {
-	name: 'NeutralToneMapping',
+	name: 'neutralToneMapping',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' },

package/src/nodes/display/ToneMappingNode.js

@@ -1,12 +1,18 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeObject, vec4 } from '../tsl/TSLCore.js';
 import { rendererReference } from '../accessors/RendererReferenceNode.js';
 
 import { NoToneMapping } from '../../constants.js';
+import { hash } from '../core/NodeUtils.js';
 
 class ToneMappingNode extends TempNode {
 
+	static get type() {
+
+		return 'ToneMappingNode';
+
+	}
+
 	constructor( toneMapping, exposureNode = toneMappingExposure, colorNode = null ) {
 
 		super( 'vec3' );
@@ -20,10 +26,7 @@ class ToneMappingNode extends TempNode {
 
 	getCacheKey() {
 
-		let cacheKey = super.getCacheKey();
-		cacheKey = '{toneMapping:' + this.toneMapping + ',nodes:' + cacheKey + '}';
-
-		return cacheKey;
+		return hash( super.getCacheKey(), this.toneMapping );
 
 	}
 
@@ -58,8 +61,6 @@ class ToneMappingNode extends TempNode {
 
 export default ToneMappingNode;
 
-ToneMappingNode.type = /*@__PURE__*/ registerNode( 'ToneMapping', ToneMappingNode );
-
 export const toneMapping = ( mapping, exposure, color ) => nodeObject( new ToneMappingNode( mapping, nodeObject( exposure ), nodeObject( color ) ) );
 export const toneMappingExposure = /*@__PURE__*/ rendererReference( 'toneMappingExposure', 'float' );
 

package/src/nodes/display/ToonOutlinePassNode.js

@@ -0,0 +1,111 @@
+import { float, nodeObject, normalize, vec4 } from '../tsl/TSLBase.js';
+import { Color } from '../../math/Color.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
+import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
+import { positionLocal } from '../../nodes/accessors/Position.js';
+import { normalLocal } from '../../nodes/accessors/Normal.js';
+import { BackSide } from '../../constants.js';
+import PassNode from './PassNode.js';
+
+class ToonOutlinePassNode extends PassNode {
+
+	static get type() {
+
+		return 'ToonOutlinePassNode';
+
+	}
+
+	constructor( scene, camera, colorNode, thicknessNode, alphaNode ) {
+
+		super( PassNode.COLOR, scene, camera );
+
+		this.colorNode = colorNode;
+		this.thicknessNode = thicknessNode;
+		this.alphaNode = alphaNode;
+
+		this._materialCache = new WeakMap();
+
+	}
+
+	updateBefore( frame ) {
+
+		const { renderer } = frame;
+
+		const currentRenderObjectFunction = renderer.getRenderObjectFunction();
+
+		renderer.setRenderObjectFunction( ( object, scene, camera, geometry, material, group, lightsNode ) => {
+
+			// only render outline for supported materials
+
+			if ( material.isMeshToonMaterial || material.isMeshToonNodeMaterial ) {
+
+				if ( material.wireframe === false ) {
+
+					const outlineMaterial = this._getOutlineMaterial( material );
+					renderer.renderObject( object, scene, camera, geometry, outlineMaterial, group, lightsNode );
+
+				}
+
+			}
+
+			// default
+
+			renderer.renderObject( object, scene, camera, geometry, material, group, lightsNode );
+
+		} );
+
+		super.updateBefore( frame );
+
+		renderer.setRenderObjectFunction( currentRenderObjectFunction );
+
+	}
+
+	_createMaterial() {
+
+		const material = new NodeMaterial();
+		material.isMeshToonOutlineMaterial = true;
+		material.name = 'Toon_Outline';
+		material.side = BackSide;
+
+		// vertex node
+
+		const outlineNormal = normalLocal.negate();
+		const mvp = cameraProjectionMatrix.mul( modelViewMatrix );
+
+		const ratio = float( 1.0 ); // TODO: support outline thickness ratio for each vertex
+		const pos = mvp.mul( vec4( positionLocal, 1.0 ) );
+		const pos2 = mvp.mul( vec4( positionLocal.add( outlineNormal ), 1.0 ) );
+		const norm = normalize( pos.sub( pos2 ) ); // NOTE: subtract pos2 from pos because BackSide objectNormal is negative
+
+		material.vertexNode = pos.add( norm.mul( this.thicknessNode ).mul( pos.w ).mul( ratio ) );
+
+		// color node
+
+		material.colorNode = vec4( this.colorNode, this.alphaNode );
+
+		return material;
+
+	}
+
+	_getOutlineMaterial( originalMaterial ) {
+
+		let outlineMaterial = this._materialCache.get( originalMaterial );
+
+		if ( outlineMaterial === undefined ) {
+
+			outlineMaterial = this._createMaterial();
+
+			this._materialCache.set( originalMaterial, outlineMaterial );
+
+		}
+
+		return outlineMaterial;
+
+	}
+
+}
+
+export default ToonOutlinePassNode;
+
+export const toonOutlinePass = ( scene, camera, color = new Color( 0, 0, 0 ), thickness = 0.003, alpha = 1 ) => nodeObject( new ToonOutlinePassNode( scene, camera, nodeObject( color ), nodeObject( thickness ), nodeObject( alpha ) ) );

package/src/nodes/display/TransitionNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, float, int, vec4, If } from '../tsl/TSLBase.js';
@@ -8,6 +7,12 @@ import { convertToTexture } from '../utils/RTTNode.js';
 
 class TransitionNode extends TempNode {
 
+	static get type() {
+
+		return 'TransitionNode';
+
+	}
+
 	constructor( textureNodeA, textureNodeB, mixTextureNode, mixRatioNode, thresholdNode, useTextureNode ) {
 
 		super();
@@ -72,6 +77,4 @@ class TransitionNode extends TempNode {
 
 export default TransitionNode;
 
-TransitionNode.type = /*@__PURE__*/ registerNode( 'Transition', TransitionNode );
-
 export const transition = ( nodeA, nodeB, mixTexture, mixRatio = 0.0, threshold = 0.1, useTexture = 0 ) => nodeObject( new TransitionNode( convertToTexture( nodeA ), convertToTexture( nodeB ), convertToTexture( mixTexture ), nodeObject( mixRatio ), nodeObject( threshold ), nodeObject( useTexture ) ) );

package/src/nodes/display/ViewportDepthNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeImmutable, nodeProxy } from '../tsl/TSLBase.js';
 import { cameraNear, cameraFar } from '../accessors/Camera.js';
 import { positionView } from '../accessors/Position.js';
@@ -6,6 +6,12 @@ import { viewportDepthTexture } from './ViewportDepthTextureNode.js';
 
 class ViewportDepthNode extends Node {
 
+	static get type() {
+
+		return 'ViewportDepthNode';
+
+	}
+
 	constructor( scope, valueNode = null ) {
 
 		super( 'float' );
@@ -94,8 +100,6 @@ ViewportDepthNode.LINEAR_DEPTH = 'linearDepth';
 
 export default ViewportDepthNode;
 
-ViewportDepthNode.type = /*@__PURE__*/ registerNode( 'ViewportDepth', ViewportDepthNode );
-
 // NOTE: viewZ, the z-coordinate in camera space, is negative for points in front of the camera
 
 // -near maps to 0; -far maps to 1

package/src/nodes/display/ViewportDepthTextureNode.js

@@ -1,7 +1,6 @@
-import { registerNode } from '../core/Node.js';
 import ViewportTextureNode from './ViewportTextureNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
-import { viewportUV } from './ViewportNode.js';
+import { screenUV } from './ScreenNode.js';
 
 import { DepthTexture } from '../../textures/DepthTexture.js';
 
@@ -9,7 +8,13 @@ let sharedDepthbuffer = null;
 
 class ViewportDepthTextureNode extends ViewportTextureNode {
 
-	constructor( uvNode = viewportUV, levelNode = null ) {
+	static get type() {
+
+		return 'ViewportDepthTextureNode';
+
+	}
+
+	constructor( uvNode = screenUV, levelNode = null ) {
 
 		if ( sharedDepthbuffer === null ) {
 
@@ -25,6 +30,4 @@ class ViewportDepthTextureNode extends ViewportTextureNode {
 
 export default ViewportDepthTextureNode;
 
-ViewportDepthTextureNode.type = /*@__PURE__*/ registerNode( 'ViewportDepthTexture', ViewportDepthTextureNode );
-
 export const viewportDepthTexture = /*@__PURE__*/ nodeProxy( ViewportDepthTextureNode );

package/src/nodes/display/ViewportSharedTextureNode.js

@@ -1,15 +1,20 @@
 import ViewportTextureNode from './ViewportTextureNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
-import { viewportUV } from './ViewportNode.js';
+import { screenUV } from './ScreenNode.js';
 
 import { FramebufferTexture } from '../../textures/FramebufferTexture.js';
-import { registerNode } from '../core/Node.js';
 
 let _sharedFramebuffer = null;
 
 class ViewportSharedTextureNode extends ViewportTextureNode {
 
-	constructor( uvNode = viewportUV, levelNode = null ) {
+	static get type() {
+
+		return 'ViewportSharedTextureNode';
+
+	}
+
+	constructor( uvNode = screenUV, levelNode = null ) {
 
 		if ( _sharedFramebuffer === null ) {
 
@@ -31,6 +36,4 @@ class ViewportSharedTextureNode extends ViewportTextureNode {
 
 export default ViewportSharedTextureNode;
 
-ViewportSharedTextureNode.type = /*@__PURE__*/ registerNode( 'ViewportSharedTexture', ViewportSharedTextureNode );
-
 export const viewportSharedTexture = /*@__PURE__*/ nodeProxy( ViewportSharedTextureNode );

package/src/nodes/display/ViewportTextureNode.js

@@ -1,8 +1,7 @@
-import { registerNode } from '../core/Node.js';
 import TextureNode from '../accessors/TextureNode.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
-import { viewportUV } from './ViewportNode.js';
+import { screenUV } from './ScreenNode.js';
 
 import { Vector2 } from '../../math/Vector2.js';
 import { FramebufferTexture } from '../../textures/FramebufferTexture.js';
@@ -12,7 +11,13 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class ViewportTextureNode extends TextureNode {
 
-	constructor( uvNode = viewportUV, levelNode = null, framebufferTexture = null ) {
+	static get type() {
+
+		return 'ViewportTextureNode';
+
+	}
+
+	constructor( uvNode = screenUV, levelNode = null, framebufferTexture = null ) {
 
 		if ( framebufferTexture === null ) {
 
@@ -72,7 +77,5 @@ class ViewportTextureNode extends TextureNode {
 
 export default ViewportTextureNode;
 
-ViewportTextureNode.type = /*@__PURE__*/ registerNode( 'ViewportTexture', ViewportTextureNode );
-
 export const viewportTexture = /*@__PURE__*/ nodeProxy( ViewportTextureNode );
 export const viewportMipTexture = /*@__PURE__*/ nodeProxy( ViewportTextureNode, null, null, { generateMipmaps: true } );

package/src/nodes/fog/FogExp2Node.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import FogNode from './FogNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class FogExp2Node extends FogNode {
 
+	static get type() {
+
+		return 'FogExp2Node';
+
+	}
+
 	constructor( colorNode, densityNode ) {
 
 		super( colorNode );
@@ -27,6 +32,4 @@ class FogExp2Node extends FogNode {
 
 export default FogExp2Node;
 
-FogExp2Node.type = /*@__PURE__*/ registerNode( 'FogExp2', FogExp2Node );
-
 export const densityFog = /*@__PURE__*/ nodeProxy( FogExp2Node );