super-three 0.147.0 → 0.152.0

package/examples/jsm/nodes/shadernode/ShaderNode.js

@@ -1,10 +1,21 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import ConvertNode from '../utils/ConvertNode.js';
 import JoinNode from '../utils/JoinNode.js';
 import SplitNode from '../utils/SplitNode.js';
 import ConstNode from '../core/ConstNode.js';
-import { getValueFromType } from '../core/NodeUtils.js';
+import { getValueFromType, getValueType } from '../core/NodeUtils.js';
+
+const NodeElements = new Map(); // @TODO: Currently only a few nodes are added, probably also add others
+
+export function addNodeElement( name, nodeElement ) {
+
+	if ( NodeElements.has( name ) ) throw new Error( `Redefinition of node element ${ name }` );
+	if ( typeof nodeElement !== 'function' ) throw new Error( `Node element ${ name } is not a function` );
+
+	NodeElements.set( name, nodeElement );
+
+}
 
 const shaderNodeHandler = {
 
@@ -16,11 +27,23 @@ const shaderNodeHandler = {
 
 	},
 
-	get: function ( node, prop ) {
+	get: function ( node, prop, nodeObj ) {
 
 		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
 
-			if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
+			if ( NodeElements.has( prop ) ) {
+
+				const nodeElement = NodeElements.get( prop );
+
+				return ( ...params ) => nodeElement( nodeObj, ...params );
+
+			} else if ( prop.endsWith( 'Assign' ) && NodeElements.has( prop.slice( 0, prop.length - 'Assign'.length ) ) ) {
+
+				const nodeElement = NodeElements.get( prop.slice( 0, prop.length - 'Assign'.length ) );
+
+				return ( ...params ) => nodeObj.assign( nodeElement( nodeObj, ...params ) );
+
+			} else if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
 
 				// accessing properties ( swizzle )
 
@@ -32,6 +55,12 @@ const shaderNodeHandler = {
 
 				return nodeObject( new SplitNode( node, prop ) );
 
+			} else if ( prop === 'width' || prop === 'height' ) {
+
+				// accessing property
+
+				return nodeObject( new SplitNode( node, prop === 'width' ? 'x' : 'y' ) );
+
 			} else if ( /^\d+$/.test( prop ) === true ) {
 
 				// accessing array
@@ -52,29 +81,29 @@ const nodeObjectsCacheMap = new WeakMap();
 
 const ShaderNodeObject = function ( obj ) {
 
-	const type = typeof obj;
+	const type = getValueType( obj );
 
-	if ( ( type === 'number' ) || ( type === 'boolean' ) ) {
+	if ( type === 'node' ) {
 
-		return nodeObject( getAutoTypedConstNode( obj ) );
+		let nodeObject = nodeObjectsCacheMap.get( obj );
 
-	} else if ( type === 'object' ) {
+		if ( nodeObject === undefined ) {
 
-		if ( obj?.isNode === true ) {
+			nodeObject = new Proxy( obj, shaderNodeHandler );
+			nodeObjectsCacheMap.set( obj, nodeObject );
+			nodeObjectsCacheMap.set( nodeObject, nodeObject );
 
-			let nodeObject = nodeObjectsCacheMap.get( obj );
+		}
 
-			if ( nodeObject === undefined ) {
+		return nodeObject;
 
-				nodeObject = new Proxy( obj, shaderNodeHandler );
-				nodeObjectsCacheMap.set( obj, nodeObject );
-				nodeObjectsCacheMap.set( nodeObject, nodeObject );
+	} else if ( ( type === 'float' ) || ( type === 'boolean' ) ) {
 
-			}
+		return nodeObject( getAutoTypedConstNode( obj ) );
 
-			return nodeObject;
+	} else if ( type && type !== 'string' ) {
 
-		}
+		return nodeObject( new ConstNode( obj ) );
 
 	}
 
@@ -158,43 +187,33 @@ class ShaderNodeInternal extends Node {
 
 	}
 
-	call( inputs, builder ) {
+	call( inputs, stack, builder ) {
 
 		inputs = nodeObjects( inputs );
 
-		return nodeObject( this._jsFunc( inputs, builder ) );
+		return nodeObject( this._jsFunc( inputs, stack, builder ) );
 
 	}
 
-	generate( builder, output ) {
-
-		const nodeCall = this.call( {}, builder );
+	getNodeType( builder ) {
 
-		if ( nodeCall === undefined ) {
-
-			return '';
-
-		}
+		const { outputNode } = builder.getNodeProperties( this );
 
-		return builder.format( nodeCall.build( builder ), nodeCall.getNodeType( builder ), output );
+		return outputNode ? outputNode.getNodeType( builder ) : super.getNodeType( builder );
 
 	}
 
-}
+	construct( builder ) {
 
-const ShaderNodeScript = function ( jsFunc ) {
+		builder.addStack();
 
-	return new ShaderNodeInternal( jsFunc );
+		builder.stack.outputNode = nodeObject( this._jsFunc( builder.stack, builder ) );
 
-};
+		return builder.removeStack();
 
-export const ShaderNode = new Proxy( ShaderNodeScript, shaderNodeHandler );
+	}
 
-export const nodeObject = ( val ) => /* new */ ShaderNodeObject( val );
-export const nodeObjects = ( val ) => new ShaderNodeObjects( val );
-export const nodeArray = ( val ) => new ShaderNodeArray( val );
-export const nodeProxy = ( ...val ) => new ShaderNodeProxy( ...val );
-export const nodeImmutable = ( ...val ) => new ShaderNodeImmutable( ...val );
+}
 
 const bools = [ false, true ];
 const uints = [ 0, 1, 2, 3 ];
@@ -214,7 +233,7 @@ const floatsCacheMap = new Map( [ ...intsCacheMap ].map( el => new ConstNode( el
 for ( const float of floats ) floatsCacheMap.set( float, new ConstNode( float ) );
 for ( const float of floats ) floatsCacheMap.set( - float, new ConstNode( - float ) );
 
-export const cacheMaps = { bool: boolsCacheMap, uint: uintsCacheMap, ints: intsCacheMap, float: floatsCacheMap };
+const cacheMaps = { bool: boolsCacheMap, uint: uintsCacheMap, ints: intsCacheMap, float: floatsCacheMap };
 
 const constNodesCacheMap = new Map( [ ...boolsCacheMap, ...floatsCacheMap ] );
 
@@ -236,7 +255,7 @@ const getAutoTypedConstNode = ( value ) => {
 
 };
 
-export const ConvertType = function ( type, cacheMap = null ) {
+const ConvertType = function ( type, cacheMap = null ) {
 
 	return ( ...params ) => {
 
@@ -262,7 +281,7 @@ export const ConvertType = function ( type, cacheMap = null ) {
 
 			if ( nodes.length === 1 ) {
 
-				return nodeObject( nodes[ 0 ].nodeType === type ? nodes[ 0 ] : new ConvertNode( nodes[ 0 ], type ) );
+				return nodeObject( nodes[ 0 ].nodeType === type || getValueType( nodes[ 0 ].value ) === type ? nodes[ 0 ] : new ConvertNode( nodes[ 0 ], type ) );
 
 			}
 
@@ -274,4 +293,101 @@ export const ConvertType = function ( type, cacheMap = null ) {
 
 };
 
-export const getConstNodeType = ( value ) => value.nodeType || value.convertTo || ( typeof value === 'string' ? value : null );
+// exports
+
+// utils
+
+export const getConstNodeType = ( value ) => ( value !== undefined && value !== null ) ? ( value.nodeType || value.convertTo || ( typeof value === 'string' ? value : null ) ) : null;
+
+// shader node base
+
+export function ShaderNode( jsFunc ) {
+
+	return new Proxy( new ShaderNodeInternal( jsFunc ), shaderNodeHandler );
+
+}
+
+export const nodeObject = ( val ) => /* new */ ShaderNodeObject( val );
+export const nodeObjects = ( val ) => new ShaderNodeObjects( val );
+export const nodeArray = ( val ) => new ShaderNodeArray( val );
+export const nodeProxy = ( ...val ) => new ShaderNodeProxy( ...val );
+export const nodeImmutable = ( ...val ) => new ShaderNodeImmutable( ...val );
+
+export const shader = ( ...val ) => new ShaderNode( ...val );
+
+addNodeClass( ShaderNode );
+
+// types
+// @TODO: Maybe export from ConstNode.js?
+
+export const color = new ConvertType( 'color' );
+
+export const float = new ConvertType( 'float', cacheMaps.float );
+export const int = new ConvertType( 'int', cacheMaps.int );
+export const uint = new ConvertType( 'uint', cacheMaps.uint );
+export const bool = new ConvertType( 'bool', cacheMaps.bool );
+
+export const vec2 = new ConvertType( 'vec2' );
+export const ivec2 = new ConvertType( 'ivec2' );
+export const uvec2 = new ConvertType( 'uvec2' );
+export const bvec2 = new ConvertType( 'bvec2' );
+
+export const vec3 = new ConvertType( 'vec3' );
+export const ivec3 = new ConvertType( 'ivec3' );
+export const uvec3 = new ConvertType( 'uvec3' );
+export const bvec3 = new ConvertType( 'bvec3' );
+
+export const vec4 = new ConvertType( 'vec4' );
+export const ivec4 = new ConvertType( 'ivec4' );
+export const uvec4 = new ConvertType( 'uvec4' );
+export const bvec4 = new ConvertType( 'bvec4' );
+
+export const mat3 = new ConvertType( 'mat3' );
+export const imat3 = new ConvertType( 'imat3' );
+export const umat3 = new ConvertType( 'umat3' );
+export const bmat3 = new ConvertType( 'bmat3' );
+
+export const mat4 = new ConvertType( 'mat4' );
+export const imat4 = new ConvertType( 'imat4' );
+export const umat4 = new ConvertType( 'umat4' );
+export const bmat4 = new ConvertType( 'bmat4' );
+
+export const string = ( value = '' ) => nodeObject( new ConstNode( value, 'string' ) );
+export const arrayBuffer = ( value ) => nodeObject( new ConstNode( value, 'ArrayBuffer' ) );
+
+addNodeElement( 'color', color );
+addNodeElement( 'float', float );
+addNodeElement( 'int', int );
+addNodeElement( 'uint', uint );
+addNodeElement( 'bool', bool );
+addNodeElement( 'vec2', vec2 );
+addNodeElement( 'ivec2', ivec2 );
+addNodeElement( 'uvec2', uvec2 );
+addNodeElement( 'bvec2', bvec2 );
+addNodeElement( 'vec3', vec3 );
+addNodeElement( 'ivec3', ivec3 );
+addNodeElement( 'uvec3', uvec3 );
+addNodeElement( 'bvec3', bvec3 );
+addNodeElement( 'vec4', vec4 );
+addNodeElement( 'ivec4', ivec4 );
+addNodeElement( 'uvec4', uvec4 );
+addNodeElement( 'bvec4', bvec4 );
+addNodeElement( 'mat3', mat3 );
+addNodeElement( 'imat3', imat3 );
+addNodeElement( 'umat3', umat3 );
+addNodeElement( 'bmat3', bmat3 );
+addNodeElement( 'mat4', mat4 );
+addNodeElement( 'imat4', imat4 );
+addNodeElement( 'umat4', umat4 );
+addNodeElement( 'bmat4', bmat4 );
+addNodeElement( 'string', string );
+addNodeElement( 'arrayBuffer', arrayBuffer );
+
+// basic nodes
+// HACK - we cannot export them from the corresponding files because of the cyclic dependency
+export const element = nodeProxy( ArrayElementNode );
+export const convert = ( node, types ) => nodeObject( new ConvertNode( nodeObject( node ), types ) );
+export const split = ( node, channels ) => nodeObject( new SplitNode( nodeObject( node ), channels ) );
+
+addNodeElement( 'element', element );
+addNodeElement( 'convert', convert );

package/examples/jsm/nodes/utils/ArrayElementNode.js

@@ -1,6 +1,6 @@
-import TempNode from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 
-class ArrayElementNode extends TempNode {
+class ArrayElementNode extends Node { // @TODO: If extending from TempNode it breaks webgpu_compute
 
 	constructor( node, indexNode ) {
 
@@ -29,3 +29,5 @@ class ArrayElementNode extends TempNode {
 }
 
 export default ArrayElementNode;
+
+addNodeClass( ArrayElementNode );

package/examples/jsm/nodes/utils/ConvertNode.js

@@ -1,4 +1,4 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 
 class ConvertNode extends Node {
 
@@ -31,6 +31,22 @@ class ConvertNode extends Node {
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.convertTo = this.convertTo;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.convertTo = data.convertTo;
+
+	}
+
 	generate( builder, output ) {
 
 		const node = this.node;
@@ -45,3 +61,5 @@ class ConvertNode extends Node {
 }
 
 export default ConvertNode;
+
+addNodeClass( ConvertNode );

package/examples/jsm/nodes/utils/DiscardNode.js

@@ -0,0 +1,26 @@
+import CondNode from '../math/CondNode.js';
+import { expression } from '../code/ExpressionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+let discardExpression;
+
+class DiscardNode extends CondNode {
+
+	constructor( condNode ) {
+
+		discardExpression = discardExpression || expression( 'discard' );
+
+		super( condNode, discardExpression );
+
+	}
+
+}
+
+export default DiscardNode;
+
+export const discard = nodeProxy( DiscardNode );
+
+addNodeElement( 'discard', discard );
+
+addNodeClass( DiscardNode );

package/examples/jsm/nodes/utils/EquirectUVNode.js

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, vec2, add, mul, atan2, asin, clamp, positionWorldDirection } from '../shadernode/ShaderNodeElements.js';
+import { negate } from '../math/MathNode.js';
+import { positionWorldDirection } from '../accessors/PositionNode.js';
+import { nodeProxy, vec2 } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class EquirectUVNode extends TempNode {
 
@@ -13,10 +16,10 @@ class EquirectUVNode extends TempNode {
 
 	construct() {
 
-		const dir = nodeObject( this.dirNode );
+		const dir = negate( this.dirNode );
 
-		const u = add( mul( atan2( dir.z, dir.x ), 1 / ( Math.PI * 2 ) ), 0.5 );
-		const v = add( mul( asin( clamp( dir.y, - 1.0, 1.0 ) ), 1 / Math.PI ), 0.5 );
+		const u = dir.z.atan2( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
+		const v = dir.y.clamp( - 1.0, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 );
 
 		return vec2( u, v );
 
@@ -25,3 +28,7 @@ class EquirectUVNode extends TempNode {
 }
 
 export default EquirectUVNode;
+
+export const equirectUV = nodeProxy( EquirectUVNode );
+
+addNodeClass( EquirectUVNode );

package/examples/jsm/nodes/utils/JoinNode.js

@@ -1,4 +1,5 @@
-import TempNode from '../core/Node.js';
+import { addNodeClass } from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
 
 class JoinNode extends TempNode {
 
@@ -46,3 +47,5 @@ class JoinNode extends TempNode {
 }
 
 export default JoinNode;
+
+addNodeClass( JoinNode );

package/examples/jsm/nodes/utils/MatcapUVNode.js

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
-import { vec2, vec3, negate, normalize, cross, dot, mul, add, transformedNormalView, positionViewDirection } from '../shadernode/ShaderNodeBaseElements.js';
+import { transformedNormalView } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { nodeImmutable, vec2, vec3 } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class MatcapUVNode extends TempNode {
 
@@ -11,13 +14,17 @@ class MatcapUVNode extends TempNode {
 
 	construct() {
 
-		const x = normalize( vec3( positionViewDirection.z, 0, negate( positionViewDirection.x ) ) );
-		const y = cross( positionViewDirection, x );
+		const x = vec3( positionViewDirection.z, 0, positionViewDirection.x.negate() ).normalize();
+		const y = positionViewDirection.cross( x );
 
-		return add( mul( vec2( dot( x, transformedNormalView ), dot( y, transformedNormalView ) ), 0.495 ), 0.5 );
+		return vec2( x.dot( transformedNormalView ), y.dot( transformedNormalView ) ).mul( 0.495 ).add( 0.5 );
 
 	}
 
 }
 
 export default MatcapUVNode;
+
+export const matcapUV = nodeImmutable( MatcapUVNode );
+
+addNodeClass( MatcapUVNode );

package/examples/jsm/nodes/utils/MaxMipLevelNode.js

@@ -1,24 +1,33 @@
 import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class MaxMipLevelNode extends UniformNode {
 
-	constructor( texture ) {
+	constructor( textureNode ) {
 
 		super( 0 );
 
-		this.texture = texture;
+		this.textureNode = textureNode;
 
 		this.updateType = NodeUpdateType.FRAME;
 
 	}
 
+	get texture() {
+
+		return this.textureNode.value;
+
+	}
+
 	update() {
 
-		const images = this.texture.images;
-		const image = ( images && images.length > 0 ) ? ( images[ 0 ]?.image || images[ 0 ] ) : this.texture.image;
+		const texture = this.texture;
+		const images = texture.images;
+		const image = ( images && images.length > 0 ) ? ( ( images[ 0 ] && images[ 0 ].image ) || images[ 0 ] ) : texture.image;
 
-		if ( image?.width !== undefined ) {
+		if ( image && image.width !== undefined ) {
 
 			const { width, height } = image;
 
@@ -31,3 +40,7 @@ class MaxMipLevelNode extends UniformNode {
 }
 
 export default MaxMipLevelNode;
+
+export const maxMipLevel = nodeProxy( MaxMipLevelNode );
+
+addNodeClass( MaxMipLevelNode );

package/examples/jsm/nodes/utils/OscNode.js

@@ -1,15 +1,10 @@
-import Node from '../core/Node.js';
-import TimerNode from './TimerNode.js';
-import { abs, fract, round, sin, add, sub, mul } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { timerLocal } from './TimerNode.js';
+import { nodeObject, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class OscNode extends Node {
 
-	static SINE = 'sine';
-	static SQUARE = 'square';
-	static TRIANGLE = 'triangle';
-	static SAWTOOTH = 'sawtooth';
-
-	constructor( method = OscNode.SINE, timeNode = new TimerNode() ) {
+	constructor( method = OscNode.SINE, timeNode = timerLocal() ) {
 
 		super();
 
@@ -27,25 +22,25 @@ class OscNode extends Node {
 	construct() {
 
 		const method = this.method;
-		const timeNode = this.timeNode;
+		const timeNode = nodeObject( this.timeNode );
 
 		let outputNode = null;
 
 		if ( method === OscNode.SINE ) {
 
-			outputNode = add( mul( sin( mul( add( timeNode, .75 ), Math.PI * 2 ) ), .5 ), .5 );
+			outputNode = timeNode.add( 0.75 ).mul( Math.PI * 2 ).sin().mul( 0.5 ).add( 0.5 );
 
 		} else if ( method === OscNode.SQUARE ) {
 
-			outputNode = round( fract( timeNode ) );
+			outputNode = timeNode.fract().round();
 
 		} else if ( method === OscNode.TRIANGLE ) {
 
-			outputNode = abs( sub( 1, mul( fract( add( timeNode, .5 ) ), 2 ) ) );
+			outputNode = timeNode.add( 0.5 ).fract().mul( 2 ).sub( 1 ).abs();
 
 		} else if ( method === OscNode.SAWTOOTH ) {
 
-			outputNode = fract( timeNode );
+			outputNode = timeNode.fract();
 
 		}
 
@@ -71,4 +66,16 @@ class OscNode extends Node {
 
 }
 
+OscNode.SINE = 'sine';
+OscNode.SQUARE = 'square';
+OscNode.TRIANGLE = 'triangle';
+OscNode.SAWTOOTH = 'sawtooth';
+
 export default OscNode;
+
+export const oscSine = nodeProxy( OscNode, OscNode.SINE );
+export const oscSquare = nodeProxy( OscNode, OscNode.SQUARE );
+export const oscTriangle = nodeProxy( OscNode, OscNode.TRIANGLE );
+export const oscSawtooth = nodeProxy( OscNode, OscNode.SAWTOOTH );
+
+addNodeClass( OscNode );

package/examples/jsm/nodes/utils/PackingNode.js

@@ -0,0 +1,55 @@
+import TempNode from '../core/TempNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+class PackingNode extends TempNode {
+
+	constructor( scope, node ) {
+
+		super();
+
+		this.scope = scope;
+		this.node = node;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	construct() {
+
+		const { scope, node } = this;
+
+		let result = null;
+
+		if ( scope === PackingNode.DIRECTION_TO_COLOR ) {
+
+			result = node.mul( 0.5 ).add( 0.5 );
+
+		} else if ( scope === PackingNode.COLOR_TO_DIRECTION ) {
+
+			result = node.mul( 2.0 ).sub( 1 );
+
+		}
+
+		return result;
+
+	}
+
+}
+
+PackingNode.DIRECTION_TO_COLOR = 'directionToColor';
+PackingNode.COLOR_TO_DIRECTION = 'colorToDirection';
+
+export default PackingNode;
+
+export const directionToColor = nodeProxy( PackingNode, PackingNode.DIRECTION_TO_COLOR );
+export const colorToDirection = nodeProxy( PackingNode, PackingNode.COLOR_TO_DIRECTION );
+
+addNodeElement( 'directionToColor', directionToColor );
+addNodeElement( 'colorToDirection', colorToDirection );
+
+addNodeClass( PackingNode );

package/examples/jsm/nodes/utils/RemapNode.js

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { add, sub, div, mul, clamp } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class RemapNode extends Node {
 
@@ -21,14 +21,22 @@ class RemapNode extends Node {
 
 		const { node, inLowNode, inHighNode, outLowNode, outHighNode, doClamp } = this;
 
-		let t = div( sub( node, inLowNode ), sub( inHighNode, inLowNode ) );
+		let t = node.sub( inLowNode ).div( inHighNode.sub( inLowNode ) );
 
-		if ( doClamp === true ) t = clamp( t );
+		if ( doClamp === true ) t = t.clamp();
 
-		return add( mul( sub( outHighNode, outLowNode ), t ), outLowNode );
+		return t.mul( outHighNode.sub( outLowNode ) ).add( outLowNode );
 
 	}
 
 }
 
 export default RemapNode;
+
+export const remap = nodeProxy( RemapNode, null, null, { doClamp: false } );
+export const remapClamp = nodeProxy( RemapNode );
+
+addNodeElement( 'remap', remap );
+addNodeElement( 'remapClamp', remapClamp );
+
+addNodeClass( RemapNode );