@needle-tools/three 0.162.12 → 0.169.2

package/src/nodes/lighting/RectAreaLightNode.js

@@ -0,0 +1,97 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { uniform } from '../core/UniformNode.js';
+import { lightViewPosition } from '../accessors/Lights.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Vector3 } from '../../math/Vector3.js';
+
+const _matrix41 = /*@__PURE__*/ new Matrix4();
+const _matrix42 = /*@__PURE__*/ new Matrix4();
+
+let ltcLib = null;
+
+class RectAreaLightNode extends AnalyticLightNode {
+
+	static get type() {
+
+		return 'RectAreaLightNode';
+
+	}
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this.halfHeight = uniform( new Vector3() ).setGroup( renderGroup );
+		this.halfWidth = uniform( new Vector3() ).setGroup( renderGroup );
+
+	}
+
+	update( frame ) {
+
+		super.update( frame );
+
+		const { light } = this;
+
+		const viewMatrix = frame.camera.matrixWorldInverse;
+
+		_matrix42.identity();
+		_matrix41.copy( light.matrixWorld );
+		_matrix41.premultiply( viewMatrix );
+		_matrix42.extractRotation( _matrix41 );
+
+		this.halfWidth.value.set( light.width * 0.5, 0.0, 0.0 );
+		this.halfHeight.value.set( 0.0, light.height * 0.5, 0.0 );
+
+		this.halfWidth.value.applyMatrix4( _matrix42 );
+		this.halfHeight.value.applyMatrix4( _matrix42 );
+
+	}
+
+	setup( builder ) {
+
+		super.setup( builder );
+
+		let ltc_1, ltc_2;
+
+		if ( builder.isAvailable( 'float32Filterable' ) ) {
+
+			ltc_1 = texture( ltcLib.LTC_FLOAT_1 );
+			ltc_2 = texture( ltcLib.LTC_FLOAT_2 );
+
+		} else {
+
+			ltc_1 = texture( ltcLib.LTC_HALF_1 );
+			ltc_2 = texture( ltcLib.LTC_HALF_2 );
+
+		}
+
+		const { colorNode, light } = this;
+		const lightingModel = builder.context.lightingModel;
+
+		const lightPosition = lightViewPosition( light );
+		const reflectedLight = builder.context.reflectedLight;
+
+		lightingModel.directRectArea( {
+			lightColor: colorNode,
+			lightPosition,
+			halfWidth: this.halfWidth,
+			halfHeight: this.halfHeight,
+			reflectedLight,
+			ltc_1,
+			ltc_2
+		}, builder.stack, builder );
+
+	}
+
+	static setLTC( ltc ) {
+
+		ltcLib = ltc;
+
+	}
+
+}
+
+export default RectAreaLightNode;

package/{examples/jsm → src}/nodes/lighting/SpotLightNode.js

@@ -1,26 +1,28 @@
 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 'three';
+import { positionView } from '../accessors/Position.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+import { lightViewPosition, lightTargetDirection } from '../accessors/Lights.js';
 
 class SpotLightNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'SpotLightNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super( light );
 
-		this.coneCosNode = uniform( 0 );
-		this.penumbraCosNode = uniform( 0 );
+		this.coneCosNode = uniform( 0 ).setGroup( renderGroup );
+		this.penumbraCosNode = uniform( 0 ).setGroup( renderGroup );
 
-		this.cutoffDistanceNode = uniform( 0 );
-		this.decayExponentNode = uniform( 0 );
+		this.cutoffDistanceNode = uniform( 0 ).setGroup( renderGroup );
+		this.decayExponentNode = uniform( 0 ).setGroup( renderGroup );
 
 	}
 
@@ -54,7 +56,7 @@ class SpotLightNode extends AnalyticLightNode {
 
 		const { colorNode, cutoffDistanceNode, decayExponentNode, light } = this;
 
-		const lVector = objectViewPosition( light ).sub( positionView ); // @TODO: Add it into LightNode
+		const lVector = lightViewPosition( light ).sub( positionView ); // @TODO: Add it into LightNode
 
 		const lightDirection = lVector.normalize();
 		const angleCos = lightDirection.dot( lightTargetDirection( light ) );
@@ -83,7 +85,3 @@ class SpotLightNode extends AnalyticLightNode {
 }
 
 export default SpotLightNode;
-
-addNodeClass( 'SpotLightNode', SpotLightNode );
-
-addLightNode( SpotLight, SpotLightNode );

package/{examples/jsm → 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

@@ -0,0 +1,127 @@
+// Three.js Transpiler
+// https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_hsv.glsl
+
+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__*/ Fn( ( [ hsv ] ) => {
+
+	const s = hsv.y;
+	const v = hsv.z;
+
+	const result = vec3().toVar();
+
+	If( s.lessThan( 0.0001 ), () => {
+
+		result.assign( vec3( v, v, v ) );
+
+	} ).Else( () => {
+
+		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 ) ), () => {
+
+			result.assign( vec3( v, t, p ) );
+
+		} ).ElseIf( hi.equal( int( 1 ) ), () => {
+
+			result.assign( vec3( q, v, p ) );
+
+		} ).ElseIf( hi.equal( int( 2 ) ), () => {
+
+			result.assign( vec3( p, v, t ) );
+
+		} ).ElseIf( hi.equal( int( 3 ) ), () => {
+
+			result.assign( vec3( p, q, v ) );
+
+		} ).ElseIf( hi.equal( int( 4 ) ), () => {
+
+			result.assign( vec3( t, p, v ) );
+
+		} ).Else( () => {
+
+			result.assign( vec3( v, p, q ) );
+
+		} );
+
+	} );
+
+	return result;
+
+} ).setLayout( {
+	name: 'mx_hsvtorgb',
+	type: 'vec3',
+	inputs: [
+		{ name: 'hsv', type: 'vec3' }
+	]
+} );
+
+export const mx_rgbtohsv = /*@__PURE__*/ Fn( ( [ c_immutable ] ) => {
+
+	const c = vec3( c_immutable ).toVar();
+	const r = float( c.x ).toVar();
+	const g = float( c.y ).toVar();
+	const b = float( c.z ).toVar();
+	const mincomp = float( min( r, min( g, b ) ) ).toVar();
+	const maxcomp = float( max( r, max( g, b ) ) ).toVar();
+	const delta = float( maxcomp.sub( mincomp ) ).toVar();
+	const h = float().toVar(), s = float().toVar(), v = float().toVar();
+	v.assign( maxcomp );
+
+	If( maxcomp.greaterThan( 0.0 ), () => {
+
+		s.assign( delta.div( maxcomp ) );
+
+	} ).Else( () => {
+
+		s.assign( 0.0 );
+
+	} );
+
+	If( s.lessThanEqual( 0.0 ), () => {
+
+		h.assign( 0.0 );
+
+	} ).Else( () => {
+
+		If( r.greaterThanEqual( maxcomp ), () => {
+
+			h.assign( g.sub( b ).div( delta ) );
+
+		} ).ElseIf( g.greaterThanEqual( maxcomp ), () => {
+
+			h.assign( add( 2.0, b.sub( r ).div( delta ) ) );
+
+		} ).Else( () => {
+
+			h.assign( add( 4.0, r.sub( g ).div( delta ) ) );
+
+		} );
+
+		h.mulAssign( 1.0 / 6.0 );
+
+		If( h.lessThan( 0.0 ), () => {
+
+			h.addAssign( 1.0 );
+
+		} );
+
+	} );
+
+	return vec3( h, s, v );
+
+} ).setLayout( {
+	name: 'mx_rgbtohsv',
+	type: 'vec3',
+	inputs: [
+		{ name: 'c', type: 'vec3' }
+	]
+} );