super-three 0.167.0 → 0.168.0

package/src/nodes/lighting/LightsNode.js

@@ -1,8 +1,5 @@
-import Node from '../core/Node.js';
-import AnalyticLightNode from './AnalyticLightNode.js';
-import { nodeObject, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-
-const LightNodes = new WeakMap();
+import Node, { registerNode } from '../core/Node.js';
+import { nodeObject, nodeProxy, vec3 } from '../tsl/TSLBase.js';
 
 const sortLights = ( lights ) => {
 
@@ -10,46 +7,61 @@ const sortLights = ( lights ) => {
 
 };
 
-class LightsNode extends Node {
+const getLightNodeById = ( id, lightNodes ) => {
 
-	constructor( lightNodes = [] ) {
+	for ( const lightNode of lightNodes ) {
 
-		super( 'vec3' );
+		if ( lightNode.isAnalyticLightNode && lightNode.light.id === id ) {
+
+			return lightNode;
+
+		}
 
-		this.totalDiffuseNode = vec3().temp( 'totalDiffuse' );
-		this.totalSpecularNode = vec3().temp( 'totalSpecular' );
+	}
 
-		this.outgoingLightNode = vec3().temp( 'outgoingLight' );
+	return null;
 
-		this.lightNodes = lightNodes;
+};
 
-		this._hash = null;
+class LightsNode extends Node {
 
-	}
+	constructor( lights = [] ) {
 
-	get hasLight() {
+		super( 'vec3' );
+
+		this.totalDiffuseNode = vec3().toVar( 'totalDiffuse' );
+		this.totalSpecularNode = vec3().toVar( 'totalSpecular' );
+
+		this.outgoingLightNode = vec3().toVar( 'outgoingLight' );
+
+		this._lights = lights;
+
+		this._lightNodes = null;
+		this._lightNodesHash = null;
 
-		return this.lightNodes.length > 0;
+		this.global = true;
 
 	}
 
-	getHash() {
+	getHash( builder ) {
 
-		if ( this._hash === null ) {
+		if ( this._lightNodesHash === 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() );
 
 			}
 
-			this._hash = 'lights-' + hash.join( ',' );
+			this._lightNodesHash = 'lights-' + hash.join( ',' );
 
 		}
 
-		return this._hash;
+		return this._lightNodesHash;
 
 	}
 
@@ -65,8 +77,58 @@ class LightsNode extends Node {
 
 	}
 
+	setupLightsNode( builder ) {
+
+		const lightNodes = [];
+
+		const previousLightNodes = this._lightNodes;
+
+		const lights = sortLights( this._lights );
+		const nodeLibrary = builder.renderer.nodes.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 ); // resuse existing light node
+
+				}
+
+				if ( lightNode === null ) {
+
+					const lightNodeClass = nodeLibrary.getLightNodeClass( light.constructor );
+
+					if ( lightNodeClass === undefined ) {
+
+						console.warn( `LightsNode.setupNodeLights: Light node not found for ${ light.constructor.name }` );
+						continue;
+
+					}
+
+					lightNodes.push( nodeObject( new lightNodeClass( light ) ) );
+
+				}
+
+			}
+
+		}
+
+		this._lightNodes = lightNodes;
+
+	}
+
 	setup( builder ) {
 
+		if ( this._lightNodes === null ) this.setupLightsNode( builder );
+
 		const context = builder.context;
 		const lightingModel = context.lightingModel;
 
@@ -74,7 +136,7 @@ class LightsNode extends Node {
 
 		if ( lightingModel ) {
 
-			const { lightNodes, totalDiffuseNode, totalSpecularNode } = this;
+			const { _lightNodes, totalDiffuseNode, totalSpecularNode } = this;
 
 			context.outgoingLight = outgoingLightNode;
 
@@ -91,7 +153,7 @@ class LightsNode extends Node {
 
 			// lights
 
-			for ( const lightNode of lightNodes ) {
+			for ( const lightNode of _lightNodes ) {
 
 				lightNode.build( builder );
 
@@ -143,49 +205,20 @@ class LightsNode extends Node {
 
 	}
 
-	_getLightNodeById( id ) {
+	setLights( lights ) {
 
-		for ( const lightNode of this.lightNodes ) {
+		this._lights = lights;
 
-			if ( lightNode.isAnalyticLightNode && lightNode.light.id === id ) {
+		this._lightNodes = null;
+		this._lightNodesHash = null;
 
-				return lightNode;
-
-			}
-
-		}
-
-		return null;
+		return this;
 
 	}
 
-	fromLights( lights = [] ) {
-
-		const lightNodes = [];
-
-		lights = sortLights( lights );
-
-		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 ) );
-
-			}
-
-			lightNodes.push( lightNode );
+	getLights() {
 
-		}
-
-		this.lightNodes = lightNodes;
-		this._hash = null;
-
-		return this;
+		return this._lights;
 
 	}
 
@@ -193,21 +226,6 @@ class LightsNode extends Node {
 
 export default LightsNode;
 
-export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
-export const lightsNode = nodeProxy( LightsNode );
-
-export function addLightNode( lightClass, lightNodeClass ) {
-
-	if ( LightNodes.has( lightClass ) ) {
+LightsNode.type = /*@__PURE__*/ registerNode( 'Lights', LightsNode );
 
-		console.warn( `Redefinition of light node ${ lightNodeClass.type }` );
-		return;
-
-	}
-
-	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 const lights = /*@__PURE__*/ nodeProxy( LightsNode );

package/src/nodes/lighting/PointLightNode.js

@@ -1,12 +1,9 @@
+import { registerNode } from '../core/Node.js';
 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 { PointLight } from '../../lights/PointLight.js';
+import { positionView } from '../accessors/Position.js';
 
 class PointLightNode extends AnalyticLightNode {
 
@@ -63,6 +60,4 @@ class PointLightNode extends AnalyticLightNode {
 
 export default PointLightNode;
 
-addNodeClass( 'PointLightNode', PointLightNode );
-
-addLightNode( PointLight, PointLightNode );
+PointLightNode.type = /*@__PURE__*/ registerNode( 'PointLight', PointLightNode );

package/src/nodes/lighting/RectAreaLightNode.js

@@ -1,11 +1,9 @@
+import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
-import { addLightNode } from './LightsNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { uniform } from '../core/UniformNode.js';
 import { objectViewPosition } from '../accessors/Object3DNode.js';
-import { addNodeClass } from '../core/Node.js';
 
-import { RectAreaLight } from '../../lights/RectAreaLight.js';
 import { Matrix4 } from '../../math/Matrix4.js';
 import { Vector3 } from '../../math/Vector3.js';
 
@@ -92,6 +90,4 @@ class RectAreaLightNode extends AnalyticLightNode {
 
 export default RectAreaLightNode;
 
-addNodeClass( 'RectAreaLightNode', RectAreaLightNode );
-
-addLightNode( RectAreaLight, RectAreaLightNode );
+RectAreaLightNode.type = /*@__PURE__*/ registerNode( 'RectAreaLight', RectAreaLightNode );

package/src/nodes/lighting/SpotLightNode.js

@@ -1,14 +1,11 @@
+import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
 import { lightTargetDirection } from './LightNode.js';
-import { addLightNode } from './LightsNode.js';
 import { getDistanceAttenuation } from './LightUtils.js';
 import { uniform } from '../core/UniformNode.js';
 import { smoothstep } from '../math/MathNode.js';
 import { objectViewPosition } from '../accessors/Object3DNode.js';
-import { positionView } from '../accessors/PositionNode.js';
-import { addNodeClass } from '../core/Node.js';
-
-import { SpotLight } from '../../lights/SpotLight.js';
+import { positionView } from '../accessors/Position.js';
 
 class SpotLightNode extends AnalyticLightNode {
 
@@ -84,6 +81,4 @@ class SpotLightNode extends AnalyticLightNode {
 
 export default SpotLightNode;
 
-addNodeClass( 'SpotLightNode', SpotLightNode );
-
-addLightNode( SpotLight, SpotLightNode );
+SpotLightNode.type = /*@__PURE__*/ registerNode( 'SpotLight', SpotLightNode );

package/src/nodes/materialx/MaterialXNodes.js

@@ -7,8 +7,8 @@ import {
 import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
 import { mx_srgb_texture_to_lin_rec709 } from './lib/mx_transform_color.js';
 import { mix, smoothstep } from '../math/MathNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { float, vec2, vec4, int } from '../shadernode/ShaderNode.js';
+import { uv } from '../accessors/UV.js';
+import { float, vec2, vec4, int } from '../tsl/TSLBase.js';
 
 export const mx_aastep = ( threshold, value ) => {
 

package/src/nodes/materialx/lib/mx_hsv.js

@@ -1,56 +1,61 @@
 // Three.js Transpiler
 // https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_hsv.glsl
 
-import { int, float, vec3, If, tslFn } from '../../shadernode/ShaderNode.js';
-import { add, sub, mul } from '../../math/OperatorNode.js';
+import { int, float, vec3, If, Fn } from '../../tsl/TSLBase.js';
+import { add } from '../../math/OperatorNode.js';
 import { floor, trunc, max, min } from '../../math/MathNode.js';
 
-export const mx_hsvtorgb = /*#__PURE__*/ tslFn( ( [ hsv_immutable ] ) => {
+export const mx_hsvtorgb = /*@__PURE__*/ Fn( ( [ hsv ] ) => {
 
-	const hsv = vec3( hsv_immutable ).toVar();
-	const h = float( hsv.x ).toVar();
-	const s = float( hsv.y ).toVar();
-	const v = float( hsv.z ).toVar();
+	const s = hsv.y;
+	const v = hsv.z;
+
+	const result = vec3().toVar();
 
 	If( s.lessThan( 0.0001 ), () => {
 
-		return vec3( v, v, v );
+		result.assign( vec3( v, v, v ) );
 
-	} ).else( () => {
+	} ).Else( () => {
 
-		h.assign( mul( 6.0, h.sub( floor( h ) ) ) );
-		const hi = int( trunc( h ) ).toVar();
-		const f = float( h.sub( float( hi ) ) ).toVar();
-		const p = float( v.mul( sub( 1.0, s ) ) ).toVar();
-		const q = float( v.mul( sub( 1.0, s.mul( f ) ) ) ).toVar();
-		const t = float( v.mul( sub( 1.0, s.mul( sub( 1.0, f ) ) ) ) ).toVar();
+		let h = hsv.x;
+		h = h.sub( floor( h ) ).mul( 6.0 ).toVar(); // TODO: check what .toVar() is needed in node system cache
+		const hi = int( trunc( h ) );
+		const f = h.sub( float( hi ) );
+		const p = v.mul( s.oneMinus() );
+		const q = v.mul( s.mul( f ).oneMinus() );
+		const t = v.mul( s.mul( f.oneMinus() ).oneMinus() );
 
 		If( hi.equal( int( 0 ) ), () => {
 
-			return vec3( v, t, p );
+			result.assign( vec3( v, t, p ) );
 
-		} ).elseif( hi.equal( int( 1 ) ), () => {
+		} ).ElseIf( hi.equal( int( 1 ) ), () => {
 
-			return vec3( q, v, p );
+			result.assign( vec3( q, v, p ) );
 
-		} ).elseif( hi.equal( int( 2 ) ), () => {
+		} ).ElseIf( hi.equal( int( 2 ) ), () => {
 
-			return vec3( p, v, t );
+			result.assign( vec3( p, v, t ) );
 
-		} ).elseif( hi.equal( int( 3 ) ), () => {
+		} ).ElseIf( hi.equal( int( 3 ) ), () => {
 
-			return vec3( p, q, v );
+			result.assign( vec3( p, q, v ) );
 
-		} ).elseif( hi.equal( int( 4 ) ), () => {
+		} ).ElseIf( hi.equal( int( 4 ) ), () => {
 
-			return vec3( t, p, v );
+			result.assign( vec3( t, p, v ) );
 
-		} );
+		} ).Else( () => {
 
-		return vec3( v, p, q );
+			result.assign( vec3( v, p, q ) );
+
+		} );
 
 	} );
 
+	return result;
+
 } ).setLayout( {
 	name: 'mx_hsvtorgb',
 	type: 'vec3',
@@ -59,7 +64,7 @@ export const mx_hsvtorgb = /*#__PURE__*/ tslFn( ( [ hsv_immutable ] ) => {
 	]
 } );
 
-export const mx_rgbtohsv = /*#__PURE__*/ tslFn( ( [ c_immutable ] ) => {
+export const mx_rgbtohsv = /*@__PURE__*/ Fn( ( [ c_immutable ] ) => {
 
 	const c = vec3( c_immutable ).toVar();
 	const r = float( c.x ).toVar();
@@ -75,7 +80,7 @@ export const mx_rgbtohsv = /*#__PURE__*/ tslFn( ( [ c_immutable ] ) => {
 
 		s.assign( delta.div( maxcomp ) );
 
-	} ).else( () => {
+	} ).Else( () => {
 
 		s.assign( 0.0 );
 
@@ -85,17 +90,17 @@ export const mx_rgbtohsv = /*#__PURE__*/ tslFn( ( [ c_immutable ] ) => {
 
 		h.assign( 0.0 );
 
-	} ).else( () => {
+	} ).Else( () => {
 
 		If( r.greaterThanEqual( maxcomp ), () => {
 
 			h.assign( g.sub( b ).div( delta ) );
 
-		} ).elseif( g.greaterThanEqual( maxcomp ), () => {
+		} ).ElseIf( g.greaterThanEqual( maxcomp ), () => {
 
 			h.assign( add( 2.0, b.sub( r ).div( delta ) ) );
 
-		} ).else( () => {
+		} ).Else( () => {
 
 			h.assign( add( 4.0, r.sub( g ).div( delta ) ) );