@unikia/upe-renderer 0.186.110 → 0.187.11

package/examples/jsm/tsl/lighting/DynamicLightsNode.js

@@ -1,5 +1,4 @@
-import { LightsNode, NodeUtils, warn } from 'three/webgpu';
-import { nodeObject } from 'three/tsl';
+import { AmbientLight, DirectionalLight, HemisphereLight, LightsNode, NodeUtils, PointLight, SpotLight } from 'three/webgpu';
 
 import AmbientLightDataNode from './data/AmbientLightDataNode.js';
 import DirectionalLightDataNode from './data/DirectionalLightDataNode.js';
@@ -7,9 +6,16 @@ import PointLightDataNode from './data/PointLightDataNode.js';
 import SpotLightDataNode from './data/SpotLightDataNode.js';
 import HemisphereLightDataNode from './data/HemisphereLightDataNode.js';
 
-const _lightNodeRef = /*@__PURE__*/ new WeakMap();
 const _hashData = [];
 
+const _lightClassToType = new Map( [
+	[ AmbientLight, 'AmbientLight' ],
+	[ DirectionalLight, 'DirectionalLight' ],
+	[ PointLight, 'PointLight' ],
+	[ SpotLight, 'SpotLight' ],
+	[ HemisphereLight, 'HemisphereLight' ]
+] );
+
 const _lightTypeToDataNode = {
 	AmbientLight: AmbientLightDataNode,
 	DirectionalLight: DirectionalLightDataNode,
@@ -25,8 +31,6 @@ const _lightTypeToMaxProp = {
 	HemisphereLight: 'maxHemisphereLights'
 };
 
-const sortLights = ( lights ) => lights.sort( ( a, b ) => a.id - b.id );
-
 const isSpecialSpotLight = ( light ) => {
 
 	return light.isSpotLight === true && ( light.map !== null || light.colorNode !== undefined );
@@ -38,28 +42,7 @@ const canBatchLight = ( light ) => {
 	return light.isNode !== true &&
 		light.castShadow !== true &&
 		isSpecialSpotLight( light ) === false &&
-		_lightTypeToDataNode[ light.constructor.name ] !== undefined;
-
-};
-
-const getOrCreateLightNode = ( light, nodeLibrary ) => {
-
-	const lightNodeClass = nodeLibrary.getLightNodeClass( light.constructor );
-
-	if ( lightNodeClass === null ) {
-
-		warn( `DynamicLightsNode: Light node not found for ${ light.constructor.name }.` );
-		return null;
-
-	}
-
-	if ( _lightNodeRef.has( light ) === false ) {
-
-		_lightNodeRef.set( light, new lightNodeClass( light ) );
-
-	}
-
-	return _lightNodeRef.get( light );
+		_lightClassToType.has( light.constructor );
 
 };
 
@@ -99,47 +82,16 @@ class DynamicLightsNode extends LightsNode {
 		this.maxSpotLights = options.maxSpotLights !== undefined ? options.maxSpotLights : 16;
 		this.maxHemisphereLights = options.maxHemisphereLights !== undefined ? options.maxHemisphereLights : 4;
 
+		this._builtinLights = [];
 		this._dataNodes = new Map();
 
 	}
 
 	customCacheKey() {
 
-		const typeSet = new Set();
-
-		for ( let i = 0; i < this._lights.length; i ++ ) {
-
-			const light = this._lights[ i ];
-
-			if ( canBatchLight( light ) ) {
-
-				typeSet.add( light.constructor.name );
-
-			} else {
-
-				_hashData.push( light.id );
-				_hashData.push( light.castShadow ? 1 : 0 );
-
-				if ( light.isSpotLight === true ) {
-
-					const hashMap = light.map !== null ? light.map.id : - 1;
-					const hashColorNode = light.colorNode ? light.colorNode.getCacheKey() : - 1;
+		_hashData.push( super.customCacheKey() );
 
-					_hashData.push( hashMap, hashColorNode );
-
-				}
-
-			}
-
-		}
-
-		for ( const typeName of this._dataNodes.keys() ) {
-
-			typeSet.add( typeName );
-
-		}
-
-		for ( const typeName of [ ...typeSet ].sort() ) {
+		for ( const typeName of [ ...this._dataNodes.keys() ].sort() ) {
 
 			_hashData.push( NodeUtils.hashString( typeName ) );
 
@@ -155,127 +107,76 @@ class DynamicLightsNode extends LightsNode {
 
 	setupLightsNode( builder ) {
 
-		const lightNodes = [];
-		const lightsByType = new Map();
-		const lights = sortLights( this._lights );
-		const nodeLibrary = builder.renderer.library;
-
-		for ( const light of lights ) {
+		const lightNodes = super.setupLightsNode( builder );
 
-			if ( light.isNode === true ) {
+		for ( const dataNode of this._dataNodes.values() ) {
 
-				lightNodes.push( nodeObject( light ) );
-				continue;
+			lightNodes.push( dataNode );
 
-			}
+		}
 
-			if ( canBatchLight( light ) ) {
+		return lightNodes;
 
-				const typeName = light.constructor.name;
-				const typeLights = lightsByType.get( typeName );
+	}
 
-				if ( typeLights === undefined ) {
+	setLights( lights ) {
 
-					lightsByType.set( typeName, [ light ] );
+		const builtinLights = this._builtinLights;
+		const lightsByType = new Map();
 
-				} else {
+		builtinLights.length = 0;
 
-					typeLights.push( light );
+		for ( const light of lights ) {
 
-				}
+			if ( canBatchLight( light ) === false ) {
 
+				builtinLights.push( light );
 				continue;
 
 			}
 
-			const lightNode = getOrCreateLightNode( light, nodeLibrary );
+			const typeName = _lightClassToType.get( light.constructor );
+			const typeLights = lightsByType.get( typeName );
+
+			if ( typeLights === undefined ) {
+
+				lightsByType.set( typeName, [ light ] );
 
-			if ( lightNode !== null ) {
+			} else {
 
-				lightNodes.push( lightNode );
+				typeLights.push( light );
 
 			}
 
 		}
 
-		for ( const [ typeName, typeLights ] of lightsByType ) {
-
-			let dataNode = this._dataNodes.get( typeName );
+		for ( const typeName of lightsByType.keys() ) {
 
-			if ( dataNode === undefined ) {
+			if ( this._dataNodes.has( typeName ) === false ) {
 
 				const DataNodeClass = _lightTypeToDataNode[ typeName ];
 				const maxProp = _lightTypeToMaxProp[ typeName ];
 				const maxCount = maxProp !== undefined ? this[ maxProp ] : undefined;
 
-				dataNode = maxCount !== undefined ? new DataNodeClass( maxCount ) : new DataNodeClass();
-
-				this._dataNodes.set( typeName, dataNode );
+				this._dataNodes.set( typeName, maxCount !== undefined ? new DataNodeClass( maxCount ) : new DataNodeClass() );
 
 			}
 
-			dataNode.setLights( typeLights );
-			lightNodes.push( dataNode );
-
 		}
 
 		for ( const [ typeName, dataNode ] of this._dataNodes ) {
 
-			if ( lightsByType.has( typeName ) === false ) {
-
-				dataNode.setLights( [] );
-				lightNodes.push( dataNode );
-
-			}
-
-		}
-
-		return lightNodes;
-
-	}
-
-	setLights( lights ) {
-
-		super.setLights( lights );
-
-		if ( this._dataNodes.size > 0 ) {
-
-			this._updateDataNodeLights( lights );
+			dataNode.setLights( lightsByType.get( typeName ) || [] );
 
 		}
 
-		return this;
+		return super.setLights( lights );
 
 	}
 
-	_updateDataNodeLights( lights ) {
+	getBuiltinLights() {
 
-		const lightsByType = new Map();
-
-		for ( const light of lights ) {
-
-			if ( canBatchLight( light ) === false ) continue;
-
-			const typeName = light.constructor.name;
-			const typeLights = lightsByType.get( typeName );
-
-			if ( typeLights === undefined ) {
-
-				lightsByType.set( typeName, [ light ] );
-
-			} else {
-
-				typeLights.push( light );
-
-			}
-
-		}
-
-		for ( const [ typeName, dataNode ] of this._dataNodes ) {
-
-			dataNode.setLights( lightsByType.get( typeName ) || [] );
-
-		}
+		return this._builtinLights;
 
 	}
 

package/examples/jsm/tsl/lighting/LightProbeGridNode.js

@@ -1,5 +1,5 @@
-import { AnalyticLightNode, Vector3 } from 'three/webgpu';
-import { array, getShIrradianceAt, normalWorld, positionWorld, texture3D, uniform, vec3 } from 'three/tsl';
+import { AnalyticLightNode, NodeUpdateType, Vector3 } from 'three/webgpu';
+import { INFINITY, If, array, getShIrradianceAt, normalWorld, positionWorld, renderGroup, texture3D, uniform, vec3 } from 'three/tsl';
 
 // Padding texels at each boundary of every atlas sub-volume.
 export const ATLAS_PADDING = 1;
@@ -49,6 +49,53 @@ function evaluateGridIrradiance( atlas, uvw, res, normal ) {
 
 }
 
+/**
+ * Evaluates the irradiance of a light probe grid at the given world-space position and normal.
+ *
+ * @private
+ * @param {LightProbeGrid} light - The light probe grid.
+ * @param {Node<vec3>} min - The minimum of the grid bounds.
+ * @param {Node<vec3>} max - The maximum of the grid bounds.
+ * @param {Node<vec3>} res - The probe resolution.
+ * @param {Node<float>} intensity - The intensity.
+ * @param {Node<vec3>} position - The world-space position.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The irradiance.
+ */
+function getGridIrradiance( light, min, max, res, intensity, position, normal ) {
+
+	const range = max.sub( min );
+	const spacing = range.div( res );
+
+	// Offset along the normal by half a probe spacing. The bounds hold one cell per
+	// probe, so they map directly to the probe grid; clamp to the outermost texel centers.
+
+	const samplePos = position.add( normal.mul( spacing ).mul( 0.5 ) );
+	const halfTexel = vec3( 0.5 ).div( res );
+	const uvw = samplePos.sub( min ).div( range ).clamp( halfTexel, halfTexel.oneMinus() );
+
+	return evaluateGridIrradiance( texture3D( light.texture ), uvw, res, normal ).mul( intensity );
+
+}
+
+/**
+ * Returns the irradiance of a baked {@link LightProbeGrid} at the given world-space
+ * position and normal. Use this to evaluate the grid outside of the lighting context,
+ * e.g. when baking light maps with {@link LightMapper}.
+ *
+ * @param {LightProbeGrid} light - The baked light probe grid.
+ * @param {Node<vec3>} position - The world-space position.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The irradiance.
+ */
+export function lightProbeGridIrradiance( light, position, normal ) {
+
+	const box = light.boundingBox;
+
+	return getGridIrradiance( light, uniform( box.min ), uniform( box.max ), uniform( light.resolution ), uniform( light.intensity ), position, normal );
+
+}
+
 /**
  * The light node that applies a {@link LightProbeGrid} to the scene. It samples
  * the baked L2 spherical-harmonic atlas at the surface position and adds the
@@ -71,11 +118,15 @@ class LightProbeGridNode extends AnalyticLightNode {
 
 		super( light );
 
+		// Bounce grid intensity changes between bake passes within a frame.
+
 		this._min = uniform( new Vector3() );
 		this._max = uniform( new Vector3() );
 		this._resolution = uniform( new Vector3() );
-		this._intensity = uniform( 1 );
-		this._falloff = uniform( 0 );
+		this._intensity = uniform( 1 ).setGroup( renderGroup );
+		this._priority = uniform( 0 ).setGroup( renderGroup );
+
+		this.updateType = NodeUpdateType.RENDER;
 
 	}
 
@@ -87,7 +138,7 @@ class LightProbeGridNode extends AnalyticLightNode {
 		this._max.value.copy( light.boundingBox.max );
 		this._resolution.value.copy( light.resolution );
 		this._intensity.value = light.intensity;
-		this._falloff.value = light.falloff;
+		this._priority.value = light.priority;
 
 	}
 
@@ -95,39 +146,35 @@ class LightProbeGridNode extends AnalyticLightNode {
 
 		const light = this.light;
 
-		// No baked data yet: contribute nothing.
-
-		if ( light.texture === null ) return;
-
 		const min = this._min;
 		const max = this._max;
 		const res = this._resolution;
 
-		const range = max.sub( min );
-		const resMinusOne = res.sub( 1.0 );
-		const spacing = range.div( resMinusOne );
-
-		// Offset along the normal by half a probe spacing, then remap to texel centers.
-
+		const spacing = max.sub( min ).div( res );
 		const samplePos = positionWorld.add( normalWorld.mul( spacing ).mul( 0.5 ) );
-		const uvw = samplePos.sub( min ).div( range ).clamp( 0.0, 1.0 ).mul( resMinusOne ).div( res ).add( vec3( 0.5 ).div( res ) );
 
-		const result = evaluateGridIrradiance( texture3D( light.texture ), uvw, res, normalWorld );
+		// Grow the bounds by 1% of a cell, so fragments on the bounds aren't left out by
+		// precision errors or samples outside of the triangle.
+
+		const margin = spacing.mul( 0.01 );
+		const inside = samplePos.greaterThanEqual( min.sub( margin ) ).all().and( samplePos.lessThanEqual( max.add( margin ) ).all() );
 
-		let irradiance = result.mul( this._intensity );
+		builder.context.lightProbeIrradiance ||= vec3().toVar( 'lightProbeIrradiance' );
+		builder.context.lightProbePriority ||= INFINITY.negate().toVar( 'lightProbePriority' );
 
-		// Optional smooth boundary for blending grids; falloff 0 applies everywhere.
+		const prioritized = this._priority.greaterThanEqual( builder.context.lightProbePriority );
 
-		if ( light.falloff > 0 ) {
+		If( inside.and( prioritized ), () => {
 
-			const outside = min.sub( positionWorld ).max( 0.0 ).add( positionWorld.sub( max ).max( 0.0 ) );
-			const weight = outside.length().smoothstep( 0.0, this._falloff ).oneMinus();
+			const irradiance = getGridIrradiance( light, min, max, res, this._intensity, positionWorld, normalWorld ).toConst();
 
-			irradiance = irradiance.mul( weight );
+			// fragments can be located in multiple grids but only the one with the highest priority defines the irradiance,
+			// on ties the most recently created grid wins, see #34798
 
-		}
+			builder.context.lightProbeIrradiance.assign( irradiance );
+			builder.context.lightProbePriority.assign( this._priority );
 
-		builder.context.irradiance.addAssign( irradiance );
+		} );
 
 	}
 

package/examples/jsm/tsl/lighting/data/AmbientLightDataNode.js

@@ -26,6 +26,12 @@ class AmbientLightDataNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	setLights( lights ) {
 
 		this._lights = lights;

package/examples/jsm/tsl/lighting/data/DirectionalLightDataNode.js

@@ -46,6 +46,12 @@ class DirectionalLightDataNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	setLights( lights ) {
 
 		if ( lights.length > this.maxCount ) {

package/examples/jsm/tsl/lighting/data/HemisphereLightDataNode.js

@@ -46,6 +46,12 @@ class HemisphereLightDataNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	setLights( lights ) {
 
 		if ( lights.length > this.maxCount ) {

package/examples/jsm/tsl/lighting/data/PointLightDataNode.js

@@ -48,6 +48,12 @@ class PointLightDataNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	setLights( lights ) {
 
 		if ( lights.length > this.maxCount ) {

package/examples/jsm/tsl/lighting/data/SpotLightDataNode.js

@@ -54,6 +54,12 @@ class SpotLightDataNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	setLights( lights ) {
 
 		if ( lights.length > this.maxCount ) {

package/examples/jsm/tsl/shadows/TileShadowNode.js

@@ -5,16 +5,22 @@ import {
 	Plane,
 	Line3,
 	DepthTexture,
+	Compatibility,
 	LessCompare,
+	GreaterEqualCompare,
+	LinearFilter,
+	NearestFilter,
+	PCFShadowMap,
 	Vector2,
 	RedFormat,
 	ArrayCamera,
 	VSMShadowMap,
 	RendererUtils,
-	Quaternion
+	Quaternion,
+	UnsignedIntType
 } from 'three/webgpu';
 
-import { min, Fn, shadow, NodeUpdateType } from 'three/tsl';
+import { Fn, int, lightShadowMatrix, mix, normalWorld, reference, renderGroup, shadow, shadowPositionWorld, texture, vec2, vec3, vec4, NodeUpdateType } from 'three/tsl';
 
 const { resetRendererAndSceneState, restoreRendererAndSceneState } = RendererUtils;
 let _rendererState;
@@ -57,6 +63,7 @@ class TileShadowNode extends ShadowBaseNode {
 	 * @param {number} [options.tilesX=2] - The number of tiles along the X-axis.
 	 * @param {number} [options.tilesY=2] - The number of tiles along the Y-axis.
 	 * @param {Object} [options.resolution] - The resolution of the shadow map.
+	 * @param {number} [options.depthType=UnsignedIntType] - The type of the tile depth texture. `UnsignedShortType` halves the memory when the depth range allows it.
 	 * @param {boolean} [options.debug=false] - Whether to enable debug mode.
 	 */
 	constructor( light, options = {} ) {
@@ -68,6 +75,7 @@ class TileShadowNode extends ShadowBaseNode {
 			tilesX: options.tilesX || 2,
 			tilesY: options.tilesY || 2,
 			resolution: options.resolution || light.shadow.mapSize,
+			depthType: options.depthType || UnsignedIntType,
 			debug: options.debug !== undefined ? options.debug : false
 		};
 
@@ -159,12 +167,14 @@ class TileShadowNode extends ShadowBaseNode {
 		// Clear existing lights/nodes if re-initializing
 		this.disposeLightsAndNodes();
 
-		const depthTexture = new DepthTexture( shadowWidth, shadowHeight, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, tileCount );
-		depthTexture.compareFunction = LessCompare;
+		const depthTexture = new DepthTexture( shadowWidth, shadowHeight, this.config.depthType, undefined, undefined, undefined, undefined, undefined, undefined, undefined, tileCount );
+		depthTexture.compareFunction = builder.renderer.reversedDepthBuffer ? GreaterEqualCompare : LessCompare;
 		depthTexture.name = 'ShadowDepthArrayTexture';
-		const shadowMap = builder.createRenderTarget( shadowWidth, shadowHeight, { format: RedFormat, depth: tileCount, useArrayDepthTexture: true } );
+		// The color attachment is only sampled for transmitted shadows.
+		const count = builder.renderer.shadowMap.transmitted === true ? 1 : 0;
+		const shadowMap = builder.createRenderTarget( shadowWidth, shadowHeight, { count, format: RedFormat, depth: tileCount, useArrayDepthTexture: true } );
 		shadowMap.depthTexture = depthTexture;
-		shadowMap.texture.name = 'ShadowTexture';
+		if ( count > 0 ) shadowMap.texture.name = 'ShadowTexture';
 		this.shadowMap = shadowMap;
 		const cameras = [];
 
@@ -221,6 +231,10 @@ class TileShadowNode extends ShadowBaseNode {
 		const cameraArray = new ArrayCamera( cameras );
 		this.cameraArray = cameraArray;
 
+		// setup() reads depth through this camera.
+		light.shadow.camera.coordinateSystem = builder.renderer.coordinateSystem;
+		light.shadow.camera._reversedDepth = builder.renderer.reversedDepthBuffer;
+
 	}
 
 	/**
@@ -259,6 +273,11 @@ class TileShadowNode extends ShadowBaseNode {
 
 		}
 
+		// The original light does not render a shadow map, but setup() uses its shadow matrix.
+
+		shadowCam.updateProjectionMatrix();
+		light.shadow.updateMatrices( light );
+
 	}
 
 	/**
@@ -270,14 +289,15 @@ class TileShadowNode extends ShadowBaseNode {
 		const { shadowMap, light } = this;
 		const { renderer, scene, camera } = frame;
 		const shadowType = renderer.shadowMap.type;
-		const depthVersion = shadowMap.depthTexture.version;
-		this._depthVersionCached = depthVersion;
 		const currentRenderObjectFunction = renderer.getRenderObjectFunction();
 
 		_rendererState = resetRendererAndSceneState( renderer, scene, _rendererState );
 		scene.overrideMaterial = this.getShadowMaterial();
 		renderer.setRenderTarget( this.shadowMap );
 
+		const cameraArrayLayers = this.cameraArray.layers.mask;
+		this.cameraArray.layers.mask = 0;
+
 		for ( let index = 0; index < this.lights.length; index ++ ) {
 
 			const light = this.lights[ index ];
@@ -294,6 +314,9 @@ class TileShadowNode extends ShadowBaseNode {
 
 			shadow.updateMatrices( light );
 
+			// The tiles render through the array camera, so it has to see every tile's layers.
+			this.cameraArray.layers.mask |= shadow.camera.layers.mask;
+
 			renderer.setRenderObjectFunction( this.getShadowRenderObjectFunction( renderer, shadow ) );
 			this.shadowMap.setSize( shadow.mapSize.width, shadow.mapSize.height, shadowMap.depth );
 
@@ -311,6 +334,8 @@ class TileShadowNode extends ShadowBaseNode {
 
 		restoreRendererAndSceneState( renderer, scene, _rendererState );
 
+		this.cameraArray.layers.mask = cameraArrayLayers;
+
 		for ( let index = 0; index < this.lights.length; index ++ ) {
 
 			const light = this.lights[ index ];
@@ -352,11 +377,7 @@ class TileShadowNode extends ShadowBaseNode {
 			this.update();
 			this.updateShadow( frame );
 
-			if ( this.shadowMap.depthTexture.version === this._depthVersionCached ) {
-
-				shadow.needsUpdate = false;
-
-			}
+			shadow.needsUpdate = false;
 
 		}
 
@@ -400,10 +421,77 @@ class TileShadowNode extends ShadowBaseNode {
 
 		}
 
+		// Hardware-filtered depth comparisons for PCF, as in ShadowNode. The shadow type can change between
+		// builds, so this is checked every time; disposing the shadow map recreates it with the new filter.
+
+		const { renderer } = builder;
+		const filter = renderer.shadowMap.type === PCFShadowMap && renderer.hasCompatibility( Compatibility.TEXTURE_COMPARE ) ? LinearFilter : NearestFilter;
+		const depthTexture = this.shadowMap.depthTexture;
+
+		if ( depthTexture.magFilter !== filter ) {
+
+			depthTexture.minFilter = filter;
+			depthTexture.magFilter = filter;
+
+			this.shadowMap.dispose();
+
+		}
+
 		return Fn( ( builder ) => {
 
 			this.setupShadowPosition( builder );
-			return min( ...this._shadowNodes ).toVar( 'shadowValue' );
+
+			// The fragment's position in the full shadow camera gives its tile and the coordinate within it.
+
+			const { tilesX, tilesY } = this.config;
+			const tileShadowNode = this._shadowNodes[ 0 ];
+			const tileShadow = this.lights[ 0 ].shadow;
+			const shadow = this.originalLight.shadow;
+			const normalBias = reference( 'normalBias', 'float', shadow ).setGroup( renderGroup );
+
+			const shadowPosition = lightShadowMatrix( this.originalLight ).mul( vec4( shadowPositionWorld.add( normalWorld.mul( normalBias ) ), 1 ) );
+			const shadowCoord = tileShadowNode.setupShadowCoord( builder, shadowPosition );
+
+			const grid = shadowCoord.xy.mul( vec2( tilesX, tilesY ) ); // tiles start from the top row
+			const tile = grid.floor().clamp( vec2( 0 ), vec2( tilesX - 1, tilesY - 1 ) );
+			const depthLayer = int( tile.y.mul( tilesX ).add( tile.x ) );
+
+			const tileCoord = vec3( grid.sub( tile ), shadowCoord.z );
+
+			const filterFn = tileShadow.filterNode || tileShadowNode.getShadowFilterFn( builder.renderer.shadowMap.type );
+			const shadowValue = tileShadowNode.setupShadowFilter( builder, {
+				filterFn,
+				depthTexture,
+				shadowCoord: tileCoord,
+				shadow: tileShadow,
+				depthLayer
+			} );
+
+			const shadowIntensity = reference( 'intensity', 'float', shadow ).setGroup( renderGroup );
+
+			let shadowOutput;
+
+			if ( builder.renderer.shadowMap.transmitted === true ) {
+
+				const shadowColor = texture( this.shadowMap.texture, tileCoord ).depth( depthLayer );
+
+				shadowOutput = mix( 1, shadowValue.rgb.mix( shadowColor, 1 ), shadowIntensity.mul( shadowColor.a ) ).toVar( 'shadowValue' );
+
+			} else {
+
+				shadowOutput = mix( 1, shadowValue, shadowIntensity ).toVar( 'shadowValue' );
+
+			}
+
+			// As in ShadowNode.setup(), which the tiles no longer go through.
+
+			if ( builder.material.receivedShadowNode ) {
+
+				shadowOutput = builder.material.receivedShadowNode( shadowOutput );
+
+			}
+
+			return shadowOutput;
 
 		} )();