super-three 0.165.0 → 0.168.0

package/src/nodes/lighting/AnalyticLightNode.js

@@ -0,0 +1,354 @@
+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 { 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 { 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';
+
+const BasicShadowMap = Fn( ( { depthTexture, shadowCoord } ) => {
+
+	return texture( depthTexture, shadowCoord.xy ).compare( shadowCoord.z );
+
+} );
+
+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 texelSize = vec2( 1 ).div( mapSize );
+	const dx0 = texelSize.x.negate().mul( radius );
+	const dy0 = texelSize.y.negate().mul( radius );
+	const dx1 = texelSize.x.mul( radius );
+	const dy1 = texelSize.y.mul( radius );
+	const dx2 = dx0.div( 2 );
+	const dy2 = dy0.div( 2 );
+	const dx3 = dx1.div( 2 );
+	const dy3 = dy1.div( 2 );
+
+	return add(
+		depthCompare( shadowCoord.xy.add( vec2( dx0, dy0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( 0, dy0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx1, dy0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx2, dy2 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( 0, dy2 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx3, dy2 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx0, 0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx2, 0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy, shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx3, 0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx1, 0 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx2, dy3 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( 0, dy3 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx3, dy3 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx0, dy1 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( 0, dy1 ) ), shadowCoord.z ),
+		depthCompare( shadowCoord.xy.add( vec2( dx1, dy1 ) ), shadowCoord.z )
+	).mul( 1 / 17 );
+
+} );
+
+const PCFSoftShadowMap = Fn( ( { depthTexture, shadowCoord, shadow } ) => {
+
+	const depthCompare = ( uv, compare ) => texture( depthTexture, uv ).compare( compare );
+
+	const mapSize = reference( 'mapSize', 'vec2', shadow );
+
+	const texelSize = vec2( 1 ).div( mapSize );
+	const dx = texelSize.x;
+	const dy = texelSize.y;
+
+	const uv = shadowCoord.xy;
+	const f = fract( uv.mul( mapSize ).add( 0.5 ) );
+	uv.subAssign( f.mul( texelSize ) );
+
+	return add(
+		depthCompare( uv, shadowCoord.z ),
+		depthCompare( uv.add( vec2( dx, 0 ) ), shadowCoord.z ),
+		depthCompare( uv.add( vec2( 0, dy ) ), shadowCoord.z ),
+		depthCompare( uv.add( texelSize ), shadowCoord.z ),
+		mix(
+			depthCompare( uv.add( vec2( dx.negate(), 0 ) ), shadowCoord.z ),
+			depthCompare( uv.add( vec2( dx.mul( 2 ), 0 ) ), shadowCoord.z ),
+			f.x
+		),
+		mix(
+			depthCompare( uv.add( vec2( dx.negate(), dy ) ), shadowCoord.z ),
+			depthCompare( uv.add( vec2( dx.mul( 2 ), dy ) ), shadowCoord.z ),
+			f.x
+		),
+		mix(
+			depthCompare( uv.add( vec2( 0, dy.negate() ) ), shadowCoord.z ),
+			depthCompare( uv.add( vec2( 0, dy.mul( 2 ) ) ), shadowCoord.z ),
+			f.y
+		),
+		mix(
+			depthCompare( uv.add( vec2( dx, dy.negate() ) ), shadowCoord.z ),
+			depthCompare( uv.add( vec2( dx, dy.mul( 2 ) ) ), shadowCoord.z ),
+			f.y
+		),
+		mix(
+			mix(
+				depthCompare( uv.add( vec2( dx.negate(), dy.negate() ) ), shadowCoord.z ),
+				depthCompare( uv.add( vec2( dx.mul( 2 ), dy.negate() ) ), shadowCoord.z ),
+				f.x
+			),
+			mix(
+				depthCompare( uv.add( vec2( dx.negate(), dy.mul( 2 ) ) ), shadowCoord.z ),
+				depthCompare( uv.add( vec2( dx.mul( 2 ), dy.mul( 2 ) ) ), shadowCoord.z ),
+				f.x
+			),
+			f.y
+		)
+	).mul( 1 / 9 );
+
+} );
+
+const shadowFilterLib = [ BasicShadowMap, PCFShadowMap, PCFSoftShadowMap ];
+
+//
+
+let overrideMaterial = null;
+
+class AnalyticLightNode extends LightingNode {
+
+	constructor( light = null ) {
+
+		super();
+
+		this.updateType = NodeUpdateType.FRAME;
+
+		this.light = light;
+
+		this.color = new Color();
+		this.colorNode = uniform( this.color );
+
+		this.baseColorNode = null;
+
+		this.shadowMap = null;
+		this.shadowNode = null;
+		this.shadowColorNode = null;
+
+		this.isAnalyticLightNode = true;
+
+	}
+
+	getCacheKey() {
+
+		return super.getCacheKey() + '-' + ( this.light.id + '-' + ( this.light.castShadow ? '1' : '0' ) );
+
+	}
+
+	getHash() {
+
+		return this.light.uuid;
+
+	}
+
+	setupShadow( builder ) {
+
+		const { object, renderer } = builder;
+
+		let shadowColorNode = this.shadowColorNode;
+
+		if ( shadowColorNode === 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';
+
+			}
+
+			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();
+
+			//
+
+			const shadowIntensity = reference( 'intensity', 'float', shadow );
+			const bias = reference( 'bias', 'float', shadow );
+			const normalBias = reference( 'normalBias', 'float', shadow );
+
+			const position = object.material.shadowPositionNode || positionWorld;
+
+			let shadowCoord = uniform( shadow.matrix ).mul( position.add( normalWorld.mul( normalBias ) ) );
+			shadowCoord = shadowCoord.xyz.div( shadowCoord.w );
+
+			let coordZ = shadowCoord.z.add( bias );
+
+			if ( renderer.coordinateSystem === WebGPUCoordinateSystem ) {
+
+				coordZ = coordZ.mul( 2 ).sub( 1 ); // WebGPU: Convertion [ 0, 1 ] to [ - 1, 1 ]
+
+			}
+
+			shadowCoord = vec3(
+				shadowCoord.x,
+				shadowCoord.y.oneMinus(), // follow webgpu standards
+				coordZ
+			);
+
+			const frustumTest = shadowCoord.x.greaterThanEqual( 0 )
+				.and( shadowCoord.x.lessThanEqual( 1 ) )
+				.and( shadowCoord.y.greaterThanEqual( 0 ) )
+				.and( shadowCoord.y.lessThanEqual( 1 ) )
+				.and( shadowCoord.z.lessThanEqual( 1 ) );
+
+			//
+
+			const filterFn = shadow.filterNode || shadowFilterLib[ renderer.shadowMap.type ] || null;
+
+			if ( filterFn === null ) {
+
+				throw new Error( 'THREE.WebGPURenderer: Shadow map type not supported yet.' );
+
+			}
+
+			const shadowColor = texture( shadowMap.texture, shadowCoord );
+			const shadowNode = frustumTest.select( filterFn( { depthTexture, shadowCoord, shadow } ), float( 1 ) );
+
+			this.shadowMap = shadowMap;
+
+			this.shadowNode = shadowNode;
+			this.shadowColorNode = shadowColorNode = this.colorNode.mul( mix( 1, shadowNode.rgb.mix( shadowColor, 1 ), shadowIntensity.mul( shadowColor.a ) ) );
+
+			this.baseColorNode = this.colorNode;
+
+		}
+
+		//
+
+		this.colorNode = shadowColorNode;
+
+		this.updateBeforeType = NodeUpdateType.RENDER;
+
+	}
+
+	setup( builder ) {
+
+		this.colorNode = this.baseColorNode || this.colorNode;
+
+		if ( this.light.castShadow ) {
+
+			if ( builder.object.receiveShadow ) {
+
+				this.setupShadow( builder );
+
+			}
+
+		} else if ( this.shadowNode !== null ) {
+
+			this.disposeShadow();
+
+		}
+
+	}
+
+	updateShadow( frame ) {
+
+		const { shadowMap, light } = this;
+		const { renderer, scene, camera } = frame;
+
+
+		const depthVersion = shadowMap.depthTexture.version;
+		this._depthVersionCached = depthVersion;
+
+		const currentOverrideMaterial = scene.overrideMaterial;
+
+		scene.overrideMaterial = overrideMaterial;
+
+		shadowMap.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
+
+		light.shadow.updateMatrices( light );
+		light.shadow.camera.layers.mask = camera.layers.mask;
+
+		const currentRenderTarget = renderer.getRenderTarget();
+		const currentRenderObjectFunction = renderer.getRenderObjectFunction();
+
+		renderer.setRenderObjectFunction( ( object, ...params ) => {
+
+			if ( object.castShadow === true ) {
+
+				renderer.renderObject( object, ...params );
+
+			}
+
+		} );
+
+		renderer.setRenderTarget( shadowMap );
+		renderer.render( scene, light.shadow.camera );
+
+		renderer.setRenderTarget( currentRenderTarget );
+		renderer.setRenderObjectFunction( currentRenderObjectFunction );
+
+		scene.overrideMaterial = currentOverrideMaterial;
+
+	}
+
+	disposeShadow() {
+
+		this.shadowMap.dispose();
+		this.shadowMap = null;
+
+		this.shadowNode = null;
+		this.shadowColorNode = null;
+
+		this.baseColorNode = null;
+
+		this.updateBeforeType = NodeUpdateType.NONE;
+
+	}
+
+	updateBefore( frame ) {
+
+		const shadow = this.light.shadow;
+
+		const needsUpdate = shadow.needsUpdate || shadow.autoUpdate;
+
+		if ( needsUpdate ) {
+
+			this.updateShadow( frame );
+
+			if ( this.shadowMap.depthTexture.version === this._depthVersionCached ) {
+
+				shadow.needsUpdate = false;
+
+			}
+
+		}
+
+	}
+
+	update( /*frame*/ ) {
+
+		const { light } = this;
+
+		this.color.copy( light.color ).multiplyScalar( light.intensity );
+
+	}
+
+}
+
+export default AnalyticLightNode;
+
+AnalyticLightNode.type = /*@__PURE__*/ registerNode( 'AnalyticLight', AnalyticLightNode );

package/src/nodes/lighting/BasicEnvironmentNode.js

@@ -0,0 +1,27 @@
+import { registerNode } from '../core/Node.js';
+import LightingNode from './LightingNode.js';
+import { cubeMapNode } from '../utils/CubeMapNode.js';
+
+class BasicEnvironmentNode extends LightingNode {
+
+	constructor( envNode = null ) {
+
+		super();
+
+		this.envNode = envNode;
+
+	}
+
+	setup( builder ) {
+
+		// environment property is used in the finish() method of BasicLightingModel
+
+		builder.context.environment = cubeMapNode( this.envNode );
+
+	}
+
+}
+
+export default BasicEnvironmentNode;
+
+BasicEnvironmentNode.type = /*@__PURE__*/ registerNode( 'BasicEnvironment', BasicEnvironmentNode );

package/src/nodes/lighting/BasicLightMapNode.js

@@ -0,0 +1,29 @@
+import { registerNode } from '../core/Node.js';
+import LightingNode from './LightingNode.js';
+import { float } from '../tsl/TSLBase.js';
+
+class BasicLightMapNode extends LightingNode {
+
+	constructor( lightMapNode = null ) {
+
+		super();
+
+		this.lightMapNode = lightMapNode;
+
+	}
+
+	setup( builder ) {
+
+		// irradianceLightMap property is used in the indirectDiffuse() method of BasicLightingModel
+
+		const RECIPROCAL_PI = float( 1 / Math.PI );
+
+		builder.context.irradianceLightMap = this.lightMapNode.mul( RECIPROCAL_PI );
+
+	}
+
+}
+
+export default BasicLightMapNode;
+
+BasicLightMapNode.type = /*@__PURE__*/ registerNode( 'BasicLightMap', BasicLightMapNode );

package/{examples/jsm → src}/nodes/lighting/DirectionalLightNode.js

@@ -1,9 +1,6 @@
+import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
 import { lightTargetDirection } from './LightNode.js';
-import { addLightNode } from './LightsNode.js';
-import { addNodeClass } from '../core/Node.js';
-
-import { DirectionalLight } from 'three';
 
 class DirectionalLightNode extends AnalyticLightNode {
 
@@ -26,8 +23,7 @@ class DirectionalLightNode extends AnalyticLightNode {
 		lightingModel.direct( {
 			lightDirection,
 			lightColor,
-			reflectedLight,
-			shadowMask: this.shadowMaskNode
+			reflectedLight
 		}, builder.stack, builder );
 
 	}
@@ -36,6 +32,4 @@ class DirectionalLightNode extends AnalyticLightNode {
 
 export default DirectionalLightNode;
 
-addNodeClass( 'DirectionalLightNode', DirectionalLightNode );
-
-addLightNode( DirectionalLight, DirectionalLightNode );
+DirectionalLightNode.type = /*@__PURE__*/ registerNode( 'DirectionalLight', DirectionalLightNode );

package/{examples/jsm → src}/nodes/lighting/EnvironmentNode.js

@@ -1,17 +1,16 @@
+import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
 import { cache } from '../core/CacheNode.js';
-import { context } from '../core/ContextNode.js';
 import { roughness, clearcoatRoughness } from '../core/PropertyNode.js';
-import { cameraViewMatrix } from '../accessors/CameraNode.js';
-import { transformedClearcoatNormalView, transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
-import { positionViewDirection } from '../accessors/PositionNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { float } from '../shadernode/ShaderNode.js';
+import { cameraViewMatrix } from '../accessors/Camera.js';
+import { transformedClearcoatNormalView, transformedNormalView, transformedNormalWorld } from '../accessors/Normal.js';
+import { positionViewDirection } from '../accessors/Position.js';
+import { float } from '../tsl/TSLBase.js';
 import { reference } from '../accessors/ReferenceNode.js';
 import { transformedBentNormalView } from '../accessors/AccessorsUtils.js';
 import { pmremTexture } from '../pmrem/PMREMNode.js';
 
-const envNodeCache = new WeakMap();
+const _envNodeCache = new WeakMap();
 
 class EnvironmentNode extends LightingNode {
 
@@ -25,17 +24,21 @@ class EnvironmentNode extends LightingNode {
 
 	setup( builder ) {
 
+		const { material } = builder;
+
 		let envNode = this.envNode;
 
-		if ( envNode.isTextureNode ) {
+		if ( envNode.isTextureNode || envNode.isMaterialReferenceNode ) {
+
+			const value = ( envNode.isTextureNode ) ? envNode.value : material[ envNode.property ];
 
-			let cacheEnvNode = envNodeCache.get( envNode.value );
+			let cacheEnvNode = _envNodeCache.get( value );
 
 			if ( cacheEnvNode === undefined ) {
 
-				cacheEnvNode = pmremTexture( envNode.value );
+				cacheEnvNode = pmremTexture( value );
 
-				envNodeCache.set( envNode.value, cacheEnvNode );
+				_envNodeCache.set( value, cacheEnvNode );
 
 			}
 
@@ -45,24 +48,23 @@ class EnvironmentNode extends LightingNode {
 
 		//
 
-		const { material } = builder;
-
 		const envMap = material.envMap;
 		const intensity = envMap ? reference( 'envMapIntensity', 'float', builder.material ) : reference( 'environmentIntensity', 'float', builder.scene ); // @TODO: Add materialEnvIntensity in MaterialNode
 
 		const useAnisotropy = material.useAnisotropy === true || material.anisotropy > 0;
 		const radianceNormalView = useAnisotropy ? transformedBentNormalView : transformedNormalView;
 
-		const radiance = context( envNode, createRadianceContext( roughness, radianceNormalView ) ).mul( intensity );
-		const irradiance = context( envNode, createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
+		const radiance = envNode.context( createRadianceContext( roughness, radianceNormalView ) ).mul( intensity );
+		const irradiance = envNode.context( createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
 
 		const isolateRadiance = cache( radiance );
+		const isolateIrradiance = cache( irradiance );
 
 		//
 
 		builder.context.radiance.addAssign( isolateRadiance );
 
-		builder.context.iblIrradiance.addAssign( irradiance );
+		builder.context.iblIrradiance.addAssign( isolateIrradiance );
 
 		//
 
@@ -70,7 +72,7 @@ class EnvironmentNode extends LightingNode {
 
 		if ( clearcoatRadiance ) {
 
-			const clearcoatRadianceContext = context( envNode, createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( intensity );
+			const clearcoatRadianceContext = envNode.context( createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( intensity );
 			const isolateClearcoatRadiance = cache( clearcoatRadianceContext );
 
 			clearcoatRadiance.addAssign( isolateClearcoatRadiance );
@@ -81,6 +83,10 @@ class EnvironmentNode extends LightingNode {
 
 }
 
+export default EnvironmentNode;
+
+EnvironmentNode.type = /*@__PURE__*/ registerNode( 'Environment', EnvironmentNode );
+
 const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
 	let reflectVec = null;
@@ -127,7 +133,3 @@ const createIrradianceContext = ( normalWorldNode ) => {
 	};
 
 };
-
-export default EnvironmentNode;
-
-addNodeClass( 'EnvironmentNode', EnvironmentNode );

package/{examples/jsm → src}/nodes/lighting/HemisphereLightNode.js

@@ -1,12 +1,11 @@
+import { registerNode } from '../core/Node.js';
 import AnalyticLightNode from './AnalyticLightNode.js';
-import { addLightNode } from './LightsNode.js';
 import { uniform } from '../core/UniformNode.js';
 import { mix } from '../math/MathNode.js';
-import { normalView } from '../accessors/NormalNode.js';
+import { normalView } from '../accessors/Normal.js';
 import { objectPosition } from '../accessors/Object3DNode.js';
-import { addNodeClass } from '../core/Node.js';
 
-import { Color, HemisphereLight } from 'three';
+import { Color } from '../../math/Color.js';
 
 class HemisphereLightNode extends AnalyticLightNode {
 
@@ -50,6 +49,4 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 export default HemisphereLightNode;
 
-addNodeClass( 'HemisphereLightNode', HemisphereLightNode );
-
-addLightNode( HemisphereLight, HemisphereLightNode );
+HemisphereLightNode.type = /*@__PURE__*/ registerNode( 'HemisphereLight', HemisphereLightNode );

package/{examples/jsm → src}/nodes/lighting/IESSpotLightNode.js

@@ -1,10 +1,7 @@
+import { registerNode } from '../core/Node.js';
 import SpotLightNode from './SpotLightNode.js';
-import { addLightNode } from './LightsNode.js';
 import { texture } from '../accessors/TextureNode.js';
-import { vec2 } from '../shadernode/ShaderNode.js';
-import { addNodeClass } from '../core/Node.js';
-
-import IESSpotLight from '../../lights/IESSpotLight.js';
+import { vec2 } from '../tsl/TSLBase.js';
 
 class IESSpotLightNode extends SpotLightNode {
 
@@ -34,6 +31,4 @@ class IESSpotLightNode extends SpotLightNode {
 
 export default IESSpotLightNode;
 
-addNodeClass( 'IESSpotLightNode', IESSpotLightNode );
-
-addLightNode( IESSpotLight, IESSpotLightNode );
+IESSpotLightNode.type = /*@__PURE__*/ registerNode( 'IESSpotLight', IESSpotLightNode );

package/{examples/jsm → src}/nodes/lighting/IrradianceNode.js

@@ -1,5 +1,5 @@
+import { registerNode } from '../core/Node.js';
 import LightingNode from './LightingNode.js';
-import { addNodeClass } from '../core/Node.js';
 
 class IrradianceNode extends LightingNode {
 
@@ -21,4 +21,4 @@ class IrradianceNode extends LightingNode {
 
 export default IrradianceNode;
 
-addNodeClass( 'IrradianceNode', IrradianceNode );
+IrradianceNode.type = /*@__PURE__*/ registerNode( 'Irradiance', IrradianceNode );

package/{examples/jsm → src}/nodes/lighting/LightNode.js

@@ -1,7 +1,7 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 import { objectPosition } from '../accessors/Object3DNode.js';
-import { cameraViewMatrix } from '../accessors/CameraNode.js';
+import { cameraViewMatrix } from '../accessors/Camera.js';
 
 class LightNode extends Node {
 
@@ -52,6 +52,6 @@ LightNode.TARGET_DIRECTION = 'targetDirection';
 
 export default LightNode;
 
-export const lightTargetDirection = nodeProxy( LightNode, LightNode.TARGET_DIRECTION );
+LightNode.type = /*@__PURE__*/ registerNode( 'Light', LightNode );
 
-addNodeClass( 'LightNode', LightNode );
+export const lightTargetDirection = /*@__PURE__*/ nodeProxy( LightNode, LightNode.TARGET_DIRECTION );