super-three 0.147.1 → 0.152.0

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

@@ -0,0 +1,71 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { getDistanceAttenuation } from './LightUtils.js';
+import { uniform } from '../core/UniformNode.js';
+import { objectViewPosition } from '../accessors/Object3DNode.js';
+import { positionView } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { PointLight } from 'three';
+
+class PointLightNode 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, light } = this;
+
+		const lVector = objectViewPosition( light ).sub( positionView ); // @TODO: Add it into LightNode
+
+		const lightDirection = lVector.normalize();
+		const lightDistance = lVector.length();
+
+		const lightAttenuation = getDistanceAttenuation.call( {
+			lightDistance,
+			cutoffDistance: cutoffDistanceNode,
+			decayExponent: decayExponentNode
+		} );
+
+		const lightColor = colorNode.mul( lightAttenuation );
+
+		const lightingModelFunctionNode = builder.context.lightingModelNode;
+		const reflectedLight = builder.context.reflectedLight;
+
+		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
+
+			lightingModelFunctionNode.direct.call( {
+				lightDirection,
+				lightColor,
+				reflectedLight
+			}, builder );
+
+		}
+
+	}
+
+}
+
+export default PointLightNode;
+
+addLightNode( PointLight, PointLightNode );
+
+addNodeClass( PointLightNode );

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

@@ -0,0 +1,92 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { lightTargetDirection } from './LightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { getDistanceAttenuation } from './LightUtils.js';
+import { uniform } from '../core/UniformNode.js';
+import { smoothstep } from '../math/MathNode.js';
+import { objectViewPosition } from '../accessors/Object3DNode.js';
+import { positionView } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { SpotLight } from 'three';
+
+class SpotLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this.coneCosNode = uniform( 0 );
+		this.penumbraCosNode = uniform( 0 );
+
+		this.cutoffDistanceNode = uniform( 0 );
+		this.decayExponentNode = uniform( 0 );
+
+	}
+
+	update( frame ) {
+
+		super.update( frame );
+
+		const { light } = this;
+
+		this.coneCosNode.value = Math.cos( light.angle );
+		this.penumbraCosNode.value = Math.cos( light.angle * ( 1 - light.penumbra ) );
+
+		this.cutoffDistanceNode.value = light.distance;
+		this.decayExponentNode.value = light.decay;
+
+	}
+
+	getSpotAttenuation( angleCosine ) {
+
+		const { coneCosNode, penumbraCosNode } = this;
+
+		return smoothstep( coneCosNode, penumbraCosNode, angleCosine );
+
+	}
+
+	construct( builder ) {
+
+		super.construct( builder );
+
+		const { colorNode, cutoffDistanceNode, decayExponentNode, light } = this;
+
+		const lVector = objectViewPosition( light ).sub( positionView ); // @TODO: Add it into LightNode
+
+		const lightDirection = lVector.normalize();
+		const angleCos = lightDirection.dot( lightTargetDirection( light ) );
+		const spotAttenuation = this.getSpotAttenuation( angleCos );
+
+		const lightDistance = lVector.length();
+
+		const lightAttenuation = getDistanceAttenuation.call( {
+			lightDistance,
+			cutoffDistance: cutoffDistanceNode,
+			decayExponent: decayExponentNode
+		} );
+
+		const lightColor = colorNode.mul( spotAttenuation ).mul( lightAttenuation );
+
+		const lightingModelFunctionNode = builder.context.lightingModelNode;
+		const reflectedLight = builder.context.reflectedLight;
+
+		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
+
+			lightingModelFunctionNode.direct.call( {
+				lightDirection,
+				lightColor,
+				reflectedLight
+			}, builder );
+
+		}
+
+	}
+
+}
+
+export default SpotLightNode;
+
+addLightNode( SpotLight, SpotLightNode );
+
+addNodeClass( SpotLightNode );

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

@@ -1,4 +1,5 @@
-import * as Nodes from '../Nodes.js';
+import { createNodeFromType } from '../core/Node.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 import { FileLoader, Loader } from 'three';
 
 class NodeLoader extends Loader {
@@ -53,7 +54,7 @@ class NodeLoader extends Loader {
 
 				const { uuid, type } = nodeJSON;
 
-				nodes[ uuid ] = Nodes.fromType( type );
+				nodes[ uuid ] = nodeObject( createNodeFromType( type ) ); // @TODO: Maybe nodeObjectify the node in createNodeFromType?
 				nodes[ uuid ].uuid = uuid;
 
 			}
@@ -79,10 +80,10 @@ class NodeLoader extends Loader {
 
 	parse( json ) {
 
-		const node = Nodes.fromType( json.type );
+		const node = nodeObject( createNodeFromType( json.type ) );
 		node.uuid = json.uuid;
 
-		const nodes = this.parseNodes( json.inputNodes );
+		const nodes = this.parseNodes( json.nodes );
 		const meta = { nodes, textures: this.textures };
 
 		json.meta = meta;

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

@@ -1,31 +1,15 @@
 import { MaterialLoader } from 'three';
-import {
-	NodeMaterial,
-	LineBasicNodeMaterial,
-	MeshBasicNodeMaterial,
-	MeshStandardNodeMaterial,
-	MeshPhysicalNodeMaterial,
-	PointsNodeMaterial,
-	SpriteNodeMaterial
-} from '../materials/Materials.js';
+import { createNodeMaterialFromType } from '../materials/Materials.js';
 
 const superFromTypeFunction = MaterialLoader.createMaterialFromType;
 
 MaterialLoader.createMaterialFromType = function ( type ) {
 
-	const materialLib = {
-		NodeMaterial,
-		LineBasicNodeMaterial,
-		MeshBasicNodeMaterial,
-		MeshStandardNodeMaterial,
-		MeshPhysicalNodeMaterial,
-		PointsNodeMaterial,
-		SpriteNodeMaterial
-	};
+	const material = createNodeMaterialFromType( type );
 
-	if ( materialLib[ type ] !== undefined ) {
+	if ( material !== undefined ) {
 
-		return new materialLib[ type ]();
+		return material;
 
 	}
 

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

@@ -1,4 +1,5 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+
 import { LineBasicMaterial } from 'three';
 
 const defaultValues = new LineBasicMaterial();
@@ -11,14 +12,8 @@ class LineBasicNodeMaterial extends NodeMaterial {
 
 		this.isLineBasicNodeMaterial = true;
 
-		this.colorNode = null;
-		this.opacityNode = null;
-
-		this.alphaTestNode = null;
-
-		this.lightNode = null;
-
-		this.positionNode = null;
+		this.lights = false;
+		this.normals = false;
 
 		this.setDefaultValues( defaultValues );
 
@@ -44,3 +39,5 @@ class LineBasicNodeMaterial extends NodeMaterial {
 }
 
 export default LineBasicNodeMaterial;
+
+addNodeMaterial( LineBasicNodeMaterial );

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

@@ -1,55 +1,11 @@
-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';
-
-export {
-	NodeMaterial,
-	LineBasicNodeMaterial,
-	MeshBasicNodeMaterial,
-	MeshStandardNodeMaterial,
-	MeshPhysicalNodeMaterial,
-	PointsNodeMaterial,
-	SpriteNodeMaterial
-};
-
-NodeMaterial.fromMaterial = function ( material ) {
-
-	const materialLib = {
-		NodeMaterial,
-		LineBasicNodeMaterial,
-		MeshBasicNodeMaterial,
-		MeshStandardNodeMaterial,
-		MeshPhysicalNodeMaterial,
-		PointsNodeMaterial,
-		SpriteNodeMaterial
-	};
-
-	const type = material.type.replace( 'Material', 'NodeMaterial' );
-
-	if ( materialLib[ type ] === undefined ) {
-
-		if ( material.isNodeMaterial !== true ) {
-
-			throw new Error( `NodeMaterial: Material "${ material.type }" is not compatible.` );
-
-		}
-
-		return material; // is already a node material
-
-	}
-
-	const nodeMaterial = new materialLib[ type ]();
-
-	for ( const key in material ) {
-
-		nodeMaterial[ key ] = material[ key ];
-
-	}
-
-	return nodeMaterial;
-
-};
+// @TODO: We can simplify "export { default as SomeNode, other, exports } from '...'" to just "export * from '...'" if we will use only named exports
+
+export { default as NodeMaterial, addNodeMaterial, createNodeMaterialFromType } from './NodeMaterial.js';
+export { default as LineBasicNodeMaterial } from './LineBasicNodeMaterial.js';
+export { default as MeshNormalNodeMaterial } from './MeshNormalNodeMaterial.js';
+export { default as MeshBasicNodeMaterial } from './MeshBasicNodeMaterial.js';
+export { default as MeshPhongNodeMaterial } from './MeshPhongNodeMaterial.js';
+export { default as MeshStandardNodeMaterial } from './MeshStandardNodeMaterial.js';
+export { default as MeshPhysicalNodeMaterial } from './MeshPhysicalNodeMaterial.js';
+export { default as PointsNodeMaterial } from './PointsNodeMaterial.js';
+export { default as SpriteNodeMaterial } from './SpriteNodeMaterial.js';

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

@@ -1,4 +1,5 @@
-import NodeMaterial from './NodeMaterial.js';
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+
 import { MeshBasicMaterial } from 'three';
 
 const defaultValues = new MeshBasicMaterial();
@@ -11,16 +12,7 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 
 		this.isMeshBasicNodeMaterial = true;
 
-		this.lights = true;
-
-		this.colorNode = null;
-		this.opacityNode = null;
-
-		this.alphaTestNode = null;
-
-		this.lightNode = null;
-
-		this.positionNode = null;
+		this.lights = false;
 
 		this.setDefaultValues( defaultValues );
 
@@ -46,3 +38,5 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 }
 
 export default MeshBasicNodeMaterial;
+
+addNodeMaterial( MeshBasicNodeMaterial );

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

@@ -0,0 +1,48 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import { diffuseColor } from '../core/PropertyNode.js';
+import { directionToColor } from '../utils/PackingNode.js';
+import { materialOpacity } from '../accessors/MaterialNode.js';
+import { transformedNormalView } from '../accessors/NormalNode.js';
+import { float, vec4 } from '../shadernode/ShaderNode.js';
+
+import { MeshNormalMaterial } from 'three';
+
+const defaultValues = new MeshNormalMaterial();
+
+class MeshNormalNodeMaterial extends NodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshNormalNodeMaterial = true;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	constructDiffuseColor( { stack } ) {
+
+		const opacityNode = this.opacityNode ? float( this.opacityNode ) : materialOpacity;
+
+		stack.assign( diffuseColor, vec4( directionToColor( transformedNormalView ), opacityNode ) );
+
+	}
+
+	copy( source ) {
+
+		this.opacityNode = source.opacityNode;
+
+		this.positionNode = source.positionNode;
+
+		return super.copy( source );
+
+	}
+
+}
+
+export default MeshNormalNodeMaterial;
+
+addNodeMaterial( MeshNormalNodeMaterial );

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

@@ -0,0 +1,74 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import { shininess, specularColor } from '../core/PropertyNode.js';
+import { materialShininess, materialSpecularColor } from '../accessors/MaterialNode.js';
+import phongLightingModel from '../functions/PhongLightingModel.js';
+import { float } from '../shadernode/ShaderNode.js';
+
+import { MeshPhongMaterial } from 'three';
+
+const defaultValues = new MeshPhongMaterial();
+
+class MeshPhongNodeMaterial extends NodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshPhongNodeMaterial = true;
+
+		this.lights = true;
+
+		this.shininessNode = null;
+		this.specularNode = null;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	constructLightingModel( /*builder*/ ) {
+
+		return phongLightingModel;
+
+	}
+
+	constructVariants( { stack } ) {
+
+		// SHININESS
+
+		const shininessNode = ( this.shininessNode ? float( this.shininessNode ) : materialShininess ).max( 1e-4 ); // to prevent pow( 0.0, 0.0 )
+
+		stack.assign( shininess, shininessNode );
+
+		// SPECULAR COLOR
+
+		const specularNode = this.specularNode || materialSpecularColor;
+
+		stack.assign( specularColor, specularNode );
+
+	}
+
+	copy( source ) {
+
+		this.colorNode = source.colorNode;
+		this.opacityNode = source.opacityNode;
+
+		this.alphaTestNode = source.alphaTestNode;
+
+		this.shininessNode = source.shininessNode;
+		this.specularNode = source.specularNode;
+
+		this.lightNode = source.lightNode;
+
+		this.positionNode = source.positionNode;
+
+		return super.copy( source );
+
+	}
+
+}
+
+export default MeshPhongNodeMaterial;
+
+addNodeMaterial( MeshPhongNodeMaterial );

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

@@ -1,10 +1,11 @@
+import { addNodeMaterial } from './NodeMaterial.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 
 import { MeshPhysicalMaterial } from 'three';
 
 const defaultValues = new MeshPhysicalMaterial();
 
-export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 	constructor( parameters ) {
 
@@ -31,11 +32,6 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 		this.attenuationDistanceNode = null;
 		this.attenuationColorNode = null;
 
-		this.sheen = 0;
-		this.clearcoat = 0;
-		this.iridescence = 0;
-		this.transmission = 0;
-
 		this.setDefaultValues( defaultValues );
 
 		this.setValues( parameters );
@@ -68,3 +64,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 	}
 
 }
+
+export default MeshPhysicalNodeMaterial;
+
+addNodeMaterial( MeshPhysicalNodeMaterial );

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

@@ -1,21 +1,16 @@
-import NodeMaterial from './NodeMaterial.js';
-import {
-	float, vec3, vec4, normalView, add, context,
-	assign, label, mul, invert, mix, texture, uniform,
-	materialRoughness, materialMetalness, materialEmissive
-} from '../shadernode/ShaderNodeElements.js';
-import LightsNode from '../lighting/LightsNode.js';
-import EnvironmentNode from '../lighting/EnvironmentNode.js';
-import AONode from '../lighting/AONode.js';
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import { diffuseColor, metalness, roughness, specularColor } from '../core/PropertyNode.js';
+import { mix } from '../math/MathNode.js';
+import { materialRoughness, materialMetalness } from '../accessors/MaterialNode.js';
 import getRoughness from '../functions/material/getRoughness.js';
-import PhysicalLightingModel from '../functions/PhysicalLightingModel.js';
-import NormalMapNode from '../display/NormalMapNode.js';
+import physicalLightingModel from '../functions/PhysicalLightingModel.js';
+import { float, vec3, vec4 } from '../shadernode/ShaderNode.js';
 
 import { MeshStandardMaterial } from 'three';
 
 const defaultValues = new MeshStandardMaterial();
 
-export default class MeshStandardNodeMaterial extends NodeMaterial {
+class MeshStandardNodeMaterial extends NodeMaterial {
 
 	constructor( parameters ) {
 
@@ -23,121 +18,47 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
 
 		this.isMeshStandardNodeMaterial = true;
 
-		this.colorNode = null;
-		this.opacityNode = null;
-
-		this.alphaTestNode = null;
-
-		this.normalNode = null;
-
 		this.emissiveNode = null;
 
 		this.metalnessNode = null;
 		this.roughnessNode = null;
 
-		this.envNode = null;
-
-		this.lightsNode = null;
-
-		this.positionNode = null;
-
 		this.setDefaultValues( defaultValues );
 
 		this.setValues( parameters );
 
 	}
 
-	build( builder ) {
-
-		this.generatePosition( 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 } );
-
-		if ( this.lightsNode ) builder.lightsNode = this.lightsNode;
-
-		const materialLightsNode = [];
-
-		if ( envNode ) {
-
-			materialLightsNode.push( new EnvironmentNode( envNode ) );
-
-		}
-
-		if ( builder.material.aoMap ) {
-
-			materialLightsNode.push( new AONode( texture( builder.material.aoMap ) ) );
-
-		}
-
-		if ( materialLightsNode.length > 0 ) {
+	constructLightingModel( /*builder*/ ) {
 
-			builder.lightsNode = new LightsNode( [ ...builder.lightsNode.lightNodes, ...materialLightsNode ] );
-
-		}
-
-		const outgoingLightNode = this.generateLight( builder, { diffuseColorNode, lightingModelNode: PhysicalLightingModel } );
-
-		this.generateOutput( builder, { diffuseColorNode, outgoingLightNode } );
+		return physicalLightingModel;
 
 	}
 
-	generateStandardMaterial( builder, { colorNode, diffuseColorNode } ) {
-
-		const { material } = builder;
+	constructVariants( { stack } ) {
 
 		// METALNESS
 
-		let metalnessNode = this.metalnessNode ? float( this.metalnessNode ) : materialMetalness;
+		const metalnessNode = this.metalnessNode ? float( this.metalnessNode ) : materialMetalness;
 
-		metalnessNode = builder.addFlow( 'fragment', label( metalnessNode, 'Metalness' ) );
-		builder.addFlow( 'fragment', assign( diffuseColorNode, vec4( mul( diffuseColorNode.rgb, invert( metalnessNode ) ), diffuseColorNode.a ) ) );
+		stack.assign( metalness, metalnessNode );
 
 		// ROUGHNESS
 
 		let roughnessNode = this.roughnessNode ? float( this.roughnessNode ) : materialRoughness;
 		roughnessNode = getRoughness.call( { roughness: roughnessNode } );
 
-		builder.addFlow( 'fragment', label( roughnessNode, 'Roughness' ) );
+		stack.assign( roughness, roughnessNode );
 
 		// SPECULAR COLOR
 
-		const specularColorNode = mix( vec3( 0.04 ), colorNode.rgb, metalnessNode );
-
-		builder.addFlow( 'fragment', label( specularColorNode, 'SpecularColor' ) );
+		const specularColorNode = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessNode );
 
-		// NORMAL VIEW
+		stack.assign( specularColor, specularColorNode );
 
-		const normalNode = this.normalNode ? vec3( this.normalNode ) : ( material.normalMap ? new NormalMapNode( texture( material.normalMap ), uniform( material.normalScale ) ) : normalView );
+		// DIFFUSE COLOR
 
-		builder.addFlow( 'fragment', label( normalNode, 'TransformedNormalView' ) );
-
-		return diffuseColorNode;
-
-	}
-
-	generateLight( builder, { diffuseColorNode, lightingModelNode, lightsNode = builder.lightsNode } ) {
-
-		const renderer = builder.renderer;
-
-		// OUTGOING LIGHT
-
-		let outgoingLightNode = super.generateLight( builder, { diffuseColorNode, lightingModelNode, lightsNode } );
-
-		// EMISSIVE
-
-		outgoingLightNode = add( vec3( this.emissiveNode || materialEmissive ), outgoingLightNode );
-
-		// TONE MAPPING
-
-		if ( renderer.toneMappingNode ) outgoingLightNode = context( renderer.toneMappingNode, { color: outgoingLightNode } );
-
-		return outgoingLightNode;
+		stack.assign( diffuseColor, vec4( diffuseColor.rgb.mul( metalnessNode.oneMinus() ), diffuseColor.a ) );
 
 	}
 
@@ -166,3 +87,7 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
 	}
 
 }
+
+export default MeshStandardNodeMaterial;
+
+addNodeMaterial( MeshStandardNodeMaterial );