super-three 0.133.4 → 0.136.1

package/examples/jsm/renderers/nodes/display/NormalMapNode.js

@@ -5,46 +5,45 @@ import MathNode from '../math/MathNode.js';
 import OperatorNode from '../math/OperatorNode.js';
 import FloatNode from '../inputs/FloatNode.js';
 import TempNode from '../core/TempNode.js';
-import FunctionNode from '../core/FunctionNode.js';
 import ModelNode from '../accessors/ModelNode.js';
+import { ShaderNode, cond, add, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, equal } from '../ShaderNode.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
 
 // Normal Mapping Without Precomputed Tangents
 // http://www.thetenthplanet.de/archives/1180
 
-export const perturbNormal2Arb = new FunctionNode( `
-vec3 ( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection, const in vec2 uv ) {
+const perturbNormal2ArbNode = new ShaderNode( ( inputs ) => {
 
-	// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
+	const { eye_pos, surf_norm, mapN, faceDirection, uv } = inputs;
 
-	vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
-	vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
-	vec2 st0 = dFdx( uv.st );
-	vec2 st1 = dFdy( uv.st );
+	const q0 = dFdx( eye_pos.xyz );
+	const q1 = dFdy( eye_pos.xyz );
+	const st0 = dFdx( uv.st );
+	const st1 = dFdy( uv.st );
 
-	vec3 N = surf_norm; // normalized
+	const N = surf_norm; // normalized
 
-	vec3 q1perp = cross( q1, N );
-	vec3 q0perp = cross( N, q0 );
+	const q1perp = cross( q1, N );
+	const q0perp = cross( N, q0 );
 
-	vec3 T = q1perp * st0.x + q0perp * st1.x;
-	vec3 B = q1perp * st0.y + q0perp * st1.y;
+	const T = add( mul( q1perp, st0.x ), mul( q0perp, st1.x ) );
+	const B = add( mul( q1perp, st0.y ), mul( q0perp, st1.y ) );
 
-	float det = max( dot( T, T ), dot( B, B ) );
-	float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
+	const det = max( dot( T, T ), dot( B, B ) );
+	const scale = cond( equal( det, 0 ), 0, mul( faceDirection, inversesqrt( det ) ) );
 
-	return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
+	return normalize( add( mul( T, mul( mapN.x, scale ) ), mul( B, mul( mapN.y, scale ) ), mul( N, mapN.z ) ) );
 
-}` );
+} );
 
 class NormalMapNode extends TempNode {
 
-	constructor( value ) {
+	constructor( node ) {
 
 		super( 'vec3' );
 
-		this.value = value;
+		this.node = node;
 
 		this.normalMapType = TangentSpaceNormalMap;
 
@@ -56,7 +55,7 @@ class NormalMapNode extends TempNode {
 
 		const normalMapType = this.normalMapType;
 
-		const normalOP = new OperatorNode( '*', this.value, new FloatNode( 2.0 ).setConst( true ) );
+		const normalOP = new OperatorNode( '*', this.node, new FloatNode( 2.0 ).setConst( true ) );
 		const normalMap = new OperatorNode( '-', normalOP, new FloatNode( 1.0 ).setConst( true ) );
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
@@ -69,7 +68,7 @@ class NormalMapNode extends TempNode {
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
-			const perturbNormal2ArbCall = perturbNormal2Arb.call( {
+			const perturbNormal2ArbCall = perturbNormal2ArbNode( {
 				eye_pos: new PositionNode( PositionNode.VIEW ),
 				surf_norm: new NormalNode( NormalNode.VIEW ),
 				mapN: normalMap,
@@ -78,7 +77,7 @@ class NormalMapNode extends TempNode {
 			} );
 
 			return perturbNormal2ArbCall.build( builder, type );
-			
+
 		}
 
 	}

package/examples/jsm/renderers/nodes/functions/BSDFs.js

@@ -1,68 +1,43 @@
-import FunctionNode from '../core/FunctionNode.js';
-import { pow2 } from './MathFunctions.js';
+import { ShaderNode,
+	add, addTo, sub, mul, div, saturate, dot, pow, pow2, exp2, normalize, max, sqrt, negate,
+	cond, greaterThan, and,
+	transformedNormalView, positionViewDirection,
+	diffuseColor, specularColor, roughness,
+	PI, RECIPROCAL_PI, EPSILON
+} from '../ShaderNode.js';
 
-export const F_Schlick = new FunctionNode( `
-vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH  ) {
+export const F_Schlick = new ShaderNode( ( inputs ) => {
+
+	const { f0, f90, dotVH } = inputs;
 
 	// Original approximation by Christophe Schlick '94
 	// float fresnel = pow( 1.0 - dotVH, 5.0 );
 
 	// Optimized variant (presented by Epic at SIGGRAPH '13)
 	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
-	float fresnel = exp2( ( -5.55473 * dotVH - 6.98316 ) * dotVH );
-
-	return ( f90 - f0 ) * fresnel + f0;
-
-}` ); // validated
-
-export const G_BlinnPhong_Implicit = new FunctionNode( `
-float G_BlinnPhong_Implicit() {
-
-	// ( const in float dotNL, const in float dotNV )
-	// geometry term is (n dot l)(n dot v) / 4(n dot l)(n dot v)
-
-	return 0.25;
-
-}` ); // validated
-
-export const BRDF_Lambert = new FunctionNode( `
-vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
-
-	return RECIPROCAL_PI * diffuseColor;
-
-}` ); // validated
+	const fresnel = exp2( mul( sub( mul( - 5.55473, dotVH ), 6.98316 ), dotVH ) );
 
-export const getDistanceAttenuation = new FunctionNode( `
-float getDistanceAttenuation( float lightDistance, float cutoffDistance, float decayExponent ) {
+	return add( mul( f0, sub( 1.0, fresnel ) ), mul( f90, fresnel ) );
 
-#if defined ( PHYSICALLY_CORRECT_LIGHTS )
+} ); // validated
 
-	// based upon Frostbite 3 Moving to Physically-based Rendering
-	// page 32, equation 26: E[window1]
-	// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
-	float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
+export const BRDF_Lambert = new ShaderNode( ( inputs ) => {
 
-	if( cutoffDistance > 0.0 ) {
+	return mul( RECIPROCAL_PI, inputs.diffuseColor ); // punctual light
 
-		distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
+} ); // validated
 
-	}
+export const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
 
-	return distanceFalloff;
+	const { lightDistance, cutoffDistance, decayExponent } = inputs;
 
-#else
+	return cond(
+		and( greaterThan( cutoffDistance, 0 ), greaterThan( decayExponent, 0 ) ),
+		pow( saturate( add( div( negate( lightDistance ), cutoffDistance ), 1.0 ) ), decayExponent ),
+		1.0
+	);
 
-	if( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
-
-		return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );
-
-	}
-
-	return 1.0;
-
-#endif
-
-}` ).setIncludes( [ pow2 ] );
+} ); // validated
 
 //
 // STANDARD
@@ -70,90 +45,78 @@ float getDistanceAttenuation( float lightDistance, float cutoffDistance, float d
 
 // Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
 // https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
-export const V_GGX_SmithCorrelated = new FunctionNode( `
-float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
+export const V_GGX_SmithCorrelated = new ShaderNode( ( inputs ) => {
 
-	float a2 = pow2( alpha );
+	const { alpha, dotNL, dotNV } = inputs;
 
-	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
-	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
+	const a2 = pow2( alpha );
 
-	return 0.5 / max( gv + gl, EPSILON );
+	const gv = mul( dotNL, sqrt( add( a2, mul( sub( 1.0, a2 ), pow2( dotNV ) ) ) ) );
+	const gl = mul( dotNV, sqrt( add( a2, mul( sub( 1.0, a2 ), pow2( dotNL ) ) ) ) );
 
-}` ).setIncludes( [ pow2 ] );
+	return div( 0.5, max( add( gv, gl ), EPSILON ) );
+
+} ); // validated
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
 // alpha is "roughness squared" in Disney’s reparameterization
-export const D_GGX = new FunctionNode( `
-float D_GGX( const in float alpha, const in float dotNH ) {
-
-	float a2 = pow2( alpha );
+export const D_GGX = new ShaderNode( ( inputs ) => {
 
-	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0; // avoid alpha = 0 with dotNH = 1
+	const { alpha, dotNH } = inputs;
 
-	return RECIPROCAL_PI * a2 / pow2( denom );
+	const a2 = pow2( alpha );
 
-}` ).setIncludes( [ pow2 ] );
+	const denom = add( mul( pow2( dotNH ), sub( a2, 1.0 ) ), 1.0 ); // avoid alpha = 0 with dotNH = 1
 
-// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-export const BRDF_Specular_GGX = new FunctionNode( `
-vec3 BRDF_Specular_GGX( vec3 lightDirection, const in vec3 f0, const in float f90, const in float roughness ) {
+	return mul( RECIPROCAL_PI, div( a2, pow2( denom ) ) );
 
-	float alpha = pow2( roughness ); // UE4's roughness
+} ); // validated
 
-	vec3 halfDir = normalize( lightDirection + PositionViewDirection );
 
-	float dotNL = saturate( dot( TransformedNormalView, lightDirection ) );
-	float dotNV = saturate( dot( TransformedNormalView, PositionViewDirection ) );
-	float dotNH = saturate( dot( TransformedNormalView, halfDir ) );
-	float dotVH = saturate( dot( PositionViewDirection, halfDir ) );
-
-	vec3 F = F_Schlick( f0, f90, dotVH );
+// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
+export const BRDF_GGX = new ShaderNode( ( inputs ) => {
 
-	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+	const { lightDirection, f0, f90, roughness } = inputs;
 
-	float D = D_GGX( alpha, dotNH );
+	const alpha = pow2( roughness ); // UE4's roughness
 
-	return F * ( V * D );
+	const halfDir = normalize( add( lightDirection, positionViewDirection ) );
 
-}` ).setIncludes( [ pow2, F_Schlick, V_GGX_SmithCorrelated, D_GGX ] ); // validated
+	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
+	const dotNH = saturate( dot( transformedNormalView, halfDir ) );
+	const dotVH = saturate( dot( positionViewDirection, halfDir ) );
 
-export const RE_Direct_Physical = new FunctionNode( `
-void RE_Direct_Physical( inout ReflectedLight reflectedLight, vec3 lightDirection, vec3 lightColor ) {
+	const F = F_Schlick( { f0, f90, dotVH } );
 
-	float dotNL = saturate( dot( TransformedNormalView, lightDirection ) );
-	vec3 irradiance = dotNL * lightColor;
+	const V = V_GGX_SmithCorrelated( { alpha, dotNL, dotNV } );
 
-#ifndef PHYSICALLY_CORRECT_LIGHTS
+	const D = D_GGX( { alpha, dotNH } );
 
-		irradiance *= PI; // punctual light
+	return mul( F, mul( V, D ) );
 
-#endif
+} ); // validated
 
-	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( MaterialDiffuseColor.rgb );
+export const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
 
-	reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX( lightDirection, MaterialSpecularTint, 1.0, MaterialRoughness );
+	const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
 
-}` ).setIncludes( [ BRDF_Lambert, BRDF_Specular_GGX ] );
+	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	let irradiance = mul( dotNL, lightColor );
 
-export const PhysicalLightingModel = new FunctionNode( `
-void ( inout ReflectedLight reflectedLight, vec3 lightDirection, vec3 lightColor ) {
+	irradiance = mul( irradiance, PI ); // punctual light
 
-	RE_Direct_Physical( reflectedLight, lightDirection, lightColor );
+	addTo( directDiffuse, mul( irradiance, BRDF_Lambert( { diffuseColor } ) ) );
 
-}` ).setIncludes( [ RE_Direct_Physical ] );
+	addTo( directSpecular, mul( irradiance, BRDF_GGX( { lightDirection, f0: specularColor, f90: 1, roughness } ) ) );
 
-// utils
+} );
 
-// Trowbridge-Reitz distribution to Mip level, following the logic of http://casual-effects.blogspot.ca/2011/08/plausible-environment-lighting-in-two.html
-export const getSpecularMIPLevel = new FunctionNode( `
-float ( const in float roughness, const in float maxMIPLevelScalar ) {
+export const PhysicalLightingModel = new ShaderNode( ( inputs/*, builder*/ ) => {
 
-	float sigma = PI * roughness * roughness / ( 1.0 + roughness );
-	float desiredMIPLevel = maxMIPLevelScalar + log2( sigma );
+	// PHYSICALLY_CORRECT_LIGHTS <-> builder.renderer.physicallyCorrectLights === true
 
-	// clamp to allowable LOD ranges.
-	return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
+	RE_Direct_Physical( inputs );
 
-}` );
+} );

package/examples/jsm/renderers/nodes/functions/PhysicalMaterialFunctions.js

@@ -0,0 +1,27 @@
+import { ShaderNode,
+	add, max, min, abs, dFdx, dFdy,
+	normalGeometry
+} from '../ShaderNode.js';
+
+export const getGeometryRoughness = new ShaderNode( () => {
+
+	const dxy = max( abs( dFdx( normalGeometry ) ), abs( dFdy( normalGeometry ) ) );
+	const geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
+
+	return geometryRoughness;
+
+} );
+
+export const getRoughness = new ShaderNode( ( inputs ) => {
+
+	const { roughness } = inputs;
+
+	const geometryRoughness = getGeometryRoughness();
+
+	let roughnessFactor = max( roughness, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.
+	roughnessFactor = add( roughnessFactor, geometryRoughness );
+	roughnessFactor = min( roughnessFactor, 1.0 );
+
+	return roughnessFactor;
+
+} );

package/examples/jsm/renderers/nodes/inputs/BufferNode.js

@@ -0,0 +1,25 @@
+import InputNode from '../core/InputNode.js';
+
+class BufferNode extends InputNode {
+
+	constructor( value, bufferType, bufferCount = 0 ) {
+
+		super( 'buffer' );
+
+		this.value = value;
+		this.bufferType = bufferType;
+		this.bufferCount = bufferCount;
+
+	}
+
+	getNodeType( /* builder */ ) {
+
+		return this.bufferType;
+
+	}
+
+}
+
+BufferNode.prototype.isBufferNode = true;
+
+export default BufferNode;

package/examples/jsm/renderers/nodes/inputs/IntNode.js

@@ -0,0 +1,17 @@
+import InputNode from '../core/InputNode.js';
+
+class IntNode extends InputNode {
+
+	constructor( value = 0 ) {
+
+		super( 'int' );
+
+		this.value = value;
+
+	}
+
+}
+
+IntNode.prototype.isIntNode = true;
+
+export default IntNode;

package/examples/jsm/renderers/nodes/inputs/TextureNode.js

@@ -1,7 +1,6 @@
 import InputNode from '../core/InputNode.js';
 import ExpressionNode from '../core/ExpressionNode.js';
 import UVNode from '../accessors/UVNode.js';
-import ColorSpaceNode from '../display/ColorSpaceNode.js';
 
 class TextureNode extends InputNode {
 
@@ -17,6 +16,14 @@ class TextureNode extends InputNode {
 
 	generate( builder, output ) {
 
+		const texture = this.value;
+
+		if ( ! texture || texture.isTexture !== true ) {
+
+			throw new Error( 'TextureNode: Need a three.js texture.' );
+
+		}
+
 		const type = this.getNodeType( builder );
 
 		const textureProperty = super.generate( builder, type );
@@ -33,9 +40,9 @@ class TextureNode extends InputNode {
 
 			const nodeData = builder.getDataFromNode( this );
 
-			let colorSpace = nodeData.colorSpace;
+			let snippet = nodeData.snippet;
 
-			if ( colorSpace === undefined ) {
+			if ( snippet === undefined ) {
 
 				const uvSnippet = this.uv.build( builder, 'vec2' );
 				const bias = this.bias;
@@ -48,17 +55,13 @@ class TextureNode extends InputNode {
 
 				}
 
-				const textureCallSnippet = builder.getTexture( textureProperty, uvSnippet, biasSnippet );
-
-				colorSpace = new ColorSpaceNode();
-				colorSpace.input = new ExpressionNode( textureCallSnippet, 'vec4' );
-				colorSpace.fromDecoding( builder.getTextureEncodingFromMap( this.value ) );
+				snippet = builder.getTexture( textureProperty, uvSnippet, biasSnippet );
 
-				nodeData.colorSpace = colorSpace;
+				nodeData.snippet = snippet;
 
 			}
 
-			return colorSpace.build( builder, output );
+			return builder.format( snippet, 'vec4', output );
 
 		}
 

package/examples/jsm/renderers/nodes/lights/LightContextNode.js

@@ -1,23 +1,24 @@
 import ContextNode from '../core/ContextNode.js';
-import StructNode from '../core/StructNode.js';
+import VarNode from '../core/VarNode.js';
+import Vector3Node from '../inputs/Vector3Node.js';
+import OperatorNode from '../math/OperatorNode.js';
 import { PhysicalLightingModel } from '../functions/BSDFs.js';
 
-const reflectedLightStruct = new StructNode( {
-	directDiffuse: 'vec3',
-	directSpecular: 'vec3'
-}, 'ReflectedLight' );
-
 class LightContextNode extends ContextNode {
 
 	constructor( node ) {
 
-		super( node, 'vec3' );
+		super( node );
 
 	}
 
-	generate( builder ) {
+	getNodeType( /*builder*/ ) {
 
-		const type = this.getNodeType( builder );
+		return 'vec3';
+
+	}
+
+	generate( builder ) {
 
 		const material = builder.material;
 
@@ -29,22 +30,27 @@ class LightContextNode extends ContextNode {
 
 		}
 
-		const reflectedLightNode = reflectedLightStruct.create();
-		const reflectedLight = reflectedLightNode.build( builder, 'var' );
+		const directDiffuse = new VarNode( new Vector3Node(), 'DirectDiffuse', 'vec3' );
+		const directSpecular = new VarNode( new Vector3Node(), 'DirectSpecular', 'vec3' );
 
-		this.setContextValue( 'reflectedLight', reflectedLightNode );
+		this.context.directDiffuse = directDiffuse;
+		this.context.directSpecular = directSpecular;
 
 		if ( lightingModel !== null ) {
 
-			this.setContextValue( 'lightingModel', lightingModel );
+			this.context.lightingModel = lightingModel;
 
 		}
 
 		// add code
 
+		const type = this.getNodeType( builder );
+
 		super.generate( builder, type );
 
-		return `( ${reflectedLight}.directDiffuse + ${reflectedLight}.directSpecular )`;
+		const totalLight = new OperatorNode( '+', directDiffuse, directSpecular );
+
+		return totalLight.build( builder, type );
 
 	}
 

package/examples/jsm/renderers/nodes/lights/LightNode.js

@@ -20,61 +20,57 @@ class LightNode extends Node {
 
 		this.light = light;
 
-		this.color = new ColorNode( new Color() );
+		this.colorNode = new ColorNode( new Color() );
 
-		this.lightCutoffDistance = new FloatNode( 0 );
-		this.lightDecayExponent = new FloatNode( 0 );
-
-		this.lightPositionView = new Object3DNode( Object3DNode.VIEW_POSITION );
-		this.positionView = new PositionNode( PositionNode.VIEW );
-
-		this.lVector = new OperatorNode( '-', this.lightPositionView, this.positionView );
-
-		this.lightDirection = new MathNode( MathNode.NORMALIZE, this.lVector );
-
-		this.lightDistance = new MathNode( MathNode.LENGTH, this.lVector );
-
-		this.lightAttenuation = getDistanceAttenuation.call( {
-			lightDistance: this.lightDistance,
-			cutoffDistance: this.lightCutoffDistance,
-			decayExponent: this.lightDecayExponent
-		} );
-
-		this.lightColor = new OperatorNode( '*', this.color, this.lightAttenuation );
+		this.lightCutoffDistanceNode = new FloatNode( 0 );
+		this.lightDecayExponentNode = new FloatNode( 0 );
 
 	}
 
 	update( /* frame */ ) {
 
-		this.color.value.copy( this.light.color ).multiplyScalar( this.light.intensity );
-		this.lightCutoffDistance.value = this.light.distance;
-		this.lightDecayExponent.value = this.light.decay;
+		this.colorNode.value.copy( this.light.color ).multiplyScalar( this.light.intensity );
+		this.lightCutoffDistanceNode.value = this.light.distance;
+		this.lightDecayExponentNode.value = this.light.decay;
 
 	}
 
 	generate( builder ) {
 
-		const type = this.getNodeType( builder );
+		const lightPositionView = new Object3DNode( Object3DNode.VIEW_POSITION );
+		const positionView = new PositionNode( PositionNode.VIEW );
 
-		this.lightPositionView.object3d = this.light;
+		const lVector = new OperatorNode( '-', lightPositionView, positionView );
 
-		const lightingModelFunctionNode = builder.getContextValue( 'lightingModel' );
+		const lightDirection = new MathNode( MathNode.NORMALIZE, lVector );
 
-		if ( lightingModelFunctionNode !== undefined ) {
+		const lightDistance = new MathNode( MathNode.LENGTH, lVector );
 
-			const reflectedLightStructNode = builder.getContextValue( 'reflectedLight' );
+		const lightAttenuation = getDistanceAttenuation( {
+			lightDistance,
+			cutoffDistance: this.lightCutoffDistanceNode,
+			decayExponent: this.lightDecayExponentNode
+		} );
 
-			const lightingModelCallNode = lightingModelFunctionNode.call( {
-				lightDirection: this.lightDirection,
-				lightColor: this.lightColor,
-				reflectedLight:	reflectedLightStructNode
-			} );
+		const lightColor = new OperatorNode( '*', this.colorNode, lightAttenuation );
 
-			builder.addFlowCode( lightingModelCallNode.build( builder ) );
+		lightPositionView.object3d = this.light;
 
-		}
+		const lightingModelFunction = builder.context.lightingModel;
+
+		if ( lightingModelFunction !== undefined ) {
 
-		return this.color.build( builder, type );
+			const directDiffuse = builder.context.directDiffuse;
+			const directSpecular = builder.context.directSpecular;
+
+			lightingModelFunction( {
+				lightDirection,
+				lightColor,
+				directDiffuse,
+				directSpecular
+			}, builder );
+
+		}
 
 	}
 

package/examples/jsm/renderers/nodes/math/CondNode.js

@@ -0,0 +1,60 @@
+import Node from '../core/Node.js';
+import PropertyNode from '../core/PropertyNode.js';
+import ContextNode from '../core/ContextNode.js';
+
+class CondNode extends Node {
+
+	constructor( node, ifNode, elseNode ) {
+
+		super();
+
+		this.node = node;
+
+		this.ifNode = ifNode;
+		this.elseNode = elseNode;
+
+	}
+
+	getNodeType( builder ) {
+
+		const ifType = this.ifNode.getNodeType( builder );
+		const elseType = this.elseNode.getNodeType( builder );
+
+		if ( builder.getTypeLength( elseType ) > builder.getTypeLength( ifType ) ) {
+
+			return elseType;
+
+		}
+
+		return ifType;
+
+	}
+
+	generate( builder ) {
+
+		const type = this.getNodeType( builder );
+
+		const context = { temp: false };
+		const nodeProperty = new PropertyNode( null, type ).build( builder );
+
+		const nodeSnippet = new ContextNode( this.node/*, context*/ ).build( builder, 'bool' ),
+			ifSnippet = new ContextNode( this.ifNode, context ).build( builder, type ),
+			elseSnippet = new ContextNode( this.elseNode, context ).build( builder, type );
+
+		builder.addFlowCode( `if ( ${nodeSnippet} ) {
+
+\t\t${nodeProperty} = ${ifSnippet};
+
+\t} else {
+
+\t\t${nodeProperty} = ${elseSnippet};
+
+\t}` );
+
+		return nodeProperty;
+
+	}
+
+}
+
+export default CondNode;