Nodes: Introduce static type (#29282)

* introduce static type

* cleanup

* node materials: introduce static type

* update example

examples/webgpu_materials.html

@@ -398,10 +398,28 @@
 
 			}
 
+			function moduleToLib( module ) {
+
+				const lib = {};
+
+				for ( const nodeElement of Object.values( module ) ) {
+
+					if ( typeof nodeElement === 'function' && nodeElement.type !== undefined ) {
+
+						lib[ nodeElement.type ] = nodeElement;
+
+					}
+
+				}
+
+				return lib;
+
+			}
+
 			function testSerialization( mesh ) {
 
 				const json = mesh.toJSON();
-				const loader = new THREE.NodeObjectLoader();
+				const loader = new THREE.NodeObjectLoader().setNodes( moduleToLib( TSL ) );
 				const serializedMesh = loader.parse( json );
 
 				serializedMesh.position.x = ( objects.length % 4 ) * 200 - 400;

src/loaders/MaterialLoader.js

@@ -86,7 +86,7 @@ class MaterialLoader extends Loader {
 
 		}
 
-		const material = MaterialLoader.createMaterialFromType( json.type );
+		const material = this.createMaterialFromType( json.type );
 
 		if ( json.uuid !== undefined ) material.uuid = json.uuid;
 		if ( json.name !== undefined ) material.name = json.name;
@@ -342,6 +342,12 @@ class MaterialLoader extends Loader {
 
 	}
 
+	createMaterialFromType( type ) {
+
+		return MaterialLoader.createMaterialFromType( type );
+
+	}
+
 	static createMaterialFromType( type ) {
 
 		const materialLib = {

src/loaders/nodes/NodeLoader.js

@@ -1,5 +1,4 @@
-import { createNodeFromType } from '../../nodes/core/Node.js';
-import { nodeObject } from '../../nodes/tsl/TSLBase.js';
+import { nodeObject, float } from '../../nodes/tsl/TSLBase.js';
 
 import { Loader } from '../Loader.js';
 import { FileLoader } from '../../loaders/FileLoader.js';
@@ -11,6 +10,7 @@ class NodeLoader extends Loader {
 		super( manager );
 
 		this.textures = {};
+		this.nodes = {};
 
 	}
 
@@ -56,7 +56,7 @@ class NodeLoader extends Loader {
 
 				const { uuid, type } = nodeJSON;
 
-				nodes[ uuid ] = nodeObject( createNodeFromType( type ) );
+				nodes[ uuid ] = this.createNodeFromType( type );
 				nodes[ uuid ].uuid = uuid;
 
 			}
@@ -82,7 +82,7 @@ class NodeLoader extends Loader {
 
 	parse( json ) {
 
-		const node = nodeObject( createNodeFromType( json.type ) );
+		const node = this.createNodeFromType( json.type );
 		node.uuid = json.uuid;
 
 		const nodes = this.parseNodes( json.nodes );
@@ -105,6 +105,26 @@ class NodeLoader extends Loader {
 
 	}
 
+	setNodes( value ) {
+
+		this.nodes = value;
+		return this;
+
+	}
+
+	createNodeFromType( type ) {
+
+		if ( this.nodes[ type ] === undefined ) {
+
+			console.error( 'THREE.NodeLoader: Node type not found:', type );
+			return float();
+
+		}
+
+		return nodeObject( new this.nodes[ type ]() );
+
+	}
+
 }
 
 export default NodeLoader;

src/loaders/nodes/NodeMaterialLoader.js

@@ -1,21 +1,4 @@
 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 {
 
@@ -24,6 +7,7 @@ class NodeMaterialLoader extends MaterialLoader {
 		super( manager );
 
 		this.nodes = {};
+		this.nodeMaterials = {};
 
 	}
 
@@ -49,11 +33,31 @@ class NodeMaterialLoader extends MaterialLoader {
 	setNodes( value ) {
 
 		this.nodes = value;
+		return this;
 
+	}
+
+	setNodeMaterials( value ) {
+
+		this.nodeMaterials = value;
 		return this;
 
 	}
 
+	createMaterialFromType( type ) {
+
+		const materialClass = this.nodeMaterials[ type ];
+
+		if ( materialClass !== undefined ) {
+
+			return new materialClass();
+
+		}
+
+		return super.createMaterialFromType( type );
+
+	}
+
 }
 
 export default NodeMaterialLoader;

src/loaders/nodes/NodeObjectLoader.js

@@ -9,10 +9,27 @@ class NodeObjectLoader extends ObjectLoader {
 
 		super( manager );
 
+		this.nodes = {};
+		this.nodeMaterials = {};
+
 		this._nodesJSON = null;
 
 	}
 
+	setNodes( value ) {
+
+		this.nodes = value;
+		return this;
+
+	}
+
+	setNodeMaterials( value ) {
+
+		this.nodeMaterials = value;
+		return this;
+
+	}
+
 	parse( json, onLoad ) {
 
 		this._nodesJSON = json.nodes;
@@ -30,6 +47,7 @@ class NodeObjectLoader extends ObjectLoader {
 		if ( json !== undefined ) {
 
 			const loader = new NodeLoader();
+			loader.setNodes( this.nodes );
 			loader.setTextures( textures );
 
 			return loader.parseNodes( json );
@@ -51,6 +69,7 @@ class NodeObjectLoader extends ObjectLoader {
 			const loader = new NodeMaterialLoader();
 			loader.setTextures( textures );
 			loader.setNodes( nodes );
+			loader.setNodeMaterials( this.nodeMaterials );
 
 			for ( let i = 0, l = json.length; i < l; i ++ ) {
 

src/materials/nodes/InstancedPointsNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { property } from '../../nodes/core/PropertyNode.js';
 import { attribute } from '../../nodes/core/AttributeNode.js';
 import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
@@ -16,6 +16,12 @@ const _defaultValues = /*@__PURE__*/ new PointsMaterial();
 
 class InstancedPointsNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'InstancedPointsNodeMaterial';
+
+	}
+
 	constructor( params = {} ) {
 
 		super();
@@ -167,5 +173,3 @@ class InstancedPointsNodeMaterial extends NodeMaterial {
 }
 
 export default InstancedPointsNodeMaterial;
-
-InstancedPointsNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'InstancedPoints', InstancedPointsNodeMaterial );

src/materials/nodes/Line2NodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial 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';
@@ -17,6 +17,12 @@ const _defaultValues = /*@__PURE__*/ new LineDashedMaterial();
 
 class Line2NodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'Line2NodeMaterial';
+
+	}
+
 	constructor( params = {} ) {
 
 		super();
@@ -433,5 +439,3 @@ class Line2NodeMaterial extends NodeMaterial {
 }
 
 export default Line2NodeMaterial;
-
-Line2NodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Line2', Line2NodeMaterial );

src/materials/nodes/LineBasicNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 
 import { LineBasicMaterial } from '../LineBasicMaterial.js';
 
@@ -6,6 +6,12 @@ const _defaultValues = /*@__PURE__*/ new LineBasicMaterial();
 
 class LineBasicNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'LineBasicNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -23,5 +29,3 @@ class LineBasicNodeMaterial extends NodeMaterial {
 }
 
 export default LineBasicNodeMaterial;
-
-LineBasicNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'LineBasic', LineBasicNodeMaterial );

src/materials/nodes/LineDashedNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial 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';
@@ -10,6 +10,12 @@ const _defaultValues = /*@__PURE__*/ new LineDashedMaterial();
 
 class LineDashedNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'LineDashedNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -49,5 +55,3 @@ class LineDashedNodeMaterial extends NodeMaterial {
 }
 
 export default LineDashedNodeMaterial;
-
-LineDashedNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'LineDashed', LineDashedNodeMaterial );

src/materials/nodes/MeshBasicNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { materialLightMap } from '../../nodes/accessors/MaterialNode.js';
 import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
 import BasicLightMapNode from '../../nodes/lighting/BasicLightMapNode.js';
@@ -12,6 +12,12 @@ const _defaultValues = /*@__PURE__*/ new MeshBasicMaterial();
 
 class MeshBasicNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshBasicNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -69,5 +75,3 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 }
 
 export default MeshBasicNodeMaterial;
-
-MeshBasicNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshBasic', MeshBasicNodeMaterial );

src/materials/nodes/MeshLambertNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
 import PhongLightingModel from '../../nodes/functions/PhongLightingModel.js';
 
@@ -8,6 +8,12 @@ const _defaultValues = /*@__PURE__*/ new MeshLambertMaterial();
 
 class MeshLambertNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshLambertNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -39,5 +45,3 @@ class MeshLambertNodeMaterial extends NodeMaterial {
 }
 
 export default MeshLambertNodeMaterial;
-
-MeshLambertNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshLambert', MeshLambertNodeMaterial );

src/materials/nodes/MeshMatcapNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
 import { diffuseColor } from '../../nodes/core/PropertyNode.js';
 import { vec3 } from '../../nodes/tsl/TSLBase.js';
@@ -11,6 +11,12 @@ const _defaultValues = /*@__PURE__*/ new MeshMatcapMaterial();
 
 class MeshMatcapNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshMatcapNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -49,5 +55,3 @@ class MeshMatcapNodeMaterial extends NodeMaterial {
 
 
 export default MeshMatcapNodeMaterial;
-
-MeshMatcapNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshMatcap', MeshMatcapNodeMaterial );

src/materials/nodes/MeshNormalNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { diffuseColor } from '../../nodes/core/PropertyNode.js';
 import { directionToColor } from '../../nodes/utils/Packing.js';
 import { materialOpacity } from '../../nodes/accessors/MaterialNode.js';
@@ -11,6 +11,12 @@ const _defaultValues = /*@__PURE__*/ new MeshNormalMaterial();
 
 class MeshNormalNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshNormalNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -36,5 +42,3 @@ class MeshNormalNodeMaterial extends NodeMaterial {
 }
 
 export default MeshNormalNodeMaterial;
-
-MeshNormalNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshNormal', MeshNormalNodeMaterial );

src/materials/nodes/MeshPhongNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial 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';
@@ -11,6 +11,12 @@ const _defaultValues = /*@__PURE__*/ new MeshPhongMaterial();
 
 class MeshPhongNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshPhongNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -70,5 +76,3 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 }
 
 export default MeshPhongNodeMaterial;
-
-MeshPhongNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshPhong', MeshPhongNodeMaterial );

src/materials/nodes/MeshPhysicalNodeMaterial.js

@@ -8,12 +8,17 @@ 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();
 
 class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
+	static get type() {
+
+		return 'MeshPhysicalNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -241,5 +246,3 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 }
 
 export default MeshPhysicalNodeMaterial;
-
-MeshPhysicalNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshPhysical', MeshPhysicalNodeMaterial );

src/materials/nodes/MeshSSSNodeMaterial.js

@@ -3,7 +3,6 @@ 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 {
 
@@ -39,6 +38,12 @@ class SSSLightingModel extends PhysicalLightingModel {
 
 class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
 
+	static get type() {
+
+		return 'MeshSSSNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super( parameters );
@@ -80,5 +85,3 @@ class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
 }
 
 export default MeshSSSNodeMaterial;
-
-MeshSSSNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshSSS', MeshSSSNodeMaterial );

src/materials/nodes/MeshStandardNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial 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';
@@ -13,6 +13,12 @@ const _defaultValues = /*@__PURE__*/ new MeshStandardMaterial();
 
 class MeshStandardNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshStandardNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -100,5 +106,3 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 }
 
 export default MeshStandardNodeMaterial;
-
-MeshStandardNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshStandard', MeshStandardNodeMaterial );

src/materials/nodes/MeshToonNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import ToonLightingModel from '../../nodes/functions/ToonLightingModel.js';
 
 import { MeshToonMaterial } from '../MeshToonMaterial.js';
@@ -7,6 +7,12 @@ const _defaultValues = /*@__PURE__*/ new MeshToonMaterial();
 
 class MeshToonNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'MeshToonNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -30,5 +36,3 @@ class MeshToonNodeMaterial extends NodeMaterial {
 }
 
 export default MeshToonNodeMaterial;
-
-MeshToonNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'MeshToon', MeshToonNodeMaterial );

src/materials/nodes/NodeMaterial.js

@@ -23,10 +23,14 @@ 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 {
 
+	static get type() {
+
+		return 'NodeMaterial';
+
+	}
+
 	constructor() {
 
 		super();
@@ -623,45 +627,3 @@ 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, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 
 import { PointsMaterial } from '../PointsMaterial.js';
 
@@ -6,6 +6,12 @@ const _defaultValues = /*@__PURE__*/ new PointsMaterial();
 
 class PointsNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'PointsNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -34,5 +40,3 @@ class PointsNodeMaterial extends NodeMaterial {
 }
 
 export default PointsNodeMaterial;
-
-PointsNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Points', PointsNodeMaterial );

src/materials/nodes/ShadowNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import ShadowMaskModel from '../../nodes/functions/ShadowMaskModel.js';
 
 import { ShadowMaterial } from '../ShadowMaterial.js';
@@ -7,6 +7,12 @@ const _defaultValues = /*@__PURE__*/ new ShadowMaterial();
 
 class ShadowNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'ShadowNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -30,5 +36,3 @@ class ShadowNodeMaterial extends NodeMaterial {
 }
 
 export default ShadowNodeMaterial;
-
-ShadowNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Shadow', ShadowNodeMaterial );

src/materials/nodes/SpriteNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { uniform } from '../../nodes/core/UniformNode.js';
 import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
 import { materialRotation } from '../../nodes/accessors/MaterialNode.js';
@@ -13,6 +13,12 @@ const _defaultValues = /*@__PURE__*/ new SpriteMaterial();
 
 class SpriteNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'SpriteNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -86,5 +92,3 @@ class SpriteNodeMaterial extends NodeMaterial {
 }
 
 export default SpriteNodeMaterial;
-
-SpriteNodeMaterial.type = /*@__PURE__*/ registerNodeMaterial( 'Sprite', SpriteNodeMaterial );

src/materials/nodes/VolumeNodeMaterial.js

@@ -1,4 +1,4 @@
-import NodeMaterial, { registerNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 import { property } from '../../nodes/core/PropertyNode.js';
 import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
 import { modelWorldMatrixInverse } from '../../nodes/accessors/ModelNode.js';
@@ -11,6 +11,12 @@ import { texture3D } from '../../nodes/accessors/Texture3DNode.js';
 
 class VolumeNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'VolumeNodeMaterial';
+
+	}
+
 	constructor( params = {} ) {
 
 		super();
@@ -100,5 +106,3 @@ 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, registerNode } from './core/Node.js';
+export { default as Node } 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/BatchNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node 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';
@@ -10,6 +10,12 @@ import { varyingProperty } from '../core/PropertyNode.js';
 
 class BatchNode extends Node {
 
+	static get type() {
+
+		return 'BatchNode';
+
+	}
+
 	constructor( batchMesh ) {
 
 		super( 'void' );
@@ -119,6 +125,4 @@ class BatchNode extends Node {
 
 export default BatchNode;
 
-BatchNode.type = /*@__PURE__*/ registerNode( 'Batch', BatchNode );
-
 export const batch = /*@__PURE__*/ nodeProxy( BatchNode );

src/nodes/accessors/BufferAttributeNode.js

@@ -1,4 +1,3 @@
-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';
@@ -9,6 +8,12 @@ import { StaticDrawUsage, DynamicDrawUsage } from '../../constants.js';
 
 class BufferAttributeNode extends InputNode {
 
+	static get type() {
+
+		return 'BufferAttributeNode';
+
+	}
+
 	constructor( value, bufferType = null, bufferStride = 0, bufferOffset = 0 ) {
 
 		super( value, bufferType );
@@ -151,8 +156,6 @@ class BufferAttributeNode extends InputNode {
 
 export default 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,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
 class BufferNode extends UniformNode {
 
+	static get type() {
+
+		return 'BufferNode';
+
+	}
+
 	constructor( value, bufferType, bufferCount = 0 ) {
 
 		super( value, bufferType );
@@ -31,6 +36,4 @@ class BufferNode extends UniformNode {
 
 export default BufferNode;
 
-BufferNode.type = /*@__PURE__*/ registerNode( 'Buffer', BufferNode );
-
 export const buffer = ( value, type, count ) => nodeObject( new BufferNode( value, type, count ) );

src/nodes/accessors/ClippingNode.js

@@ -1,5 +1,5 @@
 
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { positionView } from './Position.js';
 import { diffuseColor, property } from '../core/PropertyNode.js';
@@ -10,6 +10,12 @@ import { uniformArray } from './UniformArrayNode.js';
 
 class ClippingNode extends Node {
 
+	static get type() {
+
+		return 'ClippingNode';
+
+	}
+
 	constructor( scope = ClippingNode.DEFAULT ) {
 
 		super();
@@ -140,8 +146,6 @@ ClippingNode.DEFAULT = 'default';
 
 export default ClippingNode;
 
-ClippingNode.type = /*@__PURE__*/ registerNode( 'Clipping', ClippingNode );
-
 export const clipping = () => nodeObject( new ClippingNode() );
 
 export const clippingAlpha = () => nodeObject( new ClippingNode( ClippingNode.ALPHA_TO_COVERAGE ) );

src/nodes/accessors/CubeTextureNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { reflectVector, refractVector } from './ReflectVector.js';
 import { nodeProxy, vec3 } from '../tsl/TSLBase.js';
@@ -7,6 +6,12 @@ import { CubeReflectionMapping, CubeRefractionMapping, WebGPUCoordinateSystem }
 
 class CubeTextureNode extends TextureNode {
 
+	static get type() {
+
+		return 'CubeTextureNode';
+
+	}
+
 	constructor( value, uvNode = null, levelNode = null, biasNode = null ) {
 
 		super( value, uvNode, levelNode, biasNode );
@@ -71,6 +76,4 @@ class CubeTextureNode extends TextureNode {
 
 export default CubeTextureNode;
 
-CubeTextureNode.type = /*@__PURE__*/ registerNode( 'CubeTexture', CubeTextureNode );
-
 export const cubeTexture = /*@__PURE__*/ nodeProxy( CubeTextureNode );

src/nodes/accessors/InstanceNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { varyingProperty } from '../core/PropertyNode.js';
 import { instancedBufferAttribute, instancedDynamicBufferAttribute } from './BufferAttributeNode.js';
 import { normalLocal } from './Normal.js';
@@ -14,6 +14,12 @@ import { DynamicDrawUsage } from '../../constants.js';
 
 class InstanceNode extends Node {
 
+	static get type() {
+
+		return 'InstanceNode';
+
+	}
+
 	constructor( instanceMesh ) {
 
 		super( 'void' );
@@ -139,6 +145,4 @@ class InstanceNode extends Node {
 
 export default InstanceNode;
 
-InstanceNode.type = /*@__PURE__*/ registerNode( 'Instance', InstanceNode );
-
 export const instance = /*@__PURE__*/ nodeProxy( InstanceNode );

src/nodes/accessors/InstancedPointsMaterialNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import MaterialNode from './MaterialNode.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
 class InstancedPointsMaterialNode extends MaterialNode {
 
+	static get type() {
+
+		return 'InstancedPointsMaterialNode';
+
+	}
+
 	setup( /*builder*/ ) {
 
 		return this.getFloat( this.scope );
@@ -16,6 +21,4 @@ InstancedPointsMaterialNode.POINT_WIDTH = 'pointWidth';
 
 export default InstancedPointsMaterialNode;
 
-InstancedPointsMaterialNode.type = /*@__PURE__*/ registerNode( 'InstancedPointsMaterial', InstancedPointsMaterialNode );
-
 export const materialPointWidth = /*@__PURE__*/ nodeImmutable( InstancedPointsMaterialNode, InstancedPointsMaterialNode.POINT_WIDTH );

src/nodes/accessors/MaterialNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { reference } from './ReferenceNode.js';
 import { materialReference } from './MaterialReferenceNode.js';
 import { normalView } from './Normal.js';
@@ -13,6 +13,12 @@ const _propertyCache = new Map();
 
 class MaterialNode extends Node {
 
+	static get type() {
+
+		return 'MaterialNode';
+
+	}
+
 	constructor( scope ) {
 
 		super();
@@ -384,8 +390,6 @@ MaterialNode.AO_MAP = 'ao';
 
 export default MaterialNode;
 
-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 );

src/nodes/accessors/MaterialReferenceNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import ReferenceNode from './ReferenceNode.js';
 //import { renderGroup } from '../core/UniformGroupNode.js';
 //import { NodeUpdateType } from '../core/constants.js';
@@ -6,6 +5,12 @@ import { nodeObject } from '../tsl/TSLBase.js';
 
 class MaterialReferenceNode extends ReferenceNode {
 
+	static get type() {
+
+		return 'MaterialReferenceNode';
+
+	}
+
 	constructor( property, inputType, material = null ) {
 
 		super( property, inputType, material );
@@ -38,6 +43,4 @@ class MaterialReferenceNode extends ReferenceNode {
 
 export default 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,3 @@
-import { registerNode } from '../core/Node.js';
 import Object3DNode from './Object3DNode.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -7,6 +6,12 @@ import { Matrix4 } from '../../math/Matrix4.js';
 
 class ModelNode extends Object3DNode {
 
+	static get type() {
+
+		return 'ModelNode';
+
+	}
+
 	constructor( scope = ModelNode.VIEW_MATRIX ) {
 
 		super( scope );
@@ -25,8 +30,6 @@ class ModelNode extends Object3DNode {
 
 export default ModelNode;
 
-ModelNode.type = /*@__PURE__*/ registerNode( 'Model', ModelNode );
-
 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 );

src/nodes/accessors/ModelViewProjectionNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { cameraProjectionMatrix } from './Camera.js';
 import { modelViewMatrix } from './ModelNode.js';
@@ -7,6 +6,12 @@ import { nodeProxy, varying } from '../tsl/TSLBase.js';
 
 class ModelViewProjectionNode extends TempNode {
 
+	static get type() {
+
+		return 'ModelViewProjectionNode';
+
+	}
+
 	constructor( positionNode = null ) {
 
 		super( 'vec4' );
@@ -33,6 +38,4 @@ class ModelViewProjectionNode extends TempNode {
 
 export default ModelViewProjectionNode;
 
-ModelViewProjectionNode.type = /*@__PURE__*/ registerNode( 'ModelViewProjection', ModelViewProjectionNode );
-
 export const modelViewProjection = /*@__PURE__*/ nodeProxy( ModelViewProjectionNode );

src/nodes/accessors/MorphNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { float, nodeProxy, Fn } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -160,6 +160,12 @@ function getEntry( geometry ) {
 
 class MorphNode extends Node {
 
+	static get type() {
+
+		return 'MorphNode';
+
+	}
+
 	constructor( mesh ) {
 
 		super( 'void' );
@@ -254,6 +260,4 @@ class MorphNode extends Node {
 
 export default MorphNode;
 
-MorphNode.type = /*@__PURE__*/ registerNode( 'Morph', MorphNode );
-
 export const morphReference = /*@__PURE__*/ nodeProxy( MorphNode );

src/nodes/accessors/Object3DNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
@@ -7,6 +7,12 @@ import { Vector3 } from '../../math/Vector3.js';
 
 class Object3DNode extends Node {
 
+	static get type() {
+
+		return 'Object3DNode';
+
+	}
+
 	constructor( scope = Object3DNode.VIEW_MATRIX, object3d = null ) {
 
 		super();
@@ -139,8 +145,6 @@ Object3DNode.DIRECTION = 'direction';
 
 export default Object3DNode;
 
-Object3DNode.type = /*@__PURE__*/ registerNode( 'Object3D', Object3DNode );
-
 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 );

src/nodes/accessors/PointUVNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
 class PointUVNode extends Node {
 
+	static get type() {
+
+		return 'PointUVNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec2' );
@@ -21,6 +27,4 @@ class PointUVNode extends Node {
 
 export default PointUVNode;
 
-PointUVNode.type = /*@__PURE__*/ registerNode( 'PointUV', PointUVNode );
-
 export const pointUV = /*@__PURE__*/ nodeImmutable( PointUVNode );

src/nodes/accessors/ReferenceBaseNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { nodeObject } from '../tsl/TSLCore.js';
@@ -6,6 +6,12 @@ import ArrayElementNode from '../utils/ArrayElementNode.js';
 
 class ReferenceElementNode extends ArrayElementNode {
 
+	static get type() {
+
+		return 'ReferenceElementNode';
+
+	}
+
 	constructor( referenceNode, indexNode ) {
 
 		super( referenceNode, indexNode );
@@ -36,6 +42,12 @@ class ReferenceElementNode extends ArrayElementNode {
 
 class ReferenceBaseNode extends Node {
 
+	static get type() {
+
+		return 'ReferenceBaseNode';
+
+	}
+
 	constructor( property, uniformType, object = null, count = null ) {
 
 		super();
@@ -137,7 +149,5 @@ class ReferenceBaseNode extends Node {
 
 export default 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, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
 import { texture } from './TextureNode.js';
@@ -10,6 +10,12 @@ import ArrayElementNode from '../utils/ArrayElementNode.js';
 
 class ReferenceElementNode extends ArrayElementNode {
 
+	static get type() {
+
+		return 'ReferenceElementNode';
+
+	}
+
 	constructor( referenceNode, indexNode ) {
 
 		super( referenceNode, indexNode );
@@ -41,6 +47,12 @@ class ReferenceElementNode extends ArrayElementNode {
 // TODO: Extends this from ReferenceBaseNode
 class ReferenceNode extends Node {
 
+	static get type() {
+
+		return 'ReferenceNode';
+
+	}
+
 	constructor( property, uniformType, object = null, count = null ) {
 
 		super();
@@ -166,7 +178,5 @@ class ReferenceNode extends Node {
 
 export default 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/RendererReferenceNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import ReferenceBaseNode from './ReferenceBaseNode.js';
 import { nodeObject } from '../tsl/TSLCore.js';
 
 class RendererReferenceNode extends ReferenceBaseNode {
 
+	static get type() {
+
+		return 'RendererReferenceNode';
+
+	}
+
 	constructor( property, inputType, renderer = null ) {
 
 		super( property, inputType, renderer );
@@ -24,6 +29,4 @@ class RendererReferenceNode extends ReferenceBaseNode {
 
 export default 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,9 +1,15 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 import { reference } from './ReferenceNode.js';
 
 class SceneNode extends Node {
 
+	static get type() {
+
+		return 'SceneNode';
+
+	}
+
 	constructor( scope = SceneNode.BACKGROUND_BLURRINESS, scene = null ) {
 
 		super();
@@ -45,7 +51,5 @@ SceneNode.BACKGROUND_INTENSITY = 'backgroundIntensity';
 
 export default SceneNode;
 
-SceneNode.type = /*@__PURE__*/ registerNode( 'Scene', SceneNode );
-
 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, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { attribute } from '../core/AttributeNode.js';
@@ -14,6 +14,12 @@ const _frameId = new WeakMap();
 
 class SkinningNode extends Node {
 
+	static get type() {
+
+		return 'SkinningNode';
+
+	}
+
 	constructor( skinnedMesh, useReference = false ) {
 
 		super( 'void' );
@@ -181,7 +187,5 @@ class SkinningNode extends Node {
 
 export default 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,3 @@
-import { registerNode } from '../core/Node.js';
 import BufferNode from './BufferNode.js';
 import { bufferAttribute } from './BufferAttributeNode.js';
 import { nodeObject, varying } from '../tsl/TSLBase.js';
@@ -7,6 +6,12 @@ import { GPUBufferBindingType } from '../../renderers/webgpu/utils/WebGPUConstan
 
 class StorageBufferNode extends BufferNode {
 
+	static get type() {
+
+		return 'StorageBufferNode';
+
+	}
+
 	constructor( value, bufferType, bufferCount = 0 ) {
 
 		super( value, bufferType, bufferCount );
@@ -122,8 +127,6 @@ class StorageBufferNode extends BufferNode {
 
 export default StorageBufferNode;
 
-StorageBufferNode.type = /*@__PURE__*/ registerNode( 'StorageBuffer', StorageBufferNode );
-
 // Read-Write Storage
 export const storage = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ) );
 export const storageObject = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ).setBufferObject( true ) );

src/nodes/accessors/StorageTextureNode.js

@@ -1,10 +1,15 @@
-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';
 
 class StorageTextureNode extends TextureNode {
 
+	static get type() {
+
+		return 'StorageTextureNode';
+
+	}
+
 	constructor( value, uvNode, storeNode = null ) {
 
 		super( value, uvNode );
@@ -89,8 +94,6 @@ class StorageTextureNode extends TextureNode {
 
 export default StorageTextureNode;
 
-StorageTextureNode.type = /*@__PURE__*/ registerNode( 'StorageTexture', StorageTextureNode );
-
 export const storageTexture = /*@__PURE__*/ nodeProxy( StorageTextureNode );
 
 export const textureStore = ( value, uvNode, storeNode ) => {

src/nodes/accessors/Texture3DNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { nodeProxy, vec3, Fn, If } from '../tsl/TSLBase.js';
 
@@ -51,6 +50,12 @@ const normal = Fn( ( { texture, uv } ) => {
 
 class Texture3DNode extends TextureNode {
 
+	static get type() {
+
+		return 'Texture3DNode';
+
+	}
+
 	constructor( value, uvNode = null, levelNode = null ) {
 
 		super( value, uvNode, levelNode );
@@ -95,6 +100,4 @@ class Texture3DNode extends TextureNode {
 
 export default Texture3DNode;
 
-Texture3DNode.type = /*@__PURE__*/ registerNode( 'Texture3D', Texture3DNode );
-
 export const texture3D = /*@__PURE__*/ nodeProxy( Texture3DNode );

src/nodes/accessors/TextureNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import UniformNode, { uniform } from '../core/UniformNode.js';
 import { uv } from './UV.js';
 import { textureSize } from './TextureSizeNode.js';
@@ -12,6 +11,12 @@ import { IntType, UnsignedIntType } from '../../constants.js';
 
 class TextureNode extends UniformNode {
 
+	static get type() {
+
+		return 'TextureNode';
+
+	}
+
 	constructor( value, uvNode = null, levelNode = null, biasNode = null ) {
 
 		super( value );
@@ -430,8 +435,6 @@ class TextureNode extends UniformNode {
 
 export default TextureNode;
 
-TextureNode.type = /*@__PURE__*/ registerNode( 'Texture', TextureNode );
-
 export const texture = /*@__PURE__*/ nodeProxy( TextureNode );
 export const textureLoad = ( ...params ) => texture( ...params ).setSampler( false );
 

src/nodes/accessors/TextureSizeNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class TextureSizeNode extends Node {
 
+	static get type() {
+
+		return 'TextureSizeNode';
+
+	}
+
 	constructor( textureNode, levelNode = null ) {
 
 		super( 'uvec2' );
@@ -28,6 +33,4 @@ class TextureSizeNode extends Node {
 
 export default TextureSizeNode;
 
-TextureSizeNode.type = /*@__PURE__*/ registerNode( 'TextureSize', TextureSizeNode );
-
 export const textureSize = /*@__PURE__*/ nodeProxy( TextureSizeNode );

src/nodes/accessors/UniformArrayNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { getValueType } from '../core/NodeUtils.js';
@@ -7,6 +6,12 @@ import BufferNode from './BufferNode.js';
 
 class UniformArrayElementNode extends ArrayElementNode {
 
+	static get type() {
+
+		return 'UniformArrayElementNode';
+
+	}
+
 	constructor( arrayBuffer, indexNode ) {
 
 		super( arrayBuffer, indexNode );
@@ -34,6 +39,12 @@ class UniformArrayElementNode extends ArrayElementNode {
 
 class UniformArrayNode extends BufferNode {
 
+	static get type() {
+
+		return 'UniformArrayNode';
+
+	}
+
 	constructor( value, elementType = null ) {
 
 		super( null, 'vec4' );
@@ -141,8 +152,6 @@ class UniformArrayNode extends BufferNode {
 
 export default UniformArrayNode;
 
-UniformArrayNode.type = /*@__PURE__*/ registerNode( 'UniformArray', UniformArrayNode );
-
 export const uniformArray = ( values, nodeType ) => nodeObject( new UniformArrayNode( values, nodeType ) );
 
 //

src/nodes/accessors/UserDataNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import ReferenceNode from './ReferenceNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
 class UserDataNode extends ReferenceNode {
 
+	static get type() {
+
+		return 'UserDataNode';
+
+	}
+
 	constructor( property, inputType, userData = null ) {
 
 		super( property, inputType, userData );
@@ -24,6 +29,4 @@ class UserDataNode extends ReferenceNode {
 
 export default 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,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { modelViewMatrix } from './ModelNode.js';
 import { positionLocal, positionPrevious } from './Position.js';
@@ -13,6 +12,12 @@ const _matrixCache = new WeakMap();
 
 class VelocityNode extends TempNode {
 
+	static get type() {
+
+		return 'VelocityNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec2' );
@@ -78,6 +83,4 @@ function getPreviousMatrix( object ) {
 
 export default VelocityNode;
 
-VelocityNode.type = /*@__PURE__*/ registerNode( 'Velocity', VelocityNode );
-
 export const velocity = /*@__PURE__*/ nodeImmutable( VelocityNode );

src/nodes/accessors/VertexColorNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -6,6 +5,12 @@ import { Vector4 } from '../../math/Vector4.js';
 
 class VertexColorNode extends AttributeNode {
 
+	static get type() {
+
+		return 'VertexColorNode';
+
+	}
+
 	constructor( index = 0 ) {
 
 		super( null, 'vec4' );
@@ -66,6 +71,4 @@ class VertexColorNode extends AttributeNode {
 
 export default VertexColorNode;
 
-VertexColorNode.type = /*@__PURE__*/ registerNode( 'VertexColor', VertexColorNode );
-
 export const vertexColor = ( ...params ) => nodeObject( new VertexColorNode( ...params ) );

src/nodes/code/CodeNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class CodeNode extends Node {
 
+	static get type() {
+
+		return 'CodeNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( 'code' );
@@ -75,8 +81,6 @@ class CodeNode extends Node {
 
 export default CodeNode;
 
-CodeNode.type = /*@__PURE__*/ registerNode( 'Code', CodeNode );
-
 export const code = /*@__PURE__*/ nodeProxy( CodeNode );
 
 export const js = ( src, includes ) => code( src, includes, 'js' );

src/nodes/code/ExpressionNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLCore.js';
 
 class ExpressionNode extends Node {
 
+	static get type() {
+
+		return 'ExpressionNode';
+
+	}
+
 	constructor( snippet = '', nodeType = 'void' ) {
 
 		super( nodeType );
@@ -32,6 +38,4 @@ class ExpressionNode extends Node {
 
 export default ExpressionNode;
 
-ExpressionNode.type = /*@__PURE__*/ registerNode( 'Expression', ExpressionNode );
-
 export const expression = /*@__PURE__*/ nodeProxy( ExpressionNode );

src/nodes/code/FunctionCallNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeArray, nodeObject, nodeObjects } from '../tsl/TSLCore.js';
 
 class FunctionCallNode extends TempNode {
 
+	static get type() {
+
+		return 'FunctionCallNode';
+
+	}
+
 	constructor( functionNode = null, parameters = {} ) {
 
 		super();
@@ -83,8 +88,6 @@ class FunctionCallNode extends TempNode {
 
 export default FunctionCallNode;
 
-FunctionCallNode.type = /*@__PURE__*/ registerNode( 'FunctionCall', FunctionCallNode );
-
 export const call = ( func, ...params ) => {
 
 	params = params.length > 1 || ( params[ 0 ] && params[ 0 ].isNode === true ) ? nodeArray( params ) : nodeObjects( params[ 0 ] );

src/nodes/code/FunctionNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import CodeNode from './CodeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
 class FunctionNode extends CodeNode {
 
+	static get type() {
+
+		return 'FunctionNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( code, includes, language );
@@ -81,8 +86,6 @@ class FunctionNode extends CodeNode {
 
 export default FunctionNode;
 
-FunctionNode.type = /*@__PURE__*/ registerNode( 'Function', FunctionNode );
-
 const nativeFn = ( code, includes = [], language = '' ) => {
 
 	for ( let i = 0; i < includes.length; i ++ ) {

src/nodes/code/ScriptableNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { scriptableValue } from './ScriptableValueNode.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
 
@@ -61,6 +61,12 @@ export const global = new Resources();
 
 class ScriptableNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableNode';
+
+	}
+
 	constructor( codeNode = null, parameters = {} ) {
 
 		super();
@@ -495,6 +501,4 @@ class ScriptableNode extends Node {
 
 export default ScriptableNode;
 
-ScriptableNode.type = /*@__PURE__*/ registerNode( 'Scriptable', ScriptableNode );
-
 export const scriptable = /*@__PURE__*/ nodeProxy( ScriptableNode );

src/nodes/code/ScriptableValueNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
 
@@ -6,6 +6,12 @@ import { EventDispatcher } from '../../core/EventDispatcher.js';
 
 class ScriptableValueNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableValueNode';
+
+	}
+
 	constructor( value = null ) {
 
 		super();
@@ -161,6 +167,4 @@ class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-ScriptableValueNode.type = /*@__PURE__*/ registerNode( 'ScriptableValue', ScriptableValueNode );
-
 export const scriptableValue = /*@__PURE__*/ nodeProxy( ScriptableValueNode );

src/nodes/core/AssignNode.js

@@ -1,10 +1,15 @@
-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';
 
 class AssignNode extends TempNode {
 
+	static get type() {
+
+		return 'AssignNode';
+
+	}
+
 	constructor( targetNode, sourceNode ) {
 
 		super();
@@ -121,8 +126,6 @@ class AssignNode extends TempNode {
 
 export default AssignNode;
 
-AssignNode.type = /*@__PURE__*/ registerNode( 'Assign', AssignNode );
-
 export const assign = /*@__PURE__*/ nodeProxy( AssignNode );
 
 addMethodChaining( 'assign', assign );

src/nodes/core/AttributeNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
 
+	static get type() {
+
+		return 'AttributeNode';
+
+	}
+
 	constructor( attributeName, nodeType = null ) {
 
 		super( nodeType );
@@ -116,6 +122,4 @@ class AttributeNode extends Node {
 
 export default AttributeNode;
 
-AttributeNode.type = /*@__PURE__*/ registerNode( 'Attribute', AttributeNode );
-
 export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );

src/nodes/core/BypassNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class BypassNode extends Node {
 
+	static get type() {
+
+		return 'BypassNode';
+
+	}
+
 	constructor( returnNode, callNode ) {
 
 		super();
@@ -38,8 +44,6 @@ class BypassNode extends Node {
 
 export default BypassNode;
 
-BypassNode.type = /*@__PURE__*/ registerNode( 'Bypass', BypassNode );
-
 export const bypass = /*@__PURE__*/ nodeProxy( BypassNode );
 
 addMethodChaining( 'bypass', bypass );

src/nodes/core/CacheNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
 
 class CacheNode extends Node {
 
+	static get type() {
+
+		return 'CacheNode';
+
+	}
+
 	constructor( node, parent = true ) {
 
 		super();
@@ -39,8 +45,6 @@ class CacheNode extends Node {
 
 export default CacheNode;
 
-CacheNode.type = /*@__PURE__*/ registerNode( 'Cache', CacheNode );
-
 export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
 
 addMethodChaining( 'cache', cache );

src/nodes/core/ConstNode.js

@@ -1,8 +1,13 @@
-import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
 
 class ConstNode extends InputNode {
 
+	static get type() {
+
+		return 'ConstNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( value, nodeType );
@@ -28,5 +33,3 @@ class ConstNode extends InputNode {
 }
 
 export default ConstNode;
-
-ConstNode.type = /*@__PURE__*/ registerNode( 'Const', ConstNode );

src/nodes/core/ContextNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
 
+	static get type() {
+
+		return 'ContextNode';
+
+	}
+
 	constructor( node, value = {} ) {
 
 		super();
@@ -64,8 +70,6 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-ContextNode.type = /*@__PURE__*/ registerNode( 'Context', ContextNode );
-
 export const context = /*@__PURE__*/ nodeProxy( ContextNode );
 export const label = ( node, name ) => context( node, { label: name } );
 

src/nodes/core/IndexNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { nodeImmutable, varying } from '../tsl/TSLBase.js';
 
 class IndexNode extends Node {
 
+	static get type() {
+
+		return 'IndexNode';
+
+	}
+
 	constructor( scope ) {
 
 		super( 'uint' );
@@ -69,8 +75,6 @@ IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
-IndexNode.type = /*@__PURE__*/ registerNode( 'Index', IndexNode );
-
 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 );

src/nodes/core/InputNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
 
+	static get type() {
+
+		return 'InputNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( nodeType );
@@ -79,5 +85,3 @@ class InputNode extends Node {
 }
 
 export default InputNode;
-
-InputNode.type = /*@__PURE__*/ registerNode( 'Input', InputNode );

src/nodes/core/MRTNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from './Node.js';
 import OutputStructNode from './OutputStructNode.js';
 import { nodeProxy, vec4 } from '../tsl/TSLBase.js';
 
@@ -20,6 +19,12 @@ export function getTextureIndex( textures, name ) {
 
 class MRTNode extends OutputStructNode {
 
+	static get type() {
+
+		return 'MRTNode';
+
+	}
+
 	constructor( outputNodes ) {
 
 		super();
@@ -77,6 +82,4 @@ class MRTNode extends OutputStructNode {
 
 export default MRTNode;
 
-MRTNode.type = /*@__PURE__*/ registerNode( 'MRT', MRTNode );
-
 export const mrt = /*@__PURE__*/ nodeProxy( MRTNode );

src/nodes/core/Node.js

@@ -4,12 +4,16 @@ import { getNodeChildren, getCacheKey } from './NodeUtils.js';
 import { EventDispatcher } from '../../core/EventDispatcher.js';
 import { MathUtils } from '../../math/MathUtils.js';
 
-const Nodes = new Map();
-
 let _nodeId = 0;
 
 class Node extends EventDispatcher {
 
+	static get type() {
+
+		return 'Node';
+
+	}
+
 	constructor( nodeType = null ) {
 
 		super();
@@ -540,52 +544,3 @@ class Node extends EventDispatcher {
 }
 
 export default Node;
-
-Node.type = /*@__PURE__*/ registerNode( '', Node );
-
-export function registerNode( type, nodeClass ) {
-
-	const suffix = 'Node';
-	const nodeType = type + suffix;
-
-	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( - suffix.length ) === suffix ) {
-
-		console.warn( `TSL.Node: Node class ${ nodeType } should not have '${ suffix }' suffix.` );
-		return;
-
-	}
-
-	Nodes.set( nodeType, nodeClass );
-	nodeClass.type = nodeType;
-
-	return nodeType;
-
-}
-
-export function createNodeFromType( type ) {
-
-	const Class = Nodes.get( type );
-
-	if ( Class !== undefined ) {
-
-		return new Class();
-
-	}
-
-}
-
-export function addNodeClass( type, 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,9 +1,15 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import StructTypeNode from './StructTypeNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class OutputStructNode extends Node {
 
+	static get type() {
+
+		return 'OutputStructNode';
+
+	}
+
 	constructor( ...members ) {
 
 		super();
@@ -54,6 +60,4 @@ class OutputStructNode extends Node {
 
 export default OutputStructNode;
 
-OutputStructNode.type = /*@__PURE__*/ registerNode( 'OutputStruct', OutputStructNode );
-
 export const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );

src/nodes/core/ParameterNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from './Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import PropertyNode from './PropertyNode.js';
 
 class ParameterNode extends PropertyNode {
 
+	static get type() {
+
+		return 'ParameterNode';
+
+	}
+
 	constructor( nodeType, name = null ) {
 
 		super( nodeType, name );
@@ -28,6 +33,4 @@ class ParameterNode extends PropertyNode {
 
 export default ParameterNode;
 
-ParameterNode.type = /*@__PURE__*/ registerNode( 'Parameter', ParameterNode );
-
 export const parameter = ( type, name ) => nodeObject( new ParameterNode( type, name ) );

src/nodes/core/PropertyNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { nodeImmutable, nodeObject } from '../tsl/TSLCore.js';
 
 class PropertyNode extends Node {
 
+	static get type() {
+
+		return 'PropertyNode';
+
+	}
+
 	constructor( nodeType, name = null, varying = false ) {
 
 		super( nodeType );
@@ -49,8 +55,6 @@ class PropertyNode extends Node {
 
 export default 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 ) );
 

src/nodes/core/StackNode.js

@@ -1,9 +1,15 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { select } from '../math/ConditionalNode.js';
 import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../tsl/TSLBase.js';
 
 class StackNode extends Node {
 
+	static get type() {
+
+		return 'StackNode';
+
+	}
+
 	constructor( parent = null ) {
 
 		super();
@@ -100,6 +106,4 @@ class StackNode extends Node {
 
 export default StackNode;
 
-StackNode.type = /*@__PURE__*/ registerNode( 'Stack', StackNode );
-
 export const stack = /*@__PURE__*/ nodeProxy( StackNode );

src/nodes/core/StructTypeNode.js

@@ -1,7 +1,13 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 
 class StructTypeNode extends Node {
 
+	static get type() {
+
+		return 'StructTypeNode';
+
+	}
+
 	constructor( types ) {
 
 		super();
@@ -20,5 +26,3 @@ class StructTypeNode extends Node {
 }
 
 export default StructTypeNode;
-
-StructTypeNode.type = /*@__PURE__*/ registerNode( 'StructType', StructTypeNode );

src/nodes/core/TempNode.js

@@ -1,7 +1,13 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 
 class TempNode extends Node {
 
+	static get type() {
+
+		return 'TempNode';
+
+	}
+
 	constructor( type ) {
 
 		super( type );
@@ -54,5 +60,3 @@ class TempNode extends Node {
 }
 
 export default TempNode;
-
-TempNode.type = /*@__PURE__*/ registerNode( 'Temp', TempNode );

src/nodes/core/UniformGroupNode.js

@@ -1,7 +1,13 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 
 class UniformGroupNode extends Node {
 
+	static get type() {
+
+		return 'UniformGroupNode';
+
+	}
+
 	constructor( name, shared = false ) {
 
 		super( 'string' );
@@ -45,8 +51,6 @@ class UniformGroupNode extends Node {
 
 export default UniformGroupNode;
 
-UniformGroupNode.type = /*@__PURE__*/ registerNode( 'UniformGroup', UniformGroupNode );
-
 export const uniformGroup = ( name ) => new UniformGroupNode( name );
 export const sharedUniformGroup = ( name ) => new UniformGroupNode( name, true );
 

src/nodes/core/UniformNode.js

@@ -1,10 +1,15 @@
-import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
 import { objectGroup } from './UniformGroupNode.js';
 import { nodeObject, getConstNodeType } from '../tsl/TSLCore.js';
 
 class UniformNode extends InputNode {
 
+	static get type() {
+
+		return 'UniformNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( value, nodeType );
@@ -95,8 +100,6 @@ class UniformNode extends InputNode {
 
 export default UniformNode;
 
-UniformNode.type = /*@__PURE__*/ registerNode( 'Uniform', UniformNode );
-
 export const uniform = ( arg1, arg2 ) => {
 
 	const nodeType = getConstNodeType( arg2 || arg1 );

src/nodes/core/VarNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class VarNode extends Node {
 
+	static get type() {
+
+		return 'VarNode';
+
+	}
+
 	constructor( node, name = null ) {
 
 		super();
@@ -48,8 +54,6 @@ class VarNode extends Node {
 
 export default VarNode;
 
-VarNode.type = /*@__PURE__*/ registerNode( 'Var', VarNode );
-
 export const temp = /*@__PURE__*/ nodeProxy( VarNode );
 
 addMethodChaining( 'temp', temp ); // @TODO: Will be removed in the future

src/nodes/core/VaryingNode.js

@@ -1,9 +1,15 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { NodeShaderStage } from './constants.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class VaryingNode extends Node {
 
+	static get type() {
+
+		return 'VaryingNode';
+
+	}
+
 	constructor( node, name = null ) {
 
 		super();
@@ -97,8 +103,6 @@ class VaryingNode extends Node {
 
 export default VaryingNode;
 
-VaryingNode.type = /*@__PURE__*/ registerNode( 'Varying', VaryingNode );
-
 export const varying = /*@__PURE__*/ nodeProxy( VaryingNode );
 
 addMethodChaining( 'varying', varying );

src/nodes/display/AfterImageNode.js

@@ -19,6 +19,12 @@ const _quadMeshComp = /*@__PURE__*/ new QuadMesh();
 
 class AfterImageNode extends TempNode {
 
+	static get type() {
+
+		return 'AfterImageNode';
+
+	}
+
 	constructor( textureNode, damp = 0.96 ) {
 
 		super( textureNode );

src/nodes/display/AnaglyphPassNode.js

@@ -8,6 +8,12 @@ import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
 class AnaglyphPassNode extends StereoCompositePassNode {
 
+	static get type() {
+
+		return 'AnaglyphPassNode';
+
+	}
+
 	constructor( scene, camera ) {
 
 		super( scene, camera );

src/nodes/display/AnamorphicNode.js

@@ -17,6 +17,12 @@ const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
 class AnamorphicNode extends TempNode {
 
+	static get type() {
+
+		return 'AnamorphicNode';
+
+	}
+
 	constructor( textureNode, tresholdNode, scaleNode, samples ) {
 
 		super( 'vec4' );

src/nodes/display/BloomNode.js

@@ -29,6 +29,12 @@ const _BlurDirectionY = /*@__PURE__*/ new Vector2( 0.0, 1.0 );
 
 class BloomNode extends TempNode {
 
+	static get type() {
+
+		return 'BloomNode';
+
+	}
+
 	constructor( inputNode, strength = 1, radius = 0, threshold = 0 ) {
 
 		super();

src/nodes/display/BumpMapNode.js

@@ -46,6 +46,12 @@ const perturbNormalArb = Fn( ( inputs ) => {
 
 class BumpMapNode extends TempNode {
 
+	static get type() {
+
+		return 'BumpMapNode';
+
+	}
+
 	constructor( textureNode, scaleNode = null ) {
 
 		super( 'vec3' );

src/nodes/display/ColorSpaceNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeObject, vec4 } from '../tsl/TSLCore.js';
 
@@ -30,6 +29,12 @@ export const getColorSpaceMethod = ( source, target ) => {
 
 class ColorSpaceNode extends TempNode {
 
+	static get type() {
+
+		return 'ColorSpaceNode';
+
+	}
+
 	constructor( colorNode, target = null, source = null ) {
 
 		super( 'vec4' );
@@ -76,8 +81,6 @@ class ColorSpaceNode extends TempNode {
 
 export default ColorSpaceNode;
 
-ColorSpaceNode.type = /*@__PURE__*/ registerNode( 'ColorSpace', ColorSpaceNode );
-
 export const toOutputColorSpace = ( node, colorSpace = null ) => nodeObject( new ColorSpaceNode( nodeObject( node ), colorSpace, LinearSRGBColorSpace ) );
 export const toWorkingColorSpace = ( node, colorSpace = null ) => nodeObject( new ColorSpaceNode( nodeObject( node ), LinearSRGBColorSpace, colorSpace ) );
 

src/nodes/display/DenoiseNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, float, int, vec2, vec3, vec4, mat2, If } from '../tsl/TSLBase.js';
@@ -16,6 +15,12 @@ import { Vector3 } from '../../math/Vector3.js';
 
 class DenoiseNode extends TempNode {
 
+	static get type() {
+
+		return 'DenoiseNode';
+
+	}
+
 	constructor( textureNode, depthNode, normalNode, noiseNode, camera ) {
 
 		super();
@@ -163,8 +168,6 @@ class DenoiseNode extends TempNode {
 
 export default DenoiseNode;
 
-DenoiseNode.type = /*@__PURE__*/ registerNode( 'Denoise', DenoiseNode );
-
 function generatePdSamplePointInitializer( samples, rings, radiusExponent ) {
 
 	const poissonDisk = generateDenoiseSamples( samples, rings, radiusExponent );

src/nodes/display/DepthOfFieldNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, vec2, vec4 } from '../tsl/TSLBase.js';
@@ -9,6 +8,12 @@ import { convertToTexture } from '../utils/RTTNode.js';
 
 class DepthOfFieldNode extends TempNode {
 
+	static get type() {
+
+		return 'DepthOfFieldNode';
+
+	}
+
 	constructor( textureNode, viewZNode, focusNode, apertureNode, maxblurNode ) {
 
 		super();
@@ -116,6 +121,4 @@ class DepthOfFieldNode extends TempNode {
 
 export default 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,3 @@
-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';
@@ -11,6 +10,12 @@ import { Vector2 } from '../../math/Vector2.js';
 
 class DotScreenNode extends TempNode {
 
+	static get type() {
+
+		return 'DotScreenNode';
+
+	}
+
 	constructor( inputNode, center = new Vector2( 0.5, 0.5 ), angle = 1.57, scale = 1 ) {
 
 		super( 'vec4' );
@@ -58,6 +63,4 @@ class DotScreenNode extends TempNode {
 
 export default 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,3 @@
-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';
@@ -13,6 +12,12 @@ import { Vector2 } from '../../math/Vector2.js';
 
 class FXAANode extends TempNode {
 
+	static get type() {
+
+		return 'FXAANode';
+
+	}
+
 	constructor( textureNode ) {
 
 		super();
@@ -324,6 +329,4 @@ class FXAANode extends TempNode {
 
 export default FXAANode;
 
-FXAANode.type = /*@__PURE__*/ registerNode( 'FXAA', FXAANode );
-
 export const fxaa = ( node ) => nodeObject( new FXAANode( convertToTexture( node ) ) );

src/nodes/display/FilmNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeProxy, vec4 } from '../tsl/TSLBase.js';
@@ -7,6 +6,12 @@ import { timerLocal } from '../utils/TimerNode.js';
 
 class FilmNode extends TempNode {
 
+	static get type() {
+
+		return 'FilmNode';
+
+	}
+
 	constructor( inputNode, intensityNode = null, uvNode = null ) {
 
 		super();
@@ -48,6 +53,4 @@ class FilmNode extends TempNode {
 
 export default FilmNode;
 
-FilmNode.type = /*@__PURE__*/ registerNode( 'Film', FilmNode );
-
 export const film = /*@__PURE__*/ nodeProxy( FilmNode );

src/nodes/display/FrontFacingNode.js

@@ -1,10 +1,16 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeImmutable, float } from '../tsl/TSLBase.js';
 
 import { BackSide, WebGLCoordinateSystem } from '../../constants.js';
 
 class FrontFacingNode extends Node {
 
+	static get type() {
+
+		return 'FrontFacingNode';
+
+	}
+
 	constructor() {
 
 		super( 'bool' );
@@ -35,7 +41,5 @@ class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-FrontFacingNode.type = /*@__PURE__*/ registerNode( 'FrontFacing', FrontFacingNode );
-
 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,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { textureSize } from '../accessors/TextureSizeNode.js';
@@ -26,6 +25,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class GTAONode extends TempNode {
 
+	static get type() {
+
+		return 'GTAONode';
+
+	}
+
 	constructor( depthNode, normalNode, camera ) {
 
 		super();
@@ -239,8 +244,6 @@ class GTAONode extends TempNode {
 
 export default GTAONode;
 
-GTAONode.type = /*@__PURE__*/ registerNode( 'GTAO', GTAONode );
-
 function generateMagicSquareNoise( size = 5 ) {
 
 	const noiseSize = Math.floor( size ) % 2 === 0 ? Math.floor( size ) + 1 : Math.floor( size );

src/nodes/display/GaussianBlurNode.js

@@ -1,4 +1,3 @@
-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';
@@ -21,6 +20,12 @@ const _quadMesh2 = /*@__PURE__*/ new QuadMesh();
 
 class GaussianBlurNode extends TempNode {
 
+	static get type() {
+
+		return 'GaussianBlurNode';
+
+	}
+
 	constructor( textureNode, directionNode = null, sigma = 2 ) {
 
 		super( 'vec4' );
@@ -205,6 +210,4 @@ class GaussianBlurNode extends TempNode {
 
 export default 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,3 @@
-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';
@@ -6,6 +5,12 @@ import { mix } from '../math/MathNode.js';
 
 class Lut3DNode extends TempNode {
 
+	static get type() {
+
+		return 'Lut3DNode';
+
+	}
+
 	constructor( inputNode, lutNode, size, intensityNode ) {
 
 		super();
@@ -49,6 +54,4 @@ class Lut3DNode extends TempNode {
 
 export default 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/NormalMapNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { add } from '../math/OperatorNode.js';
 
@@ -41,6 +40,12 @@ const perturbNormal2Arb = /*@__PURE__*/ Fn( ( inputs ) => {
 
 class NormalMapNode extends TempNode {
 
+	static get type() {
+
+		return 'NormalMapNode';
+
+	}
+
 	constructor( node, scaleNode = null ) {
 
 		super( 'vec3' );
@@ -99,6 +104,4 @@ class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-NormalMapNode.type = /*@__PURE__*/ registerNode( 'NormalMap', NormalMapNode );
-
 export const normalMap = /*@__PURE__*/ nodeProxy( NormalMapNode );

src/nodes/display/ParallaxBarrierPassNode.js

@@ -1,4 +1,3 @@
-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';
@@ -8,6 +7,12 @@ import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
 class ParallaxBarrierPassNode extends StereoCompositePassNode {
 
+	static get type() {
+
+		return 'ParallaxBarrierPassNode';
+
+	}
+
 	constructor( scene, camera ) {
 
 		super( scene, camera );
@@ -50,6 +55,4 @@ class ParallaxBarrierPassNode extends StereoCompositePassNode {
 
 export default 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,3 @@
-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';
@@ -15,6 +14,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class PassTextureNode extends TextureNode {
 
+	static get type() {
+
+		return 'PassTextureNode';
+
+	}
+
 	constructor( passNode, texture ) {
 
 		super( texture );
@@ -41,10 +46,14 @@ class PassTextureNode extends TextureNode {
 
 }
 
-PassTextureNode.type = /*@__PURE__*/ registerNode( 'PassTexture', PassTextureNode );
-
 class PassMultipleTextureNode extends PassTextureNode {
 
+	static get type() {
+
+		return 'PassMultipleTextureNode';
+
+	}
+
 	constructor( passNode, textureName, previousTexture = false ) {
 
 		super( passNode, null );
@@ -76,10 +85,14 @@ class PassMultipleTextureNode extends PassTextureNode {
 
 }
 
-PassMultipleTextureNode.type = /*@__PURE__*/ registerNode( 'PassMultipleTexture', PassMultipleTextureNode );
-
 class PassNode extends TempNode {
 
+	static get type() {
+
+		return 'PassNode';
+
+	}
+
 	constructor( scope, scene, camera, options = {} ) {
 
 		super( 'vec4' );
@@ -360,8 +373,6 @@ PassNode.DEPTH = 'depth';
 
 export default 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 ) );
 export const depthPass = ( scene, camera ) => nodeObject( new PassNode( PassNode.DEPTH, scene, camera ) );

src/nodes/display/PixelationPassNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { uv } from '../accessors/UV.js';
 import { Fn, nodeObject, vec2, vec3, float, If } from '../tsl/TSLBase.js';
@@ -16,6 +15,12 @@ import { NearestFilter } from '../../constants.js';
 
 class PixelationNode extends TempNode {
 
+	static get type() {
+
+		return 'PixelationNode';
+
+	}
+
 	constructor( textureNode, depthNode, normalNode, pixelSize, normalEdgeStrength, depthEdgeStrength ) {
 
 		super();
@@ -153,12 +158,16 @@ class PixelationNode extends TempNode {
 
 }
 
-PixelationNode.type = /*@__PURE__*/ registerNode( 'Pixelation', PixelationNode );
-
 const pixelation = ( node, depthNode, normalNode, pixelSize = 6, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) => nodeObject( new PixelationNode( convertToTexture( node ), convertToTexture( depthNode ), convertToTexture( normalNode ), nodeObject( pixelSize ), nodeObject( normalEdgeStrength ), nodeObject( depthEdgeStrength ) ) );
 
 class PixelationPassNode extends PassNode {
 
+	static get type() {
+
+		return 'PixelationPassNode';
+
+	}
+
 	constructor( scene, camera, pixelSize = 6, normalEdgeStrength = 0.3, depthEdgeStrength = 0.4 ) {
 
 		super( 'color', scene, camera, { minFilter: NearestFilter, magFilter: NearestFilter } );
@@ -202,5 +211,3 @@ class PixelationPassNode extends PassNode {
 export const pixelationPass = ( scene, camera, pixelSize, normalEdgeStrength, depthEdgeStrength ) => nodeObject( new PixelationPassNode( scene, camera, pixelSize, normalEdgeStrength, depthEdgeStrength ) );
 
 export default PixelationPassNode;
-
-PixelationPassNode.type = /*@__PURE__*/ registerNode( 'PixelationPass', PixelationPassNode );

src/nodes/display/PosterizeNode.js

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

src/nodes/display/RGBShiftNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { nodeObject, Fn, vec2, vec4 } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -8,6 +7,12 @@ import { convertToTexture } from '../utils/RTTNode.js';
 
 class RGBShiftNode extends TempNode {
 
+	static get type() {
+
+		return 'RGBShiftNode';
+
+	}
+
 	constructor( textureNode, amount = 0.005, angle = 0 ) {
 
 		super( 'vec4' );
@@ -45,6 +50,4 @@ class RGBShiftNode extends TempNode {
 
 export default RGBShiftNode;
 
-RGBShiftNode.type = /*@__PURE__*/ registerNode( 'RGBShift', RGBShiftNode );
-
 export const rgbShift = ( node, amount, angle ) => nodeObject( new RGBShiftNode( convertToTexture( node ), amount, angle ) );

src/nodes/display/RenderOutputNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
 
@@ -6,6 +5,12 @@ import { LinearSRGBColorSpace, SRGBColorSpace, NoToneMapping } from '../../const
 
 class RenderOutputNode extends TempNode {
 
+	static get type() {
+
+		return 'RenderOutputNode';
+
+	}
+
 	constructor( colorNode, toneMapping, outputColorSpace ) {
 
 		super( 'vec4' );
@@ -49,8 +54,6 @@ class RenderOutputNode extends TempNode {
 
 export default RenderOutputNode;
 
-RenderOutputNode.type = /*@__PURE__*/ registerNode( 'RenderOutput', RenderOutputNode );
-
 export const renderOutput = ( color, toneMapping = null, outputColorSpace = null ) => nodeObject( new RenderOutputNode( nodeObject( color ), toneMapping, outputColorSpace ) );
 
 addMethodChaining( 'renderOutput', renderOutput );