add overrideNode

Author: sunag

src/Three.TSL.js

@@ -417,6 +417,7 @@ export const output = TSL.output;
 export const outputStruct = TSL.outputStruct;
 export const overlay = TSL.overlay;
 export const overloadingFn = TSL.overloadingFn;
+export const overrideNode = TSL.overrideNode;
 export const parabola = TSL.parabola;
 export const parallaxDirection = TSL.parallaxDirection;
 export const parallaxUV = TSL.parallaxUV;

src/nodes/Nodes.js

@@ -9,6 +9,7 @@ export { default as BypassNode } from './core/BypassNode.js';
 export { default as IsolateNode } from './core/IsolateNode.js';
 export { default as ConstNode } from './core/ConstNode.js';
 export { default as ContextNode } from './core/ContextNode.js';
+export { default as OverrideContextNode } from './core/OverrideContextNode.js';
 export { default as IndexNode } from './core/IndexNode.js';
 export { default as LightingModel } from './core/LightingModel.js';
 export { default as Node } from './core/Node.js';

src/nodes/TSL.js

@@ -7,6 +7,7 @@ export * from './core/AttributeNode.js';
 export * from './core/BypassNode.js';
 export * from './core/IsolateNode.js';
 export * from './core/ContextNode.js';
+export * from './core/OverrideContextNode.js';
 export * from './core/IndexNode.js';
 export * from './core/ParameterNode.js';
 export * from './core/PropertyNode.js';

src/nodes/core/Node.js

@@ -554,7 +554,43 @@ class Node extends EventDispatcher {
 		const hash = this.getHash( builder );
 		const nodeFromHash = builder.getNodeFromHash( hash );
 
-		return nodeFromHash || this;
+		let sharedNode = null;
+
+		if ( nodeFromHash && nodeFromHash !== this ) {
+
+			sharedNode = nodeFromHash;
+
+		} else if ( builder.context.overrideNodes ) {
+
+			const callback = builder.context.overrideNodes.get( this );
+
+			if ( callback ) {
+
+				const nodeData = builder.getDataFromNode( this );
+
+				if ( nodeData.isOverwritten !== true ) {
+
+					nodeData.isOverwritten = true;
+
+					// cancel the override for use the same node inside the callback
+
+					sharedNode = callback().overrideNode( this, null );
+
+					nodeData.sharedNode = sharedNode;
+
+				} else {
+
+					// avoid recursive override calls
+
+					sharedNode = nodeData.sharedNode;
+
+				}
+
+			}
+
+		}
+
+		return sharedNode || this;
 
 	}
 

src/nodes/core/OverrideContextNode.js

@@ -0,0 +1,94 @@
+import ContextNode from './ContextNode.js';
+import { addMethodChaining } from '../tsl/TSLCore.js';
+
+/**
+ * A context node that overrides a target node within a callback function.
+ *
+ * @augments ContextNode
+ */
+class OverrideContextNode extends ContextNode {
+
+	static get type() {
+
+		return 'OverrideContextNode';
+
+	}
+
+	constructor( targetNode, callback, flowNode = null ) {
+
+		super( flowNode, {
+			overrideNodes: new Map( [[ targetNode, callback ]] )
+		} );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isOverrideContextNode = true;
+
+		/**
+		 * A reference to the target node to override.
+		 *
+		 * @type {Node}
+		 */
+		this.targetNode = targetNode;
+
+		/**
+		 * A callback function that returns the overriding node.
+		 *
+		 * @type {Function}
+		 */
+		this.callback = callback;
+
+	}
+
+	/**
+	 * Gathers the context data from all parent context nodes.
+	 *
+	 * @return {Object} The gathered context data.
+	 */
+	getFlowContextData() {
+
+		const children = [];
+
+		this.traverse( ( node ) => {
+
+			if ( node.isOverrideContextNode === true ) {
+
+				children.push( node.value.overrideNodes );
+
+			}
+
+		} );
+
+		const overrideNodes = new Map( children.flatMap( ( map ) => Array.from( map.entries() ) ) );
+
+		const data = super.getFlowContextData();
+		data.overrideNodes = overrideNodes;
+
+		return data;
+
+	}
+
+}
+
+export default OverrideContextNode;
+
+/**
+ * Creates an OverrideContextNode that overrides a target node within a callback function.
+ *
+ * @param {Node} targetNode - The target node to override.
+ * @param {Function} callback - A callback function that returns the overriding node.
+ * @param {Node} [flowNode=null] - An optional flow node.
+ * @return {OverrideContextNode} The created OverrideContextNode.
+ */
+export function overrideNode( targetNode, callback, flowNode = null ) {
+
+	return new OverrideContextNode( targetNode, callback, flowNode );
+
+}
+
+addMethodChaining( 'overrideNode', ( flowNode, node, callback ) => overrideNode( node, callback, flowNode ) );