super-three 0.137.0 → 0.141.0

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

@@ -1,52 +1,59 @@
+import { NodeUpdateType } from './constants.js';
+
 class NodeFrame {
 
-	constructor( time ) {
+	constructor() {
 
-		this.time = time !== undefined ? time : 0;
+		this.time = 0;
+		this.deltaTime = 0;
 
-		this.id = 0;
+		this.frameId = 0;
 
-	}
+		this.startTime = null;
 
-	update( delta ) {
+		this.updateMap = new WeakMap();
 
-		++ this.id;
+		this.renderer = null;
+		this.material = null;
+		this.camera = null;
+		this.object = null;
 
-		this.time += delta;
-		this.delta = delta;
+	}
 
-		return this;
+	updateNode( node ) {
 
-	}
+		if ( node.updateType === NodeUpdateType.Frame ) {
 
-	setRenderer( renderer ) {
+			if ( this.updateMap.get( node ) !== this.frameId ) {
 
-		this.renderer = renderer;
+				this.updateMap.set( node, this.frameId );
 
-		return this;
+				node.update( this );
 
-	}
+			}
 
-	setRenderTexture( renderTexture ) {
+		} else if ( node.updateType === NodeUpdateType.Object ) {
 
-		this.renderTexture = renderTexture;
+			node.update( this );
 
-		return this;
+		}
 
 	}
 
-	updateNode( node ) {
+	update() {
+
+		this.frameId ++;
 
-		if ( node.frameId === this.id ) return this;
+		if ( this.lastTime === undefined ) this.lastTime = performance.now();
 
-		node.updateFrame( this );
+		this.deltaTime = ( performance.now() - this.lastTime ) / 1000;
 
-		node.frameId = this.id;
+		this.lastTime = performance.now();
 
-		return this;
+		this.time += this.deltaTime;
 
 	}
 
 }
 
-export { NodeFrame };
+export default NodeFrame;

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

@@ -1,11 +1,13 @@
 class NodeUniform {
 
-	constructor( params = {} ) {
+	constructor( name, type, node, needsUpdate = undefined ) {
 
-		this.name = params.name;
-		this.type = params.type;
-		this.node = params.node;
-		this.needsUpdate = params.needsUpdate;
+		this.isNodeUniform = true;
+
+		this.name = name;
+		this.type = type;
+		this.node = node;
+		this.needsUpdate = needsUpdate;
 
 	}
 
@@ -23,4 +25,4 @@ class NodeUniform {
 
 }
 
-export { NodeUniform };
+export default NodeUniform;

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

@@ -1,71 +1,103 @@
-const NodeUtils = {
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
 
-	elements: [ 'x', 'y', 'z', 'w' ],
+export const getNodesKeys = ( object ) => {
 
-	addShortcuts: function () {
+	const props = [];
 
-		function applyShortcut( proxy, property, subProperty ) {
+	for ( const name in object ) {
 
-			if ( subProperty ) {
+		const value = object[ name ];
 
-				return {
+		if ( value && value.isNode === true ) {
 
-					get: function () {
+			props.push( name );
 
-						return this[ proxy ][ property ][ subProperty ];
+		}
 
-					},
+	}
 
-					set: function ( val ) {
+	return props;
 
-						this[ proxy ][ property ][ subProperty ] = val;
+};
 
-					}
+export const getValueType = ( value ) => {
 
-				};
+	if ( typeof value === 'number' ) {
 
-			} else {
+		return 'float';
 
-				return {
+	} else if ( typeof value === 'boolean' ) {
 
-					get: function () {
+		return 'bool';
 
-						return this[ proxy ][ property ];
+	} else if ( value?.isVector2 === true ) {
 
-					},
+		return 'vec2';
 
-					set: function ( val ) {
+	} else if ( value?.isVector3 === true ) {
 
-						this[ proxy ][ property ] = val;
+		return 'vec3';
 
-					}
+	} else if ( value?.isVector4 === true ) {
 
-				};
+		return 'vec4';
 
-			}
+	} else if ( value?.isMatrix3 === true ) {
 
-		}
+		return 'mat3';
 
-		return function addShortcuts( proto, proxy, list ) {
+	} else if ( value?.isMatrix4 === true ) {
 
-			const shortcuts = {};
+		return 'mat4';
 
-			for ( let i = 0; i < list.length; ++ i ) {
+	} else if ( value?.isColor === true ) {
 
-				const data = list[ i ].split( '.' ),
-					property = data[ 0 ],
-					subProperty = data[ 1 ];
+		return 'color';
 
-				shortcuts[ property ] = applyShortcut( proxy, property, subProperty );
+	}
 
-			}
+	return null;
 
-			Object.defineProperties( proto, shortcuts );
+};
 
-		};
+export const getValueFromType = ( type, ...params ) => {
 
-	}()
+	const last4 = type?.slice( -4 );
 
-};
+	if ( type === 'color' ) {
+
+		return new Color( ...params );
+
+	} else if ( last4 === 'vec2' ) {
+
+		return new Vector2( ...params );
+
+	} else if ( last4 === 'vec3' ) {
+
+		return new Vector3( ...params );
+
+	} else if ( last4 === 'vec4' ) {
+
+		return new Vector4( ...params );
 
-export { NodeUtils };
+	} else if ( last4 === 'mat3' ) {
+
+		return new Matrix3( ...params );
+
+	} else if ( last4 === 'mat4' ) {
+
+		return new Matrix4( ...params );
+
+	} else if ( type === 'bool' ) {
+
+		return false;
+
+	} else if ( ( type === 'float' ) || ( type === 'int' ) || ( type === 'uint' ) ) {
+
+		return 0;
+
+	}
+
+	return null;
+
+};

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

@@ -2,6 +2,8 @@ class NodeVar {
 
 	constructor( name, type ) {
 
+		this.isNodeVar = true;
+
 		this.name = name;
 		this.type = type;
 
@@ -9,6 +11,4 @@ class NodeVar {
 
 }
 
-NodeVar.prototype.isNodeVar = true;
-
 export default NodeVar;

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

@@ -2,6 +2,8 @@ class NodeVary {
 
 	constructor( name, type ) {
 
+		this.isNodeVary = true;
+
 		this.name = name;
 		this.type = type;
 
@@ -9,6 +11,4 @@ class NodeVary {
 
 }
 
-NodeVary.prototype.isNodeVary = true;
-
 export default NodeVary;

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

@@ -1,142 +1,50 @@
-import { MathUtils } from 'three';
-import { Node } from './Node.js';
+import Node from './Node.js';
 
 class TempNode extends Node {
 
-	constructor( type, params = {} ) {
+	constructor( type ) {
 
 		super( type );
 
-		this.shared = params.shared !== undefined ? params.shared : true;
-		this.unique = params.unique !== undefined ? params.unique : false;
+		this.isTempNode = true;
 
 	}
 
-	build( builder, output, uuid, ns ) {
+	build( builder, output ) {
 
-		output = output || this.getType( builder );
+		const buildStage = builder.getBuildStage();
 
-		if ( this.getShared( builder, output ) ) {
+		if ( buildStage === 'generate' ) {
 
-			const isUnique = this.getUnique( builder, output );
+			const type = builder.getVectorType( this.getNodeType( builder, output ) );
+			const nodeData = builder.getDataFromNode( this );
 
-			if ( isUnique && this.constructor.uuid === undefined ) {
+			if ( builder.context.tempRead !== false && nodeData.propertyName !== undefined ) {
 
-				this.constructor.uuid = MathUtils.generateUUID();
+				return builder.format( nodeData.propertyName, type, output );
 
-			}
-
-			uuid = builder.getUuid( uuid || this.getUuid(), ! isUnique );
-
-			const data = builder.getNodeData( uuid ),
-				type = data.output || this.getType( builder );
-
-			if ( builder.analyzing ) {
-
-				if ( ( data.deps || 0 ) > 0 || this.getLabel() ) {
-
-					this.appendDepsNode( builder, data, output );
-
-					return this.generate( builder, output, uuid );
-
-				}
-
-				return super.build( builder, output, uuid );
-
-			} else if ( isUnique ) {
-
-				data.name = data.name || super.build( builder, output, uuid );
-
-				return data.name;
-
-			} else if ( ! this.getLabel() && ( ! this.getShared( builder, type ) || ( builder.context.ignoreCache || data.deps === 1 ) ) ) {
-
-				return super.build( builder, output, uuid );
+			} else if ( builder.context.tempWrite !== false && type !== 'void ' && output !== 'void' && nodeData.dependenciesCount > 1 ) {
 
-			}
-
-			uuid = this.getUuid( false );
-
-			let name = this.getTemp( builder, uuid );
-
-			if ( name ) {
+				const snippet = super.build( builder, type );
 
-				return builder.format( name, type, output );
+				const nodeVar = builder.getVarFromNode( this, type );
+				const propertyName = builder.getPropertyName( nodeVar );
 
-			} else {
+				builder.addFlowCode( `${propertyName} = ${snippet}` );
 
-				name = TempNode.prototype.generate.call( this, builder, output, uuid, data.output, ns );
+				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
-				const code = this.generate( builder, type, uuid );
-
-				builder.addNodeCode( name + ' = ' + code + ';' );
-
-				return builder.format( name, type, output );
+				return builder.format( nodeData.propertyName, type, output );
 
 			}
 
 		}
 
-		return super.build( builder, output, uuid );
-
-	}
-
-	getShared( builder, output ) {
-
-		return output !== 'sampler2D' && output !== 'samplerCube' && this.shared;
-
-	}
-
-	getUnique( /* builder, output */ ) {
-
-		return this.unique;
-
-	}
-
-	setLabel( name ) {
-
-		this.label = name;
-
-		return this;
-
-	}
-
-	getLabel( /* builder */ ) {
-
-		return this.label;
-
-	}
-
-	getUuid( unique ) {
-
-		let uuid = unique || unique == undefined ? this.constructor.uuid || this.uuid : this.uuid;
-
-		if ( typeof this.scope === 'string' ) uuid = this.scope + '-' + uuid;
-
-		return uuid;
-
-	}
-
-	getTemp( builder, uuid ) {
-
-		uuid = uuid || this.uuid;
-
-		const tempVar = builder.getVars()[ uuid ];
-
-		return tempVar ? tempVar.name : undefined;
-
-	}
-
-	generate( builder, output, uuid, type, ns ) {
-
-		if ( ! this.getShared( builder, output ) ) console.error( 'THREE.TempNode is not shared!' );
-
-		uuid = uuid || this.uuid;
-
-		return builder.getTempVar( uuid, type || this.getType( builder ), ns, this.getLabel() ).name;
+		return super.build( builder, output );
 
 	}
 
 }
 
-export { TempNode };
+export default TempNode;

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

@@ -0,0 +1,46 @@
+import InputNode from './InputNode.js';
+
+class UniformNode extends InputNode {
+
+	constructor( value, nodeType = null ) {
+
+		super( value, nodeType );
+
+		this.isUniformNode = true;
+
+	}
+
+	getUniformHash( builder ) {
+
+		return this.getHash( builder );
+
+	}
+
+	generate( builder, output ) {
+
+		const type = this.getNodeType( builder );
+
+		const hash = this.getUniformHash( builder );
+
+		let sharedNode = builder.getNodeFromHash( hash );
+
+		if ( sharedNode === undefined ) {
+
+			builder.setHashNode( this, hash );
+
+			sharedNode = this;
+
+		}
+
+		const sharedNodeType = sharedNode.getInputType( builder );
+
+		const nodeUniform = builder.getUniformFromNode( sharedNode, builder.shaderStage, sharedNodeType );
+		const propertyName = builder.getPropertyName( nodeUniform );
+
+		return builder.format( propertyName, type, output );
+
+	}
+
+}
+
+export default UniformNode;

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

@@ -1,66 +1,97 @@
-import { Node } from './Node.js';
+import Node from './Node.js';
+import OperatorNode from '../math/OperatorNode.js';
 
 class VarNode extends Node {
 
-	constructor( type, value ) {
+	constructor( node, name = null ) {
 
-		super( type );
+		super();
 
-		this.value = value;
+		this.node = node;
+		this.name = name;
 
 	}
 
-	getType( builder ) {
+	op( op, ...params ) {
 
-		return builder.getTypeByFormat( this.type );
+		this.node = new OperatorNode( op, this.node, ...params );
+
+		return this;
 
 	}
 
-	generate( builder, output ) {
+	assign( ...params ) {
 
-		const varying = builder.getVar( this.uuid, this.type );
+		return this.op( '=', ...params );
 
-		if ( this.value && builder.isShader( 'vertex' ) ) {
+	}
 
-			builder.addNodeCode( varying.name + ' = ' + this.value.build( builder, this.getType( builder ) ) + ';' );
+	add( ...params ) {
 
-		}
+		return this.op( '+', ...params );
+
+	}
+
+	sub( ...params ) {
 
-		return builder.format( varying.name, this.getType( builder ), output );
+		return this.op( '-', ...params );
 
 	}
 
-	copy( source ) {
+	mul( ...params ) {
 
-		super.copy( source );
+		return this.op( '*', ...params );
 
-		this.type = source.type;
-		this.value = source.value;
+	}
 
-		return this;
+	div( ...params ) {
+
+		return this.op( '/', ...params );
 
 	}
 
-	toJSON( meta ) {
+	getHash( builder ) {
 
-		let data = this.getJSONNode( meta );
+		return this.name || super.getHash( builder );
 
-		if ( ! data ) {
+	}
+
+	getNodeType( builder ) {
 
-			data = this.createJSONNode( meta );
+		return this.node.getNodeType( builder );
 
-			data.type = this.type;
+	}
 
-			if ( this.value ) data.value = this.value.toJSON( meta ).uuid;
+	generate( builder ) {
+
+		const node = this.node;
+		const name = this.name;
+
+		if ( name === null && node.isTempNode === true ) {
+
+			return node.build( builder );
+
+		}
+
+		const type = builder.getVectorType( this.getNodeType( builder ) );
+
+		const snippet = node.build( builder, type );
+		const nodeVar = builder.getVarFromNode( this, type );
+
+		if ( name !== null ) {
+
+			nodeVar.name = name;
 
 		}
 
-		return data;
+		const propertyName = builder.getPropertyName( nodeVar );
+
+		builder.addFlowCode( `${propertyName} = ${snippet}` );
+
+		return propertyName;
 
 	}
 
 }
 
-VarNode.prototype.nodeType = 'Var';
-
-export { VarNode };
+export default VarNode;

package/examples/jsm/{renderers/nodes → nodes}/display/ColorSpaceNode.js

@@ -1,8 +1,5 @@
 import TempNode from '../core/Node.js';
-import { ShaderNode,
-	vec3,
-	pow, mul, sub, mix, join,
-	lessThanEqual } from '../ShaderNode.js';
+import { ShaderNode, vec3, pow, mul, sub, mix, vec4, lessThanEqual } from '../shadernode/ShaderNodeBaseElements.js';
 
 import { LinearEncoding, sRGBEncoding } from 'three';
 
@@ -24,7 +21,7 @@ export const LinearTosRGB = new ShaderNode( ( inputs ) => {
 
 	const rgbResult = mix( a, b, factor );
 
-	return join( rgbResult.r, rgbResult.g, rgbResult.b, value.a );
+	return vec4( rgbResult, value.a );
 
 } );
 
@@ -68,27 +65,29 @@ class ColorSpaceNode extends TempNode {
 
 	}
 
-	generate( builder ) {
-
-		const type = this.getNodeType( builder );
+	construct() {
 
 		const method = this.method;
 		const node = this.node;
 
+		let outputNode = null;
+
 		if ( method !== ColorSpaceNode.LINEAR_TO_LINEAR ) {
 
 			const encodingFunctionNode = EncodingLib[ method ];
 
-			return encodingFunctionNode( {
+			outputNode = encodingFunctionNode.call( {
 				value: node
-			} ).build( builder, type );
+			} );
 
 		} else {
 
-			return node.build( builder, type );
+			outputNode = node;
 
 		}
 
+		return outputNode;
+
 	}
 
 }