super-three 0.147.1 → 0.152.0

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

@@ -1,8 +1,17 @@
 import LightingNode from './LightingNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { uniform } from '../shadernode/ShaderNodeElements.js';
+import { uniform } from '../core/UniformNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { vec3 } from '../shadernode/ShaderNode.js';
+import { reference } from '../accessors/ReferenceNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { positionWorld } from '../accessors/PositionNode.js';
+import { cond } from '../math/CondNode.js';
+import MeshBasicNodeMaterial from '../materials/MeshBasicNodeMaterial.js';
 
-import { Color } from 'three';
+import { Color, DepthTexture, NearestFilter } from 'three';
+
+let depthMaterial = null;
 
 class AnalyticLightNode extends LightingNode {
 
@@ -10,11 +19,15 @@ class AnalyticLightNode extends LightingNode {
 
 		super();
 
-		this.updateType = NodeUpdateType.OBJECT;
+		this.updateType = NodeUpdateType.FRAME;
 
 		this.light = light;
 
-		this.colorNode = uniform( new Color() );
+		this.rtt = null;
+		this.shadowNode = null;
+
+		this.color = new Color();
+		this.colorNode = uniform( this.color );
 
 	}
 
@@ -24,14 +37,107 @@ class AnalyticLightNode extends LightingNode {
 
 	}
 
-	update( /*frame*/ ) {
+	constructShadow( builder ) {
+
+		let shadowNode = this.shadowNode;
+
+		if ( shadowNode === null ) {
+
+			if ( depthMaterial === null ) depthMaterial = new MeshBasicNodeMaterial();
+
+			const shadow = this.light.shadow;
+			const rtt = builder.getRenderTarget( shadow.mapSize.width, shadow.mapSize.height );
+
+			const depthTexture = new DepthTexture();
+			depthTexture.minFilter = NearestFilter;
+			depthTexture.magFilter = NearestFilter;
+
+			rtt.depthTexture = depthTexture;
+
+			shadow.camera.updateProjectionMatrix();
+
+			//
+
+			const bias = reference( 'bias', 'float', shadow );
+
+			//const diffuseFactor = normalView.dot( objectViewPosition( this.light ).sub( positionView ).normalize().negate() );
+			//bias = mix( bias, 0, diffuseFactor );
+
+			let shadowCoord = uniform( shadow.matrix ).mul( positionWorld );
+			shadowCoord = shadowCoord.xyz.div( shadowCoord.w );
+
+			shadowCoord = vec3(
+				shadowCoord.x,
+				shadowCoord.y.oneMinus(),
+				shadowCoord.z
+			);
+
+			// @TODO: Optimize using WebGPU compare-sampler
+
+			let depth = texture( depthTexture, shadowCoord.xy );
+			depth = depth.mul( .5 ).add( .5 ).add( bias );
+
+			shadowNode = cond( shadowCoord.z.lessThan( depth ).or( shadowCoord.y.lessThan( .000001 ) /*@TODO: find the cause and remove it soon */ ), 1, 0 );
+			//shadowNode = step( shadowCoord.z, depth );
+
+			//
+
+			this.rtt = rtt;
+			this.colorNode = this.colorNode.mul( shadowNode );
+
+			this.shadowNode = shadowNode;
+
+			//
+
+			this.updateBeforeType = NodeUpdateType.RENDER;
+
+		}
+
+	}
+
+	construct( builder ) {
+
+		if ( this.light.castShadow ) this.constructShadow( builder );
+
+	}
+
+	updateShadow( frame ) {
+
+		const { rtt, light } = this;
+		const { renderer, scene } = frame;
+
+		scene.overrideMaterial = depthMaterial;
+
+		rtt.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
+
+		light.shadow.updateMatrices( light );
+
+		renderer.setRenderTarget( rtt );
+		renderer.render( scene, light.shadow.camera );
+		renderer.setRenderTarget( null );
+
+		scene.overrideMaterial = null;
+
+	}
+
+	updateBefore( frame ) {
 
 		const { light } = this;
 
-		this.colorNode.value.copy( light.color ).multiplyScalar( light.intensity );
+		if ( light.castShadow ) this.updateShadow( frame );
+
+	}
+
+	update( frame ) {
+
+		const { light } = this;
+
+		this.color.copy( light.color ).multiplyScalar( light.intensity );
 
 	}
 
 }
 
 export default AnalyticLightNode;
+
+addNodeClass( AnalyticLightNode );

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

@@ -0,0 +1,43 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { lightTargetDirection } from './LightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { DirectionalLight } from 'three';
+
+class DirectionalLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+	}
+
+	construct( builder ) {
+
+		super.construct( builder );
+
+		const lightColor = this.colorNode;
+		const lightDirection = lightTargetDirection( this.light );
+		const lightingModelFunctionNode = builder.context.lightingModelNode;
+		const reflectedLight = builder.context.reflectedLight;
+
+		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
+
+			lightingModelFunctionNode.direct.call( {
+				lightDirection,
+				lightColor,
+				reflectedLight
+			}, builder );
+
+		}
+
+	}
+
+}
+
+export default DirectionalLightNode;
+
+addLightNode( DirectionalLight, DirectionalLightNode );
+
+addNodeClass( DirectionalLightNode );

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

@@ -1,19 +1,14 @@
 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 );
-
-} );
+import { cache } from '../core/CacheNode.js';
+import { context } from '../core/ContextNode.js';
+import { roughness } from '../core/PropertyNode.js';
+import { equirectUV } from '../utils/EquirectUVNode.js';
+import { specularMIPLevel } from '../utils/SpecularMIPLevelNode.js';
+import { cameraViewMatrix } from '../accessors/CameraNode.js';
+import { transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { float, vec2 } from '../shadernode/ShaderNode.js';
 
 class EnvironmentNode extends LightingNode {
 
@@ -30,33 +25,106 @@ class EnvironmentNode extends LightingNode {
 		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 );
+		let reflectVec;
+		let radianceTextureUVNode;
+		let irradianceTextureUVNode;
+
+		const radianceContext = context( envNode, {
+			getUVNode: ( textureNode ) => {
+
+				let node = null;
+
+				if ( reflectVec === undefined ) {
+
+					reflectVec = positionViewDirection.negate().reflect( transformedNormalView );
+					reflectVec = roughness.mul( roughness ).mix( reflectVec, transformedNormalView ).normalize();
+					reflectVec = reflectVec.transformDirection( cameraViewMatrix );
+
+				}
+
+				if ( textureNode.isCubeTextureNode ) {
+
+					node = reflectVec;
+
+				} else if ( textureNode.isTextureNode ) {
+
+					if ( radianceTextureUVNode === undefined ) {
+
+						// @TODO: Needed PMREM
+
+						radianceTextureUVNode = equirectUV( reflectVec );
+
+					}
+
+					node = radianceTextureUVNode;
+
+				}
+
+				return node;
+
+			},
+			getSamplerLevelNode: () => {
+
+				return roughness;
 
-		const radianceContext = new ContextNode( envNode, {
-			tempRead: false,
-			uvNode: reflectVec,
-			levelNode: roughness,
-			levelShaderNode: getSpecularMIPLevel
+			},
+			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+				return specularMIPLevel( textureNode, levelNode );
+
+			}
 		} );
 
-		const irradianceContext = new ContextNode( envNode, {
-			tempRead: false,
-			uvNode: transformedNormalWorld,
-			levelNode: float( 1 ),
-			levelShaderNode: getSpecularMIPLevel
+		const irradianceContext = context( envNode, {
+			getUVNode: ( textureNode ) => {
+
+				let node = null;
+
+				if ( textureNode.isCubeTextureNode ) {
+
+					node = transformedNormalWorld;
+
+				} else if ( textureNode.isTextureNode ) {
+
+					if ( irradianceTextureUVNode === undefined ) {
+
+						// @TODO: Needed PMREM
+
+						irradianceTextureUVNode = equirectUV( transformedNormalWorld );
+						irradianceTextureUVNode = vec2( irradianceTextureUVNode.x, irradianceTextureUVNode.y.oneMinus() );
+
+					}
+
+					node = irradianceTextureUVNode;
+
+				}
+
+				return node;
+
+			},
+			getSamplerLevelNode: () => {
+
+				return float( 1 );
+
+			},
+			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+				return specularMIPLevel( textureNode, levelNode );
+
+			}
 		} );
 
-		// it's used to cache the construct only if necessary: See `CubeTextureNode.getConstructReference()`
-		radianceContext.context.environmentContext = radianceContext;
-		irradianceContext.context.environmentContext = irradianceContext;
+		//
+
+		const isolateRadianceFlowContext = cache( radianceContext );
 
-		builder.context.radiance.add( radianceContext );
+		//
 
-		builder.context.iblIrradiance.add( mul( Math.PI, irradianceContext ) );
+		builder.context.radiance.addAssign( isolateRadianceFlowContext );
 
-		properties.radianceContext = radianceContext;
+		builder.context.iblIrradiance.addAssign( irradianceContext.mul( Math.PI ) );
+
+		properties.radianceContext = isolateRadianceFlowContext;
 		properties.irradianceContext = irradianceContext;
 
 	}
@@ -64,3 +132,5 @@ class EnvironmentNode extends LightingNode {
 }
 
 export default EnvironmentNode;
+
+addNodeClass( EnvironmentNode );

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

@@ -1,7 +1,10 @@
 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 { 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, HemisphereLight } from 'three';
 
@@ -11,8 +14,8 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 		super( light );
 
-		this.lightPositionNode = new Object3DNode( Object3DNode.POSITION );
-		this.lightDirectionNode = normalize( this.lightPositionNode );
+		this.lightPositionNode = objectPosition;
+		this.lightDirectionNode = objectPosition.normalize();
 
 		this.groundColorNode = uniform( new Color() );
 
@@ -34,17 +37,19 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 		const { colorNode, groundColorNode, lightDirectionNode } = this;
 
-		const dotNL = dot( normalView, lightDirectionNode );
-		const hemiDiffuseWeight = add( mul( 0.5, dotNL ), 0.5 );
+		const dotNL = normalView.dot( lightDirectionNode );
+		const hemiDiffuseWeight = dotNL.mul( 0.5 ).add( 0.5 );
 
 		const irradiance = mix( groundColorNode, colorNode, hemiDiffuseWeight );
 
-		builder.context.irradiance.add( irradiance );
+		builder.context.irradiance.addAssign( irradiance );
 
 	}
 
 }
 
-LightsNode.setReference( HemisphereLight, HemisphereLightNode );
-
 export default HemisphereLightNode;
+
+addLightNode( HemisphereLight, HemisphereLightNode );
+
+addNodeClass( HemisphereLightNode );

package/examples/jsm/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/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;
+
+addLightNode( IESSpotLight, IESSpotLightNode );
+
+addNodeClass( IESSpotLightNode );

package/examples/jsm/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;
+
+	}
+
+	construct() {
+
+		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 );

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

@@ -0,0 +1,17 @@
+import { ShaderNode } from '../shadernode/ShaderNode.js';
+
+export const getDistanceAttenuation = new ShaderNode( ( 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/examples/jsm/nodes/lighting/LightingContextNode.js

@@ -1,13 +1,19 @@
 import ContextNode from '../core/ContextNode.js';
-import { float, vec3, add, temp } from '../shadernode/ShaderNodeBaseElements.js';
+import { temp } from '../core/VarNode.js';
+import { add } from '../math/OperatorNode.js';
+import { mix } from '../math/MathNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
 
 class LightingContextNode extends ContextNode {
 
-	constructor( node, lightingModelNode = null ) {
+	constructor( node, lightingModelNode = null, backdropNode = null, backdropAlphaNode = null ) {
 
 		super( node );
 
 		this.lightingModelNode = lightingModelNode;
+		this.backdropNode = backdropNode;
+		this.backdropAlphaNode = backdropAlphaNode;
 
 	}
 
@@ -19,7 +25,7 @@ class LightingContextNode extends ContextNode {
 
 	construct( builder ) {
 
-		const { lightingModelNode } = this;
+		const { lightingModelNode, backdropNode, backdropAlphaNode } = this;
 
 		const context = this.context = {}; // reset context
 		const properties = builder.getNodeProperties( this );
@@ -27,8 +33,18 @@ class LightingContextNode extends ContextNode {
 		const directDiffuse = temp( vec3() ),
 			directSpecular = temp( vec3() ),
 			indirectDiffuse = temp( vec3() ),
-			indirectSpecular = temp( vec3() ),
-			total = add( directDiffuse, directSpecular, indirectDiffuse, indirectSpecular );
+			indirectSpecular = temp( vec3() );
+
+		let totalDiffuse = add( directDiffuse, indirectDiffuse );
+
+		if ( backdropNode !== null ) {
+
+			totalDiffuse = vec3( backdropAlphaNode !== null ? mix( totalDiffuse, backdropNode, backdropAlphaNode ) : backdropNode );
+
+		}
+
+		const totalSpecular = add( directSpecular, indirectSpecular );
+		const total = add( totalDiffuse, totalSpecular );
 
 		const reflectedLight = {
 			directDiffuse,
@@ -51,9 +67,9 @@ class LightingContextNode extends ContextNode {
 		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 );
+		if ( lightingModelNode && lightingModelNode.indirectDiffuse ) lightingModelNode.indirectDiffuse.call( context );
+		if ( lightingModelNode && lightingModelNode.indirectSpecular ) lightingModelNode.indirectSpecular.call( context );
+		if ( lightingModelNode && lightingModelNode.ambientOcclusion ) lightingModelNode.ambientOcclusion.call( context );
 
 		return super.construct( builder );
 
@@ -73,3 +89,9 @@ class LightingContextNode extends ContextNode {
 }
 
 export default LightingContextNode;
+
+export const lightingContext = nodeProxy( LightingContextNode );
+
+addNodeElement( 'lightingContext', lightingContext );
+
+addNodeClass( LightingContextNode );

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

@@ -1,4 +1,4 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 
 class LightingNode extends Node {
 
@@ -17,3 +17,5 @@ class LightingNode extends Node {
 }
 
 export default LightingNode;
+
+addNodeClass( LightingNode );

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

@@ -1,7 +1,8 @@
 import Node from '../core/Node.js';
-import LightingNode from './LightingNode.js';
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { nodeObject, nodeProxy } from '../shadernode/ShaderNode.js';
 
-const references = new WeakMap();
+const LightNodes = new WeakMap();
 
 const sortLights = ( lights ) => {
 
@@ -79,7 +80,7 @@ class LightsNode extends Node {
 
 	}
 
-	fromLights( lights ) {
+	fromLights( lights = [] ) {
 
 		const lightNodes = [];
 
@@ -92,9 +93,9 @@ class LightsNode extends Node {
 			if ( lightNode === null ) {
 
 				const lightClass = light.constructor;
-				const lightNodeClass = references.has( lightClass ) ? references.get( lightClass ) : LightingNode;
+				const lightNodeClass = LightNodes.has( lightClass ) ? LightNodes.get( lightClass ) : AnalyticLightNode;
 
-				lightNode = new lightNodeClass( light );
+				lightNode = nodeObject( new lightNodeClass( light ) );
 
 			}
 
@@ -109,12 +110,19 @@ class LightsNode extends Node {
 
 	}
 
-	static setReference( lightClass, lightNodeClass ) {
+}
 
-		references.set( lightClass, lightNodeClass );
+export default LightsNode;
 
-	}
+export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
+export const lightsWithoutWrap = nodeProxy( LightsNode );
 
-}
+export function addLightNode( lightClass, lightNodeClass ) {
 
-export default LightsNode;
+	if ( LightNodes.has( lightClass ) ) throw new Error( `Redefinition of light node ${ lightNodeClass.name }` );
+	if ( typeof lightClass !== 'function' || ! lightClass.name ) throw new Error( `Light ${ lightClass.name } is not a class` );
+	if ( typeof lightNodeClass !== 'function' || ! lightNodeClass.name ) throw new Error( `Light node ${ lightNodeClass.name } is not a class` );
+
+	LightNodes.set( lightClass, lightNodeClass );
+
+}