@plastic-software/three 0.167.4 → 0.174.0

package/src/{nodes/materials/Materials.js → materials/nodes/NodeMaterials.js}

@@ -1,7 +1,8 @@
 // @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 InstancedPointsNodeMaterial } from './InstancedPointsNodeMaterial.js';
+export { default as NodeMaterialObserver } from './manager/NodeMaterialObserver.js';
+
+export { default as NodeMaterial } from './NodeMaterial.js';
 export { default as LineBasicNodeMaterial } from './LineBasicNodeMaterial.js';
 export { default as LineDashedNodeMaterial } from './LineDashedNodeMaterial.js';
 export { default as Line2NodeMaterial } from './Line2NodeMaterial.js';

package/src/materials/nodes/PointsNodeMaterial.js

@@ -0,0 +1,153 @@
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+import { viewport } from '../../nodes/display/ScreenNode.js';
+import { positionGeometry, positionLocal, positionView } from '../../nodes/accessors/Position.js';
+import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
+import { materialPointSize } from '../../nodes/accessors/MaterialNode.js';
+import { rotate } from '../../nodes/utils/RotateNode.js';
+import { float, vec2, vec3, vec4 } from '../../nodes/tsl/TSLBase.js';
+
+import { PointsMaterial } from '../PointsMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new PointsMaterial();
+
+/**
+ * Node material version of `PointsMaterial`.
+ *
+ * @augments SpriteNodeMaterial
+ */
+class PointsNodeMaterial extends SpriteNodeMaterial {
+
+	static get type() {
+
+		return 'PointsNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new points node material.
+	 *
+	 * @param {Object} [parameters] - The configuration parameter.
+	 */
+	constructor( parameters ) {
+
+		super();
+
+		/**
+		 * This node property provides an additional way to set the point size.
+		 *
+		 * @type {?Node<vec2>}
+		 * @default null
+		 */
+		this.sizeNode = null;
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isPointsNodeMaterial = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupPositionView() {
+
+		const { positionNode } = this;
+
+		return modelViewMatrix.mul( vec3( positionNode || positionLocal ) ).xyz;
+
+	}
+
+	setupVertex( builder ) {
+
+		const mvp = super.setupVertex( builder );
+
+		// skip further processing if the material is not a node material
+
+		if ( builder.material.isNodeMaterial !== true ) {
+
+			return mvp;
+
+		}
+
+		// ndc space
+
+		const { rotationNode, scaleNode, sizeNode } = this;
+
+		const alignedPosition = positionGeometry.xy.toVar();
+		const aspect = viewport.z.div( viewport.w );
+
+		// rotation
+
+		if ( rotationNode && rotationNode.isNode ) {
+
+			const rotation = float( rotationNode );
+
+			alignedPosition.assign( rotate( alignedPosition, rotation ) );
+
+		}
+
+		// point size
+
+		let pointSize = sizeNode !== null ? vec2( sizeNode ) : materialPointSize;
+
+		if ( this.sizeAttenuation === true ) {
+
+			pointSize = pointSize.mul( pointSize.div( positionView.z.negate() ) );
+
+		}
+
+		// scale
+
+		if ( scaleNode && scaleNode.isNode ) {
+
+			pointSize = pointSize.mul( vec2( scaleNode ) );
+
+		}
+
+		alignedPosition.mulAssign( pointSize.mul( 2 ) );
+
+		alignedPosition.assign( alignedPosition.div( viewport.z ) );
+		alignedPosition.y.assign( alignedPosition.y.mul( aspect ) );
+
+		// back to clip space
+		alignedPosition.assign( alignedPosition.mul( mvp.w ) );
+
+		//clipPos.xy += offset;
+		mvp.addAssign( vec4( alignedPosition, 0, 0 ) );
+
+		return mvp;
+
+	}
+
+	/**
+	 * Whether alpha to coverage should be used or not.
+	 *
+	 * @type {boolean}
+	 * @default true
+	 */
+	get alphaToCoverage() {
+
+		return this._useAlphaToCoverage;
+
+	}
+
+	set alphaToCoverage( value ) {
+
+		if ( this._useAlphaToCoverage !== value ) {
+
+			this._useAlphaToCoverage = value;
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+}
+
+export default PointsNodeMaterial;

package/src/materials/nodes/ShadowNodeMaterial.js

@@ -0,0 +1,67 @@
+import NodeMaterial from './NodeMaterial.js';
+import ShadowMaskModel from '../../nodes/functions/ShadowMaskModel.js';
+
+import { ShadowMaterial } from '../ShadowMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new ShadowMaterial();
+
+/**
+ * Node material version of `ShadowMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class ShadowNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'ShadowNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new shadow 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.isShadowNodeMaterial = true;
+
+		/**
+		 * Set to `true` because so it's possible to implement
+		 * the shadow mask effect.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Setups the lighting model.
+	 *
+	 * @return {ShadowMaskModel} The lighting model.
+	 */
+	setupLightingModel( /*builder*/ ) {
+
+		return new ShadowMaskModel();
+
+	}
+
+}
+
+export default ShadowNodeMaterial;

package/src/materials/nodes/SpriteNodeMaterial.js

@@ -0,0 +1,198 @@
+import NodeMaterial from './NodeMaterial.js';
+import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
+import { materialRotation } from '../../nodes/accessors/MaterialNode.js';
+import { modelViewMatrix, modelWorldMatrix } from '../../nodes/accessors/ModelNode.js';
+import { positionGeometry } from '../../nodes/accessors/Position.js';
+import { rotate } from '../../nodes/utils/RotateNode.js';
+import { float, vec2, vec3, vec4 } from '../../nodes/tsl/TSLBase.js';
+
+import { SpriteMaterial } from '../SpriteMaterial.js';
+import { reference } from '../../nodes/accessors/ReferenceBaseNode.js';
+
+const _defaultValues = /*@__PURE__*/ new SpriteMaterial();
+
+/**
+ * Node material version of `SpriteMaterial`.
+ *
+ * @augments NodeMaterial
+ */
+class SpriteNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'SpriteNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new sprite 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.isSpriteNodeMaterial = true;
+
+		this._useSizeAttenuation = true;
+
+		/**
+		 * This property makes it possible to define the position of the sprite with a
+		 * node. That can be useful when the material is used with instanced rendering
+		 * and node data are defined with an instanced attribute node:
+		 * ```js
+		 * const positionAttribute = new InstancedBufferAttribute( new Float32Array( positions ), 3 );
+		 * material.positionNode = instancedBufferAttribute( positionAttribute );
+		 * ```
+		 * Another possibility is to compute the instanced data with a compute shader:
+		 * ```js
+		 * const positionBuffer = instancedArray( particleCount, 'vec3' );
+		 * particleMaterial.positionNode = positionBuffer.toAttribute();
+		 * ```
+		 *
+		 * @type {?Node<vec2>}
+		 * @default null
+		 */
+		this.positionNode = null;
+
+		/**
+		 * The rotation of sprite materials is by default inferred from the `rotation`,
+		 * property. This node property allows to overwrite the default and define
+		 * the rotation with a node instead.
+		 *
+		 * If you don't want to overwrite the rotation but modify the existing
+		 * value instead, use {@link materialRotation}.
+		 *
+		 * @type {?Node<float>}
+		 * @default null
+		 */
+		this.rotationNode = null;
+
+		/**
+		 * This node property provides an additional way to scale sprites next to
+		 * `Object3D.scale`. The scale transformation based in `Object3D.scale`
+		 * is multiplied with the scale value of this node in the vertex shader.
+		 *
+		 * @type {?Node<vec2>}
+		 * @default null
+		 */
+		this.scaleNode = null;
+
+		/**
+		 * In Sprites, the transparent property is enabled by default.
+		 *
+		 * @type {boolean}
+		 * @default true
+		 */
+		this.transparent = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	/**
+	 * Setups the position node in view space. This method implements
+	 * the sprite specific vertex shader.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @return {Node<vec3>} The position in view space.
+	 */
+	setupPositionView( builder ) {
+
+		const { object, camera } = builder;
+
+		const sizeAttenuation = this.sizeAttenuation;
+
+		const { positionNode, rotationNode, scaleNode } = this;
+
+		const mvPosition = modelViewMatrix.mul( vec3( positionNode || 0 ) );
+
+		let scale = vec2( modelWorldMatrix[ 0 ].xyz.length(), modelWorldMatrix[ 1 ].xyz.length() );
+
+		if ( scaleNode !== null ) {
+
+			scale = scale.mul( vec2( scaleNode ) );
+
+		}
+
+		if ( sizeAttenuation === false ) {
+
+			if ( camera.isPerspectiveCamera ) {
+
+				scale = scale.mul( mvPosition.z.negate() );
+
+			} else {
+
+				const orthoScale = float( 2.0 ).div( cameraProjectionMatrix.element( 1 ).element( 1 ) );
+				scale = scale.mul( orthoScale.mul( 2 ) );
+
+			}
+
+		}
+
+		let alignedPosition = positionGeometry.xy;
+
+		if ( object.center && object.center.isVector2 === true ) {
+
+			const center = reference( 'center', 'vec2', object );
+
+			alignedPosition = alignedPosition.sub( center.sub( 0.5 ) );
+
+		}
+
+		alignedPosition = alignedPosition.mul( scale );
+
+		const rotation = float( rotationNode || materialRotation );
+
+		const rotatedPosition = rotate( alignedPosition, rotation );
+
+		return vec4( mvPosition.xy.add( rotatedPosition ), mvPosition.zw );
+
+	}
+
+	copy( source ) {
+
+		this.positionNode = source.positionNode;
+		this.rotationNode = source.rotationNode;
+		this.scaleNode = source.scaleNode;
+
+		return super.copy( source );
+
+	}
+
+	/**
+	 * Whether to use size attenuation or not.
+	 *
+	 * @type {boolean}
+	 * @default true
+	 */
+	get sizeAttenuation() {
+
+		return this._useSizeAttenuation;
+
+	}
+
+	set sizeAttenuation( value ) {
+
+		if ( this._useSizeAttenuation !== value ) {
+
+			this._useSizeAttenuation = value;
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+}
+
+export default SpriteNodeMaterial;

package/src/materials/nodes/VolumeNodeMaterial.js

@@ -0,0 +1,72 @@
+import NodeMaterial from './NodeMaterial.js';
+import VolumetricLightingModel from '../../nodes/functions/VolumetricLightingModel.js';
+import { BackSide } from '../../constants.js';
+
+/**
+ * Volume node material.
+ *
+ * @augments NodeMaterial
+ */
+class VolumeNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'VolumeNodeMaterial';
+
+	}
+
+	/**
+	 * Constructs a new volume 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.isVolumeNodeMaterial = true;
+
+		/**
+		 * Number of steps used for raymarching.
+		 *
+		 * @type {number}
+		 * @default 25
+		 */
+		this.steps = 25;
+
+		/**
+		 * Node used for scattering calculations.
+		 *
+		 * @type {Function|FunctionNode<vec4>}
+		 * @default null
+		 */
+		this.scatteringNode = null;
+
+		this.lights = true;
+
+		this.transparent = true;
+		this.side = BackSide;
+
+		this.depthTest = false;
+		this.depthWrite = false;
+
+		this.setValues( parameters );
+
+	}
+
+	setupLightingModel() {
+
+		return new VolumetricLightingModel();
+
+	}
+
+}
+
+export default VolumeNodeMaterial;