super-three 0.165.0 → 0.167.0

package/{examples/jsm → src}/nodes/materialx/lib/mx_transform_color.js

@@ -5,7 +5,7 @@ import { bvec3, vec3, tslFn } from '../../shadernode/ShaderNode.js';
 import { greaterThan } from '../../math/OperatorNode.js';
 import { max, pow, mix } from '../../math/MathNode.js';
 
-const mx_srgb_texture_to_lin_rec709 = tslFn( ( [ color_immutable ] ) => {
+export const mx_srgb_texture_to_lin_rec709 = /*#__PURE__*/ tslFn( ( [ color_immutable ] ) => {
 
 	const color = vec3( color_immutable ).toVar();
 	const isAbove = bvec3( greaterThan( color, vec3( 0.04045 ) ) ).toVar();
@@ -14,16 +14,10 @@ const mx_srgb_texture_to_lin_rec709 = tslFn( ( [ color_immutable ] ) => {
 
 	return mix( linSeg, powSeg, isAbove );
 
-} );
-
-// layouts
-
-mx_srgb_texture_to_lin_rec709.setLayout( {
+} ).setLayout( {
 	name: 'mx_srgb_texture_to_lin_rec709',
 	type: 'vec3',
 	inputs: [
 		{ name: 'color', type: 'vec3' }
 	]
 } );
-
-export { mx_srgb_texture_to_lin_rec709 };

package/{examples/jsm → src}/nodes/math/CondNode.js

@@ -1,6 +1,5 @@
 import Node, { addNodeClass } from '../core/Node.js';
 import { property } from '../core/PropertyNode.js';
-import { context as contextNode } from '../core/ContextNode.js';
 import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class CondNode extends Node {
@@ -36,10 +35,18 @@ class CondNode extends Node {
 
 	}
 
+	setup( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+		properties.condNode = this.condNode.cache();
+		properties.ifNode = this.ifNode.cache();
+		properties.elseNode = this.elseNode ? this.elseNode.cache() : null;
+
+	}
+
 	generate( builder, output ) {
 
 		const type = this.getNodeType( builder );
-		const context = { tempWrite: false };
 
 		const nodeData = builder.getDataFromNode( this );
 
@@ -49,18 +56,18 @@ class CondNode extends Node {
 
 		}
 
-		const { ifNode, elseNode } = this;
+		const { condNode, ifNode, elseNode } = builder.getNodeProperties( this );
 
 		const needsOutput = output !== 'void';
 		const nodeProperty = needsOutput ? property( type ).build( builder ) : '';
 
 		nodeData.nodeProperty = nodeProperty;
 
-		const nodeSnippet = contextNode( this.condNode/*, context*/ ).build( builder, 'bool' );
+		const nodeSnippet = condNode.build( builder, 'bool' );
 
 		builder.addFlowCode( `\n${ builder.tab }if ( ${ nodeSnippet } ) {\n\n` ).addFlowTab();
 
-		let ifSnippet = contextNode( ifNode, context ).build( builder, type );
+		let ifSnippet = ifNode.build( builder, type );
 
 		if ( ifSnippet ) {
 
@@ -82,7 +89,7 @@ class CondNode extends Node {
 
 			builder.addFlowCode( ' else {\n\n' ).addFlowTab();
 
-			let elseSnippet = contextNode( elseNode, context ).build( builder, type );
+			let elseSnippet = elseNode.build( builder, type );
 
 			if ( elseSnippet ) {
 

package/{examples/jsm → src}/nodes/math/MathNode.js

@@ -1,7 +1,7 @@
 import TempNode from '../core/TempNode.js';
 import { sub, mul, div } from './OperatorNode.js';
 import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, nodeObject, nodeProxy, float, vec3, vec4 } from '../shadernode/ShaderNode.js';
+import { addNodeElement, nodeObject, nodeProxy, float, vec2, vec3, vec4, tslFn } from '../shadernode/ShaderNode.js';
 
 class MathNode extends TempNode {
 
@@ -237,6 +237,7 @@ MathNode.RECIPROCAL = 'reciprocal';
 MathNode.TRUNC = 'trunc';
 MathNode.FWIDTH = 'fwidth';
 MathNode.BITCAST = 'bitcast';
+MathNode.TRANSPOSE = 'transpose';
 
 // 2 inputs
 
@@ -302,6 +303,7 @@ export const reciprocal = nodeProxy( MathNode, MathNode.RECIPROCAL );
 export const trunc = nodeProxy( MathNode, MathNode.TRUNC );
 export const fwidth = nodeProxy( MathNode, MathNode.FWIDTH );
 export const bitcast = nodeProxy( MathNode, MathNode.BITCAST );
+export const transpose = nodeProxy( MathNode, MathNode.TRANSPOSE );
 
 export const atan2 = nodeProxy( MathNode, MathNode.ATAN2 );
 export const min = nodeProxy( MathNode, MathNode.MIN );
@@ -328,6 +330,15 @@ export const refract = nodeProxy( MathNode, MathNode.REFRACT );
 export const smoothstep = nodeProxy( MathNode, MathNode.SMOOTHSTEP );
 export const faceForward = nodeProxy( MathNode, MathNode.FACEFORWARD );
 
+export const rand = tslFn( ( [ uv ] ) => {
+
+	const a = 12.9898, b = 78.233, c = 43758.5453;
+	const dt = dot( uv.xy, vec2( a, b ) ), sn = mod( dt, PI );
+
+	return fract( sin( sn ).mul( c ) );
+
+} );
+
 export const mixElement = ( t, e1, e2 ) => mix( e1, e2, t );
 export const smoothstepElement = ( x, low, high ) => smoothstep( low, high, x );
 
@@ -387,5 +398,7 @@ addNodeElement( 'faceForward', faceForward );
 addNodeElement( 'difference', difference );
 addNodeElement( 'saturate', saturate );
 addNodeElement( 'cbrt', cbrt );
+addNodeElement( 'transpose', transpose );
+addNodeElement( 'rand', rand );
 
 addNodeClass( 'MathNode', MathNode );

package/{examples/jsm → src}/nodes/math/OperatorNode.js

@@ -8,22 +8,22 @@ class OperatorNode extends TempNode {
 
 		super();
 
-		this.op = op;
-
 		if ( params.length > 0 ) {
 
-			let finalBNode = bNode;
+			let finalOp = new OperatorNode( op, aNode, bNode );
 
-			for ( let i = 0; i < params.length; i ++ ) {
+			for ( let i = 0; i < params.length - 1; i ++ ) {
 
-				finalBNode = new OperatorNode( op, finalBNode, params[ i ] );
+				finalOp = new OperatorNode( op, finalOp, params[ i ] );
 
 			}
 
-			bNode = finalBNode;
+			aNode = finalOp;
+			bNode = params[ params.length - 1 ];
 
 		}
 
+		this.op = op;
 		this.aNode = aNode;
 		this.bNode = bNode;
 

package/{examples/jsm → src}/nodes/parsers/GLSLNodeFunction.js

@@ -79,7 +79,7 @@ const parse = ( source ) => {
 		const name = declaration[ 3 ] !== undefined ? declaration[ 3 ] : '';
 		const type = declaration[ 2 ];
 
-		const presicion = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
+		const precision = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
 
 		const headerCode = pragmaMainIndex !== - 1 ? source.slice( 0, pragmaMainIndex ) : '';
 
@@ -87,7 +87,7 @@ const parse = ( source ) => {
 			type,
 			inputs,
 			name,
-			presicion,
+			precision,
 			inputsCode,
 			blockCode,
 			headerCode
@@ -105,9 +105,9 @@ class GLSLNodeFunction extends NodeFunction {
 
 	constructor( source ) {
 
-		const { type, inputs, name, presicion, inputsCode, blockCode, headerCode } = parse( source );
+		const { type, inputs, name, precision, inputsCode, blockCode, headerCode } = parse( source );
 
-		super( type, inputs, name, presicion );
+		super( type, inputs, name, precision );
 
 		this.inputsCode = inputsCode;
 		this.blockCode = blockCode;
@@ -123,13 +123,13 @@ class GLSLNodeFunction extends NodeFunction {
 
 		if ( blockCode !== '' ) {
 
-			const { type, inputsCode, headerCode, presicion } = this;
+			const { type, inputsCode, headerCode, precision } = this;
 
 			let declarationCode = `${ type } ${ name } ( ${ inputsCode.trim() } )`;
 
-			if ( presicion !== '' ) {
+			if ( precision !== '' ) {
 
-				declarationCode = `${ presicion } ${ declarationCode }`;
+				declarationCode = `${ precision } ${ declarationCode }`;
 
 			}
 

package/{examples/jsm → src}/nodes/pmrem/PMREMNode.js

@@ -5,7 +5,8 @@ import { textureCubeUV } from './PMREMUtils.js';
 import { uniform } from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-import { WebGLCoordinateSystem } from 'three';
+
+import { WebGLCoordinateSystem } from '../../constants.js';
 
 let _generator = null;
 

package/{examples/jsm → src}/nodes/shadernode/ShaderNode.js

@@ -351,6 +351,8 @@ class ShaderNodeInternal extends Node {
 		this.jsFunc = jsFunc;
 		this.layout = null;
 
+		this.global = true;
+
 	}
 
 	get isArrayInput() {

package/{examples/jsm → src}/nodes/utils/DiscardNode.js

@@ -21,6 +21,7 @@ export default DiscardNode;
 
 export const inlineDiscard = nodeProxy( DiscardNode );
 export const discard = ( condNode ) => inlineDiscard( condNode ).append();
+export const Return = () => expression( 'return' ).append();
 
 addNodeElement( 'discard', discard ); // @TODO: Check... this cause a little confusing using in chaining
 

package/{examples/jsm → src}/nodes/utils/FunctionOverloadingNode.js

@@ -12,6 +12,8 @@ class FunctionOverloadingNode extends Node {
 
 		this._candidateFnCall = null;
 
+		this.global = true;
+
 	}
 
 	getNodeType() {

package/{examples/jsm → src}/nodes/utils/LoopNode.js

@@ -1,7 +1,6 @@
 import Node, { addNodeClass } from '../core/Node.js';
 import { expression } from '../code/ExpressionNode.js';
 import { bypass } from '../core/BypassNode.js';
-import { context } from '../core/ContextNode.js';
 import { addNodeElement, nodeObject, nodeArray } from '../shadernode/ShaderNode.js';
 
 class LoopNode extends Node {
@@ -41,8 +40,12 @@ class LoopNode extends Node {
 
 		}
 
-		properties.returnsNode = this.params[ this.params.length - 1 ]( inputs, builder.addStack(), builder );
-		properties.stackNode = builder.removeStack();
+		const stack = builder.addStack(); // TODO: cache() it
+
+		properties.returnsNode = this.params[ this.params.length - 1 ]( inputs, stack, builder );
+		properties.stackNode = stack;
+
+		builder.removeStack();
 
 		return properties;
 
@@ -68,8 +71,6 @@ class LoopNode extends Node {
 
 		const properties = this.getProperties( builder );
 
-		const contextData = { tempWrite: false };
-
 		const params = this.params;
 		const stackNode = properties.stackNode;
 
@@ -169,7 +170,7 @@ class LoopNode extends Node {
 
 		}
 
-		const stackSnippet = context( stackNode, contextData ).build( builder, 'void' );
+		const stackSnippet = stackNode.build( builder, 'void' );
 
 		const returnsSnippet = properties.returnsNode ? properties.returnsNode.build( builder ) : '';
 

package/{examples/jsm → src}/nodes/utils/MaxMipLevelNode.js

@@ -9,15 +9,21 @@ class MaxMipLevelNode extends UniformNode {
 
 		super( 0 );
 
-		this.textureNode = textureNode;
+		this._textureNode = textureNode;
 
 		this.updateType = NodeUpdateType.FRAME;
 
 	}
 
+	get textureNode() {
+
+		return this._textureNode;
+
+	}
+
 	get texture() {
 
-		return this.textureNode.value;
+		return this._textureNode.value;
 
 	}
 

package/src/nodes/utils/RTTNode.js

@@ -0,0 +1,130 @@
+import { nodeObject, addNodeElement } from '../shadernode/ShaderNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { addNodeClass } from '../core/Node.js';
+import NodeMaterial from '../materials/NodeMaterial.js';
+import { uv } from '../accessors/UVNode.js';
+import QuadMesh from '../../renderers/common/QuadMesh.js';
+
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { HalfFloatType } from '../../constants.js';
+
+const _size = /*@__PURE__*/ new Vector2();
+
+class RTTNode extends TextureNode {
+
+	constructor( node, width = null, height = null, options = { type: HalfFloatType } ) {
+
+		const renderTarget = new RenderTarget( width, height, options );
+
+		super( renderTarget.texture, uv() );
+
+		this.node = node;
+		this.width = width;
+		this.height = height;
+
+		this.renderTarget = renderTarget;
+
+		this.textureNeedsUpdate = true;
+		this.autoUpdate = true;
+
+		this.updateMap = new WeakMap();
+
+		this._rttNode = null;
+		this._quadMesh = new QuadMesh( new NodeMaterial() );
+
+		this.updateBeforeType = NodeUpdateType.RENDER;
+
+	}
+
+	get autoSize() {
+
+		return this.width === null;
+
+	}
+
+	setup( builder ) {
+
+		this._rttNode = this.node.context( builder.getSharedContext() );
+		this._quadMesh.material.needsUpdate = true;
+
+		return super.setup( builder );
+
+	}
+
+	setSize( width, height ) {
+
+		this.width = width;
+		this.height = height;
+
+		const effectiveWidth = width * this.pixelRatio;
+		const effectiveHeight = height * this.pixelRatio;
+
+		this.renderTarget.setSize( effectiveWidth, effectiveHeight );
+
+		this.textureNeedsUpdate = true;
+
+	}
+
+	setPixelRatio( pixelRatio ) {
+
+		this.pixelRatio = pixelRatio;
+
+		this.setSize( this.width, this.height );
+
+	}
+
+	updateBefore( { renderer } ) {
+
+		if ( this.textureNeedsUpdate === false && this.autoUpdate === false ) return;
+
+		this.textureNeedsUpdate = false;
+
+		//
+
+		if ( this.autoSize === true ) {
+
+			this.pixelRatio = renderer.getPixelRatio();
+
+			const size = renderer.getSize( _size );
+
+			this.setSize( size.width, size.height );
+
+		}
+
+		//
+
+		this._quadMesh.material.fragmentNode = this._rttNode;
+
+		//
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		renderer.setRenderTarget( this.renderTarget );
+
+		this._quadMesh.render( renderer );
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+	}
+
+	clone() {
+
+		const newNode = new TextureNode( this.value, this.uvNode, this.levelNode );
+		newNode.sampler = this.sampler;
+		newNode.referenceNode = this;
+
+		return newNode;
+
+	}
+
+}
+
+export default RTTNode;
+
+export const rtt = ( node, ...params ) => nodeObject( new RTTNode( nodeObject( node ), ...params ) );
+
+addNodeElement( 'toTexture', ( node, ...params ) => node.isTextureNode ? node : rtt( node, ...params ) );
+
+addNodeClass( 'RTTNode', RTTNode );

package/{examples/jsm → src}/nodes/utils/ReflectorNode.js

@@ -2,7 +2,15 @@ import TextureNode from '../accessors/TextureNode.js';
 import { nodeObject, vec2 } from '../shadernode/ShaderNode.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { viewportTopLeft } from '../display/ViewportNode.js';
-import { Matrix4, Vector2, Vector3, Vector4, Object3D, Plane, RenderTarget, HalfFloatType, LinearMipMapLinearFilter } from 'three';
+
+import { HalfFloatType, LinearMipMapLinearFilter } from '../../constants.js';
+import { Plane } from '../../math/Plane.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
 
 const _reflectorPlane = new Plane();
 const _normal = new Vector3();