super-three 0.152.0 → 0.154.1

package/examples/jsm/nodes/geometry/RangeNode.js

@@ -1,9 +1,14 @@
 import Node, { addNodeClass } from '../core/Node.js';
 import { getValueType } from '../core/NodeUtils.js';
-import { attribute } from '../core/AttributeNode.js';
+import { buffer } from '../accessors/BufferNode.js';
+//import { bufferAttribute } from '../accessors/BufferAttributeNode.js';
+import { instanceIndex } from '../core/IndexNode.js';
 import { nodeProxy, float } from '../shadernode/ShaderNode.js';
 
-import { MathUtils, InstancedBufferAttribute } from 'three';
+import { Vector4, MathUtils } from 'three';
+
+let min = null;
+let max = null;
 
 class RangeNode extends Node {
 
@@ -39,69 +44,46 @@ class RangeNode extends Node {
 
 		if ( object.isInstancedMesh === true ) {
 
-			const geometry = builder.geometry;
-
-			let min = this.minNode.value;
-			let max = this.maxNode.value;
-
-			const minLength = builder.getTypeLength( getValueType( min ) );
-			const maxLength = builder.getTypeLength( getValueType( max ) );
-
-				 if ( minLength > maxLength && maxLength > 1 ) max = new min.constructor().fromArray( min.toArray() );
-			else if ( minLength > maxLength && maxLength === 1 ) max = new min.constructor().setScalar( max );
-			else if ( maxLength > minLength && minLength > 1 ) min = new max.constructor().fromArray( min.toArray() );
-			else if ( maxLength > minLength && minLength === 1 ) min = new max.constructor().setScalar( min );
-
-			const vectorLength = this.getVectorLength( builder );
-			const attributeName = 'node' + this.id;
-
-			const length = vectorLength * object.count;
-			const array = new Float32Array( length );
-
-			const attributeGeometry = geometry.getAttribute( attributeName );
-
-			if ( attributeGeometry === undefined || attributeGeometry.array.length < length ) {
+			let minValue = this.minNode.value;
+			let maxValue = this.maxNode.value;
 
-				if ( vectorLength === 1 ) {
+			const minLength = builder.getTypeLength( getValueType( minValue ) );
+			const maxLength = builder.getTypeLength( getValueType( maxValue ) );
 
-					for ( let i = 0; i < length; i ++ ) {
+			min = min || new Vector4();
+			max = max || new Vector4();
 
-						array[ i ] = MathUtils.lerp( min, max, Math.random() );
+			min.setScalar( 0 );
+			max.setScalar( 0 );
 
-					}
+			if ( minLength === 1 ) min.setScalar( minValue );
+			else if ( minValue.isColor ) min.set( minValue.r, minValue.g, minValue.b );
+			else min.set( minValue.x, minValue.y, minValue.z || 0, minValue.w || 0 );
 
-				} else if ( min.isColor ) {
+			if ( maxLength === 1 ) max.setScalar( maxValue );
+			else if ( maxValue.isColor ) max.set( maxValue.r, maxValue.g, maxValue.b );
+			else max.set( maxValue.x, maxValue.y, maxValue.z || 0, maxValue.w || 0 );
 
-					for ( let i = 0; i < length; i += 3 ) {
+			const stride = 4;
 
-						array[ i ] = MathUtils.lerp( min.r, max.r, Math.random() );
-						array[ i + 1 ] = MathUtils.lerp( min.g, max.g, Math.random() );
-						array[ i + 2 ] = MathUtils.lerp( min.b, max.b, Math.random() );
-
-					}
-
-				} else {
-
-					for ( let i = 0; i < length; i ++ ) {
-
-						const index = i % vectorLength;
-
-						const minValue = min.getComponent( index );
-						const maxValue = max.getComponent( index );
-
-						array[ i ] = MathUtils.lerp( minValue, maxValue, Math.random() );
+			const length = stride * object.count;
+			const array = new Float32Array( length );
 
-					}
+			for ( let i = 0; i < length; i ++ ) {
 
-				}
+				const index = i % stride;
 
-				geometry.setAttribute( attributeName, new InstancedBufferAttribute( array, vectorLength ) );
+				const minElementValue = min.getComponent( index );
+				const maxElementValue = max.getComponent( index );
 
-				geometry.dispose();
+				array[ i ] = MathUtils.lerp( minElementValue, maxElementValue, Math.random() );
 
 			}
 
-			output = attribute( attributeName, builder.getTypeFromLength( vectorLength ) );
+			const nodeType = this.getNodeType( builder );
+
+			output = buffer( array, 'vec4', object.count ).element( instanceIndex ).convert( nodeType );
+			//output = bufferAttribute( array, 'vec4', 4, 0 ).convert( nodeType );
 
 		} else {
 

package/examples/jsm/nodes/lighting/AnalyticLightNode.js

@@ -6,8 +6,8 @@ import { vec3 } from '../shadernode/ShaderNode.js';
 import { reference } from '../accessors/ReferenceNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { positionWorld } from '../accessors/PositionNode.js';
+//import { step } from '../math/MathNode.js';
 import { cond } from '../math/CondNode.js';
-import MeshBasicNodeMaterial from '../materials/MeshBasicNodeMaterial.js';
 
 import { Color, DepthTexture, NearestFilter } from 'three';
 
@@ -43,7 +43,7 @@ class AnalyticLightNode extends LightingNode {
 
 		if ( shadowNode === null ) {
 
-			if ( depthMaterial === null ) depthMaterial = new MeshBasicNodeMaterial();
+			if ( depthMaterial === null ) depthMaterial = builder.createNodeMaterial( 'MeshBasicNodeMaterial' );
 
 			const shadow = this.light.shadow;
 			const rtt = builder.getRenderTarget( shadow.mapSize.width, shadow.mapSize.height );
@@ -51,6 +51,9 @@ class AnalyticLightNode extends LightingNode {
 			const depthTexture = new DepthTexture();
 			depthTexture.minFilter = NearestFilter;
 			depthTexture.magFilter = NearestFilter;
+			depthTexture.image.width = shadow.mapSize.width;
+			depthTexture.image.height = shadow.mapSize.height;
+			//depthTexture.compareFunction = THREE.LessCompare;
 
 			rtt.depthTexture = depthTexture;
 
@@ -128,7 +131,7 @@ class AnalyticLightNode extends LightingNode {
 
 	}
 
-	update( frame ) {
+	update( /*frame*/ ) {
 
 		const { light } = this;
 

package/examples/jsm/nodes/lighting/DirectionalLightNode.js

@@ -24,11 +24,11 @@ class DirectionalLightNode extends AnalyticLightNode {
 
 		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
 
-			lightingModelFunctionNode.direct.call( {
+			lightingModelFunctionNode.direct( {
 				lightDirection,
 				lightColor,
 				reflectedLight
-			}, builder );
+			} );
 
 		}
 

package/examples/jsm/nodes/lighting/EnvironmentNode.js

@@ -1,14 +1,16 @@
 import LightingNode from './LightingNode.js';
 import { cache } from '../core/CacheNode.js';
 import { context } from '../core/ContextNode.js';
-import { roughness } from '../core/PropertyNode.js';
+import { roughness, clearcoatRoughness } from '../core/PropertyNode.js';
 import { equirectUV } from '../utils/EquirectUVNode.js';
 import { specularMIPLevel } from '../utils/SpecularMIPLevelNode.js';
 import { cameraViewMatrix } from '../accessors/CameraNode.js';
-import { transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
+import { transformedClearcoatNormalView, transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
 import { positionViewDirection } from '../accessors/PositionNode.js';
 import { addNodeClass } from '../core/Node.js';
 import { float, vec2 } from '../shadernode/ShaderNode.js';
+import { cubeTexture } from '../accessors/CubeTextureNode.js';
+import { reference } from '../accessors/ReferenceNode.js';
 
 class EnvironmentNode extends LightingNode {
 
@@ -22,114 +24,157 @@ class EnvironmentNode extends LightingNode {
 
 	construct( builder ) {
 
-		const envNode = this.envNode;
+		let envNode = this.envNode;
 		const properties = builder.getNodeProperties( this );
 
-		let reflectVec;
-		let radianceTextureUVNode;
-		let irradianceTextureUVNode;
+		if ( envNode.isTextureNode && envNode.value.isCubeTexture !== true ) {
 
-		const radianceContext = context( envNode, {
-			getUVNode: ( textureNode ) => {
+			const texture = envNode.value;
+			const renderer = builder.renderer;
 
-				let node = null;
+			// @TODO: Add dispose logic here
+			const cubeRTT = builder.getCubeRenderTarget( 512 ).fromEquirectangularTexture( renderer, texture );
 
-				if ( reflectVec === undefined ) {
+			envNode = cubeTexture( cubeRTT.texture );
 
-					reflectVec = positionViewDirection.negate().reflect( transformedNormalView );
-					reflectVec = roughness.mul( roughness ).mix( reflectVec, transformedNormalView ).normalize();
-					reflectVec = reflectVec.transformDirection( cameraViewMatrix );
+		}
 
-				}
+		//
 
-				if ( textureNode.isCubeTextureNode ) {
+		const intensity = reference( 'envMapIntensity', 'float', builder.material ); // @TODO: Add materialEnvIntensity in MaterialNode
 
-					node = reflectVec;
+		const radiance = context( envNode, createRadianceContext( roughness, transformedNormalView ) ).mul( intensity );
+		const irradiance = context( envNode, createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
 
-				} else if ( textureNode.isTextureNode ) {
+		const isolateRadiance = cache( radiance );
 
-					if ( radianceTextureUVNode === undefined ) {
+		//
 
-						// @TODO: Needed PMREM
+		builder.context.radiance.addAssign( isolateRadiance );
 
-						radianceTextureUVNode = equirectUV( reflectVec );
+		builder.context.iblIrradiance.addAssign( irradiance );
 
-					}
+		//
 
-					node = radianceTextureUVNode;
+		let isolateClearcoatRadiance = null;
 
-				}
+		if ( builder.context.clearcoatRadiance  ) {
 
-				return node;
+			const clearcoatRadiance = context( envNode, createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( intensity );
 
-			},
-			getSamplerLevelNode: () => {
+			isolateClearcoatRadiance = cache( clearcoatRadiance );
 
-				return roughness;
+			builder.context.clearcoatRadiance.addAssign( isolateClearcoatRadiance );
 
-			},
-			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+		}
 
-				return specularMIPLevel( textureNode, levelNode );
+		//
 
-			}
-		} );
+		properties.radiance = isolateRadiance;
+		properties.clearcoatRadiance = isolateClearcoatRadiance;
+		properties.irradiance = irradiance;
 
-		const irradianceContext = context( envNode, {
-			getUVNode: ( textureNode ) => {
+	}
 
-				let node = null;
+}
 
-				if ( textureNode.isCubeTextureNode ) {
+const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
-					node = transformedNormalWorld;
+	let reflectVec = null;
+	let textureUVNode = null;
 
-				} else if ( textureNode.isTextureNode ) {
+	return {
+		getUVNode: ( textureNode ) => {
 
-					if ( irradianceTextureUVNode === undefined ) {
+			let node = null;
 
-						// @TODO: Needed PMREM
+			if ( reflectVec === null ) {
 
-						irradianceTextureUVNode = equirectUV( transformedNormalWorld );
-						irradianceTextureUVNode = vec2( irradianceTextureUVNode.x, irradianceTextureUVNode.y.oneMinus() );
+				reflectVec = positionViewDirection.negate().reflect( normalViewNode );
+				reflectVec = roughnessNode.mul( roughnessNode ).mix( reflectVec, normalViewNode ).normalize();
+				reflectVec = reflectVec.transformDirection( cameraViewMatrix );
 
-					}
+			}
 
-					node = irradianceTextureUVNode;
+			if ( textureNode.isCubeTextureNode ) {
 
-				}
+				node = reflectVec;
+
+			} else if ( textureNode.isTextureNode ) {
 
-				return node;
+				if ( textureUVNode === null ) {
 
-			},
-			getSamplerLevelNode: () => {
+					// @TODO: Needed PMREM
 
-				return float( 1 );
+					textureUVNode = equirectUV( reflectVec );
 
-			},
-			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+				}
 
-				return specularMIPLevel( textureNode, levelNode );
+				node = textureUVNode;
 
 			}
-		} );
 
-		//
+			return node;
 
-		const isolateRadianceFlowContext = cache( radianceContext );
+		},
+		getSamplerLevelNode: () => {
 
-		//
+			return roughnessNode;
 
-		builder.context.radiance.addAssign( isolateRadianceFlowContext );
+		},
+		getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
 
-		builder.context.iblIrradiance.addAssign( irradianceContext.mul( Math.PI ) );
+			return specularMIPLevel( textureNode, levelNode );
 
-		properties.radianceContext = isolateRadianceFlowContext;
-		properties.irradianceContext = irradianceContext;
+		}
+	};
 
-	}
+};
 
-}
+const createIrradianceContext = ( normalWorldNode ) => {
+
+	let textureUVNode = null;
+
+	return {
+		getUVNode: ( textureNode ) => {
+
+			let node = null;
+
+			if ( textureNode.isCubeTextureNode ) {
+
+				node = normalWorldNode;
+
+			} else if ( textureNode.isTextureNode ) {
+
+				if ( textureUVNode === null ) {
+
+					// @TODO: Needed PMREM
+
+					textureUVNode = equirectUV( normalWorldNode );
+					textureUVNode = vec2( textureUVNode.x, textureUVNode.y.oneMinus() );
+
+				}
+
+				node = textureUVNode;
+
+			}
+
+			return node;
+
+		},
+		getSamplerLevelNode: () => {
+
+			return float( 1 );
+
+		},
+		getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+			return specularMIPLevel( textureNode, levelNode );
+
+		}
+	};
+
+};
 
 export default EnvironmentNode;
 

package/examples/jsm/nodes/lighting/HemisphereLightNode.js

@@ -14,8 +14,8 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 		super( light );
 
-		this.lightPositionNode = objectPosition;
-		this.lightDirectionNode = objectPosition.normalize();
+		this.lightPositionNode = objectPosition( light );
+		this.lightDirectionNode = this.lightPositionNode.normalize();
 
 		this.groundColorNode = uniform( new Color() );
 

package/examples/jsm/nodes/lighting/LightUtils.js

@@ -1,6 +1,6 @@
-import { ShaderNode } from '../shadernode/ShaderNode.js';
+import { tslFn } from '../shadernode/ShaderNode.js';
 
-export const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
+export const getDistanceAttenuation = tslFn( ( inputs ) => {
 
 	const { lightDistance, cutoffDistance, decayExponent } = inputs;
 

package/examples/jsm/nodes/lighting/LightingContextNode.js

@@ -1,5 +1,4 @@
 import ContextNode from '../core/ContextNode.js';
-import { temp } from '../core/VarNode.js';
 import { add } from '../math/OperatorNode.js';
 import { mix } from '../math/MathNode.js';
 import { addNodeClass } from '../core/Node.js';
@@ -30,10 +29,10 @@ class LightingContextNode extends ContextNode {
 		const context = this.context = {}; // reset context
 		const properties = builder.getNodeProperties( this );
 
-		const directDiffuse = temp( vec3() ),
-			directSpecular = temp( vec3() ),
-			indirectDiffuse = temp( vec3() ),
-			indirectSpecular = temp( vec3() );
+		const directDiffuse = vec3().temp(),
+			directSpecular = vec3().temp(),
+			indirectDiffuse = vec3().temp(),
+			indirectSpecular = vec3().temp();
 
 		let totalDiffuse = add( directDiffuse, indirectDiffuse );
 
@@ -44,7 +43,7 @@ class LightingContextNode extends ContextNode {
 		}
 
 		const totalSpecular = add( directSpecular, indirectSpecular );
-		const total = add( totalDiffuse, totalSpecular );
+		const total = add( totalDiffuse, totalSpecular ).temp();
 
 		const reflectedLight = {
 			directDiffuse,
@@ -55,21 +54,24 @@ class LightingContextNode extends ContextNode {
 		};
 
 		const lighting = {
-			radiance: temp( vec3() ),
-			irradiance: temp( vec3() ),
-			iblIrradiance: temp( vec3() ),
-			ambientOcclusion: temp( float( 1 ) )
+			radiance: vec3().temp(),
+			irradiance: vec3().temp(),
+			iblIrradiance: vec3().temp(),
+			ambientOcclusion: float( 1 ).temp()
 		};
 
+		context.reflectedLight = reflectedLight;
+		context.lightingModelNode = lightingModelNode || context.lightingModelNode;
+
 		Object.assign( properties, reflectedLight, lighting );
 		Object.assign( context, lighting );
 
-		context.reflectedLight = reflectedLight;
-		context.lightingModelNode = lightingModelNode || context.lightingModelNode;
+		// @TODO: Call needed return a new node ( or rename the ShaderNodeInternal.call() function ), it's not moment to run
+		if ( lightingModelNode && lightingModelNode.init ) lightingModelNode.init( context, builder.stack, builder );
 
-		if ( lightingModelNode && lightingModelNode.indirectDiffuse ) lightingModelNode.indirectDiffuse.call( context );
-		if ( lightingModelNode && lightingModelNode.indirectSpecular ) lightingModelNode.indirectSpecular.call( context );
-		if ( lightingModelNode && lightingModelNode.ambientOcclusion ) lightingModelNode.ambientOcclusion.call( context );
+		if ( lightingModelNode && lightingModelNode.indirectDiffuse ) lightingModelNode.indirectDiffuse( context, builder.stack, builder );
+		if ( lightingModelNode && lightingModelNode.indirectSpecular ) lightingModelNode.indirectSpecular( context, builder.stack, builder );
+		if ( lightingModelNode && lightingModelNode.ambientOcclusion ) lightingModelNode.ambientOcclusion( context, builder.stack, builder );
 
 		return super.construct( builder );
 

package/examples/jsm/nodes/lighting/PointLightNode.js

@@ -39,7 +39,7 @@ class PointLightNode extends AnalyticLightNode {
 		const lightDirection = lVector.normalize();
 		const lightDistance = lVector.length();
 
-		const lightAttenuation = getDistanceAttenuation.call( {
+		const lightAttenuation = getDistanceAttenuation( {
 			lightDistance,
 			cutoffDistance: cutoffDistanceNode,
 			decayExponent: decayExponentNode
@@ -52,11 +52,11 @@ class PointLightNode extends AnalyticLightNode {
 
 		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
 
-			lightingModelFunctionNode.direct.call( {
+			lightingModelFunctionNode.direct( {
 				lightDirection,
 				lightColor,
 				reflectedLight
-			}, builder );
+			} );
 
 		}
 

package/examples/jsm/nodes/lighting/SpotLightNode.js

@@ -60,7 +60,7 @@ class SpotLightNode extends AnalyticLightNode {
 
 		const lightDistance = lVector.length();
 
-		const lightAttenuation = getDistanceAttenuation.call( {
+		const lightAttenuation = getDistanceAttenuation( {
 			lightDistance,
 			cutoffDistance: cutoffDistanceNode,
 			decayExponent: decayExponentNode
@@ -73,11 +73,11 @@ class SpotLightNode extends AnalyticLightNode {
 
 		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
 
-			lightingModelFunctionNode.direct.call( {
+			lightingModelFunctionNode.direct( {
 				lightDirection,
 				lightColor,
 				reflectedLight
-			}, builder );
+			} );
 
 		}
 

package/examples/jsm/nodes/materials/LineBasicNodeMaterial.js

@@ -21,21 +21,6 @@ class LineBasicNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default LineBasicNodeMaterial;

package/examples/jsm/nodes/materials/MeshBasicNodeMaterial.js

@@ -20,21 +20,6 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default MeshBasicNodeMaterial;

package/examples/jsm/nodes/materials/MeshNormalNodeMaterial.js

@@ -31,16 +31,6 @@ class MeshNormalNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.opacityNode = source.opacityNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default MeshNormalNodeMaterial;

package/examples/jsm/nodes/materials/MeshPhongNodeMaterial.js

@@ -51,18 +51,9 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 
 	copy( source ) {
 
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
 		this.shininessNode = source.shininessNode;
 		this.specularNode = source.specularNode;
 
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
 		return super.copy( source );
 
 	}

package/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.js

@@ -1,4 +1,9 @@
 import { addNodeMaterial } from './NodeMaterial.js';
+import { transformedClearcoatNormalView } from '../accessors/NormalNode.js';
+import { clearcoat, clearcoatRoughness, sheen, sheenRoughness } from '../core/PropertyNode.js';
+import { materialClearcoatNormal } from '../accessors/ExtendedMaterialNode.js';
+import { materialClearcoat, materialClearcoatRoughness, materialSheen, materialSheenRoughness } from '../accessors/MaterialNode.js';
+import { float, vec3 } from '../shadernode/ShaderNode.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 
 import { MeshPhysicalMaterial } from 'three';
@@ -38,6 +43,42 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 	}
 
+	constructVariants( builder ) {
+
+		super.constructVariants( builder );
+
+		const { stack } = builder;
+
+		// CLEARCOAT
+
+		const clearcoatNode = this.clearcoatNode ? float( this.clearcoatNode ) : materialClearcoat;
+		const clearcoatRoughnessNode = this.clearcoatRoughnessNode ? float( this.clearcoatRoughnessNode ) : materialClearcoatRoughness;
+
+		stack.assign( clearcoat, clearcoatNode );
+		stack.assign( clearcoatRoughness, clearcoatRoughnessNode );
+
+		// SHEEN
+
+		const sheenNode = this.sheenNode ? vec3( this.sheenNode ) : materialSheen;
+		const sheenRoughnessNode = this.sheenRoughnessNode ? float( this.sheenRoughnessNode ) : materialSheenRoughness;
+
+		stack.assign( sheen, sheenNode );
+		stack.assign( sheenRoughness, sheenRoughnessNode );
+
+	}
+
+	constructNormal( builder ) {
+
+		super.constructNormal( builder );
+
+		// CLEARCOAT NORMAL
+
+		const clearcoatNormalNode = this.clearcoatNormalNode ? vec3( this.clearcoatNormalNode ) : materialClearcoatNormal;
+
+		builder.stack.assign( transformedClearcoatNormalView, clearcoatNormalNode );
+
+	}
+
 	copy( source ) {
 
 		this.clearcoatNode = source.clearcoatNode;