super-three 0.144.0 → 0.147.1

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

@@ -14,6 +14,7 @@ import VarNode from '../core/VarNode.js';
 import VaryingNode from '../core/VaryingNode.js';
 
 // accessors
+import BitangentNode from '../accessors/BitangentNode.js';
 import BufferNode from '../accessors/BufferNode.js';
 import CameraNode from '../accessors/CameraNode.js';
 import MaterialNode from '../accessors/MaterialNode.js';
@@ -25,6 +26,7 @@ import PointUVNode from '../accessors/PointUVNode.js';
 import PositionNode from '../accessors/PositionNode.js';
 import ReferenceNode from '../accessors/ReferenceNode.js';
 import StorageBufferNode from '../accessors/StorageBufferNode.js';
+import TangentNode from '../accessors/TangentNode.js';
 import TextureNode from '../accessors/TextureNode.js';
 import UserDataNode from '../accessors/UserDataNode.js';
 import UVNode from '../accessors/UVNode.js';
@@ -114,6 +116,8 @@ export const fn = ( code, includes ) => func( code, includes ).call;
 export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
 export const property = ( name, nodeOrType ) => nodeObject( new PropertyNode( name, getConstNodeType( nodeOrType ) ) );
 
+export const convert = ( node, types ) => nodeObject( new ConvertNode( nodeObject( node ), types ) );
+
 export const bypass = nodeProxy( BypassNode );
 export const code = nodeProxy( CodeNode );
 export const context = nodeProxy( ContextNode );
@@ -124,65 +128,6 @@ export const label = nodeProxy( VarNode );
 export const temp = label;
 export const varying = nodeProxy( VaryingNode );
 
-// accesors
-
-export const buffer = ( value, nodeOrType, count ) => nodeObject( new BufferNode( value, getConstNodeType( nodeOrType ), count ) );
-export const storage = ( value, nodeOrType, count ) => nodeObject( new StorageBufferNode( value, getConstNodeType( nodeOrType ), count ) );
-
-export const cameraProjectionMatrix = nodeImmutable( CameraNode, CameraNode.PROJECTION_MATRIX );
-export const cameraViewMatrix = nodeImmutable( CameraNode, CameraNode.VIEW_MATRIX );
-export const cameraNormalMatrix = nodeImmutable( CameraNode, CameraNode.NORMAL_MATRIX );
-export const cameraWorldMatrix = nodeImmutable( CameraNode, CameraNode.WORLD_MATRIX );
-export const cameraPosition = nodeImmutable( CameraNode, CameraNode.POSITION );
-
-export const materialAlphaTest = nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
-export const materialColor = nodeImmutable( MaterialNode, MaterialNode.COLOR );
-export const materialEmissive = nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
-export const materialOpacity = nodeImmutable( MaterialNode, MaterialNode.OPACITY );
-//export const materialSpecular = nodeImmutable( MaterialNode, MaterialNode.SPECULAR );
-export const materialRoughness = nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
-export const materialMetalness = nodeImmutable( MaterialNode, MaterialNode.METALNESS );
-export const materialRotation = nodeImmutable( MaterialNode, MaterialNode.ROTATION );
-
-export const diffuseColor = nodeImmutable( PropertyNode, 'DiffuseColor', 'vec4' );
-export const roughness = nodeImmutable( PropertyNode, 'Roughness', 'float' );
-export const metalness = nodeImmutable( PropertyNode, 'Metalness', 'float' );
-export const alphaTest = nodeImmutable( PropertyNode, 'AlphaTest', 'float' );
-export const specularColor = nodeImmutable( PropertyNode, 'SpecularColor', 'color' );
-
-export const reference = ( name, nodeOrType, object ) => nodeObject( new ReferenceNode( name, getConstNodeType( nodeOrType ), object ) );
-export const materialReference = ( name, nodeOrType, material ) => nodeObject( new MaterialReferenceNode( name, getConstNodeType( nodeOrType ), material ) );
-export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );
-
-export const modelViewProjection = nodeProxy( ModelViewProjectionNode );
-
-export const normalGeometry = nodeImmutable( NormalNode, NormalNode.GEOMETRY );
-export const normalLocal = nodeImmutable( NormalNode, NormalNode.LOCAL );
-export const normalWorld = nodeImmutable( NormalNode, NormalNode.WORLD );
-export const normalView = nodeImmutable( NormalNode, NormalNode.VIEW );
-export const transformedNormalView = nodeImmutable( VarNode, normalView, 'TransformedNormalView' );
-
-export const modelViewMatrix = nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX );
-export const modelNormalMatrix = nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
-export const modelWorldMatrix = nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
-export const modelPosition = nodeImmutable( ModelNode, ModelNode.POSITION );
-export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
-
-export const positionGeometry = nodeImmutable( PositionNode, PositionNode.GEOMETRY );
-export const positionLocal = nodeImmutable( PositionNode, PositionNode.LOCAL );
-export const positionWorld = nodeImmutable( PositionNode, PositionNode.WORLD );
-export const positionView = nodeImmutable( PositionNode, PositionNode.VIEW );
-export const positionViewDirection = nodeImmutable( PositionNode, PositionNode.VIEW_DIRECTION );
-
-export const texture = nodeProxy( TextureNode );
-export const sampler = ( texture ) => nodeObject( new ConvertNode( texture.isNode === true ? texture : new TextureNode( texture ), 'sampler' ) );
-export const uv = ( ...params ) => nodeObject( new UVNode( ...params ) );
-export const pointUV = nodeImmutable( PointUVNode );
-
-// gpgpu
-
-export const compute = ( node, count, workgroupSize ) => nodeObject( new ComputeNode( nodeObject( node ), count, workgroupSize ) );
-
 // math
 
 export const EPSILON = float( 1e-6 );
@@ -235,8 +180,8 @@ export const negate = nodeProxy( MathNode, MathNode.NEGATE );
 export const invert = nodeProxy( MathNode, MathNode.INVERT );
 export const dFdx = nodeProxy( MathNode, MathNode.DFDX );
 export const dFdy = nodeProxy( MathNode, MathNode.DFDY );
-export const saturate = nodeProxy( MathNode, MathNode.SATURATE );
 export const round = nodeProxy( MathNode, MathNode.ROUND );
+export const reciprocal = nodeProxy( MathNode, MathNode.RECIPROCAL );
 
 export const atan2 = nodeProxy( MathNode, MathNode.ATAN2 );
 export const min = nodeProxy( MathNode, MathNode.MIN );
@@ -254,11 +199,86 @@ export const pow4 = nodeProxy( MathNode, MathNode.POW, 4 );
 export const transformDirection = nodeProxy( MathNode, MathNode.TRANSFORM_DIRECTION );
 
 export const mix = nodeProxy( MathNode, MathNode.MIX );
-export const clamp = nodeProxy( MathNode, MathNode.CLAMP );
+export const clamp = ( value, low = 0, high = 1 ) => nodeObject( new MathNode( MathNode.CLAMP, nodeObject( value ), nodeObject( low ), nodeObject( high ) ) );
 export const refract = nodeProxy( MathNode, MathNode.REFRACT );
 export const smoothstep = nodeProxy( MathNode, MathNode.SMOOTHSTEP );
 export const faceforward = nodeProxy( MathNode, MathNode.FACEFORWARD );
 
+// accessors
+
+export const buffer = ( value, nodeOrType, count ) => nodeObject( new BufferNode( value, getConstNodeType( nodeOrType ), count ) );
+export const storage = ( value, nodeOrType, count ) => nodeObject( new StorageBufferNode( value, getConstNodeType( nodeOrType ), count ) );
+
+export const cameraProjectionMatrix = nodeImmutable( CameraNode, CameraNode.PROJECTION_MATRIX );
+export const cameraViewMatrix = nodeImmutable( CameraNode, CameraNode.VIEW_MATRIX );
+export const cameraNormalMatrix = nodeImmutable( CameraNode, CameraNode.NORMAL_MATRIX );
+export const cameraWorldMatrix = nodeImmutable( CameraNode, CameraNode.WORLD_MATRIX );
+export const cameraPosition = nodeImmutable( CameraNode, CameraNode.POSITION );
+
+export const materialAlphaTest = nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
+export const materialColor = nodeImmutable( MaterialNode, MaterialNode.COLOR );
+export const materialEmissive = nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
+export const materialOpacity = nodeImmutable( MaterialNode, MaterialNode.OPACITY );
+//export const materialSpecular = nodeImmutable( MaterialNode, MaterialNode.SPECULAR );
+export const materialRoughness = nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
+export const materialMetalness = nodeImmutable( MaterialNode, MaterialNode.METALNESS );
+export const materialRotation = nodeImmutable( MaterialNode, MaterialNode.ROTATION );
+
+export const diffuseColor = nodeImmutable( PropertyNode, 'DiffuseColor', 'vec4' );
+export const roughness = nodeImmutable( PropertyNode, 'Roughness', 'float' );
+export const metalness = nodeImmutable( PropertyNode, 'Metalness', 'float' );
+export const alphaTest = nodeImmutable( PropertyNode, 'AlphaTest', 'float' );
+export const specularColor = nodeImmutable( PropertyNode, 'SpecularColor', 'color' );
+
+export const reference = ( name, nodeOrType, object ) => nodeObject( new ReferenceNode( name, getConstNodeType( nodeOrType ), object ) );
+export const materialReference = ( name, nodeOrType, material ) => nodeObject( new MaterialReferenceNode( name, getConstNodeType( nodeOrType ), material ) );
+export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );
+
+export const modelViewProjection = nodeProxy( ModelViewProjectionNode );
+
+export const normalGeometry = nodeImmutable( NormalNode, NormalNode.GEOMETRY );
+export const normalLocal = nodeImmutable( NormalNode, NormalNode.LOCAL );
+export const normalView = nodeImmutable( NormalNode, NormalNode.VIEW );
+export const normalWorld = nodeImmutable( NormalNode, NormalNode.WORLD );
+export const transformedNormalView = nodeImmutable( VarNode, normalView, 'TransformedNormalView' );
+export const transformedNormalWorld = normalize( transformDirection( transformedNormalView, cameraViewMatrix ) );
+
+export const tangentGeometry = nodeImmutable( TangentNode, TangentNode.GEOMETRY );
+export const tangentLocal = nodeImmutable( TangentNode, TangentNode.LOCAL );
+export const tangentView = nodeImmutable( TangentNode, TangentNode.VIEW );
+export const tangentWorld = nodeImmutable( TangentNode, TangentNode.WORLD );
+export const transformedTangentView = nodeImmutable( VarNode, tangentView, 'TransformedTangentView' );
+export const transformedTangentWorld = normalize( transformDirection( transformedTangentView, cameraViewMatrix ) );
+
+export const bitangentGeometry = nodeImmutable( BitangentNode, BitangentNode.GEOMETRY );
+export const bitangentLocal = nodeImmutable( BitangentNode, BitangentNode.LOCAL );
+export const bitangentView = nodeImmutable( BitangentNode, BitangentNode.VIEW );
+export const bitangentWorld = nodeImmutable( BitangentNode, BitangentNode.WORLD );
+export const transformedBitangentView = normalize( mul( cross( transformedNormalView, transformedTangentView ), tangentGeometry.w ) );
+export const transformedBitangentWorld = normalize( transformDirection( transformedBitangentView, cameraViewMatrix ) );
+
+export const modelViewMatrix = nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX );
+export const modelNormalMatrix = nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
+export const modelWorldMatrix = nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
+export const modelPosition = nodeImmutable( ModelNode, ModelNode.POSITION );
+export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
+
+export const positionGeometry = nodeImmutable( PositionNode, PositionNode.GEOMETRY );
+export const positionLocal = nodeImmutable( PositionNode, PositionNode.LOCAL );
+export const positionWorld = nodeImmutable( PositionNode, PositionNode.WORLD );
+export const positionWorldDirection = nodeImmutable( PositionNode, PositionNode.WORLD_DIRECTION );
+export const positionView = nodeImmutable( PositionNode, PositionNode.VIEW );
+export const positionViewDirection = nodeImmutable( PositionNode, PositionNode.VIEW_DIRECTION );
+
+export const texture = nodeProxy( TextureNode );
+export const sampler = ( texture ) => nodeObject( new ConvertNode( texture.isNode === true ? texture : new TextureNode( texture ), 'sampler' ) );
+export const uv = ( ...params ) => nodeObject( new UVNode( ...params ) );
+export const pointUV = nodeImmutable( PointUVNode );
+
+// gpgpu
+
+export const compute = ( node, count, workgroupSize ) => nodeObject( new ComputeNode( nodeObject( node ), count, workgroupSize ) );
+
 // display
 
 export const frontFacing = nodeImmutable( FrontFacingNode );
@@ -273,5 +293,9 @@ export const element = nodeProxy( ArrayElementNode );
 
 // miscellaneous
 
-export const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
-export const transformedNormalWorld = normalize( transformDirection( transformedNormalView, cameraViewMatrix ) );
+export const lumaCoeffs = vec3( 0.2125, 0.7154, 0.0721 );
+
+export const luminance = ( color, luma = lumaCoeffs ) => dot( color, luma );
+export const difference = ( a, b ) => abs( sub( a, b ) );
+export const dotNV = clamp( dot( transformedNormalView, positionViewDirection ) );
+export const TBNViewMatrix = mat3( tangentView, bitangentView, normalView );

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

@@ -5,10 +5,13 @@ import ReflectVectorNode from '../accessors/ReflectVectorNode.js';
 import SkinningNode from '../accessors/SkinningNode.js';
 
 // display
+import BlendModeNode from '../display/BlendModeNode.js';
 import ColorAdjustmentNode from '../display/ColorAdjustmentNode.js';
 import ColorSpaceNode from '../display/ColorSpaceNode.js';
 import NormalMapNode from '../display/NormalMapNode.js';
+import PosterizeNode from '../display/PosterizeNode.js';
 import ToneMappingNode from '../display/ToneMappingNode.js';
+import ViewportNode from '../display/ViewportNode.js';
 
 // lighting
 import LightsNode from '../lighting/LightsNode.js';
@@ -16,12 +19,15 @@ import LightsNode from '../lighting/LightsNode.js';
 import LightingContextNode from '../lighting/LightingContextNode.js';
 
 // utils
+import EquirectUVNode from '../utils/EquirectUVNode.js';
 import MatcapUVNode from '../utils/MatcapUVNode.js';
 import MaxMipLevelNode from '../utils/MaxMipLevelNode.js';
 import OscNode from '../utils/OscNode.js';
+import RemapNode from '../utils/RemapNode.js';
 import RotateUVNode from '../utils/RotateUVNode.js';
 import SpriteSheetUVNode from '../utils/SpriteSheetUVNode.js';
 import TimerNode from '../utils/TimerNode.js';
+import TriplanarTexturesNode from '../utils/TriplanarTexturesNode.js';
 
 // geometry
 import RangeNode from '../geometry/RangeNode.js';
@@ -72,6 +78,11 @@ export const skinning = nodeProxy( SkinningNode );
 
 // display
 
+export const burn = nodeProxy( BlendModeNode, BlendModeNode.BURN );
+export const dodge = nodeProxy( BlendModeNode, BlendModeNode.DODGE );
+export const overlay = nodeProxy( BlendModeNode, BlendModeNode.OVERLAY );
+export const screen = nodeProxy( BlendModeNode, BlendModeNode.SCREEN );
+
 export const saturation = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.SATURATION );
 export const vibrance = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.VIBRANCE );
 export const hue = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.HUE );
@@ -80,6 +91,15 @@ export const colorSpace = ( node, encoding ) => nodeObject( new ColorSpaceNode(
 export const normalMap = nodeProxy( NormalMapNode );
 export const toneMapping = ( mapping, exposure, color ) => nodeObject( new ToneMappingNode( mapping, nodeObject( exposure ), nodeObject( color ) ) );
 
+export const posterize = nodeProxy( PosterizeNode );
+
+export const viewportCoordinate = nodeImmutable( ViewportNode, ViewportNode.COORDINATE );
+export const viewportResolution = nodeImmutable( ViewportNode, ViewportNode.RESOLUTION );
+export const viewportTopLeft = nodeImmutable( ViewportNode, ViewportNode.TOP_LEFT );
+export const viewportBottomLeft = nodeImmutable( ViewportNode, ViewportNode.BOTTOM_LEFT );
+export const viewportTopRight = nodeImmutable( ViewportNode, ViewportNode.TOP_RIGHT );
+export const viewportBottomRight = nodeImmutable( ViewportNode, ViewportNode.BOTTOM_RIGHT );
+
 // lighting
 
 //export const lighting = nodeProxy( LightingNode ); // abstract
@@ -90,6 +110,8 @@ export const lightingContext = nodeProxy( LightingContextNode );
 // utils
 
 export const matcapUV = nodeImmutable( MatcapUVNode );
+export const equirectUV = nodeProxy( EquirectUVNode );
+
 export const maxMipLevel = nodeProxy( MaxMipLevelNode );
 
 export const oscSine = nodeProxy( OscNode, OscNode.SINE );
@@ -97,6 +119,9 @@ export const oscSquare = nodeProxy( OscNode, OscNode.SQUARE );
 export const oscTriangle = nodeProxy( OscNode, OscNode.TRIANGLE );
 export const oscSawtooth = nodeProxy( OscNode, OscNode.SAWTOOTH );
 
+export const remap = nodeProxy( RemapNode, null, null, { doClamp: false } );
+export const remapClamp = nodeProxy( RemapNode );
+
 export const rotateUV = nodeProxy( RotateUVNode );
 
 export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
@@ -105,6 +130,10 @@ export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
 export const timerLocal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.LOCAL, timeScale, value ) );
 export const timerGlobal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.GLOBAL, timeScale, value ) );
 export const timerDelta = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.DELTA, timeScale, value ) );
+export const frameId = nodeImmutable( TimerNode, TimerNode.FRAME );
+
+export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
+export const triplanarTexture = ( texture, ...params ) => triplanarTextures( texture, texture, texture, ...params );
 
 // geometry
 

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

@@ -11,31 +11,32 @@ class ConvertNode extends Node {
 
 	}
 
-	getNodeType( /*builder*/ ) {
+	getNodeType( builder ) {
 
-		return this.convertTo;
+		const requestType = this.node.getNodeType( builder );
 
-	}
+		let convertTo = null;
 
-	generate( builder, output ) {
+		for ( const overloadingType of this.convertTo.split( '|' ) ) {
 
-		const convertTo = this.convertTo;
-		const node = this.node;
-		const type = this.getNodeType( builder );
+			if ( convertTo === null || builder.getTypeLength( requestType ) === builder.getTypeLength( overloadingType ) ) {
 
-		let snippet = null;
+				convertTo = overloadingType;
 
-		if ( builder.isReference( convertTo ) === false ) {
+			}
 
-			const nodeSnippet = node.build( builder, convertTo );
+		}
 
-			snippet = builder.format( nodeSnippet, type, convertTo );
+		return convertTo;
 
-		} else {
+	}
 
-			snippet = node.build( builder, convertTo );
+	generate( builder, output ) {
 
-		}
+		const node = this.node;
+		const type = this.getNodeType( builder );
+
+		const snippet = node.build( builder, type );
 
 		return builder.format( snippet, type, output );
 

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

@@ -0,0 +1,27 @@
+import TempNode from '../core/TempNode.js';
+import { nodeObject, vec2, add, mul, atan2, asin, clamp, positionWorldDirection } from '../shadernode/ShaderNodeElements.js';
+
+class EquirectUVNode extends TempNode {
+
+	constructor( dirNode = positionWorldDirection ) {
+
+		super( 'vec2' );
+
+		this.dirNode = dirNode;
+
+	}
+
+	construct() {
+
+		const dir = nodeObject( 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 );
+
+		return vec2( u, v );
+
+	}
+
+}
+
+export default EquirectUVNode;

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

@@ -2,9 +2,9 @@ import TempNode from '../core/Node.js';
 
 class JoinNode extends TempNode {
 
-	constructor( nodes = [] ) {
+	constructor( nodes = [], nodeType = null ) {
 
-		super();
+		super( nodeType );
 
 		this.nodes = nodes;
 
@@ -12,6 +12,12 @@ class JoinNode extends TempNode {
 
 	getNodeType( builder ) {
 
+		if ( this.nodeType !== null ) {
+
+			return builder.getVectorType( this.nodeType );
+
+		}
+
 		return builder.getTypeFromLength( this.nodes.reduce( ( count, cur ) => count + builder.getTypeLength( cur.getNodeType( builder ) ), 0 ) );
 
 	}

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

@@ -9,14 +9,12 @@ class MatcapUVNode extends TempNode {
 
 	}
 
-	generate( builder ) {
+	construct() {
 
 		const x = normalize( vec3( positionViewDirection.z, 0, negate( positionViewDirection.x ) ) );
 		const y = cross( positionViewDirection, x );
 
-		const uv = add( mul( vec2( dot( x, transformedNormalView ), dot( y, transformedNormalView ) ), 0.495 ), 0.5 );
-
-		return uv.build( builder, this.getNodeType( builder ) );
+		return add( mul( vec2( dot( x, transformedNormalView ), dot( y, transformedNormalView ) ), 0.495 ), 0.5 );
 
 	}
 

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

@@ -9,7 +9,7 @@ class MaxMipLevelNode extends UniformNode {
 
 		this.texture = texture;
 
-		this.updateType = NodeUpdateType.Frame;
+		this.updateType = NodeUpdateType.FRAME;
 
 	}
 

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

@@ -24,7 +24,7 @@ class OscNode extends Node {
 
 	}
 
-	generate( builder ) {
+	construct() {
 
 		const method = this.method;
 		const timeNode = this.timeNode;
@@ -49,7 +49,7 @@ class OscNode extends Node {
 
 		}
 
-		return outputNode.build( builder );
+		return outputNode;
 
 	}
 

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

@@ -0,0 +1,34 @@
+import Node from '../core/Node.js';
+import { add, sub, div, mul, clamp } from '../shadernode/ShaderNodeBaseElements.js';
+
+class RemapNode extends Node {
+
+	constructor( node, inLowNode, inHighNode, outLowNode, outHighNode ) {
+
+		super();
+
+		this.node = node;
+		this.inLowNode = inLowNode;
+		this.inHighNode = inHighNode;
+		this.outLowNode = outLowNode;
+		this.outHighNode = outHighNode;
+
+		this.doClamp = true;
+
+	}
+
+	construct() {
+
+		const { node, inLowNode, inHighNode, outLowNode, outHighNode, doClamp } = this;
+
+		let t = div( sub( node, inLowNode ), sub( inHighNode, inLowNode ) );
+
+		if ( doClamp === true ) t = clamp( t );
+
+		return add( mul( sub( outHighNode, outLowNode ), t ), outLowNode );
+
+	}
+
+}
+
+export default RemapNode;

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

@@ -18,20 +18,18 @@ class SpriteSheetUVNode extends Node {
 
 	}
 
-	generate( builder ) {
+	construct() {
 
-		const count = this.countNode;
-		const uv = this.uvNode;
-		const frame = this.frameNode;
+		const { frameNode, uvNode, countNode } = this;
 
 		const one = new ConstNode( 1 );
 
-		const width = new SplitNode( count, 'x' );
-		const height = new SplitNode( count, 'y' );
+		const width = new SplitNode( countNode, 'x' );
+		const height = new SplitNode( countNode, 'y' );
 
 		const total = new OperatorNode( '*', width, height );
 
-		const roundFrame = new MathNode( MathNode.FLOOR, new MathNode( MathNode.MOD, frame, total ) );
+		const roundFrame = new MathNode( MathNode.FLOOR, new MathNode( MathNode.MOD, frameNode, total ) );
 
 		const frameNum = new OperatorNode( '+', roundFrame, one );
 
@@ -39,17 +37,17 @@ class SpriteSheetUVNode extends Node {
 		const row = new MathNode( MathNode.CEIL, new OperatorNode( '/', frameNum, width ) );
 		const rowInv = new OperatorNode( '-', height, row );
 
-		const scale = new OperatorNode( '/', one, count );
+		const scale = new OperatorNode( '/', one, countNode );
 
 		const uvFrameOffset = new JoinNode( [
 			new OperatorNode( '*', cell, new SplitNode( scale, 'x' ) ),
 			new OperatorNode( '*', rowInv, new SplitNode( scale, 'y' ) )
 		] );
 
-		const uvScale = new OperatorNode( '*', uv, scale );
+		const uvScale = new OperatorNode( '*', uvNode, scale );
 		const uvFrame = new OperatorNode( '+', uvScale, uvFrameOffset );
 
-		return uvFrame.build( builder, this.getNodeType( builder ) );
+		return uvFrame;
 
 	}
 

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

@@ -6,6 +6,7 @@ class TimerNode extends UniformNode {
 	static LOCAL = 'local';
 	static GLOBAL = 'global';
 	static DELTA = 'delta';
+	static FRAME = 'frame';
 
 	constructor( scope = TimerNode.LOCAL, scale = 1, value = 0 ) {
 
@@ -14,10 +15,25 @@ class TimerNode extends UniformNode {
 		this.scope = scope;
 		this.scale = scale;
 
-		this.updateType = NodeUpdateType.Frame;
+		this.updateType = NodeUpdateType.FRAME;
 
 	}
+/*
+	@TODO:
+	getNodeType( builder ) {
 
+		const scope = this.scope;
+
+		if ( scope === TimerNode.FRAME ) {
+
+			return 'uint';
+
+		}
+
+		return 'float';
+
+	}
+*/
 	update( frame ) {
 
 		const scope = this.scope;
@@ -31,6 +47,10 @@ class TimerNode extends UniformNode {
 
 			this.value = frame.deltaTime * scale;
 
+		} else if ( scope === TimerNode.FRAME ) {
+
+			this.value = frame.frameId;
+
 		} else {
 
 			// global

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

@@ -0,0 +1,51 @@
+import Node from '../core/Node.js';
+import { float, vec3, add, mul, div, dot, normalize, abs, texture, positionWorld, normalWorld } from '../shadernode/ShaderNodeBaseElements.js';
+
+class TriplanarTexturesNode extends Node {
+
+	constructor( textureXNode, textureYNode = null, textureZNode = null, scaleNode = float( 1 ), positionNode = positionWorld, normalNode = normalWorld ) {
+
+		super( 'vec4' );
+
+		this.textureXNode = textureXNode;
+		this.textureYNode = textureYNode;
+		this.textureZNode = textureZNode;
+
+		this.scaleNode = scaleNode;
+
+		this.positionNode = positionNode;
+		this.normalNode = normalNode;
+
+	}
+
+	construct() {
+
+		const { textureXNode, textureYNode, textureZNode, scaleNode, positionNode, normalNode } = this;
+
+		// Ref: https://github.com/keijiro/StandardTriplanar
+
+		// Blending factor of triplanar mapping
+		let bf = normalize( abs( normalNode ) );
+		bf = div( bf, dot( bf, vec3( 1.0 ) ) );
+
+		// Triplanar mapping
+		const tx = mul( positionNode.yz, scaleNode );
+		const ty = mul( positionNode.zx, scaleNode );
+		const tz = mul( positionNode.xy, scaleNode );
+
+		// Base color
+		const textureX = textureXNode.value;
+		const textureY = textureYNode !== null ? textureYNode.value : textureX;
+		const textureZ = textureZNode !== null ? textureZNode.value : textureX;
+
+		const cx = mul( texture( textureX, tx ), bf.x );
+		const cy = mul( texture( textureY, ty ), bf.y );
+		const cz = mul( texture( textureZ, tz ), bf.z );
+
+		return add( cx, cy, cz );
+
+	}
+
+}
+
+export default TriplanarTexturesNode;

package/examples/jsm/postprocessing/AfterimagePass.js

@@ -30,7 +30,7 @@ class AfterimagePass extends Pass {
 			magFilter: NearestFilter,
 		} );
 
-		this.shaderMaterial = new ShaderMaterial( {
+		this.compFsMaterial = new ShaderMaterial( {
 
 			uniforms: this.uniforms,
 			vertexShader: this.shader.vertexShader,
@@ -38,10 +38,10 @@ class AfterimagePass extends Pass {
 
 		} );
 
-		this.compFsQuad = new FullScreenQuad( this.shaderMaterial );
+		this.compFsQuad = new FullScreenQuad( this.compFsMaterial );
 
-		const material = new MeshBasicMaterial();
-		this.copyFsQuad = new FullScreenQuad( material );
+		this.copyFsMaterial = new MeshBasicMaterial();
+		this.copyFsQuad = new FullScreenQuad( this.copyFsMaterial );
 
 	}
 
@@ -85,6 +85,19 @@ class AfterimagePass extends Pass {
 
 	}
 
+	dispose() {
+
+		this.textureComp.dispose();
+		this.textureOld.dispose();
+
+		this.compFsMaterial.dispose();
+		this.copyFsMaterial.dispose();
+
+		this.compFsQuad.dispose();
+		this.copyFsQuad.dispose();
+
+	}
+
 }
 
 export { AfterimagePass };