super-three 0.167.0 → 0.168.0

package/src/nodes/core/AttributeNode.js

@@ -1,15 +1,12 @@
-import Node, { addNodeClass } from './Node.js';
-import { varying } from './VaryingNode.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
 
-	constructor( attributeName, nodeType = null, defaultNode = null ) {
+	constructor( attributeName, nodeType = null ) {
 
 		super( nodeType );
 
-		this.defaultNode = defaultNode;
-
 		this.global = true;
 
 		this._attributeName = attributeName;
@@ -24,7 +21,7 @@ class AttributeNode extends Node {
 
 	getNodeType( builder ) {
 
-		let nodeType = super.getNodeType( builder );
+		let nodeType = this.nodeType;
 
 		if ( nodeType === null ) {
 
@@ -91,17 +88,7 @@ class AttributeNode extends Node {
 
 			console.warn( `AttributeNode: Vertex attribute "${ attributeName }" not found on geometry.` );
 
-			const { defaultNode } = this;
-
-			if ( defaultNode !== null ) {
-
-				return defaultNode.build( builder, nodeType );
-
-			} else {
-
-				return builder.generateConst( nodeType );
-
-			}
+			return builder.generateConst( nodeType );
 
 		}
 
@@ -129,6 +116,6 @@ class AttributeNode extends Node {
 
 export default AttributeNode;
 
-export const attribute = ( name, nodeType, defaultNode ) => nodeObject( new AttributeNode( name, nodeType, nodeObject( defaultNode ) ) );
+AttributeNode.type = /*@__PURE__*/ registerNode( 'Attribute', AttributeNode );
 
-addNodeClass( 'AttributeNode', AttributeNode );
+export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );

package/src/nodes/core/BypassNode.js

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

package/src/nodes/core/CacheNode.js

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

package/src/nodes/core/ConstNode.js

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

package/src/nodes/core/ContextNode.js

@@ -1,16 +1,22 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
 
-	constructor( node, context = {} ) {
+	constructor( node, value = {} ) {
 
 		super();
 
 		this.isContextNode = true;
 
 		this.node = node;
-		this.context = context;
+		this.value = value;
+
+	}
+
+	getScope() {
+
+		return this.node.getScope();
 
 	}
 
@@ -30,7 +36,7 @@ class ContextNode extends Node {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( { ...builder.context, ...this.context } );
+		builder.setContext( { ...builder.context, ...this.value } );
 
 		const node = this.node.build( builder );
 
@@ -44,7 +50,7 @@ class ContextNode extends Node {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( { ...builder.context, ...this.context } );
+		builder.setContext( { ...builder.context, ...this.value } );
 
 		const snippet = this.node.build( builder, output );
 
@@ -58,10 +64,10 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context = nodeProxy( ContextNode );
-export const label = ( node, name ) => context( node, { label: name } );
+ContextNode.type = /*@__PURE__*/ registerNode( 'Context', ContextNode );
 
-addNodeElement( 'context', context );
-addNodeElement( 'label', label );
+export const context = /*@__PURE__*/ nodeProxy( ContextNode );
+export const label = ( node, name ) => context( node, { label: name } );
 
-addNodeClass( 'ContextNode', ContextNode );
+addMethodChaining( 'context', context );
+addMethodChaining( 'label', label );

package/src/nodes/core/IndexNode.js

@@ -1,6 +1,5 @@
-import Node, { addNodeClass } from './Node.js';
-import { varying } from './VaryingNode.js';
-import { nodeImmutable } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { nodeImmutable, varying } from '../tsl/TSLBase.js';
 
 class IndexNode extends Node {
 
@@ -33,6 +32,10 @@ class IndexNode extends Node {
 
 			propertyName = builder.getDrawIndex();
 
+		} else if ( scope === IndexNode.INVOCATION_LOCAL ) {
+
+			propertyName = builder.getInvocationLocalIndex();
+
 		} else {
 
 			throw new Error( 'THREE.IndexNode: Unknown scope: ' + scope );
@@ -61,12 +64,14 @@ class IndexNode extends Node {
 
 IndexNode.VERTEX = 'vertex';
 IndexNode.INSTANCE = 'instance';
+IndexNode.INVOCATION_LOCAL = 'invocationLocal';
 IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
-export const vertexIndex = nodeImmutable( IndexNode, IndexNode.VERTEX );
-export const instanceIndex = nodeImmutable( IndexNode, IndexNode.INSTANCE );
-export const drawIndex = nodeImmutable( IndexNode, IndexNode.DRAW );
+IndexNode.type = /*@__PURE__*/ registerNode( 'Index', IndexNode );
 
-addNodeClass( 'IndexNode', 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 );
+export const drawIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.DRAW );

package/src/nodes/core/InputNode.js

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

package/src/nodes/core/MRTNode.js

@@ -1,8 +1,8 @@
-import { addNodeClass } from './Node.js';
+import { registerNode } from './Node.js';
 import OutputStructNode from './OutputStructNode.js';
-import { nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
+import { nodeProxy, vec4 } from '../tsl/TSLBase.js';
 
-function getTextureIndex( textures, name ) {
+export function getTextureIndex( textures, name ) {
 
 	for ( let i = 0; i < textures.length; i ++ ) {
 
@@ -30,7 +30,13 @@ class MRTNode extends OutputStructNode {
 
 	}
 
-	getNode( name ) {
+	has( name ) {
+
+		return this.outputNodes[ name ] !== undefined;
+
+	}
+
+	get( name ) {
 
 		return this.outputNodes[ name ];
 
@@ -71,6 +77,6 @@ class MRTNode extends OutputStructNode {
 
 export default MRTNode;
 
-export const mrt = nodeProxy( MRTNode );
+MRTNode.type = /*@__PURE__*/ registerNode( 'MRT', MRTNode );
 
-addNodeClass( 'MRTNode', MRTNode );
+export const mrt = /*@__PURE__*/ nodeProxy( MRTNode );

package/src/nodes/core/Node.js

@@ -4,7 +4,7 @@ import { getNodeChildren, getCacheKey } from './NodeUtils.js';
 import { EventDispatcher } from '../../core/EventDispatcher.js';
 import { MathUtils } from '../../math/MathUtils.js';
 
-const NodeClasses = new Map();
+const Nodes = new Map();
 
 let _nodeId = 0;
 
@@ -149,6 +149,12 @@ class Node extends EventDispatcher {
 
 	}
 
+	getScope() {
+
+		return this;
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return this.uuid;
@@ -222,18 +228,9 @@ class Node extends EventDispatcher {
 
 	}
 
-	increaseUsage( builder ) {
-
-		const nodeData = builder.getDataFromNode( this );
-		nodeData.usageCount = nodeData.usageCount === undefined ? 1 : nodeData.usageCount + 1;
-
-		return nodeData.usageCount;
-
-	}
-
 	analyze( builder ) {
 
-		const usageCount = this.increaseUsage( builder );
+		const usageCount = builder.increaseUsage( this );
 
 		if ( usageCount === 1 ) {
 
@@ -322,7 +319,8 @@ class Node extends EventDispatcher {
 
 				if ( properties.outputNode !== null && builder.stack.nodes.length !== stackNodesBeforeSetup ) {
 
-					properties.outputNode = builder.stack;
+					// !! no outputNode !!
+					//properties.outputNode = builder.stack;
 
 				}
 
@@ -543,24 +541,39 @@ class Node extends EventDispatcher {
 
 export default Node;
 
-export function addNodeClass( type, nodeClass ) {
+Node.type = /*@__PURE__*/ registerNode( '', Node );
+
+export function registerNode( type, nodeClass ) {
+
+	const suffix = 'Node';
+	const nodeType = type + suffix;
 
-	if ( typeof nodeClass !== 'function' || ! type ) throw new Error( `Node class ${ type } is not a class` );
-	if ( NodeClasses.has( type ) ) {
+	if ( typeof nodeClass !== 'function' ) throw new Error( `TSL.Node: Node class ${ type } is not a class` );
 
-		console.warn( `Redefinition of node class ${ type }` );
+	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;
 
 	}
 
-	NodeClasses.set( type, nodeClass );
-	nodeClass.type = type;
+	Nodes.set( nodeType, nodeClass );
+	nodeClass.type = nodeType;
+
+	return nodeType;
 
 }
 
 export function createNodeFromType( type ) {
 
-	const Class = NodeClasses.get( type );
+	const Class = Nodes.get( type );
 
 	if ( Class !== undefined ) {
 
@@ -569,3 +582,10 @@ export function createNodeFromType( type ) {
 	}
 
 }
+
+export function addNodeClass( type, nodeClass ) {
+
+	console.warn( 'TSL.Node: Function addNodeClass() is deprecated. Use /*@__PURE__*/ registerNode() instead.' );
+	/*@__PURE__*/ registerNode( type.slice( 0, - 4 ), nodeClass );
+
+}

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';
@@ -113,7 +112,6 @@ class NodeBuilder {
 		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 );
 
 		}
 
@@ -399,7 +400,6 @@ class NodeBuilder {
 
 		const context = { ...this.context };
 
-		delete context.keywords;
 		delete context.material;
 
 		return this.context;
@@ -469,6 +469,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 +605,7 @@ class NodeBuilder {
 
 	}
 
-	needsColorSpaceToLinear( /*texture*/ ) {
+	needsToWorkingColorSpace( /*texture*/ ) {
 
 		return false;
 
@@ -995,27 +1004,24 @@ class NodeBuilder {
 
 		const layout = shaderNode.layout;
 
-		let inputs;
-
-		if ( shaderNode.isArrayInput ) {
-
-			inputs = [];
+		const inputs = {
+			[ Symbol.iterator ]() {
 
-			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 +1230,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 +1316,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

@@ -12,6 +12,7 @@ export function getCacheKey( object, force = false ) {
 	if ( object.isNode === true ) {
 
 		cacheKey += object.id;
+		object = object.getSelf();
 
 	}
 

package/src/nodes/core/OutputStructNode.js

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

package/src/nodes/core/ParameterNode.js

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

package/src/nodes/core/PropertyNode.js

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