@plastic-software/three 0.167.3 → 0.174.0

package/src/nodes/lighting/LightsNode.js

@@ -1,8 +1,6 @@
 import Node from '../core/Node.js';
-import AnalyticLightNode from './AnalyticLightNode.js';
-import { nodeObject, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-
-const LightNodes = new WeakMap();
+import { nodeObject, vec3 } from '../tsl/TSLBase.js';
+import { hashArray } from '../core/NodeUtils.js';
 
 const sortLights = ( lights ) => {
 
@@ -10,46 +8,150 @@ const sortLights = ( lights ) => {
 
 };
 
+const getLightNodeById = ( id, lightNodes ) => {
+
+	for ( const lightNode of lightNodes ) {
+
+		if ( lightNode.isAnalyticLightNode && lightNode.light.id === id ) {
+
+			return lightNode;
+
+		}
+
+	}
+
+	return null;
+
+};
+
+const _lightsNodeRef = /*@__PURE__*/ new WeakMap();
+
+/**
+ * This node represents the scene's lighting and manages the lighting model's life cycle
+ * for the current build 3D object. It is responsible for computing the total outgoing
+ * light in a given lighting context.
+ *
+ * @augments Node
+ */
 class LightsNode extends Node {
 
-	constructor( lightNodes = [] ) {
+	static get type() {
 
-		super( 'vec3' );
+		return 'LightsNode';
 
-		this.totalDiffuseNode = vec3().temp( 'totalDiffuse' );
-		this.totalSpecularNode = vec3().temp( 'totalSpecular' );
+	}
 
-		this.outgoingLightNode = vec3().temp( 'outgoingLight' );
+	/**
+	 * Constructs a new lights node.
+	 */
+	constructor() {
 
-		this.lightNodes = lightNodes;
+		super( 'vec3' );
 
-		this._hash = null;
+		/**
+		 * A node representing the total diffuse light.
+		 *
+		 * @type {Node<vec3>}
+		 */
+		this.totalDiffuseNode = vec3().toVar( 'totalDiffuse' );
+
+		/**
+		 * A node representing the total specular light.
+		 *
+		 * @type {Node<vec3>}
+		 */
+		this.totalSpecularNode = vec3().toVar( 'totalSpecular' );
+
+		/**
+		 * A node representing the outgoing light.
+		 *
+		 * @type {Node<vec3>}
+		 */
+		this.outgoingLightNode = vec3().toVar( 'outgoingLight' );
+
+		/**
+		 * An array representing the lights in the scene.
+		 *
+		 * @private
+		 * @type {Array<Light>}
+		 */
+		this._lights = [];
+
+		/**
+		 * For each light in the scene, this node will create a
+		 * corresponding light node.
+		 *
+		 * @private
+		 * @type {?Array<LightingNode>}
+		 * @default null
+		 */
+		this._lightNodes = null;
+
+		/**
+		 * A hash for identifying the current light nodes setup.
+		 *
+		 * @private
+		 * @type {?string}
+		 * @default null
+		 */
+		this._lightNodesHash = null;
+
+		/**
+		 * `LightsNode` sets this property to `true` by default.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.global = true;
 
 	}
 
-	get hasLight() {
+	/**
+	 * Overwrites the default {@link Node#customCacheKey} implementation by including the
+	 * light IDs into the cache key.
+	 *
+	 * @return {number} The custom cache key.
+	 */
+	customCacheKey() {
 
-		return this.lightNodes.length > 0;
+		const lightIDs = [];
+		const lights = this._lights;
+
+		for ( let i = 0; i < lights.length; i ++ ) {
+
+			lightIDs.push( lights[ i ].id );
+
+		}
+
+		return hashArray( lightIDs );
 
 	}
 
-	getHash() {
+	/**
+	 * Computes a hash value for identifying the current light nodes setup.
+	 *
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @return {string} The computed hash.
+	 */
+	getHash( builder ) {
+
+		if ( this._lightNodesHash === null ) {
 
-		if ( this._hash === null ) {
+			if ( this._lightNodes === null ) this.setupLightsNode( builder );
 
 			const hash = [];
 
-			for ( const lightNode of this.lightNodes ) {
+			for ( const lightNode of this._lightNodes ) {
 
-				hash.push( lightNode.getHash() );
+				hash.push( lightNode.getSelf().getHash() );
 
 			}
 
-			this._hash = 'lights-' + hash.join( ',' );
+			this._lightNodesHash = 'lights-' + hash.join( ',' );
 
 		}
 
-		return this._hash;
+		return this._lightNodesHash;
 
 	}
 
@@ -65,16 +167,157 @@ class LightsNode extends Node {
 
 	}
 
+	/**
+	 * Creates lighting nodes for each scene light. This makes it possible to further
+	 * process lights in the node system.
+	 *
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 */
+	setupLightsNode( builder ) {
+
+		const lightNodes = [];
+
+		const previousLightNodes = this._lightNodes;
+
+		const lights = sortLights( this._lights );
+		const nodeLibrary = builder.renderer.library;
+
+		for ( const light of lights ) {
+
+			if ( light.isNode ) {
+
+				lightNodes.push( nodeObject( light ) );
+
+			} else {
+
+				let lightNode = null;
+
+				if ( previousLightNodes !== null ) {
+
+					lightNode = getLightNodeById( light.id, previousLightNodes ); // reuse existing light node
+
+				}
+
+				if ( lightNode === null ) {
+
+					// find the corresponding node type for a given light
+
+					const lightNodeClass = nodeLibrary.getLightNodeClass( light.constructor );
+
+					if ( lightNodeClass === null ) {
+
+						console.warn( `LightsNode.setupNodeLights: Light node not found for ${ light.constructor.name }` );
+						continue;
+
+					}
+
+					let lightNode = null;
+
+					if ( ! _lightsNodeRef.has( light ) ) {
+
+						lightNode = nodeObject( new lightNodeClass( light ) );
+						_lightsNodeRef.set( light, lightNode );
+
+					} else {
+
+						lightNode = _lightsNodeRef.get( light );
+
+					}
+
+					lightNodes.push( lightNode );
+
+				}
+
+			}
+
+		}
+
+		this._lightNodes = lightNodes;
+
+	}
+
+	/**
+	 * Sets up a direct light in the lighting model.
+	 *
+	 * @param {Object} builder - The builder object containing the context and stack.
+	 * @param {Object} lightNode - The light node.
+	 * @param {Object} lightData - The light object containing color and direction properties.
+	 */
+	setupDirectLight( builder, lightNode, lightData ) {
+
+		const { lightingModel, reflectedLight } = builder.context;
+
+		lightingModel.direct( {
+			...lightData,
+			lightNode,
+			reflectedLight
+		}, builder );
+
+	}
+
+	setupDirectRectAreaLight( builder, lightNode, lightData ) {
+
+		const { lightingModel, reflectedLight } = builder.context;
+
+		lightingModel.directRectArea( {
+			...lightData,
+			lightNode,
+			reflectedLight
+		}, builder );
+
+	}
+
+	/**
+	 * Setups the internal lights by building all respective
+	 * light nodes.
+	 *
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @param {Array<LightingNode>} lightNodes - An array of lighting nodes.
+	 */
+	setupLights( builder, lightNodes ) {
+
+		for ( const lightNode of lightNodes ) {
+
+			lightNode.build( builder );
+
+		}
+
+	}
+
+	getLightNodes( builder ) {
+
+		if ( this._lightNodes === null ) this.setupLightsNode( builder );
+
+		return this._lightNodes;
+
+	}
+
+	/**
+	 * The implementation makes sure that for each light in the scene
+	 * there is a corresponding light node. By building the light nodes
+	 * and evaluating the lighting model the outgoing light is computed.
+	 *
+	 * @param {NodeBuilder} builder - A reference to the current node builder.
+	 * @return {Node<vec3>} A node representing the outgoing light.
+	 */
 	setup( builder ) {
 
+		const currentLightsNode = builder.lightsNode;
+
+		builder.lightsNode = this;
+
+		//
+
+		let outgoingLightNode = this.outgoingLightNode;
+
 		const context = builder.context;
 		const lightingModel = context.lightingModel;
 
-		let outgoingLightNode = this.outgoingLightNode;
+		const properties = builder.getDataFromNode( this );
 
 		if ( lightingModel ) {
 
-			const { lightNodes, totalDiffuseNode, totalSpecularNode } = this;
+			const { totalDiffuseNode, totalSpecularNode } = this;
 
 			context.outgoingLight = outgoingLightNode;
 
@@ -82,24 +325,11 @@ class LightsNode extends Node {
 
 			//
 
-			const properties = builder.getDataFromNode( this );
 			properties.nodes = stack.nodes;
 
 			//
 
-			lightingModel.start( context, stack, builder );
-
-			// lights
-
-			for ( const lightNode of lightNodes ) {
-
-				lightNode.build( builder );
-
-			}
-
-			//
-
-			lightingModel.indirect( context, stack, builder );
+			lightingModel.start( builder );
 
 			//
 
@@ -131,83 +361,76 @@ class LightsNode extends Node {
 
 			//
 
-			lightingModel.finish( context, stack, builder );
+			lightingModel.finish( builder );
 
 			//
 
 			outgoingLightNode = outgoingLightNode.bypass( builder.removeStack() );
 
-		}
-
-		return outgoingLightNode;
-
-	}
-
-	_getLightNodeById( id ) {
-
-		for ( const lightNode of this.lightNodes ) {
-
-			if ( lightNode.isAnalyticLightNode && lightNode.light.id === id ) {
+		} else {
 
-				return lightNode;
-
-			}
+			properties.nodes = [];
 
 		}
 
-		return null;
-
-	}
-
-	fromLights( lights = [] ) {
-
-		const lightNodes = [];
+		//
 
-		lights = sortLights( lights );
+		builder.lightsNode = currentLightsNode;
 
-		for ( const light of lights ) {
-
-			let lightNode = this._getLightNodeById( light.id );
-
-			if ( lightNode === null ) {
-
-				const lightClass = light.constructor;
-				const lightNodeClass = LightNodes.has( lightClass ) ? LightNodes.get( lightClass ) : AnalyticLightNode;
-
-				lightNode = nodeObject( new lightNodeClass( light ) );
+		return outgoingLightNode;
 
-			}
+	}
 
-			lightNodes.push( lightNode );
+	/**
+	 * Configures this node with an array of lights.
+	 *
+	 * @param {Array<Light>} lights - An array of lights.
+	 * @return {LightsNode} A reference to this node.
+	 */
+	setLights( lights ) {
 
-		}
+		this._lights = lights;
 
-		this.lightNodes = lightNodes;
-		this._hash = null;
+		this._lightNodes = null;
+		this._lightNodesHash = null;
 
 		return this;
 
 	}
 
-}
-
-export default LightsNode;
+	/**
+	 * Returns an array of the scene's lights.
+	 *
+	 * @return {Array<Light>} The scene's lights.
+	 */
+	getLights() {
 
-export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
-export const lightsNode = nodeProxy( LightsNode );
+		return this._lights;
 
-export function addLightNode( lightClass, lightNodeClass ) {
+	}
 
-	if ( LightNodes.has( lightClass ) ) {
+	/**
+	 * Whether the scene has lights or not.
+	 *
+	 * @type {boolean}
+	 */
+	get hasLights() {
 
-		console.warn( `Redefinition of light node ${ lightNodeClass.type }` );
-		return;
+		return this._lights.length > 0;
 
 	}
 
-	if ( typeof lightClass !== 'function' ) throw new Error( `Light ${ lightClass.name } is not a class` );
-	if ( typeof lightNodeClass !== 'function' || ! lightNodeClass.type ) throw new Error( `Light node ${ lightNodeClass.type } is not a class` );
+}
 
-	LightNodes.set( lightClass, lightNodeClass );
+export default LightsNode;
 
-}
+/**
+ * TSL function for creating an instance of `LightsNode` and configuring
+ * it with the given array of lights.
+ *
+ * @tsl
+ * @function
+ * @param {Array<Light>} lights - An array of lights.
+ * @return {LightsNode} The created lights node.
+ */
+export const lights = ( lights = [] ) => nodeObject( new LightsNode() ).setLights( lights );

package/src/nodes/lighting/PointLightNode.js

@@ -1,24 +1,69 @@
 import AnalyticLightNode from './AnalyticLightNode.js';
-import { addLightNode } from './LightsNode.js';
 import { getDistanceAttenuation } from './LightUtils.js';
 import { uniform } from '../core/UniformNode.js';
-import { objectViewPosition } from '../accessors/Object3DNode.js';
-import { positionView } from '../accessors/PositionNode.js';
-import { addNodeClass } from '../core/Node.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+import { pointShadow } from './PointShadowNode.js';
 
-import { PointLight } from '../../lights/PointLight.js';
+export const directPointLight = ( { color, lightVector, cutoffDistance, decayExponent } ) => {
 
+	const lightDirection = lightVector.normalize();
+	const lightDistance = lightVector.length();
+
+	const attenuation = getDistanceAttenuation( {
+		lightDistance,
+		cutoffDistance,
+		decayExponent
+	} );
+
+	const lightColor = color.mul( attenuation );
+
+	return { lightDirection, lightColor };
+
+};
+
+/**
+ * Module for representing point lights as nodes.
+ *
+ * @augments AnalyticLightNode
+ */
 class PointLightNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'PointLightNode';
+
+	}
+
+	/**
+	 * Constructs a new point light node.
+	 *
+	 * @param {?PointLight} [light=null] - The point light source.
+	 */
 	constructor( light = null ) {
 
 		super( light );
 
-		this.cutoffDistanceNode = uniform( 0 );
-		this.decayExponentNode = uniform( 0 );
+		/**
+		 * Uniform node representing the cutoff distance.
+		 *
+		 * @type {UniformNode<float>}
+		 */
+		this.cutoffDistanceNode = uniform( 0 ).setGroup( renderGroup );
+
+		/**
+		 * Uniform node representing the decay exponent.
+		 *
+		 * @type {UniformNode<float>}
+		 */
+		this.decayExponentNode = uniform( 2 ).setGroup( renderGroup );
 
 	}
 
+	/**
+	 * Overwritten to updated point light specific uniforms.
+	 *
+	 * @param {NodeFrame} frame - A reference to the current node frame.
+	 */
 	update( frame ) {
 
 		const { light } = this;
@@ -30,39 +75,28 @@ class PointLightNode extends AnalyticLightNode {
 
 	}
 
-	setup( builder ) {
-
-		const { colorNode, cutoffDistanceNode, decayExponentNode, light } = this;
+	/**
+	 * Overwritten to setup point light specific shadow.
+	 *
+	 * @return {PointShadowNode}
+	 */
+	setupShadowNode() {
 
-		const lightingModel = builder.context.lightingModel;
+		return pointShadow( this.light );
 
-		const lVector = objectViewPosition( light ).sub( positionView ); // @TODO: Add it into LightNode
+	}
 
-		const lightDirection = lVector.normalize();
-		const lightDistance = lVector.length();
+	setupDirect( builder ) {
 
-		const lightAttenuation = getDistanceAttenuation( {
-			lightDistance,
-			cutoffDistance: cutoffDistanceNode,
-			decayExponent: decayExponentNode
+		return directPointLight( {
+			color: this.colorNode,
+			lightVector: this.getLightVector( builder ),
+			cutoffDistance: this.cutoffDistanceNode,
+			decayExponent: this.decayExponentNode
 		} );
 
-		const lightColor = colorNode.mul( lightAttenuation );
-
-		const reflectedLight = builder.context.reflectedLight;
-
-		lightingModel.direct( {
-			lightDirection,
-			lightColor,
-			reflectedLight
-		}, builder.stack, builder );
-
 	}
 
 }
 
 export default PointLightNode;
-
-addNodeClass( 'PointLightNode', PointLightNode );
-
-addLightNode( PointLight, PointLightNode );