WebGPURenderer: Tree-shaking 1/2 - revision (#29250)

* revision of `registerNode()`

* added `registerNodeMaterial`

* revision

* revision

* revision

* adding and standardizing PURE

* added PURE and rev

src/loaders/nodes/NodeMaterialLoader.js

@@ -1,4 +1,21 @@
 import { MaterialLoader } from '../../loaders/MaterialLoader.js';
+import { createNodeMaterialFromType } from '../../materials/nodes/NodeMaterial.js';
+
+const superFromTypeFunction = MaterialLoader.createMaterialFromType;
+
+MaterialLoader.createMaterialFromType = function ( type ) {
+
+	const material = createNodeMaterialFromType( type );
+
+	if ( material !== undefined ) {
+
+		return material;
+
+	}
+
+	return superFromTypeFunction.call( this, type );
+
+};
 
 class NodeMaterialLoader extends MaterialLoader {
 

src/materials/nodes/InstancedPointsNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { property } from '../../nodes/core/PropertyNode.js';
 import { attribute } from '../../nodes/core/AttributeNode.js';
 import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
@@ -165,3 +165,5 @@ class InstancedPointsNodeMaterial extends NodeMaterial {
 }
 
 export default InstancedPointsNodeMaterial;
+
+InstancedPointsNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'InstancedPoints', InstancedPointsNodeMaterial );

src/materials/nodes/Line2NodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { property, varyingProperty } from '../../nodes/core/PropertyNode.js';
 import { attribute } from '../../nodes/core/AttributeNode.js';
 import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
@@ -433,3 +433,5 @@ class Line2NodeMaterial extends NodeMaterial {
 }
 
 export default Line2NodeMaterial;
+
+Line2NodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Line2', Line2NodeMaterial );

src/materials/nodes/LineBasicNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 
 import { LineBasicMaterial } from '../LineBasicMaterial.js';
 
@@ -23,3 +23,5 @@ class LineBasicNodeMaterial extends NodeMaterial {
 }
 
 export default LineBasicNodeMaterial;
+
+LineBasicNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'LineBasic', LineBasicNodeMaterial );

src/materials/nodes/LineDashedNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { attribute } from '../../nodes/core/AttributeNode.js';
 import { materialLineDashSize, materialLineGapSize, materialLineScale } from '../../nodes/accessors/MaterialNode.js';
 import { dashSize, gapSize } from '../../nodes/core/PropertyNode.js';
@@ -49,3 +49,5 @@ class LineDashedNodeMaterial extends NodeMaterial {
 }
 
 export default LineDashedNodeMaterial;
+
+LineDashedNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'LineDashed', LineDashedNodeMaterial );

src/materials/nodes/MeshBasicNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { materialLightMap } from '../../nodes/accessors/MaterialNode.js';
 import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
 import BasicLightMapNode from '../../nodes/lighting/BasicLightMapNode.js';
@@ -69,3 +69,5 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 }
 
 export default MeshBasicNodeMaterial;
+
+MeshBasicNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshBasic', MeshBasicNodeMaterial );

src/materials/nodes/MeshLambertNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
 import PhongLightingModel from '../../nodes/functions/PhongLightingModel.js';
 
@@ -39,3 +39,5 @@ class MeshLambertNodeMaterial extends NodeMaterial {
 }
 
 export default MeshLambertNodeMaterial;
+
+MeshLambertNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshLambert', MeshLambertNodeMaterial );

src/materials/nodes/MeshMatcapNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
 import { diffuseColor } from '../../nodes/core/PropertyNode.js';
 import { vec3 } from '../../nodes/tsl/TSLBase.js';
@@ -49,3 +49,5 @@ class MeshMatcapNodeMaterial extends NodeMaterial {
 
 
 export default MeshMatcapNodeMaterial;
+
+MeshMatcapNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshMatcap', MeshMatcapNodeMaterial );

src/materials/nodes/MeshNormalNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { diffuseColor } from '../../nodes/core/PropertyNode.js';
 import { directionToColor } from '../../nodes/utils/Packing.js';
 import { materialOpacity } from '../../nodes/accessors/MaterialNode.js';
@@ -36,3 +36,5 @@ class MeshNormalNodeMaterial extends NodeMaterial {
 }
 
 export default MeshNormalNodeMaterial;
+
+MeshNormalNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshNormal', MeshNormalNodeMaterial );

src/materials/nodes/MeshPhongNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { shininess, specularColor } from '../../nodes/core/PropertyNode.js';
 import { materialShininess, materialSpecular } from '../../nodes/accessors/MaterialNode.js';
 import { float } from '../../nodes/tsl/TSLBase.js';
@@ -70,3 +70,5 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 }
 
 export default MeshPhongNodeMaterial;
+
+MeshPhongNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshPhong', MeshPhongNodeMaterial );

src/materials/nodes/MeshPhysicalNodeMaterial.js

@@ -8,6 +8,7 @@ import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 import { mix, pow2, min } from '../../nodes/math/MathNode.js';
 
 import { MeshPhysicalMaterial } from '../MeshPhysicalMaterial.js';
+import { registerNodeMaterial } from './NodeMaterial.js';
 
 const _defaultValues = /*@__PURE__*/ new MeshPhysicalMaterial();
 
@@ -240,3 +241,5 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 }
 
 export default MeshPhysicalNodeMaterial;
+
+MeshPhysicalNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshPhysical', MeshPhysicalNodeMaterial );

src/materials/nodes/MeshSSSNodeMaterial.js

@@ -3,6 +3,7 @@ import PhysicalLightingModel from '../../nodes/functions/PhysicalLightingModel.j
 import { transformedNormalView } from '../../nodes/accessors/Normal.js';
 import { positionViewDirection } from '../../nodes/accessors/Position.js';
 import { float, vec3 } from '../../nodes/tsl/TSLBase.js';
+import { registerNodeMaterial } from './NodeMaterial.js';
 
 class SSSLightingModel extends PhysicalLightingModel {
 
@@ -79,3 +80,5 @@ class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
 }
 
 export default MeshSSSNodeMaterial;
+
+MeshSSSNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshSSS', MeshSSSNodeMaterial );

src/materials/nodes/MeshStandardNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { diffuseColor, metalness, roughness, specularColor, specularF90 } from '../../nodes/core/PropertyNode.js';
 import { mix } from '../../nodes/math/MathNode.js';
 import { materialRoughness, materialMetalness } from '../../nodes/accessors/MaterialNode.js';
@@ -100,3 +100,5 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 }
 
 export default MeshStandardNodeMaterial;
+
+MeshStandardNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshStandard', MeshStandardNodeMaterial );

src/materials/nodes/MeshToonNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import ToonLightingModel from '../../nodes/functions/ToonLightingModel.js';
 
 import { MeshToonMaterial } from '../MeshToonMaterial.js';
@@ -30,3 +30,5 @@ class MeshToonNodeMaterial extends NodeMaterial {
 }
 
 export default MeshToonNodeMaterial;
+
+MeshToonNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshToon', MeshToonNodeMaterial );

src/materials/nodes/NodeMaterial.js

@@ -23,6 +23,8 @@ import { depth } from '../../nodes/display/ViewportDepthNode.js';
 import { cameraLogDepth } from '../../nodes/accessors/Camera.js';
 import { clipping, clippingAlpha } from '../../nodes/accessors/ClippingNode.js';
 
+const NodeMaterials = new Map();
+
 class NodeMaterial extends Material {
 
 	constructor() {
@@ -621,3 +623,45 @@ class NodeMaterial extends Material {
 }
 
 export default NodeMaterial;
+
+NodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( '', NodeMaterial );
+
+export function registerNodeMaterial( type, nodeMaterialClass ) {
+
+	const suffix = 'NodeMaterial';
+	const nodeMaterialType = type + suffix;
+
+	if ( typeof nodeMaterialClass !== 'function' ) throw new Error( `THREE.Node: NodeMaterial class "${ type }" is not a class.` );
+
+	if ( NodeMaterials.has( nodeMaterialType ) ) {
+
+		console.warn( `THREE.Node: Redefinition of NodeMaterial class "${ nodeMaterialType }".` );
+		return;
+
+	}
+
+	if ( type.slice( - suffix.length ) === suffix ) {
+
+		console.warn( `THREE.NodeMaterial: NodeMaterial class ${ nodeMaterialType } should not have '${ suffix }' suffix.` );
+		return;
+
+	}
+
+	NodeMaterials.set( nodeMaterialType, nodeMaterialClass );
+	nodeMaterialClass.type = nodeMaterialType;
+
+	return nodeMaterialType;
+
+}
+
+export function createNodeMaterialFromType( type ) {
+
+	const Material = NodeMaterials.get( type );
+
+	if ( Material !== undefined ) {
+
+		return new Material();
+
+	}
+
+}

src/materials/nodes/PointsNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 
 import { PointsMaterial } from '../PointsMaterial.js';
 
@@ -34,3 +34,5 @@ class PointsNodeMaterial extends NodeMaterial {
 }
 
 export default PointsNodeMaterial;
+
+PointsNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Points', PointsNodeMaterial );

src/materials/nodes/ShadowNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import ShadowMaskModel from '../../nodes/functions/ShadowMaskModel.js';
 
 import { ShadowMaterial } from '../ShadowMaterial.js';
@@ -30,3 +30,5 @@ class ShadowNodeMaterial extends NodeMaterial {
 }
 
 export default ShadowNodeMaterial;
+
+ShadowNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Shadow', ShadowNodeMaterial );

src/materials/nodes/SpriteNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { uniform } from '../../nodes/core/UniformNode.js';
 import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
 import { materialRotation } from '../../nodes/accessors/MaterialNode.js';
@@ -86,3 +86,5 @@ class SpriteNodeMaterial extends NodeMaterial {
 }
 
 export default SpriteNodeMaterial;
+
+SpriteNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Sprite', SpriteNodeMaterial );

src/materials/nodes/VolumeNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
 import { property } from '../../nodes/core/PropertyNode.js';
 import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
 import { modelWorldMatrixInverse } from '../../nodes/accessors/ModelNode.js';
@@ -100,3 +100,5 @@ class VolumeNodeMaterial extends NodeMaterial {
 }
 
 export default VolumeNodeMaterial;
+
+VolumeNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Volume', VolumeNodeMaterial );

src/nodes/Nodes.js

@@ -10,7 +10,7 @@ export { default as ConstNode } from './core/ConstNode.js';
 export { default as ContextNode } from './core/ContextNode.js';
 export { default as IndexNode } from './core/IndexNode.js';
 export { default as LightingModel } from './core/LightingModel.js';
-export { default as Node } from './core/Node.js';
+export { default as Node, registerNode } from './core/Node.js';
 export { default as VarNode } from './core/VarNode.js';
 export { default as NodeAttribute } from './core/NodeAttribute.js';
 export { default as NodeBuilder } from './core/NodeBuilder.js';

src/nodes/accessors/AccessorsUtils.js

@@ -6,12 +6,12 @@ import { mix } from '../math/MathNode.js';
 import { anisotropy, anisotropyB, roughness } from '../core/PropertyNode.js';
 import { positionViewDirection } from './Position.js';
 
-export const TBNViewMatrix = mat3( tangentView, bitangentView, normalView );
+export const TBNViewMatrix = /*@__PURE__*/ mat3( tangentView, bitangentView, normalView );
 
-export const parallaxDirection = positionViewDirection.mul( TBNViewMatrix )/*.normalize()*/;
+export const parallaxDirection = /*@__PURE__*/ positionViewDirection.mul( TBNViewMatrix )/*.normalize()*/;
 export const parallaxUV = ( uv, scale ) => uv.sub( parallaxDirection.mul( scale ) );
 
-export const transformedBentNormalView = ( () => {
+export const transformedBentNormalView = /*@__PURE__*/ ( () => {
 
 	// https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/anisotropy
 

src/nodes/accessors/BatchNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { normalLocal } from './Normal.js';
 import { positionLocal } from './Position.js';
 import { nodeProxy, vec3, mat3, mat4, int, ivec2, float, Fn } from '../tsl/TSLBase.js';
@@ -119,6 +119,6 @@ class BatchNode extends Node {
 
 export default BatchNode;
 
-registerNodeClass( 'Batch', BatchNode );
+BatchNode.type = /*@__PURE__*/ registerNode( 'Batch', BatchNode );
 
-export const batch = nodeProxy( BatchNode );
+export const batch = /*@__PURE__*/ nodeProxy( BatchNode );

src/nodes/accessors/Bitangent.js

@@ -5,9 +5,9 @@ import { tangentGeometry, tangentLocal, tangentView, tangentWorld, transformedTa
 
 const getBitangent = ( crossNormalTangent ) => crossNormalTangent.mul( tangentGeometry.w ).xyz;
 
-export const bitangentGeometry = /*#__PURE__*/ varying( getBitangent( normalGeometry.cross( tangentGeometry ) ), 'v_bitangentGeometry' ).normalize().toVar( 'bitangentGeometry' );
-export const bitangentLocal = /*#__PURE__*/ varying( getBitangent( normalLocal.cross( tangentLocal ) ), 'v_bitangentLocal' ).normalize().toVar( 'bitangentLocal' );
-export const bitangentView = /*#__PURE__*/ varying( getBitangent( normalView.cross( tangentView ) ), 'v_bitangentView' ).normalize().toVar( 'bitangentView' );
-export const bitangentWorld = /*#__PURE__*/ varying( getBitangent( normalWorld.cross( tangentWorld ) ), 'v_bitangentWorld' ).normalize().toVar( 'bitangentWorld' );
-export const transformedBitangentView = /*#__PURE__*/ getBitangent( transformedNormalView.cross( transformedTangentView ) ).normalize().toVar( 'transformedBitangentView' );
-export const transformedBitangentWorld = /*#__PURE__*/ transformedBitangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedBitangentWorld' );
+export const bitangentGeometry = /*@__PURE__*/ varying( getBitangent( normalGeometry.cross( tangentGeometry ) ), 'v_bitangentGeometry' ).normalize().toVar( 'bitangentGeometry' );
+export const bitangentLocal = /*@__PURE__*/ varying( getBitangent( normalLocal.cross( tangentLocal ) ), 'v_bitangentLocal' ).normalize().toVar( 'bitangentLocal' );
+export const bitangentView = /*@__PURE__*/ varying( getBitangent( normalView.cross( tangentView ) ), 'v_bitangentView' ).normalize().toVar( 'bitangentView' );
+export const bitangentWorld = /*@__PURE__*/ varying( getBitangent( normalWorld.cross( tangentWorld ) ), 'v_bitangentWorld' ).normalize().toVar( 'bitangentWorld' );
+export const transformedBitangentView = /*@__PURE__*/ getBitangent( transformedNormalView.cross( transformedTangentView ) ).normalize().toVar( 'transformedBitangentView' );
+export const transformedBitangentWorld = /*@__PURE__*/ transformedBitangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedBitangentWorld' );

src/nodes/accessors/BufferAttributeNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import InputNode from '../core/InputNode.js';
 import { nodeObject, addMethodChaining } from '../tsl/TSLCore.js';
 import { varying } from '../core/VaryingNode.js';
@@ -151,7 +151,7 @@ class BufferAttributeNode extends InputNode {
 
 export default BufferAttributeNode;
 
-registerNodeClass( 'BufferAttribute', BufferAttributeNode );
+BufferAttributeNode.type = /*@__PURE__*/ registerNode( 'BufferAttribute', BufferAttributeNode );
 
 export const bufferAttribute = ( array, type, stride, offset ) => nodeObject( new BufferAttributeNode( array, type, stride, offset ) );
 export const dynamicBufferAttribute = ( array, type, stride, offset ) => bufferAttribute( array, type, stride, offset ).setUsage( DynamicDrawUsage );

src/nodes/accessors/BufferNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -31,6 +31,6 @@ class BufferNode extends UniformNode {
 
 export default BufferNode;
 
-registerNodeClass( 'Buffer', BufferNode );
+BufferNode.type = /*@__PURE__*/ registerNode( 'Buffer', BufferNode );
 
 export const buffer = ( value, type, count ) => nodeObject( new BufferNode( value, type, count ) );

src/nodes/accessors/Camera.js

@@ -2,18 +2,18 @@ import { uniform } from '../core/UniformNode.js';
 import { sharedUniformGroup } from '../core/UniformGroupNode.js';
 import { Vector3 } from '../../math/Vector3.js';
 
-const cameraGroup = /*#__PURE__*/ sharedUniformGroup( 'camera' ).onRenderUpdate( () => {
+const cameraGroup = /*@__PURE__*/ sharedUniformGroup( 'camera' ).onRenderUpdate( () => {
 
 	cameraGroup.needsUpdate = true;
 
 } );
 
-export const cameraNear = /*#__PURE__*/ uniform( 'float' ).label( 'cameraNear' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.near );
-export const cameraFar = /*#__PURE__*/ uniform( 'float' ).label( 'cameraFar' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.far );
-export const cameraLogDepth = /*#__PURE__*/ uniform( 'float' ).label( 'cameraLogDepth' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
-export const cameraProjectionMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrix );
-export const cameraProjectionMatrixInverse = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrixInverse' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrixInverse );
-export const cameraViewMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraViewMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorldInverse );
-export const cameraWorldMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraWorldMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorld );
-export const cameraNormalMatrix = /*#__PURE__*/ uniform( 'mat3' ).label( 'cameraNormalMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.normalMatrix );
-export const cameraPosition = /*#__PURE__*/ uniform( new Vector3() ).label( 'cameraPosition' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera }, self ) => self.value.setFromMatrixPosition( camera.matrixWorld ) );
+export const cameraNear = /*@__PURE__*/ uniform( 'float' ).label( 'cameraNear' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.near );
+export const cameraFar = /*@__PURE__*/ uniform( 'float' ).label( 'cameraFar' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.far );
+export const cameraLogDepth = /*@__PURE__*/ uniform( 'float' ).label( 'cameraLogDepth' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
+export const cameraProjectionMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrix );
+export const cameraProjectionMatrixInverse = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrixInverse' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrixInverse );
+export const cameraViewMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraViewMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorldInverse );
+export const cameraWorldMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraWorldMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorld );
+export const cameraNormalMatrix = /*@__PURE__*/ uniform( 'mat3' ).label( 'cameraNormalMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.normalMatrix );
+export const cameraPosition = /*@__PURE__*/ uniform( new Vector3() ).label( 'cameraPosition' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera }, self ) => self.value.setFromMatrixPosition( camera.matrixWorld ) );

src/nodes/accessors/ClippingNode.js

@@ -1,5 +1,5 @@
 
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { positionView } from './Position.js';
 import { diffuseColor, property } from '../core/PropertyNode.js';
@@ -140,7 +140,7 @@ ClippingNode.DEFAULT = 'default';
 
 export default ClippingNode;
 
-registerNodeClass( 'Clipping', ClippingNode );
+ClippingNode.type = /*@__PURE__*/ registerNode( 'Clipping', ClippingNode );
 
 export const clipping = () => nodeObject( new ClippingNode() );
 

src/nodes/accessors/CubeTextureNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { reflectVector, refractVector } from './ReflectVector.js';
 import { nodeProxy, vec3 } from '../tsl/TSLBase.js';
@@ -71,6 +71,6 @@ class CubeTextureNode extends TextureNode {
 
 export default CubeTextureNode;
 
-registerNodeClass( 'CubeTexture', CubeTextureNode );
+CubeTextureNode.type = /*@__PURE__*/ registerNode( 'CubeTexture', CubeTextureNode );
 
-export const cubeTexture = nodeProxy( CubeTextureNode );
+export const cubeTexture = /*@__PURE__*/ nodeProxy( CubeTextureNode );

src/nodes/accessors/InstanceNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { varyingProperty } from '../core/PropertyNode.js';
 import { instancedBufferAttribute, instancedDynamicBufferAttribute } from './BufferAttributeNode.js';
 import { normalLocal } from './Normal.js';
@@ -139,6 +139,6 @@ class InstanceNode extends Node {
 
 export default InstanceNode;
 
-registerNodeClass( 'Instance', InstanceNode );
+InstanceNode.type = /*@__PURE__*/ registerNode( 'Instance', InstanceNode );
 
-export const instance = nodeProxy( InstanceNode );
+export const instance = /*@__PURE__*/ nodeProxy( InstanceNode );

src/nodes/accessors/InstancedPointsMaterialNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import MaterialNode from './MaterialNode.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
@@ -16,6 +16,6 @@ InstancedPointsMaterialNode.POINT_WIDTH = 'pointWidth';
 
 export default InstancedPointsMaterialNode;
 
-registerNodeClass( 'InstancedPointsMaterial', InstancedPointsMaterialNode );
+InstancedPointsMaterialNode.type = /*@__PURE__*/ registerNode( 'InstancedPointsMaterial', InstancedPointsMaterialNode );
 
-export const materialPointWidth = nodeImmutable( InstancedPointsMaterialNode, InstancedPointsMaterialNode.POINT_WIDTH );
+export const materialPointWidth = /*@__PURE__*/ nodeImmutable( InstancedPointsMaterialNode, InstancedPointsMaterialNode.POINT_WIDTH );

src/nodes/accessors/MaterialNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { reference } from './ReferenceNode.js';
 import { materialReference } from './MaterialReferenceNode.js';
 import { normalView } from './Normal.js';
@@ -384,49 +384,49 @@ MaterialNode.AO_MAP = 'ao';
 
 export default MaterialNode;
 
-registerNodeClass( 'Material', MaterialNode );
-
-export const materialAlphaTest = nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
-export const materialColor = nodeImmutable( MaterialNode, MaterialNode.COLOR );
-export const materialShininess = nodeImmutable( MaterialNode, MaterialNode.SHININESS );
-export const materialEmissive = nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
-export const materialOpacity = nodeImmutable( MaterialNode, MaterialNode.OPACITY );
-export const materialSpecular = nodeImmutable( MaterialNode, MaterialNode.SPECULAR );
-
-export const materialSpecularIntensity = nodeImmutable( MaterialNode, MaterialNode.SPECULAR_INTENSITY );
-export const materialSpecularColor = nodeImmutable( MaterialNode, MaterialNode.SPECULAR_COLOR );
-
-export const materialSpecularStrength = nodeImmutable( MaterialNode, MaterialNode.SPECULAR_STRENGTH );
-export const materialReflectivity = nodeImmutable( MaterialNode, MaterialNode.REFLECTIVITY );
-export const materialRoughness = nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
-export const materialMetalness = nodeImmutable( MaterialNode, MaterialNode.METALNESS );
-export const materialNormal = nodeImmutable( MaterialNode, MaterialNode.NORMAL ).context( { getUV: null } );
-export const materialClearcoat = nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT );
-export const materialClearcoatRoughness = nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT_ROUGHNESS );
-export const materialClearcoatNormal = nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT_NORMAL ).context( { getUV: null } );
-export const materialRotation = nodeImmutable( MaterialNode, MaterialNode.ROTATION );
-export const materialSheen = nodeImmutable( MaterialNode, MaterialNode.SHEEN );
-export const materialSheenRoughness = nodeImmutable( MaterialNode, MaterialNode.SHEEN_ROUGHNESS );
-export const materialAnisotropy = nodeImmutable( MaterialNode, MaterialNode.ANISOTROPY );
-export const materialIridescence = nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE );
-export const materialIridescenceIOR = nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE_IOR );
-export const materialIridescenceThickness = nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE_THICKNESS );
-export const materialTransmission = nodeImmutable( MaterialNode, MaterialNode.TRANSMISSION );
-export const materialThickness = nodeImmutable( MaterialNode, MaterialNode.THICKNESS );
-export const materialIOR = nodeImmutable( MaterialNode, MaterialNode.IOR );
-export const materialAttenuationDistance = nodeImmutable( MaterialNode, MaterialNode.ATTENUATION_DISTANCE );
-export const materialAttenuationColor = nodeImmutable( MaterialNode, MaterialNode.ATTENUATION_COLOR );
-export const materialLineScale = nodeImmutable( MaterialNode, MaterialNode.LINE_SCALE );
-export const materialLineDashSize = nodeImmutable( MaterialNode, MaterialNode.LINE_DASH_SIZE );
-export const materialLineGapSize = nodeImmutable( MaterialNode, MaterialNode.LINE_GAP_SIZE );
-export const materialLineWidth = nodeImmutable( MaterialNode, MaterialNode.LINE_WIDTH );
-export const materialLineDashOffset = nodeImmutable( MaterialNode, MaterialNode.LINE_DASH_OFFSET );
-export const materialPointWidth = nodeImmutable( MaterialNode, MaterialNode.POINT_WIDTH );
-export const materialDispersion = nodeImmutable( MaterialNode, MaterialNode.DISPERSION );
-export const materialLightMap = nodeImmutable( MaterialNode, MaterialNode.LIGHT_MAP );
-export const materialAOMap = nodeImmutable( MaterialNode, MaterialNode.AO_MAP );
-export const materialRefractionRatio = nodeImmutable( MaterialNode, MaterialNode.REFRACTION_RATIO );
-export const materialAnisotropyVector = uniform( new Vector2() ).onReference( function ( frame ) {
+MaterialNode.type = /*@__PURE__*/ registerNode( 'Material', MaterialNode );
+
+export const materialAlphaTest = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
+export const materialColor = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.COLOR );
+export const materialShininess = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SHININESS );
+export const materialEmissive = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
+export const materialOpacity = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.OPACITY );
+export const materialSpecular = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SPECULAR );
+
+export const materialSpecularIntensity = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SPECULAR_INTENSITY );
+export const materialSpecularColor = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SPECULAR_COLOR );
+
+export const materialSpecularStrength = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SPECULAR_STRENGTH );
+export const materialReflectivity = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.REFLECTIVITY );
+export const materialRoughness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
+export const materialMetalness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.METALNESS );
+export const materialNormal = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.NORMAL ).context( { getUV: null } );
+export const materialClearcoat = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT );
+export const materialClearcoatRoughness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT_ROUGHNESS );
+export const materialClearcoatNormal = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.CLEARCOAT_NORMAL ).context( { getUV: null } );
+export const materialRotation = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ROTATION );
+export const materialSheen = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SHEEN );
+export const materialSheenRoughness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SHEEN_ROUGHNESS );
+export const materialAnisotropy = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ANISOTROPY );
+export const materialIridescence = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE );
+export const materialIridescenceIOR = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE_IOR );
+export const materialIridescenceThickness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.IRIDESCENCE_THICKNESS );
+export const materialTransmission = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.TRANSMISSION );
+export const materialThickness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.THICKNESS );
+export const materialIOR = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.IOR );
+export const materialAttenuationDistance = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ATTENUATION_DISTANCE );
+export const materialAttenuationColor = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ATTENUATION_COLOR );
+export const materialLineScale = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LINE_SCALE );
+export const materialLineDashSize = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LINE_DASH_SIZE );
+export const materialLineGapSize = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LINE_GAP_SIZE );
+export const materialLineWidth = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LINE_WIDTH );
+export const materialLineDashOffset = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LINE_DASH_OFFSET );
+export const materialPointWidth = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.POINT_WIDTH );
+export const materialDispersion = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.DISPERSION );
+export const materialLightMap = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LIGHT_MAP );
+export const materialAOMap = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.AO_MAP );
+export const materialRefractionRatio = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.REFRACTION_RATIO );
+export const materialAnisotropyVector = /*@__PURE__*/ uniform( new Vector2() ).onReference( function ( frame ) {
 
 	return frame.material;
 

src/nodes/accessors/MaterialReferenceNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import ReferenceNode from './ReferenceNode.js';
 //import { renderGroup } from '../core/UniformGroupNode.js';
 //import { NodeUpdateType } from '../core/constants.js';
@@ -38,6 +38,6 @@ class MaterialReferenceNode extends ReferenceNode {
 
 export default MaterialReferenceNode;
 
-registerNodeClass( 'MaterialReference', MaterialReferenceNode );
+MaterialReferenceNode.type = /*@__PURE__*/ registerNode( 'MaterialReference', MaterialReferenceNode );
 
 export const materialReference = ( name, type, material ) => nodeObject( new MaterialReferenceNode( name, type, material ) );

src/nodes/accessors/ModelNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import Object3DNode from './Object3DNode.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -25,13 +25,13 @@ class ModelNode extends Object3DNode {
 
 export default ModelNode;
 
-registerNodeClass( 'Model', ModelNode );
+ModelNode.type = /*@__PURE__*/ registerNode( 'Model', ModelNode );
 
-export const modelDirection = nodeImmutable( ModelNode, ModelNode.DIRECTION );
-export const modelViewMatrix = nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX ).label( 'modelViewMatrix' ).toVar( 'ModelViewMatrix' );
-export const modelNormalMatrix = nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
-export const modelWorldMatrix = nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
-export const modelPosition = nodeImmutable( ModelNode, ModelNode.POSITION );
-export const modelScale = nodeImmutable( ModelNode, ModelNode.SCALE );
-export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
-export const modelWorldMatrixInverse = uniform( new Matrix4() ).onObjectUpdate( ( { object }, self ) => self.value.copy( object.matrixWorld ).invert() );
+export const modelDirection = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.DIRECTION );
+export const modelViewMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX ).label( 'modelViewMatrix' ).toVar( 'ModelViewMatrix' );
+export const modelNormalMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
+export const modelWorldMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
+export const modelPosition = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.POSITION );
+export const modelScale = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.SCALE );
+export const modelViewPosition = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
+export const modelWorldMatrixInverse = /*@__PURE__*/ uniform( new Matrix4() ).onObjectUpdate( ( { object }, self ) => self.value.copy( object.matrixWorld ).invert() );

src/nodes/accessors/ModelViewProjectionNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { cameraProjectionMatrix } from './Camera.js';
 import { modelViewMatrix } from './ModelNode.js';
@@ -33,6 +33,6 @@ class ModelViewProjectionNode extends TempNode {
 
 export default ModelViewProjectionNode;
 
-registerNodeClass( 'ModelViewProjection', ModelViewProjectionNode );
+ModelViewProjectionNode.type = /*@__PURE__*/ registerNode( 'ModelViewProjection', ModelViewProjectionNode );
 
-export const modelViewProjection = nodeProxy( ModelViewProjectionNode );
+export const modelViewProjection = /*@__PURE__*/ nodeProxy( ModelViewProjectionNode );

src/nodes/accessors/MorphNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { float, nodeProxy, Fn } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -15,10 +15,10 @@ import { Vector2 } from '../../math/Vector2.js';
 import { Vector4 } from '../../math/Vector4.js';
 import { FloatType } from '../../constants.js';
 
-const _morphTextures = new WeakMap();
+const _morphTextures = /*@__PURE__*/ new WeakMap();
 const _morphVec4 = /*@__PURE__*/ new Vector4();
 
-const getMorph = Fn( ( { bufferMap, influence, stride, width, depth, offset } ) => {
+const getMorph = /*@__PURE__*/ Fn( ( { bufferMap, influence, stride, width, depth, offset } ) => {
 
 	const texelIndex = int( vertexIndex ).mul( stride ).add( offset );
 
@@ -254,6 +254,6 @@ class MorphNode extends Node {
 
 export default MorphNode;
 
-registerNodeClass( 'Morph', MorphNode );
+MorphNode.type = /*@__PURE__*/ registerNode( 'Morph', MorphNode );
 
-export const morphReference = nodeProxy( MorphNode );
+export const morphReference = /*@__PURE__*/ nodeProxy( MorphNode );

src/nodes/accessors/Normal.js

@@ -6,9 +6,9 @@ import { positionView } from './Position.js';
 import { Fn, varying } from '../tsl/TSLBase.js';
 import { faceDirection } from '../display/FrontFacingNode.js';
 
-export const normalGeometry = /*#__PURE__*/ attribute( 'normal', 'vec3' );
+export const normalGeometry = /*@__PURE__*/ attribute( 'normal', 'vec3' );
 
-export const normalLocal = /*#__PURE__*/ ( Fn( ( builder ) => {
+export const normalLocal = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	if ( builder.geometry.hasAttribute( 'normal' ) === false ) {
 
@@ -22,11 +22,11 @@ export const normalLocal = /*#__PURE__*/ ( Fn( ( builder ) => {
 
 }, 'vec3' ).once() )().toVar( 'normalLocal' );
 
-export const normalFlat = /*#__PURE__*/ positionView.dFdx().cross( positionView.dFdy() ).normalize().toVar( 'normalFlat' );
+export const normalFlat = /*@__PURE__*/ positionView.dFdx().cross( positionView.dFdy() ).normalize().toVar( 'normalFlat' );
 
 let normalViewVarying = null;
 
-export const normalView = /*#__PURE__*/ ( Fn( ( builder ) => {
+export const normalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	let node;
 
@@ -44,18 +44,18 @@ export const normalView = /*#__PURE__*/ ( Fn( ( builder ) => {
 
 }, 'vec3' ).once() )().toVar( 'normalView' );
 
-export const normalWorld = /*#__PURE__*/ varying( normalView.transformDirection( cameraViewMatrix ), 'v_normalWorld' ).normalize().toVar( 'normalWorld' );
+export const normalWorld = /*@__PURE__*/ varying( normalView.transformDirection( cameraViewMatrix ), 'v_normalWorld' ).normalize().toVar( 'normalWorld' );
 
-export const transformedNormalView = /*#__PURE__*/ ( Fn( ( builder ) => {
+export const transformedNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	return builder.context.setupNormal();
 
 }, 'vec3' ).once() )().mul( faceDirection ).toVar( 'transformedNormalView' );
 
 
-export const transformedNormalWorld = /*#__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedNormalWorld' );
+export const transformedNormalWorld = /*@__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedNormalWorld' );
 
-export const transformedClearcoatNormalView = /*#__PURE__*/ ( Fn( ( builder ) => {
+export const transformedClearcoatNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	return builder.context.setupClearcoatNormal();
 

src/nodes/accessors/Object3DNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
@@ -139,12 +139,12 @@ Object3DNode.DIRECTION = 'direction';
 
 export default Object3DNode;
 
-registerNodeClass( 'Object3D', Object3DNode );
+Object3DNode.type = /*@__PURE__*/ registerNode( 'Object3D', Object3DNode );
 
-export const objectDirection = nodeProxy( Object3DNode, Object3DNode.DIRECTION );
-export const objectViewMatrix = nodeProxy( Object3DNode, Object3DNode.VIEW_MATRIX );
-export const objectNormalMatrix = nodeProxy( Object3DNode, Object3DNode.NORMAL_MATRIX );
-export const objectWorldMatrix = nodeProxy( Object3DNode, Object3DNode.WORLD_MATRIX );
-export const objectPosition = nodeProxy( Object3DNode, Object3DNode.POSITION );
-export const objectScale = nodeProxy( Object3DNode, Object3DNode.SCALE );
-export const objectViewPosition = nodeProxy( Object3DNode, Object3DNode.VIEW_POSITION );
+export const objectDirection = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.DIRECTION );
+export const objectViewMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.VIEW_MATRIX );
+export const objectNormalMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.NORMAL_MATRIX );
+export const objectWorldMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.WORLD_MATRIX );
+export const objectPosition = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.POSITION );
+export const objectScale = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.SCALE );
+export const objectViewPosition = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.VIEW_POSITION );

src/nodes/accessors/PointUVNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
 class PointUVNode extends Node {
@@ -21,6 +21,6 @@ class PointUVNode extends Node {
 
 export default PointUVNode;
 
-registerNodeClass( 'PointUV', PointUVNode );
+PointUVNode.type = /*@__PURE__*/ registerNode( 'PointUV', PointUVNode );
 
-export const pointUV = nodeImmutable( PointUVNode );
+export const pointUV = /*@__PURE__*/ nodeImmutable( PointUVNode );

src/nodes/accessors/Position.js

@@ -1,10 +1,10 @@
 import { attribute } from '../core/AttributeNode.js';
 import { modelWorldMatrix, modelViewMatrix } from './ModelNode.js';
 
-export const positionGeometry = /*#__PURE__*/ attribute( 'position', 'vec3' );
-export const positionLocal = /*#__PURE__*/ positionGeometry.varying( 'positionLocal' );
-export const positionPrevious = /*#__PURE__*/ positionGeometry.varying( 'positionPrevious' );
-export const positionWorld = /*#__PURE__*/ modelWorldMatrix.mul( positionLocal ).xyz.varying( 'v_positionWorld' );
-export const positionWorldDirection = /*#__PURE__*/ positionLocal.transformDirection( modelWorldMatrix ).varying( 'v_positionWorldDirection' ).normalize().toVar( 'positionWorldDirection' );
-export const positionView = /*#__PURE__*/ modelViewMatrix.mul( positionLocal ).xyz.varying( 'v_positionView' );
-export const positionViewDirection = /*#__PURE__*/ positionView.negate().varying( 'v_positionViewDirection' ).normalize().toVar( 'positionViewDirection' );
+export const positionGeometry = /*@__PURE__*/ attribute( 'position', 'vec3' );
+export const positionLocal = /*@__PURE__*/ positionGeometry.varying( 'positionLocal' );
+export const positionPrevious = /*@__PURE__*/ positionGeometry.varying( 'positionPrevious' );
+export const positionWorld = /*@__PURE__*/ modelWorldMatrix.mul( positionLocal ).xyz.varying( 'v_positionWorld' );
+export const positionWorldDirection = /*@__PURE__*/ positionLocal.transformDirection( modelWorldMatrix ).varying( 'v_positionWorldDirection' ).normalize().toVar( 'positionWorldDirection' );
+export const positionView = /*@__PURE__*/ modelViewMatrix.mul( positionLocal ).xyz.varying( 'v_positionView' );
+export const positionViewDirection = /*@__PURE__*/ positionView.negate().varying( 'v_positionViewDirection' ).normalize().toVar( 'positionViewDirection' );

src/nodes/accessors/ReferenceBaseNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { nodeObject } from '../tsl/TSLCore.js';
@@ -137,7 +137,7 @@ class ReferenceBaseNode extends Node {
 
 export default ReferenceBaseNode;
 
-registerNodeClass( 'ReferenceBase', ReferenceBaseNode );
+ReferenceBaseNode.type = /*@__PURE__*/ registerNode( 'ReferenceBase', ReferenceBaseNode );
 
 export const reference = ( name, type, object ) => nodeObject( new ReferenceBaseNode( name, type, object ) );
 export const referenceBuffer = ( name, type, count, object ) => nodeObject( new ReferenceBaseNode( name, type, object, count ) );

src/nodes/accessors/ReferenceNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { texture } from './TextureNode.js';
@@ -166,7 +166,7 @@ class ReferenceNode extends Node {
 
 export default ReferenceNode;
 
-registerNodeClass( 'Reference', ReferenceNode );
+ReferenceNode.type = /*@__PURE__*/ registerNode( 'Reference', ReferenceNode );
 
 export const reference = ( name, type, object ) => nodeObject( new ReferenceNode( name, type, object ) );
 export const referenceBuffer = ( name, type, count, object ) => nodeObject( new ReferenceNode( name, type, object, count ) );

src/nodes/accessors/ReflectVector.js

@@ -3,8 +3,8 @@ import { transformedNormalView } from './Normal.js';
 import { positionViewDirection } from './Position.js';
 import { materialRefractionRatio } from './MaterialProperties.js';
 
-export const reflectView = /*#__PURE__*/ positionViewDirection.negate().reflect( transformedNormalView );
-export const refractView = /*#__PURE__*/ positionViewDirection.negate().refract( transformedNormalView, materialRefractionRatio );
+export const reflectView = /*@__PURE__*/ positionViewDirection.negate().reflect( transformedNormalView );
+export const refractView = /*@__PURE__*/ positionViewDirection.negate().refract( transformedNormalView, materialRefractionRatio );
 
-export const reflectVector = /*#__PURE__*/ reflectView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );
-export const refractVector = /*#__PURE__*/ refractView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );
+export const reflectVector = /*@__PURE__*/ reflectView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );
+export const refractVector = /*@__PURE__*/ refractView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );

src/nodes/accessors/RendererReferenceNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import ReferenceBaseNode from './ReferenceBaseNode.js';
 import { nodeObject } from '../tsl/TSLCore.js';
 
@@ -24,6 +24,6 @@ class RendererReferenceNode extends ReferenceBaseNode {
 
 export default RendererReferenceNode;
 
-registerNodeClass( 'RendererReference', RendererReferenceNode );
+RendererReferenceNode.type = /*@__PURE__*/ registerNode( 'RendererReference', RendererReferenceNode );
 
 export const rendererReference = ( name, type, renderer ) => nodeObject( new RendererReferenceNode( name, type, renderer ) );

src/nodes/accessors/SceneNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 import { reference } from './ReferenceNode.js';
 
@@ -45,7 +45,7 @@ SceneNode.BACKGROUND_INTENSITY = 'backgroundIntensity';
 
 export default SceneNode;
 
-registerNodeClass( 'Scene', SceneNode );
+SceneNode.type = /*@__PURE__*/ registerNode( 'Scene', SceneNode );
 
-export const backgroundBlurriness = nodeImmutable( SceneNode, SceneNode.BACKGROUND_BLURRINESS );
-export const backgroundIntensity = nodeImmutable( SceneNode, SceneNode.BACKGROUND_INTENSITY );
+export const backgroundBlurriness = /*@__PURE__*/ nodeImmutable( SceneNode, SceneNode.BACKGROUND_BLURRINESS );
+export const backgroundIntensity = /*@__PURE__*/ nodeImmutable( SceneNode, SceneNode.BACKGROUND_INTENSITY );

src/nodes/accessors/SkinningNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { attribute } from '../core/AttributeNode.js';
@@ -181,7 +181,7 @@ class SkinningNode extends Node {
 
 export default SkinningNode;
 
-registerNodeClass( 'Skinning', SkinningNode );
+SkinningNode.type = /*@__PURE__*/ registerNode( 'Skinning', SkinningNode );
 
 export const skinning = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh ) );
 export const skinningReference = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh, true ) );

src/nodes/accessors/StorageBufferNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import BufferNode from './BufferNode.js';
 import { bufferAttribute } from './BufferAttributeNode.js';
 import { nodeObject, varying } from '../tsl/TSLBase.js';
@@ -122,7 +122,7 @@ class StorageBufferNode extends BufferNode {
 
 export default StorageBufferNode;
 
-registerNodeClass( 'StorageBuffer', StorageBufferNode );
+StorageBufferNode.type = /*@__PURE__*/ registerNode( 'StorageBuffer', StorageBufferNode );
 
 // Read-Write Storage
 export const storage = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ) );

src/nodes/accessors/StorageTextureNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 import { GPUStorageTextureAccess } from '../../renderers/webgpu/utils/WebGPUConstants.js';
@@ -89,9 +89,9 @@ class StorageTextureNode extends TextureNode {
 
 export default StorageTextureNode;
 
-registerNodeClass( 'StorageTexture', StorageTextureNode );
+StorageTextureNode.type = /*@__PURE__*/ registerNode( 'StorageTexture', StorageTextureNode );
 
-export const storageTexture = nodeProxy( StorageTextureNode );
+export const storageTexture = /*@__PURE__*/ nodeProxy( StorageTextureNode );
 
 export const textureStore = ( value, uvNode, storeNode ) => {
 

src/nodes/accessors/Tangent.js

@@ -3,7 +3,7 @@ import { cameraViewMatrix } from './Camera.js';
 import { modelViewMatrix } from './ModelNode.js';
 import { Fn, vec4 } from '../tsl/TSLBase.js';
 
-export const tangentGeometry = /*#__PURE__*/ Fn( ( builder ) => {
+export const tangentGeometry = /*@__PURE__*/ Fn( ( builder ) => {
 
 	if ( builder.geometry.hasAttribute( 'tangent' ) === false ) {
 
@@ -15,8 +15,8 @@ export const tangentGeometry = /*#__PURE__*/ Fn( ( builder ) => {
 
 } )();
 
-export const tangentLocal = /*#__PURE__*/ tangentGeometry.xyz.toVar( 'tangentLocal' );
-export const tangentView = /*#__PURE__*/ modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz.varying( 'v_tangentView' ).normalize().toVar( 'tangentView' );
-export const tangentWorld = /*#__PURE__*/ tangentView.transformDirection( cameraViewMatrix ).varying( 'v_tangentWorld' ).normalize().toVar( 'tangentWorld' );
-export const transformedTangentView = /*#__PURE__*/ tangentView.toVar( 'transformedTangentView' );
-export const transformedTangentWorld = /*#__PURE__*/ transformedTangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedTangentWorld' );
+export const tangentLocal = /*@__PURE__*/ tangentGeometry.xyz.toVar( 'tangentLocal' );
+export const tangentView = /*@__PURE__*/ modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz.varying( 'v_tangentView' ).normalize().toVar( 'tangentView' );
+export const tangentWorld = /*@__PURE__*/ tangentView.transformDirection( cameraViewMatrix ).varying( 'v_tangentWorld' ).normalize().toVar( 'tangentWorld' );
+export const transformedTangentView = /*@__PURE__*/ tangentView.toVar( 'transformedTangentView' );
+export const transformedTangentWorld = /*@__PURE__*/ transformedTangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedTangentWorld' );

src/nodes/accessors/Texture3DNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { nodeProxy, vec3, Fn, If } from '../tsl/TSLBase.js';
 
@@ -95,6 +95,6 @@ class Texture3DNode extends TextureNode {
 
 export default Texture3DNode;
 
-registerNodeClass( 'Texture3D', Texture3DNode );
+Texture3DNode.type = /*@__PURE__*/ registerNode( 'Texture3D', Texture3DNode );
 
-export const texture3D = nodeProxy( Texture3DNode );
+export const texture3D = /*@__PURE__*/ nodeProxy( Texture3DNode );

src/nodes/accessors/TextureBicubic.js

@@ -51,7 +51,7 @@ const bicubic = ( textureNode, texelSize, lod ) => {
 
 };
 
-export const textureBicubic = Fn( ( [ textureNode, lodNode = float( 3 ) ] ) => {
+export const textureBicubic = /*@__PURE__*/ Fn( ( [ textureNode, lodNode = float( 3 ) ] ) => {
 
 	const fLodSize = vec2( textureNode.size( int( lodNode ) ) );
 	const cLodSize = vec2( textureNode.size( int( lodNode.add( 1.0 ) ) ) );

src/nodes/accessors/TextureNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import UniformNode, { uniform } from '../core/UniformNode.js';
 import { uv } from './UV.js';
 import { textureSize } from './TextureSizeNode.js';
@@ -430,9 +430,9 @@ class TextureNode extends UniformNode {
 
 export default TextureNode;
 
-registerNodeClass( 'Texture', TextureNode );
+TextureNode.type = /*@__PURE__*/ registerNode( 'Texture', TextureNode );
 
-export const texture = nodeProxy( TextureNode );
+export const texture = /*@__PURE__*/ nodeProxy( TextureNode );
 export const textureLoad = ( ...params ) => texture( ...params ).setSampler( false );
 
 //export const textureLevel = ( value, uv, level ) => texture( value, uv ).level( level );

src/nodes/accessors/TextureSizeNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
@@ -28,6 +28,6 @@ class TextureSizeNode extends Node {
 
 export default TextureSizeNode;
 
-registerNodeClass( 'TextureSize', TextureSizeNode );
+TextureSizeNode.type = /*@__PURE__*/ registerNode( 'TextureSize', TextureSizeNode );
 
-export const textureSize = nodeProxy( TextureSizeNode );
+export const textureSize = /*@__PURE__*/ nodeProxy( TextureSizeNode );

src/nodes/accessors/UniformArrayNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { getValueType } from '../core/NodeUtils.js';
@@ -141,7 +141,7 @@ class UniformArrayNode extends BufferNode {
 
 export default UniformArrayNode;
 
-registerNodeClass( 'UniformArray', UniformArrayNode );
+UniformArrayNode.type = /*@__PURE__*/ registerNode( 'UniformArray', UniformArrayNode );
 
 export const uniformArray = ( values, nodeType ) => nodeObject( new UniformArrayNode( values, nodeType ) );
 

src/nodes/accessors/UserDataNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import ReferenceNode from './ReferenceNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -24,6 +24,6 @@ class UserDataNode extends ReferenceNode {
 
 export default UserDataNode;
 
-registerNodeClass( 'UserData', UserDataNode );
+UserDataNode.type = /*@__PURE__*/ registerNode( 'UserData', UserDataNode );
 
 export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );

src/nodes/accessors/VelocityNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { modelViewMatrix } from './ModelNode.js';
 import { positionLocal, positionPrevious } from './Position.js';
@@ -78,6 +78,6 @@ function getPreviousMatrix( object ) {
 
 export default VelocityNode;
 
-registerNodeClass( 'Velocity', VelocityNode );
+VelocityNode.type = /*@__PURE__*/ registerNode( 'Velocity', VelocityNode );
 
-export const velocity = nodeImmutable( VelocityNode );
+export const velocity = /*@__PURE__*/ nodeImmutable( VelocityNode );

src/nodes/accessors/VertexColorNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -66,6 +66,6 @@ class VertexColorNode extends AttributeNode {
 
 export default VertexColorNode;
 
-registerNodeClass( 'VertexColor', VertexColorNode );
+VertexColorNode.type = /*@__PURE__*/ registerNode( 'VertexColor', VertexColorNode );
 
 export const vertexColor = ( ...params ) => nodeObject( new VertexColorNode( ...params ) );

src/nodes/code/CodeNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class CodeNode extends Node {
@@ -75,9 +75,9 @@ class CodeNode extends Node {
 
 export default CodeNode;
 
-registerNodeClass( 'Code', CodeNode );
+CodeNode.type = /*@__PURE__*/ registerNode( 'Code', CodeNode );
 
-export const code = nodeProxy( CodeNode );
+export const code = /*@__PURE__*/ nodeProxy( CodeNode );
 
 export const js = ( src, includes ) => code( src, includes, 'js' );
 export const wgsl = ( src, includes ) => code( src, includes, 'wgsl' );

src/nodes/code/ExpressionNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLCore.js';
 
 class ExpressionNode extends Node {
@@ -32,6 +32,6 @@ class ExpressionNode extends Node {
 
 export default ExpressionNode;
 
-registerNodeClass( 'Expression', ExpressionNode );
+ExpressionNode.type = /*@__PURE__*/ registerNode( 'Expression', ExpressionNode );
 
-export const expression = nodeProxy( ExpressionNode );
+export const expression = /*@__PURE__*/ nodeProxy( ExpressionNode );

src/nodes/code/FunctionCallNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeArray, nodeObject, nodeObjects } from '../tsl/TSLCore.js';
 
@@ -83,7 +83,7 @@ class FunctionCallNode extends TempNode {
 
 export default FunctionCallNode;
 
-registerNodeClass( 'FunctionCall', FunctionCallNode );
+FunctionCallNode.type = /*@__PURE__*/ registerNode( 'FunctionCall', FunctionCallNode );
 
 export const call = ( func, ...params ) => {
 

src/nodes/code/FunctionNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import CodeNode from './CodeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -81,7 +81,7 @@ class FunctionNode extends CodeNode {
 
 export default FunctionNode;
 
-registerNodeClass( 'Function', FunctionNode );
+FunctionNode.type = /*@__PURE__*/ registerNode( 'Function', FunctionNode );
 
 const nativeFn = ( code, includes = [], language = '' ) => {
 

src/nodes/code/ScriptableNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { scriptableValue } from './ScriptableValueNode.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
 
@@ -495,6 +495,6 @@ class ScriptableNode extends Node {
 
 export default ScriptableNode;
 
-registerNodeClass( 'Scriptable', ScriptableNode );
+ScriptableNode.type = /*@__PURE__*/ registerNode( 'Scriptable', ScriptableNode );
 
-export const scriptable = nodeProxy( ScriptableNode );
+export const scriptable = /*@__PURE__*/ nodeProxy( ScriptableNode );

src/nodes/code/ScriptableValueNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
 
@@ -161,6 +161,6 @@ class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-registerNodeClass( 'ScriptableValue', ScriptableValueNode );
+ScriptableValueNode.type = /*@__PURE__*/ registerNode( 'ScriptableValue', ScriptableValueNode );
 
-export const scriptableValue = nodeProxy( ScriptableValueNode );
+export const scriptableValue = /*@__PURE__*/ nodeProxy( ScriptableValueNode );

src/nodes/core/AssignNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 import { vectorComponents } from '../core/constants.js';
@@ -121,8 +121,8 @@ class AssignNode extends TempNode {
 
 export default AssignNode;
 
-registerNodeClass( 'Assign', AssignNode );
+AssignNode.type = /*@__PURE__*/ registerNode( 'Assign', AssignNode );
 
-export const assign = nodeProxy( AssignNode );
+export const assign = /*@__PURE__*/ nodeProxy( AssignNode );
 
 addMethodChaining( 'assign', assign );

src/nodes/core/AttributeNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
@@ -116,6 +116,6 @@ class AttributeNode extends Node {
 
 export default AttributeNode;
 
-registerNodeClass( 'Attribute', AttributeNode );
+AttributeNode.type = /*@__PURE__*/ registerNode( 'Attribute', AttributeNode );
 
 export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );

src/nodes/core/BypassNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class BypassNode extends Node {
@@ -38,8 +38,8 @@ class BypassNode extends Node {
 
 export default BypassNode;
 
-registerNodeClass( 'Bypass', BypassNode );
+BypassNode.type = /*@__PURE__*/ registerNode( 'Bypass', BypassNode );
 
-export const bypass = nodeProxy( BypassNode );
+export const bypass = /*@__PURE__*/ nodeProxy( BypassNode );
 
 addMethodChaining( 'bypass', bypass );

src/nodes/core/CacheNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
 
 class CacheNode extends Node {
@@ -39,7 +39,7 @@ class CacheNode extends Node {
 
 export default CacheNode;
 
-registerNodeClass( 'Cache', CacheNode );
+CacheNode.type = /*@__PURE__*/ registerNode( 'Cache', CacheNode );
 
 export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
 

src/nodes/core/ConstNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from './Node.js';
+import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
 
 class ConstNode extends InputNode {
@@ -29,4 +29,4 @@ class ConstNode extends InputNode {
 
 export default ConstNode;
 
-registerNodeClass( 'Const', ConstNode );
+ConstNode.type = /*@__PURE__*/ registerNode( 'Const', ConstNode );

src/nodes/core/ContextNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
@@ -64,9 +64,9 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-registerNodeClass( 'Context', ContextNode );
+ContextNode.type = /*@__PURE__*/ registerNode( 'Context', ContextNode );
 
-export const context = nodeProxy( ContextNode );
+export const context = /*@__PURE__*/ nodeProxy( ContextNode );
 export const label = ( node, name ) => context( node, { label: name } );
 
 addMethodChaining( 'context', context );

src/nodes/core/IndexNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { nodeImmutable, varying } from '../tsl/TSLBase.js';
 
 class IndexNode extends Node {
@@ -69,9 +69,9 @@ IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
-registerNodeClass( 'Index', IndexNode );
+IndexNode.type = /*@__PURE__*/ registerNode( 'Index', IndexNode );
 
-export const vertexIndex = nodeImmutable( IndexNode, IndexNode.VERTEX );
-export const instanceIndex = nodeImmutable( IndexNode, IndexNode.INSTANCE );
-export const invocationLocalIndex = nodeImmutable( IndexNode, IndexNode.INVOCATION_LOCAL );
-export const drawIndex = nodeImmutable( IndexNode, IndexNode.DRAW );
+export const vertexIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.VERTEX );
+export const instanceIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INSTANCE );
+export const invocationLocalIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INVOCATION_LOCAL );
+export const drawIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.DRAW );

src/nodes/core/InputNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
@@ -80,4 +80,4 @@ class InputNode extends Node {
 
 export default InputNode;
 
-registerNodeClass( 'Input', InputNode );
+InputNode.type = /*@__PURE__*/ registerNode( 'Input', InputNode );

src/nodes/core/MRTNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from './Node.js';
+import { registerNode } from './Node.js';
 import OutputStructNode from './OutputStructNode.js';
 import { nodeProxy, vec4 } from '../tsl/TSLBase.js';
 
@@ -77,6 +77,6 @@ class MRTNode extends OutputStructNode {
 
 export default MRTNode;
 
-registerNodeClass( 'MRT', MRTNode );
+MRTNode.type = /*@__PURE__*/ registerNode( 'MRT', MRTNode );
 
-export const mrt = nodeProxy( MRTNode );
+export const mrt = /*@__PURE__*/ nodeProxy( MRTNode );

src/nodes/core/Node.js

@@ -4,7 +4,7 @@ import { getNodeChildren, getCacheKey } from './NodeUtils.js';
 import { EventDispatcher } from '../../core/EventDispatcher.js';
 import { MathUtils } from '../../math/MathUtils.js';
 
-const NodeClasses = new Map();
+const Nodes = new Map();
 
 let _nodeId = 0;
 
@@ -541,34 +541,39 @@ class Node extends EventDispatcher {
 
 export default Node;
 
-export function registerNodeClass( type, nodeClass ) {
+Node.type = /*@__PURE__*/ registerNode( '', Node );
 
-	const nodeType = type + 'Node';
+export function registerNode( type, nodeClass ) {
 
-	if ( typeof nodeClass !== 'function' || ! type ) throw new Error( `TSL.Node: Node class ${ type } is not a class` );
+	const suffix = 'Node';
+	const nodeType = type + suffix;
 
-	if ( NodeClasses.has( nodeType ) ) {
+	if ( typeof nodeClass !== 'function' ) throw new Error( `TSL.Node: Node class ${ type } is not a class` );
+
+	if ( Nodes.has( nodeType ) ) {
 
 		console.warn( `TSL.Node: Redefinition of node class ${ nodeType }` );
 		return;
 
 	}
 
-	if ( type.slice( - 4 ) === 'Node' ) {
+	if ( type.slice( - suffix.length ) === suffix ) {
 
-		console.warn( `TSL.Node: Node class ${ nodeType } should not have 'Node' suffix.` );
+		console.warn( `TSL.Node: Node class ${ nodeType } should not have '${ suffix }' suffix.` );
 		return;
 
 	}
 
-	NodeClasses.set( nodeType, nodeClass );
+	Nodes.set( nodeType, nodeClass );
 	nodeClass.type = nodeType;
 
+	return nodeType;
+
 }
 
 export function createNodeFromType( type ) {
 
-	const Class = NodeClasses.get( type );
+	const Class = Nodes.get( type );
 
 	if ( Class !== undefined ) {
 
@@ -580,7 +585,7 @@ export function createNodeFromType( type ) {
 
 export function addNodeClass( type, nodeClass ) {
 
-	console.warn( 'TSL.Node: Function addNodeClass() is deprecated. Use registerNodeClass() instead.' );
-	registerNodeClass( type.slice( 0, - 4 ), nodeClass );
+	console.warn( 'TSL.Node: Function addNodeClass() is deprecated. Use /*@__PURE__*/ registerNode() instead.' );
+	/*@__PURE__*/ registerNode( type.slice( 0, - 4 ), nodeClass );
 
 }

src/nodes/core/OutputStructNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import StructTypeNode from './StructTypeNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
@@ -54,6 +54,6 @@ class OutputStructNode extends Node {
 
 export default OutputStructNode;
 
-registerNodeClass( 'OutputStruct', OutputStructNode );
+OutputStructNode.type = /*@__PURE__*/ registerNode( 'OutputStruct', OutputStructNode );
 
-export const outputStruct = nodeProxy( OutputStructNode );
+export const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );

src/nodes/core/ParameterNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from './Node.js';
+import { registerNode } from './Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import PropertyNode from './PropertyNode.js';
 
@@ -28,6 +28,6 @@ class ParameterNode extends PropertyNode {
 
 export default ParameterNode;
 
-registerNodeClass( 'Parameter', ParameterNode );
+ParameterNode.type = /*@__PURE__*/ registerNode( 'Parameter', ParameterNode );
 
 export const parameter = ( type, name ) => nodeObject( new ParameterNode( type, name ) );

src/nodes/core/PropertyNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { nodeImmutable, nodeObject } from '../tsl/TSLCore.js';
 
 class PropertyNode extends Node {
@@ -49,36 +49,36 @@ class PropertyNode extends Node {
 
 export default PropertyNode;
 
-registerNodeClass( 'Property', PropertyNode );
+PropertyNode.type = /*@__PURE__*/ registerNode( 'Property', PropertyNode );
 
 export const property = ( type, name ) => nodeObject( new PropertyNode( type, name ) );
 export const varyingProperty = ( type, name ) => nodeObject( new PropertyNode( type, name, true ) );
 
-export const diffuseColor = nodeImmutable( PropertyNode, 'vec4', 'DiffuseColor' );
-export const emissive = nodeImmutable( PropertyNode, 'vec3', 'EmissiveColor' );
-export const roughness = nodeImmutable( PropertyNode, 'float', 'Roughness' );
-export const metalness = nodeImmutable( PropertyNode, 'float', 'Metalness' );
-export const clearcoat = nodeImmutable( PropertyNode, 'float', 'Clearcoat' );
-export const clearcoatRoughness = nodeImmutable( PropertyNode, 'float', 'ClearcoatRoughness' );
-export const sheen = nodeImmutable( PropertyNode, 'vec3', 'Sheen' );
-export const sheenRoughness = nodeImmutable( PropertyNode, 'float', 'SheenRoughness' );
-export const iridescence = nodeImmutable( PropertyNode, 'float', 'Iridescence' );
-export const iridescenceIOR = nodeImmutable( PropertyNode, 'float', 'IridescenceIOR' );
-export const iridescenceThickness = nodeImmutable( PropertyNode, 'float', 'IridescenceThickness' );
-export const alphaT = nodeImmutable( PropertyNode, 'float', 'AlphaT' );
-export const anisotropy = nodeImmutable( PropertyNode, 'float', 'Anisotropy' );
-export const anisotropyT = nodeImmutable( PropertyNode, 'vec3', 'AnisotropyT' );
-export const anisotropyB = nodeImmutable( PropertyNode, 'vec3', 'AnisotropyB' );
-export const specularColor = nodeImmutable( PropertyNode, 'color', 'SpecularColor' );
-export const specularF90 = nodeImmutable( PropertyNode, 'float', 'SpecularF90' );
-export const shininess = nodeImmutable( PropertyNode, 'float', 'Shininess' );
-export const output = nodeImmutable( PropertyNode, 'vec4', 'Output' );
-export const dashSize = nodeImmutable( PropertyNode, 'float', 'dashSize' );
-export const gapSize = nodeImmutable( PropertyNode, 'float', 'gapSize' );
-export const pointWidth = nodeImmutable( PropertyNode, 'float', 'pointWidth' );
-export const ior = nodeImmutable( PropertyNode, 'float', 'IOR' );
-export const transmission = nodeImmutable( PropertyNode, 'float', 'Transmission' );
-export const thickness = nodeImmutable( PropertyNode, 'float', 'Thickness' );
-export const attenuationDistance = nodeImmutable( PropertyNode, 'float', 'AttenuationDistance' );
-export const attenuationColor = nodeImmutable( PropertyNode, 'color', 'AttenuationColor' );
-export const dispersion = nodeImmutable( PropertyNode, 'float', 'Dispersion' );
+export const diffuseColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec4', 'DiffuseColor' );
+export const emissive = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'EmissiveColor' );
+export const roughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Roughness' );
+export const metalness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Metalness' );
+export const clearcoat = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Clearcoat' );
+export const clearcoatRoughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'ClearcoatRoughness' );
+export const sheen = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'Sheen' );
+export const sheenRoughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'SheenRoughness' );
+export const iridescence = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Iridescence' );
+export const iridescenceIOR = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IridescenceIOR' );
+export const iridescenceThickness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IridescenceThickness' );
+export const alphaT = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'AlphaT' );
+export const anisotropy = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Anisotropy' );
+export const anisotropyT = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'AnisotropyT' );
+export const anisotropyB = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'AnisotropyB' );
+export const specularColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'color', 'SpecularColor' );
+export const specularF90 = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'SpecularF90' );
+export const shininess = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Shininess' );
+export const output = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec4', 'Output' );
+export const dashSize = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'dashSize' );
+export const gapSize = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'gapSize' );
+export const pointWidth = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'pointWidth' );
+export const ior = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IOR' );
+export const transmission = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Transmission' );
+export const thickness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Thickness' );
+export const attenuationDistance = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'AttenuationDistance' );
+export const attenuationColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'color', 'AttenuationColor' );
+export const dispersion = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Dispersion' );

src/nodes/core/StackNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { select } from '../math/ConditionalNode.js';
 import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../tsl/TSLBase.js';
 
@@ -100,6 +100,6 @@ class StackNode extends Node {
 
 export default StackNode;
 
-registerNodeClass( 'Stack', StackNode );
+StackNode.type = /*@__PURE__*/ registerNode( 'Stack', StackNode );
 
-export const stack = nodeProxy( StackNode );
+export const stack = /*@__PURE__*/ nodeProxy( StackNode );

src/nodes/core/StructTypeNode.js

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

src/nodes/core/TempNode.js

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

src/nodes/core/UniformGroupNode.js

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

src/nodes/core/UniformNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from './Node.js';
+import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
 import { objectGroup } from './UniformGroupNode.js';
 import { nodeObject, getConstNodeType } from '../tsl/TSLCore.js';
@@ -95,7 +95,7 @@ class UniformNode extends InputNode {
 
 export default UniformNode;
 
-registerNodeClass( 'Uniform', UniformNode );
+UniformNode.type = /*@__PURE__*/ registerNode( 'Uniform', UniformNode );
 
 export const uniform = ( arg1, arg2 ) => {
 

src/nodes/core/VarNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from './Node.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;
 
-registerNodeClass( 'Var', VarNode );
+VarNode.type = /*@__PURE__*/ registerNode( 'Var', VarNode );
 
-export const temp = nodeProxy( VarNode );
+export const temp = /*@__PURE__*/ nodeProxy( VarNode );
 
 addMethodChaining( 'temp', temp ); // @TODO: Will be removed in the future
 addMethodChaining( 'toVar', ( ...params ) => temp( ...params ).append() );

src/nodes/core/VaryingNode.js

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

src/nodes/display/BlendMode.js

@@ -1,7 +1,7 @@
 import { Fn } from '../tsl/TSLBase.js';
 import { mix, min, step } from '../math/MathNode.js';
 
-export const burn = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
+export const burn = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
 
 	return min( 1.0, base.oneMinus().div( blend ) ).oneMinus();
 
@@ -14,7 +14,7 @@ export const burn = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
 	]
 } );
 
-export const dodge = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
+export const dodge = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
 
 	return min( base.div( blend.oneMinus() ), 1.0 );
 
@@ -27,7 +27,7 @@ export const dodge = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
 	]
 } );
 
-export const screen = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
+export const screen = /*@__PURE__*/ Fn( ( [ base, blend ] ) => {
 
 	return base.oneMinus().mul( blend.oneMinus() ).oneMinus();
 
@@ -40,7 +40,7 @@ export const screen = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
 	]
 } );
 
-export const overlay = /*#__PURE__*/ Fn( ( [ base, blend ] ) => {
+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 ) );
 

src/nodes/display/BumpMapNode.js

@@ -72,4 +72,4 @@ class BumpMapNode extends TempNode {
 
 export default BumpMapNode;
 
-export const bumpMap = nodeProxy( BumpMapNode );
+export const bumpMap = /*@__PURE__*/ nodeProxy( BumpMapNode );

src/nodes/display/ColorAdjustment.js

@@ -4,19 +4,19 @@ 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 ] ) => {
+export const grayscale = /*@__PURE__*/ Fn( ( [ color ] ) => {
 
 	return luminance( color.rgb );
 
 } );
 
-export const saturation = /*#__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
+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 ) ] ) => {
+export const vibrance = /*@__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
 
 	const average = add( color.r, color.g, color.b ).div( 3.0 );
 
@@ -27,7 +27,7 @@ export const vibrance = /*#__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] )
 
 } );
 
-export const hue = /*#__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
+export const hue = /*@__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
 
 	const k = vec3( 0.57735, 0.57735, 0.57735 );
 
@@ -37,7 +37,7 @@ export const hue = /*#__PURE__*/ Fn( ( [ color, adjustment = float( 1 ) ] ) => {
 
 } );
 
-const _luminanceCoefficients = /*#__PURE__*/ new Vector3();
+const _luminanceCoefficients = /*@__PURE__*/ new Vector3();
 export const luminance = (
 	color,
 	luminanceCoefficients = vec3( ... ColorManagement.getLuminanceCoefficients( _luminanceCoefficients ) )

src/nodes/display/ColorSpaceFunctions.js

@@ -1,7 +1,7 @@
 import { mix } from '../math/MathNode.js';
 import { Fn } from '../tsl/TSLBase.js';
 
-export const sRGBToLinearShader = Fn( ( [ color ] ) => {
+export const sRGBToLinear = /*@__PURE__*/ Fn( ( [ color ] ) => {
 
 	const a = color.mul( 0.9478672986 ).add( 0.0521327014 ).pow( 2.4 );
 	const b = color.mul( 0.0773993808 );
@@ -12,14 +12,14 @@ export const sRGBToLinearShader = Fn( ( [ color ] ) => {
 	return rgbResult;
 
 } ).setLayout( {
-	name: 'sRGBToLinearShader',
+	name: 'sRGBToLinear',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' }
 	]
 } );
 
-export const LinearTosRGBShader = Fn( ( [ color ] ) => {
+export const LinearTosRGB = /*@__PURE__*/ Fn( ( [ color ] ) => {
 
 	const a = color.pow( 0.41666 ).mul( 1.055 ).sub( 0.055 );
 	const b = color.mul( 12.92 );
@@ -30,7 +30,7 @@ export const LinearTosRGBShader = Fn( ( [ color ] ) => {
 	return rgbResult;
 
 } ).setLayout( {
-	name: 'LinearTosRGBShader',
+	name: 'LinearTosRGB',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' }

src/nodes/display/ColorSpaceNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeObject, vec4 } from '../tsl/TSLCore.js';
 
@@ -76,7 +76,7 @@ class ColorSpaceNode extends TempNode {
 
 export default ColorSpaceNode;
 
-registerNodeClass( 'ColorSpace', ColorSpaceNode );
+ColorSpaceNode.type = /*@__PURE__*/ registerNode( 'ColorSpace', ColorSpaceNode );
 
 export const linearSRGBToColorSpace = ( node, colorSpace = null ) => nodeObject( new ColorSpaceNode( nodeObject( node ), colorSpace, LinearSRGBColorSpace ) );
 export const colorSpaceToLinearSRGB = ( node, colorSpace = null ) => nodeObject( new ColorSpaceNode( nodeObject( node ), LinearSRGBColorSpace, colorSpace ) );

src/nodes/display/DenoiseNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, float, int, vec2, vec3, vec4, mat2, If } from '../tsl/TSLBase.js';
@@ -163,7 +163,7 @@ class DenoiseNode extends TempNode {
 
 export default DenoiseNode;
 
-registerNodeClass( 'Denoise', DenoiseNode );
+DenoiseNode.type = /*@__PURE__*/ registerNode( 'Denoise', DenoiseNode );
 
 function generatePdSamplePointInitializer( samples, rings, radiusExponent ) {
 

src/nodes/display/DepthOfFieldNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, vec2, vec4 } from '../tsl/TSLBase.js';
@@ -116,6 +116,6 @@ class DepthOfFieldNode extends TempNode {
 
 export default DepthOfFieldNode;
 
-registerNodeClass( 'DepthOfField', DepthOfFieldNode );
+DepthOfFieldNode.type = /*@__PURE__*/ registerNode( 'DepthOfField', 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 ) ) );

src/nodes/display/DotScreenNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { nodeObject, Fn, vec2, vec3, vec4 } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -58,6 +58,6 @@ class DotScreenNode extends TempNode {
 
 export default DotScreenNode;
 
-registerNodeClass( 'DotScreen', DotScreenNode );
+DotScreenNode.type = /*@__PURE__*/ registerNode( 'DotScreen', DotScreenNode );
 
 export const dotScreen = ( node, center, angle, scale ) => nodeObject( new DotScreenNode( nodeObject( node ), center, angle, scale ) );

src/nodes/display/FXAANode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, float, vec2, vec4, int, If } from '../tsl/TSLBase.js';
@@ -324,6 +324,6 @@ class FXAANode extends TempNode {
 
 export default FXAANode;
 
-registerNodeClass( 'FXAA', FXAANode );
+FXAANode.type = /*@__PURE__*/ registerNode( 'FXAA', FXAANode );
 
 export const fxaa = ( node ) => nodeObject( new FXAANode( convertToTexture( node ) ) );

src/nodes/display/FilmNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeProxy, vec4 } from '../tsl/TSLBase.js';
@@ -48,6 +48,6 @@ class FilmNode extends TempNode {
 
 export default FilmNode;
 
-registerNodeClass( 'Film', FilmNode );
+FilmNode.type = /*@__PURE__*/ registerNode( 'Film', FilmNode );
 
-export const film = nodeProxy( FilmNode );
+export const film = /*@__PURE__*/ nodeProxy( FilmNode );

src/nodes/display/FrontFacingNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNodeClass } from '../core/Node.js';
+import Node, { registerNode } from '../core/Node.js';
 import { nodeImmutable, float } from '../tsl/TSLBase.js';
 
 import { BackSide, WebGLCoordinateSystem } from '../../constants.js';
@@ -35,7 +35,7 @@ class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-registerNodeClass( 'FrontFacing', FrontFacingNode );
+FrontFacingNode.type = /*@__PURE__*/ registerNode( 'FrontFacing', FrontFacingNode );
 
-export const frontFacing = nodeImmutable( FrontFacingNode );
-export const faceDirection = float( frontFacing ).mul( 2.0 ).sub( 1.0 );
+export const frontFacing = /*@__PURE__*/ nodeImmutable( FrontFacingNode );
+export const faceDirection = /*@__PURE__*/ float( frontFacing ).mul( 2.0 ).sub( 1.0 );

src/nodes/display/GTAONode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { textureSize } from '../accessors/TextureSizeNode.js';
@@ -239,7 +239,7 @@ class GTAONode extends TempNode {
 
 export default GTAONode;
 
-registerNodeClass( 'GTAO', GTAONode );
+GTAONode.type = /*@__PURE__*/ registerNode( 'GTAO', GTAONode );
 
 function generateMagicSquareNoise( size = 5 ) {
 

src/nodes/display/GaussianBlurNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { nodeObject, Fn, float, vec2, vec4 } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
@@ -205,6 +205,6 @@ class GaussianBlurNode extends TempNode {
 
 export default GaussianBlurNode;
 
-registerNodeClass( 'GaussianBlur', GaussianBlurNode );
+GaussianBlurNode.type = /*@__PURE__*/ registerNode( 'GaussianBlur', GaussianBlurNode );
 
 export const gaussianBlur = ( node, directionNode, sigma ) => nodeObject( new GaussianBlurNode( convertToTexture( node ), directionNode, sigma ) );

src/nodes/display/Lut3DNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { Fn, nodeObject, vec3, vec4, float } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -49,6 +49,6 @@ class Lut3DNode extends TempNode {
 
 export default Lut3DNode;
 
-registerNodeClass( 'Lut3D', Lut3DNode );
+Lut3DNode.type = /*@__PURE__*/ registerNode( 'Lut3D', Lut3DNode );
 
 export const lut3D = ( node, lut, size, intensity ) => nodeObject( new Lut3DNode( nodeObject( node ), nodeObject( lut ), size, nodeObject( intensity ) ) );

src/nodes/display/MotionBlur.js

@@ -2,7 +2,7 @@ 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 ) ] ) => {
+export const motionBlur = /*@__PURE__*/ Fn( ( [ inputNode, velocity, numSamples = int( 16 ) ] ) => {
 
 	const sampleColor = ( uv ) => inputNode.uv( uv );
 

src/nodes/display/NormalMapNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { add } from '../math/OperatorNode.js';
 
@@ -15,7 +15,7 @@ import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from '../../constants.js'
 // Normal Mapping Without Precomputed Tangents
 // http://www.thetenthplanet.de/archives/1180
 
-const perturbNormal2Arb = Fn( ( inputs ) => {
+const perturbNormal2Arb = /*@__PURE__*/ Fn( ( inputs ) => {
 
 	const { eye_pos, surf_norm, mapN, uv } = inputs;
 
@@ -99,6 +99,6 @@ class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-registerNodeClass( 'NormalMap', NormalMapNode );
+NormalMapNode.type = /*@__PURE__*/ registerNode( 'NormalMap', NormalMapNode );
 
-export const normalMap = nodeProxy( NormalMapNode );
+export const normalMap = /*@__PURE__*/ nodeProxy( NormalMapNode );

src/nodes/display/ParallaxBarrierPassNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } from '../core/Node.js';
 import { Fn, If, nodeObject, vec4 } from '../tsl/TSLBase.js';
 import { uv } from '../accessors/UV.js';
 import { mod } from '../math/MathNode.js';
@@ -50,6 +50,6 @@ class ParallaxBarrierPassNode extends StereoCompositePassNode {
 
 export default ParallaxBarrierPassNode;
 
-registerNodeClass( 'ParallaxBarrierPass', ParallaxBarrierPassNode );
+ParallaxBarrierPassNode.type = /*@__PURE__*/ registerNode( 'ParallaxBarrierPass', ParallaxBarrierPassNode );
 
 export const parallaxBarrierPass = ( scene, camera ) => nodeObject( new ParallaxBarrierPassNode( scene, camera ) );

src/nodes/display/PassNode.js

@@ -1,4 +1,4 @@
-import { registerNodeClass } from '../core/Node.js';
+import { registerNode } 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';
@@ -41,7 +41,7 @@ class PassTextureNode extends TextureNode {
 
 }
 
-registerNodeClass( 'PassTexture', PassTextureNode );
+PassTextureNode.type = /*@__PURE__*/ registerNode( 'PassTexture', PassTextureNode );
 
 class PassMultipleTextureNode extends PassTextureNode {
 
@@ -76,7 +76,7 @@ class PassMultipleTextureNode extends PassTextureNode {
 
 }
 
-registerNodeClass( 'PassMultipleTexture', PassMultipleTextureNode );
+PassMultipleTextureNode.type = /*@__PURE__*/ registerNode( 'PassMultipleTexture', PassMultipleTextureNode );
 
 class PassNode extends TempNode {
 
@@ -360,7 +360,7 @@ PassNode.DEPTH = 'depth';
 
 export default PassNode;
 
-registerNodeClass( 'Pass', PassNode );
+PassNode.type = /*@__PURE__*/ registerNode( 'Pass', 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 ) );