super-three 0.136.1 → 0.144.0

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

@@ -0,0 +1,107 @@
+import * as Nodes from '../Nodes.js';
+import { FileLoader, 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( json.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,73 @@
+import { MaterialLoader } from 'three';
+import {
+	NodeMaterial,
+	LineBasicNodeMaterial,
+	MeshBasicNodeMaterial,
+	MeshStandardNodeMaterial,
+	PointsNodeMaterial,
+	SpriteNodeMaterial
+} from '../materials/Materials.js';
+
+const superFromTypeFunction = MaterialLoader.createMaterialFromType;
+
+MaterialLoader.createMaterialFromType = function ( type ) {
+
+	const materialLib = {
+		NodeMaterial,
+		LineBasicNodeMaterial,
+		MeshBasicNodeMaterial,
+		MeshStandardNodeMaterial,
+		PointsNodeMaterial,
+		SpriteNodeMaterial,
+	};
+
+	if ( materialLib[ type ] !== undefined ) {
+
+		return new materialLib[ type ]();
+
+	}
+
+	return superFromTypeFunction.call( this, type );
+
+};
+
+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;

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

@@ -0,0 +1,53 @@
+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 ) {
+
+		return material; // is already a node material or cannot be converted
+
+	}
+
+	const nodeMaterial = new materialLib[ type ]( material );
+
+	for ( const key in material ) {
+
+		if ( nodeMaterial[ key ] === undefined ) {
+
+			nodeMaterial[ key ] = material[ key ]; // currently this is needed only for material.alphaTest
+
+		}
+
+	}
+
+	return nodeMaterial;
+
+};

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

@@ -1,10 +1,17 @@
+import NodeMaterial from './NodeMaterial.js';
 import { MeshBasicMaterial } from 'three';
 
-class MeshBasicNodeMaterial extends MeshBasicMaterial {
+const defaultValues = new MeshBasicMaterial();
+
+class MeshBasicNodeMaterial extends NodeMaterial {
 
 	constructor( parameters ) {
 
-		super( parameters );
+		super();
+
+		this.isMeshBasicNodeMaterial = true;
+
+		this.lights = true;
 
 		this.colorNode = null;
 		this.opacityNode = null;
@@ -15,6 +22,10 @@ class MeshBasicNodeMaterial extends MeshBasicMaterial {
 
 		this.positionNode = null;
 
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
 	}
 
 	copy( source ) {
@@ -34,6 +45,4 @@ class MeshBasicNodeMaterial extends MeshBasicMaterial {
 
 }
 
-MeshBasicNodeMaterial.prototype.isNodeMaterial = true;
-
 export default MeshBasicNodeMaterial;

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

@@ -0,0 +1,70 @@
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+
+import { MeshPhysicalMaterial } from 'three';
+
+const defaultValues = new MeshPhysicalMaterial();
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshPhysicalNodeMaterial = true;
+
+		this.clearcoatNode = null;
+		this.clearcoatRoughnessNode = null;
+		this.clearcoatNormalNode = null;
+
+		this.sheenNode = null;
+		this.sheenRoughnessNode = null;
+
+		this.iridescenceNode = null;
+		this.iridescenceIORNode = null;
+		this.iridescenceThicknessNode = null;
+
+		this.specularIntensityNode = null;
+		this.specularColorNode = null;
+
+		this.transmissionNode = null;
+		this.thicknessNode = null;
+		this.attenuationDistanceNode = null;
+		this.attenuationColorNode = null;
+
+		this.sheen = 0;
+		this.clearcoat = 0;
+		this.iridescence = 0;
+		this.transmission = 0;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		this.clearcoatNode = source.clearcoatNode;
+		this.clearcoatRoughnessNode = source.clearcoatRoughnessNode;
+		this.clearcoatNormalNode = source.clearcoatNormalNode;
+
+		this.sheenNode = source.sheenNode;
+		this.sheenRoughnessNode = source.sheenRoughnessNode;
+
+		this.iridescenceNode = source.iridescenceNode;
+		this.iridescenceIORNode = source.iridescenceIORNode;
+		this.iridescenceThicknessNode = source.iridescenceThicknessNode;
+
+		this.specularIntensityNode = source.specularIntensityNode;
+		this.specularColorNode = source.specularColorNode;
+
+		this.transmissionNode = source.transmissionNode;
+		this.thicknessNode = source.thicknessNode;
+		this.attenuationDistanceNode = source.attenuationDistanceNode;
+		this.attenuationColorNode = source.attenuationColorNode;
+
+		return super.copy( source );
+
+	}
+
+}

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

@@ -1,31 +1,168 @@
-import { MeshStandardNode } from './nodes/MeshStandardNode.js';
-import { NodeMaterial } from './NodeMaterial.js';
-import { NodeUtils } from '../core/NodeUtils.js';
+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 getRoughness from '../functions/material/getRoughness.js';
+import PhysicalLightingModel from '../functions/PhysicalLightingModel.js';
+import NormalMapNode from '../display/NormalMapNode.js';
 
-class MeshStandardNodeMaterial extends NodeMaterial {
+import { MeshStandardMaterial } from 'three';
 
-	constructor() {
+const defaultValues = new MeshStandardMaterial();
 
-		const node = new MeshStandardNode();
+export default class MeshStandardNodeMaterial extends NodeMaterial {
 
-		super( node, node );
+	constructor( parameters ) {
 
-		this.type = 'MeshStandardNodeMaterial';
+		super();
+
+		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 ) {
+
+			builder.lightsNode = new LightsNode( [ ...builder.lightsNode.lightNodes, ...materialLightsNode ] );
+
+		}
+
+		const outgoingLightNode = this.generateLight( builder, { diffuseColorNode, lightingModelNode: PhysicalLightingModel } );
+
+		this.generateOutput( builder, { diffuseColorNode, outgoingLightNode } );
+
+	}
+
+	generateStandardMaterial( builder, { colorNode, diffuseColorNode } ) {
+
+		const { material } = builder;
+
+		// METALNESS
+
+		let 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 ) ) );
 
-NodeUtils.addShortcuts( MeshStandardNodeMaterial.prototype, 'properties', [
-	'color',
-	'roughness',
-	'metalness',
-	'map',
-	'normalMap',
-	'normalScale',
-	'metalnessMap',
-	'roughnessMap',
-	'envMap'
-] );
-
-export { MeshStandardNodeMaterial };
+		// ROUGHNESS
+
+		let roughnessNode = this.roughnessNode ? float( this.roughnessNode ) : materialRoughness;
+		roughnessNode = getRoughness.call( { roughness: roughnessNode } );
+
+		builder.addFlow( 'fragment', label( roughnessNode, 'Roughness' ) );
+
+		// SPECULAR COLOR
+
+		const specularColorNode = mix( vec3( 0.04 ), colorNode.rgb, metalnessNode );
+
+		builder.addFlow( 'fragment', label( specularColorNode, 'SpecularColor' ) );
+
+		// NORMAL VIEW
+
+		const normalNode = this.normalNode ? vec3( this.normalNode ) : ( material.normalMap ? new NormalMapNode( texture( material.normalMap ), uniform( material.normalScale ) ) : normalView );
+
+		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;
+
+	}
+
+	copy( source ) {
+
+		this.colorNode = source.colorNode;
+		this.opacityNode = source.opacityNode;
+
+		this.alphaTestNode = source.alphaTestNode;
+
+		this.normalNode = source.normalNode;
+
+		this.emissiveNode = source.emissiveNode;
+
+		this.metalnessNode = source.metalnessNode;
+		this.roughnessNode = source.roughnessNode;
+
+		this.envNode = source.envNode;
+
+		this.lightsNode = source.lightsNode;
+
+		this.positionNode = source.positionNode;
+
+		return super.copy( source );
+
+	}
+
+}