super-three 0.136.1 → 0.144.0

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

@@ -0,0 +1,21 @@
+import BufferNode from './BufferNode.js';
+
+class StorageBufferNode extends BufferNode {
+
+	constructor( value, bufferType, bufferCount = 0 ) {
+
+		super( value, bufferType, bufferCount );
+
+		this.isStorageBufferNode = true;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return 'storageBuffer';
+
+	}
+
+}
+
+export default StorageBufferNode;

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

@@ -0,0 +1,100 @@
+import UniformNode from '../core/UniformNode.js';
+import UVNode from './UVNode.js';
+
+class TextureNode extends UniformNode {
+
+	constructor( value, uvNode = new UVNode(), levelNode = null ) {
+
+		super( value, 'vec4' );
+
+		this.isTextureNode = true;
+
+		this.uvNode = uvNode;
+		this.levelNode = levelNode;
+
+	}
+
+	getUniformHash( /*builder*/ ) {
+
+		return this.value.uuid;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return 'texture';
+
+	}
+
+	generate( builder, output ) {
+
+		const texture = this.value;
+
+		if ( ! texture || texture.isTexture !== true ) {
+
+			throw new Error( 'TextureNode: Need a three.js texture.' );
+
+		}
+
+		const textureProperty = super.generate( builder, 'texture' );
+
+		if ( output === 'sampler' ) {
+
+			return textureProperty + '_sampler';
+
+		} else if ( builder.isReference( output ) ) {
+
+			return textureProperty;
+
+		} else {
+
+			const nodeData = builder.getDataFromNode( this );
+
+			let snippet = nodeData.snippet;
+
+			if ( snippet === undefined ) {
+
+				const uvSnippet = this.uvNode.build( builder, 'vec2' );
+				const levelNode = this.levelNode;
+
+				if ( levelNode !== null ) {
+
+					const levelSnippet = levelNode.build( builder, 'float' );
+
+					snippet = builder.getTextureLevel( textureProperty, uvSnippet, levelSnippet );
+
+				} else {
+
+					snippet = builder.getTexture( textureProperty, uvSnippet );
+
+				}
+
+				nodeData.snippet = snippet;
+
+			}
+
+			return builder.format( snippet, 'vec4', output );
+
+		}
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.value = this.value.toJSON( data.meta ).uuid;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.value = data.meta.textures[ data.value ];
+
+	}
+
+}
+
+export default TextureNode;

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

@@ -1,67 +1,41 @@
-import { TempNode } from '../core/TempNode.js';
-import { NodeLib } from '../core/NodeLib.js';
+import AttributeNode from '../core/AttributeNode.js';
 
-class UVNode extends TempNode {
+class UVNode extends AttributeNode {
 
-	constructor( index ) {
+	constructor( index = 0 ) {
 
-		super( 'v2', { shared: false } );
+		super( null, 'vec2' );
 
-		this.index = index || 0;
+		this.isUVNode = true;
 
-	}
-
-	generate( builder, output ) {
-
-		builder.requires.uv[ this.index ] = true;
-
-		const uvIndex = this.index > 0 ? this.index + 1 : '';
-		const result = builder.isShader( 'vertex' ) ? 'uv' + uvIndex : 'vUv' + uvIndex;
-
-		return builder.format( result, this.getType( builder ), output );
+		this.index = index;
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
+	getAttributeName( /*builder*/ ) {
 
-		this.index = source.index;
+		const index = this.index;
 
-		return this;
+		return 'uv' + ( index > 0 ? index + 1 : '' );
 
 	}
 
-	toJSON( meta ) {
+	serialize( data ) {
 
-		let data = this.getJSONNode( meta );
+		super.serialize( data );
 
-		if ( ! data ) {
+		data.index = this.index;
 
-			data = this.createJSONNode( meta );
+	}
 
-			data.index = this.index;
+	deserialize( data ) {
 
-		}
+		super.deserialize( data );
 
-		return data;
+		this.index = data.index;
 
 	}
 
 }
 
-UVNode.prototype.nodeType = 'UV';
-
-NodeLib.addKeyword( 'uv', function () {
-
-	return new UVNode();
-
-} );
-
-NodeLib.addKeyword( 'uv2', function () {
-
-	return new UVNode( 1 );
-
-} );
-
-export { UVNode };
+export default UVNode;

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

@@ -0,0 +1,23 @@
+import ReferenceNode from './ReferenceNode.js';
+
+class UserDataNode extends ReferenceNode {
+
+	constructor( property, inputType, userData = null ) {
+
+		super( property, inputType, userData );
+
+		this.userData = userData;
+
+	}
+
+	update( frame ) {
+
+		this.object = this.userData !== null ? this.userData : frame.object.userData;
+
+		super.update( frame );
+
+	}
+
+}
+
+export default UserDataNode;

package/examples/jsm/nodes/core/ArrayUniformNode.js

@@ -0,0 +1,23 @@
+import UniformNode from './UniformNode.js';
+
+class ArrayUniformNode extends UniformNode {
+
+	constructor( nodes = [] ) {
+
+		super();
+
+		this.isArrayUniformNode = true;
+
+		this.nodes = nodes;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.nodes[ 0 ].getNodeType( builder );
+
+	}
+
+}
+
+export default ArrayUniformNode;

package/examples/jsm/nodes/core/AttributeNode.js

@@ -1,68 +1,71 @@
-import { Node } from './Node.js';
+import Node from './Node.js';
+import VaryingNode from './VaryingNode.js';
 
 class AttributeNode extends Node {
 
-	constructor( name, type ) {
+	constructor( attributeName, nodeType = null ) {
 
-		super( type );
+		super( nodeType );
 
-		this.name = name;
+		this._attributeName = attributeName;
 
 	}
 
-	getAttributeType( builder ) {
+	getHash( builder ) {
 
-		return typeof this.type === 'number' ? builder.getConstructorFromLength( this.type ) : this.type;
+		return this.getAttributeName( builder );
 
 	}
 
-	getType( builder ) {
+	getNodeType( builder ) {
 
-		const type = this.getAttributeType( builder );
+		let nodeType = super.getNodeType( builder );
 
-		return builder.getTypeByFormat( type );
+		if ( nodeType === null ) {
 
-	}
-
-	generate( builder, output ) {
+			const attributeName = this.getAttributeName( builder );
+			const attribute = builder.geometry.getAttribute( attributeName );
 
-		const type = this.getAttributeType( builder );
+			nodeType = builder.getTypeFromLength( attribute.itemSize );
 
-		const attribute = builder.getAttribute( this.name, type ),
-			name = builder.isShader( 'vertex' ) ? this.name : attribute.varying.name;
+		}
 
-		return builder.format( name, this.getType( builder ), output );
+		return nodeType;
 
 	}
 
-	copy( source ) {
+	setAttributeName( attributeName ) {
 
-		super.copy( source );
-
-		this.type = source.type;
+		this._attributeName = attributeName;
 
 		return this;
 
 	}
 
-	toJSON( meta ) {
+	getAttributeName( /*builder*/ ) {
 
-		let data = this.getJSONNode( meta );
+		return this._attributeName;
 
-		if ( ! data ) {
+	}
 
-			data = this.createJSONNode( meta );
+	generate( builder ) {
 
-			data.type = this.type;
+		const attribute = builder.getAttribute( this.getAttributeName( builder ), this.getNodeType( builder ) );
 
-		}
+		if ( builder.isShaderStage( 'vertex' ) ) {
 
-		return data;
+			return attribute.name;
+
+		} else {
+
+			const nodeVarying = new VaryingNode( this );
+
+			return nodeVarying.build( builder, attribute.type );
+
+		}
 
 	}
 
 }
 
-AttributeNode.prototype.nodeType = 'Attribute';
-
-export { AttributeNode };
+export default AttributeNode;

package/examples/jsm/{renderers/nodes → nodes}/core/BypassNode.js

@@ -6,6 +6,8 @@ class BypassNode extends Node {
 
 		super();
 
+		this.isBypassNode = true;
+
 		this.outputNode = returnNode;
 		this.callNode = callNode;
 
@@ -33,6 +35,4 @@ class BypassNode extends Node {
 
 }
 
-BypassNode.prototype.isBypassNode = true;
-
 export default BypassNode;

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

@@ -0,0 +1,50 @@
+import Node from './Node.js';
+
+class CodeNode extends Node {
+
+	constructor( code = '', includes = [] ) {
+
+		super( 'code' );
+
+		this.isCodeNode = true;
+
+		this.code = code;
+
+		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;
+
+	}
+
+}
+
+export default CodeNode;

package/examples/jsm/nodes/core/ConstNode.js

@@ -1,125 +1,29 @@
-import { TempNode } from './TempNode.js';
+import InputNode from './InputNode.js';
 
-const declarationRegexp = /^([a-z_0-9]+)\s([a-z_0-9]+)\s?\=?\s?(.*?)(\;|$)/i;
+class ConstNode extends InputNode {
 
-class ConstNode extends TempNode {
+	constructor( value, nodeType = null ) {
 
-	constructor( src, useDefine ) {
+		super( value, nodeType );
 
-		super();
-
-		this.parse( src || ConstNode.PI, useDefine );
-
-	}
-
-	getType( builder ) {
-
-		return builder.getTypeByFormat( this.type );
+		this.isConstNode = true;
 
 	}
 
-	parse( src, useDefine ) {
-
-		this.src = src || '';
-
-		let name, type, value = '';
-
-		const match = this.src.match( declarationRegexp );
-
-		this.useDefine = useDefine || this.src.charAt( 0 ) === '#';
-
-		if ( match && match.length > 1 ) {
-
-			type = match[ 1 ];
-			name = match[ 2 ];
-			value = match[ 3 ];
-
-		} else {
+	generateConst( builder ) {
 
-			name = this.src;
-			type = 'f';
-
-		}
-
-		this.name = name;
-		this.type = type;
-		this.value = value;
-
-	}
-
-	build( builder, output ) {
-
-		if ( output === 'source' ) {
-
-			if ( this.value ) {
-
-				if ( this.useDefine ) {
-
-					return '#define ' + this.name + ' ' + this.value;
-
-				}
-
-				return 'const ' + this.type + ' ' + this.name + ' = ' + this.value + ';';
-
-			} else if ( this.useDefine ) {
-
-				return this.src;
-
-			}
-
-		} else {
-
-			builder.include( this );
-
-			return builder.format( this.name, this.getType( builder ), output );
-
-		}
+		return builder.getConst( this.getNodeType( builder ), this.value );
 
 	}
 
 	generate( builder, output ) {
 
-		return builder.format( this.name, this.getType( builder ), output );
+		const type = this.getNodeType( builder );
 
-	}
-
-	copy( source ) {
-
-		super.copy( source );
-
-		this.parse( source.src, source.useDefine );
-
-		return this;
-
-	}
-
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.src = this.src;
-
-			if ( data.useDefine === true ) data.useDefine = true;
-
-		}
-
-		return data;
+		return builder.format( this.generateConst( builder ), type, output );
 
 	}
 
 }
 
-ConstNode.prototype.nodeType = 'Const';
-
-ConstNode.PI = 'PI';
-ConstNode.PI2 = 'PI2';
-ConstNode.RECIPROCAL_PI = 'RECIPROCAL_PI';
-ConstNode.RECIPROCAL_PI2 = 'RECIPROCAL_PI2';
-ConstNode.LOG2 = 'LOG2';
-ConstNode.EPSILON = 'EPSILON';
-
-export { ConstNode };
+export default ConstNode;

package/examples/jsm/{renderers/nodes → nodes}/core/ContextNode.js

@@ -6,6 +6,8 @@ class ContextNode extends Node {
 
 		super();
 
+		this.isContextNode = true;
+
 		this.node = node;
 		this.context = context;
 
@@ -17,11 +19,25 @@ class ContextNode extends Node {
 
 	}
 
+	construct( builder ) {
+
+		const previousContext = builder.getContext();
+
+		builder.setContext( { ...builder.context, ...this.context } );
+
+		const node = this.node.build( builder );
+
+		builder.setContext( previousContext );
+
+		return node;
+
+	}
+
 	generate( builder, output ) {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( Object.assign( {}, builder.context, this.context ) );
+		builder.setContext( { ...builder.context, ...this.context } );
 
 		const snippet = this.node.build( builder, output );
 
@@ -33,6 +49,4 @@ class ContextNode extends Node {
 
 }
 
-ContextNode.prototype.isContextNode = true;
-
 export default ContextNode;

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

@@ -1,15 +1,32 @@
-import { FunctionNode } from './FunctionNode.js';
+import TempNode from './TempNode.js';
 
-class ExpressionNode extends FunctionNode {
+class ExpressionNode extends TempNode {
 
-	constructor( src, type, keywords, extensions, includes ) {
+	constructor( snipped = '', nodeType = 'void' ) {
 
-		super( src, includes, extensions, keywords, type );
+		super( nodeType );
+
+		this.snipped = snipped;
 
 	}
 
-}
+	generate( builder ) {
+
+		const type = this.getNodeType( builder );
+		const snipped = this.snipped;
+
+		if ( type === 'void' ) {
+
+			builder.addFlowCode( snipped );
+
+		} else {
 
-ExpressionNode.prototype.nodeType = 'Expression';
+			return `( ${ snipped } )`;
+
+		}
+
+	}
+
+}
 
-export { ExpressionNode };
+export default ExpressionNode;