three-gpu-pathtracer 0.0.22 → 0.0.24

package/build/index.module.js

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial } from 'three';
+import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, LinearMipMapLinearFilter, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial } from 'three';
 import { SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 
@@ -43,12 +43,18 @@ function createAttributeClone( attr, countOverride = null ) {
 
 }
 
-// Confirms that the two provided attributes are compatible
+// Confirms that the two provided attributes are compatible. Returns false if they are not.
 function validateAttributes( attr1, attr2 ) {
 
 	if ( ! attr1 && ! attr2 ) {
 
-		return;
+		return true;
+
+	}
+
+	if ( Boolean( attr1 ) !== Boolean( attr2 ) ) {
+
+		return false;
 
 	}
 
@@ -59,10 +65,12 @@ function validateAttributes( attr1, attr2 ) {
 
 	if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
 
-		throw new Error();
+		return false;
 
 	}
 
+	return true;
+
 }
 
 function validateMergeability( geometries ) {
@@ -269,7 +277,20 @@ function mergeGeometries( geometries, options = {}, targetGeometry = new BufferG
 			const attr = geometry.getAttribute( key );
  			if ( ! skip ) {
 
-				copyAttributeContents( attr, targetAttribute, offset );
+				if ( key === 'color' && targetAttribute.itemSize !== attr.itemSize ) {
+
+					// make sure the color attribute is aligned with itemSize 3 to 4
+					for ( let index = offset, l = attr.count; index < l; index ++ ) {
+
+						attr.setXYZW( index, targetAttribute.getX( index ), targetAttribute.getY( index ), targetAttribute.getZ( index ), 1.0 );
+
+					}
+
+				} else {
+
+					copyAttributeContents( attr, targetAttribute, offset );
+
+				}
 
 			}
 
@@ -430,29 +451,22 @@ function bufferToHash( buffer ) {
 
 }
 
-function attributeSort( a, b ) {
-
-	if ( a.uuid > b.uuid ) return 1;
-	if ( a.uuid < b.uuid ) return - 1;
-	return 0;
-
-}
-
 function getGeometryHash( geometry ) {
 
-	let hash = '';
+	let hash = geometry.uuid;
 	const attributes = Object.values( geometry.attributes );
 	if ( geometry.index ) {
 
 		attributes.push( geometry.index );
+		hash += `index|${ geometry.index.version }`;
 
 	}
 
-	attributes.sort( attributeSort );
+	const keys = Object.keys( attributes ).sort();
+	for ( const key of keys ) {
 
-	for ( const attr of attributes ) {
-
-		hash += `${ attr.uuid }_${ attr.version }|`;
+		const attr = attributes[ key ];
+		hash += `${ key }_${ attr.version }|`;
 
 	}
 
@@ -883,6 +897,28 @@ class BakedGeometry extends BufferGeometry {
 
 	}
 
+	// returns whether the passed mesh is compatible with this baked geometry
+	// such that it can be updated without resizing attributes
+	isCompatible( mesh, attributes ) {
+
+		const geometry = mesh.geometry;
+		for ( let i = 0; i < attributes.length; i ++ ) {
+
+			const key = attributes[ i ];
+			const attr1 = geometry.attributes[ key ];
+			const attr2 = this.attributes[ key ];
+			if ( attr1 && ! validateAttributes( attr1, attr2 ) ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
 	updateFrom( mesh, options ) {
 
 		const diff = this._diff;
@@ -1072,15 +1108,24 @@ class StaticGeometryGenerator {
 			unusedMeshKeys.delete( meshKey );
 
 			// initialize the intermediate geometry
-			if ( ! _intermediateGeometry.has( meshKey ) ) {
+			// if the mesh and source geometry have changed in such a way that they are no longer
+			// compatible then regenerate the baked geometry from scratch
+			let geom = _intermediateGeometry.get( meshKey );
+			if ( ! geom || ! geom.isCompatible( mesh, this.attributes ) ) {
+
+				if ( geom ) {
 
-				_intermediateGeometry.set( meshKey, new BakedGeometry() );
+					geom.dispose();
+
+				}
+
+				geom = new BakedGeometry();
+				_intermediateGeometry.set( meshKey, geom );
 
 			}
 
 			// transform the geometry into the intermediate buffer geometry, saving whether
 			// or not it changed.
-			const geom = _intermediateGeometry.get( meshKey );
 			if ( geom.updateFrom( mesh, convertOptions ) ) {
 
 				// TODO: provide option for only generating the set of attributes that are present
@@ -1132,6 +1177,12 @@ class StaticGeometryGenerator {
 
 		// get the list of geometries to merge
 		let forceUpdate = false;
+		if ( meshes.length !== previousMergeInfo.length ) {
+
+			forceUpdate = true;
+
+		}
+
 		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
 
 			const mesh = meshes[ i ];
@@ -1277,6 +1328,7 @@ class PathTracingSceneGenerator {
 		this._bvhWorker = null;
 		this._pendingGenerate = null;
 		this._buildAsync = false;
+		this._materialUuids = null;
 
 	}
 
@@ -1358,12 +1410,29 @@ class PathTracingSceneGenerator {
 		// generate the geometry
 		const result = staticGeometryGenerator.generate( geometry );
 		const materials = result.materials;
+		let needsMaterialIndexUpdate = result.changeType !== NO_CHANGE || this._materialUuids === null || this._materialUuids.length !== length;
+		if ( ! needsMaterialIndexUpdate ) {
+
+			for ( let i = 0, length = materials.length; i < length; i ++ ) {
+
+				const material = materials[ i ];
+				if ( material.uuid !== this._materialUuids[ i ] ) {
+
+					needsMaterialIndexUpdate = true;
+					break;
+
+				}
+
+			}
+
+		}
+
 		const textures = getTextures$1( materials );
 		const { lights, iesTextures } = getLights$1( objects );
-
-		if ( result.changeType !== NO_CHANGE ) {
+		if ( needsMaterialIndexUpdate ) {
 
 			updateMaterialIndexAttribute( geometry, materials, materials );
+			this._materialUuids = materials.map( material => material.uuid );
 
 		}
 
@@ -1407,6 +1476,7 @@ class PathTracingSceneGenerator {
 		return {
 			bvhChanged: result.changeType !== NO_CHANGE,
 			bvh: this.bvh,
+			needsMaterialIndexUpdate,
 			lights,
 			iesTextures,
 			geometry,
@@ -1443,6 +1513,17 @@ class PathTracingSceneWorker extends PathTracingSceneGenerator {
 
 class MaterialBase extends ShaderMaterial {
 
+	set needsUpdate( v ) {
+
+		super.needsUpdate = true;
+		this.dispatchEvent( {
+
+			type: 'recompilation',
+
+		} );
+
+	}
+
 	constructor( shader ) {
 
 		super( shader );
@@ -2823,7 +2904,7 @@ function getLights( scene ) {
 
 }
 
-const MATERIAL_PIXELS = 45;
+const MATERIAL_PIXELS = 47;
 const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
 
 class MaterialFeatures {
@@ -3248,6 +3329,9 @@ class MaterialsTexture extends DataTexture {
 			// specularIntensityMap transform 43
 			index += writeTextureMatrixToArray( m, 'specularIntensityMap', floatArray, index );
 
+			// alphaMap transform 45
+			index += writeTextureMatrixToArray( m, 'alphaMap', floatArray, index );
+
 		}
 
 		// check if the contents have changed
@@ -3443,11 +3527,11 @@ class CopyMaterial extends ShaderMaterial {
 // - https://github.com/hoverinc/ray-tracing-renderer
 // - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
 
-function shuffle( arr ) {
+function shuffle( arr, random = Math.random() ) {
 
 	for ( let i = arr.length - 1; i > 0; i -- ) {
 
-	  const j = Math.floor( Math.random() * ( i + 1 ) );
+	  const j = Math.floor( random() * ( i + 1 ) );
 	  const x = arr[ i ];
 	  arr[ i ] = arr[ j ];
 	  arr[ j ] = x;
@@ -3462,7 +3546,7 @@ function shuffle( arr ) {
 // dimensions  : The number of dimensions to generate stratified values for
 class StratifiedSampler {
 
-	constructor( strataCount, dimensions ) {
+	constructor( strataCount, dimensions, random = Math.random ) {
 
 		const l = strataCount ** dimensions;
 		const strata = new Uint16Array( l );
@@ -3479,7 +3563,19 @@ class StratifiedSampler {
 
 		this.strataCount = strataCount;
 
-		this.restart = function () {
+		this.reset = function () {
+
+			for ( let i = 0; i < l; i ++ ) {
+
+				strata[ i ] = i;
+
+			}
+
+			index = 0;
+
+		};
+
+		this.reshuffle = function () {
 
 			index = 0;
 
@@ -3491,8 +3587,8 @@ class StratifiedSampler {
 
 			if ( index >= strata.length ) {
 
-				shuffle( strata );
-				this.restart();
+				shuffle( strata, random );
+				this.reshuffle();
 
 			}
 
@@ -3500,7 +3596,7 @@ class StratifiedSampler {
 
 			for ( let i = 0; i < dimensions; i ++ ) {
 
-				samples[ i ] = ( stratum % strataCount + Math.random() ) / strataCount;
+				samples[ i ] = ( stratum % strataCount + random() ) / strataCount;
 				stratum = Math.floor( stratum / strataCount );
 
 			}
@@ -3518,7 +3614,7 @@ class StratifiedSampler {
 // Stratified set of data with each tuple stratified separately and combined
 class StratifiedSamplerCombined {
 
-	constructor( strataCount, listOfDimensions ) {
+	constructor( strataCount, listOfDimensions, random = Math.random ) {
 
 		let totalDim = 0;
 		for ( const dim of listOfDimensions ) {
@@ -3532,7 +3628,7 @@ class StratifiedSamplerCombined {
 		let offset = 0;
 		for ( const dim of listOfDimensions ) {
 
-			const sampler = new StratifiedSampler( strataCount, dim );
+			const sampler = new StratifiedSampler( strataCount, dim, random );
 			sampler.samples = new Float32Array( combined.buffer, offset, sampler.samples.length );
 			offset += sampler.samples.length * 4;
 			strataObjs.push( sampler );
@@ -3555,11 +3651,21 @@ class StratifiedSamplerCombined {
 
 		};
 
-		this.restart = function () {
+		this.reshuffle = function () {
 
 			for ( const strata of strataObjs ) {
 
-				strata.restart();
+				strata.reshuffle();
+
+			}
+
+		};
+
+		this.reset = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.reset();
 
 			}
 
@@ -3569,6 +3675,36 @@ class StratifiedSamplerCombined {
 
 }
 
+// https://stackoverflow.com/questions/424292/seedable-javascript-random-number-generator
+class RandomGenerator {
+
+	constructor( seed = 0 ) {
+
+		// LCG using GCC's constants
+		this.m = 0x80000000; // 2**31;
+		this.a = 1103515245;
+		this.c = 12345;
+
+		this.seed = seed;
+
+	}
+
+	nextInt() {
+
+		this.seed = ( this.a * this.seed + this.c ) % this.m;
+		return this.seed;
+
+	}
+
+	nextFloat() {
+
+		// returns in range [0,1]
+		return this.nextInt() / ( this.m - 1 );
+
+	}
+
+}
+
 class StratifiedSamplesTexture extends DataTexture {
 
 	constructor( count = 1, depth = 1, strata = 8 ) {
@@ -3579,22 +3715,37 @@ class StratifiedSamplesTexture extends DataTexture {
 
 		this.strata = strata;
 		this.sampler = null;
+		this.generator = new RandomGenerator();
+		this.stableNoise = false;
+		this.random = () => {
+
+			if ( this.stableNoise ) {
+
+				return this.generator.nextFloat();
+
+			} else {
+
+				return Math.random();
+
+			}
+
+		};
 
 		this.init( count, depth, strata );
 
 	}
 
-	init( count, depth, strata = this.strata ) {
+	init( count = this.image.height, depth = this.image.width, strata = this.strata ) {
 
 		const { image } = this;
-		if ( image.width === depth && image.height === count ) {
+		if ( image.width === depth && image.height === count && this.sampler !== null ) {
 
 			return;
 
 		}
 
 		const dimensions = new Array( count * depth ).fill( 4 );
-		const sampler = new StratifiedSamplerCombined( strata, dimensions );
+		const sampler = new StratifiedSamplerCombined( strata, dimensions, this.random );
 
 		image.width = depth;
 		image.height = count;
@@ -3614,6 +3765,13 @@ class StratifiedSamplesTexture extends DataTexture {
 
 	}
 
+	reset() {
+
+		this.sampler.reset();
+		this.generator.seed = 0;
+
+	}
+
 }
 
 function shuffleArray( array, random = Math.random ) {
@@ -4253,6 +4411,7 @@ const material_struct = /* glsl */ `
 		mat3 iridescenceThicknessMapTransform;
 		mat3 specularColorMapTransform;
 		mat3 specularIntensityMapTransform;
+		mat3 alphaMapTransform;
 
 	};
 
@@ -4273,7 +4432,7 @@ const material_struct = /* glsl */ `
 
 	Material readMaterialInfo( sampler2D tex, uint index ) {
 
-		uint i = index * 45u;
+		uint i = index * uint( MATERIAL_PIXELS );
 
 		vec4 s0 = texelFetch1D( tex, i + 0u );
 		vec4 s1 = texelFetch1D( tex, i + 1u );
@@ -4372,6 +4531,7 @@ const material_struct = /* glsl */ `
 		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
 		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
 		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
+		m.alphaMapTransform = m.alphaMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 30u );
 
 		return m;
 
@@ -6138,7 +6298,7 @@ const inside_fog_volume_function = /* glsl */`
 // returns whether the given material is a fog material or not
 bool isMaterialFogVolume( sampler2D materials, uint materialIndex ) {
 
-	uint i = materialIndex * 45u;
+	uint i = materialIndex * uint( MATERIAL_PIXELS );
 	vec4 s14 = texelFetch1D( materials, i + 14u );
 	return bool( int( s14.b ) & 4 );
 
@@ -6368,7 +6528,8 @@ const attenuate_hit_function = /* glsl */`
 				// alphaMap
 				if ( material.alphaMap != - 1 ) {
 
-					albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
+					vec3 uvPrime = material.alphaMapTransform * vec3( uv, 1 );
+					albedo.a *= texture2D( textures, vec3( uvPrime.xy, material.alphaMap ) ).x;
 
 				}
 
@@ -6510,7 +6671,7 @@ const camera_util_functions = /* glsl */`
 			vec3 shapeUVW= rand3( 1 );
 			int blades = physicalCamera.apertureBlades;
 			float anamorphicRatio = physicalCamera.anamorphicRatio;
-			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
+			vec2 apertureSample = sampleAperture( blades, shapeUVW );
 			apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
 
 			// rotate the aperture shape
@@ -6680,7 +6841,8 @@ const get_surface_record_function = /* glsl */`
 		// alphaMap
 		if ( material.alphaMap != - 1 ) {
 
-			albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
+			vec3 uvPrime = material.alphaMapTransform * vec3( uv, 1 );
+			albedo.a *= texture2D( textures, vec3( uvPrime.xy, material.alphaMap ) ).x;
 
 		}
 
@@ -7095,6 +7257,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				ATTR_TANGENT: 1,
 				ATTR_UV: 2,
 				ATTR_COLOR: 3,
+				MATERIAL_PIXELS: MATERIAL_PIXELS,
 			},
 
 			uniforms: {
@@ -7777,6 +7940,9 @@ class PathTracingRenderer {
 
 	set material( v ) {
 
+		this._fsQuad.material.removeEventListener( 'recompilation', this._compileFunction );
+		v.addEventListener( 'recompilation', this._compileFunction );
+
 		this._fsQuad.material = v;
 
 	}
@@ -7813,6 +7979,12 @@ class PathTracingRenderer {
 
 	}
 
+	get isCompiling() {
+
+		return Boolean( this._compilePromise );
+
+	}
+
 	constructor( renderer ) {
 
 		this.camera = null;
@@ -7830,6 +8002,7 @@ class PathTracingRenderer {
 		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
 		this._task = null;
 		this._currentTile = 0;
+		this._compilePromise = null;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
@@ -7854,6 +8027,33 @@ class PathTracingRenderer {
 			} ),
 		];
 
+		// function for listening to for triggered compilation so we can wait for compilation to finish
+		// before starting to render
+		this._compileFunction = () => {
+
+			const promise = this.compileMaterial( this._fsQuad._mesh );
+			promise.then( () => {
+
+				if ( this._compilePromise === promise ) {
+
+					this._compilePromise = null;
+
+				}
+
+			} );
+
+			this._compilePromise = promise;
+
+		};
+
+		this.material.addEventListener( 'recompilation', this._compileFunction );
+
+	}
+
+	compileMaterial() {
+
+		return this._renderer.compileAsync( this._fsQuad._mesh );
+
 	}
 
 	setCamera( camera ) {
@@ -7885,7 +8085,6 @@ class PathTracingRenderer {
 		material.setDefine( 'CAMERA_TYPE', cameraType );
 
 		this.camera = camera;
-		// this.reset();
 
 	}
 
@@ -7952,9 +8151,11 @@ class PathTracingRenderer {
 		this.samples = 0;
 		this._task = null;
 
+		this.material.stratifiedTexture.stableNoise = this.stableNoise;
 		if ( this.stableNoise ) {
 
 			this.material.seed = 0;
+			this.material.stratifiedTexture.reset();
 
 		}
 
@@ -7962,6 +8163,15 @@ class PathTracingRenderer {
 
 	update() {
 
+		// ensure we've updated our defines before rendering so we can ensure we
+		// can wait for compilation to finish
+		this.material.onBeforeRender();
+		if ( this.isCompiling ) {
+
+			return;
+
+		}
+
 		if ( ! this._task ) {
 
 			this._task = renderTask.call( this );
@@ -8181,6 +8391,150 @@ class ClampedInterpolationMaterial extends ShaderMaterial {
 
 }
 
+class CubeToEquirectMaterial extends ShaderMaterial {
+
+	constructor() {
+
+		super( {
+
+			uniforms: {
+
+				envMap: { value: null },
+				flipEnvMap: { value: - 1 },
+
+			},
+
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}`,
+
+			fragmentShader: /* glsl */`
+				#define ENVMAP_TYPE_CUBE_UV
+
+				uniform samplerCube envMap;
+				uniform float flipEnvMap;
+				varying vec2 vUv;
+
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${ util_functions }
+
+				void main() {
+
+					vec3 rayDirection = equirectUvToDirection( vUv );
+					rayDirection.x *= flipEnvMap;
+					gl_FragColor = textureCube( envMap, rayDirection );
+
+				}`
+		} );
+
+		this.depthWrite = false;
+		this.depthTest = false;
+
+	}
+
+}
+
+class CubeToEquirectGenerator {
+
+	constructor( renderer ) {
+
+		this._renderer = renderer;
+		this._quad = new FullScreenQuad( new CubeToEquirectMaterial() );
+
+	}
+
+	generate( source, width = null, height = null ) {
+
+		if ( ! source.isCubeTexture ) {
+
+			throw new Error( 'CubeToEquirectMaterial: Source can only be cube textures.' );
+
+		}
+
+		const image = source.images[ 0 ];
+		const renderer = this._renderer;
+		const quad = this._quad;
+
+		// determine the dimensions if not provided
+		if ( width === null ) {
+
+			width = 4 * image.height;
+
+		}
+
+		if ( height === null ) {
+
+			height = 2 * image.height;
+
+		}
+
+		const target = new WebGLRenderTarget( width, height, {
+			type: FloatType,
+			colorSpace: image.colorSpace,
+		} );
+
+		// prep the cube map data
+		const imageHeight = image.height;
+		const maxMip = Math.log2( imageHeight ) - 2;
+		const texelHeight = 1.0 / imageHeight;
+		const texelWidth = 1.0 / ( 3 * Math.max( Math.pow( 2, maxMip ), 7 * 16 ) );
+
+		quad.material.defines.CUBEUV_MAX_MIP = `${ maxMip }.0`;
+		quad.material.defines.CUBEUV_TEXEL_WIDTH = texelWidth;
+		quad.material.defines.CUBEUV_TEXEL_HEIGHT = texelHeight;
+		quad.material.uniforms.envMap.value = source;
+		quad.material.uniforms.flipEnvMap.value = source.isRenderTargetTexture ? 1 : - 1;
+		quad.material.needsUpdate = true;
+
+		// save state and render the contents
+		const currentTarget = renderer.getRenderTarget();
+		const currentAutoClear = renderer.autoClear;
+		renderer.autoClear = true;
+		renderer.setRenderTarget( target );
+		quad.render( renderer );
+		renderer.setRenderTarget( currentTarget );
+		renderer.autoClear = currentAutoClear;
+
+		// read the data back
+		const buffer = new Uint16Array( width * height * 4 );
+		const readBuffer = new Float32Array( width * height * 4 );
+		renderer.readRenderTargetPixels( target, 0, 0, width, height, readBuffer );
+		target.dispose();
+
+		for ( let i = 0, l = readBuffer.length; i < l; i ++ ) {
+
+			buffer[ i ] = DataUtils.toHalfFloat( readBuffer[ i ] );
+
+		}
+
+		// produce the data texture
+		const result = new DataTexture( buffer, width, height, RGBAFormat, HalfFloatType );
+		result.minFilter = LinearMipMapLinearFilter;
+		result.magFilter = LinearFilter;
+		result.wrapS = RepeatWrapping;
+		result.wrapT = RepeatWrapping;
+		result.mapping = EquirectangularReflectionMapping;
+		result.needsUpdate = true;
+
+		return result;
+
+	}
+
+	dispose() {
+
+		this._quad.dispose();
+
+	}
+
+}
+
 function supportsFloatBlending( renderer ) {
 
 	return renderer.extensions.get( 'EXT_float_blend' );
@@ -8256,6 +8610,24 @@ class WebGLPathTracer {
 
 	}
 
+	get stableNoise() {
+
+		return this._pathTracer.stableNoise;
+
+	}
+
+	set stableNoise( v ) {
+
+		this._pathTracer.stableNoise = v;
+
+	}
+
+	get isCompiling() {
+
+		return Boolean( this._pathTracer.isCompiling );
+
+	}
+
 	constructor( renderer ) {
 
 		// members
@@ -8264,6 +8636,7 @@ class WebGLPathTracer {
 		this._pathTracer = new PathTracingRenderer( renderer );
 		this._queueReset = false;
 		this._clock = new Clock();
+		this._compilePromise = null;
 
 		this._lowResPathTracer = new PathTracingRenderer( renderer );
 		this._lowResPathTracer.tiles.set( 1, 1 );
@@ -8276,6 +8649,10 @@ class WebGLPathTracer {
 		} ) );
 		this._materials = null;
 
+		this._previousEnvironment = null;
+		this._previousBackground = null;
+		this._internalBackground = null;
+
 		// options
 		this.renderDelay = 100;
 		this.minSamples = 5;
@@ -8404,6 +8781,13 @@ class WebGLPathTracer {
 		const scene = this.scene;
 		const material = this._pathTracer.material;
 
+		if ( this._internalBackground ) {
+
+			this._internalBackground.dispose();
+			this._internalBackground = null;
+
+		}
+
 		// update scene background
 		material.backgroundBlur = scene.backgroundBlurriness;
 		material.backgroundIntensity = scene.backgroundIntensity ?? 1;
@@ -8431,6 +8815,17 @@ class WebGLPathTracer {
 			material.backgroundMap = colorBackground;
 			material.backgroundAlpha = 1;
 
+		} else if ( scene.background.isCubeTexture ) {
+
+			if ( scene.background !== this._previousBackground ) {
+
+				const background = new CubeToEquirectGenerator( this._renderer ).generate( scene.background );
+				this._internalBackground = background;
+				material.backgroundMap = background;
+				material.backgroundAlpha = 1;
+
+			}
+
 		} else {
 
 			material.backgroundMap = scene.background;
@@ -8439,26 +8834,32 @@ class WebGLPathTracer {
 		}
 
 		// update scene environment
-		material.environmentIntensity = scene.environmentIntensity ?? 1;
+		material.environmentIntensity = scene.environment !== null ? ( scene.environmentIntensity ?? 1 ) : 0;
 		material.environmentRotation.makeRotationFromEuler( scene.environmentRotation ).invert();
 		if ( this._previousEnvironment !== scene.environment ) {
 
-			if ( scene.environment ) {
+			if ( scene.environment !== null ) {
 
-				// TODO: Consider setting this to the highest supported bit depth by checking for
-				// OES_texture_float_linear or OES_texture_half_float_linear. Requires changes to
-				// the equirect uniform
-				material.envMapInfo.updateFrom( scene.environment );
+				if ( scene.environment.isCubeTexture ) {
 
-			} else {
+					const environment = new CubeToEquirectGenerator( this._renderer ).generate( scene.environment );
+					material.envMapInfo.updateFrom( environment );
+
+				} else {
+
+					// TODO: Consider setting this to the highest supported bit depth by checking for
+					// OES_texture_float_linear or OES_texture_half_float_linear. Requires changes to
+					// the equirect uniform
+					material.envMapInfo.updateFrom( scene.environment );
 
-				material.environmentIntensity = 0;
+				}
 
 			}
 
 		}
 
 		this._previousEnvironment = scene.environment;
+		this._previousBackground = scene.background;
 		this.reset();
 
 	}
@@ -8470,6 +8871,7 @@ class WebGLPathTracer {
 			geometry,
 			bvh,
 			bvhChanged,
+			needsMaterialIndexUpdate,
 		} = results;
 
 		this._materials = materials;
@@ -8487,6 +8889,10 @@ class WebGLPathTracer {
 				geometry.attributes.color,
 			);
 
+		}
+
+		if ( needsMaterialIndexUpdate ) {
+
 			material.materialIndexAttribute.updateFrom( geometry.attributes.materialIndex );
 
 		}
@@ -8529,7 +8935,7 @@ class WebGLPathTracer {
 		// render the path tracing sample after enough time has passed
 		const delta = clock.getDelta() * 1e3;
 		const elapsedTime = clock.getElapsedTime() * 1e3;
-		if ( ! this.pausePathTracing && this.enablePathTracing && this.renderDelay <= elapsedTime ) {
+		if ( ! this.pausePathTracing && this.enablePathTracing && this.renderDelay <= elapsedTime && ! this.isCompiling ) {
 
 			pathTracer.update();
 
@@ -8562,7 +8968,7 @@ class WebGLPathTracer {
 			// render the fallback if we haven't rendered enough samples, are paused, or are occluded
 			if ( ! this.enablePathTracing || this.samples < minSamples || quad.material.opacity < 1 ) {
 
-				if ( this.dynamicLowRes ) {
+				if ( this.dynamicLowRes && ! this.isCompiling ) {
 
 					if ( lowResPathTracer.samples < 1 ) {
 
@@ -8577,7 +8983,9 @@ class WebGLPathTracer {
 					quad.render( renderer );
 					quad.material.opacity = currentOpacity;
 
-				} else if ( this.rasterizeScene ) {
+				}
+
+				if ( ! this.dynamicLowRes && this.rasterizeScene || this.dynamicLowRes && this.isCompiling ) {
 
 					this.rasterizeSceneCallback( this.scene, this.camera );
 
@@ -8615,8 +9023,8 @@ class WebGLPathTracer {
 
 	dispose() {
 
-		this._renderQuad.dispose();
-		this._renderQuad.material.dispose();
+		this._quad.dispose();
+		this._quad.material.dispose();
 		this._pathTracer.dispose();
 
 	}