super-three 0.141.0 → 0.144.0

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

@@ -0,0 +1,94 @@
+import TempNode from '../core/TempNode.js';
+import { ShaderNode, vec3, mat3, add, sub, mul, max, div, dot, float, mix, cos, sin, atan2, sqrt } from '../shadernode/ShaderNodeBaseElements.js';
+
+const luminanceNode = new ShaderNode( ( { color } ) => {
+
+	const LUMA = vec3( 0.2125, 0.7154, 0.0721 );
+
+	return dot( color, LUMA );
+
+} );
+
+const saturationNode = new ShaderNode( ( { color, adjustment } ) => {
+
+	const intensityNode = luminanceNode.call( { color } );
+
+	return mix( intensityNode, 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/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

@@ -34,6 +34,8 @@ class ComputeNode extends Node {
 
 	}
 
+	onInit() { }
+
 	update( { renderer } ) {
 
 		renderer.compute( this );

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

@@ -1,7 +1,7 @@
 import LightingNode from './LightingNode.js';
 import ContextNode from '../core/ContextNode.js';
 import MaxMipLevelNode from '../utils/MaxMipLevelNode.js';
-import { ShaderNode, float, add, mul, div, log2, clamp, roughness, reflect, mix, vec3, positionViewDirection, negate, normalize, transformedNormalView, transformedNormalWorld, transformDirection, cameraViewMatrix } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNode, float, add, mul, div, log2, clamp, roughness, reflect, mix, positionViewDirection, negate, normalize, transformedNormalView, transformedNormalWorld, transformDirection, cameraViewMatrix } from '../shadernode/ShaderNodeElements.js';
 
 // taken from here: http://casual-effects.blogspot.ca/2011/08/plausible-environment-lighting-in-two.html
 const getSpecularMIPLevel = new ShaderNode( ( { texture, levelNode } ) => {
@@ -15,7 +15,7 @@ const getSpecularMIPLevel = new ShaderNode( ( { texture, levelNode } ) => {
 
 } );
 
-class EnvironmentLightNode extends LightingNode {
+class EnvironmentNode extends LightingNode {
 
 	constructor( envNode = null ) {
 
@@ -28,13 +28,11 @@ class EnvironmentLightNode extends LightingNode {
 	construct( builder ) {
 
 		const envNode = this.envNode;
-
-		const flipNormalWorld = vec3( negate( transformedNormalWorld.x ), transformedNormalWorld.yz );
+		const properties = builder.getNodeProperties( this );
 
 		let reflectVec = reflect( negate( positionViewDirection ), transformedNormalView );
 		reflectVec = normalize( mix( reflectVec, transformedNormalView, mul( roughness, roughness ) ) );
 		reflectVec = transformDirection( reflectVec, cameraViewMatrix );
-		reflectVec = vec3( negate( reflectVec.x ), reflectVec.yz );
 
 		const radianceContext = new ContextNode( envNode, {
 			tempRead: false,
@@ -45,7 +43,7 @@ class EnvironmentLightNode extends LightingNode {
 
 		const irradianceContext = new ContextNode( envNode, {
 			tempRead: false,
-			uvNode: flipNormalWorld,
+			uvNode: transformedNormalWorld,
 			levelNode: float( 1 ),
 			levelShaderNode: getSpecularMIPLevel
 		} );
@@ -58,8 +56,11 @@ class EnvironmentLightNode extends LightingNode {
 
 		builder.context.iblIrradiance.add( mul( Math.PI, irradianceContext ) );
 
+		properties.radianceContext = radianceContext;
+		properties.irradianceContext = irradianceContext;
+
 	}
 
 }
 
-export default EnvironmentLightNode;
+export default EnvironmentNode;

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

@@ -39,10 +39,10 @@ class LightingContextNode extends ContextNode {
 		};
 
 		const lighting = {
-			radiance : temp( vec3() ),
-			irradiance : temp( vec3() ),
-			iblIrradiance : temp( vec3() ),
-			ambientOcclusion : temp( float( 1 ) )
+			radiance: temp( vec3() ),
+			irradiance: temp( vec3() ),
+			iblIrradiance: temp( vec3() ),
+			ambientOcclusion: temp( float( 1 ) )
 		};
 
 		Object.assign( properties, reflectedLight, lighting );

package/examples/jsm/nodes/loaders/NodeLoader.js

@@ -1,5 +1,5 @@
 import * as Nodes from '../Nodes.js';
-import { Loader } from 'three';
+import { FileLoader, Loader } from 'three';
 
 class NodeLoader extends Loader {
 
@@ -79,7 +79,7 @@ class NodeLoader extends Loader {
 
 	parse( json ) {
 
-		const node = Nodes.fromType( type );
+		const node = Nodes.fromType( json.type );
 		node.uuid = json.uuid;
 
 		const nodes = this.parseNodes( json.inputNodes );

package/examples/jsm/nodes/loaders/NodeMaterialLoader.js

@@ -1,4 +1,35 @@
 import { MaterialLoader } from 'three';
+import {
+	NodeMaterial,
+	LineBasicNodeMaterial,
+	MeshBasicNodeMaterial,
+	MeshStandardNodeMaterial,
+	PointsNodeMaterial,
+	SpriteNodeMaterial
+} from '../materials/Materials.js';
+
+const superFromTypeFunction = MaterialLoader.createMaterialFromType;
+
+MaterialLoader.createMaterialFromType = function ( type ) {
+
+	const materialLib = {
+		NodeMaterial,
+		LineBasicNodeMaterial,
+		MeshBasicNodeMaterial,
+		MeshStandardNodeMaterial,
+		PointsNodeMaterial,
+		SpriteNodeMaterial,
+	};
+
+	if ( materialLib[ type ] !== undefined ) {
+
+		return new materialLib[ type ]();
+
+	}
+
+	return superFromTypeFunction.call( this, type );
+
+};
 
 class NodeMaterialLoader extends MaterialLoader {
 

package/examples/jsm/nodes/materials/Materials.js

@@ -2,44 +2,32 @@ import NodeMaterial from './NodeMaterial.js';
 import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
 import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
 import PointsNodeMaterial from './PointsNodeMaterial.js';
 import SpriteNodeMaterial from './SpriteNodeMaterial.js';
-import { Material } from 'three';
 
 export {
 	NodeMaterial,
 	LineBasicNodeMaterial,
 	MeshBasicNodeMaterial,
 	MeshStandardNodeMaterial,
+	MeshPhysicalNodeMaterial,
 	PointsNodeMaterial,
 	SpriteNodeMaterial
 };
 
-const materialLib = {
-	NodeMaterial,
-	LineBasicNodeMaterial,
-	MeshBasicNodeMaterial,
-	MeshStandardNodeMaterial,
-	PointsNodeMaterial,
-	SpriteNodeMaterial
-};
-
-const fromTypeFunction = Material.fromType;
-
-Material.fromType = function ( type ) {
-
-	if ( materialLib[ type ] !== undefined ) {
-
-		return new materialLib[ type ]();
-
-	}
-
-	return fromTypeFunction.call( this, type );
-
-};
-
 NodeMaterial.fromMaterial = function ( material ) {
 
+	const materialLib = {
+		NodeMaterial,
+		LineBasicNodeMaterial,
+		MeshBasicNodeMaterial,
+		MeshStandardNodeMaterial,
+		MeshPhysicalNodeMaterial,
+		PointsNodeMaterial,
+		SpriteNodeMaterial
+	};
+
 	const type = material.type.replace( 'Material', 'NodeMaterial' );
 
 	if ( materialLib[ type ] === undefined ) {
@@ -50,7 +38,7 @@ NodeMaterial.fromMaterial = function ( material ) {
 
 	const nodeMaterial = new materialLib[ type ]( material );
 
-	for ( let key in material ) {
+	for ( const key in material ) {
 
 		if ( nodeMaterial[ key ] === undefined ) {
 

package/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.js

@@ -0,0 +1,70 @@
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+
+import { MeshPhysicalMaterial } from 'three';
+
+const defaultValues = new MeshPhysicalMaterial();
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshPhysicalNodeMaterial = true;
+
+		this.clearcoatNode = null;
+		this.clearcoatRoughnessNode = null;
+		this.clearcoatNormalNode = null;
+
+		this.sheenNode = null;
+		this.sheenRoughnessNode = null;
+
+		this.iridescenceNode = null;
+		this.iridescenceIORNode = null;
+		this.iridescenceThicknessNode = null;
+
+		this.specularIntensityNode = null;
+		this.specularColorNode = null;
+
+		this.transmissionNode = null;
+		this.thicknessNode = null;
+		this.attenuationDistanceNode = null;
+		this.attenuationColorNode = null;
+
+		this.sheen = 0;
+		this.clearcoat = 0;
+		this.iridescence = 0;
+		this.transmission = 0;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		this.clearcoatNode = source.clearcoatNode;
+		this.clearcoatRoughnessNode = source.clearcoatRoughnessNode;
+		this.clearcoatNormalNode = source.clearcoatNormalNode;
+
+		this.sheenNode = source.sheenNode;
+		this.sheenRoughnessNode = source.sheenRoughnessNode;
+
+		this.iridescenceNode = source.iridescenceNode;
+		this.iridescenceIORNode = source.iridescenceIORNode;
+		this.iridescenceThicknessNode = source.iridescenceThicknessNode;
+
+		this.specularIntensityNode = source.specularIntensityNode;
+		this.specularColorNode = source.specularColorNode;
+
+		this.transmissionNode = source.transmissionNode;
+		this.thicknessNode = source.thicknessNode;
+		this.attenuationDistanceNode = source.attenuationDistanceNode;
+		this.attenuationColorNode = source.attenuationColorNode;
+
+		return super.copy( source );
+
+	}
+
+}

package/examples/jsm/nodes/materials/MeshStandardNodeMaterial.js

@@ -35,9 +35,6 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
 		this.metalnessNode = null;
 		this.roughnessNode = null;
 
-		this.clearcoatNode = null;
-		this.clearcoatRoughnessNode = null;
-
 		this.envNode = null;
 
 		this.lightsNode = null;
@@ -54,7 +51,10 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
 
 		this.generatePosition( builder );
 
-		let { colorNode, diffuseColorNode } = this.generateDiffuseColor( builder );
+		const colorNodes = this.generateDiffuseColor( builder );
+		const { colorNode } = colorNodes;
+		let { diffuseColorNode } = colorNodes;
+
 		const envNode = this.envNode || builder.scene.environmentNode;
 
 		diffuseColorNode = this.generateStandardMaterial( builder, { colorNode, diffuseColorNode } );
@@ -155,9 +155,6 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
 		this.metalnessNode = source.metalnessNode;
 		this.roughnessNode = source.roughnessNode;
 
-		this.clearcoatNode = source.clearcoatNode;
-		this.clearcoatRoughnessNode = source.clearcoatRoughnessNode;
-
 		this.envNode = source.envNode;
 
 		this.lightsNode = source.lightsNode;

package/examples/jsm/nodes/materials/NodeMaterial.js

@@ -1,5 +1,5 @@
 import { Material, ShaderMaterial } from 'three';
-import { getNodesKeys } from '../core/NodeUtils.js';
+import { getNodesKeys, getCacheKey } from '../core/NodeUtils.js';
 import ExpressionNode from '../core/ExpressionNode.js';
 import {
 	float, vec3, vec4,
@@ -37,7 +37,7 @@ class NodeMaterial extends ShaderMaterial {
 
 	customProgramCacheKey() {
 
-		return this.uuid + '-' + this.version;
+		return getCacheKey( this );
 
 	}
 

package/examples/jsm/nodes/materials/SpriteNodeMaterial.js

@@ -2,8 +2,8 @@ import NodeMaterial from './NodeMaterial.js';
 import { SpriteMaterial } from 'three';
 import {
 	vec2, vec3, vec4,
-	assign, add, mul, sub,
-	positionLocal, bypass, length, cos, sin,
+	uniform, add, mul, sub,
+	positionLocal, length, cos, sin,
 	modelViewMatrix, cameraProjectionMatrix, modelWorldMatrix, materialRotation
 } from '../shadernode/ShaderNodeElements.js';
 
@@ -22,13 +22,13 @@ class SpriteNodeMaterial extends NodeMaterial {
 		this.colorNode = null;
 		this.opacityNode = null;
 
-		this.rotationNode = null;
-
 		this.alphaTestNode = null;
 
 		this.lightNode = null;
 
 		this.positionNode = null;
+		this.rotationNode = null;
+		this.scaleNode = null;
 
 		this.setDefaultValues( defaultValues );
 
@@ -40,25 +40,36 @@ class SpriteNodeMaterial extends NodeMaterial {
 
 		// < VERTEX STAGE >
 
-		let vertex = positionLocal;
-
-		if ( this.positionNode !== null ) {
-
-			vertex = bypass( vertex, assign( positionLocal, this.positionNode ) );
+		const { positionNode, rotationNode, scaleNode } = this;
 
-		}
+		const vertex = positionLocal;
 
-		let mvPosition = mul( modelViewMatrix, vec4( 0, 0, 0, 1 ) );
+		let mvPosition = mul( modelViewMatrix, positionNode ? vec4( positionNode.xyz, 1 ) : vec4( 0, 0, 0, 1 ) );
 
-		const scale = vec2(
+		let scale = vec2(
 			length( vec3( modelWorldMatrix[ 0 ].x, modelWorldMatrix[ 0 ].y, modelWorldMatrix[ 0 ].z ) ),
 			length( vec3( modelWorldMatrix[ 1 ].x, modelWorldMatrix[ 1 ].y, modelWorldMatrix[ 1 ].z ) )
 		);
 
-		const alignedPosition = mul( positionLocal.xy, scale );
-		const rotation = this.rotationNode || materialRotation;
+		if ( scaleNode !== null ) {
+
+			scale = mul( scale, scaleNode );
+
+		}
+
+		let alignedPosition = vertex.xy;
 
-		let rotatedPosition = vec2(
+		if ( builder.object.center?.isVector2 === true ) {
+
+			alignedPosition = sub( alignedPosition, sub( uniform( builder.object.center ), vec2( 0.5 ) ) );
+
+		}
+
+		alignedPosition = mul( alignedPosition, scale );
+
+		const rotation = rotationNode || materialRotation;
+
+		const rotatedPosition = vec2(
 			sub( mul( cos( rotation ), alignedPosition.x ), mul( sin( rotation ), alignedPosition.y ) ),
 			add( mul( sin( rotation ), alignedPosition.x ), mul( cos( rotation ), alignedPosition.y ) )
 		);
@@ -78,13 +89,13 @@ class SpriteNodeMaterial extends NodeMaterial {
 		this.colorNode = source.colorNode;
 		this.opacityNode = source.opacityNode;
 
-		this.rotationNode = source.rotationNode;
-
 		this.alphaTestNode = source.alphaTestNode;
 
 		this.lightNode = source.lightNode;
 
 		this.positionNode = source.positionNode;
+		this.rotationNode = source.rotationNode;
+		this.scaleNode = source.scaleNode;
 
 		return super.copy( source );