@gnsx/three 0.184.8 → 0.184.10

package/examples/jsm/lighting/LightProbeGrid.js

@@ -18,6 +18,26 @@ import {
 	WebGLCubeRenderTarget,
 	WebGLRenderTarget
 } from 'three';
+// WITH_GENESYS
+import { CubeRenderTarget, Storage3DTexture } from 'three/webgpu';
+import {
+	Fn,
+	If,
+	Loop,
+	PI,
+	convert,
+	cubeTexture,
+	float,
+	int,
+	select,
+	storageTexture,
+	textureStore,
+	uniform,
+	uvec3,
+	vec3,
+	vec4
+} from 'three/tsl';
+// !WITH_GENESYS
 
 // Shared fullscreen-quad scene / camera
 let _scene = null;
@@ -38,6 +58,21 @@ let _cachedCubemapSize = 0;
 let _cachedNear = 0;
 let _cachedFar = 0;
 
+// WITH_GENESYS
+// Cached WebGPU bake resources. The WebGPU path projects cubemaps on the GPU
+// via TSL compute and writes directly into a Storage3DTexture atlas.
+let _webgpuCubeRenderTarget = null;
+let _webgpuCubeCamera = null;
+let _webgpuCachedCubemapSize = 0;
+let _webgpuCachedNear = 0;
+let _webgpuCachedFar = 0;
+let _webgpuComputeNode = null;
+let _webgpuComputeCubemapSize = 0;
+let _webgpuComputeAtlas = null;
+let _webgpuComputeEnvMap = null;
+let _webgpuProbeUniforms = null;
+// !WITH_GENESYS
+
 // Cached batch render target
 let _batchTarget = null;
 let _batchTargetProbes = 0;
@@ -161,6 +196,33 @@ class LightProbeGrid extends Object3D {
 		 */
 		this._renderTarget = null;
 
+		/**
+		 * Array of cube textures captured during baking, only populated
+		 * when `retainCubemaps` option is true in {@link LightProbeGrid#bake}.
+		 *
+		 * @type {?CubeTexture[]}
+		 * @default null
+		 */
+		this.cubeTextures = null;
+
+		/**
+		 * Render targets backing retained cube textures.
+		 *
+		 * @private
+		 * @type {?Array<WebGLCubeRenderTarget|CubeRenderTarget>}
+		 * @default null
+		 */
+		this._cubeRenderTargets = null;
+
+		/**
+		 * Whether retained cube render targets are WebGPU render targets.
+		 *
+		 * @private
+		 * @type {?boolean}
+		 * @default null
+		 */
+		this._cubeRenderTargetsWebGPU = null;
+
 		this.updateBoundingBox();
 
 	}
@@ -210,134 +272,395 @@ class LightProbeGrid extends Object3D {
 	 * @param {number} [options.cubemapSize=8] - Resolution of each cubemap face.
 	 * @param {number} [options.near=0.1] - Near plane for the cube camera.
 	 * @param {number} [options.far=100] - Far plane for the cube camera.
+	 * @param {boolean} [options.retainCubemaps=false] - Whether to retain the captured cube maps for visualization.
+	 * @return {Promise<void>} Resolves when baking has completed.
 	 */
-	bake( renderer, scene, options = {} ) {
+	async bake( renderer, scene, options = {} ) {
 
-		const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );
-
-		this._ensureTextures();
-		this.updateBoundingBox();
+		const wasVisible = this.visible; // WITH_GENESYS
+		const retainCubemaps = options.retainCubemaps === true;
 
 		// Prevent feedback: temporarily hide the volume during baking
 		this.visible = false;
 
-		const res = this.resolution;
-		const totalProbes = res.x * res.y * res.z;
+		if ( ! retainCubemaps ) this._disposeRetainedCubemaps();
 
-		// Batch render target for SH coefficients: 9 pixels wide, one row per probe
-		const batchTarget = _ensureBatchTarget( totalProbes );
+		// WITH_GENESYS
+		if ( renderer.isWebGPURenderer === true ) {
 
-		// Save renderer state
-		const savedRenderTarget = renderer.getRenderTarget();
-		renderer.getViewport( _savedViewport );
-		renderer.getScissor( _savedScissor );
-		const savedScissorTest = renderer.getScissorTest();
+			await this._bakeWebGPU( renderer, scene, options );
 
-		// Clear pooled batch target so skipped probes read as zero
-		batchTarget.scissorTest = false;
-		batchTarget.viewport.set( 0, 0, 9, totalProbes );
-		renderer.setRenderTarget( batchTarget );
-		renderer.clear();
+		} else { // !WITH_GENESYS
 
-		// const t0 = performance.now();
+			const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );
 
-		// Phase 1: Render cubemaps and project to SH into batch target
-		// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
-		batchTarget.scissorTest = true;
+			this._ensureTextures();
+			this.updateBoundingBox();
 
-		// Disable shadow map auto-update during bake — lights don't move between probes.
-		// Force one shadow update on the first render so maps are initialized.
-		const savedShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-		renderer.shadowMap.autoUpdate = false;
-		renderer.shadowMap.needsUpdate = true;
+			const res = this.resolution;
+			const totalProbes = res.x * res.y * res.z;
 
-		for ( let iz = 0; iz < res.z; iz ++ ) {
+			// Batch render target for SH coefficients: 9 pixels wide, one row per probe
+			const batchTarget = _ensureBatchTarget( totalProbes );
 
-			for ( let iy = 0; iy < res.y; iy ++ ) {
+			// Save renderer state
+			const savedRenderTarget = renderer.getRenderTarget();
+			renderer.getViewport( _savedViewport );
+			renderer.getScissor( _savedScissor );
+			const savedScissorTest = renderer.getScissorTest();
 
-				for ( let ix = 0; ix < res.x; ix ++ ) {
+			// Clear pooled batch target so skipped probes read as zero
+			batchTarget.scissorTest = false;
+			batchTarget.viewport.set( 0, 0, 9, totalProbes );
+			renderer.setRenderTarget( batchTarget );
+			renderer.clear();
 
-					const probeIndex = ix + iy * res.x + iz * res.x * res.y;
+			// const t0 = performance.now();
 
-					this.getProbePosition( ix, iy, iz, _position );
-					cubeCamera.position.copy( _position );
-					cubeCamera.update( renderer, scene );
+			// Phase 1: Render cubemaps and project to SH into batch target
+			// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
+			batchTarget.scissorTest = true;
 
-					// SH projection
-					_shMaterial.uniforms.envMap.value = cubeRenderTarget.texture;
-					_mesh.material = _shMaterial;
-					batchTarget.viewport.set( 0, probeIndex, 9, 1 );
-					batchTarget.scissor.set( 0, probeIndex, 9, 1 );
-					renderer.setRenderTarget( batchTarget );
-					renderer.render( _scene, _camera );
+			// Disable shadow map auto-update during bake — lights don't move between probes.
+			// Force one shadow update on the first render so maps are initialized.
+			const savedShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+			renderer.shadowMap.autoUpdate = false;
+			renderer.shadowMap.needsUpdate = true;
+
+			// Initialize cube texture/render target arrays if retaining
+			if ( retainCubemaps ) {
+
+				if ( this.cubeTextures === null || this.cubeTextures.length !== totalProbes ) {
+
+					this.cubeTextures = new Array( totalProbes );
+
+				}
+
+				if ( this._cubeRenderTargets === null || this._cubeRenderTargets.length !== totalProbes ) {
+
+					this._disposeRetainedCubemaps();
+					this.cubeTextures = new Array( totalProbes );
+
+					this._cubeRenderTargets = new Array( totalProbes );
 
 				}
 
 			}
 
-		}
+			for ( let iz = 0; iz < res.z; iz ++ ) {
 
-		renderer.shadowMap.autoUpdate = savedShadowAutoUpdate;
+				for ( let iy = 0; iy < res.y; iy ++ ) {
 
-		// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
-		//
-		// For each of the 7 packed sub-volumes (texture index t) we write:
-		//   - A leading padding slice  (copy of data slice iz = 0)
-		//   - All nz data slices       (iz = 0 … nz-1)
-		//   - A trailing padding slice (copy of data slice iz = nz-1)
-		//
-		// In the atlas the slices for sub-volume t occupy the range:
-		//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
-		// where paddedSlices = nz + 2 * ATLAS_PADDING.
+					for ( let ix = 0; ix < res.x; ix ++ ) {
 
-		_ensureRepackResources();
+						const probeIndex = ix + iy * res.x + iz * res.x * res.y;
 
-		const paddedSlices = res.z + 2 * ATLAS_PADDING;
-		const rt = this._renderTarget;
-		rt.scissorTest = false;
-		rt.viewport.set( 0, 0, res.x, res.y );
+						this.getProbePosition( ix, iy, iz, _position );
 
-		for ( let t = 0; t < 7; t ++ ) {
+						let envMapTexture = cubeRenderTarget.texture;
 
-			_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
-			_repackMaterials[ t ].uniforms.resolution.value.copy( res );
+						if ( retainCubemaps ) {
 
-			// Write data slices
-			for ( let iz = 0; iz < res.z; iz ++ ) {
+							const retainedTarget = this._ensureRetainedCubeRenderTarget( probeIndex, options );
+							const retainedCamera = new CubeCamera(
+								options.near !== undefined ? options.near : 0.1,
+								options.far !== undefined ? options.far : 100,
+								retainedTarget
+							);
+
+							retainedCamera.position.copy( _position );
+							retainedCamera.update( renderer, scene );
+
+							envMapTexture = retainedTarget.texture;
+							this.cubeTextures[ probeIndex ] = retainedTarget.texture;
+
+						} else {
+
+							cubeCamera.position.copy( _position );
+							cubeCamera.update( renderer, scene );
+
+						}
+
+						// SH projection
+						_shMaterial.uniforms.envMap.value = envMapTexture;
+						_mesh.material = _shMaterial;
+						batchTarget.viewport.set( 0, probeIndex, 9, 1 );
+						batchTarget.scissor.set( 0, probeIndex, 9, 1 );
+						renderer.setRenderTarget( batchTarget );
+						renderer.render( _scene, _camera );
+
+					}
+
+				}
+
+			}
+
+			renderer.shadowMap.autoUpdate = savedShadowAutoUpdate;
+
+			// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
+			//
+			// For each of the 7 packed sub-volumes (texture index t) we write:
+			//   - A leading padding slice  (copy of data slice iz = 0)
+			//   - All nz data slices       (iz = 0 … nz-1)
+			//   - A trailing padding slice (copy of data slice iz = nz-1)
+			//
+			// In the atlas the slices for sub-volume t occupy the range:
+			//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
+			// where paddedSlices = nz + 2 * ATLAS_PADDING.
+
+			_ensureRepackResources();
+
+			const paddedSlices = res.z + 2 * ATLAS_PADDING;
+			const rt = this._renderTarget;
+			rt.scissorTest = false;
+			rt.viewport.set( 0, 0, res.x, res.y );
+
+			for ( let t = 0; t < 7; t ++ ) {
+
+				_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
+				_repackMaterials[ t ].uniforms.resolution.value.copy( res );
+
+				// Write data slices
+				for ( let iz = 0; iz < res.z; iz ++ ) {
+
+					_repackMaterials[ t ].uniforms.sliceZ.value = iz;
+					_mesh.material = _repackMaterials[ t ];
+					renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
+					renderer.render( _scene, _camera );
+
+				}
+
+				// Leading padding: copy of data slice iz = 0
+				_repackMaterials[ t ].uniforms.sliceZ.value = 0;
+				_mesh.material = _repackMaterials[ t ];
+				renderer.setRenderTarget( rt, t * paddedSlices );
+				renderer.render( _scene, _camera );
 
-				_repackMaterials[ t ].uniforms.sliceZ.value = iz;
+				// Trailing padding: copy of data slice iz = nz - 1
+				_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
 				_mesh.material = _repackMaterials[ t ];
-				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
+				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
 				renderer.render( _scene, _camera );
 
 			}
 
-			// Leading padding: copy of data slice iz = 0
-			_repackMaterials[ t ].uniforms.sliceZ.value = 0;
-			_mesh.material = _repackMaterials[ t ];
-			renderer.setRenderTarget( rt, t * paddedSlices );
-			renderer.render( _scene, _camera );
+			// Restore renderer state
+			renderer.setRenderTarget( savedRenderTarget );
+			renderer.setViewport( _savedViewport );
+			renderer.setScissor( _savedScissor );
+			renderer.setScissorTest( savedScissorTest );
 
-			// Trailing padding: copy of data slice iz = nz - 1
-			_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
-			_mesh.material = _repackMaterials[ t ];
-			renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
-			renderer.render( _scene, _camera );
+			// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );
 
 		}
 
-		// Restore renderer state
-		renderer.setRenderTarget( savedRenderTarget );
-		renderer.setViewport( _savedViewport );
-		renderer.setScissor( _savedScissor );
-		renderer.setScissorTest( savedScissorTest );
+		this.visible = wasVisible; // WITH_GENESYS
+		// this.visible = true;
 
-		// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );
+	}
+
+	// WITH_GENESYS
+	/**
+	 * Ensures a retained cube render target exists for a probe.
+	 *
+	 * @private
+	 * @param {number} probeIndex - The probe index.
+	 * @param {Object} options - Bake options.
+	 * @param {boolean} [webgpu=false] - Whether to create a WebGPU cube render target.
+	 * @return {WebGLCubeRenderTarget|CubeRenderTarget} The retained cube render target.
+	 */
+	_ensureRetainedCubeRenderTarget( probeIndex, options, webgpu = false ) {
+
+		const cubemapSize = options.cubemapSize !== undefined ? options.cubemapSize : 8;
+
+		if ( this._cubeRenderTargetsWebGPU !== null && this._cubeRenderTargetsWebGPU !== webgpu ) {
+
+			this._disposeRetainedCubemaps();
+
+		}
+
+		if ( this._cubeRenderTargets === null ) {
+
+			this._cubeRenderTargets = [];
+
+		}
+
+		this._cubeRenderTargetsWebGPU = webgpu;
+
+		let target = this._cubeRenderTargets[ probeIndex ];
 
-		this.visible = true;
+		if ( target === undefined || target.width !== cubemapSize || target.height !== cubemapSize ) {
+
+			if ( target !== undefined ) target.dispose();
+
+			target = webgpu === true
+				? new CubeRenderTarget( cubemapSize, { type: HalfFloatType } )
+				: new WebGLCubeRenderTarget( cubemapSize, { type: HalfFloatType } );
+			this._cubeRenderTargets[ probeIndex ] = target;
+
+		}
+
+		return target;
 
 	}
 
+	/**
+	 * Frees retained cube map render targets.
+	 *
+	 * @private
+	 */
+	_disposeRetainedCubemaps() {
+
+		if ( this._cubeRenderTargets !== null ) {
+
+			for ( const target of this._cubeRenderTargets ) {
+
+				if ( target !== undefined ) target.dispose();
+
+			}
+
+			this._cubeRenderTargets = null;
+
+		}
+
+		this._cubeRenderTargetsWebGPU = null;
+		this.cubeTextures = null;
+
+	}
+
+	/**
+	 * Frees retained cube maps used for cube map visualization.
+	 */
+	disposeRetainedCubemaps() {
+
+		this._disposeRetainedCubemaps();
+
+	}
+
+	/**
+	 * Bakes all probes with a WebGPU renderer.
+	 *
+	 * @private
+	 * @async
+	 * @param {WebGPURenderer} renderer - The renderer.
+	 * @param {Scene} scene - The scene to render.
+	 * @param {Object} [options] - Bake options.
+	 * @return {Promise<void>} Resolves when baking has completed.
+	 */
+	async _bakeWebGPU( renderer, scene, options = {} ) {
+
+		const cubemapSize = options.cubemapSize !== undefined ? options.cubemapSize : 8;
+		const retainCubemaps = options.retainCubemaps === true;
+		const { cubeRenderTarget, cubeCamera } = _ensureWebGPUBakeResources( options );
+
+		this._ensureWebGPUTexture();
+		this.updateBoundingBox();
+
+		const computeNode = _ensureWebGPUComputeResources( cubemapSize, cubeRenderTarget.texture, this.texture );
+		const uniforms = _webgpuProbeUniforms;
+
+		const res = this.resolution;
+		const nx = res.x, ny = res.y, nz = res.z;
+		const totalProbes = nx * ny * nz;
+		const paddedSlices = nz + 2 * ATLAS_PADDING;
+
+		uniforms.paddedSlices.value = paddedSlices;
+
+		const savedShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+		renderer.shadowMap.autoUpdate = false;
+		renderer.shadowMap.needsUpdate = true;
+
+		// Initialize cube textures array if retaining
+		if ( retainCubemaps ) {
+
+			if ( this.cubeTextures === null || this.cubeTextures.length !== totalProbes ) {
+
+				this.cubeTextures = new Array( totalProbes );
+
+			}
+
+			if ( this._cubeRenderTargets === null || this._cubeRenderTargets.length !== totalProbes ) {
+
+				this._disposeRetainedCubemaps();
+				this.cubeTextures = new Array( totalProbes );
+				this._cubeRenderTargets = new Array( totalProbes );
+
+			}
+
+		}
+
+		for ( let iz = 0; iz < nz; iz ++ ) {
+
+			for ( let iy = 0; iy < ny; iy ++ ) {
+
+				for ( let ix = 0; ix < nx; ix ++ ) {
+
+					const probeIndex = ix + iy * nx + iz * nx * ny;
+
+					this.getProbePosition( ix, iy, iz, _position );
+					cubeCamera.position.copy( _position );
+					cubeCamera.update( renderer, scene );
+
+					if ( retainCubemaps ) {
+
+						const retainedTarget = this._ensureRetainedCubeRenderTarget( probeIndex, options, true );
+						const retainedCamera = new CubeCamera(
+							options.near !== undefined ? options.near : 0.1,
+							options.far !== undefined ? options.far : 100,
+							retainedTarget
+						);
+
+						retainedCamera.position.copy( _position );
+						retainedCamera.update( renderer, scene );
+
+						this.cubeTextures[ probeIndex ] = retainedTarget.texture;
+
+					}
+
+					uniforms.probeIx.value = ix;
+					uniforms.probeIy.value = iy;
+					uniforms.probeIz.value = iz;
+
+					renderer.compute( computeNode );
+
+				}
+
+			}
+
+		}
+
+		renderer.shadowMap.autoUpdate = savedShadowAutoUpdate;
+
+		// Padding slices (GPU-to-GPU copy of nearest edge data slices).
+		const atlas = this.texture;
+
+		for ( let textureIndex = 0; textureIndex < 7; textureIndex ++ ) {
+
+			const baseSlice = textureIndex * paddedSlices;
+			const dataSlice = baseSlice + ATLAS_PADDING;
+			const trailingSlice = dataSlice + nz;
+
+			renderer.copyTextureToTexture(
+				atlas,
+				atlas,
+				new Box3( new Vector3( 0, 0, dataSlice ), new Vector3( nx, ny, dataSlice + 1 ) ),
+				new Vector3( 0, 0, baseSlice )
+			);
+
+			renderer.copyTextureToTexture(
+				atlas,
+				atlas,
+				new Box3( new Vector3( 0, 0, dataSlice + nz - 1 ), new Vector3( nx, ny, dataSlice + nz ) ),
+				new Vector3( 0, 0, trailingSlice )
+			);
+
+		}
+
+		await renderer.backend.device.queue.onSubmittedWorkDone();
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Ensures the atlas 3D render target exists with the correct dimensions.
 	 *
@@ -347,6 +670,15 @@ class LightProbeGrid extends Object3D {
 
 		if ( this._renderTarget !== null ) return;
 
+		// WITH_GENESYS
+		if ( this.texture !== null ) {
+
+			this.texture.dispose();
+			this.texture = null;
+
+		}
+		// !WITH_GENESYS
+
 		const res = this.resolution;
 		const nx = res.x, ny = res.y, nz = res.z;
 
@@ -367,6 +699,54 @@ class LightProbeGrid extends Object3D {
 
 	}
 
+	// WITH_GENESYS
+	/**
+	 * Ensures the atlas Storage3DTexture exists with the correct dimensions for WebGPU.
+	 *
+	 * @private
+	 */
+	_ensureWebGPUTexture() {
+
+		if ( this._renderTarget !== null ) {
+
+			this._renderTarget.dispose();
+			this._renderTarget = null;
+			this.texture = null;
+
+		}
+
+		const res = this.resolution;
+		const nx = res.x, ny = res.y, nz = res.z;
+		const atlasDepth = 7 * ( nz + 2 * ATLAS_PADDING );
+
+		if ( this.texture !== null ) {
+
+			const image = this.texture.image;
+
+			if ( image.width === nx && image.height === ny && image.depth === atlasDepth ) {
+
+				return;
+
+			}
+
+			this.texture.dispose();
+			this.texture = null;
+
+		}
+
+		const texture = new Storage3DTexture( nx, ny, atlasDepth );
+
+		texture.format = RGBAFormat;
+		texture.type = FloatType;
+		texture.minFilter = LinearFilter;
+		texture.magFilter = LinearFilter;
+		texture.generateMipmaps = false;
+
+		this.texture = texture;
+
+	}
+	// !WITH_GENESYS
+
 	/**
 	 * Frees GPU resources.
 	 */
@@ -378,7 +758,14 @@ class LightProbeGrid extends Object3D {
 			this._renderTarget = null;
 			this.texture = null;
 
-		}
+		} else if ( this.texture !== null ) { // WITH_GENESYS
+
+			this.texture.dispose();
+			this.texture = null;
+
+		} // !WITH_GENESYS
+
+		this._disposeRetainedCubemaps();
 
 	}
 
@@ -627,6 +1014,163 @@ function _ensureBakeResources( options ) {
 
 }
 
+// WITH_GENESYS
+function _ensureWebGPUBakeResources( options ) {
+
+	const {
+		cubemapSize = 8,
+		near = 0.1,
+		far = 100
+	} = options;
+
+	if ( _webgpuCubeRenderTarget === null || cubemapSize !== _webgpuCachedCubemapSize || near !== _webgpuCachedNear || far !== _webgpuCachedFar ) {
+
+		if ( _webgpuCubeRenderTarget !== null ) _webgpuCubeRenderTarget.dispose();
+
+		_webgpuCubeRenderTarget = new CubeRenderTarget( cubemapSize, { type: HalfFloatType } );
+		_webgpuCubeCamera = new CubeCamera( near, far, _webgpuCubeRenderTarget );
+		_webgpuCachedCubemapSize = cubemapSize;
+		_webgpuCachedNear = near;
+		_webgpuCachedFar = far;
+
+	}
+
+	return { cubeRenderTarget: _webgpuCubeRenderTarget, cubeCamera: _webgpuCubeCamera };
+
+}
+
+function _ensureWebGPUComputeResources( cubemapSize, envMapTexture, atlasTexture ) {
+
+	if (
+		_webgpuComputeNode !== null &&
+		_webgpuComputeCubemapSize === cubemapSize &&
+		_webgpuComputeAtlas === atlasTexture &&
+		_webgpuComputeEnvMap === envMapTexture
+	) {
+
+		return _webgpuComputeNode;
+
+	}
+
+	_webgpuComputeCubemapSize = cubemapSize;
+	_webgpuComputeAtlas = atlasTexture;
+	_webgpuComputeEnvMap = envMapTexture;
+
+	const probeIx = uniform( 'uint' );
+	const probeIy = uniform( 'uint' );
+	const probeIz = uniform( 'uint' );
+	const paddedSlices = uniform( 'uint' );
+
+	_webgpuProbeUniforms = { probeIx, probeIy, probeIz, paddedSlices };
+
+	const atlas = storageTexture( atlasTexture );
+
+	const projectProbe = Fn( () => {
+
+		const accum0 = vec3( 0 ).toVar();
+		const accum1 = vec3( 0 ).toVar();
+		const accum2 = vec3( 0 ).toVar();
+		const accum3 = vec3( 0 ).toVar();
+		const accum4 = vec3( 0 ).toVar();
+		const accum5 = vec3( 0 ).toVar();
+		const accum6 = vec3( 0 ).toVar();
+		const accum7 = vec3( 0 ).toVar();
+		const accum8 = vec3( 0 ).toVar();
+		const totalWeight = float( 0 ).toVar();
+		const pixelSize = float( 2 ).div( float( cubemapSize ) );
+
+		Loop(
+			{ end: 6, name: 'face', type: 'int' },
+			{ end: cubemapSize, name: 'iy', type: 'int' },
+			{ end: cubemapSize, name: 'ix', type: 'int' },
+			( { face, iy, ix } ) => {
+
+				const col = convert( ix, 'float' ).add( 0.5 ).mul( pixelSize ).sub( 1.0 );
+				const row = float( 1 ).sub( convert( iy, 'float' ).add( 0.5 ).mul( pixelSize ) );
+
+				const dirX = select( face.equal( int( 0 ) ), float( 1 ), select( face.equal( int( 1 ) ), float( - 1 ), select( face.equal( int( 5 ) ), col.negate(), col ) ) );
+				const dirY = select( face.equal( int( 2 ) ), float( 1 ), select( face.equal( int( 3 ) ), float( - 1 ), row ) );
+				const dirZ = select( face.equal( int( 0 ) ), col.negate(), select( face.equal( int( 1 ) ), col, select( face.equal( int( 2 ) ), row.negate(), select( face.equal( int( 3 ) ), row, select( face.equal( int( 4 ) ), float( 1 ), float( - 1 ) ) ) ) ) );
+				const coord = vec3( dirX, dirY, dirZ );
+
+				const lengthSq = coord.dot( coord );
+				const weight = float( 4 ).div( lengthSq.sqrt().mul( lengthSq ) );
+				totalWeight.addAssign( weight );
+
+				const dir = coord.normalize();
+				// Pass explicit direction — omitting UV would default to reflectVector (needs camera).
+				const cw = cubeTexture( envMapTexture, coord ).rgb.mul( weight );
+
+				accum0.addAssign( cw.mul( 0.282095 ) );
+				accum1.addAssign( cw.mul( 0.488603 ).mul( dir.y ) );
+				accum2.addAssign( cw.mul( 0.488603 ).mul( dir.z ) );
+				accum3.addAssign( cw.mul( 0.488603 ).mul( dir.x ) );
+				accum4.addAssign( cw.mul( 1.092548 ).mul( dir.x ).mul( dir.y ) );
+				accum5.addAssign( cw.mul( 1.092548 ).mul( dir.y ).mul( dir.z ) );
+				accum6.addAssign( cw.mul( 0.315392 ).mul( dir.z.mul( dir.z ).mul( 3 ).sub( 1 ) ) );
+				accum7.addAssign( cw.mul( 1.092548 ).mul( dir.x ).mul( dir.z ) );
+				accum8.addAssign( cw.mul( 0.546274 ).mul( dir.x.mul( dir.x ).sub( dir.y.mul( dir.y ) ) ) );
+
+			}
+
+		);
+
+		const norm = float( 4 ).mul( PI ).div( totalWeight );
+		const c0 = accum0.mul( norm );
+		const c1 = accum1.mul( norm );
+		const c2 = accum2.mul( norm );
+		const c3 = accum3.mul( norm );
+		const c4 = accum4.mul( norm );
+		const c5 = accum5.mul( norm );
+		const c6 = accum6.mul( norm );
+		const c7 = accum7.mul( norm );
+		const c8 = accum8.mul( norm );
+
+		Loop( { end: 7, name: 't', type: 'int' }, ( { t } ) => {
+
+			const atlasZ = paddedSlices.mul( t ).add( 1 ).add( probeIz );
+
+			If( t.equal( int( 0 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c0.x, c0.y, c0.z, c1.x ) ).toWriteOnly();
+
+			} ).ElseIf( t.equal( int( 1 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c1.y, c1.z, c2.x, c2.y ) ).toWriteOnly();
+
+			} ).ElseIf( t.equal( int( 2 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c2.z, c3.x, c3.y, c3.z ) ).toWriteOnly();
+
+			} ).ElseIf( t.equal( int( 3 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c4.x, c4.y, c4.z, c5.x ) ).toWriteOnly();
+
+			} ).ElseIf( t.equal( int( 4 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c5.y, c5.z, c6.x, c6.y ) ).toWriteOnly();
+
+			} ).ElseIf( t.equal( int( 5 ) ), () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c6.z, c7.x, c7.y, c7.z ) ).toWriteOnly();
+
+			} ).Else( () => {
+
+				textureStore( atlas, uvec3( probeIx, probeIy, atlasZ ), vec4( c8.x, c8.y, c8.z, float( 0 ) ) ).toWriteOnly();
+
+			} );
+
+		} );
+
+	} );
+
+	_webgpuComputeNode = projectProbe().compute( 1 );
+
+	return _webgpuComputeNode;
+
+}
+// !WITH_GENESYS
+
 function _ensureBatchTarget( totalProbes ) {
 
 	if ( _batchTarget === null || _batchTargetProbes !== totalProbes ) {