super-three 0.168.0 → 0.169.1

package/src/nodes/accessors/VelocityNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { modelViewMatrix } from './ModelNode.js';
 import { positionLocal, positionPrevious } from './Position.js';
@@ -8,11 +7,18 @@ import { Matrix4 } from '../../math/Matrix4.js';
 import { uniform } from '../core/UniformNode.js';
 import { sub } from '../math/OperatorNode.js';
 import { cameraProjectionMatrix } from './Camera.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
 
-const _matrixCache = new WeakMap();
+const _objectData = new WeakMap();
 
 class VelocityNode extends TempNode {
 
+	static get type() {
+
+		return 'VelocityNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec2' );
@@ -20,35 +26,66 @@ class VelocityNode extends TempNode {
 		this.updateType = NodeUpdateType.OBJECT;
 		this.updateAfterType = NodeUpdateType.OBJECT;
 
-		this.previousProjectionMatrix = uniform( new Matrix4() );
-		this.previousModelViewMatrix = uniform( new Matrix4() );
+		this.previousModelWorldMatrix = uniform( new Matrix4() );
+		this.previousProjectionMatrix = uniform( new Matrix4() ).setGroup( renderGroup );
+		this.previousCameraViewMatrix = uniform( new Matrix4() );
 
 	}
 
-	update( { camera, object } ) {
+	update( { frameId, camera, object } ) {
 
 		const previousModelMatrix = getPreviousMatrix( object );
-		const previousCameraMatrix = getPreviousMatrix( camera );
 
-		this.previousModelViewMatrix.value.copy( previousModelMatrix );
-		this.previousProjectionMatrix.value.copy( previousCameraMatrix );
+		this.previousModelWorldMatrix.value.copy( previousModelMatrix );
 
-	}
+		//
 
-	updateAfter( { camera, object } ) {
+		const cameraData = getData( camera );
 
-		const previousModelMatrix = getPreviousMatrix( object );
-		const previousCameraMatrix = getPreviousMatrix( camera );
+		if ( cameraData.frameId !== frameId ) {
+
+			cameraData.frameId = frameId;
+
+			if ( cameraData.previousProjectionMatrix === undefined ) {
+
+				cameraData.previousProjectionMatrix = new Matrix4();
+				cameraData.previousCameraViewMatrix = new Matrix4();
+
+				cameraData.currentProjectionMatrix = new Matrix4();
+				cameraData.currentCameraViewMatrix = new Matrix4();
+
+				cameraData.previousProjectionMatrix.copy( camera.projectionMatrix );
+				cameraData.previousCameraViewMatrix.copy( camera.matrixWorldInverse );
+
+			} else {
+
+				cameraData.previousProjectionMatrix.copy( cameraData.currentProjectionMatrix );
+				cameraData.previousCameraViewMatrix.copy( cameraData.currentCameraViewMatrix );
+
+			}
+
+			cameraData.currentProjectionMatrix.copy( camera.projectionMatrix );
+			cameraData.currentCameraViewMatrix.copy( camera.matrixWorldInverse );
+
+			this.previousProjectionMatrix.value.copy( cameraData.previousProjectionMatrix );
+			this.previousCameraViewMatrix.value.copy( cameraData.previousCameraViewMatrix );
 
-		previousModelMatrix.copy( object.modelViewMatrix );
-		previousCameraMatrix.copy( camera.projectionMatrix );
+		}
+
+	}
+
+	updateAfter( { object } ) {
+
+		getPreviousMatrix( object ).copy( object.matrixWorld );
 
 	}
 
 	setup( /*builder*/ ) {
 
+		const previousModelViewMatrix = this.previousCameraViewMatrix.mul( this.previousModelWorldMatrix );
+
 		const clipPositionCurrent = cameraProjectionMatrix.mul( modelViewMatrix ).mul( positionLocal );
-		const clipPositionPrevious = this.previousProjectionMatrix.mul( this.previousModelViewMatrix ).mul( positionPrevious );
+		const clipPositionPrevious = this.previousProjectionMatrix.mul( previousModelViewMatrix ).mul( positionPrevious );
 
 		const ndcPositionCurrent = clipPositionCurrent.xy.div( clipPositionCurrent.w );
 		const ndcPositionPrevious = clipPositionPrevious.xy.div( clipPositionPrevious.w );
@@ -61,23 +98,37 @@ class VelocityNode extends TempNode {
 
 }
 
-function getPreviousMatrix( object ) {
+function getData( object ) {
 
-	let previousMatrix = _matrixCache.get( object );
+	let objectData = _objectData.get( object );
 
-	if ( previousMatrix === undefined ) {
+	if ( objectData === undefined ) {
 
-		previousMatrix = new Matrix4();
-		_matrixCache.set( object, previousMatrix );
+		objectData = {};
+		_objectData.set( object, objectData );
 
 	}
 
-	return previousMatrix;
+	return objectData;
 
 }
 
-export default VelocityNode;
+function getPreviousMatrix( object, index = 0 ) {
+
+	const objectData = getData( object );
+
+	let matrix = objectData[ index ];
 
-VelocityNode.type = /*@__PURE__*/ registerNode( 'Velocity', VelocityNode );
+	if ( matrix === undefined ) {
+
+		objectData[ index ] = matrix = new Matrix4();
+
+	}
+
+	return matrix;
+
+}
+
+export default VelocityNode;
 
 export const velocity = /*@__PURE__*/ nodeImmutable( VelocityNode );

package/src/nodes/accessors/VertexColorNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
@@ -6,6 +5,12 @@ import { Vector4 } from '../../math/Vector4.js';
 
 class VertexColorNode extends AttributeNode {
 
+	static get type() {
+
+		return 'VertexColorNode';
+
+	}
+
 	constructor( index = 0 ) {
 
 		super( null, 'vec4' );
@@ -66,6 +71,4 @@ class VertexColorNode extends AttributeNode {
 
 export default VertexColorNode;
 
-VertexColorNode.type = /*@__PURE__*/ registerNode( 'VertexColor', VertexColorNode );
-
 export const vertexColor = ( ...params ) => nodeObject( new VertexColorNode( ...params ) );

package/src/nodes/code/CodeNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
 
 class CodeNode extends Node {
 
+	static get type() {
+
+		return 'CodeNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( 'code' );
@@ -75,8 +81,6 @@ class CodeNode extends Node {
 
 export default CodeNode;
 
-CodeNode.type = /*@__PURE__*/ registerNode( 'Code', CodeNode );
-
 export const code = /*@__PURE__*/ nodeProxy( CodeNode );
 
 export const js = ( src, includes ) => code( src, includes, 'js' );

package/src/nodes/code/ExpressionNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeProxy } from '../tsl/TSLCore.js';
 
 class ExpressionNode extends Node {
 
+	static get type() {
+
+		return 'ExpressionNode';
+
+	}
+
 	constructor( snippet = '', nodeType = 'void' ) {
 
 		super( nodeType );
@@ -18,7 +24,7 @@ class ExpressionNode extends Node {
 
 		if ( type === 'void' ) {
 
-			builder.addLineFlowCode( snippet );
+			builder.addLineFlowCode( snippet, this );
 
 		} else {
 
@@ -32,6 +38,4 @@ class ExpressionNode extends Node {
 
 export default ExpressionNode;
 
-ExpressionNode.type = /*@__PURE__*/ registerNode( 'Expression', ExpressionNode );
-
 export const expression = /*@__PURE__*/ nodeProxy( ExpressionNode );

package/src/nodes/code/FunctionCallNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeArray, nodeObject, nodeObjects } from '../tsl/TSLCore.js';
 
 class FunctionCallNode extends TempNode {
 
+	static get type() {
+
+		return 'FunctionCallNode';
+
+	}
+
 	constructor( functionNode = null, parameters = {} ) {
 
 		super();
@@ -83,8 +88,6 @@ class FunctionCallNode extends TempNode {
 
 export default FunctionCallNode;
 
-FunctionCallNode.type = /*@__PURE__*/ registerNode( 'FunctionCall', FunctionCallNode );
-
 export const call = ( func, ...params ) => {
 
 	params = params.length > 1 || ( params[ 0 ] && params[ 0 ].isNode === true ) ? nodeArray( params ) : nodeObjects( params[ 0 ] );

package/src/nodes/code/FunctionNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import CodeNode from './CodeNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
 class FunctionNode extends CodeNode {
 
+	static get type() {
+
+		return 'FunctionNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( code, includes, language );
@@ -81,8 +86,6 @@ class FunctionNode extends CodeNode {
 
 export default FunctionNode;
 
-FunctionNode.type = /*@__PURE__*/ registerNode( 'Function', FunctionNode );
-
 const nativeFn = ( code, includes = [], language = '' ) => {
 
 	for ( let i = 0; i < includes.length; i ++ ) {

package/src/nodes/code/ScriptableNode.js

@@ -1,6 +1,7 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { scriptableValue } from './ScriptableValueNode.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
+import { hashArray, hashString } from '../core/NodeUtils.js';
 
 class Resources extends Map {
 
@@ -61,6 +62,12 @@ export const global = new Resources();
 
 class ScriptableNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableNode';
+
+	}
+
 	constructor( codeNode = null, parameters = {} ) {
 
 		super();
@@ -439,15 +446,15 @@ class ScriptableNode extends Node {
 
 	getCacheKey( force ) {
 
-		const cacheKey = [ this.source, this.getDefaultOutputNode().getCacheKey( force ) ];
+		const values = [ hashString( this.source ), this.getDefaultOutputNode().getCacheKey( force ) ];
 
 		for ( const param in this.parameters ) {
 
-			cacheKey.push( this.parameters[ param ].getCacheKey( force ) );
+			values.push( this.parameters[ param ].getCacheKey( force ) );
 
 		}
 
-		return cacheKey.join( ',' );
+		return hashArray( values );
 
 	}
 
@@ -495,6 +502,4 @@ class ScriptableNode extends Node {
 
 export default ScriptableNode;
 
-ScriptableNode.type = /*@__PURE__*/ registerNode( 'Scriptable', ScriptableNode );
-
 export const scriptable = /*@__PURE__*/ nodeProxy( ScriptableNode );

package/src/nodes/code/ScriptableValueNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
 import { nodeProxy, float } from '../tsl/TSLBase.js';
 
@@ -6,6 +6,12 @@ import { EventDispatcher } from '../../core/EventDispatcher.js';
 
 class ScriptableValueNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableValueNode';
+
+	}
+
 	constructor( value = null ) {
 
 		super();
@@ -161,6 +167,4 @@ class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-ScriptableValueNode.type = /*@__PURE__*/ registerNode( 'ScriptableValue', ScriptableValueNode );
-
 export const scriptableValue = /*@__PURE__*/ nodeProxy( ScriptableValueNode );

package/src/nodes/core/AssignNode.js

@@ -1,10 +1,15 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 import { vectorComponents } from '../core/constants.js';
 
 class AssignNode extends TempNode {
 
+	static get type() {
+
+		return 'AssignNode';
+
+	}
+
 	constructor( targetNode, sourceNode ) {
 
 		super();
@@ -75,7 +80,7 @@ class AssignNode extends TempNode {
 			const sourceVar = builder.getVarFromNode( this, null, targetType );
 			const sourceProperty = builder.getPropertyName( sourceVar );
 
-			builder.addLineFlowCode( `${ sourceProperty } = ${ source }` );
+			builder.addLineFlowCode( `${ sourceProperty } = ${ source }`, this );
 
 			const targetRoot = targetNode.node.context( { assign: true } ).build( builder );
 
@@ -83,7 +88,7 @@ class AssignNode extends TempNode {
 
 				const component = targetNode.components[ i ];
 
-				builder.addLineFlowCode( `${ targetRoot }.${ component } = ${ sourceProperty }[ ${ i } ]` );
+				builder.addLineFlowCode( `${ targetRoot }.${ component } = ${ sourceProperty }[ ${ i } ]`, this );
 
 			}
 
@@ -99,7 +104,7 @@ class AssignNode extends TempNode {
 
 			if ( output === 'void' || sourceType === 'void' ) {
 
-				builder.addLineFlowCode( snippet );
+				builder.addLineFlowCode( snippet, this );
 
 				if ( output !== 'void' ) {
 
@@ -121,8 +126,6 @@ class AssignNode extends TempNode {
 
 export default AssignNode;
 
-AssignNode.type = /*@__PURE__*/ registerNode( 'Assign', AssignNode );
-
 export const assign = /*@__PURE__*/ nodeProxy( AssignNode );
 
 addMethodChaining( 'assign', assign );

package/src/nodes/core/AttributeNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
 
+	static get type() {
+
+		return 'AttributeNode';
+
+	}
+
 	constructor( attributeName, nodeType = null ) {
 
 		super( nodeType );
@@ -116,6 +122,4 @@ class AttributeNode extends Node {
 
 export default AttributeNode;
 
-AttributeNode.type = /*@__PURE__*/ registerNode( 'Attribute', AttributeNode );
-
 export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );

package/src/nodes/core/BypassNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class BypassNode extends Node {
 
+	static get type() {
+
+		return 'BypassNode';
+
+	}
+
 	constructor( returnNode, callNode ) {
 
 		super();
@@ -26,7 +32,7 @@ class BypassNode extends Node {
 
 		if ( snippet !== '' ) {
 
-			builder.addLineFlowCode( snippet );
+			builder.addLineFlowCode( snippet, this );
 
 		}
 
@@ -38,8 +44,6 @@ class BypassNode extends Node {
 
 export default BypassNode;
 
-BypassNode.type = /*@__PURE__*/ registerNode( 'Bypass', BypassNode );
-
 export const bypass = /*@__PURE__*/ nodeProxy( BypassNode );
 
 addMethodChaining( 'bypass', bypass );

package/src/nodes/core/CacheNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
 
 class CacheNode extends Node {
 
+	static get type() {
+
+		return 'CacheNode';
+
+	}
+
 	constructor( node, parent = true ) {
 
 		super();
@@ -23,7 +29,7 @@ class CacheNode extends Node {
 	build( builder, ...params ) {
 
 		const previousCache = builder.getCache();
-		const cache = builder.getCacheFromNode( this, parent );
+		const cache = builder.getCacheFromNode( this, this.parent );
 
 		builder.setCache( cache );
 
@@ -39,8 +45,6 @@ class CacheNode extends Node {
 
 export default CacheNode;
 
-CacheNode.type = /*@__PURE__*/ registerNode( 'Cache', CacheNode );
-
 export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
 
 addMethodChaining( 'cache', cache );

package/src/nodes/core/ConstNode.js

@@ -1,8 +1,13 @@
-import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
 
 class ConstNode extends InputNode {
 
+	static get type() {
+
+		return 'ConstNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( value, nodeType );
@@ -28,5 +33,3 @@ class ConstNode extends InputNode {
 }
 
 export default ConstNode;
-
-ConstNode.type = /*@__PURE__*/ registerNode( 'Const', ConstNode );

package/src/nodes/core/ContextNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
 
+	static get type() {
+
+		return 'ContextNode';
+
+	}
+
 	constructor( node, value = {} ) {
 
 		super();
@@ -64,8 +70,6 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-ContextNode.type = /*@__PURE__*/ registerNode( 'Context', ContextNode );
-
 export const context = /*@__PURE__*/ nodeProxy( ContextNode );
 export const label = ( node, name ) => context( node, { label: name } );
 

package/src/nodes/core/IndexNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { nodeImmutable, varying } from '../tsl/TSLBase.js';
 
 class IndexNode extends Node {
 
+	static get type() {
+
+		return 'IndexNode';
+
+	}
+
 	constructor( scope ) {
 
 		super( 'uint' );
@@ -22,20 +28,34 @@ class IndexNode extends Node {
 
 		if ( scope === IndexNode.VERTEX ) {
 
+			// The index of a vertex within a mesh.
 			propertyName = builder.getVertexIndex();
 
 		} else if ( scope === IndexNode.INSTANCE ) {
 
+			// The index of either a mesh instance or an invocation of a compute shader.
 			propertyName = builder.getInstanceIndex();
 
 		} else if ( scope === IndexNode.DRAW ) {
 
+			// The index of a draw call.
 			propertyName = builder.getDrawIndex();
 
 		} else if ( scope === IndexNode.INVOCATION_LOCAL ) {
 
+			// The index of a compute invocation within the scope of a workgroup load.
 			propertyName = builder.getInvocationLocalIndex();
 
+		} else if ( scope === IndexNode.INVOCATION_SUBGROUP ) {
+
+			// The index of a compute invocation within the scope of a subgroup.
+			propertyName = builder.getInvocationSubgroupIndex();
+
+		} else if ( scope === IndexNode.SUBGROUP ) {
+
+			// The index of the subgroup the current compute invocation belongs to.
+			propertyName = builder.getSubgroupIndex();
+
 		} else {
 
 			throw new Error( 'THREE.IndexNode: Unknown scope: ' + scope );
@@ -64,14 +84,16 @@ class IndexNode extends Node {
 
 IndexNode.VERTEX = 'vertex';
 IndexNode.INSTANCE = 'instance';
+IndexNode.SUBGROUP = 'subgroup';
 IndexNode.INVOCATION_LOCAL = 'invocationLocal';
+IndexNode.INVOCATION_SUBGROUP = 'invocationSubgroup';
 IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
-IndexNode.type = /*@__PURE__*/ registerNode( 'Index', IndexNode );
-
 export const vertexIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.VERTEX );
 export const instanceIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INSTANCE );
+export const subgroupIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.SUBGROUP );
+export const invocationSubgroupIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INVOCATION_SUBGROUP );
 export const invocationLocalIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INVOCATION_LOCAL );
 export const drawIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.DRAW );

package/src/nodes/core/InputNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from './Node.js';
+import Node from './Node.js';
 import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
 
+	static get type() {
+
+		return 'InputNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( nodeType );
@@ -79,5 +85,3 @@ class InputNode extends Node {
 }
 
 export default InputNode;
-
-InputNode.type = /*@__PURE__*/ registerNode( 'Input', InputNode );

package/src/nodes/core/MRTNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from './Node.js';
 import OutputStructNode from './OutputStructNode.js';
 import { nodeProxy, vec4 } from '../tsl/TSLBase.js';
 
@@ -20,6 +19,12 @@ export function getTextureIndex( textures, name ) {
 
 class MRTNode extends OutputStructNode {
 
+	static get type() {
+
+		return 'MRTNode';
+
+	}
+
 	constructor( outputNodes ) {
 
 		super();
@@ -77,6 +82,4 @@ class MRTNode extends OutputStructNode {
 
 export default MRTNode;
 
-MRTNode.type = /*@__PURE__*/ registerNode( 'MRT', MRTNode );
-
 export const mrt = /*@__PURE__*/ nodeProxy( MRTNode );