super-three 0.164.0 → 0.167.0

package/{examples/jsm → src}/nodes/accessors/UniformsNode.js

@@ -118,8 +118,14 @@ class UniformsNode extends BufferNode {
 		this._elementType = this.elementType === null ? getValueType( this.array[ 0 ] ) : this.elementType;
 		this._elementLength = builder.getTypeLength( this._elementType );
 
-		this.value = new Float32Array( length * 4 );
+		let arrayType = Float32Array;
+
+		if ( this._elementType.charAt( 0 ) === 'i' ) arrayType = Int32Array;
+		else if ( this._elementType.charAt( 0 ) === 'u' ) arrayType = Uint32Array;
+
+		this.value = new arrayType( length * 4 );
 		this.bufferCount = length;
+		this.bufferType = builder.changeComponentType( 'vec4', builder.getComponentType( this._elementType ) );
 
 		return super.setup( builder );
 

package/{examples/jsm → src}/nodes/accessors/VertexColorNode.js

@@ -1,7 +1,8 @@
 import { addNodeClass } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
 import { nodeObject } from '../shadernode/ShaderNode.js';
-import { Vector4 } from 'three';
+
+import { Vector4 } from '../../math/Vector4.js';
 
 class VertexColorNode extends AttributeNode {
 

package/{examples/jsm → src}/nodes/code/ScriptableNode.js

@@ -437,6 +437,20 @@ class ScriptableNode extends Node {
 
 	}
 
+	getCacheKey( force ) {
+
+		const cacheKey = [ this.source, this.getDefaultOutputNode().getCacheKey( force ) ];
+
+		for ( const param in this.parameters ) {
+
+			cacheKey.push( this.parameters[ param ].getCacheKey( force ) );
+
+		}
+
+		return cacheKey.join( ',' );
+
+	}
+
 	set needsUpdate( value ) {
 
 		if ( value === true ) this.dispose();

package/{examples/jsm → src}/nodes/code/ScriptableValueNode.js

@@ -1,7 +1,8 @@
 import Node, { addNodeClass } from '../core/Node.js';
 import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
 import { addNodeElement, nodeProxy, float } from '../shadernode/ShaderNode.js';
-import { EventDispatcher } from 'three';
+
+import { EventDispatcher } from '../../core/EventDispatcher.js';
 
 class ScriptableValueNode extends Node {
 

package/{examples/jsm → src}/nodes/core/AttributeNode.js

@@ -4,17 +4,15 @@ import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class AttributeNode extends Node {
 
-	constructor( attributeName, nodeType = null ) {
+	constructor( attributeName, nodeType = null, defaultNode = null ) {
 
 		super( nodeType );
 
-		this._attributeName = attributeName;
-
-	}
+		this.defaultNode = defaultNode;
 
-	isGlobal() {
+		this.global = true;
 
-		return true;
+		this._attributeName = attributeName;
 
 	}
 
@@ -93,16 +91,44 @@ class AttributeNode extends Node {
 
 			console.warn( `AttributeNode: Vertex attribute "${ attributeName }" not found on geometry.` );
 
-			return builder.generateConst( nodeType );
+			const { defaultNode } = this;
+
+			if ( defaultNode !== null ) {
+
+				return defaultNode.build( builder, nodeType );
+
+			} else {
+
+				return builder.generateConst( nodeType );
+
+			}
 
 		}
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.global = this.global;
+		data._attributeName = this._attributeName;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.global = data.global;
+		this._attributeName = data._attributeName;
+
+	}
+
 }
 
 export default AttributeNode;
 
-export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
+export const attribute = ( name, nodeType, defaultNode ) => nodeObject( new AttributeNode( name, nodeType, nodeObject( defaultNode ) ) );
 
 addNodeClass( 'AttributeNode', AttributeNode );

package/{examples/jsm → src}/nodes/core/CacheNode.js

@@ -1,17 +1,16 @@
 import Node, { addNodeClass } from './Node.js';
-import NodeCache from './NodeCache.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { addNodeElement, nodeObject } from '../shadernode/ShaderNode.js';
 
 class CacheNode extends Node {
 
-	constructor( node, cache = new NodeCache() ) {
+	constructor( node, parent = true ) {
 
 		super();
 
-		this.isCacheNode = true;
-
 		this.node = node;
-		this.cache = cache;
+		this.parent = parent;
+
+		this.isCacheNode = true;
 
 	}
 
@@ -24,7 +23,7 @@ class CacheNode extends Node {
 	build( builder, ...params ) {
 
 		const previousCache = builder.getCache();
-		const cache = this.cache || builder.globalCache;
+		const cache = builder.getCacheFromNode( this, parent );
 
 		builder.setCache( cache );
 
@@ -40,10 +39,8 @@ class CacheNode extends Node {
 
 export default CacheNode;
 
-export const cache = nodeProxy( CacheNode );
-export const globalCache = ( node ) => cache( node, null );
+export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
 
 addNodeElement( 'cache', cache );
-addNodeElement( 'globalCache', globalCache );
 
 addNodeClass( 'CacheNode', CacheNode );

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

@@ -20,6 +20,12 @@ class ContextNode extends Node {
 
 	}
 
+	analyze( builder ) {
+
+		this.node.build( builder );
+
+	}
+
 	setup( builder ) {
 
 		const previousContext = builder.getContext();

package/{examples/jsm → src}/nodes/core/IndexNode.js

@@ -29,6 +29,10 @@ class IndexNode extends Node {
 
 			propertyName = builder.getInstanceIndex();
 
+		} else if ( scope === IndexNode.DRAW ) {
+
+			propertyName = builder.getDrawIndex();
+
 		} else {
 
 			throw new Error( 'THREE.IndexNode: Unknown scope: ' + scope );
@@ -57,10 +61,12 @@ class IndexNode extends Node {
 
 IndexNode.VERTEX = 'vertex';
 IndexNode.INSTANCE = 'instance';
+IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
 export const vertexIndex = nodeImmutable( IndexNode, IndexNode.VERTEX );
 export const instanceIndex = nodeImmutable( IndexNode, IndexNode.INSTANCE );
+export const drawIndex = nodeImmutable( IndexNode, IndexNode.DRAW );
 
 addNodeClass( 'IndexNode', IndexNode );

package/{examples/jsm → src}/nodes/core/LightingModel.js

@@ -6,9 +6,9 @@ class LightingModel {
 
 	direct( /*input, stack, builder*/ ) { }
 
-	indirectDiffuse( /*input, stack, builder*/ ) { }
+	directRectArea( /*input, stack, builder*/ ) {}
 
-	indirectSpecular( /*input, stack, builder*/ ) { }
+	indirect( /*input, stack, builder*/ ) { }
 
 	ambientOcclusion( /*input, stack, builder*/ ) { }
 

package/src/nodes/core/MRTNode.js

@@ -0,0 +1,76 @@
+import { addNodeClass } from './Node.js';
+import OutputStructNode from './OutputStructNode.js';
+import { nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
+
+function getTextureIndex( textures, name ) {
+
+	for ( let i = 0; i < textures.length; i ++ ) {
+
+		if ( textures[ i ].name === name ) {
+
+			return i;
+
+		}
+
+	}
+
+	return - 1;
+
+}
+
+class MRTNode extends OutputStructNode {
+
+	constructor( outputNodes ) {
+
+		super();
+
+		this.outputNodes = outputNodes;
+
+		this.isMRTNode = true;
+
+	}
+
+	getNode( name ) {
+
+		return this.outputNodes[ name ];
+
+	}
+
+	merge( mrtNode ) {
+
+		const outputs = { ...this.outputNodes, ...mrtNode.outputNodes };
+
+		return mrt( outputs );
+
+	}
+
+	setup( builder ) {
+
+		const outputNodes = this.outputNodes;
+		const mrt = builder.renderer.getRenderTarget();
+
+		const members = [];
+
+		const textures = mrt.textures;
+
+		for ( const name in outputNodes ) {
+
+			const index = getTextureIndex( textures, name );
+
+			members[ index ] = vec4( outputNodes[ name ] );
+
+		}
+
+		this.members = members;
+
+		return super.setup( builder );
+
+	}
+
+}
+
+export default MRTNode;
+
+export const mrt = nodeProxy( MRTNode );
+
+addNodeClass( 'MRTNode', MRTNode );

package/{examples/jsm → src}/nodes/core/Node.js

@@ -1,7 +1,8 @@
-import { EventDispatcher } from 'three';
 import { NodeUpdateType } from './constants.js';
 import { getNodeChildren, getCacheKey } from './NodeUtils.js';
-import { MathUtils } from 'three';
+
+import { EventDispatcher } from '../../core/EventDispatcher.js';
+import { MathUtils } from '../../math/MathUtils.js';
 
 const NodeClasses = new Map();
 
@@ -17,6 +18,7 @@ class Node extends EventDispatcher {
 
 		this.updateType = NodeUpdateType.NONE;
 		this.updateBeforeType = NodeUpdateType.NONE;
+		this.updateAfterType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 
@@ -25,6 +27,8 @@ class Node extends EventDispatcher {
 		this._cacheKey = null;
 		this._cacheKeyVersion = 0;
 
+		this.global = false;
+
 		this.isNode = true;
 
 		Object.defineProperty( this, 'id', { value: _nodeId ++ } );
@@ -98,7 +102,7 @@ class Node extends EventDispatcher {
 
 	isGlobal( /*builder*/ ) {
 
-		return false;
+		return this.global;
 
 	}
 
@@ -163,6 +167,21 @@ class Node extends EventDispatcher {
 
 	}
 
+	getUpdateAfterType() {
+
+		return this.updateAfterType;
+
+	}
+
+	getElementType( builder ) {
+
+		const type = this.getNodeType( builder );
+		const elementType = builder.getElementType( type );
+
+		return elementType;
+
+	}
+
 	getNodeType( builder ) {
 
 		const nodeProperties = builder.getNodeProperties( this );
@@ -190,9 +209,11 @@ class Node extends EventDispatcher {
 
 		const nodeProperties = builder.getNodeProperties( this );
 
+		let index = 0;
+
 		for ( const childNode of this.getChildren() ) {
 
-			nodeProperties[ '_node' + childNode.id ] = childNode;
+			nodeProperties[ 'node' + index ++ ] = childNode;
 
 		}
 
@@ -201,14 +222,6 @@ class Node extends EventDispatcher {
 
 	}
 
-	construct( builder ) { // @deprecated, r157
-
-		console.warn( 'THREE.Node: construct() is deprecated. Use setup() instead.' );
-
-		return this.setup( builder );
-
-	}
-
 	increaseUsage( builder ) {
 
 		const nodeData = builder.getDataFromNode( this );
@@ -260,6 +273,12 @@ class Node extends EventDispatcher {
 
 	}
 
+	updateAfter( /*frame*/ ) {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
 	update( /*frame*/ ) {
 
 		console.warn( 'Abstract function.' );
@@ -294,7 +313,7 @@ class Node extends EventDispatcher {
 
 			const properties = builder.getNodeProperties( this );
 
-			if ( properties.initialized !== true || builder.context.tempRead === false ) {
+			if ( properties.initialized !== true ) {
 
 				const stackNodesBeforeSetup = builder.stack.nodes.length;
 
@@ -334,7 +353,7 @@ class Node extends EventDispatcher {
 
 				result = nodeData.snippet;
 
-				if ( result === undefined /*|| builder.context.tempRead === false*/ ) {
+				if ( result === undefined ) {
 
 					result = this.generate( builder ) || '';