three-gpu-pathtracer 0.0.22 → 0.0.24

package/build/index.umd.cjs

@@ -45,12 +45,18 @@
 
 	}
 
-	// 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;
 
 		}
 
@@ -61,10 +67,12 @@
 
 		if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
 
-			throw new Error();
+			return false;
 
 		}
 
+		return true;
+
 	}
 
 	function validateMergeability( geometries ) {
@@ -271,7 +279,20 @@
 				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 );
+
+					}
 
 				}
 
@@ -432,29 +453,22 @@
 
 	}
 
-	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 }|`;
 
 		}
 
@@ -885,6 +899,28 @@
 
 		}
 
+		// 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;
@@ -1074,15 +1110,24 @@
 				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
@@ -1134,6 +1179,12 @@
 
 			// 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 ];
@@ -1279,6 +1330,7 @@
 			this._bvhWorker = null;
 			this._pendingGenerate = null;
 			this._buildAsync = false;
+			this._materialUuids = null;
 
 		}
 
@@ -1360,12 +1412,29 @@
 			// 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 );
 
 			}
 
@@ -1409,6 +1478,7 @@
 			return {
 				bvhChanged: result.changeType !== NO_CHANGE,
 				bvh: this.bvh,
+				needsMaterialIndexUpdate,
 				lights,
 				iesTextures,
 				geometry,
@@ -1445,6 +1515,17 @@
 
 	class MaterialBase extends three.ShaderMaterial {
 
+		set needsUpdate( v ) {
+
+			super.needsUpdate = true;
+			this.dispatchEvent( {
+
+				type: 'recompilation',
+
+			} );
+
+		}
+
 		constructor( shader ) {
 
 			super( shader );
@@ -2825,7 +2906,7 @@
 
 	}
 
-	const MATERIAL_PIXELS = 45;
+	const MATERIAL_PIXELS = 47;
 	const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
 
 	class MaterialFeatures {
@@ -3250,6 +3331,9 @@
 				// specularIntensityMap transform 43
 				index += writeTextureMatrixToArray( m, 'specularIntensityMap', floatArray, index );
 
+				// alphaMap transform 45
+				index += writeTextureMatrixToArray( m, 'alphaMap', floatArray, index );
+
 			}
 
 			// check if the contents have changed
@@ -3445,11 +3529,11 @@
 	// - 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;
@@ -3464,7 +3548,7 @@
 	// 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 );
@@ -3481,7 +3565,19 @@
 
 			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;
 
@@ -3493,8 +3589,8 @@
 
 				if ( index >= strata.length ) {
 
-					shuffle( strata );
-					this.restart();
+					shuffle( strata, random );
+					this.reshuffle();
 
 				}
 
@@ -3502,7 +3598,7 @@
 
 				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 );
 
 				}
@@ -3520,7 +3616,7 @@
 	// 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 ) {
@@ -3534,7 +3630,7 @@
 			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 );
@@ -3557,11 +3653,21 @@
 
 			};
 
-			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();
 
 				}
 
@@ -3571,6 +3677,36 @@
 
 	}
 
+	// 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 three.DataTexture {
 
 		constructor( count = 1, depth = 1, strata = 8 ) {
@@ -3581,22 +3717,37 @@
 
 			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;
@@ -3616,6 +3767,13 @@
 
 		}
 
+		reset() {
+
+			this.sampler.reset();
+			this.generator.seed = 0;
+
+		}
+
 	}
 
 	function shuffleArray( array, random = Math.random ) {
@@ -4255,6 +4413,7 @@
 		mat3 iridescenceThicknessMapTransform;
 		mat3 specularColorMapTransform;
 		mat3 specularIntensityMapTransform;
+		mat3 alphaMapTransform;
 
 	};
 
@@ -4275,7 +4434,7 @@
 
 	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 );
@@ -4374,6 +4533,7 @@
 		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;
 
@@ -6140,7 +6300,7 @@
 // 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 );
 
@@ -6370,7 +6530,8 @@ bool bvhIntersectFogVolumeHit(
 				// 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;
 
 				}
 
@@ -6512,7 +6673,7 @@ bool bvhIntersectFogVolumeHit(
 			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
@@ -6682,7 +6843,8 @@ bool bvhIntersectFogVolumeHit(
 		// 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;
 
 		}
 
@@ -7097,6 +7259,7 @@ bool bvhIntersectFogVolumeHit(
 					ATTR_TANGENT: 1,
 					ATTR_UV: 2,
 					ATTR_COLOR: 3,
+					MATERIAL_PIXELS: MATERIAL_PIXELS,
 				},
 
 				uniforms: {
@@ -7779,6 +7942,9 @@ bool bvhIntersectFogVolumeHit(
 
 		set material( v ) {
 
+			this._fsQuad.material.removeEventListener( 'recompilation', this._compileFunction );
+			v.addEventListener( 'recompilation', this._compileFunction );
+
 			this._fsQuad.material = v;
 
 		}
@@ -7815,6 +7981,12 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		get isCompiling() {
+
+			return Boolean( this._compilePromise );
+
+		}
+
 		constructor( renderer ) {
 
 			this.camera = null;
@@ -7832,6 +8004,7 @@ bool bvhIntersectFogVolumeHit(
 			this._blendQuad = new Pass_js.FullScreenQuad( new BlendMaterial() );
 			this._task = null;
 			this._currentTile = 0;
+			this._compilePromise = null;
 
 			this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
@@ -7856,6 +8029,33 @@ bool bvhIntersectFogVolumeHit(
 				} ),
 			];
 
+			// 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 ) {
@@ -7887,7 +8087,6 @@ bool bvhIntersectFogVolumeHit(
 			material.setDefine( 'CAMERA_TYPE', cameraType );
 
 			this.camera = camera;
-			// this.reset();
 
 		}
 
@@ -7954,9 +8153,11 @@ bool bvhIntersectFogVolumeHit(
 			this.samples = 0;
 			this._task = null;
 
+			this.material.stratifiedTexture.stableNoise = this.stableNoise;
 			if ( this.stableNoise ) {
 
 				this.material.seed = 0;
+				this.material.stratifiedTexture.reset();
 
 			}
 
@@ -7964,6 +8165,15 @@ bool bvhIntersectFogVolumeHit(
 
 		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 );
@@ -8183,6 +8393,150 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
+	class CubeToEquirectMaterial extends three.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 Pass_js.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 three.WebGLRenderTarget( width, height, {
+				type: three.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 ] = three.DataUtils.toHalfFloat( readBuffer[ i ] );
+
+			}
+
+			// produce the data texture
+			const result = new three.DataTexture( buffer, width, height, three.RGBAFormat, three.HalfFloatType );
+			result.minFilter = three.LinearMipMapLinearFilter;
+			result.magFilter = three.LinearFilter;
+			result.wrapS = three.RepeatWrapping;
+			result.wrapT = three.RepeatWrapping;
+			result.mapping = three.EquirectangularReflectionMapping;
+			result.needsUpdate = true;
+
+			return result;
+
+		}
+
+		dispose() {
+
+			this._quad.dispose();
+
+		}
+
+	}
+
 	function supportsFloatBlending( renderer ) {
 
 		return renderer.extensions.get( 'EXT_float_blend' );
@@ -8258,6 +8612,24 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		get stableNoise() {
+
+			return this._pathTracer.stableNoise;
+
+		}
+
+		set stableNoise( v ) {
+
+			this._pathTracer.stableNoise = v;
+
+		}
+
+		get isCompiling() {
+
+			return Boolean( this._pathTracer.isCompiling );
+
+		}
+
 		constructor( renderer ) {
 
 			// members
@@ -8266,6 +8638,7 @@ bool bvhIntersectFogVolumeHit(
 			this._pathTracer = new PathTracingRenderer( renderer );
 			this._queueReset = false;
 			this._clock = new three.Clock();
+			this._compilePromise = null;
 
 			this._lowResPathTracer = new PathTracingRenderer( renderer );
 			this._lowResPathTracer.tiles.set( 1, 1 );
@@ -8278,6 +8651,10 @@ bool bvhIntersectFogVolumeHit(
 			} ) );
 			this._materials = null;
 
+			this._previousEnvironment = null;
+			this._previousBackground = null;
+			this._internalBackground = null;
+
 			// options
 			this.renderDelay = 100;
 			this.minSamples = 5;
@@ -8406,6 +8783,13 @@ bool bvhIntersectFogVolumeHit(
 			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;
@@ -8433,6 +8817,17 @@ bool bvhIntersectFogVolumeHit(
 				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;
@@ -8441,26 +8836,32 @@ bool bvhIntersectFogVolumeHit(
 			}
 
 			// 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();
 
 		}
@@ -8472,6 +8873,7 @@ bool bvhIntersectFogVolumeHit(
 				geometry,
 				bvh,
 				bvhChanged,
+				needsMaterialIndexUpdate,
 			} = results;
 
 			this._materials = materials;
@@ -8489,6 +8891,10 @@ bool bvhIntersectFogVolumeHit(
 					geometry.attributes.color,
 				);
 
+			}
+
+			if ( needsMaterialIndexUpdate ) {
+
 				material.materialIndexAttribute.updateFrom( geometry.attributes.materialIndex );
 
 			}
@@ -8531,7 +8937,7 @@ bool bvhIntersectFogVolumeHit(
 			// 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();
 
@@ -8564,7 +8970,7 @@ bool bvhIntersectFogVolumeHit(
 				// 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 ) {
 
@@ -8579,7 +8985,9 @@ bool bvhIntersectFogVolumeHit(
 						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 );
 
@@ -8617,8 +9025,8 @@ bool bvhIntersectFogVolumeHit(
 
 		dispose() {
 
-			this._renderQuad.dispose();
-			this._renderQuad.material.dispose();
+			this._quad.dispose();
+			this._quad.material.dispose();
 			this._pathTracer.dispose();
 
 		}