super-three 0.168.0 → 0.169.1

package/src/nodes/accessors/BufferNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 
 class BufferNode extends UniformNode {
 
+	static get type() {
+
+		return 'BufferNode';
+
+	}
+
 	constructor( value, bufferType, bufferCount = 0 ) {
 
 		super( value, bufferType );
@@ -31,6 +36,4 @@ class BufferNode extends UniformNode {
 
 export default BufferNode;
 
-BufferNode.type = /*@__PURE__*/ registerNode( 'Buffer', BufferNode );
-
 export const buffer = ( value, type, count ) => nodeObject( new BufferNode( value, type, count ) );

package/src/nodes/accessors/Camera.js

@@ -1,19 +1,13 @@
 import { uniform } from '../core/UniformNode.js';
-import { sharedUniformGroup } from '../core/UniformGroupNode.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
 import { Vector3 } from '../../math/Vector3.js';
 
-const cameraGroup = /*@__PURE__*/ sharedUniformGroup( 'camera' ).onRenderUpdate( () => {
-
-	cameraGroup.needsUpdate = true;
-
-} );
-
-export const cameraNear = /*@__PURE__*/ uniform( 'float' ).label( 'cameraNear' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.near );
-export const cameraFar = /*@__PURE__*/ uniform( 'float' ).label( 'cameraFar' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.far );
-export const cameraLogDepth = /*@__PURE__*/ uniform( 'float' ).label( 'cameraLogDepth' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
-export const cameraProjectionMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrix );
-export const cameraProjectionMatrixInverse = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrixInverse' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrixInverse );
-export const cameraViewMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraViewMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorldInverse );
-export const cameraWorldMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraWorldMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorld );
-export const cameraNormalMatrix = /*@__PURE__*/ uniform( 'mat3' ).label( 'cameraNormalMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.normalMatrix );
-export const cameraPosition = /*@__PURE__*/ uniform( new Vector3() ).label( 'cameraPosition' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera }, self ) => self.value.setFromMatrixPosition( camera.matrixWorld ) );
+export const cameraNear = /*@__PURE__*/ uniform( 'float' ).label( 'cameraNear' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.near );
+export const cameraFar = /*@__PURE__*/ uniform( 'float' ).label( 'cameraFar' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.far );
+export const cameraLogDepth = /*@__PURE__*/ uniform( 'float' ).label( 'cameraLogDepth' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
+export const cameraProjectionMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrix' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrix );
+export const cameraProjectionMatrixInverse = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrixInverse' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrixInverse );
+export const cameraViewMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraViewMatrix' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorldInverse );
+export const cameraWorldMatrix = /*@__PURE__*/ uniform( 'mat4' ).label( 'cameraWorldMatrix' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorld );
+export const cameraNormalMatrix = /*@__PURE__*/ uniform( 'mat3' ).label( 'cameraNormalMatrix' ).setGroup( renderGroup ).onRenderUpdate( ( { camera } ) => camera.normalMatrix );
+export const cameraPosition = /*@__PURE__*/ uniform( new Vector3() ).label( 'cameraPosition' ).setGroup( renderGroup ).onRenderUpdate( ( { camera }, self ) => self.value.setFromMatrixPosition( camera.matrixWorld ) );

package/src/nodes/accessors/ClippingNode.js

@@ -1,5 +1,5 @@
 
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeObject } from '../tsl/TSLBase.js';
 import { positionView } from './Position.js';
 import { diffuseColor, property } from '../core/PropertyNode.js';
@@ -10,6 +10,12 @@ import { uniformArray } from './UniformArrayNode.js';
 
 class ClippingNode extends Node {
 
+	static get type() {
+
+		return 'ClippingNode';
+
+	}
+
 	constructor( scope = ClippingNode.DEFAULT ) {
 
 		super();
@@ -140,8 +146,6 @@ ClippingNode.DEFAULT = 'default';
 
 export default ClippingNode;
 
-ClippingNode.type = /*@__PURE__*/ registerNode( 'Clipping', ClippingNode );
-
 export const clipping = () => nodeObject( new ClippingNode() );
 
 export const clippingAlpha = () => nodeObject( new ClippingNode( ClippingNode.ALPHA_TO_COVERAGE ) );

package/src/nodes/accessors/CubeTextureNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
 import { reflectVector, refractVector } from './ReflectVector.js';
 import { nodeProxy, vec3 } from '../tsl/TSLBase.js';
@@ -7,6 +6,12 @@ import { CubeReflectionMapping, CubeRefractionMapping, WebGPUCoordinateSystem }
 
 class CubeTextureNode extends TextureNode {
 
+	static get type() {
+
+		return 'CubeTextureNode';
+
+	}
+
 	constructor( value, uvNode = null, levelNode = null, biasNode = null ) {
 
 		super( value, uvNode, levelNode, biasNode );
@@ -71,6 +76,4 @@ class CubeTextureNode extends TextureNode {
 
 export default CubeTextureNode;
 
-CubeTextureNode.type = /*@__PURE__*/ registerNode( 'CubeTexture', CubeTextureNode );
-
 export const cubeTexture = /*@__PURE__*/ nodeProxy( CubeTextureNode );

package/src/nodes/accessors/InstanceNode.js

@@ -1,9 +1,9 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { varyingProperty } from '../core/PropertyNode.js';
 import { instancedBufferAttribute, instancedDynamicBufferAttribute } from './BufferAttributeNode.js';
-import { normalLocal } from './Normal.js';
+import { normalLocal, transformNormal } from './Normal.js';
 import { positionLocal } from './Position.js';
-import { nodeProxy, vec3, mat3, mat4 } from '../tsl/TSLBase.js';
+import { nodeProxy, vec3, mat4 } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { buffer } from '../accessors/BufferNode.js';
 import { instanceIndex } from '../core/IndexNode.js';
@@ -14,6 +14,12 @@ import { DynamicDrawUsage } from '../../constants.js';
 
 class InstanceNode extends Node {
 
+	static get type() {
+
+		return 'InstanceNode';
+
+	}
+
 	constructor( instanceMesh ) {
 
 		super( 'void' );
@@ -46,7 +52,7 @@ class InstanceNode extends Node {
 
 			if ( instanceMesh.count <= 1000 ) {
 
-				instanceMatrixNode = buffer( instanceAttribute.array, 'mat4', instanceMesh.count ).element( instanceIndex );
+				instanceMatrixNode = buffer( instanceAttribute.array, 'mat4', Math.max( instanceMesh.count, 1 ) ).element( instanceIndex );
 
 			} else {
 
@@ -97,11 +103,7 @@ class InstanceNode extends Node {
 
 		if ( builder.hasGeometryAttribute( 'normal' ) ) {
 
-			const m = mat3( instanceMatrixNode );
-
-			const transformedNormal = normalLocal.div( vec3( m[ 0 ].dot( m[ 0 ] ), m[ 1 ].dot( m[ 1 ] ), m[ 2 ].dot( m[ 2 ] ) ) );
-
-			const instanceNormal = m.mul( transformedNormal ).xyz;
+			const instanceNormal = transformNormal( normalLocal, instanceMatrixNode );
 
 			// ASSIGNS
 
@@ -139,6 +141,4 @@ class InstanceNode extends Node {
 
 export default InstanceNode;
 
-InstanceNode.type = /*@__PURE__*/ registerNode( 'Instance', InstanceNode );
-
 export const instance = /*@__PURE__*/ nodeProxy( InstanceNode );

package/src/nodes/accessors/InstancedPointsMaterialNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import MaterialNode from './MaterialNode.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
 class InstancedPointsMaterialNode extends MaterialNode {
 
+	static get type() {
+
+		return 'InstancedPointsMaterialNode';
+
+	}
+
 	setup( /*builder*/ ) {
 
 		return this.getFloat( this.scope );
@@ -16,6 +21,4 @@ InstancedPointsMaterialNode.POINT_WIDTH = 'pointWidth';
 
 export default InstancedPointsMaterialNode;
 
-InstancedPointsMaterialNode.type = /*@__PURE__*/ registerNode( 'InstancedPointsMaterial', InstancedPointsMaterialNode );
-
 export const materialPointWidth = /*@__PURE__*/ nodeImmutable( InstancedPointsMaterialNode, InstancedPointsMaterialNode.POINT_WIDTH );

package/src/nodes/accessors/Lights.js

@@ -0,0 +1,51 @@
+import { uniform } from '../core/UniformNode.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { cameraViewMatrix } from './Camera.js';
+
+let uniformsLib;
+
+function getLightData( light ) {
+
+	uniformsLib = uniformsLib || new WeakMap();
+
+	let uniforms = uniformsLib.get( light );
+
+	if ( uniforms === undefined ) uniformsLib.set( light, uniforms = {} );
+
+	return uniforms;
+
+}
+
+export function lightPosition( light ) {
+
+	const data = getLightData( light );
+
+	return data.position || ( data.position = uniform( new Vector3() ).setGroup( renderGroup ).onRenderUpdate( ( _, self ) => self.value.setFromMatrixPosition( light.matrixWorld ) ) );
+
+}
+
+export function lightTargetPosition( light ) {
+
+	const data = getLightData( light );
+
+	return data.targetPosition || ( data.targetPosition = uniform( new Vector3() ).setGroup( renderGroup ).onRenderUpdate( ( _, self ) => self.value.setFromMatrixPosition( light.target.matrixWorld ) ) );
+
+}
+
+export function lightViewPosition( light ) {
+
+	const data = getLightData( light );
+
+	return data.viewPosition || ( data.viewPosition = uniform( new Vector3() ).setGroup( renderGroup ).onRenderUpdate( ( { camera }, self ) => {
+
+		self.value = self.value || new Vector3();
+		self.value.setFromMatrixPosition( light.matrixWorld );
+
+		self.value.applyMatrix4( camera.matrixWorldInverse );
+
+	} ) );
+
+}
+
+export const lightTargetDirection = ( light ) => cameraViewMatrix.transformDirection( lightPosition( light ).sub( lightTargetPosition( light ) ) );

package/src/nodes/accessors/MaterialNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { reference } from './ReferenceNode.js';
 import { materialReference } from './MaterialReferenceNode.js';
 import { normalView } from './Normal.js';
@@ -13,6 +13,12 @@ const _propertyCache = new Map();
 
 class MaterialNode extends Node {
 
+	static get type() {
+
+		return 'MaterialNode';
+
+	}
+
 	constructor( scope ) {
 
 		super();
@@ -178,6 +184,7 @@ class MaterialNode extends Node {
 			if ( material.normalMap ) {
 
 				node = normalMap( this.getTexture( 'normal' ), this.getCache( 'normalScale', 'vec2' ) );
+				node.normalMapType = material.normalMapType;
 
 			} else if ( material.bumpMap ) {
 
@@ -384,8 +391,6 @@ MaterialNode.AO_MAP = 'ao';
 
 export default MaterialNode;
 
-MaterialNode.type = /*@__PURE__*/ registerNode( 'Material', MaterialNode );
-
 export const materialAlphaTest = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
 export const materialColor = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.COLOR );
 export const materialShininess = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.SHININESS );
@@ -425,7 +430,6 @@ export const materialPointWidth = /*@__PURE__*/ nodeImmutable( MaterialNode, Mat
 export const materialDispersion = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.DISPERSION );
 export const materialLightMap = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.LIGHT_MAP );
 export const materialAOMap = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.AO_MAP );
-export const materialRefractionRatio = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.REFRACTION_RATIO );
 export const materialAnisotropyVector = /*@__PURE__*/ uniform( new Vector2() ).onReference( function ( frame ) {
 
 	return frame.material;

package/src/nodes/accessors/MaterialReferenceNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import ReferenceNode from './ReferenceNode.js';
 //import { renderGroup } from '../core/UniformGroupNode.js';
 //import { NodeUpdateType } from '../core/constants.js';
@@ -6,6 +5,12 @@ import { nodeObject } from '../tsl/TSLBase.js';
 
 class MaterialReferenceNode extends ReferenceNode {
 
+	static get type() {
+
+		return 'MaterialReferenceNode';
+
+	}
+
 	constructor( property, inputType, material = null ) {
 
 		super( property, inputType, material );
@@ -38,6 +43,4 @@ class MaterialReferenceNode extends ReferenceNode {
 
 export default MaterialReferenceNode;
 
-MaterialReferenceNode.type = /*@__PURE__*/ registerNode( 'MaterialReference', MaterialReferenceNode );
-
 export const materialReference = ( name, type, material ) => nodeObject( new MaterialReferenceNode( name, type, material ) );

package/src/nodes/accessors/ModelNode.js

@@ -1,13 +1,20 @@
-import { registerNode } from '../core/Node.js';
 import Object3DNode from './Object3DNode.js';
-import { nodeImmutable } from '../tsl/TSLBase.js';
+import { Fn, nodeImmutable } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
 
 import { Matrix4 } from '../../math/Matrix4.js';
+import { cameraViewMatrix } from './Camera.js';
+import { Matrix3 } from '../../math/Matrix3.js';
 
 class ModelNode extends Object3DNode {
 
-	constructor( scope = ModelNode.VIEW_MATRIX ) {
+	static get type() {
+
+		return 'ModelNode';
+
+	}
+
+	constructor( scope ) {
 
 		super( scope );
 
@@ -25,13 +32,41 @@ class ModelNode extends Object3DNode {
 
 export default ModelNode;
 
-ModelNode.type = /*@__PURE__*/ registerNode( 'Model', ModelNode );
-
 export const modelDirection = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.DIRECTION );
-export const modelViewMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX ).label( 'modelViewMatrix' ).toVar( 'ModelViewMatrix' );
-export const modelNormalMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
 export const modelWorldMatrix = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
 export const modelPosition = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.POSITION );
 export const modelScale = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.SCALE );
 export const modelViewPosition = /*@__PURE__*/ nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
+export const modelNormalMatrix = /*@__PURE__*/ uniform( new Matrix3() ).onObjectUpdate( ( { object }, self ) => self.value.getNormalMatrix( object.matrixWorld ) );
 export const modelWorldMatrixInverse = /*@__PURE__*/ uniform( new Matrix4() ).onObjectUpdate( ( { object }, self ) => self.value.copy( object.matrixWorld ).invert() );
+export const modelViewMatrix = /*@__PURE__*/ cameraViewMatrix.mul( modelWorldMatrix ).toVar( 'modelViewMatrix' );
+
+export const highPrecisionModelViewMatrix = /*@__PURE__*/ ( Fn( ( builder ) => {
+
+	builder.context.isHighPrecisionModelViewMatrix = true;
+
+	return uniform( 'mat4' ).onObjectUpdate( ( { object, camera } ) => {
+
+		return object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
+
+	} );
+
+} ).once() )().toVar( 'highPrecisionModelViewMatrix' );
+
+export const highPrecisionModelNormalViewMatrix = /*@__PURE__*/ ( Fn( ( builder ) => {
+
+	const isHighPrecisionModelViewMatrix = builder.context.isHighPrecisionModelViewMatrix;
+
+	return uniform( 'mat3' ).onObjectUpdate( ( { object, camera } ) => {
+
+		if ( isHighPrecisionModelViewMatrix !== true ) {
+
+			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
+
+		}
+
+		return object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
+
+	} );
+
+} ).once() )().toVar( 'highPrecisionModelNormalMatrix' );

package/src/nodes/accessors/ModelViewProjectionNode.js

@@ -1,12 +1,17 @@
-import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { cameraProjectionMatrix } from './Camera.js';
-import { modelViewMatrix } from './ModelNode.js';
 import { positionLocal } from './Position.js';
 import { nodeProxy, varying } from '../tsl/TSLBase.js';
+import { modelViewMatrix } from './ModelNode.js';
 
 class ModelViewProjectionNode extends TempNode {
 
+	static get type() {
+
+		return 'ModelViewProjectionNode';
+
+	}
+
 	constructor( positionNode = null ) {
 
 		super( 'vec4' );
@@ -24,8 +29,9 @@ class ModelViewProjectionNode extends TempNode {
 		}
 
 		const position = this.positionNode || positionLocal;
+		const viewMatrix = builder.renderer.nodes.modelViewMatrix || modelViewMatrix;
 
-		return cameraProjectionMatrix.mul( modelViewMatrix ).mul( position );
+		return cameraProjectionMatrix.mul( viewMatrix ).mul( position );
 
 	}
 
@@ -33,6 +39,4 @@ class ModelViewProjectionNode extends TempNode {
 
 export default ModelViewProjectionNode;
 
-ModelViewProjectionNode.type = /*@__PURE__*/ registerNode( 'ModelViewProjection', ModelViewProjectionNode );
-
 export const modelViewProjection = /*@__PURE__*/ nodeProxy( ModelViewProjectionNode );

package/src/nodes/accessors/MorphNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { float, nodeProxy, Fn } from '../tsl/TSLBase.js';
 import { uniform } from '../core/UniformNode.js';
@@ -160,6 +160,12 @@ function getEntry( geometry ) {
 
 class MorphNode extends Node {
 
+	static get type() {
+
+		return 'MorphNode';
+
+	}
+
 	constructor( mesh ) {
 
 		super( 'void' );
@@ -254,6 +260,4 @@ class MorphNode extends Node {
 
 export default MorphNode;
 
-MorphNode.type = /*@__PURE__*/ registerNode( 'Morph', MorphNode );
-
 export const morphReference = /*@__PURE__*/ nodeProxy( MorphNode );

package/src/nodes/accessors/Normal.js

@@ -1,7 +1,7 @@
 import { attribute } from '../core/AttributeNode.js';
 import { cameraViewMatrix } from './Camera.js';
-import { modelNormalMatrix } from './ModelNode.js';
-import { vec3 } from '../tsl/TSLBase.js';
+import { modelNormalMatrix, modelWorldMatrix } from './ModelNode.js';
+import { mat3, vec3 } from '../tsl/TSLBase.js';
 import { positionView } from './Position.js';
 import { Fn, varying } from '../tsl/TSLBase.js';
 import { faceDirection } from '../display/FrontFacingNode.js';
@@ -24,8 +24,6 @@ export const normalLocal = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 export const normalFlat = /*@__PURE__*/ positionView.dFdx().cross( positionView.dFdy() ).normalize().toVar( 'normalFlat' );
 
-let normalViewVarying = null;
-
 export const normalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	let node;
@@ -36,7 +34,7 @@ export const normalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	} else {
 
-		node = normalViewVarying || ( normalViewVarying = varying( modelNormalMatrix.mul( normalLocal ), 'v_normalView' ).normalize() );
+		node = varying( transformNormalToView( normalLocal ), 'v_normalView' ).normalize();
 
 	}
 
@@ -53,10 +51,38 @@ export const transformedNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 }, 'vec3' ).once() )().mul( faceDirection ).toVar( 'transformedNormalView' );
 
 
-export const transformedNormalWorld = /*@__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedNormalWorld' );
+export const transformedNormalWorld = /*@__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).toVar( 'transformedNormalWorld' );
 
 export const transformedClearcoatNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
 	return builder.context.setupClearcoatNormal();
 
 }, 'vec3' ).once() )().mul( faceDirection ).toVar( 'transformedClearcoatNormalView' );
+
+export const transformNormal = /*@__PURE__*/ Fn( ( [ normal, matrix = modelWorldMatrix ] ) => {
+
+	const m = mat3( matrix );
+
+	const transformedNormal = normal.div( vec3( m[ 0 ].dot( m[ 0 ] ), m[ 1 ].dot( m[ 1 ] ), m[ 2 ].dot( m[ 2 ] ) ) );
+
+	return m.mul( transformedNormal ).xyz;
+
+} );
+
+export const transformNormalToView = /*@__PURE__*/ Fn( ( [ normal ], builder ) => {
+
+	const modelNormalViewMatrix = builder.renderer.nodes.modelNormalViewMatrix;
+
+	if ( modelNormalViewMatrix !== null ) {
+
+		return modelNormalViewMatrix.transformDirection( normal );
+
+	}
+
+	//
+
+	const transformedNormal = modelNormalMatrix.mul( normal );
+
+	return cameraViewMatrix.transformDirection( transformedNormal );
+
+} );

package/src/nodes/accessors/Object3DNode.js

@@ -1,4 +1,4 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
 import UniformNode from '../core/UniformNode.js';
 import { nodeProxy } from '../tsl/TSLBase.js';
@@ -7,7 +7,13 @@ import { Vector3 } from '../../math/Vector3.js';
 
 class Object3DNode extends Node {
 
-	constructor( scope = Object3DNode.VIEW_MATRIX, object3d = null ) {
+	static get type() {
+
+		return 'Object3DNode';
+
+	}
+
+	constructor( scope, object3d = null ) {
 
 		super();
 
@@ -24,14 +30,10 @@ class Object3DNode extends Node {
 
 		const scope = this.scope;
 
-		if ( scope === Object3DNode.WORLD_MATRIX || scope === Object3DNode.VIEW_MATRIX ) {
+		if ( scope === Object3DNode.WORLD_MATRIX ) {
 
 			return 'mat4';
 
-		} else if ( scope === Object3DNode.NORMAL_MATRIX ) {
-
-			return 'mat3';
-
 		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION || scope === Object3DNode.DIRECTION || scope === Object3DNode.SCALE ) {
 
 			return 'vec3';
@@ -46,15 +48,7 @@ class Object3DNode extends Node {
 		const uniformNode = this._uniformNode;
 		const scope = this.scope;
 
-		if ( scope === Object3DNode.VIEW_MATRIX ) {
-
-			uniformNode.value = object.modelViewMatrix;
-
-		} else if ( scope === Object3DNode.NORMAL_MATRIX ) {
-
-			uniformNode.value = object.normalMatrix;
-
-		} else if ( scope === Object3DNode.WORLD_MATRIX ) {
+		if ( scope === Object3DNode.WORLD_MATRIX ) {
 
 			uniformNode.value = object.matrixWorld;
 
@@ -93,14 +87,10 @@ class Object3DNode extends Node {
 
 		const scope = this.scope;
 
-		if ( scope === Object3DNode.WORLD_MATRIX || scope === Object3DNode.VIEW_MATRIX ) {
+		if ( scope === Object3DNode.WORLD_MATRIX ) {
 
 			this._uniformNode.nodeType = 'mat4';
 
-		} else if ( scope === Object3DNode.NORMAL_MATRIX ) {
-
-			this._uniformNode.nodeType = 'mat3';
-
 		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION || scope === Object3DNode.DIRECTION || scope === Object3DNode.SCALE ) {
 
 			this._uniformNode.nodeType = 'vec3';
@@ -129,8 +119,6 @@ class Object3DNode extends Node {
 
 }
 
-Object3DNode.VIEW_MATRIX = 'viewMatrix';
-Object3DNode.NORMAL_MATRIX = 'normalMatrix';
 Object3DNode.WORLD_MATRIX = 'worldMatrix';
 Object3DNode.POSITION = 'position';
 Object3DNode.SCALE = 'scale';
@@ -139,11 +127,7 @@ Object3DNode.DIRECTION = 'direction';
 
 export default Object3DNode;
 
-Object3DNode.type = /*@__PURE__*/ registerNode( 'Object3D', Object3DNode );
-
 export const objectDirection = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.DIRECTION );
-export const objectViewMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.VIEW_MATRIX );
-export const objectNormalMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.NORMAL_MATRIX );
 export const objectWorldMatrix = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.WORLD_MATRIX );
 export const objectPosition = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.POSITION );
 export const objectScale = /*@__PURE__*/ nodeProxy( Object3DNode, Object3DNode.SCALE );

package/src/nodes/accessors/PointUVNode.js

@@ -1,8 +1,14 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { nodeImmutable } from '../tsl/TSLBase.js';
 
 class PointUVNode extends Node {
 
+	static get type() {
+
+		return 'PointUVNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec2' );
@@ -21,6 +27,4 @@ class PointUVNode extends Node {
 
 export default PointUVNode;
 
-PointUVNode.type = /*@__PURE__*/ registerNode( 'PointUV', PointUVNode );
-
 export const pointUV = /*@__PURE__*/ nodeImmutable( PointUVNode );