super-three 0.144.0 → 0.147.0

package/examples/jsm/nodes/display/ViewportNode.js

@@ -0,0 +1,106 @@
+import Node from '../core/Node.js';
+import { uniform, div, vec2, invert } from '../shadernode/ShaderNodeBaseElements.js';
+import { Vector2 } from 'three';
+import { NodeUpdateType } from '../core/constants.js';
+
+let resolution;
+
+class ViewportNode extends Node {
+
+	static COORDINATE = 'coordinate';
+	static RESOLUTION = 'resolution';
+	static TOP_LEFT = 'topLeft';
+	static BOTTOM_LEFT = 'bottomLeft';
+	static TOP_RIGHT = 'topRight';
+	static BOTTOM_RIGHT = 'bottomRight';
+
+	constructor( scope ) {
+
+		super();
+
+		this.scope = scope;
+
+		this.isViewportNode = true;
+
+	}
+
+	getNodeType() {
+
+		return this.scope === ViewportNode.COORDINATE ? 'vec4' : 'vec2';
+
+	}
+
+	getUpdateType() {
+
+		let updateType = NodeUpdateType.NONE;
+
+		if ( this.scope === ViewportNode.RESOLUTION ) {
+
+			updateType = NodeUpdateType.FRAME;
+
+		}
+
+		this.updateType = updateType;
+
+		return updateType;
+
+	}
+
+	update( { renderer } ) {
+
+		renderer.getSize( resolution );
+
+	}
+
+	construct( builder ) {
+
+		const scope = this.scope;
+
+		if ( scope === ViewportNode.COORDINATE ) return;
+
+		let output = null;
+
+		if ( scope === ViewportNode.RESOLUTION ) {
+
+			resolution ||= new Vector2();
+
+			output = uniform( resolution );
+
+		} else {
+
+			const coordinateNode = vec2( new ViewportNode( ViewportNode.COORDINATE ) );
+			const resolutionNode = new ViewportNode( ViewportNode.RESOLUTION );
+
+			output = div( coordinateNode, resolutionNode );
+
+			let outX = output.x;
+			let outY = output.y;
+
+			if ( /top/i.test( scope ) && builder.isFlipY() ) outY = invert( outY );
+			else if ( /bottom/i.test( scope ) && builder.isFlipY() === false ) outY = invert( outY );
+
+			if ( /right/i.test( scope ) ) outX = invert( outX );
+
+			output = vec2( outX, outY );
+
+		}
+
+		return output;
+
+	}
+
+	generate( builder ) {
+
+		if ( this.scope === ViewportNode.COORDINATE ) {
+
+			return builder.getFragCoord();
+
+		}
+
+		return super.generate( builder );
+
+	}
+
+}
+
+export default ViewportNode;

package/examples/jsm/nodes/functions/BSDF/BRDF_GGX.js

@@ -2,7 +2,7 @@ import F_Schlick from './F_Schlick.js';
 import V_GGX_SmithCorrelated from './V_GGX_SmithCorrelated.js';
 import D_GGX from './D_GGX.js';
 import {
-	ShaderNode, dotNV, add, mul, saturate, dot, pow2, normalize,
+	ShaderNode, dotNV, add, mul, clamp, dot, pow2, normalize,
 	transformedNormalView, positionViewDirection
 } from '../../shadernode/ShaderNodeBaseElements.js';
 
@@ -15,10 +15,10 @@ const BRDF_GGX = new ShaderNode( ( inputs ) => {
 
 	const halfDir = normalize( add( lightDirection, positionViewDirection ) );
 
-	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
-	//const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
-	const dotNH = saturate( dot( transformedNormalView, halfDir ) );
-	const dotVH = saturate( dot( positionViewDirection, halfDir ) );
+	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
+	//const dotNV = clamp( dot( transformedNormalView, positionViewDirection ) );
+	const dotNH = clamp( dot( transformedNormalView, halfDir ) );
+	const dotVH = clamp( dot( positionViewDirection, halfDir ) );
 
 	const F = F_Schlick.call( { f0, f90, dotVH } );
 

package/examples/jsm/nodes/functions/PhysicalLightingModel.js

@@ -3,7 +3,7 @@ import BRDF_GGX from './BSDF/BRDF_GGX.js';
 import DFGApprox from './BSDF/DFGApprox.js';
 import {
 	ShaderNode,
-	vec3, mul, saturate, add, sub, dot, div, transformedNormalView,
+	vec3, mul, clamp, add, sub, dot, div, transformedNormalView,
 	pow, exp2, dotNV,
 	diffuseColor, specularColor, roughness, temp
 } from '../shadernode/ShaderNodeElements.js';
@@ -61,7 +61,7 @@ const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
 
 	const { lightDirection, lightColor, reflectedLight } = inputs;
 
-	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
 	const irradiance = mul( dotNL, lightColor );
 
 	reflectedLight.directDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
@@ -75,7 +75,7 @@ const RE_AmbientOcclusion_Physical = new ShaderNode( ( { ambientOcclusion, refle
 	const aoNV = add( dotNV, ambientOcclusion );
 	const aoExp = exp2( sub( mul( - 16.0, roughness ), 1.0 ) );
 
-	const aoNode = saturate( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
+	const aoNode = clamp( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
 
 	reflectedLight.indirectDiffuse.mul( ambientOcclusion );
 

package/examples/jsm/nodes/functions/light/getDistanceAttenuation.js

@@ -1,5 +1,5 @@
 import {
-	ShaderNode, div, max, sub, mul, saturate, pow, pow2, pow4, cond, greaterThan
+	ShaderNode, div, max, sub, mul, clamp, pow, pow2, pow4, cond, greaterThan
 } from '../../shadernode/ShaderNodeBaseElements.js';
 
 const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
@@ -13,7 +13,7 @@ const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
 
 	return cond(
 		greaterThan( cutoffDistance, 0 ),
-		mul( distanceFalloff, pow2( saturate( sub( 1.0, pow4( div( lightDistance, cutoffDistance ) ) ) ) ) ),
+		mul( distanceFalloff, pow2( clamp( sub( 1.0, pow4( div( lightDistance, cutoffDistance ) ) ) ) ) ),
 		distanceFalloff
 	);
 

package/examples/jsm/nodes/gpgpu/ComputeNode.js

@@ -15,7 +15,7 @@ class ComputeNode extends Node {
 		this.workgroupSize = workgroupSize;
 		this.dispatchCount = 0;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.updateDispatchCount();
 

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

@@ -10,7 +10,7 @@ class AnalyticLightNode extends LightingNode {
 
 		super();
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.light = light;
 

package/examples/jsm/nodes/loaders/NodeMaterialLoader.js

@@ -4,6 +4,7 @@ import {
 	LineBasicNodeMaterial,
 	MeshBasicNodeMaterial,
 	MeshStandardNodeMaterial,
+	MeshPhysicalNodeMaterial,
 	PointsNodeMaterial,
 	SpriteNodeMaterial
 } from '../materials/Materials.js';
@@ -17,8 +18,9 @@ MaterialLoader.createMaterialFromType = function ( type ) {
 		LineBasicNodeMaterial,
 		MeshBasicNodeMaterial,
 		MeshStandardNodeMaterial,
+		MeshPhysicalNodeMaterial,
 		PointsNodeMaterial,
-		SpriteNodeMaterial,
+		SpriteNodeMaterial
 	};
 
 	if ( materialLib[ type ] !== undefined ) {

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

@@ -32,19 +32,21 @@ NodeMaterial.fromMaterial = function ( material ) {
 
 	if ( materialLib[ type ] === undefined ) {
 
-		return material; // is already a node material or cannot be converted
+		if ( material.isNodeMaterial !== true ) {
 
-	}
+			throw new Error( `NodeMaterial: Material "${ material.type }" is not compatible.` );
 
-	const nodeMaterial = new materialLib[ type ]( material );
+		}
 
-	for ( const key in material ) {
+		return material; // is already a node material
 
-		if ( nodeMaterial[ key ] === undefined ) {
+	}
 
-			nodeMaterial[ key ] = material[ key ]; // currently this is needed only for material.alphaTest
+	const nodeMaterial = new materialLib[ type ]();
 
-		}
+	for ( const key in material ) {
+
+		nodeMaterial[ key ] = material[ key ];
 
 	}
 

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

@@ -3,7 +3,7 @@ import { getNodesKeys, getCacheKey } from '../core/NodeUtils.js';
 import ExpressionNode from '../core/ExpressionNode.js';
 import {
 	float, vec3, vec4,
-	assign, label, mul, bypass,
+	assign, label, mul, bypass, attribute,
 	positionLocal, skinning, instance, modelViewProjection, lightingContext, colorSpace,
 	materialAlphaTest, materialColor, materialOpacity
 } from '../shadernode/ShaderNodeElements.js';
@@ -80,6 +80,14 @@ class NodeMaterial extends ShaderMaterial {
 		let colorNode = vec4( this.colorNode || materialColor );
 		let opacityNode = this.opacityNode ? float( this.opacityNode ) : materialOpacity;
 
+		// VERTEX COLORS
+
+		if ( this.vertexColors === true && builder.geometry.hasAttribute( 'color' ) ) {
+
+			colorNode = vec4( mul( colorNode.xyz, attribute( 'color' ) ), colorNode.a );
+		
+		}
+
 		// COLOR
 
 		colorNode = builder.addFlow( 'fragment', label( colorNode, 'Color' ) );

package/examples/jsm/nodes/materialx/{Disclaimer.md → DISCLAIMER.md}

@@ -196,4 +196,4 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
    of your accepting any such warranty or additional liability.
 
 END OF TERMS AND CONDITIONS
-```
+```

package/examples/jsm/nodes/materialx/MaterialXNodes.js

@@ -0,0 +1,59 @@
+import {
+	mx_perlin_noise_float, mx_perlin_noise_vec2, mx_perlin_noise_vec3,
+	mx_worley_noise_float as worley_noise_float, mx_worley_noise_vec2 as worley_noise_vec2, mx_worley_noise_vec3 as worley_noise_vec3,
+	mx_cell_noise_float as cell_noise_float,
+	mx_fractal_noise_float as fractal_noise_float, mx_fractal_noise_vec2 as fractal_noise_vec2, mx_fractal_noise_vec3 as fractal_noise_vec3, mx_fractal_noise_vec4 as fractal_noise_vec4
+} from './lib/mx_noise.js';
+import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
+import { mx_srgb_texture_to_lin_rec709 } from './lib/mx_transform_color.js';
+import { nodeObject, float, vec2, vec4, add, sub, mul, mix, clamp, uv, length, smoothstep, dFdx, dFdy, sign, pow, abs, convert } from '../shadernode/ShaderNodeElements.js';
+
+export const mx_aastep = ( threshold, value ) => {
+
+	threshold = float( threshold );
+	value = float( value );
+
+	const afwidth = mul( length( vec2( dFdx( value ), dFdy( value ) ) ), 0.70710678118654757 );
+
+	return smoothstep( sub( threshold, afwidth ), add( threshold, afwidth ), value );
+
+};
+
+const _ramp = ( a, b, uv, p ) => mix( a, b, clamp( nodeObject( uv )[ p ] ) );
+export const mx_ramplr = ( valuel, valuer, texcoord = uv() ) => _ramp( valuel, valuer, texcoord, 'x' );
+export const mx_ramptb = ( valuet, valueb, texcoord = uv() ) => _ramp( valuet, valueb, texcoord, 'y' );
+
+const _split = ( a, b, center, uv, p ) => mix( a, b, mx_aastep( center, nodeObject( uv )[ p ] ) );
+export const mx_splitlr = ( valuel, valuer, center, texcoord = uv() ) => _split( valuel, valuer, center, texcoord, 'x' );
+export const mx_splittb = ( valuet, valueb, center, texcoord = uv() ) => _split( valuet, valueb, center, texcoord, 'y' );
+
+export const mx_transform_uv = ( uv_scale = 1, uv_offset = 0, uv_geo = uv() ) => add( mul( uv_geo, uv_scale ), uv_offset );
+
+export const mx_safepower = ( in1, in2 = 1 ) => mul( sign( in1 ), pow( abs( in1 ), in2 ) );
+export const mx_contrast = ( input, amount = 1, pivot = .5 ) => add( mul( sub( input, pivot ), amount ), pivot );
+
+export const mx_noise_float = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_float( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
+export const mx_noise_vec2 = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_vec2( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
+export const mx_noise_vec3 = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_vec3( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
+export const mx_noise_vec4 = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => {
+
+	texcoord = convert( texcoord, 'vec2|vec3' ); // overloading type
+
+	const noise_vec4 = vec4( mx_perlin_noise_vec3( texcoord ), mx_perlin_noise_float( add( texcoord, vec2( 19, 73 ) ) ) );
+
+	return add( mul( amplitude, noise_vec4 ), pivot );
+
+};
+
+export const mx_worley_noise_float = ( texcoord = uv(), jitter = 1 ) => worley_noise_float( convert( texcoord, 'vec2|vec3' ), jitter, 1 );
+export const mx_worley_noise_vec2 = ( texcoord = uv(), jitter = 1 ) => worley_noise_vec2( convert( texcoord, 'vec2|vec3' ), jitter, 1 );
+export const mx_worley_noise_vec3 = ( texcoord = uv(), jitter = 1 ) => worley_noise_vec3( convert( texcoord, 'vec2|vec3' ), jitter, 1 );
+
+export const mx_cell_noise_float = ( texcoord = uv() ) => cell_noise_float( convert( texcoord, 'vec2|vec3' ) );
+
+export const mx_fractal_noise_float = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_float( position, octaves, lacunarity, diminish ), amplitude );
+export const mx_fractal_noise_vec2 = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_vec2( position, octaves, lacunarity, diminish ), amplitude );
+export const mx_fractal_noise_vec3 = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_vec3( position, octaves, lacunarity, diminish ), amplitude );
+export const mx_fractal_noise_vec4 = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_vec4( position, octaves, lacunarity, diminish ), amplitude );
+
+export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

package/examples/jsm/nodes/materialx/{functions/lib → lib}/mx_hsv.js

@@ -1,4 +1,4 @@
-import { fn } from '../../../Nodes.js';
+import { fn } from '../../Nodes.js';
 
 // Original shader code from:
 // https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_hsv.glsl

package/examples/jsm/nodes/materialx/{functions/lib → lib}/mx_noise.js

@@ -1,4 +1,4 @@
-import { code, fn } from '../../../Nodes.js';
+import { code, fn } from '../../Nodes.js';
 
 // Original shader code from:
 // https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_noise.glsl
@@ -601,7 +601,17 @@ vec3 mx_worley_noise_vec3(vec3 p, float jitter, int metric)
 
 const includes = [ mx_noise ];
 
-export const mx_perlin_noise_float = fn( 'float mx_perlin_noise_float( vec3 p )', includes );
+export const mx_perlin_noise_float = fn( 'float mx_perlin_noise_float( any p )', includes );
+export const mx_perlin_noise_vec2 = fn( 'vec2 mx_perlin_noise_vec2( any p )', includes );
+export const mx_perlin_noise_vec3 = fn( 'vec3 mx_perlin_noise_vec3( any p )', includes );
+
 export const mx_cell_noise_float = fn( 'float mx_cell_noise_float( vec3 p )', includes );
-export const mx_worley_noise_float = fn( 'float mx_worley_noise_float( vec3 p, float jitter, int metric )', includes );
+
+export const mx_worley_noise_float = fn( 'float mx_worley_noise_float( any p, float jitter, int metric )', includes );
+export const mx_worley_noise_vec2 = fn( 'float mx_worley_noise_vec2( any p, float jitter, int metric )', includes );
+export const mx_worley_noise_vec3 = fn( 'float mx_worley_noise_vec3( any p, float jitter, int metric )', includes );
+
 export const mx_fractal_noise_float = fn( 'float mx_fractal_noise_float( vec3 p, int octaves, float lacunarity, float diminish )', includes );
+export const mx_fractal_noise_vec2 = fn( 'float mx_fractal_noise_vec2( vec3 p, int octaves, float lacunarity, float diminish )', includes );
+export const mx_fractal_noise_vec3 = fn( 'float mx_fractal_noise_vec3( vec3 p, int octaves, float lacunarity, float diminish )', includes );
+export const mx_fractal_noise_vec4 = fn( 'float mx_fractal_noise_vec4( vec3 p, int octaves, float lacunarity, float diminish )', includes );

package/examples/jsm/nodes/materialx/lib/mx_transform_color.js

@@ -0,0 +1,18 @@
+import { code, fn } from '../../Nodes.js';
+
+// Original shader code from:
+// https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_transform_color.glsl
+
+export const mx_transform_color = code( `#define M_AP1_TO_REC709 mat3(1.705079555511475, -0.1297005265951157, -0.02416634373366833, -0.6242334842681885, 1.138468623161316, -0.1246141716837883, -0.0808461606502533, -0.008768022060394287, 1.148780584335327)
+
+vec3 mx_srgb_texture_to_lin_rec709(vec3 color)
+{
+    bvec3 isAbove = greaterThan(color, vec3(0.04045));
+    vec3 linSeg = color / 12.92;
+    vec3 powSeg = pow(max(color + vec3(0.055), vec3(0.0)) / 1.055, vec3(2.4));
+    return mix(linSeg, powSeg, isAbove);
+}` );
+
+const includes = [ mx_transform_color ];
+
+export const mx_srgb_texture_to_lin_rec709 = fn( 'vec3 mx_srgb_texture_to_lin_rec709( vec3 color )', includes );

package/examples/jsm/nodes/math/MathNode.js

@@ -32,8 +32,8 @@ class MathNode extends TempNode {
 	static INVERT = 'invert';
 	static DFDX = 'dFdx';
 	static DFDY = 'dFdy';
-	static SATURATE = 'saturate';
 	static ROUND = 'round';
+	static RECIPROCAL = 'reciprocal';
 
 	// 2 inputs
 
@@ -152,10 +152,6 @@ class MathNode extends TempNode {
 
 			return new MathNode( MathNode.NORMALIZE, mulNode ).build( builder );
 
-		} else if ( method === MathNode.SATURATE ) {
-
-			return builder.format( `clamp( ${ a.build( builder, inputType ) }, 0.0, 1.0 )`, type, output );
-
 		} else if ( method === MathNode.NEGATE ) {
 
 			return builder.format( '( -' + a.build( builder, inputType ) + ' )', type, output );
@@ -164,6 +160,10 @@ class MathNode extends TempNode {
 
 			return builder.format( '( 1.0 - ' + a.build( builder, inputType ) + ' )', type, output );
 
+		} else if ( method === MathNode.RECIPROCAL ) {
+
+			return builder.format( '( 1.0 / ' + a.build( builder, inputType ) + ' )', type, output );
+
 		} else {
 
 			const params = [];

package/examples/jsm/nodes/math/OperatorNode.js

@@ -47,7 +47,7 @@ class OperatorNode extends TempNode {
 
 		} else if ( op === '&' || op === '|' || op === '^' || op === '>>' || op === '<<' ) {
 
-			return 'int';
+			return builder.getIntegerType( typeA );
 
 		} else if ( op === '==' || op === '&&' || op === '||' || op === '^^' ) {
 
@@ -124,6 +124,11 @@ class OperatorNode extends TempNode {
 
 				}
 
+			} else if ( op === '>>' || op === '<<' ) {
+
+				typeA = type;
+				typeB = builder.changeComponentType( typeB, 'uint' );
+
 			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
 
 				// matrix x vector
@@ -163,14 +168,22 @@ class OperatorNode extends TempNode {
 
 				return a;
 
-			} else if ( op === '>' && outputLength > 1 ) {
+			} else if ( op === '<' && outputLength > 1 ) {
 
-				return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`, type, output );
+				return builder.format( `${ builder.getMethod( 'lessThan' ) }( ${a}, ${b} )`, type, output );
 
 			} else if ( op === '<=' && outputLength > 1 ) {
 
 				return builder.format( `${ builder.getMethod( 'lessThanEqual' ) }( ${a}, ${b} )`, type, output );
 
+			} else if ( op === '>' && outputLength > 1 ) {
+
+				return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`, type, output );
+
+			} else if ( op === '>=' && outputLength > 1 ) {
+
+				return builder.format( `${ builder.getMethod( 'greaterThanEqual' ) }( ${a}, ${b} )`, type, output );
+
 			} else {
 
 				return builder.format( `( ${a} ${this.op} ${b} )`, type, output );

package/examples/jsm/nodes/shadernode/ShaderNode.js

@@ -1,3 +1,4 @@
+import Node from '../core/Node.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import ConvertNode from '../utils/ConvertNode.js';
 import JoinNode from '../utils/JoinNode.js';
@@ -107,31 +108,33 @@ const ShaderNodeArray = function ( array ) {
 
 };
 
-const ShaderNodeProxy = function ( NodeClass, scope = null, factor = null ) {
+const ShaderNodeProxy = function ( NodeClass, scope = null, factor = null, settings = null ) {
+
+	const assignNode = ( node ) => nodeObject( settings !== null ? Object.assign( node, settings ) : node );
 
 	if ( scope === null ) {
 
 		return ( ...params ) => {
 
-			return nodeObject( new NodeClass( ...nodeArray( params ) ) );
+			return assignNode( new NodeClass( ...nodeArray( params ) ) );
 
 		};
 
-	} else if ( factor === null ) {
+	} else if ( factor !== null ) {
+
+		factor = nodeObject( factor );
 
 		return ( ...params ) => {
 
-			return nodeObject( new NodeClass( scope, ...nodeArray( params ) ) );
+			return assignNode( new NodeClass( scope, ...nodeArray( params ), factor ) );
 
 		};
 
 	} else {
 
-		factor = nodeObject( factor );
-
 		return ( ...params ) => {
 
-			return nodeObject( new NodeClass( scope, ...nodeArray( params ), factor ) );
+			return assignNode( new NodeClass( scope, ...nodeArray( params ) ) );
 
 		};
 
@@ -145,31 +148,43 @@ const ShaderNodeImmutable = function ( NodeClass, ...params ) {
 
 };
 
-const ShaderNodeScript = function ( jsFunc ) {
+class ShaderNodeInternal extends Node {
 
-	// @TODO: Move this to Node extended class
+	constructor( jsFunc ) {
 
-	const self = {
+		super();
 
-		build: ( builder ) => {
+		this._jsFunc = jsFunc;
 
-			self.call( {}, builder );
+	}
 
-			return '';
+	call( inputs, builder ) {
 
-		},
+		inputs = nodeObjects( inputs );
 
-		call: ( inputs, builder ) => {
+		return nodeObject( this._jsFunc( inputs, builder ) );
+
+	}
 
-			inputs = nodeObjects( inputs );
+	generate( builder, output ) {
 
-			return nodeObject( jsFunc( inputs, builder ) );
+		const nodeCall = this.call( {}, builder );
+
+		if ( nodeCall === undefined ) {
+
+			return '';
 
 		}
 
-	};
+		return builder.format( nodeCall.build( builder ), nodeCall.getNodeType( builder ), output );
+
+	}
+
+}
+
+const ShaderNodeScript = function ( jsFunc ) {
 
-	return self;
+	return new ShaderNodeInternal( jsFunc );
 
 };
 
@@ -251,7 +266,7 @@ export const ConvertType = function ( type, cacheMap = null ) {
 
 			}
 
-			return nodeObject( new ConvertNode( new JoinNode( nodes ), type ) );
+			return nodeObject( new JoinNode( nodes, type ) );
 
 		}