@unikia/upe-renderer 0.186.110 → 0.187.11

package/src/nodes/math/BitcastNode.js

@@ -1,12 +1,12 @@
-import TempNode from '../core/TempNode.js';
-import { nodeProxyIntent } from '../tsl/TSLCore.js';
+import Node from '../core/Node.js';
+import { nodeProxyAssignable } from '../tsl/TSLCore.js';
 /**
  * This node represents an operation that reinterprets the bit representation of a value
  * in one type as a value in another type.
  *
- * @augments TempNode
+ * @augments Node
  */
-class BitcastNode extends TempNode {
+class BitcastNode extends Node {
 
 	static get type() {
 
@@ -113,7 +113,7 @@ export default BitcastNode;
  * @param {string} y - The new type.
  * @returns {Node}
  */
-export const bitcast = /*@__PURE__*/ nodeProxyIntent( BitcastNode ).setParameterLength( 2 );
+export const bitcast = /*@__PURE__*/ nodeProxyAssignable( BitcastNode ).setParameterLength( 2 );
 
 /**
  * Bitcasts a float or a vector of floats to a corresponding integer type with the same element size.

package/src/nodes/math/BitcountNode.js

@@ -1,4 +1,4 @@
-import { float, Fn, If, nodeProxyIntent, uint, int, uvec2, uvec3, uvec4, ivec2, ivec3, ivec4 } from '../tsl/TSLCore.js';
+import { float, Fn, If, nodeProxyAssignable, uint, int, uvec2, uvec3, uvec4, ivec2, ivec3, ivec4 } from '../tsl/TSLCore.js';
 import { bitcast, floatBitsToUint } from './BitcastNode.js';
 import MathNode, { negate } from './MathNode.js';
 
@@ -120,11 +120,10 @@ class BitcountNode extends MathNode {
 	 * Creates and registers a reusable GLSL function that emulates the behavior of countTrailingZeros.
 	 *
 	 * @private
-	 * @param {string} method - The name of the function to create.
 	 * @param {string} elementType - The type of the input value.
 	 * @returns {Function} - The generated function
 	 */
-	_createTrailingZerosBaseLayout( method, elementType ) {
+	_createTrailingZerosBaseLayout( elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
 
@@ -132,7 +131,7 @@ class BitcountNode extends MathNode {
 
 			If( value.equal( uint( 0 ) ), () => {
 
-				return uint( 32 );
+				return outputConvertNode( 32 );
 
 			} );
 
@@ -147,13 +146,7 @@ class BitcountNode extends MathNode {
 
 			return outputConvertNode( numTrailingZeros );
 
-		} ).setLayout( {
-			name: method,
-			type: elementType,
-			inputs: [
-				{ name: 'value', type: elementType }
-			]
-		} );
+		}, { value: elementType, return: elementType } );
 
 		return fnDef;
 
@@ -163,11 +156,10 @@ class BitcountNode extends MathNode {
 	 * Creates and registers a reusable GLSL function that emulates the behavior of countLeadingZeros.
 	 *
 	 * @private
-	 * @param {string} method - The name of the function to create.
 	 * @param {string} elementType - The type of the input value.
 	 * @returns {Function} - The generated function
 	 */
-	_createLeadingZerosBaseLayout( method, elementType ) {
+	_createLeadingZerosBaseLayout( elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
 
@@ -175,7 +167,7 @@ class BitcountNode extends MathNode {
 
 			If( value.equal( uint( 0 ) ), () => {
 
-				return uint( 32 );
+				return outputConvertNode( 32 );
 
 			} );
 
@@ -219,13 +211,7 @@ class BitcountNode extends MathNode {
 
 			return outputConvertNode( n );
 
-		} ).setLayout( {
-			name: method,
-			type: elementType,
-			inputs: [
-				{ name: 'value', type: elementType }
-			]
-		} );
+		}, { value: elementType, return: elementType } );
 
 		return fnDef;
 
@@ -235,11 +221,10 @@ class BitcountNode extends MathNode {
 	 * Creates and registers a reusable GLSL function that emulates the behavior of countOneBits.
 	 *
 	 * @private
-	 * @param {string} method - The name of the function to create.
 	 * @param {string} elementType - The type of the input value.
 	 * @returns {Function} - The generated function
 	 */
-	_createOneBitsBaseLayout( method, elementType ) {
+	_createOneBitsBaseLayout( elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
 
@@ -256,13 +241,7 @@ class BitcountNode extends MathNode {
 
 			return outputConvertNode( numBits );
 
-		} ).setLayout( {
-			name: method,
-			type: elementType,
-			inputs: [
-				{ name: 'value', type: elementType }
-			]
-		} );
+		}, { value: elementType, return: elementType } );
 
 		return fnDef;
 
@@ -273,13 +252,12 @@ class BitcountNode extends MathNode {
 	 * including considerations for component-wise bitcounts on vector type inputs.
 	 *
 	 * @private
-	 * @param {string} method - The name of the function to create.
 	 * @param {string} inputType - The type of the input value.
 	 * @param {number} typeLength - The vec length of the input value.
 	 * @param {Function} baseFn - The base function that operates on an individual component of the vector.
 	 * @returns {Function} - The alias function for the specified bitcount method.
 	 */
-	_createMainLayout( method, inputType, typeLength, baseFn ) {
+	_createMainLayout( inputType, typeLength, baseFn ) {
 
 		const outputConvertNode = this._returnDataNode( inputType );
 
@@ -306,13 +284,7 @@ class BitcountNode extends MathNode {
 
 			}
 
-		} ).setLayout( {
-			name: method,
-			type: inputType,
-			inputs: [
-				{ name: 'value', type: inputType }
-			]
-		} );
+		}, { value: inputType, return: inputType } );
 
 		return fnDef;
 
@@ -348,21 +320,21 @@ class BitcountNode extends MathNode {
 
 				case BitcountNode.COUNT_LEADING_ZEROS: {
 
-					baseFn = this._createLeadingZerosBaseLayout( baseMethod, elementType );
+					baseFn = this._createLeadingZerosBaseLayout( elementType );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_TRAILING_ZEROS: {
 
-					baseFn = this._createTrailingZerosBaseLayout( baseMethod, elementType );
+					baseFn = this._createTrailingZerosBaseLayout( elementType );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_ONE_BITS: {
 
-					baseFn = this._createOneBitsBaseLayout( baseMethod, elementType );
+					baseFn = this._createOneBitsBaseLayout( elementType );
 					break;
 
 				}
@@ -377,7 +349,7 @@ class BitcountNode extends MathNode {
 
 		if ( fn === undefined ) {
 
-			fn = this._createMainLayout( newMethod, inputType, typeLength, baseFn );
+			fn = this._createMainLayout( inputType, typeLength, baseFn );
 			registeredBitcountFunctions[ newMethod ] = fn;
 
 		}
@@ -427,7 +399,7 @@ export default BitcountNode;
  * @param {Node | number} x - The input value.
  * @returns {Node}
  */
-export const countTrailingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_TRAILING_ZEROS ).setParameterLength( 1 );
+export const countTrailingZeros = /*@__PURE__*/ nodeProxyAssignable( BitcountNode, BitcountNode.COUNT_TRAILING_ZEROS ).setParameterLength( 1 );
 
 /**
  * Finds the number of consecutive 0 bits starting from the most significant bit of the input value.
@@ -439,7 +411,7 @@ export const countTrailingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, B
  * @param {Node | number} x - The input value.
  * @returns {Node}
  */
-export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_LEADING_ZEROS ).setParameterLength( 1 );
+export const countLeadingZeros = /*@__PURE__*/ nodeProxyAssignable( BitcountNode, BitcountNode.COUNT_LEADING_ZEROS ).setParameterLength( 1 );
 
 /**
  * Finds the number of '1' bits set in the input value
@@ -450,4 +422,4 @@ export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, Bi
  * @function
  * @returns {Node}
  */
-export const countOneBits = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_ONE_BITS ).setParameterLength( 1 );
+export const countOneBits = /*@__PURE__*/ nodeProxyAssignable( BitcountNode, BitcountNode.COUNT_ONE_BITS ).setParameterLength( 1 );

package/src/nodes/math/ConditionalNode.js

@@ -2,6 +2,7 @@ import Node from '../core/Node.js';
 import { property } from '../core/PropertyNode.js';
 import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 import { warn } from '../../utils.js';
+import NodeError from '../core/NodeError.js';
 
 /**
  * Represents a logical `if/else` statement. Can be used as an alternative
@@ -14,6 +15,19 @@ import { warn } from '../../utils.js';
  * velocity = position.greaterThanEqual( limit ).select( velocity.negate(), velocity );
  * ```
  *
+ * When the condition is itself a vector (e.g. the `bvec4` produced by
+ * `someVec4.greaterThanEqual( someOtherVec4 )`), `select()` resolves
+ * per-component - each output lane picks independently based on its own
+ * condition component, the same way WGSL's native `select()` and GLSL's
+ * `mix( x, y, bvecN )` do - rather than picking one branch for the whole
+ * vector. The condition and values are converted to the largest vector width,
+ * with the condition converted to boolean components. Scalar values are broadcast.
+ *
+ * ```js
+ * // per-component: each channel picks independently
+ * const clamped = value.greaterThan( vec3( 1.0 ) ).select( vec3( 1.0 ), value );
+ * ```
+ *
  * @augments Node
  */
 class ConditionalNode extends Node {
@@ -59,6 +73,12 @@ class ConditionalNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	/**
 	 * This method is overwritten since the node type is inferred from the if/else
 	 * nodes.
@@ -68,7 +88,7 @@ class ConditionalNode extends Node {
 	 */
 	generateNodeType( builder ) {
 
-		const { ifNode, elseNode } = builder.getNodeProperties( this );
+		const { condNode, ifNode, elseNode } = builder.getNodeProperties( this );
 
 		if ( ifNode === undefined ) {
 
@@ -80,45 +100,40 @@ class ConditionalNode extends Node {
 
 		}
 
-		const ifType = ifNode.getNodeType( builder );
+		let type = ifNode.getNodeType( builder );
 
 		if ( elseNode !== null ) {
 
 			const elseType = elseNode.getNodeType( builder );
 
-			if ( builder.getTypeLength( elseType ) > builder.getTypeLength( ifType ) ) {
+			if ( builder.getTypeLength( elseType ) > builder.getTypeLength( type ) ) {
 
-				return elseType;
+				type = elseType;
 
 			}
 
 		}
 
-		return ifType;
+		const condLength = builder.getTypeLength( condNode.getNodeType( builder ) );
 
-	}
-
-	setup( builder ) {
+		if ( condLength > 1 && ! builder.isReference( type ) && ( builder.getTypeLength( type ) === 1 || builder.isVector( builder.getVectorType( type ) ) ) ) {
 
-		const condNode = this.condNode;
-		const ifNode = this.ifNode.isolate();
-		const elseNode = this.elseNode ? this.elseNode.isolate() : null;
+			type = builder.getTypeFromLength( Math.max( condLength, builder.getTypeLength( type ) ), builder.getComponentType( type ) );
 
-		//
+		}
 
-		const currentNodeBlock = builder.context.nodeBlock;
+		return type;
 
-		builder.getDataFromNode( ifNode ).parentNodeBlock = currentNodeBlock;
-		if ( elseNode !== null ) builder.getDataFromNode( elseNode ).parentNodeBlock = currentNodeBlock;
+	}
 
-		//
+	setup( builder ) {
 
-		const isUniformFlow = builder.context.uniformFlow;
+		const { condNode, ifNode, elseNode } = this;
 
 		const properties = builder.getNodeProperties( this );
 		properties.condNode = condNode;
-		properties.ifNode = isUniformFlow ? ifNode : ifNode.context( { nodeBlock: ifNode } );
-		properties.elseNode = elseNode ? ( isUniformFlow ? elseNode : elseNode.context( { nodeBlock: elseNode } ) ) : null;
+		properties.ifNode = ifNode;
+		properties.elseNode = elseNode;
 
 	}
 
@@ -128,9 +143,9 @@ class ConditionalNode extends Node {
 
 		const nodeData = builder.getDataFromNode( this );
 
-		if ( nodeData.nodeProperty !== undefined ) {
+		if ( nodeData.propertyName !== undefined ) {
 
-			return nodeData.nodeProperty;
+			return builder.format( nodeData.propertyName, type, output );
 
 		}
 
@@ -140,7 +155,48 @@ class ConditionalNode extends Node {
 		const needsOutput = output !== 'void';
 		const nodeProperty = needsOutput ? property( type ).build( builder ) : '';
 
-		nodeData.nodeProperty = nodeProperty;
+		nodeData.propertyName = nodeProperty;
+
+		// A vector condition selects per-component - see getVectorSelect().
+		const condType = condNode.getNodeType( builder );
+		const condLength = builder.getTypeLength( condType );
+
+		if ( condLength > 1 ) {
+
+			const vectorType = builder.getVectorType( type );
+
+			if ( builder.isReference( type ) || ! builder.isVector( vectorType ) ) {
+
+				throw new NodeError( `TSL: select() with a vector condition ("${ condType }") requires scalar or vector values, received "${ type }".`, this.stackTrace );
+
+			}
+
+			// No "else": unselected lanes fall back to the type's zero value.
+			let elseSnippet;
+
+			if ( elseNode !== null ) {
+
+				elseSnippet = elseNode.build( builder, type );
+
+			} else {
+
+				elseSnippet = builder.generateConst( type );
+
+			}
+
+			const boolType = builder.changeComponentType( type, 'bool' );
+			const condSnippet = condNode.build( builder, boolType );
+			const ifSnippet = ifNode.build( builder, type );
+
+			const mathSnippet = builder.getVectorSelect( condSnippet, ifSnippet, elseSnippet, type );
+
+			if ( ! needsOutput ) return '';
+
+			builder.addFlowCode( `\n${ builder.tab }${ nodeProperty } = ${ mathSnippet };\n\n` );
+
+			return builder.format( nodeProperty, type, output );
+
+		}
 
 		const nodeSnippet = condNode.build( builder, 'bool' );
 		const isUniformFlow = builder.context.uniformFlow;
@@ -160,8 +216,18 @@ class ConditionalNode extends Node {
 
 		builder.addFlowCode( `\n${ builder.tab }if ( ${ nodeSnippet } ) {\n\n` ).addFlowTab();
 
+		// An immutable condition, i.e. a constant, is the guard of the blocks: blocks of the same parent and guard run together.
+		const condData = builder.getDataFromNode( condNode );
+		const guard = condData.propertyName === nodeSnippet && condData.assign !== true ? nodeSnippet : undefined;
+
+		const flowBlock = builder.flowBlock;
+
+		builder.flowBlock = { parent: flowBlock, guard };
+
 		let ifSnippet = ifNode.build( builder, type );
 
+		builder.flowBlock = flowBlock;
+
 		if ( ifSnippet ) {
 
 			if ( needsOutput ) {
@@ -190,8 +256,12 @@ class ConditionalNode extends Node {
 
 			builder.addFlowCode( ' else {\n\n' ).addFlowTab();
 
+			builder.flowBlock = { parent: flowBlock, guard: guard !== undefined ? '!' + guard : undefined };
+
 			let elseSnippet = elseNode.build( builder, type );
 
+			builder.flowBlock = flowBlock;
+
 			if ( elseSnippet ) {
 
 				if ( needsOutput ) {

package/src/nodes/math/Hash.js

@@ -18,4 +18,4 @@ export const hash = /*@__PURE__*/ Fn( ( [ seed ] ) => {
 
 	return result.toFloat().mul( 1 / 2 ** 32 ); // Convert to range [0, 1)
 
-} );
+}, { seed: 'uint', return: 'float' } );