@needle-tools/three 0.146.10 → 0.153.1

package/examples/jsm/nodes/accessors/TextureNode.js

@@ -1,11 +1,15 @@
 import UniformNode from '../core/UniformNode.js';
-import UVNode from './UVNode.js';
+import { uv } from './UVNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+let defaultUV;
 
 class TextureNode extends UniformNode {
 
-	constructor( value, uvNode = new UVNode(), levelNode = null ) {
+	constructor( value, uvNode = null, levelNode = null ) {
 
-		super( value, 'vec4' );
+		super( value );
 
 		this.isTextureNode = true;
 
@@ -20,14 +24,63 @@ class TextureNode extends UniformNode {
 
 	}
 
+	getNodeType( /*builder*/ ) {
+
+		if ( this.value.isDepthTexture === true ) return 'float';
+
+		return 'vec4';
+
+	}
+
 	getInputType( /*builder*/ ) {
 
 		return 'texture';
 
 	}
 
+	getDefaultUV() {
+
+		return defaultUV || ( defaultUV = uv() );
+
+	}
+
+	construct( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		//
+
+		let uvNode = this.uvNode;
+
+		if ( uvNode === null && builder.context.getUVNode ) {
+
+			uvNode = builder.context.getUVNode( this );
+
+		}
+
+		uvNode || ( uvNode = this.getDefaultUV() );
+
+		//
+
+		let levelNode = this.levelNode;
+
+		if ( levelNode === null && builder.context.getSamplerLevelNode ) {
+
+			levelNode = builder.context.getSamplerLevelNode( this );
+
+		}
+
+		//
+
+		properties.uvNode = uvNode;
+		properties.levelNode = levelNode ? builder.context.getMIPLevelAlgorithmNode( this, levelNode ) : null;
+
+	}
+
 	generate( builder, output ) {
 
+		const { uvNode, levelNode } = builder.getNodeProperties( this );
+
 		const texture = this.value;
 
 		if ( ! texture || texture.isTexture !== true ) {
@@ -36,7 +89,7 @@ class TextureNode extends UniformNode {
 
 		}
 
-		const textureProperty = super.generate( builder, 'texture' );
+		const textureProperty = super.generate( builder, 'property' );
 
 		if ( output === 'sampler' ) {
 
@@ -48,32 +101,40 @@ class TextureNode extends UniformNode {
 
 		} else {
 
+			const nodeType = this.getNodeType( builder );
 			const nodeData = builder.getDataFromNode( this );
 
-			let snippet = nodeData.snippet;
+			let propertyName = nodeData.propertyName;
+
+			if ( propertyName === undefined ) {
+
+				const uvSnippet = uvNode.build( builder, 'vec2' );
+				const nodeVar = builder.getVarFromNode( this, nodeType );
 
-			if ( snippet === undefined ) {
+				propertyName = builder.getPropertyName( nodeVar );
 
-				const uvSnippet = this.uvNode.build( builder, 'vec2' );
-				const levelNode = this.levelNode;
+				let snippet = null;
 
-				if ( levelNode !== null ) {
+				if ( levelNode && levelNode.isNode === true ) {
 
 					const levelSnippet = levelNode.build( builder, 'float' );
 
-					snippet = builder.getTextureLevel( textureProperty, uvSnippet, levelSnippet );
+					snippet = builder.getTextureLevel( texture, textureProperty, uvSnippet, levelSnippet );
 
 				} else {
 
-					snippet = builder.getTexture( textureProperty, uvSnippet );
+					snippet = builder.getTexture( texture, textureProperty, uvSnippet );
 
 				}
 
+				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+
 				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
 			}
 
-			return builder.format( snippet, 'vec4', output );
+			return builder.format( propertyName, nodeType, output );
 
 		}
 
@@ -98,3 +159,10 @@ class TextureNode extends UniformNode {
 }
 
 export default TextureNode;
+
+export const texture = nodeProxy( TextureNode );
+export const sampler = ( aTexture ) => ( aTexture.isNode === true ? aTexture : texture( aTexture ) ).convert( 'sampler' );
+
+addNodeElement( 'texture', texture );
+
+addNodeClass( TextureNode );

package/examples/jsm/nodes/accessors/UVNode.js

@@ -1,4 +1,6 @@
+import { addNodeClass } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class UVNode extends AttributeNode {
 
@@ -39,3 +41,7 @@ class UVNode extends AttributeNode {
 }
 
 export default UVNode;
+
+export const uv = ( ...params ) => nodeObject( new UVNode( ...params ) );
+
+addNodeClass( UVNode );

package/examples/jsm/nodes/accessors/UserDataNode.js

@@ -1,4 +1,6 @@
 import ReferenceNode from './ReferenceNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class UserDataNode extends ReferenceNode {
 
@@ -21,3 +23,7 @@ class UserDataNode extends ReferenceNode {
 }
 
 export default UserDataNode;
+
+export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );
+
+addNodeClass( UserDataNode );

package/examples/jsm/nodes/code/CodeNode.js

@@ -0,0 +1,75 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+
+class CodeNode extends Node {
+
+	constructor( code = '', includes = [], language = '' ) {
+
+		super( 'code' );
+
+		this.isCodeNode = true;
+
+		this.code = code;
+		this.language = language;
+
+		this._includes = includes;
+
+	}
+
+	setIncludes( includes ) {
+
+		this._includes = includes;
+
+		return this;
+
+	}
+
+	getIncludes( /*builder*/ ) {
+
+		return this._includes;
+
+	}
+
+	generate( builder ) {
+
+		const includes = this.getIncludes( builder );
+
+		for ( const include of includes ) {
+
+			include.build( builder );
+
+		}
+
+		const nodeCode = builder.getCodeFromNode( this, this.getNodeType( builder ) );
+		nodeCode.code = this.code;
+
+		return nodeCode.code;
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.code = this.code;
+		data.language = this.language;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.code = data.code;
+		this.language = data.language;
+
+	}
+
+}
+
+export default CodeNode;
+
+export const code = nodeProxy( CodeNode );
+export const js = ( src, includes ) => code( src, includes, 'js' );
+
+addNodeClass( CodeNode );

package/examples/jsm/nodes/code/ExpressionNode.js

@@ -0,0 +1,37 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+
+class ExpressionNode extends Node {
+
+	constructor( snippet = '', nodeType = 'void' ) {
+
+		super( nodeType );
+
+		this.snippet = snippet;
+
+	}
+
+	generate( builder, output ) {
+
+		const type = this.getNodeType( builder );
+		const snippet = this.snippet;
+
+		if ( type === 'void' ) {
+
+			builder.addLineFlowCode( snippet );
+
+		} else {
+
+			return builder.format( `( ${ snippet } )`, type, output );
+
+		}
+
+	}
+
+}
+
+export default ExpressionNode;
+
+export const expression = nodeProxy( ExpressionNode );
+
+addNodeClass( ExpressionNode );

package/examples/jsm/nodes/{core → code}/FunctionCallNode.js

@@ -1,4 +1,6 @@
-import TempNode from './TempNode.js';
+import TempNode from '../core/TempNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeArray, nodeObject, nodeObjects } from '../shadernode/ShaderNode.js';
 
 class FunctionCallNode extends TempNode {
 
@@ -80,3 +82,15 @@ class FunctionCallNode extends TempNode {
 }
 
 export default FunctionCallNode;
+
+export const call = ( func, ...params ) => {
+
+	params = params.length > 1 || ( params[ 0 ] && params[ 0 ].isNode === true ) ? nodeArray( params ) : nodeObjects( params[ 0 ] );
+
+	return nodeObject( new FunctionCallNode( nodeObject( func ), params ) );
+
+};
+
+addNodeElement( 'call', call );
+
+addNodeClass( FunctionCallNode );

package/examples/jsm/nodes/{core → code}/FunctionNode.js

@@ -1,5 +1,6 @@
 import CodeNode from './CodeNode.js';
-import FunctionCallNode from './FunctionCallNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class FunctionNode extends CodeNode {
 
@@ -41,12 +42,6 @@ class FunctionNode extends CodeNode {
 
 	}
 
-	call( parameters = {} ) {
-
-		return new FunctionCallNode( this, parameters );
-
-	}
-
 	generate( builder, output ) {
 
 		super.generate( builder );
@@ -103,3 +98,9 @@ class FunctionNode extends CodeNode {
 }
 
 export default FunctionNode;
+
+export const func = ( code, includes ) => nodeObject( new FunctionNode( code, includes ) );
+
+export const fn = ( code, includes ) => func( code, includes ).call;
+
+addNodeClass( FunctionNode );