@needle-tools/three 0.145.4 → 0.146.2

package/examples/jsm/nodes/core/Node.js

@@ -12,7 +12,7 @@ class Node {
 
 		this.nodeType = nodeType;
 
-		this.updateType = NodeUpdateType.None;
+		this.updateType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 

package/examples/jsm/nodes/core/NodeBuilder.js

@@ -13,7 +13,6 @@ export const shaderStages = [ ...defaultShaderStages, 'compute' ];
 export const vector = [ 'x', 'y', 'z', 'w' ];
 
 const typeFromLength = new Map();
-typeFromLength.set( 1, 'float' );
 typeFromLength.set( 2, 'vec2' );
 typeFromLength.set( 3, 'vec3' );
 typeFromLength.set( 4, 'vec4' );
@@ -117,7 +116,7 @@ class NodeBuilder {
 
 			const updateType = node.getUpdateType( this );
 
-			if ( updateType !== NodeUpdateType.None ) {
+			if ( updateType !== NodeUpdateType.NONE ) {
 
 				this.updateNodes.push( node );
 
@@ -181,6 +180,18 @@ class NodeBuilder {
 
 	}
 
+	getFragCoord() {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
+	isFlipY() {
+
+		return false;
+
+	}
+
 	getTexture( /* textureProperty, uvSnippet */ ) {
 
 		console.warn( 'Abstract function.' );
@@ -353,6 +364,8 @@ class NodeBuilder {
 
 		type = this.getVectorType( type );
 
+		if ( type === 'float' || type === 'bool' || type === 'int' || type === 'uint' ) return type;
+
 		const componentType = /(b|i|u|)(vec|mat)([2-4])/.exec( type );
 
 		if ( componentType === null ) return null;
@@ -374,9 +387,12 @@ class NodeBuilder {
 
 	}
 
-	getTypeFromLength( length ) {
+	getTypeFromLength( length, componentType = 'float' ) {
 
-		return typeFromLength.get( length );
+		if ( length === 1 ) return componentType;
+		const baseType = typeFromLength.get( length );
+		const prefix = componentType === 'float' ? '' : componentType[ 0 ];
+		return prefix + baseType;
 
 	}
 
@@ -400,6 +416,22 @@ class NodeBuilder {
 
 	}
 
+	changeComponentType( type, newComponentType ) {
+
+		return this.getTypeFromLength( this.getTypeLength( type ), newComponentType );
+
+	}
+
+	getIntegerType( type ) {
+
+		const componentType = this.getComponentType( type );
+
+		if ( componentType === 'int' || componentType === 'uint' ) return type;
+
+		return this.changeComponentType( type, 'int' );
+
+	}
+
 	getDataFromNode( node, shaderStage = this.shaderStage ) {
 
 		let nodeData = this.nodesData.get( node );

package/examples/jsm/nodes/core/NodeFrame.js

@@ -22,7 +22,7 @@ class NodeFrame {
 
 	updateNode( node ) {
 
-		if ( node.updateType === NodeUpdateType.Frame ) {
+		if ( node.updateType === NodeUpdateType.FRAME ) {
 
 			if ( this.updateMap.get( node ) !== this.frameId ) {
 
@@ -32,7 +32,7 @@ class NodeFrame {
 
 			}
 
-		} else if ( node.updateType === NodeUpdateType.Object ) {
+		} else if ( node.updateType === NodeUpdateType.OBJECT ) {
 
 			node.update( this );
 

package/examples/jsm/nodes/core/NodeVarying.js

@@ -1,11 +1,14 @@
-class NodeVarying {
+import NodeVar from './NodeVar.js';
+
+class NodeVarying extends NodeVar {
 
 	constructor( name, type ) {
 
-		this.isNodeVarying = true;
+		super( name, type );
 
-		this.name = name;
-		this.type = type;
+		this.needsInterpolation = false;
+
+		this.isNodeVarying = true;
 
 	}
 

package/examples/jsm/nodes/core/VaryingNode.js

@@ -28,22 +28,24 @@ class VaryingNode extends Node {
 
 	generate( builder ) {
 
+		const { name, node } = this;
 		const type = this.getNodeType( builder );
-		const node = this.node;
-		const name = this.name;
 
 		const nodeVarying = builder.getVaryingFromNode( this, type );
 
+		// this property can be used to check if the varying can be optimized for a var
+		nodeVarying.needsInterpolation ||= builder.shaderStage === 'fragment';
+
 		if ( name !== null ) {
 
 			nodeVarying.name = name;
 
 		}
 
-		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.Vertex );
+		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.VERTEX );
 
 		// force node run in vertex stage
-		builder.flowNodeFromShaderStage( NodeShaderStage.Vertex, node, type, propertyName );
+		builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, node, type, propertyName );
 
 		return builder.getPropertyName( nodeVarying );
 

package/examples/jsm/nodes/core/constants.js

@@ -1,21 +1,21 @@
 export const NodeShaderStage = {
-	Vertex: 'vertex',
-	Fragment: 'fragment'
+	VERTEX: 'vertex',
+	FRAGMENT: 'fragment'
 };
 
 export const NodeUpdateType = {
-	None: 'none',
-	Frame: 'frame',
-	Object: 'object'
+	NONE: 'none',
+	FRAME: 'frame',
+	OBJECT: 'object'
 };
 
 export const NodeType = {
-	Boolean: 'bool',
-	Integer: 'int',
-	Float: 'float',
-	Vector2: 'vec2',
-	Vector3: 'vec3',
-	Vector4: 'vec4',
-	Matrix3: 'mat3',
-	Matrix4: 'mat4'
+	BOOLEAN: 'bool',
+	INTEGER: 'int',
+	FLOAT: 'float',
+	VECTOR2: 'vec2',
+	VECTOR3: 'vec3',
+	VECTOR4: 'vec4',
+	MATRIX3: 'mat3',
+	MATRIX4: 'mat4'
 };

package/examples/jsm/nodes/display/PosterizeNode.js

@@ -0,0 +1,25 @@
+import TempNode from '../core/Node.js';
+import { mul, floor, reciprocal } from '../shadernode/ShaderNodeBaseElements.js';
+
+class PosterizeNode extends TempNode {
+
+	constructor( sourceNode, stepsNode ) {
+
+		super();
+
+		this.sourceNode = sourceNode;
+		this.stepsNode = stepsNode;
+
+	}
+
+	construct() {
+
+		const { sourceNode, stepsNode } = this;
+
+		return mul( floor( mul( sourceNode, stepsNode ) ), reciprocal( stepsNode ) );
+
+	}
+
+}
+
+export default PosterizeNode;

package/examples/jsm/nodes/display/ViewportNode.js

@@ -0,0 +1,106 @@
+import Node from '../core/Node.js';
+import { uniform, div, vec2, invert } from '../shadernode/ShaderNodeBaseElements.js';
+import { Vector2 } from 'three';
+import { NodeUpdateType } from '../core/constants.js';
+
+let resolution;
+
+class ViewportNode extends Node {
+
+	static COORDINATE = 'coordinate';
+	static RESOLUTION = 'resolution';
+	static TOP_LEFT = 'topLeft';
+	static BOTTOM_LEFT = 'bottomLeft';
+	static TOP_RIGHT = 'topRight';
+	static BOTTOM_RIGHT = 'bottomRight';
+
+	constructor( scope ) {
+
+		super();
+
+		this.scope = scope;
+
+		this.isViewportNode = true;
+
+	}
+
+	getNodeType() {
+
+		return this.scope === ViewportNode.COORDINATE ? 'vec4' : 'vec2';
+
+	}
+
+	getUpdateType() {
+
+		let updateType = NodeUpdateType.NONE;
+
+		if ( this.scope === ViewportNode.RESOLUTION ) {
+
+			updateType = NodeUpdateType.FRAME;
+
+		}
+
+		this.updateType = updateType;
+
+		return updateType;
+
+	}
+
+	update( { renderer } ) {
+
+		renderer.getSize( resolution );
+
+	}
+
+	construct( builder ) {
+
+		const scope = this.scope;
+
+		if ( scope === ViewportNode.COORDINATE ) return;
+
+		let output = null;
+
+		if ( scope === ViewportNode.RESOLUTION ) {
+
+			resolution ||= new Vector2();
+
+			output = uniform( resolution );
+
+		} else {
+
+			const coordinateNode = vec2( new ViewportNode( ViewportNode.COORDINATE ) );
+			const resolutionNode = new ViewportNode( ViewportNode.RESOLUTION );
+
+			output = div( coordinateNode, resolutionNode );
+
+			let outX = output.x;
+			let outY = output.y;
+
+			if ( /top/i.test( scope ) && builder.isFlipY() ) outY = invert( outY );
+			else if ( /bottom/i.test( scope ) && builder.isFlipY() === false ) outY = invert( outY );
+
+			if ( /right/i.test( scope ) ) outX = invert( outX );
+
+			output = vec2( outX, outY );
+
+		}
+
+		return output;
+
+	}
+
+	generate( builder ) {
+
+		if ( this.scope === ViewportNode.COORDINATE ) {
+
+			return builder.getFragCoord();
+
+		}
+
+		return super.generate( builder );
+
+	}
+
+}
+
+export default ViewportNode;

package/examples/jsm/nodes/gpgpu/ComputeNode.js

@@ -15,7 +15,7 @@ class ComputeNode extends Node {
 		this.workgroupSize = workgroupSize;
 		this.dispatchCount = 0;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.updateDispatchCount();
 

package/examples/jsm/nodes/lighting/AnalyticLightNode.js

@@ -10,7 +10,7 @@ class AnalyticLightNode extends LightingNode {
 
 		super();
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.light = light;
 

package/examples/jsm/nodes/loaders/NodeMaterialLoader.js

@@ -4,6 +4,7 @@ import {
 	LineBasicNodeMaterial,
 	MeshBasicNodeMaterial,
 	MeshStandardNodeMaterial,
+	MeshPhysicalNodeMaterial,
 	PointsNodeMaterial,
 	SpriteNodeMaterial
 } from '../materials/Materials.js';
@@ -17,8 +18,9 @@ MaterialLoader.createMaterialFromType = function ( type ) {
 		LineBasicNodeMaterial,
 		MeshBasicNodeMaterial,
 		MeshStandardNodeMaterial,
+		MeshPhysicalNodeMaterial,
 		PointsNodeMaterial,
-		SpriteNodeMaterial,
+		SpriteNodeMaterial
 	};
 
 	if ( materialLib[ type ] !== undefined ) {

package/examples/jsm/nodes/materials/Materials.js

@@ -32,19 +32,21 @@ NodeMaterial.fromMaterial = function ( material ) {
 
 	if ( materialLib[ type ] === undefined ) {
 
-		return material; // is already a node material or cannot be converted
+		if ( material.isNodeMaterial !== true ) {
 
-	}
+			throw new Error( `NodeMaterial: Material "${ material.type }" is not compatible.` );
 
-	const nodeMaterial = new materialLib[ type ]( material );
+		}
 
-	for ( const key in material ) {
+		return material; // is already a node material
 
-		if ( nodeMaterial[ key ] === undefined ) {
+	}
 
-			nodeMaterial[ key ] = material[ key ]; // currently this is needed only for material.alphaTest
+	const nodeMaterial = new materialLib[ type ]();
 
-		}
+	for ( const key in material ) {
+
+		nodeMaterial[ key ] = material[ key ];
 
 	}
 

package/examples/jsm/nodes/materials/NodeMaterial.js

@@ -3,7 +3,7 @@ import { getNodesKeys, getCacheKey } from '../core/NodeUtils.js';
 import ExpressionNode from '../core/ExpressionNode.js';
 import {
 	float, vec3, vec4,
-	assign, label, mul, bypass,
+	assign, label, mul, bypass, attribute,
 	positionLocal, skinning, instance, modelViewProjection, lightingContext, colorSpace,
 	materialAlphaTest, materialColor, materialOpacity
 } from '../shadernode/ShaderNodeElements.js';
@@ -80,6 +80,14 @@ class NodeMaterial extends ShaderMaterial {
 		let colorNode = vec4( this.colorNode || materialColor );
 		let opacityNode = this.opacityNode ? float( this.opacityNode ) : materialOpacity;
 
+		// VERTEX COLORS
+
+		if ( this.vertexColors === true && builder.geometry.hasAttribute( 'color' ) ) {
+
+			colorNode = vec4( mul( colorNode.xyz, attribute( 'color' ) ), colorNode.a );
+		
+		}
+
 		// COLOR
 
 		colorNode = builder.addFlow( 'fragment', label( colorNode, 'Color' ) );

package/examples/jsm/nodes/materialx/MaterialXNodes.js

@@ -5,7 +5,8 @@ import {
 	mx_fractal_noise_float as fractal_noise_float, mx_fractal_noise_vec2 as fractal_noise_vec2, mx_fractal_noise_vec3 as fractal_noise_vec3, mx_fractal_noise_vec4 as fractal_noise_vec4
 } from './lib/mx_noise.js';
 import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import { nodeObject, float, vec2, vec4, add, sub, mul, mix, clamp, uv, length, smoothstep, dFdx, dFdy, convert } from '../shadernode/ShaderNodeElements.js';
+import { mx_srgb_texture_to_lin_rec709 } from './lib/mx_transform_color.js';
+import { nodeObject, float, vec2, vec4, add, sub, mul, mix, clamp, uv, length, smoothstep, dFdx, dFdy, sign, pow, abs, convert } from '../shadernode/ShaderNodeElements.js';
 
 export const mx_aastep = ( threshold, value ) => {
 
@@ -28,6 +29,9 @@ export const mx_splittb = ( valuet, valueb, center, texcoord = uv() ) => _split(
 
 export const mx_transform_uv = ( uv_scale = 1, uv_offset = 0, uv_geo = uv() ) => add( mul( uv_geo, uv_scale ), uv_offset );
 
+export const mx_safepower = ( in1, in2 = 1 ) => mul( sign( in1 ), pow( abs( in1 ), in2 ) );
+export const mx_contrast = ( input, amount = 1, pivot = .5 ) => add( mul( sub( input, pivot ), amount ), pivot );
+
 export const mx_noise_float = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_float( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
 export const mx_noise_vec2 = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_vec2( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
 export const mx_noise_vec3 = ( texcoord = uv(), amplitude = 1, pivot = 0 ) => add( mul( amplitude, mx_perlin_noise_vec3( convert( texcoord, 'vec2|vec3' ) ) ), pivot );
@@ -52,4 +56,4 @@ export const mx_fractal_noise_vec2 = ( position = uv(), octaves = 3, lacunarity
 export const mx_fractal_noise_vec3 = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_vec3( position, octaves, lacunarity, diminish ), amplitude );
 export const mx_fractal_noise_vec4 = ( position = uv(), octaves = 3, lacunarity = 2, diminish = .5, amplitude = 1 ) => mul( fractal_noise_vec4( position, octaves, lacunarity, diminish ), amplitude );
 
-export { mx_hsvtorgb, mx_rgbtohsv };
+export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

package/examples/jsm/nodes/materialx/lib/mx_transform_color.js

@@ -0,0 +1,18 @@
+import { code, fn } from '../../Nodes.js';
+
+// Original shader code from:
+// https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/libraries/stdlib/genglsl/lib/mx_transform_color.glsl
+
+export const mx_transform_color = code( `#define M_AP1_TO_REC709 mat3(1.705079555511475, -0.1297005265951157, -0.02416634373366833, -0.6242334842681885, 1.138468623161316, -0.1246141716837883, -0.0808461606502533, -0.008768022060394287, 1.148780584335327)
+
+vec3 mx_srgb_texture_to_lin_rec709(vec3 color)
+{
+    bvec3 isAbove = greaterThan(color, vec3(0.04045));
+    vec3 linSeg = color / 12.92;
+    vec3 powSeg = pow(max(color + vec3(0.055), vec3(0.0)) / 1.055, vec3(2.4));
+    return mix(linSeg, powSeg, isAbove);
+}` );
+
+const includes = [ mx_transform_color ];
+
+export const mx_srgb_texture_to_lin_rec709 = fn( 'vec3 mx_srgb_texture_to_lin_rec709( vec3 color )', includes );

package/examples/jsm/nodes/math/MathNode.js

@@ -33,6 +33,7 @@ class MathNode extends TempNode {
 	static DFDX = 'dFdx';
 	static DFDY = 'dFdy';
 	static ROUND = 'round';
+	static RECIPROCAL = 'reciprocal';
 
 	// 2 inputs
 
@@ -159,6 +160,10 @@ class MathNode extends TempNode {
 
 			return builder.format( '( 1.0 - ' + a.build( builder, inputType ) + ' )', type, output );
 
+		} else if ( method === MathNode.RECIPROCAL ) {
+
+			return builder.format( '( 1.0 / ' + a.build( builder, inputType ) + ' )', type, output );
+
 		} else {
 
 			const params = [];

package/examples/jsm/nodes/math/OperatorNode.js

@@ -47,7 +47,7 @@ class OperatorNode extends TempNode {
 
 		} else if ( op === '&' || op === '|' || op === '^' || op === '>>' || op === '<<' ) {
 
-			return 'int';
+			return builder.getIntegerType( typeA );
 
 		} else if ( op === '==' || op === '&&' || op === '||' || op === '^^' ) {
 
@@ -124,6 +124,11 @@ class OperatorNode extends TempNode {
 
 				}
 
+			} else if ( op === '>>' || op === '<<' ) {
+
+				typeA = type;
+				typeB = builder.changeComponentType( typeB, 'uint' );
+
 			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
 
 				// matrix x vector

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

@@ -1,3 +1,4 @@
+import Node from '../core/Node.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import ConvertNode from '../utils/ConvertNode.js';
 import JoinNode from '../utils/JoinNode.js';
@@ -147,31 +148,43 @@ const ShaderNodeImmutable = function ( NodeClass, ...params ) {
 
 };
 
-const ShaderNodeScript = function ( jsFunc ) {
+class ShaderNodeInternal extends Node {
+
+	constructor( jsFunc ) {
 
-	// @TODO: Move this to Node extended class
+		super();
 
-	const self = {
+		this._jsFunc = jsFunc;
 
-		build: ( builder ) => {
+	}
 
-			self.call( {}, builder );
+	call( inputs, builder ) {
 
-			return '';
+		inputs = nodeObjects( inputs );
+
+		return nodeObject( this._jsFunc( inputs, builder ) );
+
+	}
 
-		},
+	generate( builder, output ) {
 
-		call: ( inputs, builder ) => {
+		const nodeCall = this.call( {}, builder );
 
-			inputs = nodeObjects( inputs );
+		if ( nodeCall === undefined ) {
 
-			return nodeObject( jsFunc( inputs, builder ) );
+			return '';
 
 		}
 
-	};
+		return builder.format( nodeCall.build( builder ), nodeCall.getNodeType( builder ), output );
+
+	}
+
+}
+
+const ShaderNodeScript = function ( jsFunc ) {
 
-	return self;
+	return new ShaderNodeInternal( jsFunc );
 
 };
 
@@ -253,7 +266,7 @@ export const ConvertType = function ( type, cacheMap = null ) {
 
 			}
 
-			return nodeObject( new ConvertNode( new JoinNode( nodes ), type ) );
+			return nodeObject( new JoinNode( nodes, type ) );
 
 		}
 

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

@@ -181,6 +181,7 @@ export const invert = nodeProxy( MathNode, MathNode.INVERT );
 export const dFdx = nodeProxy( MathNode, MathNode.DFDX );
 export const dFdy = nodeProxy( MathNode, MathNode.DFDY );
 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 );
@@ -265,6 +266,7 @@ export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITI
 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 );
 

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

@@ -9,7 +9,9 @@ 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';
@@ -17,6 +19,7 @@ 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';
@@ -24,6 +27,7 @@ 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';
@@ -87,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
@@ -97,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 );
@@ -117,6 +132,9 @@ export const timerGlobal = ( timeScale, value = 0 ) => nodeObject( new TimerNode
 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
 
 export const range = ( min, max ) => nodeObject( new RangeNode( min, max ) );