super-three 0.167.0 → 0.169.0

package/src/nodes/core/NodeBuilder.js

@@ -3,11 +3,10 @@ import NodeAttribute from './NodeAttribute.js';
 import NodeVarying from './NodeVarying.js';
 import NodeVar from './NodeVar.js';
 import NodeCode from './NodeCode.js';
-import NodeKeywords from './NodeKeywords.js';
 import NodeCache from './NodeCache.js';
 import ParameterNode from './ParameterNode.js';
 import FunctionNode from '../code/FunctionNode.js';
-import { createNodeMaterialFromType, default as NodeMaterial } from '../materials/NodeMaterial.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 import { NodeUpdateType, defaultBuildStages, shaderStages } from './constants.js';
 
 import {
@@ -16,7 +15,7 @@ import {
 } from '../../renderers/common/nodes/NodeUniform.js';
 
 import { stack } from './StackNode.js';
-import { getCurrentStack, setCurrentStack } from '../shadernode/ShaderNode.js';
+import { getCurrentStack, setCurrentStack } from '../tsl/TSLBase.js';
 
 import CubeRenderTarget from '../../renderers/common/CubeRenderTarget.js';
 import ChainMap from '../../renderers/common/ChainMap.js';
@@ -80,6 +79,8 @@ class NodeBuilder {
 		this.updateAfterNodes = [];
 		this.hashNodes = {};
 
+		this.monitor = null;
+
 		this.lightsNode = null;
 		this.environmentNode = null;
 		this.fogNode = null;
@@ -108,12 +109,9 @@ class NodeBuilder {
 		this.stacks = [];
 		this.tab = '\t';
 
-		this.instanceBindGroups = true;
-
 		this.currentFunctionNode = null;
 
 		this.context = {
-			keywords: new NodeKeywords(),
 			material: this.material
 		};
 
@@ -125,9 +123,11 @@ class NodeBuilder {
 		this.shaderStage = null;
 		this.buildStage = null;
 
+		this.useComparisonMethod = false;
+
 	}
 
-	getBingGroupsCache() {
+	getBindGroupsCache() {
 
 		let bindGroupsCache = rendererCache.get( this.renderer );
 
@@ -171,7 +171,7 @@ class NodeBuilder {
 
 	_getBindGroup( groupName, bindings ) {
 
-		const bindGroupsCache = this.getBingGroupsCache();
+		const bindGroupsCache = this.getBindGroupsCache();
 
 		//
 
@@ -197,14 +197,15 @@ class NodeBuilder {
 
 			if ( bindGroup === undefined ) {
 
-				bindGroup = new BindGroup( groupName, bindingsArray );
+				bindGroup = new BindGroup( groupName, bindingsArray, this.bindingsIndexes[ groupName ].group, bindingsArray );
+
 				bindGroupsCache.set( bindingsArray, bindGroup );
 
 			}
 
 		} else {
 
-			bindGroup = new BindGroup( groupName, bindingsArray );
+			bindGroup = new BindGroup( groupName, bindingsArray, this.bindingsIndexes[ groupName ].group, bindingsArray );
 
 		}
 
@@ -276,6 +277,23 @@ class NodeBuilder {
 
 	}
 
+	sortBindingGroups() {
+
+		const bindingsGroups = this.getBindings();
+
+		bindingsGroups.sort( ( a, b ) => ( a.bindings[ 0 ].groupNode.order - b.bindings[ 0 ].groupNode.order ) );
+
+		for ( let i = 0; i < bindingsGroups.length; i ++ ) {
+
+			const bindingGroup = bindingsGroups[ i ];
+			this.bindingsIndexes[ bindingGroup.name ].group = i;
+
+			bindingGroup.index = i;
+
+		}
+
+	}
+
 	setHashNode( node, hash ) {
 
 		this.hashNodes[ hash ] = node;
@@ -310,13 +328,13 @@ class NodeBuilder {
 
 			if ( updateBeforeType !== NodeUpdateType.NONE ) {
 
-				this.updateBeforeNodes.push( node );
+				this.updateBeforeNodes.push( node.getSelf() );
 
 			}
 
 			if ( updateAfterType !== NodeUpdateType.NONE ) {
 
-				this.updateAfterNodes.push( node );
+				this.updateAfterNodes.push( node.getSelf() );
 
 			}
 
@@ -399,7 +417,6 @@ class NodeBuilder {
 
 		const context = { ...this.context };
 
-		delete context.keywords;
 		delete context.material;
 
 		return this.context;
@@ -469,6 +486,15 @@ class NodeBuilder {
 
 	}
 
+	increaseUsage( node ) {
+
+		const nodeData = this.getDataFromNode( node );
+		nodeData.usageCount = nodeData.usageCount === undefined ? 1 : nodeData.usageCount + 1;
+
+		return nodeData.usageCount;
+
+	}
+
 	generateTexture( /* texture, textureProperty, uvSnippet */ ) {
 
 		console.warn( 'Abstract function.' );
@@ -596,7 +622,7 @@ class NodeBuilder {
 
 	}
 
-	needsColorSpaceToLinear( /*texture*/ ) {
+	needsToWorkingColorSpace( /*texture*/ ) {
 
 		return false;
 
@@ -915,10 +941,59 @@ class NodeBuilder {
 
 	}
 
-	addLineFlowCode( code ) {
+	addFlowCodeHierarchy( node, nodeBlock ) {
+
+		const { flowCodes, flowCodeBlock } = this.getDataFromNode( node );
+
+		let needsFlowCode = true;
+		let nodeBlockHierarchy = nodeBlock;
+
+		while ( nodeBlockHierarchy ) {
+
+			if ( flowCodeBlock.get( nodeBlockHierarchy ) === true ) {
+
+				needsFlowCode = false;
+				break;
+
+			}
+
+			nodeBlockHierarchy = this.getDataFromNode( nodeBlockHierarchy ).parentNodeBlock;
+
+		}
+
+		if ( needsFlowCode ) {
+
+			for ( const flowCode of flowCodes ) {
+
+				this.addLineFlowCode( flowCode );
+
+			}
+
+		}
+
+	}
+
+	addLineFlowCodeBlock( node, code, nodeBlock ) {
+
+		const nodeData = this.getDataFromNode( node );
+		const flowCodes = nodeData.flowCodes || ( nodeData.flowCodes = [] );
+		const codeBlock = nodeData.flowCodeBlock || ( nodeData.flowCodeBlock = new WeakMap() );
+
+		flowCodes.push( code );
+		codeBlock.set( nodeBlock, true );
+
+	}
+
+	addLineFlowCode( code, node = null ) {
 
 		if ( code === '' ) return this;
 
+		if ( node !== null && this.context.nodeBlock ) {
+
+			this.addLineFlowCodeBlock( node, code, this.context.nodeBlock );
+
+		}
+
 		code = this.tab + code;
 
 		if ( ! /;\s*$/.test( code ) ) {
@@ -995,27 +1070,24 @@ class NodeBuilder {
 
 		const layout = shaderNode.layout;
 
-		let inputs;
-
-		if ( shaderNode.isArrayInput ) {
+		const inputs = {
+			[ Symbol.iterator ]() {
 
-			inputs = [];
-
-			for ( const input of layout.inputs ) {
-
-				inputs.push( new ParameterNode( input.type, input.name ) );
+				let index = 0;
+				const values = Object.values( this );
+				return {
+					next: () => ( {
+						value: values[ index ],
+						done: index ++ >= values.length
+					} )
+				};
 
 			}
+		};
 
-		} else {
-
-			inputs = {};
-
-			for ( const input of layout.inputs ) {
-
-				inputs[ input.name ] = new ParameterNode( input.type, input.name );
+		for ( const input of layout.inputs ) {
 
-			}
+			inputs[ input.name ] = new ParameterNode( input.type, input.name );
 
 		}
 
@@ -1224,12 +1296,21 @@ class NodeBuilder {
 
 	build() {
 
-		const { object, material } = this;
-
+		const { object, material, renderer } = this;
 
 		if ( material !== null ) {
 
-			NodeMaterial.fromMaterial( material ).build( this );
+			let nodeMaterial = renderer.nodes.library.fromMaterial( material );
+
+			if ( nodeMaterial === null ) {
+
+				console.error( `NodeMaterial: Material "${ material.type }" is not compatible.` );
+
+				nodeMaterial = new NodeMaterial();
+
+			}
+
+			nodeMaterial.build( this );
 
 		} else {
 
@@ -1301,11 +1382,9 @@ class NodeBuilder {
 
 	}
 
-	createNodeMaterial( type = 'NodeMaterial' ) {
-
-		// TODO: Move Materials.js to outside of the Nodes.js in order to remove this function and improve tree-shaking support
+	createNodeMaterial( type = 'NodeMaterial' ) { // @deprecated, r168
 
-		return createNodeMaterialFromType( type );
+		throw new Error( `THREE.NodeBuilder: createNodeMaterial() was deprecated. Use new ${ type }() instead.` );
 
 	}
 

package/src/nodes/core/NodeUtils.js

@@ -5,25 +5,68 @@ import { Vector2 } from '../../math/Vector2.js';
 import { Vector3 } from '../../math/Vector3.js';
 import { Vector4 } from '../../math/Vector4.js';
 
+// cyrb53 (c) 2018 bryc (github.com/bryc). License: Public domain. Attribution appreciated.
+// A fast and simple 64-bit (or 53-bit) string hash function with decent collision resistance.
+// Largely inspired by MurmurHash2/3, but with a focus on speed/simplicity.
+// See https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript/52171480#52171480
+// https://github.com/bryc/code/blob/master/jshash/experimental/cyrb53.js
+function cyrb53( value, seed = 0 ) {
+
+	let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+
+	if ( value instanceof Array ) {
+
+		for ( let i = 0, val; i < value.length; i ++ ) {
+
+			val = value[ i ];
+			h1 = Math.imul( h1 ^ val, 2654435761 );
+			h2 = Math.imul( h2 ^ val, 1597334677 );
+
+		}
+
+	} else {
+
+		for ( let i = 0, ch; i < value.length; i ++ ) {
+
+			ch = value.charCodeAt( i );
+			h1 = Math.imul( h1 ^ ch, 2654435761 );
+			h2 = Math.imul( h2 ^ ch, 1597334677 );
+
+		}
+
+	}
+
+	h1 = Math.imul( h1 ^ ( h1 >>> 16 ), 2246822507 );
+	h1 ^= Math.imul( h2 ^ ( h2 >>> 13 ), 3266489909 );
+	h2 = Math.imul( h2 ^ ( h2 >>> 16 ), 2246822507 );
+	h2 ^= Math.imul( h1 ^ ( h1 >>> 13 ), 3266489909 );
+
+	return 4294967296 * ( 2097151 & h2 ) + ( h1 >>> 0 );
+
+}
+
+export const hashString = ( str ) => cyrb53( str );
+export const hashArray = ( array ) => cyrb53( array );
+export const hash = ( ...params ) => cyrb53( params );
+
 export function getCacheKey( object, force = false ) {
 
-	let cacheKey = '{';
+	const values = [];
 
 	if ( object.isNode === true ) {
 
-		cacheKey += object.id;
+		values.push( object.id );
+		object = object.getSelf();
 
 	}
 
 	for ( const { property, childNode } of getNodeChildren( object ) ) {
 
-		cacheKey += ',' + property.slice( 0, - 4 ) + ':' + childNode.getCacheKey( force );
+		values.push( values, cyrb53( property.slice( 0, - 4 ) ), childNode.getCacheKey( force ) );
 
 	}
 
-	cacheKey += '}';
-
-	return cacheKey;
+	return cyrb53( values );
 
 }
 

package/src/nodes/core/OutputStructNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 import StructTypeNode from './StructTypeNode.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class OutputStructNode extends Node {
 
+	static get type() {
+
+		return 'OutputStructNode';
+
+	}
+
 	constructor( ...members ) {
 
 		super();
@@ -42,7 +48,7 @@ class OutputStructNode extends Node {
 
 			const snippet = members[ i ].build( builder, output );
 
-			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }` );
+			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }`, this );
 
 		}
 
@@ -54,6 +60,4 @@ class OutputStructNode extends Node {
 
 export default OutputStructNode;
 
-export const outputStruct = nodeProxy( OutputStructNode );
-
-addNodeClass( 'OutputStructNode', OutputStructNode );
+export const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );

package/src/nodes/core/ParameterNode.js

@@ -1,9 +1,14 @@
-import { addNodeClass } from './Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.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 );
@@ -29,5 +34,3 @@ class ParameterNode extends PropertyNode {
 export default ParameterNode;
 
 export const parameter = ( type, name ) => nodeObject( new ParameterNode( type, name ) );
-
-addNodeClass( 'ParameterNode', ParameterNode );

package/src/nodes/core/PropertyNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from './Node.js';
-import { nodeImmutable, nodeObject } from '../shadernode/ShaderNode.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 );
@@ -52,33 +58,31 @@ export default 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' );
-
-addNodeClass( 'PropertyNode', PropertyNode );
+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' );

package/src/nodes/core/StackNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from './Node.js';
-import { cond } from '../math/CondNode.js';
-import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../shadernode/ShaderNode.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();
@@ -33,19 +39,19 @@ class StackNode extends Node {
 
 	}
 
-	if( boolNode, method ) {
+	If( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		this._currentCond = cond( boolNode, methodNode );
+		this._currentCond = select( boolNode, methodNode );
 
 		return this.add( this._currentCond );
 
 	}
 
-	elseif( boolNode, method ) {
+	ElseIf( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		const ifNode = cond( boolNode, methodNode );
+		const ifNode = select( boolNode, methodNode );
 
 		this._currentCond.elseNode = ifNode;
 		this._currentCond = ifNode;
@@ -54,7 +60,7 @@ class StackNode extends Node {
 
 	}
 
-	else( method ) {
+	Else( method ) {
 
 		this._currentCond.elseNode = new ShaderNode( method );
 
@@ -80,10 +86,24 @@ class StackNode extends Node {
 
 	}
 
+	//
+
+	else( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .else() has been renamed to .Else().' );
+		return this.Else( ...params );
+
+	}
+
+	elseif( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .elseif() has been renamed to .ElseIf().' );
+		return this.ElseIf( ...params );
+
+	}
+
 }
 
 export default StackNode;
 
-export const stack = nodeProxy( StackNode );
-
-addNodeClass( 'StackNode', StackNode );
+export const stack = /*@__PURE__*/ nodeProxy( StackNode );

package/src/nodes/core/StructTypeNode.js

@@ -1,7 +1,13 @@
-import Node, { addNodeClass } 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;
-
-addNodeClass( 'StructTypeNode', StructTypeNode );

package/src/nodes/core/TempNode.js

@@ -1,7 +1,13 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 
 class TempNode extends Node {
 
+	static get type() {
+
+		return 'TempNode';
+
+	}
+
 	constructor( type ) {
 
 		super( type );
@@ -36,7 +42,7 @@ class TempNode extends Node {
 				const nodeVar = builder.getVarFromNode( this, null, type );
 				const propertyName = builder.getPropertyName( nodeVar );
 
-				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+				builder.addLineFlowCode( `${propertyName} = ${snippet}`, this );
 
 				nodeData.snippet = snippet;
 				nodeData.propertyName = propertyName;
@@ -54,5 +60,3 @@ class TempNode extends Node {
 }
 
 export default TempNode;
-
-addNodeClass( 'TempNode', TempNode );

package/src/nodes/core/UniformGroupNode.js

@@ -1,9 +1,14 @@
 import Node from './Node.js';
-import { addNodeClass } from './Node.js';
 
 class UniformGroupNode extends Node {
 
-	constructor( name, shared = false ) {
+	static get type() {
+
+		return 'UniformGroupNode';
+
+	}
+
+	constructor( name, shared = false, order = 1 ) {
 
 		super( 'string' );
 
@@ -11,7 +16,7 @@ class UniformGroupNode extends Node {
 		this.version = 0;
 
 		this.shared = shared;
-
+		this.order = order;
 		this.isUniformGroup = true;
 
 	}
@@ -44,13 +49,11 @@ class UniformGroupNode extends Node {
 
 }
 
-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 default UniformGroupNode;
 
-addNodeClass( 'UniformGroupNode', UniformGroupNode );
+export const uniformGroup = ( name ) => new UniformGroupNode( name );
+export const sharedUniformGroup = ( name, order = 0 ) => new UniformGroupNode( name, true, order );
+
+export const frameGroup = /*@__PURE__*/ sharedUniformGroup( 'frame' );
+export const renderGroup = /*@__PURE__*/ sharedUniformGroup( 'render' );
+export const objectGroup = /*@__PURE__*/ uniformGroup( 'object' );