@plastic-software/three 0.167.3 → 0.174.0

package/src/materials/nodes/MeshBasicNodeMaterial.js

@@ -0,0 +1,133 @@
+import NodeMaterial from './NodeMaterial.js';
+import { materialLightMap } from '../../nodes/accessors/MaterialNode.js';
+import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
+import BasicLightMapNode from '../../nodes/lighting/BasicLightMapNode.js';
+import BasicLightingModel from '../../nodes/functions/BasicLightingModel.js';
+import { normalView } from '../../nodes/accessors/Normal.js';
+import { diffuseColor } from '../../nodes/core/PropertyNode.js';
+
+import { MeshBasicMaterial } from '../MeshBasicMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshBasicMaterial();
+
+/**
+ * Node material version of `MeshBasicMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class MeshBasicNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshBasicNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new mesh basic node material.
+	 *
+	 * @param {?Object} parameters - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMeshBasicNodeMaterial = true;
+
+		/**
+		 * Although the basic material is by definition unlit, we set
+		 * this property to `true` since we use a lighting model to compute
+		 * the outgoing light of the fragment shader.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Basic materials are not affected by normal and bump maps so we
+	 * return by default {@link normalView}.
+	 *
+	 * @return {Node<vec3>} The normal node.
+	 */
+	setupNormal() {
+
+		return normalView; // see #28839
+
+	}
+
+	/**
+	 * Overwritten since this type of material uses {@link BasicEnvironmentNode}
+	 * to implement the default environment mapping.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @return {?BasicEnvironmentNode<vec3>} The environment node.
+	 */
+	setupEnvironment( builder ) {
+
+		const envNode = super.setupEnvironment( builder );
+
+		return envNode ? new BasicEnvironmentNode( envNode ) : null;
+
+	}
+
+	/**
+	 * This method must be overwritten since light maps are evaluated
+	 * with a special scaling factor for basic materials.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @return {?BasicLightMapNode<vec3>} The light map node.
+	 */
+	setupLightMap( builder ) {
+
+		let node = null;
+
+		if ( builder.material.lightMap ) {
+
+			node = new BasicLightMapNode( materialLightMap );
+
+		}
+
+		return node;
+
+	}
+
+	/**
+	 * The material overwrites this method because `lights` is set to `true` but
+	 * we still want to return the diffuse color as the outgoing light.
+	 *
+	 * @return {Node<vec3>} The outgoing light node.
+	 */
+	setupOutgoingLight() {
+
+		return diffuseColor.rgb;
+
+	}
+
+	/**
+	 * Setups the lighting model.
+	 *
+	 * @return {BasicLightingModel} The lighting model.
+	 */
+	setupLightingModel() {
+
+		return new BasicLightingModel();
+
+	}
+
+}
+
+export default MeshBasicNodeMaterial;

package/src/materials/nodes/MeshLambertNodeMaterial.js

@@ -0,0 +1,82 @@
+import NodeMaterial from './NodeMaterial.js';
+import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
+import PhongLightingModel from '../../nodes/functions/PhongLightingModel.js';
+
+import { MeshLambertMaterial } from '../MeshLambertMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshLambertMaterial();
+
+/**
+ * Node material version of `MeshLambertMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class MeshLambertNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshLambertNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new mesh lambert node material.
+	 *
+	 * @param {?Object} parameters - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMeshLambertNodeMaterial = true;
+
+		/**
+		 * Set to `true` because lambert materials react on lights.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Overwritten since this type of material uses {@link BasicEnvironmentNode}
+	 * to implement the default environment mapping.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @return {?BasicEnvironmentNode<vec3>} The environment node.
+	 */
+	setupEnvironment( builder ) {
+
+		const envNode = super.setupEnvironment( builder );
+
+		return envNode ? new BasicEnvironmentNode( envNode ) : null;
+
+	}
+
+	/**
+	 * Setups the lighting model.
+	 *
+	 * @return {PhongLightingModel} The lighting model.
+	 */
+	setupLightingModel( /*builder*/ ) {
+
+		return new PhongLightingModel( false ); // ( specular ) -> force lambert
+
+	}
+
+}
+
+export default MeshLambertNodeMaterial;

package/src/materials/nodes/MeshMatcapNodeMaterial.js

@@ -0,0 +1,77 @@
+import NodeMaterial from './NodeMaterial.js';
+import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
+import { diffuseColor } from '../../nodes/core/PropertyNode.js';
+import { vec3 } from '../../nodes/tsl/TSLBase.js';
+import { mix } from '../../nodes/math/MathNode.js';
+import { matcapUV } from '../../nodes/utils/MatcapUVNode.js';
+
+import { MeshMatcapMaterial } from '../MeshMatcapMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshMatcapMaterial();
+
+/**
+ * Node material version of `MeshMatcapMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class MeshMatcapNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshMatcapNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new mesh normal node material.
+	 *
+	 * @param {?Object} parameters - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMeshMatcapNodeMaterial = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Setups the matcap specific node variables.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 */
+	setupVariants( builder ) {
+
+		const uv = matcapUV;
+
+		let matcapColor;
+
+		if ( builder.material.matcap ) {
+
+			matcapColor = materialReference( 'matcap', 'texture' ).context( { getUV: () => uv } );
+
+		} else {
+
+			matcapColor = vec3( mix( 0.2, 0.8, uv.y ) ); // default if matcap is missing
+
+		}
+
+		diffuseColor.rgb.mulAssign( matcapColor.rgb );
+
+	}
+
+}
+
+
+export default MeshMatcapNodeMaterial;

package/src/materials/nodes/MeshNormalNodeMaterial.js

@@ -0,0 +1,67 @@
+import NodeMaterial from './NodeMaterial.js';
+import { diffuseColor } from '../../nodes/core/PropertyNode.js';
+import { directionToColor } from '../../nodes/utils/Packing.js';
+import { materialOpacity } from '../../nodes/accessors/MaterialNode.js';
+import { transformedNormalView } from '../../nodes/accessors/Normal.js';
+import { colorSpaceToWorking } from '../../nodes/display/ColorSpaceNode.js';
+import { float, vec4 } from '../../nodes/tsl/TSLBase.js';
+import { SRGBColorSpace } from '../../constants.js';
+
+import { MeshNormalMaterial } from '../MeshNormalMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshNormalMaterial();
+
+/**
+ * Node material version of `MeshNormalMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class MeshNormalNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshNormalNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new mesh normal node material.
+	 *
+	 * @param {?Object} parameters - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMeshNormalNodeMaterial = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Overwrites the default implementation by computing the diffuse color
+	 * based on the normal data.
+	 */
+	setupDiffuseColor() {
+
+		const opacityNode = this.opacityNode ? float( this.opacityNode ) : materialOpacity;
+
+		// By convention, a normal packed to RGB is in sRGB color space. Convert it to working color space.
+
+		diffuseColor.assign( colorSpaceToWorking( vec4( directionToColor( transformedNormalView ), opacityNode ), SRGBColorSpace ) );
+
+	}
+
+}
+
+export default MeshNormalNodeMaterial;

package/src/materials/nodes/MeshPhongNodeMaterial.js

@@ -0,0 +1,141 @@
+import NodeMaterial from './NodeMaterial.js';
+import { shininess, specularColor } from '../../nodes/core/PropertyNode.js';
+import { materialShininess, materialSpecular } from '../../nodes/accessors/MaterialNode.js';
+import { float } from '../../nodes/tsl/TSLBase.js';
+import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
+import PhongLightingModel from '../../nodes/functions/PhongLightingModel.js';
+
+import { MeshPhongMaterial } from '../MeshPhongMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshPhongMaterial();
+
+/**
+ * Node material version of `MeshPhongMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class MeshPhongNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshPhongNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new mesh lambert node material.
+	 *
+	 * @param {?Object} parameters - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isMeshPhongNodeMaterial = true;
+
+		/**
+		 * Set to `true` because phong materials react on lights.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.lights = true;
+
+		/**
+		 * The shininess of phong materials is by default inferred from the `shininess`
+		 * property. This node property allows to overwrite the default
+		 * and define the shininess with a node instead.
+		 *
+		 * If you don't want to overwrite the shininess but modify the existing
+		 * value instead, use {@link materialShininess}.
+		 *
+		 * @type {?Node<float>}
+		 * @default null
+		 */
+		this.shininessNode = null;
+
+		/**
+		 * The specular color of phong materials is by default inferred from the
+		 * `specular` property. This node property allows to overwrite the default
+		 * and define the specular color with a node instead.
+		 *
+		 * If you don't want to overwrite the specular color but modify the existing
+		 * value instead, use {@link materialSpecular}.
+		 *
+		 * @type {?Node<vec3>}
+		 * @default null
+		 */
+		this.specularNode = null;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Overwritten since this type of material uses {@link BasicEnvironmentNode}
+	 * to implement the default environment mapping.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @return {?BasicEnvironmentNode<vec3>} The environment node.
+	 */
+	setupEnvironment( builder ) {
+
+		const envNode = super.setupEnvironment( builder );
+
+		return envNode ? new BasicEnvironmentNode( envNode ) : null;
+
+	}
+
+	/**
+	 * Setups the lighting model.
+	 *
+	 * @return {PhongLightingModel} The lighting model.
+	 */
+	setupLightingModel( /*builder*/ ) {
+
+		return new PhongLightingModel();
+
+	}
+
+	/**
+	 * Setups the phong specific node variables.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 */
+	setupVariants( /*builder*/ ) {
+
+		// SHININESS
+
+		const shininessNode = ( this.shininessNode ? float( this.shininessNode ) : materialShininess ).max( 1e-4 ); // to prevent pow( 0.0, 0.0 )
+
+		shininess.assign( shininessNode );
+
+		// SPECULAR COLOR
+
+		const specularNode = this.specularNode || materialSpecular;
+
+		specularColor.assign( specularNode );
+
+	}
+
+	copy( source ) {
+
+		this.shininessNode = source.shininessNode;
+		this.specularNode = source.specularNode;
+
+		return super.copy( source );
+
+	}
+
+}
+
+export default MeshPhongNodeMaterial;