three.js/examples/jsm/lighting/LightProbeGrid.js

import {
	Box3,
	CubeCamera,
	Data3DTexture,
	DataUtils,
	FloatType,
	HalfFloatType,
	LinearFilter,
	Mesh,
	NearestFilter,
	Object3D,
	OrthographicCamera,
	PlaneGeometry,
	RGBAFormat,
	Scene,
	ShaderMaterial,
	Vector3,
	Vector4,
	WebGL3DRenderTarget,
	WebGLCubeRenderTarget,
	WebGLRenderTarget
} from 'three';

// Number of SH coefficients stored per probe: 9 L2 bands x 3 colour channels.
const COEFFICIENTS_PER_PROBE = 27;

// Fixed-point scale used by toJSON(): coefficients are stored as
// Math.round( value * SERIALIZE_SCALE ) integers. 4096 keeps the quantization
// error around 1e-4 (negligible for irradiance) while gzipping very well.
const SERIALIZE_SCALE = 4096;

// Shared fullscreen-quad scene / camera
let _scene = null;
let _camera = null;
let _mesh = null;

// SH projection material (depends on cubemapSize)
let _shMaterial = null;
let _lastCubemapSize = 0;

// Repack materials (one per output sub-volume / texture index)
let _repackMaterials = null;

// Cached bake resources
let _cubeRenderTarget = null;
let _cubeCamera = null;
let _cachedCubemapSize = 0;
let _cachedNear = 0;
let _cachedFar = 0;

// Cached batch render target
let _batchTarget = null;
let _batchTargetProbes = 0;

// Reusable temp objects
const _position = /*@__PURE__*/ new Vector3();
const _size = /*@__PURE__*/ new Vector3();
const _currentViewport = /*@__PURE__*/ new Vector4();
const _currentScissor = /*@__PURE__*/ new Vector4();

// Number of padding texels added at each boundary of every sub-volume in the atlas.
const ATLAS_PADDING = 1;

/**
 * A 3D grid of L2 Spherical Harmonic irradiance probes that provides
 * position-dependent diffuse global illumination.
 *
 * Note that this class can only be used with {@link WebGLRenderer}.
 * A version for {@link WebGPURenderer} will be added at a later point.
 *
 * All seven packed SH sub-volumes are stored in a **single** RGBA
 * `WebGL3DRenderTarget` using a texture-atlas layout along the Z axis.
 * Each sub-volume occupies `( nz + 2 )` atlas slices: one padding slice at
 * each end (a copy of the nearest edge data slice) to prevent color bleeding
 * when the hardware trilinear filter reads across a sub-volume boundary.
 *
 * Atlas layout (nz = resolution.z, PADDING = 1):
 * ```
 *   slice   0              : padding  (copy of sub-volume 0, data slice 0)
 *   slices  1 … nz         : sub-volume 0 data
 *   slice   nz + 1         : padding  (copy of sub-volume 0, data slice nz-1)
 *   slice   nz + 2         : padding  (copy of sub-volume 1, data slice 0)
 *   slices  nz+3 … 2*nz+2  : sub-volume 1 data
 *   …
 * ```
 * Total atlas depth = `7 * ( nz + 2 )`.
 *
 * Baking happens almost entirely on the GPU — cubemap rendering, SH
 * projection, and texture packing all run as GPU passes; only a small
 * `9 x totalProbes` SH coefficient buffer is read back to the CPU at the
 * end of baking so the result can be serialized via {@link LightProbeGrid#toJSON}.
 *
 * @three_import import { LightProbeGrid } from 'three/addons/lighting/LightProbeGrid.js';
 */
class LightProbeGrid extends Object3D {

	/**
	 * Constructs a new irradiance probe grid.
	 *
	 * The volume is centered at the object's position.
	 *
	 * @param {number} [width=1] - Full width of the volume along X.
	 * @param {number} [height=1] - Full height of the volume along Y.
	 * @param {number} [depth=1] - Full depth of the volume along Z.
	 * @param {number} [widthProbes] - Number of probes along X. Defaults to `Math.max( 2, Math.round( width ) + 1 )`.
	 * @param {number} [heightProbes] - Number of probes along Y. Defaults to `Math.max( 2, Math.round( height ) + 1 )`.
	 * @param {number} [depthProbes] - Number of probes along Z. Defaults to `Math.max( 2, Math.round( depth ) + 1 )`.
	 */
	constructor( width = 1, height = 1, depth = 1, widthProbes, heightProbes, depthProbes ) {

		super();

		/**
		 * This flag can be used for type testing.
		 *
		 * @type {boolean}
		 * @readonly
		 * @default true
		 */
		this.isLightProbeGrid = true;

		/**
		 * The full width of the volume along X.
		 *
		 * @type {number}
		 */
		this.width = width;

		/**
		 * The full height of the volume along Y.
		 *
		 * @type {number}
		 */
		this.height = height;

		/**
		 * The full depth of the volume along Z.
		 *
		 * @type {number}
		 */
		this.depth = depth;

		/**
		 * The number of probes along each axis.
		 *
		 * @type {Vector3}
		 */
		this.resolution = new Vector3(
			widthProbes !== undefined ? widthProbes : Math.max( 2, Math.round( width ) + 1 ),
			heightProbes !== undefined ? heightProbes : Math.max( 2, Math.round( height ) + 1 ),
			depthProbes !== undefined ? depthProbes : Math.max( 2, Math.round( depth ) + 1 )
		);

		/**
		 * The world-space bounding box for the grid. Updated automatically
		 * by {@link LightProbeGrid#bake}.
		 *
		 * @type {Box3}
		 */
		this.boundingBox = new Box3();

		/**
		 * The single RGBA atlas 3D texture storing all seven packed SH sub-volumes.
		 *
		 * @type {?Data3DTexture}
		 * @default null
		 */
		this.texture = null;

		/**
		 * The raw baked SH coefficients, laid out as `27` floats per probe
		 * (`9` L2 bands times `3` colour channels), in
		 * `ix + iy * nx + iz * nx * ny` probe order.
		 *
		 * Populated by {@link LightProbeGrid#bake} (read back from the GPU) and
		 * by {@link LightProbeGrid.fromJSON}. This is the unpadded, minimal
		 * representation used by {@link LightProbeGrid#toJSON}.
		 *
		 * @type {?Float32Array}
		 * @default null
		 */
		this.coefficients = null;

		/**
		 * Internal render target for GPU-resident baking.
		 *
		 * @private
		 * @type {?WebGL3DRenderTarget}
		 * @default null
		 */
		this._renderTarget = null;

		this.updateBoundingBox();

	}

	/**
	 * Returns the world-space position of the probe at grid indices (ix, iy, iz).
	 *
	 * @param {number} ix - X index.
	 * @param {number} iy - Y index.
	 * @param {number} iz - Z index.
	 * @param {Vector3} target - The target vector.
	 * @return {Vector3} The world-space position.
	 */
	getProbePosition( ix, iy, iz, target ) {

		const pos = this.position;
		const res = this.resolution;
		const w = this.width, h = this.height, d = this.depth;

		target.set(
			res.x > 1 ? pos.x - w / 2 + ix * w / ( res.x - 1 ) : pos.x,
			res.y > 1 ? pos.y - h / 2 + iy * h / ( res.y - 1 ) : pos.y,
			res.z > 1 ? pos.z - d / 2 + iz * d / ( res.z - 1 ) : pos.z
		);

		return target;

	}

	/**
	 * Updates the world-space bounding box from the current position and size.
	 */
	updateBoundingBox() {

		_size.set( this.width, this.height, this.depth );
		this.boundingBox.setFromCenterAndSize( this.position, _size );

	}

	/**
	 * Bakes all probes by rendering cubemaps at each probe position
	 * and projecting to L2 SH. Optionally iterates additional passes to
	 * capture indirect bounces — each extra pass samples the previous pass's
	 * atlas as indirect light, so a grid added to the scene before baking
	 * accumulates one bounce per extra pass.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {Scene} scene - The scene to render.
	 * @param {Object} [options] - Bake options.
	 * @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 {number} [options.bounces=0] - Additional bounce passes after the initial direct pass.
	 */
	bake( renderer, scene, options = {} ) {

		const { bounces = 0 } = options;
		const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );

		this._ensureTextures();
		this.updateBoundingBox();

		const res = this.resolution;
		const totalProbes = res.x * res.y * res.z;

		// Batch render target for SH coefficients: 9 pixels wide, one row per probe
		const batchTarget = _ensureBatchTarget( totalProbes );

		// Save renderer state
		const currentRenderTarget = renderer.getRenderTarget();
		renderer.getViewport( _currentViewport );
		renderer.getScissor( _currentScissor );
		const currentScissorTest = renderer.getScissorTest();

		// Scene is static across the bake — update once and disable per-render auto updates.
		const currentMatrixWorldAutoUpdate = scene.matrixWorldAutoUpdate;
		if ( currentMatrixWorldAutoUpdate === true ) {

			scene.updateMatrixWorld( true );
			scene.matrixWorldAutoUpdate = false;

		}

		// Disable shadow map auto-update across all passes — lights don't move.
		// Force a single shadow update on the first render so maps are initialized.
		const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
		renderer.shadowMap.autoUpdate = false;
		renderer.shadowMap.needsUpdate = true;

		_ensureRepackResources();

		const paddedSlices = res.z + 2 * ATLAS_PADDING;
		const rt = this._renderTarget;

		// const t0 = performance.now();

		// Pass 0 captures direct light only (grid hidden, so probesSH is not sampled
		// — the atlas at this point may be uninitialized or hold a prior bake).
		// Each subsequent pass keeps the grid visible so the cube cameras read the
		// previous pass's atlas as indirect light, accumulating one bounce per pass.
		// Phase 1 writes to the batch target and Phase 2 only swaps it into the atlas
		// at the very end of each pass, which gives an implicit ping-pong for free.

		for ( let pass = 0; pass <= bounces; pass ++ ) {

			this.visible = pass > 0;

			// 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();

			// 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;

			for ( let iz = 0; iz < res.z; iz ++ ) {

				for ( let iy = 0; iy < res.y; iy ++ ) {

					for ( let ix = 0; ix < res.x; ix ++ ) {

						const probeIndex = ix + iy * res.x + iz * res.x * res.y;

						this.getProbePosition( ix, iy, iz, _position );
						cubeCamera.position.copy( _position );
						cubeCamera.update( renderer, scene );

						// 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 );

					}

				}

			}

			// 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.

			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 );

				// 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 );

			}

		}

		renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;

		// Read the final pass's SH coefficients back to the CPU so the bake can
		// be serialized (see toJSON). The batch target is a compact 9 x totalProbes
		// RGBA buffer; only the RGB of each of the 9 texels per row carries data.
		{

			const batchPixels = new Float32Array( 9 * totalProbes * 4 );
			renderer.readRenderTargetPixels( batchTarget, 0, 0, 9, totalProbes, batchPixels );

			const coefficients = new Float32Array( totalProbes * COEFFICIENTS_PER_PROBE );

			for ( let p = 0; p < totalProbes; p ++ ) {

				for ( let k = 0; k < 9; k ++ ) {

					const src = ( p * 9 + k ) * 4;
					const dst = p * COEFFICIENTS_PER_PROBE + k * 3;

					coefficients[ dst ] = batchPixels[ src ];
					coefficients[ dst + 1 ] = batchPixels[ src + 1 ];
					coefficients[ dst + 2 ] = batchPixels[ src + 2 ];

				}

			}

			this.coefficients = coefficients;

		}

		// Restore renderer state
		renderer.setRenderTarget( currentRenderTarget );
		renderer.setViewport( _currentViewport );
		renderer.setScissor( _currentScissor );
		renderer.setScissorTest( currentScissorTest );

		scene.matrixWorldAutoUpdate = currentMatrixWorldAutoUpdate;

		// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );

		this.visible = true;

	}

	/**
	 * Ensures the atlas 3D render target exists with the correct dimensions.
	 *
	 * @private
	 */
	_ensureTextures() {

		if ( this._renderTarget !== null ) return;

		// Re-baking a deserialized grid: drop the standalone atlas texture.
		if ( this.texture !== null ) this.texture.dispose();

		const res = this.resolution;
		const nx = res.x, ny = res.y, nz = res.z;

		// Atlas depth: 7 sub-volumes, each with ATLAS_PADDING slices at both ends
		const atlasDepth = 7 * ( nz + 2 * ATLAS_PADDING );

		const rt = new WebGL3DRenderTarget( nx, ny, atlasDepth, {
			format: RGBAFormat,
			type: FloatType,
			minFilter: LinearFilter,
			magFilter: LinearFilter,
			generateMipmaps: false,
			depthBuffer: false
		} );

		this._renderTarget = rt;
		this.texture = rt.texture;

	}

	/**
	 * Frees GPU resources.
	 */
	dispose() {

		if ( this._renderTarget !== null ) {

			// Baked grid: the texture is owned by the render target.
			this._renderTarget.dispose();
			this._renderTarget = null;

		} else if ( this.texture !== null ) {

			// Deserialized grid: the texture is a standalone Data3DTexture.
			this.texture.dispose();

		}

		this.texture = null;

	}

	/**
	 * Serializes the baked grid to a JSON-compatible object.
	 *
	 * Only the `27` SH coefficients per probe are stored — the padded atlas
	 * layout used on the GPU is fully reconstructed by {@link LightProbeGrid.fromJSON}.
	 * Coefficients are stored as fixed-point integers (`value * scale`,
	 * rounded). This is simple, human-readable, and — because the many
	 * near-zero higher-order coefficients collapse to short tokens — gzips
	 * better than a binary layout: a `7 x 7 x 3` grid is a ~16 KB JSON file
	 * that gzips to ~6.7 KB.
	 *
	 * Requires the grid to have been baked (see {@link LightProbeGrid#bake}).
	 *
	 * @return {Object} A JSON-compatible representation of the grid.
	 */
	toJSON() {

		if ( this.coefficients === null ) {

			throw new Error( 'THREE.LightProbeGrid: toJSON() requires a baked grid. Call bake() first.' );

		}

		const source = this.coefficients;
		const data = new Array( source.length );

		for ( let i = 0; i < source.length; i ++ ) {

			data[ i ] = Math.round( source[ i ] * SERIALIZE_SCALE );

		}

		return {
			metadata: {
				version: 1,
				type: 'LightProbeGrid',
				generator: 'LightProbeGrid.toJSON'
			},
			width: this.width,
			height: this.height,
			depth: this.depth,
			resolution: [ this.resolution.x, this.resolution.y, this.resolution.z ],
			position: [ this.position.x, this.position.y, this.position.z ],
			coefficients: {
				scale: SERIALIZE_SCALE,
				data: data
			}
		};

	}

	/**
	 * Reconstructs a baked grid from data produced by {@link LightProbeGrid#toJSON}.
	 *
	 * The returned grid carries a ready-to-use {@link Data3DTexture} and does
	 * not need a renderer — baking can be skipped entirely.
	 *
	 * @param {Object} json - The serialized grid.
	 * @return {LightProbeGrid} The reconstructed grid.
	 */
	static fromJSON( json ) {

		const [ nx, ny, nz ] = json.resolution;

		const grid = new LightProbeGrid( json.width, json.height, json.depth, nx, ny, nz );
		grid.position.fromArray( json.position );
		grid.updateBoundingBox();

		const { scale, data } = json.coefficients;
		const coefficients = new Float32Array( data.length );

		for ( let i = 0; i < data.length; i ++ ) {

			coefficients[ i ] = data[ i ] / scale;

		}

		grid.coefficients = coefficients;
		grid.texture = grid._createDataTexture( coefficients );

		return grid;

	}

	/**
	 * Builds the padded atlas {@link Data3DTexture} from the raw SH
	 * coefficients (`27` per probe). The atlas layout matches the one produced
	 * by {@link LightProbeGrid#bake} so the same shader code can sample either.
	 *
	 * @private
	 * @param {Float32Array} coefficients - Raw coefficients (`27` per probe).
	 * @return {Data3DTexture} The atlas texture.
	 */
	_createDataTexture( coefficients ) {

		const res = this.resolution;
		const nx = res.x, ny = res.y, nz = res.z;
		const sliceTexels = nx * ny;

		const paddedSlices = nz + 2 * ATLAS_PADDING;
		const atlasDepth = 7 * paddedSlices;

		const atlas = new Uint16Array( sliceTexels * atlasDepth * 4 );

		for ( let t = 0; t < 7; t ++ ) {

			for ( let s = 0; s < paddedSlices; s ++ ) {

				// Padding slices clamp to the first / last data slice.
				const iz = Math.min( Math.max( s - ATLAS_PADDING, 0 ), nz - 1 );
				const layer = t * paddedSlices + s;

				for ( let iy = 0; iy < ny; iy ++ ) {

					for ( let ix = 0; ix < nx; ix ++ ) {

						const probeIndex = ix + iy * nx + iz * sliceTexels;
						const src = probeIndex * COEFFICIENTS_PER_PROBE;
						const dst = ( layer * sliceTexels + iy * nx + ix ) * 4;

						for ( let ch = 0; ch < 4; ch ++ ) {

							// Channels map sequentially onto the 27 coefficients;
							// the very last channel (sub-volume 6, alpha) is unused.
							const ci = t * 4 + ch;
							atlas[ dst + ch ] = ci < COEFFICIENTS_PER_PROBE ? DataUtils.toHalfFloat( coefficients[ src + ci ] ) : 0;

						}

					}

				}

			}

		}

		const texture = new Data3DTexture( atlas, nx, ny, atlasDepth );
		texture.format = RGBAFormat;
		texture.type = HalfFloatType;
		texture.minFilter = LinearFilter;
		texture.magFilter = LinearFilter;
		texture.generateMipmaps = false;
		texture.needsUpdate = true;

		return texture;

	}

}

// Internal: Ensure the shared fullscreen-quad scene exists
function _ensureScene() {

	if ( _scene === null ) {

		_camera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );
		_mesh = new Mesh( new PlaneGeometry( 2, 2 ) );
		_scene = new Scene();
		_scene.add( _mesh );

	}

}

// Internal: Ensure GPU resources for SH projection are created
function _ensureGPUResources( cubemapSize ) {

	_ensureScene();

	// Recreate material when cubemap size changes
	if ( cubemapSize !== _lastCubemapSize ) {

		if ( _shMaterial !== null ) _shMaterial.dispose();

		_shMaterial = new ShaderMaterial( {
			precision: 'highp',
			defines: {
				CUBEMAP_SIZE: cubemapSize
			},
			uniforms: {
				envMap: { value: null }
			},
			vertexShader: /* glsl */`
				void main() {
					gl_Position = vec4( position.xy, 0.0, 1.0 );
				}
			`,
			fragmentShader: /* glsl */`
				#include <common>

				uniform samplerCube envMap;

				void main() {

					int coefIndex = int( gl_FragCoord.x );

					vec3 accum0 = vec3( 0.0 );
					vec3 accum1 = vec3( 0.0 );
					vec3 accum2 = vec3( 0.0 );
					vec3 accum3 = vec3( 0.0 );
					vec3 accum4 = vec3( 0.0 );
					vec3 accum5 = vec3( 0.0 );
					vec3 accum6 = vec3( 0.0 );
					vec3 accum7 = vec3( 0.0 );
					vec3 accum8 = vec3( 0.0 );
					float totalWeight = 0.0;
					float pixelSize = 2.0 / float( CUBEMAP_SIZE );

					for ( int face = 0; face < 6; face ++ ) {

						for ( int iy = 0; iy < CUBEMAP_SIZE; iy ++ ) {

							for ( int ix = 0; ix < CUBEMAP_SIZE; ix ++ ) {

								// WebGL cubemaps have a left-handed orientation (flip = -1)
								float col = ( float( ix ) + 0.5 ) * pixelSize - 1.0;
								float row = 1.0 - ( float( iy ) + 0.5 ) * pixelSize;

								vec3 coord;

								if ( face == 0 ) coord = vec3( 1.0, row, -col );
								else if ( face == 1 ) coord = vec3( -1.0, row, col );
								else if ( face == 2 ) coord = vec3( col, 1.0, -row );
								else if ( face == 3 ) coord = vec3( col, -1.0, row );
								else if ( face == 4 ) coord = vec3( col, row, 1.0 );
								else coord = vec3( -col, row, -1.0 );

								float lengthSq = dot( coord, coord );
								float weight = 4.0 / ( sqrt( lengthSq ) * lengthSq );
								totalWeight += weight;

								vec3 dir = normalize( coord );
								vec3 cw = textureCube( envMap, coord ).rgb * weight;

								// band 0
								accum0 += cw * 0.282095;

								// band 1
								accum1 += cw * ( 0.488603 * dir.y );
								accum2 += cw * ( 0.488603 * dir.z );
								accum3 += cw * ( 0.488603 * dir.x );

								// band 2
								accum4 += cw * ( 1.092548 * ( dir.x * dir.y ) );
								accum5 += cw * ( 1.092548 * ( dir.y * dir.z ) );
								accum6 += cw * ( 0.315392 * ( 3.0 * dir.z * dir.z - 1.0 ) );
								accum7 += cw * ( 1.092548 * ( dir.x * dir.z ) );
								accum8 += cw * ( 0.546274 * ( dir.x * dir.x - dir.y * dir.y ) );

							}

						}

					}

					float norm = 4.0 * PI / totalWeight;

					vec3 accum;
					if ( coefIndex == 0 ) accum = accum0;
					else if ( coefIndex == 1 ) accum = accum1;
					else if ( coefIndex == 2 ) accum = accum2;
					else if ( coefIndex == 3 ) accum = accum3;
					else if ( coefIndex == 4 ) accum = accum4;
					else if ( coefIndex == 5 ) accum = accum5;
					else if ( coefIndex == 6 ) accum = accum6;
					else if ( coefIndex == 7 ) accum = accum7;
					else accum = accum8;

					gl_FragColor = vec4( accum * norm, 1.0 );

				}
			`
		} );

		_lastCubemapSize = cubemapSize;

	}

}

// Internal: Ensure GPU resources for repacking SH into the atlas 3D texture
function _ensureRepackResources() {

	if ( _repackMaterials !== null ) return;

	_ensureScene();

	// Create 7 materials, one per output texture packing
	// Texture 0: (c0.r, c0.g, c0.b, c1.r)
	// Texture 1: (c1.g, c1.b, c2.r, c2.g)
	// Texture 2: (c2.b, c3.r, c3.g, c3.b)
	// Texture 3: (c4.r, c4.g, c4.b, c5.r)
	// Texture 4: (c5.g, c5.b, c6.r, c6.g)
	// Texture 5: (c6.b, c7.r, c7.g, c7.b)
	// Texture 6: (c8.r, c8.g, c8.b, 0.0)

	const repackVertexShader = /* glsl */`
		void main() {
			gl_Position = vec4( position.xy, 0.0, 1.0 );
		}
	`;

	_repackMaterials = [];

	for ( let t = 0; t < 7; t ++ ) {

		_repackMaterials[ t ] = new ShaderMaterial( {
			precision: 'highp',
			defines: {
				TEXTURE_INDEX: t
			},
			uniforms: {
				batchTexture: { value: null },
				resolution: { value: new Vector3() },
				sliceZ: { value: 0 }
			},
			vertexShader: repackVertexShader,
			fragmentShader: /* glsl */`
				uniform sampler2D batchTexture;
				uniform vec3 resolution;
				uniform int sliceZ;

				void main() {

					int ix = int( gl_FragCoord.x );
					int iy = int( gl_FragCoord.y );
					int iz = sliceZ;

					int probeIndex = ix + iy * int( resolution.x ) + iz * int( resolution.x ) * int( resolution.y );

					// Read 9 SH coefficients from the batch texture row
					vec4 c0 = texelFetch( batchTexture, ivec2( 0, probeIndex ), 0 );
					vec4 c1 = texelFetch( batchTexture, ivec2( 1, probeIndex ), 0 );
					vec4 c2 = texelFetch( batchTexture, ivec2( 2, probeIndex ), 0 );
					vec4 c3 = texelFetch( batchTexture, ivec2( 3, probeIndex ), 0 );
					vec4 c4 = texelFetch( batchTexture, ivec2( 4, probeIndex ), 0 );
					vec4 c5 = texelFetch( batchTexture, ivec2( 5, probeIndex ), 0 );
					vec4 c6 = texelFetch( batchTexture, ivec2( 6, probeIndex ), 0 );
					vec4 c7 = texelFetch( batchTexture, ivec2( 7, probeIndex ), 0 );
					vec4 c8 = texelFetch( batchTexture, ivec2( 8, probeIndex ), 0 );

					// Pack into the output format for this texture index
					#if TEXTURE_INDEX == 0
						gl_FragColor = vec4( c0.rgb, c1.r );
					#elif TEXTURE_INDEX == 1
						gl_FragColor = vec4( c1.gb, c2.rg );
					#elif TEXTURE_INDEX == 2
						gl_FragColor = vec4( c2.b, c3.rgb );
					#elif TEXTURE_INDEX == 3
						gl_FragColor = vec4( c4.rgb, c5.r );
					#elif TEXTURE_INDEX == 4
						gl_FragColor = vec4( c5.gb, c6.rg );
					#elif TEXTURE_INDEX == 5
						gl_FragColor = vec4( c6.b, c7.rgb );
					#else
						gl_FragColor = vec4( c8.rgb, 0.0 );
					#endif

				}
			`
		} );

	}

}

// Internal: Ensure cube render target and camera exist with the right parameters
function _ensureBakeResources( options ) {

	const {
		cubemapSize = 8,
		near = 0.1,
		far = 100
	} = options;

	if ( _cubeRenderTarget === null || cubemapSize !== _cachedCubemapSize || near !== _cachedNear || far !== _cachedFar ) {

		if ( _cubeRenderTarget !== null ) _cubeRenderTarget.dispose();

		_cubeRenderTarget = new WebGLCubeRenderTarget( cubemapSize, { type: HalfFloatType } );
		_cubeCamera = new CubeCamera( near, far, _cubeRenderTarget );
		_cachedCubemapSize = cubemapSize;
		_cachedNear = near;
		_cachedFar = far;

	}

	_ensureGPUResources( cubemapSize );

	return { cubeRenderTarget: _cubeRenderTarget, cubeCamera: _cubeCamera };

}

function _ensureBatchTarget( totalProbes ) {

	if ( _batchTarget === null || _batchTargetProbes !== totalProbes ) {

		if ( _batchTarget !== null ) _batchTarget.dispose();

		_batchTarget = new WebGLRenderTarget( 9, totalProbes, {
			type: FloatType,
			minFilter: NearestFilter,
			magFilter: NearestFilter,
			depthBuffer: false
		} );

		_batchTargetProbes = totalProbes;

	}

	return _batchTarget;

}

export { LightProbeGrid };