super-three 0.136.1 → 0.144.0

package/examples/jsm/nodes/functions/material/getRoughness.js

@@ -0,0 +1,18 @@
+import getGeometryRoughness from './getGeometryRoughness.js';
+import { ShaderNode, add, max, min } from '../../shadernode/ShaderNodeBaseElements.js';
+
+const getRoughness = new ShaderNode( ( inputs ) => {
+
+	const { roughness } = inputs;
+
+	const geometryRoughness = getGeometryRoughness.call();
+
+	let roughnessFactor = max( roughness, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.
+	roughnessFactor = add( roughnessFactor, geometryRoughness );
+	roughnessFactor = min( roughnessFactor, 1.0 );
+
+	return roughnessFactor;
+
+} );
+
+export default getRoughness;

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

@@ -0,0 +1,65 @@
+import Node from '../core/Node.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+class ComputeNode extends Node {
+
+	constructor( computeNode, count, workgroupSize = [ 64 ] ) {
+
+		super( 'void' );
+
+		this.isComputeNode = true;
+
+		this.computeNode = computeNode;
+
+		this.count = count;
+		this.workgroupSize = workgroupSize;
+		this.dispatchCount = 0;
+
+		this.updateType = NodeUpdateType.Object;
+
+		this.updateDispatchCount();
+
+	}
+
+	updateDispatchCount() {
+
+		const { count, workgroupSize } = this;
+
+		let size = workgroupSize[ 0 ];
+
+		for ( let i = 1; i < workgroupSize.length; i ++ )
+			size *= workgroupSize[ i ];
+
+		this.dispatchCount = Math.ceil( count / size );
+
+	}
+
+	onInit() { }
+
+	update( { renderer } ) {
+
+		renderer.compute( this );
+
+	}
+
+	generate( builder ) {
+
+		const { shaderStage } = builder;
+
+		if ( shaderStage === 'compute' ) {
+
+			const snippet = this.computeNode.build( builder, 'void' );
+
+			if ( snippet !== '' ) {
+
+				builder.addFlowCode( snippet );
+
+			}
+
+		}
+
+	}
+
+}
+
+export default ComputeNode;

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

@@ -0,0 +1,25 @@
+import LightingNode from './LightingNode.js';
+import { float, add, mul, sub } from '../shadernode/ShaderNodeElements.js';
+
+class AONode extends LightingNode {
+
+	constructor( aoNode = null ) {
+
+		super();
+
+		this.aoNode = aoNode;
+
+	}
+
+	construct( builder ) {
+
+		const aoIntensity = 1;
+		const aoNode = add( mul( sub( float( this.aoNode ), 1.0 ), aoIntensity ), 1.0 );
+
+		builder.context.ambientOcclusion.mul( aoNode );
+
+	}
+
+}
+
+export default AONode;

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

@@ -0,0 +1,37 @@
+import LightingNode from './LightingNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../shadernode/ShaderNodeElements.js';
+
+import { Color } from 'three';
+
+class AnalyticLightNode extends LightingNode {
+
+	constructor( light = null ) {
+
+		super();
+
+		this.updateType = NodeUpdateType.Object;
+
+		this.light = light;
+
+		this.colorNode = uniform( new Color() );
+
+	}
+
+	getHash( /*builder*/ ) {
+
+		return this.light.uuid;
+
+	}
+
+	update( /*frame*/ ) {
+
+		const { light } = this;
+
+		this.colorNode.value.copy( light.color ).multiplyScalar( light.intensity );
+
+	}
+
+}
+
+export default AnalyticLightNode;

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

@@ -0,0 +1,66 @@
+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, 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 } ) => {
+
+	const maxMIPLevelScalar = new MaxMipLevelNode( texture );
+
+	const sigma = div( mul( Math.PI, mul( levelNode, levelNode ) ), add( 1.0, levelNode ) );
+	const desiredMIPLevel = add( maxMIPLevelScalar, log2( sigma ) );
+
+	return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
+
+} );
+
+class EnvironmentNode extends LightingNode {
+
+	constructor( envNode = null ) {
+
+		super();
+
+		this.envNode = envNode;
+
+	}
+
+	construct( builder ) {
+
+		const envNode = this.envNode;
+		const properties = builder.getNodeProperties( this );
+
+		let reflectVec = reflect( negate( positionViewDirection ), transformedNormalView );
+		reflectVec = normalize( mix( reflectVec, transformedNormalView, mul( roughness, roughness ) ) );
+		reflectVec = transformDirection( reflectVec, cameraViewMatrix );
+
+		const radianceContext = new ContextNode( envNode, {
+			tempRead: false,
+			uvNode: reflectVec,
+			levelNode: roughness,
+			levelShaderNode: getSpecularMIPLevel
+		} );
+
+		const irradianceContext = new ContextNode( envNode, {
+			tempRead: false,
+			uvNode: transformedNormalWorld,
+			levelNode: float( 1 ),
+			levelShaderNode: getSpecularMIPLevel
+		} );
+
+		// it's used to cache the construct only if necessary: See `CubeTextureNode.getConstructReference()`
+		radianceContext.context.environmentContext = radianceContext;
+		irradianceContext.context.environmentContext = irradianceContext;
+
+		builder.context.radiance.add( radianceContext );
+
+		builder.context.iblIrradiance.add( mul( Math.PI, irradianceContext ) );
+
+		properties.radianceContext = radianceContext;
+		properties.irradianceContext = irradianceContext;
+
+	}
+
+}
+
+export default EnvironmentNode;

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

@@ -0,0 +1,50 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import LightsNode from './LightsNode.js';
+import Object3DNode from '../accessors/Object3DNode.js';
+import { uniform, add, mul, dot, mix, normalize, normalView } from '../shadernode/ShaderNodeElements.js';
+
+import { Color, HemisphereLight } from 'three';
+
+class HemisphereLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this.lightPositionNode = new Object3DNode( Object3DNode.POSITION );
+		this.lightDirectionNode = normalize( this.lightPositionNode );
+
+		this.groundColorNode = uniform( new Color() );
+
+	}
+
+	update( frame ) {
+
+		const { light } = this;
+
+		super.update( frame );
+
+		this.lightPositionNode.object3d = light;
+
+		this.groundColorNode.value.copy( light.groundColor ).multiplyScalar( light.intensity );
+
+	}
+
+	generate( builder ) {
+
+		const { colorNode, groundColorNode, lightDirectionNode } = this;
+
+		const dotNL = dot( normalView, lightDirectionNode );
+		const hemiDiffuseWeight = add( mul( 0.5, dotNL ), 0.5 );
+
+		const irradiance = mix( groundColorNode, colorNode, hemiDiffuseWeight );
+
+		builder.context.irradiance.add( irradiance );
+
+	}
+
+}
+
+LightsNode.setReference( HemisphereLight, HemisphereLightNode );
+
+export default HemisphereLightNode;

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

@@ -0,0 +1,75 @@
+import ContextNode from '../core/ContextNode.js';
+import { float, vec3, add, temp } from '../shadernode/ShaderNodeBaseElements.js';
+
+class LightingContextNode extends ContextNode {
+
+	constructor( node, lightingModelNode = null ) {
+
+		super( node );
+
+		this.lightingModelNode = lightingModelNode;
+
+	}
+
+	getNodeType( /*builder*/ ) {
+
+		return 'vec3';
+
+	}
+
+	construct( builder ) {
+
+		const { lightingModelNode } = this;
+
+		const context = this.context = {}; // reset context
+		const properties = builder.getNodeProperties( this );
+
+		const directDiffuse = temp( vec3() ),
+			directSpecular = temp( vec3() ),
+			indirectDiffuse = temp( vec3() ),
+			indirectSpecular = temp( vec3() ),
+			total = add( directDiffuse, directSpecular, indirectDiffuse, indirectSpecular );
+
+		const reflectedLight = {
+			directDiffuse,
+			directSpecular,
+			indirectDiffuse,
+			indirectSpecular,
+			total
+		};
+
+		const lighting = {
+			radiance: temp( vec3() ),
+			irradiance: temp( vec3() ),
+			iblIrradiance: temp( vec3() ),
+			ambientOcclusion: temp( float( 1 ) )
+		};
+
+		Object.assign( properties, reflectedLight, lighting );
+		Object.assign( context, lighting );
+
+		context.reflectedLight = reflectedLight;
+		context.lightingModelNode = lightingModelNode || context.lightingModelNode;
+
+		if ( lightingModelNode?.indirectDiffuse ) lightingModelNode.indirectDiffuse.call( context );
+		if ( lightingModelNode?.indirectSpecular ) lightingModelNode.indirectSpecular.call( context );
+		if ( lightingModelNode?.ambientOcclusion ) lightingModelNode.ambientOcclusion.call( context );
+
+		return super.construct( builder );
+
+	}
+
+	generate( builder ) {
+
+		const { context } = this;
+		const type = this.getNodeType( builder );
+
+		super.generate( builder, type );
+
+		return context.reflectedLight.total.build( builder, type );
+
+	}
+
+}
+
+export default LightingContextNode;

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

@@ -0,0 +1,19 @@
+import Node from '../core/Node.js';
+
+class LightingNode extends Node {
+
+	constructor() {
+
+		super( 'vec3' );
+
+	}
+
+	generate( /*builder*/ ) {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
+}
+
+export default LightingNode;

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

@@ -0,0 +1,120 @@
+import Node from '../core/Node.js';
+import LightingNode from './LightingNode.js';
+
+const references = new WeakMap();
+
+const sortLights = ( lights ) => {
+
+	return lights.sort( ( a, b ) => a.id - b.id );
+
+};
+
+class LightsNode extends Node {
+
+	constructor( lightNodes = [] ) {
+
+		super( 'vec3' );
+
+		this.lightNodes = lightNodes;
+
+		this._hash = null;
+
+	}
+
+	get hasLight() {
+
+		return this.lightNodes.length > 0;
+
+	}
+
+	construct( builder ) {
+
+		const lightNodes = this.lightNodes;
+
+		for ( const lightNode of lightNodes ) {
+
+			lightNode.build( builder );
+
+		}
+
+	}
+
+	getHash( builder ) {
+
+		if ( this._hash === null ) {
+
+			let hash = '';
+
+			const lightNodes = this.lightNodes;
+
+			for ( const lightNode of lightNodes ) {
+
+				hash += lightNode.getHash( builder ) + ' ';
+
+			}
+
+			this._hash = hash;
+
+		}
+
+		return this._hash;
+
+	}
+
+	getLightNodeByHash( hash ) {
+
+		const lightNodes = this.lightNodes;
+
+		for ( const lightNode of lightNodes ) {
+
+			if ( lightNode.light.uuid === hash ) {
+
+				return lightNode;
+
+			}
+
+		}
+
+		return null;
+
+	}
+
+	fromLights( lights ) {
+
+		const lightNodes = [];
+
+		lights = sortLights( lights );
+
+		for ( const light of lights ) {
+
+			let lightNode = this.getLightNodeByHash( light.uuid );
+
+			if ( lightNode === null ) {
+
+				const lightClass = light.constructor;
+				const lightNodeClass = references.has( lightClass ) ? references.get( lightClass ) : LightingNode;
+
+				lightNode = new lightNodeClass( light );
+
+			}
+
+			lightNodes.push( lightNode );
+
+		}
+
+		this.lightNodes = lightNodes;
+		this._hash = null;
+
+		return this;
+
+	}
+
+	static setReference( lightClass, lightNodeClass ) {
+
+		references.set( lightClass, lightNodeClass );
+
+	}
+
+}
+
+export default LightsNode;

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

@@ -0,0 +1,68 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import LightsNode from './LightsNode.js';
+import Object3DNode from '../accessors/Object3DNode.js';
+import getDistanceAttenuation from '../functions/light/getDistanceAttenuation.js';
+import { uniform, mul, normalize, length, sub, positionView } from '../shadernode/ShaderNodeElements.js';
+
+import { PointLight } from 'three';
+
+class PunctualLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this.cutoffDistanceNode = uniform( 0 );
+		this.decayExponentNode = uniform( 0 );
+
+	}
+
+	update( frame ) {
+
+		const { light } = this;
+
+		super.update( frame );
+
+		this.cutoffDistanceNode.value = light.distance;
+		this.decayExponentNode.value = light.decay;
+
+	}
+
+	construct( builder ) {
+
+		const { colorNode, cutoffDistanceNode, decayExponentNode } = this;
+
+		const lightPositionViewNode = new Object3DNode( Object3DNode.VIEW_POSITION, this.light );
+		const lVector = sub( lightPositionViewNode, positionView );
+
+		const lightDirection = normalize( lVector );
+		const lightDistance = length( lVector );
+
+		const lightAttenuation = getDistanceAttenuation.call( {
+			lightDistance,
+			cutoffDistance: cutoffDistanceNode,
+			decayExponent: decayExponentNode
+		} );
+
+		const lightColor = mul( colorNode, lightAttenuation );
+
+		const lightingModelFunctionNode = builder.context.lightingModelNode;
+		const reflectedLight = builder.context.reflectedLight;
+
+		if ( lightingModelFunctionNode?.direct ) {
+
+			lightingModelFunctionNode.direct.call( {
+				lightDirection,
+				lightColor,
+				reflectedLight
+			}, builder );
+
+		}
+
+	}
+
+}
+
+LightsNode.setReference( PointLight, PunctualLightNode );
+
+export default PunctualLightNode;