super-three 0.168.0 → 0.169.0

package/src/nodes/lighting/AnalyticLightNode.js

@@ -1,19 +1,22 @@
-import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { uniform } from '../core/UniformNode.js';
-import { float, vec2, vec3, vec4 } from '../tsl/TSLBase.js';
+import { float, vec2, vec3, vec4, If, int, Fn } from '../tsl/TSLBase.js';
 import { reference } from '../accessors/ReferenceNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { positionWorld } from '../accessors/Position.js';
 import { normalWorld } from '../accessors/Normal.js';
-import { mix, fract } from '../math/MathNode.js';
-import { add } from '../math/OperatorNode.js';
+import { mix, fract, step, max, clamp, sqrt } from '../math/MathNode.js';
+import { add, sub } from '../math/OperatorNode.js';
 import { Color } from '../../math/Color.js';
 import { DepthTexture } from '../../textures/DepthTexture.js';
-import { Fn } from '../tsl/TSLBase.js';
-import { LessCompare, WebGPUCoordinateSystem } from '../../constants.js';
 import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+import QuadMesh from '../../renderers/common/QuadMesh.js';
+import { Loop } from '../utils/LoopNode.js';
+import { screenCoordinate } from '../display/ScreenNode.js';
+import { HalfFloatType, LessCompare, RGFormat, VSMShadowMap, WebGPUCoordinateSystem } from '../../constants.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+import { hash } from '../core/NodeUtils.js';
 
 const BasicShadowMap = Fn( ( { depthTexture, shadowCoord } ) => {
 
@@ -25,8 +28,8 @@ const PCFShadowMap = Fn( ( { depthTexture, shadowCoord, shadow } ) => {
 
 	const depthCompare = ( uv, compare ) => texture( depthTexture, uv ).compare( compare );
 
-	const mapSize = reference( 'mapSize', 'vec2', shadow );
-	const radius = reference( 'radius', 'float', shadow );
+	const mapSize = reference( 'mapSize', 'vec2', shadow ).setGroup( renderGroup );
+	const radius = reference( 'radius', 'float', shadow ).setGroup( renderGroup );
 
 	const texelSize = vec2( 1 ).div( mapSize );
 	const dx0 = texelSize.x.negate().mul( radius );
@@ -64,7 +67,7 @@ const PCFSoftShadowMap = Fn( ( { depthTexture, shadowCoord, shadow } ) => {
 
 	const depthCompare = ( uv, compare ) => texture( depthTexture, uv ).compare( compare );
 
-	const mapSize = reference( 'mapSize', 'vec2', shadow );
+	const mapSize = reference( 'mapSize', 'vec2', shadow ).setGroup( renderGroup );
 
 	const texelSize = vec2( 1 ).div( mapSize );
 	const dx = texelSize.x;
@@ -116,14 +119,97 @@ const PCFSoftShadowMap = Fn( ( { depthTexture, shadowCoord, shadow } ) => {
 
 } );
 
-const shadowFilterLib = [ BasicShadowMap, PCFShadowMap, PCFSoftShadowMap ];
+// VSM
+
+const VSMShadowMapNode = Fn( ( { depthTexture, shadowCoord } ) => {
+
+	const occlusion = float( 1 ).toVar();
+
+	const distribution = texture( depthTexture ).uv( shadowCoord.xy ).rg;
+
+	const hardShadow = step( shadowCoord.z, distribution.x );
+
+	If( hardShadow.notEqual( float( 1.0 ) ), () => {
+
+		const distance = shadowCoord.z.sub( distribution.x );
+		const variance = max( 0, distribution.y.mul( distribution.y ) );
+		let softnessProbability = variance.div( variance.add( distance.mul( distance ) ) ); // Chebeyshevs inequality
+		softnessProbability = clamp( sub( softnessProbability, 0.3 ).div( 0.95 - 0.3 ) );
+		occlusion.assign( clamp( max( hardShadow, softnessProbability ) ) );
+
+	} );
+
+	return occlusion;
+
+} );
+
+const VSMPassVertical = Fn( ( { samples, radius, size, shadowPass } ) => {
+
+	const mean = float( 0 ).toVar();
+	const squaredMean = float( 0 ).toVar();
+
+	const uvStride = samples.lessThanEqual( float( 1 ) ).select( float( 0 ), float( 2 ).div( samples.sub( 1 ) ) );
+	const uvStart = samples.lessThanEqual( float( 1 ) ).select( float( 0 ), float( - 1 ) );
+
+	Loop( { start: int( 0 ), end: int( samples ), type: 'int', condition: '<' }, ( { i } ) => {
+
+		const uvOffset = uvStart.add( float( i ).mul( uvStride ) );
+
+		const depth = shadowPass.uv( add( screenCoordinate.xy, vec2( 0, uvOffset ).mul( radius ) ).div( size ) ).x;
+		mean.addAssign( depth );
+		squaredMean.addAssign( depth.mul( depth ) );
+
+	} );
+
+	mean.divAssign( samples );
+	squaredMean.divAssign( samples );
+
+	const std_dev = sqrt( squaredMean.sub( mean.mul( mean ) ) );
+	return vec2( mean, std_dev );
+
+} );
+
+const VSMPassHorizontal = Fn( ( { samples, radius, size, shadowPass } ) => {
+
+	const mean = float( 0 ).toVar();
+	const squaredMean = float( 0 ).toVar();
+
+	const uvStride = samples.lessThanEqual( float( 1 ) ).select( float( 0 ), float( 2 ).div( samples.sub( 1 ) ) );
+	const uvStart = samples.lessThanEqual( float( 1 ) ).select( float( 0 ), float( - 1 ) );
+
+	Loop( { start: int( 0 ), end: int( samples ), type: 'int', condition: '<' }, ( { i } ) => {
+
+		const uvOffset = uvStart.add( float( i ).mul( uvStride ) );
+
+		const distribution = shadowPass.uv( add( screenCoordinate.xy, vec2( uvOffset, 0 ).mul( radius ) ).div( size ) );
+		mean.addAssign( distribution.x );
+		squaredMean.addAssign( add( distribution.y.mul( distribution.y ), distribution.x.mul( distribution.x ) ) );
+
+	} );
+
+	mean.divAssign( samples );
+	squaredMean.divAssign( samples );
+
+	const std_dev = sqrt( squaredMean.sub( mean.mul( mean ) ) );
+	return vec2( mean, std_dev );
+
+} );
+
+const _shadowFilterLib = [ BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMapNode ];
 
 //
 
-let overrideMaterial = null;
+let _overrideMaterial = null;
+const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
 class AnalyticLightNode extends LightingNode {
 
+	static get type() {
+
+		return 'AnalyticLightNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super();
@@ -133,7 +219,7 @@ class AnalyticLightNode extends LightingNode {
 		this.light = light;
 
 		this.color = new Color();
-		this.colorNode = uniform( this.color );
+		this.colorNode = uniform( this.color ).setGroup( renderGroup );
 
 		this.baseColorNode = null;
 
@@ -141,13 +227,19 @@ class AnalyticLightNode extends LightingNode {
 		this.shadowNode = null;
 		this.shadowColorNode = null;
 
+		this.vsmShadowMapVertical = null;
+		this.vsmShadowMapHorizontal = null;
+
+		this.vsmMaterialVertical = null;
+		this.vsmMaterialHorizontal = null;
+
 		this.isAnalyticLightNode = true;
 
 	}
 
 	getCacheKey() {
 
-		return super.getCacheKey() + '-' + ( this.light.id + '-' + ( this.light.castShadow ? '1' : '0' ) );
+		return hash( super.getCacheKey(), this.light.id, this.light.castShadow ? 1 : 0 );
 
 	}
 
@@ -161,37 +253,67 @@ class AnalyticLightNode extends LightingNode {
 
 		const { object, renderer } = builder;
 
+		if ( renderer.shadowMap.enabled === false ) return;
+
 		let shadowColorNode = this.shadowColorNode;
 
 		if ( shadowColorNode === null ) {
 
-			if ( overrideMaterial === null ) {
+			if ( _overrideMaterial === null ) {
 
-				overrideMaterial = new NodeMaterial();
-				overrideMaterial.fragmentNode = vec4( 0, 0, 0, 1 );
-				overrideMaterial.isShadowNodeMaterial = true; // Use to avoid other overrideMaterial override material.fragmentNode unintentionally when using material.shadowNode
-				overrideMaterial.name = 'ShadowMaterial';
+				_overrideMaterial = new NodeMaterial();
+				_overrideMaterial.fragmentNode = vec4( 0, 0, 0, 1 );
+				_overrideMaterial.isShadowNodeMaterial = true; // Use to avoid other overrideMaterial override material.fragmentNode unintentionally when using material.shadowNode
+				_overrideMaterial.name = 'ShadowMaterial';
 
 			}
 
+			const shadowMapType = renderer.shadowMap.type;
+			const shadow = this.light.shadow;
+
 			const depthTexture = new DepthTexture();
 			depthTexture.compareFunction = LessCompare;
 
-			const shadow = this.light.shadow;
 			const shadowMap = builder.createRenderTarget( shadow.mapSize.width, shadow.mapSize.height );
 			shadowMap.depthTexture = depthTexture;
 
 			shadow.camera.updateProjectionMatrix();
 
+			// VSM
+
+			if ( shadowMapType === VSMShadowMap ) {
+
+				depthTexture.compareFunction = null; // VSM does not use textureSampleCompare()/texture2DCompare()
+
+				this.vsmShadowMapVertical = builder.createRenderTarget( shadow.mapSize.width, shadow.mapSize.height, { format: RGFormat, type: HalfFloatType } );
+				this.vsmShadowMapHorizontal = builder.createRenderTarget( shadow.mapSize.width, shadow.mapSize.height, { format: RGFormat, type: HalfFloatType } );
+
+				const shadowPassVertical = texture( depthTexture );
+				const shadowPassHorizontal = texture( this.vsmShadowMapVertical.texture );
+
+				const samples = reference( 'blurSamples', 'float', shadow ).setGroup( renderGroup );
+				const radius = reference( 'radius', 'float', shadow ).setGroup( renderGroup );
+				const size = reference( 'mapSize', 'vec2', shadow ).setGroup( renderGroup );
+
+				let material = this.vsmMaterialVertical || ( this.vsmMaterialVertical = new NodeMaterial() );
+				material.fragmentNode = VSMPassVertical( { samples, radius, size, shadowPass: shadowPassVertical } ).context( builder.getSharedContext() );
+				material.name = 'VSMVertical';
+
+				material = this.vsmMaterialHorizontal || ( this.vsmMaterialHorizontal = new NodeMaterial() );
+				material.fragmentNode = VSMPassHorizontal( { samples, radius, size, shadowPass: shadowPassHorizontal } ).context( builder.getSharedContext() );
+				material.name = 'VSMHorizontal';
+
+			}
+
 			//
 
-			const shadowIntensity = reference( 'intensity', 'float', shadow );
-			const bias = reference( 'bias', 'float', shadow );
-			const normalBias = reference( 'normalBias', 'float', shadow );
+			const shadowIntensity = reference( 'intensity', 'float', shadow ).setGroup( renderGroup );
+			const bias = reference( 'bias', 'float', shadow ).setGroup( renderGroup );
+			const normalBias = reference( 'normalBias', 'float', shadow ).setGroup( renderGroup );
 
 			const position = object.material.shadowPositionNode || positionWorld;
 
-			let shadowCoord = uniform( shadow.matrix ).mul( position.add( normalWorld.mul( normalBias ) ) );
+			let shadowCoord = uniform( shadow.matrix ).setGroup( renderGroup ).mul( position.add( normalWorld.mul( normalBias ) ) );
 			shadowCoord = shadowCoord.xyz.div( shadowCoord.w );
 
 			let coordZ = shadowCoord.z.add( bias );
@@ -216,7 +338,7 @@ class AnalyticLightNode extends LightingNode {
 
 			//
 
-			const filterFn = shadow.filterNode || shadowFilterLib[ renderer.shadowMap.type ] || null;
+			const filterFn = shadow.filterNode || _shadowFilterLib[ renderer.shadowMap.type ] || null;
 
 			if ( filterFn === null ) {
 
@@ -225,9 +347,10 @@ class AnalyticLightNode extends LightingNode {
 			}
 
 			const shadowColor = texture( shadowMap.texture, shadowCoord );
-			const shadowNode = frustumTest.select( filterFn( { depthTexture, shadowCoord, shadow } ), float( 1 ) );
+			const shadowNode = frustumTest.select( filterFn( { depthTexture: ( shadowMapType === VSMShadowMap ) ? this.vsmShadowMapHorizontal.texture : depthTexture, shadowCoord, shadow } ), float( 1 ) );
 
 			this.shadowMap = shadowMap;
+			this.light.shadow.map = shadowMap;
 
 			this.shadowNode = shadowNode;
 			this.shadowColorNode = shadowColorNode = this.colorNode.mul( mix( 1, shadowNode.rgb.mix( shadowColor, 1 ), shadowIntensity.mul( shadowColor.a ) ) );
@@ -269,13 +392,14 @@ class AnalyticLightNode extends LightingNode {
 		const { shadowMap, light } = this;
 		const { renderer, scene, camera } = frame;
 
+		const shadowType = renderer.shadowMap.type;
 
 		const depthVersion = shadowMap.depthTexture.version;
 		this._depthVersionCached = depthVersion;
 
 		const currentOverrideMaterial = scene.overrideMaterial;
 
-		scene.overrideMaterial = overrideMaterial;
+		scene.overrideMaterial = _overrideMaterial;
 
 		shadowMap.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
 
@@ -287,7 +411,7 @@ class AnalyticLightNode extends LightingNode {
 
 		renderer.setRenderObjectFunction( ( object, ...params ) => {
 
-			if ( object.castShadow === true ) {
+			if ( object.castShadow === true || ( object.receiveShadow && shadowType === VSMShadowMap ) ) {
 
 				renderer.renderObject( object, ...params );
 
@@ -298,18 +422,64 @@ class AnalyticLightNode extends LightingNode {
 		renderer.setRenderTarget( shadowMap );
 		renderer.render( scene, light.shadow.camera );
 
-		renderer.setRenderTarget( currentRenderTarget );
 		renderer.setRenderObjectFunction( currentRenderObjectFunction );
 
+		// vsm blur pass
+
+		if ( light.isPointLight !== true && shadowType === VSMShadowMap ) {
+
+			this.vsmPass( frame, light );
+
+		}
+
+		renderer.setRenderTarget( currentRenderTarget );
+
 		scene.overrideMaterial = currentOverrideMaterial;
 
 	}
 
+	vsmPass( frame, light ) {
+
+		const { renderer } = frame;
+
+		this.vsmShadowMapVertical.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
+		this.vsmShadowMapHorizontal.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
+
+		renderer.setRenderTarget( this.vsmShadowMapVertical );
+		_quadMesh.material = this.vsmMaterialVertical;
+		_quadMesh.render( renderer );
+
+		renderer.setRenderTarget( this.vsmShadowMapHorizontal );
+		_quadMesh.material = this.vsmMaterialHorizontal;
+		_quadMesh.render( renderer );
+
+	}
+
 	disposeShadow() {
 
 		this.shadowMap.dispose();
 		this.shadowMap = null;
 
+		if ( this.vsmShadowMapVertical !== null ) {
+
+			this.vsmShadowMapVertical.dispose();
+			this.vsmShadowMapVertical = null;
+
+			this.vsmMaterialVertical.dispose();
+			this.vsmMaterialVertical = null;
+
+		}
+
+		if ( this.vsmShadowMapHorizontal !== null ) {
+
+			this.vsmShadowMapHorizontal.dispose();
+			this.vsmShadowMapHorizontal = null;
+
+			this.vsmMaterialHorizontal.dispose();
+			this.vsmMaterialHorizontal = null;
+
+		}
+
 		this.shadowNode = null;
 		this.shadowColorNode = null;
 
@@ -350,5 +520,3 @@ class AnalyticLightNode extends LightingNode {
 }
 
 export default AnalyticLightNode;
-
-AnalyticLightNode.type = /*@__PURE__*/ registerNode( 'AnalyticLight', AnalyticLightNode );

package/src/nodes/lighting/BasicEnvironmentNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 import { cubeMapNode } from '../utils/CubeMapNode.js';
 
 class BasicEnvironmentNode extends LightingNode {
 
+	static get type() {
+
+		return 'BasicEnvironmentNode';
+
+	}
+
 	constructor( envNode = null ) {
 
 		super();
@@ -23,5 +28,3 @@ class BasicEnvironmentNode extends LightingNode {
 }
 
 export default BasicEnvironmentNode;
-
-BasicEnvironmentNode.type = /*@__PURE__*/ registerNode( 'BasicEnvironment', BasicEnvironmentNode );

package/src/nodes/lighting/BasicLightMapNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 import { float } from '../tsl/TSLBase.js';
 
 class BasicLightMapNode extends LightingNode {
 
+	static get type() {
+
+		return 'BasicLightMapNode';
+
+	}
+
 	constructor( lightMapNode = null ) {
 
 		super();
@@ -25,5 +30,3 @@ class BasicLightMapNode extends LightingNode {
 }
 
 export default BasicLightMapNode;
-
-BasicLightMapNode.type = /*@__PURE__*/ registerNode( 'BasicLightMap', BasicLightMapNode );

package/src/nodes/lighting/DirectionalLightNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
-import { lightTargetDirection } from './LightNode.js';
+import { lightTargetDirection } from '../accessors/Lights.js';
 
 class DirectionalLightNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'DirectionalLightNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super( light );
@@ -31,5 +36,3 @@ class DirectionalLightNode extends AnalyticLightNode {
 }
 
 export default DirectionalLightNode;
-
-DirectionalLightNode.type = /*@__PURE__*/ registerNode( 'DirectionalLight', DirectionalLightNode );

package/src/nodes/lighting/EnvironmentNode.js

@@ -1,4 +1,3 @@
-import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 import { cache } from '../core/CacheNode.js';
 import { roughness, clearcoatRoughness } from '../core/PropertyNode.js';
@@ -14,6 +13,12 @@ const _envNodeCache = new WeakMap();
 
 class EnvironmentNode extends LightingNode {
 
+	static get type() {
+
+		return 'EnvironmentNode';
+
+	}
+
 	constructor( envNode = null ) {
 
 		super();
@@ -85,8 +90,6 @@ class EnvironmentNode extends LightingNode {
 
 export default EnvironmentNode;
 
-EnvironmentNode.type = /*@__PURE__*/ registerNode( 'Environment', EnvironmentNode );
-
 const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
 	let reflectVec = null;

package/src/nodes/lighting/HemisphereLightNode.js

@@ -1,22 +1,28 @@
-import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
 import { uniform } from '../core/UniformNode.js';
 import { mix } from '../math/MathNode.js';
 import { normalView } from '../accessors/Normal.js';
-import { objectPosition } from '../accessors/Object3DNode.js';
+import { lightPosition } from '../accessors/Lights.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
 
 import { Color } from '../../math/Color.js';
 
 class HemisphereLightNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'HemisphereLightNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super( light );
 
-		this.lightPositionNode = objectPosition( light );
+		this.lightPositionNode = lightPosition( light );
 		this.lightDirectionNode = this.lightPositionNode.normalize();
 
-		this.groundColorNode = uniform( new Color() );
+		this.groundColorNode = uniform( new Color() ).setGroup( renderGroup );
 
 	}
 
@@ -48,5 +54,3 @@ class HemisphereLightNode extends AnalyticLightNode {
 }
 
 export default HemisphereLightNode;
-
-HemisphereLightNode.type = /*@__PURE__*/ registerNode( 'HemisphereLight', HemisphereLightNode );

package/src/nodes/lighting/IESSpotLightNode.js

@@ -1,10 +1,15 @@
-import { registerNode } from '../core/Node.js';
 import SpotLightNode from './SpotLightNode.js';
 import { texture } from '../accessors/TextureNode.js';
 import { vec2 } from '../tsl/TSLBase.js';
 
 class IESSpotLightNode extends SpotLightNode {
 
+	static get type() {
+
+		return 'IESSpotLightNode';
+
+	}
+
 	getSpotAttenuation( angleCosine ) {
 
 		const iesMap = this.light.iesMap;
@@ -30,5 +35,3 @@ class IESSpotLightNode extends SpotLightNode {
 }
 
 export default IESSpotLightNode;
-
-IESSpotLightNode.type = /*@__PURE__*/ registerNode( 'IESSpotLight', IESSpotLightNode );

package/src/nodes/lighting/IrradianceNode.js

@@ -1,8 +1,13 @@
-import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 
 class IrradianceNode extends LightingNode {
 
+	static get type() {
+
+		return 'IrradianceNode';
+
+	}
+
 	constructor( node ) {
 
 		super();
@@ -20,5 +25,3 @@ class IrradianceNode extends LightingNode {
 }
 
 export default IrradianceNode;
-
-IrradianceNode.type = /*@__PURE__*/ registerNode( 'Irradiance', IrradianceNode );

package/src/nodes/lighting/LightProbeNode.js

@@ -1,13 +1,17 @@
-import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
 import { normalWorld } from '../accessors/Normal.js';
 import { uniformArray } from '../accessors/UniformArrayNode.js';
-import { Fn } from '../tsl/TSLBase.js';
-import { mul } from '../math/OperatorNode.js';
 import { Vector3 } from '../../math/Vector3.js';
+import getShIrradianceAt from '../functions/material/getShIrradianceAt.js';
 
 class LightProbeNode extends AnalyticLightNode {
 
+	static get type() {
+
+		return 'LightProbeNode';
+
+	}
+
 	constructor( light = null ) {
 
 		super( light );
@@ -38,7 +42,7 @@ class LightProbeNode extends AnalyticLightNode {
 
 	setup( builder ) {
 
-		const irradiance = shGetIrradianceAt( normalWorld, this.lightProbe );
+		const irradiance = getShIrradianceAt( normalWorld, this.lightProbe );
 
 		builder.context.irradiance.addAssign( irradiance );
 
@@ -47,30 +51,3 @@ class LightProbeNode extends AnalyticLightNode {
 }
 
 export default LightProbeNode;
-
-LightProbeNode.type = /*@__PURE__*/ registerNode( 'LightProbe', LightProbeNode );
-
-const shGetIrradianceAt = /*@__PURE__*/ Fn( ( [ normal, shCoefficients ] ) => {
-
-	// normal is assumed to have unit length
-
-	const x = normal.x, y = normal.y, z = normal.z;
-
-	// band 0
-	const result = shCoefficients.element( 0 ).mul( 0.886227 );
-
-	// band 1
-	result.addAssign( shCoefficients.element( 1 ).mul( 2.0 * 0.511664 ).mul( y ) );
-	result.addAssign( shCoefficients.element( 2 ).mul( 2.0 * 0.511664 ).mul( z ) );
-	result.addAssign( shCoefficients.element( 3 ).mul( 2.0 * 0.511664 ).mul( x ) );
-
-	// band 2
-	result.addAssign( shCoefficients.element( 4 ).mul( 2.0 * 0.429043 ).mul( x ).mul( y ) );
-	result.addAssign( shCoefficients.element( 5 ).mul( 2.0 * 0.429043 ).mul( y ).mul( z ) );
-	result.addAssign( shCoefficients.element( 6 ).mul( z.mul( z ).mul( 0.743125 ).sub( 0.247708 ) ) );
-	result.addAssign( shCoefficients.element( 7 ).mul( 2.0 * 0.429043 ).mul( x ).mul( z ) );
-	result.addAssign( shCoefficients.element( 8 ).mul( 0.429043 ).mul( mul( x, x ).sub( mul( y, y ) ) ) );
-
-	return result;
-
-} );

package/src/nodes/lighting/LightingContextNode.js

@@ -1,9 +1,14 @@
-import { registerNode } from '../core/Node.js';
 import ContextNode from '../core/ContextNode.js';
 import { nodeProxy, float, vec3 } from '../tsl/TSLBase.js';
 
 class LightingContextNode extends ContextNode {
 
+	static get type() {
+
+		return 'LightingContextNode';
+
+	}
+
 	constructor( node, lightingModel = null, backdropNode = null, backdropAlphaNode = null ) {
 
 		super( node );
@@ -59,6 +64,4 @@ class LightingContextNode extends ContextNode {
 
 export default LightingContextNode;
 
-LightingContextNode.type = /*@__PURE__*/ registerNode( 'LightingContext', LightingContextNode );
-
 export const lightingContext = /*@__PURE__*/ nodeProxy( LightingContextNode );

package/src/nodes/lighting/LightingNode.js

@@ -1,7 +1,13 @@
-import Node, { registerNode } from '../core/Node.js';
+import Node from '../core/Node.js';
 
 class LightingNode extends Node {
 
+	static get type() {
+
+		return 'LightingNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec3' );
@@ -19,5 +25,3 @@ class LightingNode extends Node {
 }
 
 export default LightingNode;
-
-LightingNode.type = /*@__PURE__*/ registerNode( 'Lighting', LightingNode );