@plastic-software/three 0.167.4 → 0.174.0

package/src/nodes/display/ColorSpaceNode.js

@@ -1,108 +1,187 @@
 import TempNode from '../core/TempNode.js';
-import { mix } from '../math/MathNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, Fn, nodeObject, nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
-
-import { LinearSRGBColorSpace, SRGBColorSpace } from '../../constants.js';
-
-const sRGBToLinearShader = Fn( ( inputs ) => {
+import { addMethodChaining, mat3, nodeObject, vec4 } from '../tsl/TSLCore.js';
+
+import { SRGBTransfer } from '../../constants.js';
+import { ColorManagement } from '../../math/ColorManagement.js';
+import { sRGBTransferEOTF, sRGBTransferOETF } from './ColorSpaceFunctions.js';
+import { Matrix3 } from '../../math/Matrix3.js';
+
+const WORKING_COLOR_SPACE = 'WorkingColorSpace';
+const OUTPUT_COLOR_SPACE = 'OutputColorSpace';
+
+/**
+ * This node represents a color space conversion. Meaning it converts
+ * a color value from a source to a target color space.
+ *
+ * @augments TempNode
+ */
+class ColorSpaceNode extends TempNode {
 
-	const { value } = inputs;
-	const { rgb } = value;
+	static get type() {
 
-	const a = rgb.mul( 0.9478672986 ).add( 0.0521327014 ).pow( 2.4 );
-	const b = rgb.mul( 0.0773993808 );
-	const factor = rgb.lessThanEqual( 0.04045 );
+		return 'ColorSpaceNode';
 
-	const rgbResult = mix( a, b, factor );
+	}
 
-	return vec4( rgbResult, value.a );
+	/**
+	 * Constructs a new color space node.
+	 *
+	 * @param {Node} colorNode - Represents the color to convert.
+	 * @param {string} source - The source color space.
+	 * @param {string} target - The target color space.
+	 */
+	constructor( colorNode, source, target ) {
 
-} );
+		super( 'vec4' );
 
-const LinearTosRGBShader = Fn( ( inputs ) => {
+		/**
+		 * Represents the color to convert.
+		 *
+		 * @type {Node}
+		 */
+		this.colorNode = colorNode;
+
+		/**
+		 * The source color space.
+		 *
+		 * @type {string}
+		 */
+		this.source = source;
+
+		/**
+		 * The target color space.
+		 *
+		 * @type {string}
+		 */
+		this.target = target;
 
-	const { value } = inputs;
-	const { rgb } = value;
+	}
 
-	const a = rgb.pow( 0.41666 ).mul( 1.055 ).sub( 0.055 );
-	const b = rgb.mul( 12.92 );
-	const factor = rgb.lessThanEqual( 0.0031308 );
+	/**
+	 * This method resolves the constants `WORKING_COLOR_SPACE` and
+	 * `OUTPUT_COLOR_SPACE` based on the current configuration of the
+	 * color management and renderer.
+	 *
+	 * @param {NodeBuilder} builder - The current node builder.
+	 * @param {string} colorSpace - The color space to resolve.
+	 * @return {string} The resolved color space.
+	 */
+	resolveColorSpace( builder, colorSpace ) {
 
-	const rgbResult = mix( a, b, factor );
+		if ( colorSpace === WORKING_COLOR_SPACE ) {
 
-	return vec4( rgbResult, value.a );
+			return ColorManagement.workingColorSpace;
 
-} );
+		} else if ( colorSpace === OUTPUT_COLOR_SPACE ) {
 
-const getColorSpaceMethod = ( colorSpace ) => {
+			return builder.context.outputColorSpace || builder.renderer.outputColorSpace;
 
-	let method = null;
+		}
 
-	if ( colorSpace === LinearSRGBColorSpace ) {
+		return colorSpace;
 
-		method = 'Linear';
+	}
 
-	} else if ( colorSpace === SRGBColorSpace ) {
+	setup( builder ) {
 
-		method = 'sRGB';
+		const { colorNode } = this;
 
-	}
+		const source = this.resolveColorSpace( builder, this.source );
+		const target = this.resolveColorSpace( builder, this.target );
 
-	return method;
+		let outputNode = colorNode;
 
-};
+		if ( ColorManagement.enabled === false || source === target || ! source || ! target ) {
 
-const getMethod = ( source, target ) => {
+			return outputNode;
 
-	return getColorSpaceMethod( source ) + 'To' + getColorSpaceMethod( target );
+		}
 
-};
+		if ( ColorManagement.getTransfer( source ) === SRGBTransfer ) {
 
-class ColorSpaceNode extends TempNode {
+			outputNode = vec4( sRGBTransferEOTF( outputNode.rgb ), outputNode.a );
 
-	constructor( method, node ) {
+		}
 
-		super( 'vec4' );
+		if ( ColorManagement.getPrimaries( source ) !== ColorManagement.getPrimaries( target ) ) {
 
-		this.method = method;
-		this.node = node;
+			outputNode = vec4(
+				mat3( ColorManagement._getMatrix( new Matrix3(), source, target ) ).mul( outputNode.rgb ),
+				outputNode.a
+			);
 
-	}
+		}
 
-	setup() {
+		if ( ColorManagement.getTransfer( target ) === SRGBTransfer ) {
 
-		const { method, node } = this;
+			outputNode = vec4( sRGBTransferOETF( outputNode.rgb ), outputNode.a );
 
-		if ( method === ColorSpaceNode.LINEAR_TO_LINEAR )
-			return node;
+		}
 
-		return Methods[ method ]( { value: node } );
+		return outputNode;
 
 	}
 
 }
 
-ColorSpaceNode.LINEAR_TO_LINEAR = 'LinearToLinear';
-ColorSpaceNode.LINEAR_TO_sRGB = 'LinearTosRGB';
-ColorSpaceNode.sRGB_TO_LINEAR = 'sRGBToLinear';
-
-const Methods = {
-	[ ColorSpaceNode.LINEAR_TO_sRGB ]: LinearTosRGBShader,
-	[ ColorSpaceNode.sRGB_TO_LINEAR ]: sRGBToLinearShader
-};
-
 export default ColorSpaceNode;
 
-export const linearToColorSpace = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( LinearSRGBColorSpace, colorSpace ), nodeObject( node ) ) );
-export const colorSpaceToLinear = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( colorSpace, LinearSRGBColorSpace ), nodeObject( node ) ) );
-
-export const linearTosRGB = nodeProxy( ColorSpaceNode, ColorSpaceNode.LINEAR_TO_sRGB );
-export const sRGBToLinear = nodeProxy( ColorSpaceNode, ColorSpaceNode.sRGB_TO_LINEAR );
-
-addNodeElement( 'linearTosRGB', linearTosRGB );
-addNodeElement( 'sRGBToLinear', sRGBToLinear );
-addNodeElement( 'linearToColorSpace', linearToColorSpace );
-addNodeElement( 'colorSpaceToLinear', colorSpaceToLinear );
-
-addNodeClass( 'ColorSpaceNode', ColorSpaceNode );
+/**
+ * TSL function for converting a given color node to the current output color space.
+ *
+ * @tsl
+ * @function
+ * @param {Node} node - Represents the node to convert.
+ * @returns {ColorSpaceNode}
+ */
+export const toOutputColorSpace = ( node ) => nodeObject( new ColorSpaceNode( nodeObject( node ), WORKING_COLOR_SPACE, OUTPUT_COLOR_SPACE ) );
+
+/**
+ * TSL function for converting a given color node to the current working color space.
+ *
+ * @tsl
+ * @function
+ * @param {Node} node - Represents the node to convert.
+ * @returns {ColorSpaceNode}
+ */
+export const toWorkingColorSpace = ( node ) => nodeObject( new ColorSpaceNode( nodeObject( node ), OUTPUT_COLOR_SPACE, WORKING_COLOR_SPACE ) );
+
+/**
+ * TSL function for converting a given color node from the current working color space to the given color space.
+ *
+ * @tsl
+ * @function
+ * @param {Node} node - Represents the node to convert.
+ * @param {string} colorSpace - The target color space.
+ * @returns {ColorSpaceNode}
+ */
+export const workingToColorSpace = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( nodeObject( node ), WORKING_COLOR_SPACE, colorSpace ) );
+
+/**
+ * TSL function for converting a given color node from the given color space to the current working color space.
+ *
+ * @tsl
+ * @function
+ * @param {Node} node - Represents the node to convert.
+ * @param {string} colorSpace - The source color space.
+ * @returns {ColorSpaceNode}
+ */
+export const colorSpaceToWorking = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( nodeObject( node ), colorSpace, WORKING_COLOR_SPACE ) );
+
+/**
+ * TSL function for converting a given color node from one color space to another one.
+ *
+ * @tsl
+ * @function
+ * @param {Node} node - Represents the node to convert.
+ * @param {string} sourceColorSpace - The source color space.
+ * @param {string} targetColorSpace - The target color space.
+ * @returns {ColorSpaceNode}
+ */
+export const convertColorSpace = ( node, sourceColorSpace, targetColorSpace ) => nodeObject( new ColorSpaceNode( nodeObject( node ), sourceColorSpace, targetColorSpace ) );
+
+addMethodChaining( 'toOutputColorSpace', toOutputColorSpace );
+addMethodChaining( 'toWorkingColorSpace', toWorkingColorSpace );
+
+addMethodChaining( 'workingToColorSpace', workingToColorSpace );
+addMethodChaining( 'colorSpaceToWorking', colorSpaceToWorking );

package/src/nodes/display/FrontFacingNode.js

@@ -1,14 +1,35 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeImmutable, float } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { nodeImmutable, float } from '../tsl/TSLBase.js';
 
 import { BackSide, WebGLCoordinateSystem } from '../../constants.js';
 
+/**
+ * This node can be used to evaluate whether a primitive is front or back facing.
+ *
+ * @augments Node
+ */
 class FrontFacingNode extends Node {
 
+	static get type() {
+
+		return 'FrontFacingNode';
+
+	}
+
+	/**
+	 * Constructs a new front facing node.
+	 */
 	constructor() {
 
 		super( 'bool' );
 
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
 		this.isFrontFacingNode = true;
 
 	}
@@ -35,7 +56,19 @@ class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-export const frontFacing = nodeImmutable( FrontFacingNode );
-export const faceDirection = float( frontFacing ).mul( 2.0 ).sub( 1.0 );
-
-addNodeClass( 'FrontFacingNode', FrontFacingNode );
+/**
+ * TSL object that represents whether a primitive is front or back facing
+ *
+ * @tsl
+ * @type {FrontFacingNode<bool>}
+ */
+export const frontFacing = /*@__PURE__*/ nodeImmutable( FrontFacingNode );
+
+/**
+ * TSL object that represents the front facing status as a number instead of a bool.
+ * `1` means front facing, `-1` means back facing.
+ *
+ * @tsl
+ * @type {Node<float>}
+ */
+export const faceDirection = /*@__PURE__*/ float( frontFacing ).mul( 2.0 ).sub( 1.0 );

package/src/nodes/display/NormalMapNode.js

@@ -1,21 +1,19 @@
 import TempNode from '../core/TempNode.js';
 import { add } from '../math/OperatorNode.js';
 
-import { modelNormalMatrix } from '../accessors/ModelNode.js';
-import { normalView } from '../accessors/NormalNode.js';
-import { positionView } from '../accessors/PositionNode.js';
+import { normalView, transformNormalToView } from '../accessors/Normal.js';
+import { positionView } from '../accessors/Position.js';
 import { TBNViewMatrix } from '../accessors/AccessorsUtils.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
 import { faceDirection } from './FrontFacingNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, Fn, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
+import { Fn, nodeProxy, vec3 } from '../tsl/TSLBase.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from '../../constants.js';
 
 // Normal Mapping Without Precomputed Tangents
 // http://www.thetenthplanet.de/archives/1180
 
-const perturbNormal2Arb = Fn( ( inputs ) => {
+const perturbNormal2Arb = /*@__PURE__*/ Fn( ( inputs ) => {
 
 	const { eye_pos, surf_norm, mapN, uv } = inputs;
 
@@ -39,15 +37,54 @@ const perturbNormal2Arb = Fn( ( inputs ) => {
 
 } );
 
+/**
+ * This class can be used for applying normals maps to materials.
+ *
+ * ```js
+ * material.normalNode = normalMap( texture( normalTex ) );
+ * ```
+ *
+ * @augments TempNode
+ */
 class NormalMapNode extends TempNode {
 
+	static get type() {
+
+		return 'NormalMapNode';
+
+	}
+
+	/**
+	 * Constructs a new normal map node.
+	 *
+	 * @param {Node<vec3>} node - Represents the normal map data.
+	 * @param {?Node<vec2>} [scaleNode=null] - Controls the intensity of the effect.
+	 */
 	constructor( node, scaleNode = null ) {
 
 		super( 'vec3' );
 
+		/**
+		 * Represents the normal map data.
+		 *
+		 * @type {Node<vec3>}
+		 */
 		this.node = node;
+
+		/**
+		 * Controls the intensity of the effect.
+		 *
+		 * @type {?Node<vec2>}
+		 * @default null
+		 */
 		this.scaleNode = scaleNode;
 
+		/**
+		 * The normal map type.
+		 *
+		 * @type {(TangentSpaceNormalMap|ObjectSpaceNormalMap)}
+		 * @default TangentSpaceNormalMap
+		 */
 		this.normalMapType = TangentSpaceNormalMap;
 
 	}
@@ -68,7 +105,7 @@ class NormalMapNode extends TempNode {
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
 
-			outputNode = modelNormalMatrix.mul( normalMap ).normalize();
+			outputNode = transformNormalToView( normalMap );
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
@@ -99,8 +136,13 @@ class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-export const normalMap = nodeProxy( NormalMapNode );
-
-addNodeElement( 'normalMap', normalMap );
-
-addNodeClass( 'NormalMapNode', NormalMapNode );
+/**
+ * TSL function for creating a normal map node.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} node - Represents the normal map data.
+ * @param {?Node<vec2>} [scaleNode=null] - Controls the intensity of the effect.
+ * @returns {NormalMapNode}
+ */
+export const normalMap = /*@__PURE__*/ nodeProxy( NormalMapNode );