super-three 0.136.0 → 0.141.0

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

@@ -0,0 +1,274 @@
+// core
+//import ArrayUniformNode from '../core/ArrayUniformNode.js';
+import AttributeNode from '../core/AttributeNode.js';
+import BypassNode from '../core/BypassNode.js';
+import CodeNode from '../core/CodeNode.js';
+import ContextNode from '../core/ContextNode.js';
+import ExpressionNode from '../core/ExpressionNode.js';
+import FunctionCallNode from '../core/FunctionCallNode.js';
+import FunctionNode from '../core/FunctionNode.js';
+import InstanceIndexNode from '../core/InstanceIndexNode.js';
+import PropertyNode from '../core/PropertyNode.js';
+import UniformNode from '../core/UniformNode.js';
+import VarNode from '../core/VarNode.js';
+import VaryNode from '../core/VaryNode.js';
+
+// accessors
+import BufferNode from '../accessors/BufferNode.js';
+import CameraNode from '../accessors/CameraNode.js';
+import MaterialNode from '../accessors/MaterialNode.js';
+import MaterialReferenceNode from '../accessors/MaterialReferenceNode.js';
+import ModelViewProjectionNode from '../accessors/ModelViewProjectionNode.js';
+import NormalNode from '../accessors/NormalNode.js';
+import ModelNode from '../accessors/ModelNode.js';
+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 TextureNode from '../accessors/TextureNode.js';
+import UserDataNode from '../accessors/UserDataNode.js';
+import UVNode from '../accessors/UVNode.js';
+
+// display
+import FrontFacingNode from '../display/FrontFacingNode.js';
+
+// gpgpu
+import ComputeNode from '../gpgpu/ComputeNode.js';
+
+// math
+import MathNode from '../math/MathNode.js';
+import OperatorNode from '../math/OperatorNode.js';
+import CondNode from '../math/CondNode.js';
+
+// utils
+import ArrayElementNode from '../utils/ArrayElementNode.js';
+import ConvertNode from '../utils/ConvertNode.js';
+
+// shader node utils
+import { ShaderNode, nodeObject, nodeObjects, nodeArray, nodeProxy, nodeImmutable, ConvertType, getConstNodeType, cacheMaps } from './ShaderNode.js';
+
+// shader node base
+
+export { ShaderNode, nodeObject, nodeObjects, nodeArray, nodeProxy, nodeImmutable };
+
+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' );
+
+// core
+
+// @TODO: ArrayUniformNode
+
+export const func = ( code ) => {
+
+	const node = nodeObject( new FunctionNode( code ) );
+
+	const call = node.call.bind( node );
+	node.call = ( params ) => nodeObject( call( params ) );
+
+	return node;
+
+};
+
+export const uniform = ( nodeOrType ) => {
+
+	const nodeType = getConstNodeType( nodeOrType );
+
+	// @TODO: get ConstNode from .traverse() in the future
+	const value = nodeOrType.isNode === true ? nodeOrType.node?.value || nodeOrType.value : nodeOrType;
+
+	return nodeObject( new UniformNode( value, nodeType ) );
+
+};
+
+export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
+export const property = ( name, nodeOrType ) => nodeObject( new PropertyNode( name, getConstNodeType( nodeOrType ) ) );
+
+export const bypass = nodeProxy( BypassNode );
+export const code = nodeProxy( CodeNode );
+export const context = nodeProxy( ContextNode );
+export const expression = nodeProxy( ExpressionNode );
+export const call = nodeProxy( FunctionCallNode );
+export const instanceIndex = nodeImmutable( InstanceIndexNode );
+export const label = nodeProxy( VarNode );
+export const temp = label;
+export const vary = nodeProxy( VaryNode );
+
+// 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 );
+export const INFINITY = float( 1e6 );
+
+export const cond = nodeProxy( CondNode );
+
+export const add = nodeProxy( OperatorNode, '+' );
+export const sub = nodeProxy( OperatorNode, '-' );
+export const mul = nodeProxy( OperatorNode, '*' );
+export const div = nodeProxy( OperatorNode, '/' );
+export const remainder = nodeProxy( OperatorNode, '%' );
+export const equal = nodeProxy( OperatorNode, '==' );
+export const assign = nodeProxy( OperatorNode, '=' );
+export const lessThan = nodeProxy( OperatorNode, '<' );
+export const greaterThan = nodeProxy( OperatorNode, '>' );
+export const lessThanEqual = nodeProxy( OperatorNode, '<=' );
+export const greaterThanEqual = nodeProxy( OperatorNode, '>=' );
+export const and = nodeProxy( OperatorNode, '&&' );
+export const or = nodeProxy( OperatorNode, '||' );
+export const xor = nodeProxy( OperatorNode, '^^' );
+export const bitAnd = nodeProxy( OperatorNode, '&' );
+export const bitOr = nodeProxy( OperatorNode, '|' );
+export const bitXor = nodeProxy( OperatorNode, '^' );
+export const shiftLeft = nodeProxy( OperatorNode, '<<' );
+export const shiftRight = nodeProxy( OperatorNode, '>>' );
+
+export const radians = nodeProxy( MathNode, MathNode.RADIANS );
+export const degrees = nodeProxy( MathNode, MathNode.DEGREES );
+export const exp = nodeProxy( MathNode, MathNode.EXP );
+export const exp2 = nodeProxy( MathNode, MathNode.EXP2 );
+export const log = nodeProxy( MathNode, MathNode.LOG );
+export const log2 = nodeProxy( MathNode, MathNode.LOG2 );
+export const sqrt = nodeProxy( MathNode, MathNode.SQRT );
+export const inversesqrt = nodeProxy( MathNode, MathNode.INVERSE_SQRT );
+export const floor = nodeProxy( MathNode, MathNode.FLOOR );
+export const ceil = nodeProxy( MathNode, MathNode.CEIL );
+export const normalize = nodeProxy( MathNode, MathNode.NORMALIZE );
+export const fract = nodeProxy( MathNode, MathNode.FRACT );
+export const sin = nodeProxy( MathNode, MathNode.SIN );
+export const cos = nodeProxy( MathNode, MathNode.COS );
+export const tan = nodeProxy( MathNode, MathNode.TAN );
+export const asin = nodeProxy( MathNode, MathNode.ASIN );
+export const acos = nodeProxy( MathNode, MathNode.ACOS );
+export const atan = nodeProxy( MathNode, MathNode.ATAN );
+export const abs = nodeProxy( MathNode, MathNode.ABS );
+export const sign = nodeProxy( MathNode, MathNode.SIGN );
+export const length = nodeProxy( MathNode, MathNode.LENGTH );
+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 min = nodeProxy( MathNode, MathNode.MIN );
+export const max = nodeProxy( MathNode, MathNode.MAX );
+export const mod = nodeProxy( MathNode, MathNode.MOD );
+export const step = nodeProxy( MathNode, MathNode.STEP );
+export const reflect = nodeProxy( MathNode, MathNode.REFLECT );
+export const distance = nodeProxy( MathNode, MathNode.DISTANCE );
+export const dot = nodeProxy( MathNode, MathNode.DOT );
+export const cross = nodeProxy( MathNode, MathNode.CROSS );
+export const pow = nodeProxy( MathNode, MathNode.POW );
+export const pow2 = nodeProxy( MathNode, MathNode.POW, 2 );
+export const pow3 = nodeProxy( MathNode, MathNode.POW, 3 );
+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 refract = nodeProxy( MathNode, MathNode.REFRACT );
+export const smoothstep = nodeProxy( MathNode, MathNode.SMOOTHSTEP );
+export const faceforward = nodeProxy( MathNode, MathNode.FACEFORWARD );
+
+// display
+
+export const frontFacing = nodeImmutable( FrontFacingNode );
+export const faceDirection = sub( mul( float( frontFacing ), 2 ), 1 );
+
+// lighting
+
+
+// utils
+
+export const element = nodeProxy( ArrayElementNode );
+
+// miscellaneous
+
+export const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
+export const transformedNormalWorld = normalize( transformDirection( transformedNormalView, cameraViewMatrix ) );

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

@@ -0,0 +1,106 @@
+// accessors
+import CubeTextureNode from '../accessors/CubeTextureNode.js';
+import InstanceNode from '../accessors/InstanceNode.js';
+import ReflectNode from '../accessors/ReflectNode.js';
+import SkinningNode from '../accessors/SkinningNode.js';
+
+// display
+import ColorSpaceNode from '../display/ColorSpaceNode.js';
+import NormalMapNode from '../display/NormalMapNode.js';
+import ToneMappingNode from '../display/ToneMappingNode.js';
+
+// lighting
+import LightsNode from '../lighting/LightsNode.js';
+//import LightingNode from '../lighting/LightingNode.js';
+import LightingContextNode from '../lighting/LightingContextNode.js';
+
+// utils
+import MatcapUVNode from '../utils/MatcapUVNode.js';
+import MaxMipLevelNode from '../utils/MaxMipLevelNode.js';
+import OscNode from '../utils/OscNode.js';
+import SpriteSheetUVNode from '../utils/SpriteSheetUVNode.js';
+import TimerNode from '../utils/TimerNode.js';
+
+// procedural
+import CheckerNode from '../procedural/CheckerNode.js';
+
+// fog
+import FogNode from '../fog/FogNode.js';
+import FogRangeNode from '../fog/FogRangeNode.js';
+
+// shader node utils
+import { nodeObject, nodeProxy, nodeImmutable } from './ShaderNode.js';
+
+//
+// Node Material Shader Syntax
+//
+
+// shader node base
+
+export * from './ShaderNodeBaseElements.js';
+
+// functions
+
+export { default as BRDF_GGX } from '../functions/BSDF/BRDF_GGX.js'; // see https://github.com/tc39/proposal-export-default-from
+export { default as BRDF_Lambert } from '../functions/BSDF/BRDF_Lambert.js';
+export { default as D_GGX } from '../functions/BSDF/D_GGX.js';
+export { default as DFGApprox } from '../functions/BSDF/DFGApprox.js';
+export { default as F_Schlick } from '../functions/BSDF/F_Schlick.js';
+export { default as V_GGX_SmithCorrelated } from '../functions/BSDF/V_GGX_SmithCorrelated.js';
+
+export { default as getDistanceAttenuation } from '../functions/light/getDistanceAttenuation.js';
+
+export { default as getGeometryRoughness } from '../functions/material/getGeometryRoughness.js';
+export { default as getRoughness } from '../functions/material/getRoughness.js';
+
+export { default as PhysicalLightingModel } from '../functions/PhysicalLightingModel.js';
+
+// accessors
+
+export const cubeTexture = nodeProxy( CubeTextureNode );
+
+export const instance = nodeProxy( InstanceNode );
+
+export const reflectVector = nodeImmutable( ReflectNode, ReflectNode.VECTOR );
+export const reflectCube = nodeImmutable( ReflectNode, ReflectNode.CUBE );
+
+export const skinning = nodeProxy( SkinningNode );
+
+// display
+
+export const colorSpace = ( node, encoding ) => nodeObject( new ColorSpaceNode( null, nodeObject( node ) ).fromEncoding( encoding ) );
+export const normalMap = nodeProxy( NormalMapNode );
+export const toneMapping = ( mapping, exposure, color ) => nodeObject( new ToneMappingNode( mapping, nodeObject( exposure ), nodeObject( color ) ) );
+
+// lighting
+
+//export const lighting = nodeProxy( LightingNode ); // abstract
+//export const light; // still needs to be added
+export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
+export const lightingContext = nodeProxy( LightingContextNode );
+
+// utils
+
+export const matcapUV = nodeImmutable( MatcapUVNode );
+export const maxMipLevel = nodeProxy( MaxMipLevelNode );
+
+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 );
+
+export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
+
+// @TODO: add supports to use node in timeScale
+export const timerLocal = ( timeScale ) => nodeObject( new TimerNode( TimerNode.LOCAL, timeScale ) );
+export const timerGlobal = ( timeScale ) => nodeObject( new TimerNode( TimerNode.GLOBAL, timeScale ) );
+export const timerDelta = ( timeScale ) => nodeObject( new TimerNode( TimerNode.DELTA, timeScale ) );
+
+// procedural
+
+export const checker = nodeProxy( CheckerNode );
+
+// fog
+
+export const fog = nodeProxy( FogNode );
+export const rangeFog = nodeProxy( FogRangeNode );

package/examples/jsm/{renderers/nodes → nodes}/utils/ArrayElementNode.js

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
+import TempNode from '../core/Node.js';
 
-class ArrayElementNode extends Node {
+class ArrayElementNode extends TempNode {
 
 	constructor( node, indexNode ) {
 
@@ -20,7 +20,7 @@ class ArrayElementNode extends Node {
 	generate( builder ) {
 
 		const nodeSnippet = this.node.build( builder );
-		const indexSnippet = this.indexNode.build( builder, 'int' );
+		const indexSnippet = this.indexNode.build( builder, 'uint' );
 
 		return `${nodeSnippet}[ ${indexSnippet} ]`;
 

package/examples/jsm/{renderers/nodes → nodes}/utils/ConvertNode.js

@@ -20,11 +20,19 @@ class ConvertNode extends Node {
 	generate( builder ) {
 
 		const convertTo = this.convertTo;
+		const node = this.node;
 
-		const convertToSnippet = builder.getType( convertTo );
-		const nodeSnippet = this.node.build( builder, convertTo );
+		if ( builder.isReference( convertTo ) === false ) {
 
-		return `${ convertToSnippet }( ${ nodeSnippet } )`;
+			const nodeSnippet = node.build( builder, convertTo );
+
+			return builder.format( nodeSnippet, this.getNodeType( builder ), convertTo );
+
+		} else {
+
+			return node.build( builder, convertTo );
+
+		}
 
 	}
 

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

@@ -1,114 +1,42 @@
-import { TempNode } from '../core/TempNode.js';
-import { NodeUtils } from '../core/NodeUtils.js';
+import Node from '../core/Node.js';
 
-const inputs = NodeUtils.elements;
+class JoinNode extends Node {
 
-class JoinNode extends TempNode {
+	constructor( nodes = [] ) {
 
-	constructor( x, y, z, w ) {
+		super();
 
-		super( 'f' );
-
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
-
-	}
-
-	getNumElements() {
-
-		let i = inputs.length;
-
-		while ( i -- ) {
-
-			if ( this[ inputs[ i ] ] !== undefined ) {
-
-				++ i;
-
-				break;
-
-			}
-
-		}
-
-		return Math.max( i, 2 );
-
-	}
-
-	getType( builder ) {
-
-		return builder.getTypeFromLength( this.getNumElements() );
-
-	}
-
-	generate( builder, output ) {
-
-		const type = this.getType( builder ),
-			length = this.getNumElements(),
-			outputs = [];
-
-		for ( let i = 0; i < length; i ++ ) {
-
-			const elm = this[ inputs[ i ] ];
-
-			outputs.push( elm ? elm.build( builder, 'f' ) : '0.0' );
-
-		}
-
-		const code = ( length > 1 ? builder.getConstructorFromLength( length ) : '' ) + '( ' + outputs.join( ', ' ) + ' )';
-
-		return builder.format( code, type, output );
+		this.nodes = nodes;
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
-
-		for ( const prop in source.inputs ) {
+	getNodeType( builder ) {
 
-			this[ prop ] = source.inputs[ prop ];
-
-		}
-
-		return this;
+		return builder.getTypeFromLength( this.nodes.reduce( ( count, cur ) => count + builder.getTypeLength( cur.getNodeType( builder ) ), 0 ) );
 
 	}
 
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
+	generate( builder ) {
 
-			data = this.createJSONNode( meta );
+		const type = this.getNodeType( builder );
+		const nodes = this.nodes;
 
-			data.inputs = {};
+		const snippetValues = [];
 
-			const length = this.getNumElements();
+		for ( let i = 0; i < nodes.length; i ++ ) {
 
-			for ( let i = 0; i < length; i ++ ) {
+			const input = nodes[ i ];
 
-				const elm = this[ inputs[ i ] ];
-
-				if ( elm ) {
-
-					data.inputs[ inputs[ i ] ] = elm.toJSON( meta ).uuid;
-
-				}
-
-			}
+			const inputSnippet = input.build( builder );
 
+			snippetValues.push( inputSnippet );
 
 		}
 
-		return data;
+		return `${ builder.getType( type ) }( ${ snippetValues.join( ', ' ) } )`;
 
 	}
 
 }
 
-JoinNode.prototype.nodeType = 'Join';
-
-export { JoinNode };
+export default JoinNode;

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

@@ -0,0 +1,25 @@
+import TempNode from '../core/TempNode.js';
+import { vec2, vec3, negate, normalize, cross, dot, mul, add, transformedNormalView, positionViewDirection } from '../shadernode/ShaderNodeBaseElements.js';
+
+class MatcapUVNode extends TempNode {
+
+	constructor() {
+
+		super( 'vec2' );
+
+	}
+
+	generate( builder ) {
+
+		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 ) );
+
+	}
+
+}
+
+export default MatcapUVNode;

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

@@ -0,0 +1,32 @@
+import UniformNode from '../core/UniformNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+class MaxMipLevelNode extends UniformNode {
+
+	constructor( texture ) {
+
+		super( 0 );
+
+		this.texture = texture;
+
+		this.updateType = NodeUpdateType.Frame;
+
+	}
+
+	update() {
+
+		const image = this.texture.images ? this.texture.images[ 0 ].image || this.texture.images[ 0 ] : this.texture.image;
+
+		if ( image?.width !== undefined ) {
+
+			const { width, height } = image;
+
+			this.value = Math.log2( Math.max( width, height ) );
+
+		}
+
+	}
+
+}
+
+export default MaxMipLevelNode;

package/examples/jsm/{renderers/nodes → nodes}/utils/OscNode.js

@@ -1,6 +1,6 @@
 import Node from '../core/Node.js';
 import TimerNode from './TimerNode.js';
-import { abs, fract, round, sin, add, sub, mul, PI2 } from '../ShaderNode.js';
+import { abs, fract, round, sin, add, sub, mul } from '../shadernode/ShaderNodeBaseElements.js';
 
 class OscNode extends Node {
 
@@ -33,7 +33,7 @@ class OscNode extends Node {
 
 		if ( method === OscNode.SINE ) {
 
-			outputNode = add( mul( sin( mul( add( timeNode, .75 ), PI2 ) ), .5 ), .5 );
+			outputNode = add( mul( sin( mul( add( timeNode, .75 ), Math.PI * 2 ) ), .5 ), .5 );
 
 		} else if ( method === OscNode.SQUARE ) {
 
@@ -53,6 +53,22 @@ class OscNode extends Node {
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.method = this.method;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.method = data.method;
+
+	}
+
 }
 
 export default OscNode;