super-three 0.141.0 → 0.147.0

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

@@ -0,0 +1,56 @@
+import Node from './Node.js';
+import { NodeShaderStage } from './constants.js';
+
+class VaryingNode extends Node {
+
+	constructor( node, name = null ) {
+
+		super();
+
+		this.node = node;
+		this.name = name;
+
+	}
+
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
+
+	}
+
+	getNodeType( builder ) {
+
+		// VaryingNode is auto type
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	generate( builder ) {
+
+		const { name, node } = this;
+		const type = this.getNodeType( builder );
+
+		const nodeVarying = builder.getVaryingFromNode( this, type );
+
+		// this property can be used to check if the varying can be optimized for a var
+		nodeVarying.needsInterpolation ||= builder.shaderStage === 'fragment';
+
+		if ( name !== null ) {
+
+			nodeVarying.name = name;
+
+		}
+
+		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.VERTEX );
+
+		// force node run in vertex stage
+		builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, node, type, propertyName );
+
+		return builder.getPropertyName( nodeVarying );
+
+	}
+
+}
+
+export default VaryingNode;

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

@@ -1,21 +1,21 @@
 export const NodeShaderStage = {
-	Vertex: 'vertex',
-	Fragment: 'fragment'
+	VERTEX: 'vertex',
+	FRAGMENT: 'fragment'
 };
 
 export const NodeUpdateType = {
-	None: 'none',
-	Frame: 'frame',
-	Object: 'object'
+	NONE: 'none',
+	FRAME: 'frame',
+	OBJECT: 'object'
 };
 
 export const NodeType = {
-	Boolean: 'bool',
-	Integer: 'int',
-	Float: 'float',
-	Vector2: 'vec2',
-	Vector3: 'vec3',
-	Vector4: 'vec4',
-	Matrix3: 'mat3',
-	Matrix4: 'mat4'
+	BOOLEAN: 'bool',
+	INTEGER: 'int',
+	FLOAT: 'float',
+	VECTOR2: 'vec2',
+	VECTOR3: 'vec3',
+	VECTOR4: 'vec4',
+	MATRIX3: 'mat3',
+	MATRIX4: 'mat4'
 };

package/examples/jsm/nodes/display/BlendModeNode.js

@@ -0,0 +1,85 @@
+import TempNode from '../core/Node.js';
+import { ShaderNode, EPSILON, vec3, sub, mul, div, cond, lessThan, equal, max } from '../shadernode/ShaderNodeBaseElements.js';
+
+export const BurnNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( lessThan( blend[ c ], EPSILON ), blend[ c ], max( sub( 1.0, div( sub( 1.0, base[ c ] ), blend[ c ] ) ), 0 ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const DodgeNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( equal( blend[ c ], 1.0 ), blend[ c ], max( div( base[ c ], sub( 1.0, blend[ c ] ) ), 0 ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const ScreenNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => sub( 1.0, mul( sub( 1.0, base[ c ] ), sub( 1.0, blend[ c ] ) ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const OverlayNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( lessThan( base[ c ], 0.5 ), mul( 2.0, base[ c ], blend[ c ] ), sub( 1.0, mul( sub( 1.0, base[ c ] ), sub( 1.0, blend[ c ] ) ) ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+class BlendModeNode extends TempNode {
+
+	static BURN = 'burn';
+	static DODGE = 'dodge';
+	static SCREEN = 'screen';
+	static OVERLAY = 'overlay';
+
+	constructor( blendMode, baseNode, blendNode ) {
+
+		super();
+
+		this.blendMode = blendMode;
+
+		this.baseNode = baseNode;
+		this.blendNode = blendNode;
+
+	}
+
+	construct() {
+
+		const { blendMode, baseNode, blendNode } = this;
+		const params = { base: baseNode, blend: blendNode };
+
+		let outputNode = null;
+
+		if ( blendMode === BlendModeNode.BURN ) {
+
+			outputNode = BurnNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.DODGE ) {
+
+			outputNode = DodgeNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.SCREEN ) {
+
+			outputNode = ScreenNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.OVERLAY ) {
+
+			outputNode = OverlayNode.call( params );
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default BlendModeNode;

package/examples/jsm/nodes/display/ColorAdjustmentNode.js

@@ -0,0 +1,84 @@
+import TempNode from '../core/TempNode.js';
+import { ShaderNode, vec3, mat3, add, sub, mul, max, div, float, mix, cos, sin, atan2, sqrt, luminance } from '../shadernode/ShaderNodeBaseElements.js';
+
+const saturationNode = new ShaderNode( ( { color, adjustment } ) => {
+
+	return mix( luminance( color ), color, adjustment );
+
+} );
+
+const vibranceNode = new ShaderNode( ( { color, adjustment } ) => {
+
+	const average = div( add( color.r, color.g, color.b ), 3.0 );
+
+	const mx = max( color.r, max( color.g, color.b ) );
+	const amt = mul( sub( mx, average ), mul( - 3.0, adjustment ) );
+
+	return mix( color.rgb, vec3( mx ), amt );
+
+} );
+
+const hueNode = new ShaderNode( ( { color, adjustment } ) => {
+
+	const RGBtoYIQ = mat3( 0.299, 0.587, 0.114, 0.595716, - 0.274453, - 0.321263, 0.211456, - 0.522591, 0.311135 );
+	const YIQtoRGB = mat3( 1.0, 0.9563, 0.6210, 1.0, - 0.2721, - 0.6474, 1.0, - 1.107, 1.7046 );
+
+	const yiq = mul( RGBtoYIQ, color );
+
+	const hue = add( atan2( yiq.z, yiq.y ), adjustment );
+	const chroma = sqrt( add( mul( yiq.z, yiq.z ), mul( yiq.y, yiq.y ) ) );
+
+	return mul( YIQtoRGB, vec3( yiq.x, mul( chroma, cos( hue ) ), mul( chroma, sin( hue ) ) ) );
+
+} );
+
+class ColorAdjustmentNode extends TempNode {
+
+	static SATURATION = 'saturation';
+	static VIBRANCE = 'vibrance';
+	static HUE = 'hue';
+
+	constructor( method, colorNode, adjustmentNode = float( 1 ) ) {
+
+		super( 'vec3' );
+
+		this.method = method;
+
+		this.colorNode = colorNode;
+		this.adjustmentNode = adjustmentNode;
+
+	}
+
+	construct() {
+
+		const { method, colorNode, adjustmentNode } = this;
+
+		const callParams = { color: colorNode, adjustment: adjustmentNode };
+
+		let outputNode = null;
+
+		if ( method === ColorAdjustmentNode.SATURATION ) {
+
+			outputNode = saturationNode.call( callParams );
+
+		} else if ( method === ColorAdjustmentNode.VIBRANCE ) {
+
+			outputNode = vibranceNode.call( callParams );
+
+		} else if ( method === ColorAdjustmentNode.HUE ) {
+
+			outputNode = hueNode.call( callParams );
+
+		} else {
+
+			console.error( `${ this.type }: Method "${ this.method }" not supported!` );
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default ColorAdjustmentNode;

package/examples/jsm/nodes/display/NormalMapNode.js

@@ -1,6 +1,5 @@
 import TempNode from '../core/TempNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import { ShaderNode, positionView, normalView, uv, vec3, add, sub, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, faceDirection } from '../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode, positionView, normalView, uv, vec3, add, sub, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, faceDirection, modelNormalMatrix, TBNViewMatrix } from '../shadernode/ShaderNodeBaseElements.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
 
@@ -44,7 +43,7 @@ class NormalMapNode extends TempNode {
 
 	}
 
-	construct() {
+	construct( builder ) {
 
 		const { normalMapType, scaleNode } = this;
 
@@ -62,18 +61,26 @@ class NormalMapNode extends TempNode {
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
 
-			const vertexNormalNode = mul( new ModelNode( ModelNode.NORMAL_MATRIX ), normalMap );
-
-			outputNode = normalize( vertexNormalNode );
+			outputNode = normalize( mul( modelNormalMatrix, normalMap ) );
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
-			outputNode = perturbNormal2ArbNode.call( {
-				eye_pos: positionView,
-				surf_norm: normalView,
-				mapN: normalMap,
-				uv: uv()
-			} );
+			const tangent = builder.hasGeometryAttribute( 'tangent' );
+
+			if ( tangent === true ) {
+
+				outputNode = normalize( mul( TBNViewMatrix, normalMap ) );
+
+			} else {
+
+				outputNode = perturbNormal2ArbNode.call( {
+					eye_pos: positionView,
+					surf_norm: normalView,
+					mapN: normalMap,
+					uv: uv()
+				} );
+
+			}
 
 		}
 

package/examples/jsm/nodes/display/PosterizeNode.js

@@ -0,0 +1,25 @@
+import TempNode from '../core/Node.js';
+import { mul, floor, reciprocal } from '../shadernode/ShaderNodeBaseElements.js';
+
+class PosterizeNode extends TempNode {
+
+	constructor( sourceNode, stepsNode ) {
+
+		super();
+
+		this.sourceNode = sourceNode;
+		this.stepsNode = stepsNode;
+
+	}
+
+	construct() {
+
+		const { sourceNode, stepsNode } = this;
+
+		return mul( floor( mul( sourceNode, stepsNode ) ), reciprocal( stepsNode ) );
+
+	}
+
+}
+
+export default PosterizeNode;

package/examples/jsm/nodes/display/ViewportNode.js

@@ -0,0 +1,106 @@
+import Node from '../core/Node.js';
+import { uniform, div, vec2, invert } from '../shadernode/ShaderNodeBaseElements.js';
+import { Vector2 } from 'three';
+import { NodeUpdateType } from '../core/constants.js';
+
+let resolution;
+
+class ViewportNode extends Node {
+
+	static COORDINATE = 'coordinate';
+	static RESOLUTION = 'resolution';
+	static TOP_LEFT = 'topLeft';
+	static BOTTOM_LEFT = 'bottomLeft';
+	static TOP_RIGHT = 'topRight';
+	static BOTTOM_RIGHT = 'bottomRight';
+
+	constructor( scope ) {
+
+		super();
+
+		this.scope = scope;
+
+		this.isViewportNode = true;
+
+	}
+
+	getNodeType() {
+
+		return this.scope === ViewportNode.COORDINATE ? 'vec4' : 'vec2';
+
+	}
+
+	getUpdateType() {
+
+		let updateType = NodeUpdateType.NONE;
+
+		if ( this.scope === ViewportNode.RESOLUTION ) {
+
+			updateType = NodeUpdateType.FRAME;
+
+		}
+
+		this.updateType = updateType;
+
+		return updateType;
+
+	}
+
+	update( { renderer } ) {
+
+		renderer.getSize( resolution );
+
+	}
+
+	construct( builder ) {
+
+		const scope = this.scope;
+
+		if ( scope === ViewportNode.COORDINATE ) return;
+
+		let output = null;
+
+		if ( scope === ViewportNode.RESOLUTION ) {
+
+			resolution ||= new Vector2();
+
+			output = uniform( resolution );
+
+		} else {
+
+			const coordinateNode = vec2( new ViewportNode( ViewportNode.COORDINATE ) );
+			const resolutionNode = new ViewportNode( ViewportNode.RESOLUTION );
+
+			output = div( coordinateNode, resolutionNode );
+
+			let outX = output.x;
+			let outY = output.y;
+
+			if ( /top/i.test( scope ) && builder.isFlipY() ) outY = invert( outY );
+			else if ( /bottom/i.test( scope ) && builder.isFlipY() === false ) outY = invert( outY );
+
+			if ( /right/i.test( scope ) ) outX = invert( outX );
+
+			output = vec2( outX, outY );
+
+		}
+
+		return output;
+
+	}
+
+	generate( builder ) {
+
+		if ( this.scope === ViewportNode.COORDINATE ) {
+
+			return builder.getFragCoord();
+
+		}
+
+		return super.generate( builder );
+
+	}
+
+}
+
+export default ViewportNode;

package/examples/jsm/nodes/functions/BSDF/BRDF_GGX.js

@@ -2,7 +2,7 @@ import F_Schlick from './F_Schlick.js';
 import V_GGX_SmithCorrelated from './V_GGX_SmithCorrelated.js';
 import D_GGX from './D_GGX.js';
 import {
-	ShaderNode, dotNV, add, mul, saturate, dot, pow2, normalize,
+	ShaderNode, dotNV, add, mul, clamp, dot, pow2, normalize,
 	transformedNormalView, positionViewDirection
 } from '../../shadernode/ShaderNodeBaseElements.js';
 
@@ -15,10 +15,10 @@ const BRDF_GGX = new ShaderNode( ( inputs ) => {
 
 	const halfDir = normalize( add( lightDirection, positionViewDirection ) );
 
-	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
-	//const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
-	const dotNH = saturate( dot( transformedNormalView, halfDir ) );
-	const dotVH = saturate( dot( positionViewDirection, halfDir ) );
+	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
+	//const dotNV = clamp( dot( transformedNormalView, positionViewDirection ) );
+	const dotNH = clamp( dot( transformedNormalView, halfDir ) );
+	const dotVH = clamp( dot( positionViewDirection, halfDir ) );
 
 	const F = F_Schlick.call( { f0, f90, dotVH } );
 

package/examples/jsm/nodes/functions/PhysicalLightingModel.js

@@ -3,7 +3,7 @@ import BRDF_GGX from './BSDF/BRDF_GGX.js';
 import DFGApprox from './BSDF/DFGApprox.js';
 import {
 	ShaderNode,
-	vec3, mul, saturate, add, sub, dot, div, transformedNormalView,
+	vec3, mul, clamp, add, sub, dot, div, transformedNormalView,
 	pow, exp2, dotNV,
 	diffuseColor, specularColor, roughness, temp
 } from '../shadernode/ShaderNodeElements.js';
@@ -61,7 +61,7 @@ const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
 
 	const { lightDirection, lightColor, reflectedLight } = inputs;
 
-	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
 	const irradiance = mul( dotNL, lightColor );
 
 	reflectedLight.directDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
@@ -75,7 +75,7 @@ const RE_AmbientOcclusion_Physical = new ShaderNode( ( { ambientOcclusion, refle
 	const aoNV = add( dotNV, ambientOcclusion );
 	const aoExp = exp2( sub( mul( - 16.0, roughness ), 1.0 ) );
 
-	const aoNode = saturate( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
+	const aoNode = clamp( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
 
 	reflectedLight.indirectDiffuse.mul( ambientOcclusion );
 

package/examples/jsm/nodes/functions/light/getDistanceAttenuation.js

@@ -1,5 +1,5 @@
 import {
-	ShaderNode, div, max, sub, mul, saturate, pow, pow2, pow4, cond, greaterThan
+	ShaderNode, div, max, sub, mul, clamp, pow, pow2, pow4, cond, greaterThan
 } from '../../shadernode/ShaderNodeBaseElements.js';
 
 const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
@@ -13,7 +13,7 @@ const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
 
 	return cond(
 		greaterThan( cutoffDistance, 0 ),
-		mul( distanceFalloff, pow2( saturate( sub( 1.0, pow4( div( lightDistance, cutoffDistance ) ) ) ) ) ),
+		mul( distanceFalloff, pow2( clamp( sub( 1.0, pow4( div( lightDistance, cutoffDistance ) ) ) ) ) ),
 		distanceFalloff
 	);
 

package/examples/jsm/nodes/geometry/RangeNode.js

@@ -0,0 +1,109 @@
+import Node from '../core/Node.js';
+import { attribute, float } from '../shadernode/ShaderNodeBaseElements.js';
+import { MathUtils, InstancedBufferAttribute } from 'three';
+
+class RangeNode extends Node {
+
+	constructor( min, max ) {
+
+		super();
+
+		this.min = min;
+		this.max = max;
+
+	}
+
+	getVectorLength() {
+
+		const min = this.min;
+
+		let length = 1;
+
+		if ( min.isVector2 ) length = 2;
+		else if ( min.isVector3 ) length = 3;
+		else if ( min.isVector4 ) length = 4;
+		else if ( min.isColor ) length = 3;
+
+		return length;
+
+	}
+
+	getNodeType( builder ) {
+
+		return ( builder.object.isInstancedMesh === true ) ? builder.getTypeFromLength( this.getVectorLength() ) : 'float';
+
+	}
+
+	construct( builder ) {
+
+		const { min, max } = this;
+		const { object, geometry } = builder;
+
+		let output = null;
+
+		if ( object.isInstancedMesh === true ) {
+
+			const vectorLength = this.getVectorLength();
+			const attributeName = 'node' + this.id;
+
+			const length = vectorLength * object.count;
+			const array = new Float32Array( length );
+
+			const attributeGeometry = geometry.getAttribute( attributeName );
+
+			if ( attributeGeometry === undefined || attributeGeometry.array.length < length ) {
+
+				if ( vectorLength === 1 ) {
+
+					for ( let i = 0; i < length; i ++ ) {
+
+						array[ i ] = MathUtils.lerp( min, max, Math.random() );
+
+					}
+
+				} else if ( min.isColor ) {
+
+					for ( let i = 0; i < length; i += 3 ) {
+
+						array[ i ] = MathUtils.lerp( min.r, max.r, Math.random() );
+						array[ i + 1 ] = MathUtils.lerp( min.g, max.g, Math.random() );
+						array[ i + 2 ] = MathUtils.lerp( min.b, max.b, Math.random() );
+
+					}
+
+				} else {
+
+					for ( let i = 0; i < length; i ++ ) {
+
+						const index = i % vectorLength;
+
+						const minValue = min.getComponent( index );
+						const maxValue = max.getComponent( index );
+
+						array[ i ] = MathUtils.lerp( minValue, maxValue, Math.random() );
+
+					}
+
+				}
+
+				geometry.setAttribute( attributeName, new InstancedBufferAttribute( array, vectorLength ) );
+
+				geometry.dispose();
+
+			}
+
+			output = attribute( attributeName, builder.getTypeFromLength( vectorLength ) );
+
+		} else {
+
+			output = float( 0 );
+
+		}
+
+		return output;
+
+	}
+
+}
+
+export default RangeNode;

package/examples/jsm/nodes/gpgpu/ComputeNode.js

@@ -15,7 +15,7 @@ class ComputeNode extends Node {
 		this.workgroupSize = workgroupSize;
 		this.dispatchCount = 0;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.updateDispatchCount();
 
@@ -34,6 +34,8 @@ class ComputeNode extends Node {
 
 	}
 
+	onInit() { }
+
 	update( { renderer } ) {
 
 		renderer.compute( this );

package/examples/jsm/nodes/lighting/AnalyticLightNode.js

@@ -10,7 +10,7 @@ class AnalyticLightNode extends LightingNode {
 
 		super();
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.light = light;