super-three 0.136.0 → 0.141.0

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,65 @@
+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';
+
+// 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 EnvironmentLightNode extends LightingNode {
+
+	constructor( envNode = null ) {
+
+		super();
+
+		this.envNode = envNode;
+
+	}
+
+	construct( builder ) {
+
+		const envNode = this.envNode;
+
+		const flipNormalWorld = vec3( negate( transformedNormalWorld.x ), transformedNormalWorld.yz );
+
+		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,
+			uvNode: reflectVec,
+			levelNode: roughness,
+			levelShaderNode: getSpecularMIPLevel
+		} );
+
+		const irradianceContext = new ContextNode( envNode, {
+			tempRead: false,
+			uvNode: flipNormalWorld,
+			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 ) );
+
+	}
+
+}
+
+export default EnvironmentLightNode;

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;

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

@@ -0,0 +1,107 @@
+import * as Nodes from '../Nodes.js';
+import { Loader } from 'three';
+
+class NodeLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+		this.textures = {};
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const loader = new FileLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+		loader.load( url, ( text ) => {
+
+			try {
+
+				onLoad( this.parse( JSON.parse( text ) ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				this.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parseNodes( json ) {
+
+		const nodes = {};
+
+		if ( json !== undefined ) {
+
+			for ( const nodeJSON of json ) {
+
+				const { uuid, type } = nodeJSON;
+
+				nodes[ uuid ] = Nodes.fromType( type );
+				nodes[ uuid ].uuid = uuid;
+
+			}
+
+			const meta = { nodes, textures: this.textures };
+
+			for ( const nodeJSON of json ) {
+
+				nodeJSON.meta = meta;
+
+				const node = nodes[ nodeJSON.uuid ];
+				node.deserialize( nodeJSON );
+
+				delete nodeJSON.meta;
+
+			}
+
+		}
+
+		return nodes;
+
+	}
+
+	parse( json ) {
+
+		const node = Nodes.fromType( type );
+		node.uuid = json.uuid;
+
+		const nodes = this.parseNodes( json.inputNodes );
+		const meta = { nodes, textures: this.textures };
+
+		json.meta = meta;
+
+		node.deserialize( json );
+
+		delete json.meta;
+
+		return node;
+
+	}
+
+	setTextures( value ) {
+
+		this.textures = value;
+		return this;
+
+	}
+
+}
+
+export default NodeLoader;

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

@@ -0,0 +1,42 @@
+import { MaterialLoader } from 'three';
+
+class NodeMaterialLoader extends MaterialLoader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+		this.nodes = {};
+
+	}
+
+	parse( json ) {
+
+		const material = super.parse( json );
+
+		const nodes = this.nodes;
+		const inputNodes = json.inputNodes;
+
+		for ( const property in inputNodes ) {
+
+			const uuid = inputNodes[ property ];
+
+			material[ property ] = nodes[ uuid ];
+
+		}
+
+		return material;
+
+	}
+
+	setNodes( value ) {
+
+		this.nodes = value;
+
+		return this;
+
+	}
+
+}
+
+export default NodeMaterialLoader;

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

@@ -0,0 +1,70 @@
+import NodeLoader from './NodeLoader.js';
+import NodeMaterialLoader from './NodeMaterialLoader.js';
+import { ObjectLoader } from 'three';
+
+class NodeObjectLoader extends ObjectLoader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+		this._nodesJSON = null;
+
+	}
+
+	parse( json, onLoad ) {
+
+		this._nodesJSON = json.nodes;
+
+		const data = super.parse( json, onLoad );
+
+		this._nodesJSON = null; // dispose
+
+		return data;
+
+	}
+
+	parseNodes( json, textures ) {
+
+		if ( json !== undefined ) {
+
+			const loader = new NodeLoader();
+			loader.setTextures( textures );
+
+			return loader.parseNodes( json );
+
+		}
+
+		return {};
+
+	}
+
+	parseMaterials( json, textures ) {
+
+		const materials = {};
+
+		if ( json !== undefined ) {
+
+			const nodes = this.parseNodes( this._nodesJSON, textures );
+
+			const loader = new NodeMaterialLoader();
+			loader.setTextures( textures );
+			loader.setNodes( nodes );
+
+			for ( let i = 0, l = json.length; i < l; i ++ ) {
+
+				const data = json[ i ];
+
+				materials[ data.uuid ] = loader.parse( data );
+
+			}
+
+		}
+
+		return materials;
+
+	}
+
+}
+
+export default NodeObjectLoader;

package/examples/jsm/{renderers/nodes → nodes}/materials/LineBasicNodeMaterial.js

@@ -1,10 +1,15 @@
+import NodeMaterial from './NodeMaterial.js';
 import { LineBasicMaterial } from 'three';
 
-class LineBasicNodeMaterial extends LineBasicMaterial {
+const defaultValues = new LineBasicMaterial();
+
+class LineBasicNodeMaterial extends NodeMaterial {
 
 	constructor( parameters ) {
 
-		super( parameters );
+		super();
+
+		this.isLineBasicNodeMaterial = true;
 
 		this.colorNode = null;
 		this.opacityNode = null;
@@ -15,6 +20,10 @@ class LineBasicNodeMaterial extends LineBasicMaterial {
 
 		this.positionNode = null;
 
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
 	}
 
 	copy( source ) {
@@ -34,6 +43,4 @@ class LineBasicNodeMaterial extends LineBasicMaterial {
 
 }
 
-LineBasicNodeMaterial.prototype.isNodeMaterial = true;
-
 export default LineBasicNodeMaterial;