@plastic-software/three 0.167.0

package/src/nodes/lighting/BasicLightMapNode.js

@@ -0,0 +1,29 @@
+import LightingNode from './LightingNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { float } from '../shadernode/ShaderNode.js';
+
+class BasicLightMapNode extends LightingNode {
+
+	constructor( lightMapNode = null ) {
+
+		super();
+
+		this.lightMapNode = lightMapNode;
+
+	}
+
+	setup( builder ) {
+
+		// irradianceLightMap property is used in the indirectDiffuse() method of BasicLightingModel
+
+		const RECIPROCAL_PI = float( 1 / Math.PI );
+
+		builder.context.irradianceLightMap = this.lightMapNode.mul( RECIPROCAL_PI );
+
+	}
+
+}
+
+export default BasicLightMapNode;
+
+addNodeClass( 'BasicLightMapNode', BasicLightMapNode );

package/src/nodes/lighting/DirectionalLightNode.js

@@ -0,0 +1,40 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { lightTargetDirection } from './LightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { DirectionalLight } from '../../lights/DirectionalLight.js';
+
+class DirectionalLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+	}
+
+	setup( builder ) {
+
+		super.setup( builder );
+
+		const lightingModel = builder.context.lightingModel;
+
+		const lightColor = this.colorNode;
+		const lightDirection = lightTargetDirection( this.light );
+		const reflectedLight = builder.context.reflectedLight;
+
+		lightingModel.direct( {
+			lightDirection,
+			lightColor,
+			reflectedLight
+		}, builder.stack, builder );
+
+	}
+
+}
+
+export default DirectionalLightNode;
+
+addNodeClass( 'DirectionalLightNode', DirectionalLightNode );
+
+addLightNode( DirectionalLight, DirectionalLightNode );

package/src/nodes/lighting/EnvironmentNode.js

@@ -0,0 +1,136 @@
+import LightingNode from './LightingNode.js';
+import { cache } from '../core/CacheNode.js';
+import { context } from '../core/ContextNode.js';
+import { roughness, clearcoatRoughness } from '../core/PropertyNode.js';
+import { cameraViewMatrix } from '../accessors/CameraNode.js';
+import { transformedClearcoatNormalView, transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { float } from '../shadernode/ShaderNode.js';
+import { reference } from '../accessors/ReferenceNode.js';
+import { transformedBentNormalView } from '../accessors/AccessorsUtils.js';
+import { pmremTexture } from '../pmrem/PMREMNode.js';
+
+const _envNodeCache = new WeakMap();
+
+class EnvironmentNode extends LightingNode {
+
+	constructor( envNode = null ) {
+
+		super();
+
+		this.envNode = envNode;
+
+	}
+
+	setup( builder ) {
+
+		const { material } = builder;
+
+		let envNode = this.envNode;
+
+		if ( envNode.isTextureNode || envNode.isMaterialReferenceNode ) {
+
+			const value = ( envNode.isTextureNode ) ? envNode.value : material[ envNode.property ];
+
+			let cacheEnvNode = _envNodeCache.get( value );
+
+			if ( cacheEnvNode === undefined ) {
+
+				cacheEnvNode = pmremTexture( value );
+
+				_envNodeCache.set( value, cacheEnvNode );
+
+			}
+
+			envNode	= cacheEnvNode;
+
+		}
+
+		//
+
+		const envMap = material.envMap;
+		const intensity = envMap ? reference( 'envMapIntensity', 'float', builder.material ) : reference( 'environmentIntensity', 'float', builder.scene ); // @TODO: Add materialEnvIntensity in MaterialNode
+
+		const useAnisotropy = material.useAnisotropy === true || material.anisotropy > 0;
+		const radianceNormalView = useAnisotropy ? transformedBentNormalView : transformedNormalView;
+
+		const radiance = context( envNode, createRadianceContext( roughness, radianceNormalView ) ).mul( intensity );
+		const irradiance = context( envNode, createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
+
+		const isolateRadiance = cache( radiance );
+		const isolateIrradiance = cache( irradiance );
+
+		//
+
+		builder.context.radiance.addAssign( isolateRadiance );
+
+		builder.context.iblIrradiance.addAssign( isolateIrradiance );
+
+		//
+
+		const clearcoatRadiance = builder.context.lightingModel.clearcoatRadiance;
+
+		if ( clearcoatRadiance ) {
+
+			const clearcoatRadianceContext = context( envNode, createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( intensity );
+			const isolateClearcoatRadiance = cache( clearcoatRadianceContext );
+
+			clearcoatRadiance.addAssign( isolateClearcoatRadiance );
+
+		}
+
+	}
+
+}
+
+const createRadianceContext = ( roughnessNode, normalViewNode ) => {
+
+	let reflectVec = null;
+
+	return {
+		getUV: () => {
+
+			if ( reflectVec === null ) {
+
+				reflectVec = positionViewDirection.negate().reflect( normalViewNode );
+
+				// Mixing the reflection with the normal is more accurate and keeps rough objects from gathering light from behind their tangent plane.
+				reflectVec = roughnessNode.mul( roughnessNode ).mix( reflectVec, normalViewNode ).normalize();
+
+				reflectVec = reflectVec.transformDirection( cameraViewMatrix );
+
+			}
+
+			return reflectVec;
+
+		},
+		getTextureLevel: () => {
+
+			return roughnessNode;
+
+		}
+	};
+
+};
+
+const createIrradianceContext = ( normalWorldNode ) => {
+
+	return {
+		getUV: () => {
+
+			return normalWorldNode;
+
+		},
+		getTextureLevel: () => {
+
+			return float( 1.0 );
+
+		}
+	};
+
+};
+
+export default EnvironmentNode;
+
+addNodeClass( 'EnvironmentNode', EnvironmentNode );

package/src/nodes/lighting/HemisphereLightNode.js

@@ -0,0 +1,56 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { uniform } from '../core/UniformNode.js';
+import { mix } from '../math/MathNode.js';
+import { normalView } from '../accessors/NormalNode.js';
+import { objectPosition } from '../accessors/Object3DNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { Color } from '../../math/Color.js';
+import { HemisphereLight } from '../../lights/HemisphereLight.js';
+
+class HemisphereLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this.lightPositionNode = objectPosition( light );
+		this.lightDirectionNode = this.lightPositionNode.normalize();
+
+		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 );
+
+	}
+
+	setup( builder ) {
+
+		const { colorNode, groundColorNode, lightDirectionNode } = this;
+
+		const dotNL = normalView.dot( lightDirectionNode );
+		const hemiDiffuseWeight = dotNL.mul( 0.5 ).add( 0.5 );
+
+		const irradiance = mix( groundColorNode, colorNode, hemiDiffuseWeight );
+
+		builder.context.irradiance.addAssign( irradiance );
+
+	}
+
+}
+
+export default HemisphereLightNode;
+
+addNodeClass( 'HemisphereLightNode', HemisphereLightNode );
+
+addLightNode( HemisphereLight, HemisphereLightNode );

package/src/nodes/lighting/IESSpotLightNode.js

@@ -0,0 +1,39 @@
+import SpotLightNode from './SpotLightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { vec2 } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import IESSpotLight from '../../lights/webgpu/IESSpotLight.js';
+
+class IESSpotLightNode extends SpotLightNode {
+
+	getSpotAttenuation( angleCosine ) {
+
+		const iesMap = this.light.iesMap;
+
+		let spotAttenuation = null;
+
+		if ( iesMap && iesMap.isTexture === true ) {
+
+			const angle = angleCosine.acos().mul( 1.0 / Math.PI );
+
+			spotAttenuation = texture( iesMap, vec2( angle, 0 ), 0 ).r;
+
+		} else {
+
+			spotAttenuation = super.getSpotAttenuation( angleCosine );
+
+		}
+
+		return spotAttenuation;
+
+	}
+
+}
+
+export default IESSpotLightNode;
+
+addNodeClass( 'IESSpotLightNode', IESSpotLightNode );
+
+addLightNode( IESSpotLight, IESSpotLightNode );

package/src/nodes/lighting/IrradianceNode.js

@@ -0,0 +1,24 @@
+import LightingNode from './LightingNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+class IrradianceNode extends LightingNode {
+
+	constructor( node ) {
+
+		super();
+
+		this.node = node;
+
+	}
+
+	setup( builder ) {
+
+		builder.context.irradiance.addAssign( this.node );
+
+	}
+
+}
+
+export default IrradianceNode;
+
+addNodeClass( 'IrradianceNode', IrradianceNode );

package/src/nodes/lighting/LightNode.js

@@ -0,0 +1,57 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { objectPosition } from '../accessors/Object3DNode.js';
+import { cameraViewMatrix } from '../accessors/CameraNode.js';
+
+class LightNode extends Node {
+
+	constructor( scope = LightNode.TARGET_DIRECTION, light = null ) {
+
+		super();
+
+		this.scope = scope;
+		this.light = light;
+
+	}
+
+	setup() {
+
+		const { scope, light } = this;
+
+		let output = null;
+
+		if ( scope === LightNode.TARGET_DIRECTION ) {
+
+			output = cameraViewMatrix.transformDirection( objectPosition( light ).sub( objectPosition( light.target ) ) );
+
+		}
+
+		return output;
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.scope = this.scope;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.scope = data.scope;
+
+	}
+
+}
+
+LightNode.TARGET_DIRECTION = 'targetDirection';
+
+export default LightNode;
+
+export const lightTargetDirection = nodeProxy( LightNode, LightNode.TARGET_DIRECTION );
+
+addNodeClass( 'LightNode', LightNode );

package/src/nodes/lighting/LightUtils.js

@@ -0,0 +1,17 @@
+import { tslFn } from '../shadernode/ShaderNode.js';
+
+export const getDistanceAttenuation = tslFn( ( inputs ) => {
+
+	const { lightDistance, cutoffDistance, decayExponent } = inputs;
+
+	// based upon Frostbite 3 Moving to Physically-based Rendering
+	// page 32, equation 26: E[window1]
+	// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+	const distanceFalloff = lightDistance.pow( decayExponent ).max( 0.01 ).reciprocal();
+
+	return cutoffDistance.greaterThan( 0 ).cond(
+		distanceFalloff.mul( lightDistance.div( cutoffDistance ).pow4().oneMinus().clamp().pow2() ),
+		distanceFalloff
+	);
+
+} ); // validated

package/src/nodes/lighting/LightingContextNode.js

@@ -0,0 +1,66 @@
+import ContextNode from '../core/ContextNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
+
+class LightingContextNode extends ContextNode {
+
+	constructor( node, lightingModel = null, backdropNode = null, backdropAlphaNode = null ) {
+
+		super( node );
+
+		this.lightingModel = lightingModel;
+		this.backdropNode = backdropNode;
+		this.backdropAlphaNode = backdropAlphaNode;
+
+		this._context = null;
+
+	}
+
+	getContext() {
+
+		const { backdropNode, backdropAlphaNode } = this;
+
+		const directDiffuse = vec3().temp( 'directDiffuse' ),
+			directSpecular = vec3().temp( 'directSpecular' ),
+			indirectDiffuse = vec3().temp( 'indirectDiffuse' ),
+			indirectSpecular = vec3().temp( 'indirectSpecular' );
+
+		const reflectedLight = {
+			directDiffuse,
+			directSpecular,
+			indirectDiffuse,
+			indirectSpecular
+		};
+
+		const context = {
+			radiance: vec3().temp( 'radiance' ),
+			irradiance: vec3().temp( 'irradiance' ),
+			iblIrradiance: vec3().temp( 'iblIrradiance' ),
+			ambientOcclusion: float( 1 ).temp( 'ambientOcclusion' ),
+			reflectedLight,
+			backdrop: backdropNode,
+			backdropAlpha: backdropAlphaNode
+		};
+
+		return context;
+
+	}
+
+	setup( builder ) {
+
+		this.context = this._context || ( this._context = this.getContext() );
+		this.context.lightingModel = this.lightingModel || builder.context.lightingModel;
+
+		return super.setup( builder );
+
+	}
+
+}
+
+export default LightingContextNode;
+
+export const lightingContext = nodeProxy( LightingContextNode );
+
+addNodeElement( 'lightingContext', lightingContext );
+
+addNodeClass( 'LightingContextNode', LightingContextNode );

package/src/nodes/lighting/LightingNode.js

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

package/src/nodes/lighting/LightsNode.js

@@ -0,0 +1,213 @@
+import Node from '../core/Node.js';
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { nodeObject, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
+
+const LightNodes = new WeakMap();
+
+const sortLights = ( lights ) => {
+
+	return lights.sort( ( a, b ) => a.id - b.id );
+
+};
+
+class LightsNode extends Node {
+
+	constructor( lightNodes = [] ) {
+
+		super( 'vec3' );
+
+		this.totalDiffuseNode = vec3().temp( 'totalDiffuse' );
+		this.totalSpecularNode = vec3().temp( 'totalSpecular' );
+
+		this.outgoingLightNode = vec3().temp( 'outgoingLight' );
+
+		this.lightNodes = lightNodes;
+
+		this._hash = null;
+
+	}
+
+	get hasLight() {
+
+		return this.lightNodes.length > 0;
+
+	}
+
+	getHash() {
+
+		if ( this._hash === null ) {
+
+			const hash = [];
+
+			for ( const lightNode of this.lightNodes ) {
+
+				hash.push( lightNode.getHash() );
+
+			}
+
+			this._hash = 'lights-' + hash.join( ',' );
+
+		}
+
+		return this._hash;
+
+	}
+
+	analyze( builder ) {
+
+		const properties = builder.getDataFromNode( this );
+
+		for ( const node of properties.nodes ) {
+
+			node.build( builder );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const context = builder.context;
+		const lightingModel = context.lightingModel;
+
+		let outgoingLightNode = this.outgoingLightNode;
+
+		if ( lightingModel ) {
+
+			const { lightNodes, totalDiffuseNode, totalSpecularNode } = this;
+
+			context.outgoingLight = outgoingLightNode;
+
+			const stack = builder.addStack();
+
+			//
+
+			const properties = builder.getDataFromNode( this );
+			properties.nodes = stack.nodes;
+
+			//
+
+			lightingModel.start( context, stack, builder );
+
+			// lights
+
+			for ( const lightNode of lightNodes ) {
+
+				lightNode.build( builder );
+
+			}
+
+			//
+
+			lightingModel.indirect( context, stack, builder );
+
+			//
+
+			const { backdrop, backdropAlpha } = context;
+			const { directDiffuse, directSpecular, indirectDiffuse, indirectSpecular } = context.reflectedLight;
+
+			let totalDiffuse = directDiffuse.add( indirectDiffuse );
+
+			if ( backdrop !== null ) {
+
+				if ( backdropAlpha !== null ) {
+
+					totalDiffuse = vec3( backdropAlpha.mix( totalDiffuse, backdrop ) );
+
+				} else {
+
+					totalDiffuse = vec3( backdrop );
+
+				}
+
+				context.material.transparent = true;
+
+			}
+
+			totalDiffuseNode.assign( totalDiffuse );
+			totalSpecularNode.assign( directSpecular.add( indirectSpecular ) );
+
+			outgoingLightNode.assign( totalDiffuseNode.add( totalSpecularNode ) );
+
+			//
+
+			lightingModel.finish( context, stack, builder );
+
+			//
+
+			outgoingLightNode = outgoingLightNode.bypass( builder.removeStack() );
+
+		}
+
+		return outgoingLightNode;
+
+	}
+
+	_getLightNodeById( id ) {
+
+		for ( const lightNode of this.lightNodes ) {
+
+			if ( lightNode.isAnalyticLightNode && lightNode.light.id === id ) {
+
+				return lightNode;
+
+			}
+
+		}
+
+		return null;
+
+	}
+
+	fromLights( lights = [] ) {
+
+		const lightNodes = [];
+
+		lights = sortLights( lights );
+
+		for ( const light of lights ) {
+
+			let lightNode = this._getLightNodeById( light.id );
+
+			if ( lightNode === null ) {
+
+				const lightClass = light.constructor;
+				const lightNodeClass = LightNodes.has( lightClass ) ? LightNodes.get( lightClass ) : AnalyticLightNode;
+
+				lightNode = nodeObject( new lightNodeClass( light ) );
+
+			}
+
+			lightNodes.push( lightNode );
+
+		}
+
+		this.lightNodes = lightNodes;
+		this._hash = null;
+
+		return this;
+
+	}
+
+}
+
+export default LightsNode;
+
+export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
+export const lightsNode = nodeProxy( LightsNode );
+
+export function addLightNode( lightClass, lightNodeClass ) {
+
+	if ( LightNodes.has( lightClass ) ) {
+
+		console.warn( `Redefinition of light node ${ lightNodeClass.type }` );
+		return;
+
+	}
+
+	if ( typeof lightClass !== 'function' ) throw new Error( `Light ${ lightClass.name } is not a class` );
+	if ( typeof lightNodeClass !== 'function' || ! lightNodeClass.type ) throw new Error( `Light node ${ lightNodeClass.type } is not a class` );
+
+	LightNodes.set( lightClass, lightNodeClass );
+
+}