super-three 0.136.1 → 0.144.0

package/examples/jsm/nodes/utils/ConvertNode.js

@@ -0,0 +1,46 @@
+import Node from '../core/Node.js';
+
+class ConvertNode extends Node {
+
+	constructor( node, convertTo ) {
+
+		super();
+
+		this.node = node;
+		this.convertTo = convertTo;
+
+	}
+
+	getNodeType( /*builder*/ ) {
+
+		return this.convertTo;
+
+	}
+
+	generate( builder, output ) {
+
+		const convertTo = this.convertTo;
+		const node = this.node;
+		const type = this.getNodeType( builder );
+
+		let snippet = null;
+
+		if ( builder.isReference( convertTo ) === false ) {
+
+			const nodeSnippet = node.build( builder, convertTo );
+
+			snippet = builder.format( nodeSnippet, type, convertTo );
+
+		} else {
+
+			snippet = node.build( builder, convertTo );
+
+		}
+
+		return builder.format( snippet, type, output );
+
+	}
+
+}
+
+export default ConvertNode;

package/examples/jsm/nodes/utils/JoinNode.js

@@ -1,114 +1,42 @@
-import { TempNode } from '../core/TempNode.js';
-import { NodeUtils } from '../core/NodeUtils.js';
-
-const inputs = NodeUtils.elements;
+import TempNode from '../core/Node.js';
 
 class JoinNode extends TempNode {
 
-	constructor( x, y, z, w ) {
-
-		super( 'f' );
-
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
-
-	}
-
-	getNumElements() {
-
-		let i = inputs.length;
-
-		while ( i -- ) {
-
-			if ( this[ inputs[ i ] ] !== undefined ) {
-
-				++ i;
+	constructor( nodes = [] ) {
 
-				break;
+		super();
 
-			}
-
-		}
-
-		return Math.max( i, 2 );
+		this.nodes = nodes;
 
 	}
 
-	getType( builder ) {
+	getNodeType( builder ) {
 
-		return builder.getTypeFromLength( this.getNumElements() );
+		return builder.getTypeFromLength( this.nodes.reduce( ( count, cur ) => count + builder.getTypeLength( cur.getNodeType( builder ) ), 0 ) );
 
 	}
 
 	generate( builder, output ) {
 
-		const type = this.getType( builder ),
-			length = this.getNumElements(),
-			outputs = [];
-
-		for ( let i = 0; i < length; i ++ ) {
-
-			const elm = this[ inputs[ i ] ];
-
-			outputs.push( elm ? elm.build( builder, 'f' ) : '0.0' );
-
-		}
-
-		const code = ( length > 1 ? builder.getConstructorFromLength( length ) : '' ) + '( ' + outputs.join( ', ' ) + ' )';
-
-		return builder.format( code, type, output );
+		const type = this.getNodeType( builder );
+		const nodes = this.nodes;
 
-	}
-
-	copy( source ) {
+		const snippetValues = [];
 
-		super.copy( source );
+		for ( const input of nodes ) {
 
-		for ( const prop in source.inputs ) {
+			const inputSnippet = input.build( builder );
 
-			this[ prop ] = source.inputs[ prop ];
+			snippetValues.push( inputSnippet );
 
 		}
 
-		return this;
-
-	}
-
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.inputs = {};
-
-			const length = this.getNumElements();
+		const snippet = `${ builder.getType( type ) }( ${ snippetValues.join( ', ' ) } )`;
 
-			for ( let i = 0; i < length; i ++ ) {
-
-				const elm = this[ inputs[ i ] ];
-
-				if ( elm ) {
-
-					data.inputs[ inputs[ i ] ] = elm.toJSON( meta ).uuid;
-
-				}
-
-			}
-
-
-		}
-
-		return data;
+		return builder.format( snippet, type, output );
 
 	}
 
 }
 
-JoinNode.prototype.nodeType = 'Join';
-
-export { JoinNode };
+export default JoinNode;

package/examples/jsm/nodes/utils/MatcapUVNode.js

@@ -0,0 +1,25 @@
+import TempNode from '../core/TempNode.js';
+import { vec2, vec3, negate, normalize, cross, dot, mul, add, transformedNormalView, positionViewDirection } from '../shadernode/ShaderNodeBaseElements.js';
+
+class MatcapUVNode extends TempNode {
+
+	constructor() {
+
+		super( 'vec2' );
+
+	}
+
+	generate( builder ) {
+
+		const x = normalize( vec3( positionViewDirection.z, 0, negate( positionViewDirection.x ) ) );
+		const y = cross( positionViewDirection, x );
+
+		const uv = add( mul( vec2( dot( x, transformedNormalView ), dot( y, transformedNormalView ) ), 0.495 ), 0.5 );
+
+		return uv.build( builder, this.getNodeType( builder ) );
+
+	}
+
+}
+
+export default MatcapUVNode;

package/examples/jsm/nodes/utils/MaxMipLevelNode.js

@@ -0,0 +1,33 @@
+import UniformNode from '../core/UniformNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+class MaxMipLevelNode extends UniformNode {
+
+	constructor( texture ) {
+
+		super( 0 );
+
+		this.texture = texture;
+
+		this.updateType = NodeUpdateType.Frame;
+
+	}
+
+	update() {
+
+		const images = this.texture.images;
+		const image = ( images && images.length > 0 ) ? ( images[ 0 ]?.image || images[ 0 ] ) : this.texture.image;
+
+		if ( image?.width !== undefined ) {
+
+			const { width, height } = image;
+
+			this.value = Math.log2( Math.max( width, height ) );
+
+		}
+
+	}
+
+}
+
+export default MaxMipLevelNode;

package/examples/jsm/{renderers/nodes → nodes}/utils/OscNode.js

@@ -1,6 +1,6 @@
 import Node from '../core/Node.js';
 import TimerNode from './TimerNode.js';
-import { abs, fract, round, sin, add, sub, mul, PI2 } from '../ShaderNode.js';
+import { abs, fract, round, sin, add, sub, mul } from '../shadernode/ShaderNodeBaseElements.js';
 
 class OscNode extends Node {
 
@@ -33,7 +33,7 @@ class OscNode extends Node {
 
 		if ( method === OscNode.SINE ) {
 
-			outputNode = add( mul( sin( mul( add( timeNode, .75 ), PI2 ) ), .5 ), .5 );
+			outputNode = add( mul( sin( mul( add( timeNode, .75 ), Math.PI * 2 ) ), .5 ), .5 );
 
 		} else if ( method === OscNode.SQUARE ) {
 
@@ -53,6 +53,22 @@ class OscNode extends Node {
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.method = this.method;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.method = data.method;
+
+	}
+
 }
 
 export default OscNode;

package/examples/jsm/nodes/utils/RotateUVNode.js

@@ -0,0 +1,32 @@
+import TempNode from '../core/TempNode.js';
+import { vec2, add, sub, mul, cos, sin } from '../shadernode/ShaderNodeBaseElements.js';
+
+class RotateUVNode extends TempNode {
+
+	constructor( uvNode, rotationNode, centerNode = vec2( .5 ) ) {
+
+		super( 'vec2' );
+
+		this.uvNode = uvNode;
+		this.rotationNode = rotationNode;
+		this.centerNode = centerNode;
+
+	}
+
+	construct() {
+
+		const { uvNode, rotationNode, centerNode } = this;
+
+		const cosAngle = cos( rotationNode );
+		const sinAngle = sin( rotationNode );
+
+		return vec2(
+			add( add( mul( cosAngle, sub( uvNode.x, centerNode.x ) ), mul( sinAngle, sub( uvNode.y, centerNode.y ) ) ), centerNode.x ),
+			add( sub( mul( cosAngle, sub( uvNode.y, centerNode.y ) ), mul( sinAngle, sub( uvNode.x, centerNode.x ) ) ), centerNode.y )
+		);
+
+	}
+
+}
+
+export default RotateUVNode;

package/examples/jsm/nodes/utils/SplitNode.js

@@ -0,0 +1,102 @@
+import Node from '../core/Node.js';
+import { vector } from '../core/NodeBuilder.js';
+
+const vectorComponents = 'xyzw';
+
+class SplitNode extends Node {
+
+	constructor( node, components = 'x' ) {
+
+		super();
+
+		this.node = node;
+		this.components = components;
+
+	}
+
+	getVectorLength() {
+
+		let vectorLength = this.components.length;
+
+		for ( const c of this.components ) {
+
+			vectorLength = Math.max( vector.indexOf( c ) + 1, vectorLength );
+
+		}
+
+		return vectorLength;
+
+	}
+
+	getNodeType( builder ) {
+
+		return builder.getTypeFromLength( this.components.length );
+
+	}
+
+	generate( builder, output ) {
+
+		const node = this.node;
+		const nodeTypeLength = builder.getTypeLength( node.getNodeType( builder ) );
+
+		let snippet = null;
+
+		if ( nodeTypeLength > 1 ) {
+
+			let type = null;
+
+			const componentsLength = this.getVectorLength();
+
+			if ( componentsLength >= nodeTypeLength ) {
+
+				// needed expand the input node
+
+				type = builder.getTypeFromLength( this.getVectorLength() );
+
+			}
+
+			const nodeSnippet = node.build( builder, type );
+
+			if ( this.components.length === nodeTypeLength && this.components === vectorComponents.slice( 0, this.components.length ) ) {
+
+				// unecessary swizzle
+
+				snippet = builder.format( nodeSnippet, type, output );
+
+			} else {
+
+				snippet = builder.format( `${nodeSnippet}.${this.components}`, this.getNodeType( builder ), output );
+
+			}
+
+		} else {
+
+			// ignore .components if .node returns float/integer
+
+			snippet = node.build( builder, output );
+
+		}
+
+		return snippet;
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.components = this.components;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.components = data.components;
+
+	}
+
+}
+
+export default SplitNode;

package/examples/jsm/{renderers/nodes → nodes}/utils/SpriteSheetUVNode.js

@@ -1,5 +1,5 @@
 import Node from '../core/Node.js';
-import FloatNode from '../inputs/FloatNode.js';
+import ConstNode from '../core/ConstNode.js';
 import UVNode from '../accessors/UVNode.js';
 import MathNode from '../math/MathNode.js';
 import OperatorNode from '../math/OperatorNode.js';
@@ -8,7 +8,7 @@ import JoinNode from '../utils/JoinNode.js';
 
 class SpriteSheetUVNode extends Node {
 
-	constructor( countNode, uvNode = new UVNode(), frameNode = new FloatNode( 0 ).setConst( true ) ) {
+	constructor( countNode, uvNode = new UVNode(), frameNode = new ConstNode( 0 ) ) {
 
 		super( 'vec2' );
 
@@ -24,7 +24,7 @@ class SpriteSheetUVNode extends Node {
 		const uv = this.uvNode;
 		const frame = this.frameNode;
 
-		const one = new FloatNode( 1 ).setConst( true );
+		const one = new ConstNode( 1 );
 
 		const width = new SplitNode( count, 'x' );
 		const height = new SplitNode( count, 'y' );

package/examples/jsm/nodes/utils/TimerNode.js

@@ -1,99 +1,64 @@
-import { FloatNode } from '../inputs/FloatNode.js';
-import { NodeLib } from '../core/NodeLib.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeUpdateType } from '../core/constants.js';
 
-class TimerNode extends FloatNode {
+class TimerNode extends UniformNode {
 
-	constructor( scale, scope, timeScale ) {
+	static LOCAL = 'local';
+	static GLOBAL = 'global';
+	static DELTA = 'delta';
 
-		super();
+	constructor( scope = TimerNode.LOCAL, scale = 1, value = 0 ) {
 
-		this.scale = scale !== undefined ? scale : 1;
-		this.scope = scope || TimerNode.GLOBAL;
+		super( value );
 
-		this.timeScale = timeScale !== undefined ? timeScale : scale !== undefined;
+		this.scope = scope;
+		this.scale = scale;
 
-	}
-
-	getReadonly() {
-
-		// never use TimerNode as readonly but aways as "uniform"
-
-		return false;
-
-	}
-
-	getUnique() {
-
-		// share TimerNode "uniform" input if is used on more time with others TimerNode
-
-		return this.timeScale && ( this.scope === TimerNode.GLOBAL || this.scope === TimerNode.DELTA );
+		this.updateType = NodeUpdateType.Frame;
 
 	}
 
-	updateFrame( frame ) {
+	update( frame ) {
 
-		const scale = this.timeScale ? this.scale : 1;
+		const scope = this.scope;
+		const scale = this.scale;
 
-		switch ( this.scope ) {
+		if ( scope === TimerNode.LOCAL ) {
 
-			case TimerNode.LOCAL:
+			this.value += frame.deltaTime * scale;
 
-				this.value += frame.delta * scale;
+		} else if ( scope === TimerNode.DELTA ) {
 
-				break;
+			this.value = frame.deltaTime * scale;
 
-			case TimerNode.DELTA:
+		} else {
 
-				this.value = frame.delta * scale;
+			// global
 
-				break;
-
-			default:
-
-				this.value = frame.time * scale;
+			this.value = frame.time * scale;
 
 		}
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
-
-		this.scope = source.scope;
-		this.scale = source.scale;
-
-		this.timeScale = source.timeScale;
-
-		return this;
-
-	}
-
-	toJSON( meta ) {
+	serialize( data ) {
 
-		const data = super.toJSON( meta );
+		super.serialize( data );
 
 		data.scope = this.scope;
 		data.scale = this.scale;
 
-		data.timeScale = this.timeScale;
-
-		return data;
-
 	}
 
-}
-
-TimerNode.GLOBAL = 'global';
-TimerNode.LOCAL = 'local';
-TimerNode.DELTA = 'delta';
+	deserialize( data ) {
 
-TimerNode.prototype.nodeType = 'Timer';
+		super.deserialize( data );
 
-NodeLib.addKeyword( 'time', function () {
+		this.scope = data.scope;
+		this.scale = data.scale;
 
-	return new TimerNode();
+	}
 
-} );
+}
 
-export { TimerNode };
+export default TimerNode;