@needle-tools/three 0.162.12 → 0.169.2

package/src/nodes/functions/ToonLightingModel.js

@@ -0,0 +1,51 @@
+import LightingModel from '../core/LightingModel.js';
+import BRDF_Lambert from './BSDF/BRDF_Lambert.js';
+import { diffuseColor } from '../core/PropertyNode.js';
+import { normalGeometry } from '../accessors/Normal.js';
+import { Fn, float, vec2, vec3 } from '../tsl/TSLBase.js';
+import { mix, smoothstep } from '../math/MathNode.js';
+import { materialReference } from '../accessors/MaterialReferenceNode.js';
+
+const getGradientIrradiance = /*@__PURE__*/ Fn( ( { normal, lightDirection, builder } ) => {
+
+	// dotNL will be from -1.0 to 1.0
+	const dotNL = normal.dot( lightDirection );
+	const coord = vec2( dotNL.mul( 0.5 ).add( 0.5 ), 0.0 );
+
+	if ( builder.material.gradientMap ) {
+
+		const gradientMap = materialReference( 'gradientMap', 'texture' ).context( { getUV: () => coord } );
+
+		return vec3( gradientMap.r );
+
+	} else {
+
+		const fw = coord.fwidth().mul( 0.5 );
+
+		return mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( float( 0.7 ).sub( fw.x ), float( 0.7 ).add( fw.x ), coord.x ) );
+
+	}
+
+} );
+
+class ToonLightingModel extends LightingModel {
+
+	direct( { lightDirection, lightColor, reflectedLight }, stack, builder ) {
+
+		const irradiance = getGradientIrradiance( { normal: normalGeometry, lightDirection, builder } ).mul( lightColor );
+
+		reflectedLight.directDiffuse.addAssign( irradiance.mul( BRDF_Lambert( { diffuseColor: diffuseColor.rgb } ) ) );
+
+	}
+
+	indirect( { ambientOcclusion, irradiance, reflectedLight } ) {
+
+		reflectedLight.indirectDiffuse.addAssign( irradiance.mul( BRDF_Lambert( { diffuseColor } ) ) );
+
+		reflectedLight.indirectDiffuse.mulAssign( ambientOcclusion );
+
+	}
+
+}
+
+export default ToonLightingModel;

package/src/nodes/functions/material/getGeometryRoughness.js

@@ -0,0 +1,13 @@
+import { normalView } from '../../accessors/Normal.js';
+import { Fn } from '../../tsl/TSLBase.js';
+
+const getGeometryRoughness = /*@__PURE__*/ Fn( () => {
+
+	const dxy = normalView.dFdx().abs().max( normalView.dFdy().abs() );
+	const geometryRoughness = dxy.x.max( dxy.y ).max( dxy.z );
+
+	return geometryRoughness;
+
+} );
+
+export default getGeometryRoughness;

package/{examples/jsm → src}/nodes/functions/material/getRoughness.js

@@ -1,7 +1,7 @@
 import getGeometryRoughness from './getGeometryRoughness.js';
-import { tslFn } from '../../shadernode/ShaderNode.js';
+import { Fn } from '../../tsl/TSLBase.js';
 
-const getRoughness = tslFn( ( inputs ) => {
+const getRoughness = /*@__PURE__*/ Fn( ( inputs ) => {
 
 	const { roughness } = inputs;
 

package/src/nodes/functions/material/getShIrradianceAt.js

@@ -0,0 +1,28 @@
+import { Fn, mul } from '../../tsl/TSLBase.js';
+
+const getShIrradianceAt = /*@__PURE__*/ Fn( ( [ normal, shCoefficients ] ) => {
+
+	// normal is assumed to have unit length
+
+	const x = normal.x, y = normal.y, z = normal.z;
+
+	// band 0
+	let result = shCoefficients.element( 0 ).mul( 0.886227 );
+
+	// band 1
+	result = result.add( shCoefficients.element( 1 ).mul( 2.0 * 0.511664 ).mul( y ) );
+	result = result.add( shCoefficients.element( 2 ).mul( 2.0 * 0.511664 ).mul( z ) );
+	result = result.add( shCoefficients.element( 3 ).mul( 2.0 * 0.511664 ).mul( x ) );
+
+	// band 2
+	result = result.add( shCoefficients.element( 4 ).mul( 2.0 * 0.429043 ).mul( x ).mul( y ) );
+	result = result.add( shCoefficients.element( 5 ).mul( 2.0 * 0.429043 ).mul( y ).mul( z ) );
+	result = result.add( shCoefficients.element( 6 ).mul( z.mul( z ).mul( 0.743125 ).sub( 0.247708 ) ) );
+	result = result.add( shCoefficients.element( 7 ).mul( 2.0 * 0.429043 ).mul( x ).mul( z ) );
+	result = result.add( shCoefficients.element( 8 ).mul( 0.429043 ).mul( mul( x, x ).sub( mul( y, y ) ) ) );
+
+	return result;
+
+} );
+
+export default getShIrradianceAt;

package/{examples/jsm → src}/nodes/geometry/RangeNode.js

@@ -1,17 +1,25 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { getValueType } from '../core/NodeUtils.js';
 import { buffer } from '../accessors/BufferNode.js';
-//import { bufferAttribute } from '../accessors/BufferAttributeNode.js';
+import { instancedBufferAttribute } from '../accessors/BufferAttributeNode.js';
 import { instanceIndex } from '../core/IndexNode.js';
-import { nodeProxy, float } from '../shadernode/ShaderNode.js';
+import { nodeProxy, float } from '../tsl/TSLBase.js';
 
-import { Vector4, MathUtils } from 'three';
+import { Vector4 } from '../../math/Vector4.js';
+import { MathUtils } from '../../math/MathUtils.js';
+import { InstancedBufferAttribute } from '../../core/InstancedBufferAttribute.js';
 
 let min = null;
 let max = null;
 
 class RangeNode extends Node {
 
+	static get type() {
+
+		return 'RangeNode';
+
+	}
+
 	constructor( minNode = float(), maxNode = float() ) {
 
 		super();
@@ -32,7 +40,7 @@ class RangeNode extends Node {
 
 	getNodeType( builder ) {
 
-		return builder.object.isInstancedMesh === true ? builder.getTypeFromLength( this.getVectorLength( builder ) ) : 'float';
+		return builder.object.count > 1 ? builder.getTypeFromLength( this.getVectorLength( builder ) ) : 'float';
 
 	}
 
@@ -42,7 +50,7 @@ class RangeNode extends Node {
 
 		let output = null;
 
-		if ( object.isInstancedMesh === true ) {
+		if ( object.count > 1 ) {
 
 			const minValue = this.minNode.value;
 			const maxValue = this.maxNode.value;
@@ -82,8 +90,19 @@ class RangeNode extends Node {
 
 			const nodeType = this.getNodeType( builder );
 
-			output = buffer( array, 'vec4', object.count ).element( instanceIndex ).convert( nodeType );
-			//output = bufferAttribute( array, 'vec4', 4, 0 ).convert( nodeType );
+			if ( object.count <= 4096 ) {
+
+				output = buffer( array, 'vec4', object.count ).element( instanceIndex ).convert( nodeType );
+
+			} else {
+
+				// TODO: Improve anonymous buffer attribute creation removing this part
+				const bufferAttribute = new InstancedBufferAttribute( array, 4 );
+				builder.geometry.setAttribute( '__range' + this.id, bufferAttribute );
+
+				output = instancedBufferAttribute( bufferAttribute ).convert( nodeType );
+
+			}
 
 		} else {
 
@@ -99,6 +118,4 @@ class RangeNode extends Node {
 
 export default RangeNode;
 
-export const range = nodeProxy( RangeNode );
-
-addNodeClass( 'RangeNode', RangeNode );
+export const range = /*@__PURE__*/ nodeProxy( RangeNode );

package/src/nodes/gpgpu/AtomicFunctionNode.js

@@ -0,0 +1,99 @@
+import TempNode from '../core/TempNode.js';
+import { nodeProxy } from '../tsl/TSLCore.js';
+
+class AtomicFunctionNode extends TempNode {
+
+	static get type() {
+
+		return 'AtomicFunctionNode';
+
+	}
+
+	constructor( method, pointerNode, valueNode, storeNode = null ) {
+
+		super( 'uint' );
+
+		this.method = method;
+
+		this.pointerNode = pointerNode;
+		this.valueNode = valueNode;
+		this.storeNode = storeNode;
+
+	}
+
+	getInputType( builder ) {
+
+		return this.pointerNode.getNodeType( builder );
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.getInputType( builder );
+
+	}
+
+	generate( builder ) {
+
+		const method = this.method;
+
+		const type = this.getNodeType( builder );
+		const inputType = this.getInputType( builder );
+
+		const a = this.pointerNode;
+		const b = this.valueNode;
+
+		const params = [];
+
+		params.push( `&${ a.build( builder, inputType ) }` );
+		params.push( b.build( builder, inputType ) );
+
+		const methodSnippet = `${ builder.getMethod( method, type ) }( ${params.join( ', ' )} )`;
+
+		if ( this.storeNode !== null ) {
+
+			const varSnippet = this.storeNode.build( builder, inputType );
+
+			builder.addLineFlowCode( `${varSnippet} = ${methodSnippet}`, this );
+
+		} else {
+
+			builder.addLineFlowCode( methodSnippet, this );
+
+		}
+
+	}
+
+}
+
+AtomicFunctionNode.ATOMIC_LOAD = 'atomicLoad';
+AtomicFunctionNode.ATOMIC_STORE = 'atomicStore';
+AtomicFunctionNode.ATOMIC_ADD = 'atomicAdd';
+AtomicFunctionNode.ATOMIC_SUB = 'atomicSub';
+AtomicFunctionNode.ATOMIC_MAX = 'atomicMax';
+AtomicFunctionNode.ATOMIC_MIN = 'atomicMin';
+AtomicFunctionNode.ATOMIC_AND = 'atomicAnd';
+AtomicFunctionNode.ATOMIC_OR = 'atomicOr';
+AtomicFunctionNode.ATOMIC_XOR = 'atomicXor';
+
+export default AtomicFunctionNode;
+
+const atomicNode = nodeProxy( AtomicFunctionNode );
+
+export const atomicFunc = ( method, pointerNode, valueNode, storeNode ) => {
+
+	const node = atomicNode( method, pointerNode, valueNode, storeNode );
+	node.append();
+
+	return node;
+
+};
+
+export const atomicStore = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_STORE, pointerNode, valueNode, storeNode );
+export const atomicAdd = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_ADD, pointerNode, valueNode, storeNode );
+export const atomicSub = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_SUB, pointerNode, valueNode, storeNode );
+export const atomicMax = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_MAX, pointerNode, valueNode, storeNode );
+export const atomicMin = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_MIN, pointerNode, valueNode, storeNode );
+export const atomicAnd = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_AND, pointerNode, valueNode, storeNode );
+export const atomicOr = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_OR, pointerNode, valueNode, storeNode );
+export const atomicXor = ( pointerNode, valueNode, storeNode = null ) => atomicFunc( AtomicFunctionNode.ATOMIC_XOR, pointerNode, valueNode, storeNode );

package/src/nodes/gpgpu/BarrierNode.js

@@ -0,0 +1,40 @@
+import Node from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLCore.js';
+
+class BarrierNode extends Node {
+
+	constructor( scope ) {
+
+		super();
+
+		this.scope = scope;
+
+	}
+
+	generate( builder ) {
+
+		const { scope } = this;
+		const { renderer } = builder;
+
+		if ( renderer.backend.isWebGLBackend === true ) {
+
+			builder.addFlowCode( `\t// ${scope}Barrier \n` );
+
+		} else {
+
+			builder.addLineFlowCode( `${scope}Barrier()`, this );
+
+		}
+
+	}
+
+}
+
+export default BarrierNode;
+
+const barrier = nodeProxy( BarrierNode );
+
+export const workgroupBarrier = () => barrier( 'workgroup' ).append();
+export const storageBarrier = () => barrier( 'storage' ).append();
+export const textureBarrier = () => barrier( 'texture' ).append();
+

package/src/nodes/gpgpu/ComputeBuiltinNode.js

@@ -0,0 +1,98 @@
+import Node from '../core/Node.js';
+import { nodeObject } from '../tsl/TSLBase.js';
+
+class ComputeBuiltinNode extends Node {
+
+	static get type() {
+
+		return 'ComputeBuiltinNode';
+
+	}
+
+	constructor( builtinName, nodeType ) {
+
+		super( nodeType );
+
+		this._builtinName = builtinName;
+
+	}
+
+	getHash( builder ) {
+
+		return this.getBuiltinName( builder );
+
+	}
+
+	getNodeType( /*builder*/ ) {
+
+		return this.nodeType;
+
+	}
+
+	setBuiltinName( builtinName ) {
+
+		this._builtinName = builtinName;
+
+		return this;
+
+	}
+
+	getBuiltinName( /*builder*/ ) {
+
+		return this._builtinName;
+
+	}
+
+	hasBuiltin( builder ) {
+
+		builder.hasBuiltin( this._builtinName );
+
+	}
+
+	generate( builder, output ) {
+
+		const builtinName = this.getBuiltinName( builder );
+		const nodeType = this.getNodeType( builder );
+
+		if ( builder.shaderStage === 'compute' ) {
+
+			return builder.format( builtinName, nodeType, output );
+
+		} else {
+
+			console.warn( `ComputeBuiltinNode: Compute built-in value ${builtinName} can not be accessed in the ${builder.shaderStage} stage` );
+			return builder.generateConst( nodeType );
+
+		}
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.global = this.global;
+		data._builtinName = this._builtinName;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.global = data.global;
+		this._builtinName = data._builtinName;
+
+	}
+
+}
+
+export default ComputeBuiltinNode;
+
+const computeBuiltin = ( name, nodeType ) => nodeObject( new ComputeBuiltinNode( name, nodeType ) );
+
+export const numWorkgroups = /*@__PURE__*/ computeBuiltin( 'numWorkgroups', 'uvec3' );
+export const workgroupId = /*@__PURE__*/ computeBuiltin( 'workgroupId', 'uvec3' );
+export const localId = /*@__PURE__*/ computeBuiltin( 'localId', 'uvec3' );
+export const subgroupSize = /*@__PURE__*/ computeBuiltin( 'subgroupSize', 'uint' );
+

package/{examples/jsm → src}/nodes/gpgpu/ComputeNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { addNodeElement, nodeObject } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
 
 class ComputeNode extends Node {
 
+	static get type() {
+
+		return 'ComputeNode';
+
+	}
+
 	constructor( computeNode, count, workgroupSize = [ 64 ] ) {
 
 		super( 'void' );
@@ -66,7 +72,7 @@ class ComputeNode extends Node {
 
 			if ( snippet !== '' ) {
 
-				builder.addLineFlowCode( snippet );
+				builder.addLineFlowCode( snippet, this );
 
 			}
 
@@ -80,6 +86,4 @@ export default ComputeNode;
 
 export const compute = ( node, count, workgroupSize ) => nodeObject( new ComputeNode( nodeObject( node ), count, workgroupSize ) );
 
-addNodeElement( 'compute', compute );
-
-addNodeClass( 'ComputeNode', ComputeNode );
+addMethodChaining( 'compute', compute );

package/src/nodes/gpgpu/WorkgroupInfoNode.js

@@ -0,0 +1,100 @@
+import ArrayElementNode from '../utils/ArrayElementNode.js';
+import { nodeObject } from '../tsl/TSLCore.js';
+import Node from '../core/Node.js';
+
+class WorkgroupInfoElementNode extends ArrayElementNode {
+
+	constructor( workgroupInfoNode, indexNode ) {
+
+		super( workgroupInfoNode, indexNode );
+
+		this.isWorkgroupInfoElementNode = true;
+
+	}
+
+	generate( builder, output ) {
+
+		let snippet;
+
+		const isAssignContext = builder.context.assign;
+		snippet = super.generate( builder );
+
+		if ( isAssignContext !== true ) {
+
+			const type = this.getNodeType( builder );
+
+			snippet = builder.format( snippet, type, output );
+
+		}
+
+		// TODO: Possibly activate clip distance index on index access rather than from clipping context
+
+		return snippet;
+
+	}
+
+}
+
+
+class WorkgroupInfoNode extends Node {
+
+	constructor( scope, bufferType, bufferCount = 0 ) {
+
+		super( bufferType );
+
+		this.bufferType = bufferType;
+		this.bufferCount = bufferCount;
+
+		this.isWorkgroupInfoNode = true;
+
+		this.scope = scope;
+
+	}
+
+	label( name ) {
+
+		this.name = name;
+
+		return this;
+
+	}
+
+	getHash() {
+
+		return this.uuid;
+
+	}
+
+	setScope( scope ) {
+
+		this.scope = scope;
+
+		return this;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return `${this.scope}Array`;
+
+	}
+
+	element( indexNode ) {
+
+		return nodeObject( new WorkgroupInfoElementNode( this, indexNode ) );
+
+	}
+
+	generate( builder ) {
+
+		return builder.getScopedArray( this.name || `${this.scope}Array_${this.id}`, this.scope.toLowerCase(), this.bufferType, this.bufferCount );
+
+	}
+
+}
+
+export default WorkgroupInfoNode;
+
+export const workgroupArray = ( type, count ) => nodeObject( new WorkgroupInfoNode( 'Workgroup', type, count ) );
+
+

package/src/nodes/lighting/AONode.js

@@ -0,0 +1,27 @@
+import LightingNode from './LightingNode.js';
+
+class AONode extends LightingNode {
+
+	static get type() {
+
+		return 'AONode';
+
+	}
+
+	constructor( aoNode = null ) {
+
+		super();
+
+		this.aoNode = aoNode;
+
+	}
+
+	setup( builder ) {
+
+		builder.context.ambientOcclusion.mulAssign( this.aoNode );
+
+	}
+
+}
+
+export default AONode;

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

@@ -1,11 +1,13 @@
 import AnalyticLightNode from './AnalyticLightNode.js';
-import { addLightNode } from './LightsNode.js';
-import { addNodeClass } from '../core/Node.js';
-
-import { AmbientLight } from 'three';
 
 class AmbientLightNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'AmbientLightNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super( light );
@@ -21,7 +23,3 @@ class AmbientLightNode extends AnalyticLightNode {
 }
 
 export default AmbientLightNode;
-
-addNodeClass( 'AmbientLightNode', AmbientLightNode );
-
-addLightNode( AmbientLight, AmbientLightNode );