three-gpu-pathtracer 0.0.16 → 0.0.18

package/build/index.module.js

@@ -1,7 +1,7 @@
-import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, Vector4, NormalBlending, Color, Vector3, MathUtils, Matrix4, PerspectiveCamera, BufferAttribute, Mesh, BufferGeometry, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, HalfFloatType, DataUtils, RedFormat, Quaternion, Loader, FileLoader, PMREMGenerator, DataArrayTexture, MeshStandardMaterial, BoxGeometry } from 'three';
+import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, Vector4, NormalBlending, Color, HalfFloatType, Vector3, MathUtils, Matrix4, PerspectiveCamera, BufferAttribute, MeshBasicMaterial, BufferGeometry, Mesh, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, DataUtils, Source, RedFormat, Quaternion, Loader, FileLoader, PMREMGenerator, DataArrayTexture, RGFormat, MeshStandardMaterial, BoxGeometry } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { StaticGeometryGenerator, SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
-import { mergeVertices, mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { StaticGeometryGenerator, MeshBVH, SAH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
+import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
 class MaterialBase extends ShaderMaterial {
 
@@ -339,9 +339,9 @@ const sobolSamplingGLSL = /* glsl */`
 
 	// Seeds
 	uniform sampler2D sobolTexture;
-	uint sobolPixelIndex;
-	uint sobolPathIndex;
-	uint sobolBounceIndex;
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
 
 	uint sobolGetSeed( uint bounce, uint effect ) {
 
@@ -456,9 +456,6 @@ class SobolNumberMapGenerator {
 
 }
 
-const _scissor = new Vector4();
-const _viewport = new Vector4();
-
 function* renderTask() {
 
 	const {
@@ -500,12 +497,21 @@ function* renderTask() {
 		const h = _primaryTarget.height;
 		material.resolution.set( w * subW, h * subH );
 		material.sobolTexture = _sobolTarget.texture;
+		material.stratifiedTexture.init( 20, material.bounces + material.transmissiveBounces + 5 );
+		material.stratifiedTexture.next();
 		material.seed ++;
 
 		const tilesX = this.tiles.x || 1;
 		const tilesY = this.tiles.y || 1;
 		const totalTiles = tilesX * tilesY;
-		const dprInv = ( 1 / _renderer.getPixelRatio() );
+
+		const pxSubW = Math.ceil( w * subW );
+		const pxSubH = Math.ceil( h * subH );
+		const pxSubX = Math.floor( subX * w );
+		const pxSubY = Math.floor( subY * h );
+
+		const pxTileW = Math.ceil( pxSubW / tilesX );
+		const pxTileH = Math.ceil( pxSubH / tilesY );
 
 		for ( let y = 0; y < tilesY; y ++ ) {
 
@@ -554,40 +560,28 @@ function* renderTask() {
 
 				}
 
+				// set the scissor and the viewport on the render target
+				// note that when using the webgl renderer set viewport the device pixel ratio
+				// is multiplied into the field causing some pixels to not be rendered
+				const reverseTy = tilesY - ty - 1;
+				_primaryTarget.scissor.set(
+					pxSubX + tx * pxTileW,
+					pxSubY + reverseTy * pxTileH,
+					Math.min( pxTileW, pxSubW - tx * pxTileW ),
+					Math.min( pxTileH, pxSubH - reverseTy * pxTileH ),
+				);
+
+				_primaryTarget.viewport.set(
+					pxSubX,
+					pxSubY,
+					pxSubW,
+					pxSubH,
+				);
+
 				// three.js renderer takes values relative to the current pixel ratio
 				_renderer.setRenderTarget( _primaryTarget );
 				_renderer.setScissorTest( true );
 
-				// set the scissor window for a subtile
-				_scissor.x = tx * w / tilesX;
-				_scissor.y = ( tilesY - ty - 1 ) * h / tilesY;
-				_scissor.z = w / tilesX;
-				_scissor.w = h / tilesY;
-
-				// adjust for the subframe
-				_scissor.x = subX * w + subW * _scissor.x;
-				_scissor.y = subY * h + subH * _scissor.y;
-				_scissor.z = subW * _scissor.z;
-				_scissor.w = subH * _scissor.w;
-
-				// round for floating point cases
-				_scissor.x = _scissor.x;
-				_scissor.y = _scissor.y;
-				_scissor.z = _scissor.z;
-				_scissor.w = _scissor.w;
-
-				// multiply inverse of DPR in because threes multiplies it in
-				_scissor.multiplyScalar( dprInv ).ceil();
-
-				_viewport.x = subX * w;
-				_viewport.y = subY * h;
-				_viewport.z = subW * w;
-				_viewport.w = subH * h;
-				_viewport.multiplyScalar( dprInv ).ceil();
-
-				_renderer.setScissor( _scissor );
-				_renderer.setViewport( _viewport );
-
 				_renderer.autoClear = false;
 				_fsQuad.render( _renderer );
 
@@ -703,18 +697,22 @@ class PathTracingRenderer {
 		this._currentTile = 0;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
+
+		// will be null if extension not supported
+		const floatLinearExtensionSupported = renderer.extensions.get( 'OES_texture_float_linear' );
+
 		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
 			format: RGBAFormat,
-			type: FloatType,
+			type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 		} );
 		this._blendTargets = [
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 		];
 
@@ -1073,25 +1071,6 @@ function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
 
 }
 
-function trimToAttributes( geometry, attributes ) {
-
-	// trim any unneeded attributes
-	if ( attributes ) {
-
-		for ( const key in geometry.attributes ) {
-
-			if ( ! attributes.includes( key ) ) {
-
-				geometry.deleteAttribute( key );
-
-			}
-
-		}
-
-	}
-
-}
-
 function setCommonAttributes( geometry, options ) {
 
 	const { attributes = [], normalMapRequired = false } = options;
@@ -1109,6 +1088,13 @@ function setCommonAttributes( geometry, options ) {
 
 	}
 
+	if ( ! geometry.attributes.uv2 && ( attributes && attributes.includes( 'uv2' ) ) ) {
+
+		const vertCount = geometry.attributes.position.count;
+		geometry.setAttribute( 'uv2', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+	}
+
 	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
 
 		if ( normalMapRequired ) {
@@ -1157,158 +1143,46 @@ function setCommonAttributes( geometry, options ) {
 
 }
 
-function mergeMeshes( meshes, options = {} ) {
-
-	options = { attributes: null, cloneGeometry: true, ...options };
-
-	const transformedGeometry = [];
-	const materialSet = new Set();
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// save any materials
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
-
-		if ( Array.isArray( mesh.material ) ) {
-
-			mesh.material.forEach( m => materialSet.add( m ) );
-
-		} else {
-
-			materialSet.add( mesh.material );
-
-		}
-
-	}
-
-	const materials = Array.from( materialSet );
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// ensure the matrix world is up to date
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
+const dummyMaterial = new MeshBasicMaterial();
+function getDummyMesh() {
 
-		mesh.updateMatrixWorld();
+	const emptyGeometry = new BufferGeometry();
+	emptyGeometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 9 ), 3 ) );
+	return new Mesh( emptyGeometry, dummyMaterial );
 
-		// apply the matrix world to the geometry
-		const originalGeometry = meshes[ i ].geometry;
-		const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-		geometry.applyMatrix4( mesh.matrixWorld );
+}
 
-		// ensure our geometry has common attributes
-		setCommonAttributes( geometry, {
-			attributes: options.attributes,
-			normalMapRequired: ! ! mesh.material.normalMap,
-		} );
-		trimToAttributes( geometry, options.attributes );
+class DynamicPathTracingSceneGenerator {
 
-		// create the material index attribute
-		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
-		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+	get initialized() {
 
-		transformedGeometry.push( geometry );
+		return Boolean( this.bvh );
 
 	}
 
-	const textureSet = new Set();
-	materials.forEach( material => {
-
-		for ( const key in material ) {
-
-			const value = material[ key ];
-			if ( value && value.isTexture ) {
+	constructor( objects ) {
 
-				textureSet.add( value );
+		// ensure the objects is an array
+		if ( ! Array.isArray( objects ) ) {
 
-			}
+			objects = [ objects ];
 
 		}
 
-	} );
-
-	const geometry = mergeBufferGeometries( transformedGeometry, false );
-	const textures = Array.from( textureSet );
-	return { geometry, materials, textures };
-
-}
-
-class PathTracingSceneGenerator {
-
-	prepScene( scene ) {
-
-		scene = Array.isArray( scene ) ? scene : [ scene ];
+		// use a dummy object for a fallback
+		const finalObjects = [ ...objects ];
+		if ( finalObjects.length === 0 ) {
 
-		const meshes = [];
-		const lights = [];
-
-		for ( let i = 0, l = scene.length; i < l; i ++ ) {
-
-			scene[ i ].traverseVisible( c => {
-
-				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
-
-					const generator = new StaticGeometryGenerator( c );
-					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-					generator.applyWorldTransforms = false;
-					const mesh = new Mesh(
-						generator.generate(),
-						c.material,
-					);
-					mesh.matrixWorld.copy( c.matrixWorld );
-					mesh.matrix.copy( c.matrixWorld );
-					mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
-					meshes.push( mesh );
-
-				} else if ( c.isMesh ) {
-
-					meshes.push( c );
-
-				} else if ( c.isRectAreaLight || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
-
-					lights.push( c );
-
-				}
-
-			} );
+			finalObjects.push( getDummyMesh() );
 
 		}
 
-		return {
-			...mergeMeshes( meshes, {
-				attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
-			} ),
-			lights,
-		};
-
-	}
-
-	generate( scene, options = {} ) {
-
-		const { materials, textures, geometry, lights } = this.prepScene( scene );
-		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
-		return {
-			scene,
-			materials,
-			textures,
-			lights,
-			bvh: new MeshBVH( geometry, bvhOptions ),
-		};
-
-	}
-
-}
-
-class DynamicPathTracingSceneGenerator {
-
-	get initialized() {
-
-		return Boolean( this.bvh );
-
-	}
-
-	constructor( scene ) {
+		// options
+		this.bvhOptions = {};
+		this.attributes = [ 'position', 'normal', 'tangent', 'color', 'uv', 'uv2' ];
 
-		this.objects = Array.isArray( scene ) ? scene : [ scene ];
+		// state
+		this.objects = finalObjects;
 		this.bvh = null;
 		this.geometry = new BufferGeometry();
 		this.materials = null;
@@ -1332,59 +1206,75 @@ class DynamicPathTracingSceneGenerator {
 
 	dispose() {}
 
-	generate() {
+	prepScene() {
 
-		const { objects, staticGeometryGenerator, geometry } = this;
-		if ( this.bvh === null ) {
+		if ( this.bvh !== null ) {
 
-			const attributes = [ 'position', 'normal', 'tangent', 'uv', 'color' ];
+			return;
 
-			for ( let i = 0, l = objects.length; i < l; i ++ ) {
+		}
 
-				objects[ i ].traverse( c => {
+		const { objects, staticGeometryGenerator, geometry, lights, attributes } = this;
+		for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
-					if ( c.isMesh ) {
+			objects[ i ].traverse( c => {
 
-						const normalMapRequired = ! ! c.material.normalMap;
-						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+				if ( c.isMesh ) {
 
-					} else if ( c.isRectAreaLight || c.isSpotLight ) {
+					const normalMapRequired = ! ! c.material.normalMap;
+					setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-						this.lights.push( c );
+				} else if (
+					c.isRectAreaLight ||
+					c.isSpotLight ||
+					c.isPointLight ||
+					c.isDirectionalLight
+				) {
 
-					}
+					lights.push( c );
 
-				} );
+				}
 
-			}
+			} );
 
-			const textureSet = new Set();
-			const materials = staticGeometryGenerator.getMaterials();
-			materials.forEach( material => {
+		}
 
-				for ( const key in material ) {
+		const textureSet = new Set();
+		const materials = staticGeometryGenerator.getMaterials();
+		materials.forEach( material => {
 
-					const value = material[ key ];
-					if ( value && value.isTexture ) {
+			for ( const key in material ) {
 
-						textureSet.add( value );
+				const value = material[ key ];
+				if ( value && value.isTexture ) {
 
-					}
+					textureSet.add( value );
 
 				}
 
-			} );
+			}
 
-			staticGeometryGenerator.attributes = attributes;
-			staticGeometryGenerator.generate( geometry );
+		} );
+
+		staticGeometryGenerator.attributes = attributes;
+		staticGeometryGenerator.generate( geometry );
+
+		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
+		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+		geometry.clearGroups();
 
-			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
-			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-			geometry.clearGroups();
+		this.materials = materials;
+		this.textures = Array.from( textureSet );
 
-			this.bvh = new MeshBVH( geometry );
-			this.materials = materials;
-			this.textures = Array.from( textureSet );
+	}
+
+	generate() {
+
+		const { objects, staticGeometryGenerator, geometry, bvhOptions } = this;
+		if ( this.bvh === null ) {
+
+			this.prepScene();
+			this.bvh = new MeshBVH( geometry, { strategy: SAH, maxLeafTris: 1, ...bvhOptions } );
 
 			return {
 				lights: this.lights,
@@ -1414,6 +1304,30 @@ class DynamicPathTracingSceneGenerator {
 
 }
 
+class PathTracingSceneGenerator {
+
+	generate( scene, options = {} ) {
+
+		// ensure scene transforms are up to date
+		// TODO: remove this?
+		if ( Array.isArray( scene ) ) {
+
+			scene.forEach( s => s.updateMatrixWorld( true ) );
+
+		} else {
+
+			scene.updateMatrixWorld( true );
+
+		}
+
+		const generator = new DynamicPathTracingSceneGenerator( scene );
+		generator.bvhOptions = options;
+		return generator.generate();
+
+	}
+
+}
+
 // https://github.com/gkjohnson/webxr-sandbox/blob/main/skinned-mesh-batching/src/MaterialReducer.js
 
 function isTypedArray( arr ) {
@@ -1775,7 +1689,7 @@ const _polar = new Spherical();
 const _color = new Color();
 class ProceduralEquirectTexture extends DataTexture {
 
-	constructor( width, height ) {
+	constructor( width = 512, height = 512 ) {
 
 		super(
 			new Float32Array( width * height * 4 ),
@@ -1811,10 +1725,10 @@ class ProceduralEquirectTexture extends DataTexture {
 
 				const i = y * width + x;
 				const i4 = 4 * i;
-				data[ i4 + 0 ] = _color.r;
-				data[ i4 + 1 ] = _color.g;
-				data[ i4 + 2 ] = _color.b;
-				data[ i4 + 3 ] = 1.0;
+				data[ i4 + 0 ] = ( _color.r );
+				data[ i4 + 1 ] = ( _color.g );
+				data[ i4 + 2 ] = ( _color.b );
+				data[ i4 + 3 ] = ( 1.0 );
 
 			}
 
@@ -1869,7 +1783,7 @@ class GradientEquirectTexture extends ProceduralEquirectTexture {
 // when rendering each texture to the texture array they must have a consistent color space.
 function getTextureHash( t ) {
 
-	return `${ t.source.uuid }:${ t.encoding }`;
+	return `${ t.source.uuid }:${ t.colorSpace }`;
 
 }
 
@@ -1948,6 +1862,8 @@ class MaterialsTexture extends DataTexture {
 		this.type = FloatType;
 		this.wrapS = ClampToEdgeWrapping;
 		this.wrapT = ClampToEdgeWrapping;
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
 		this.generateMipmaps = false;
 		this.threeCompatibilityTransforms = false;
 		this.features = new MaterialFeatures();
@@ -2417,7 +2333,7 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 		};
 
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		const fsQuad = new FullScreenQuad( new CopyMaterial() );
 		this.fsQuad = fsQuad;
 
 	}
@@ -2452,7 +2368,6 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 				texture.matrix.identity();
 
 				fsQuad.material.map = texture;
-				fsQuad.material.transparent = true;
 
 				renderer.setRenderTarget( this, i );
 				fsQuad.render( renderer );
@@ -2482,6 +2397,67 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 }
 
+class CopyMaterial extends ShaderMaterial {
+
+	get map() {
+
+		return this.uniforms.map.value;
+
+	}
+	set map( v ) {
+
+		this.uniforms.map.value = v;
+
+	}
+
+	constructor() {
+
+		super( {
+			uniforms: {
+
+				map: { value: null },
+
+			},
+
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+
+			fragmentShader: /* glsl */`
+				uniform sampler2D map;
+				varying vec2 vUv;
+				void main() {
+
+					gl_FragColor = texture2D( map, vUv );
+
+				}
+			`
+		} );
+
+	}
+
+
+}
+
+function toHalfFloatArray( f32Array ) {
+
+	const f16Array = new Uint16Array( f32Array.length );
+	for ( let i = 0, n = f32Array.length; i < n; ++ i ) {
+
+		f16Array[ i ] = DataUtils.toHalfFloat( f32Array[ i ] );
+
+	}
+
+	return f16Array;
+
+}
+
 function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
 
 	let lower = offset;
@@ -2520,7 +2496,7 @@ function colorToLuminance( r, g, b ) {
 }
 
 // ensures the data is all floating point values and flipY is false
-function preprocessEnvMap( envMap ) {
+function preprocessEnvMap( envMap, targetType = HalfFloatType ) {
 
 	const map = envMap.clone();
 	map.source = new Source( { ...map.image } );
@@ -2529,17 +2505,54 @@ function preprocessEnvMap( envMap ) {
 	// TODO: is there a simple way to avoid cloning and adjusting the env map data here?
 	// convert the data from half float uint 16 arrays to float arrays for cdf computation
 	let newData = data;
-	if ( map.type === HalfFloatType ) {
+	if ( map.type !== targetType ) {
+
+		if ( targetType === HalfFloatType ) {
+
+			newData = new Uint16Array( data.length );
+
+		} else {
+
+			newData = new Float32Array( data.length );
+
+		}
+
+		let maxIntValue;
+		if ( data instanceof Int8Array || data instanceof Int16Array || data instanceof Int32Array ) {
+
+			maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT - 1 ) - 1;
+
+		} else {
+
+			maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT ) - 1;
+
+		}
 
-		newData = new Float32Array( data.length );
-		for ( const i in data ) {
+		for ( let i = 0, l = data.length; i < l; i ++ ) {
 
-			newData[ i ] = DataUtils.fromHalfFloat( data[ i ] );
+			let v = data[ i ];
+			if ( map.type === HalfFloatType ) {
+
+				v = DataUtils.fromHalfFloat( data[ i ] );
+
+			}
+
+			if ( map.type !== FloatType && map.type !== HalfFloatType ) {
+
+				v /= maxIntValue;
+
+			}
+
+			if ( targetType === HalfFloatType ) {
+
+				newData[ i ] = DataUtils.toHalfFloat( v );
+
+			}
 
 		}
 
 		map.image.data = newData;
-		map.type = FloatType;
+		map.type = targetType;
 
 	}
 
@@ -2580,8 +2593,8 @@ class EquirectHdrInfoUniform {
 
 		// Default to a white texture and associated weights so we don't
 		// just render black initially.
-		const whiteTex = new DataTexture( new Float32Array( [ 1, 1, 1, 1 ] ), 1, 1 );
-		whiteTex.type = FloatType;
+		const whiteTex = new DataTexture( toHalfFloatArray( new Float32Array( [ 1, 1, 1, 1 ] ) ), 1, 1 );
+		whiteTex.type = HalfFloatType;
 		whiteTex.format = RGBAFormat;
 		whiteTex.minFilter = LinearFilter;
 		whiteTex.magFilter = LinearFilter;
@@ -2592,8 +2605,8 @@ class EquirectHdrInfoUniform {
 
 		// Stores a map of [0, 1] value -> cumulative importance row & pdf
 		// used to sampling a random value to a relevant row to sample from
-		const marginalWeights = new DataTexture( new Float32Array( [ 0, 1 ] ), 1, 2 );
-		marginalWeights.type = FloatType;
+		const marginalWeights = new DataTexture( toHalfFloatArray( new Float32Array( [ 0, 1 ] ) ), 1, 2 );
+		marginalWeights.type = HalfFloatType;
 		marginalWeights.format = RedFormat;
 		marginalWeights.minFilter = LinearFilter;
 		marginalWeights.magFilter = LinearFilter;
@@ -2602,8 +2615,8 @@ class EquirectHdrInfoUniform {
 
 		// Stores a map of [0, 1] value -> cumulative importance column & pdf
 		// used to sampling a random value to a relevant pixel to sample from
-		const conditionalWeights = new DataTexture( new Float32Array( [ 0, 0, 1, 1 ] ), 2, 2 );
-		conditionalWeights.type = FloatType;
+		const conditionalWeights = new DataTexture( toHalfFloatArray( new Float32Array( [ 0, 0, 1, 1 ] ) ), 2, 2 );
+		conditionalWeights.type = HalfFloatType;
 		conditionalWeights.format = RedFormat;
 		conditionalWeights.minFilter = LinearFilter;
 		conditionalWeights.magFilter = LinearFilter;
@@ -2631,7 +2644,7 @@ class EquirectHdrInfoUniform {
 		// https://pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources#InfiniteAreaLights
 		const map = preprocessEnvMap( hdr );
 		map.wrapS = RepeatWrapping;
-		map.wrapT = RepeatWrapping;
+		map.wrapT = ClampToEdgeWrapping;
 
 		const { width, height, data } = map.image;
 
@@ -2653,9 +2666,9 @@ class EquirectHdrInfoUniform {
 			for ( let x = 0; x < width; x ++ ) {
 
 				const i = y * width + x;
-				const r = data[ 4 * i + 0 ];
-				const g = data[ 4 * i + 1 ];
-				const b = data[ 4 * i + 2 ];
+				const r = DataUtils.fromHalfFloat( data[ 4 * i + 0 ] );
+				const g = DataUtils.fromHalfFloat( data[ 4 * i + 1 ] );
+				const b = DataUtils.fromHalfFloat( data[ 4 * i + 2 ] );
 
 				// the probability of the pixel being selected in this row is the
 				// scale of the luminance relative to the rest of the pixels.
@@ -2707,8 +2720,8 @@ class EquirectHdrInfoUniform {
 		// the marginal and conditional data. These will be used to sample with a random number
 		// to retrieve a uv value to sample in the environment map.
 		// These values continually increase so it's okay to interpolate between them.
-		const marginalDataArray = new Float32Array( height );
-		const conditionalDataArray = new Float32Array( width * height );
+		const marginalDataArray = new Uint16Array( height );
+		const conditionalDataArray = new Uint16Array( width * height );
 
 		// we add a half texel offset so we're sampling the center of the pixel
 		for ( let i = 0; i < height; i ++ ) {
@@ -2716,7 +2729,7 @@ class EquirectHdrInfoUniform {
 			const dist = ( i + 1 ) / height;
 			const row = binarySearchFindClosestIndexOf( cdfMarginal, dist );
 
-			marginalDataArray[ i ] = ( row + 0.5 ) / height;
+			marginalDataArray[ i ] = DataUtils.toHalfFloat( ( row + 0.5 ) / height );
 
 		}
 
@@ -2728,7 +2741,7 @@ class EquirectHdrInfoUniform {
 				const dist = ( x + 1 ) / width;
 				const col = binarySearchFindClosestIndexOf( cdfConditional, dist, y * width, width );
 
-				conditionalDataArray[ i ] = ( col + 0.5 ) / width;
+				conditionalDataArray[ i ] = DataUtils.toHalfFloat( ( col + 0.5 ) / width );
 
 			}
 
@@ -2802,6 +2815,8 @@ class LightsInfoUniformStruct {
 		tex.wrapS = ClampToEdgeWrapping;
 		tex.wrapT = ClampToEdgeWrapping;
 		tex.generateMipmaps = false;
+		tex.minFilter = NearestFilter;
+		tex.magFilter = NearestFilter;
 
 		this.tex = tex;
 		this.count = 0;
@@ -2832,7 +2847,7 @@ class LightsInfoUniformStruct {
 		const worldQuaternion = new Quaternion();
 		const eye = new Vector3();
 		const target = new Vector3();
-		const up = new Vector3();
+		const up = new Vector3( 0, 1, 0 );
 
 		for ( let i = 0, l = lights.length; i < l; i ++ ) {
 
@@ -2841,6 +2856,13 @@ class LightsInfoUniformStruct {
 			const baseIndex = i * LIGHT_PIXELS * 4;
 			let index = 0;
 
+			// initialize to 0
+			for ( let p = 0; p < LIGHT_PIXELS; p ++ ) {
+
+				floatArray[ baseIndex + p ] = 0;
+
+			}
+
 			// sample 1
 		    // position
 			l.getWorldPosition( v );
@@ -2905,7 +2927,7 @@ class LightsInfoUniformStruct {
 
 			} else if ( l.isSpotLight ) {
 
-				const radius = l.radius;
+				const radius = l.radius || 0;
 				eye.setFromMatrixPosition( l.matrixWorld );
 				target.setFromMatrixPosition( l.target.matrixWorld );
 				m.lookAt( eye, target, up );
@@ -2935,24 +2957,21 @@ class LightsInfoUniformStruct {
 				// radius
 				floatArray[ baseIndex + ( index ++ ) ] = radius;
 
-				// near
-				floatArray[ baseIndex + ( index ++ ) ] = l.shadow.camera.near;
-
 				// decay
 				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 
 				// distance
 				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
 
-				// sample 6
 				// coneCos
 				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle );
 
+				// sample 6
 				// penumbraCos
 				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
 
 				// iesProfile
-				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
+				floatArray[ baseIndex + ( index ++ ) ] = l.iesTexture ? iesTextures.indexOf( l.iesTexture ) : - 1;
 
 			} else if ( l.isPointLight ) {
 
@@ -2969,7 +2988,7 @@ class LightsInfoUniformStruct {
 				index += 4;
 
 				// sample 5
-				index += 2;
+				index += 1;
 
 				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
@@ -3275,7 +3294,7 @@ class IESLoader extends Loader {
 		loader.setPath( this.path );
 		loader.setRequestHeader( this.requestHeader );
 
-		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		const texture = new DataTexture( null, 360, 180, RedFormat, HalfFloatType );
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
 
@@ -3283,7 +3302,7 @@ class IESLoader extends Loader {
 
 			const iesLamp = new IESLamp( text );
 
-			texture.image.data = this._getIESValues( iesLamp );
+			texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 			texture.needsUpdate = true;
 
 			if ( onLoad !== undefined ) {
@@ -3301,10 +3320,10 @@ class IESLoader extends Loader {
 	parse( text ) {
 
 		const iesLamp = new IESLamp( text );
-		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		const texture = new DataTexture( null, 360, 180, RedFormat, HalfFloatType );
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
-		texture.image.data = this._getIESValues( iesLamp );
+		texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 		texture.needsUpdate = true;
 
 		return texture;
@@ -3322,7 +3341,7 @@ class IESProfilesTexture extends WebGLArrayRenderTarget {
 
 		const tex = this.texture;
 		tex.format = RGBAFormat;
-		tex.type = FloatType;
+		tex.type = HalfFloatType;
 		tex.minFilter = LinearFilter;
 		tex.magFilter = LinearFilter;
 		tex.wrapS = ClampToEdgeWrapping;
@@ -3573,7 +3592,7 @@ class BlurredEnvMapGenerator {
 		this.renderer = renderer;
 		this.pmremGenerator = new PMREMGenerator( renderer );
 		this.copyQuad = new FullScreenQuad( new PMREMCopyMaterial() );
-		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: FloatType, format: RGBAFormat } );
+		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: HalfFloatType, format: RGBAFormat } );
 
 	}
 
@@ -3610,10 +3629,10 @@ class BlurredEnvMapGenerator {
 		renderer.autoClear = prevClear;
 
 		// read the data back
-		const buffer = new Float32Array( width * height * 4 );
+		const buffer = new Uint16Array( width * height * 4 );
 		renderer.readRenderTargetPixels( renderTarget, 0, 0, width, height, buffer );
 
-		const result = new DataTexture( buffer, width, height, RGBAFormat, FloatType );
+		const result = new DataTexture( buffer, width, height, RGBAFormat, HalfFloatType );
 		result.minFilter = texture.minFilter;
 		result.magFilter = texture.magFilter;
 		result.wrapS = texture.wrapS;
@@ -3755,7 +3774,7 @@ class DenoiseMaterial extends MaterialBase {
 
 					gl_FragColor = smartDeNoise( map, vec2( vUv.x, vUv.y ), sigma, kSigma, threshold );
 					#include <tonemapping_fragment>
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 					#include <premultiplied_alpha_fragment>
 
 				}
@@ -3838,7 +3857,7 @@ class GradientMapMaterial extends MaterialBase {
 					gl_FragColor.rgb = vec3( mix( minColor, maxColor, t ) );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`,
 
@@ -4047,7 +4066,7 @@ class GraphMaterial extends MaterialBase {
 
 					}
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}
 
@@ -4383,13 +4402,22 @@ const lightsStructGLSL = /* glsl */`
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );
 			l.radius = s4.r;
-			l.near = s4.g;
-			l.decay = s4.b;
-			l.distance = s4.a;
+			l.decay = s4.g;
+			l.distance = s4.b;
+			l.coneCos = s4.a;
+
+			l.penumbraCos = s5.r;
+			l.iesProfile = int( round( s5.g ) );
 
-			l.coneCos = s5.r;
-			l.penumbraCos = s5.g;
-			l.iesProfile = int( round ( s5.b ) );
+		} else {
+
+			l.radius = 0.0;
+			l.decay = 0.0;
+			l.distance = 0.0;
+
+			l.coneCos = 0.0;
+			l.penumbraCos = 0.0;
+			l.iesProfile = - 1;
 
 		}
 
@@ -4585,21 +4613,22 @@ const materialStructGLSL = /* glsl */ `
 
 		uint firstTextureTransformIdx = i + 15u;
 
-		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx );
-		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
-		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
-		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
-		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
-		m.normalMapTransform = m.normalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
-		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
-		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
-		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
-		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
-		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
-		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
-		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
-		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
-		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
+		// mat3( 1.0 ) is an identity matrix
+		m.mapTransform = m.map == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx );
+		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
+		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
+		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
+		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
+		m.normalMapTransform = m.normalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
+		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
+		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
+		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
+		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
+		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
+		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
+		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 );
 
 		return m;
 
@@ -4624,9 +4653,9 @@ bool isMaterialFogVolume( sampler2D materials, uint materialIndex ) {
 
 // returns true if we're within the first fog volume we hit
 bool bvhIntersectFogVolumeHit(
-	BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+	vec3 rayOrigin, vec3 rayDirection,
 	usampler2D materialIndexAttribute, sampler2D materials,
-	out Material material
+	inout Material material
 ) {
 
 	material.fogVolume = false;
@@ -5086,7 +5115,7 @@ const bsdfSamplingGLSL = /* glsl */`
 	${ iridescenceGLSL }
 
 	// diffuse
-	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// https://schuttejoe.github.io/post/disneybsdf/
 		float fl = schlickFresnel( wi.z, 0.0 );
@@ -5100,15 +5129,17 @@ const bsdfSamplingGLSL = /* glsl */`
 
 		// TODO: subsurface approx?
 
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		color = ( 1.0 - F ) * transFactor * metalFactor * wi.z * surf.color * ( retro + lambert ) / PI;
+
 		return wi.z / PI;
 
 	}
 
 	vec3 diffuseDirection( vec3 wo, SurfaceRecord surf ) {
 
-		vec3 lightDirection = sampleSphere( sobol2( 11 ) );
+		vec3 lightDirection = sampleSphere( rand2( 11 ) );
 		lightDirection.z += 1.0;
 		lightDirection = normalize( lightDirection );
 
@@ -5117,7 +5148,7 @@ const bsdfSamplingGLSL = /* glsl */`
 	}
 
 	// specular
-	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// if roughness is set to 0 then D === NaN which results in black pixels
 		float metalness = surf.metalness;
@@ -5153,7 +5184,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 12 )
+			rand2( 12 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5164,7 +5195,7 @@ const bsdfSamplingGLSL = /* glsl */`
 
 	// transmission
 	/*
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
 
@@ -5190,7 +5221,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -5207,12 +5238,13 @@ const bsdfSamplingGLSL = /* glsl */`
 
 	// TODO: This is just using a basic cosine-weighted specular distribution with an
 	// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		color = surf.transmission * surf.color;
 
 		// PDF
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		if ( F >= 1.0 ) {
 
 			return 0.0;
@@ -5227,7 +5259,7 @@ const bsdfSamplingGLSL = /* glsl */`
 
 		float roughness = surf.filteredRoughness;
 		float eta = surf.eta;
-		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
+		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( rand2( 13 ) ) * roughness );
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 		if ( surf.thinFilm ) {
@@ -5268,7 +5300,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 14 )
+			rand2( 14 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -5298,12 +5330,13 @@ const bsdfSamplingGLSL = /* glsl */`
 	// bsdf
 	void getLobeWeights(
 		vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRecord surf,
-		out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight
+		inout float diffuseWeight, inout float specularWeight, inout float transmissionWeight, inout float clearcoatWeight
 	) {
 
 		float metalness = surf.metalness;
 		float transmission = surf.transmission;
-		float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float fEstimate = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 
 		float transSpecularProb = mix( max( 0.25, fEstimate ), 1.0, metalness );
 		float diffSpecularProb = 0.5 + 0.5 * metalness;
@@ -5322,7 +5355,7 @@ const bsdfSamplingGLSL = /* glsl */`
 
 	float bsdfEval(
 		vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRecord surf,
-		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, out float specularPdf, out vec3 color
+		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, inout float specularPdf, inout vec3 color
 	) {
 
 		float metalness = surf.metalness;
@@ -5385,7 +5418,7 @@ const bsdfSamplingGLSL = /* glsl */`
 
 	}
 
-	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, out vec3 color ) {
+	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, inout vec3 color ) {
 
 		if ( surf.volumeParticle ) {
 
@@ -5419,7 +5452,7 @@ const bsdfSamplingGLSL = /* glsl */`
 			ScatterRecord sampleRec;
 			sampleRec.specularPdf = 0.0;
 			sampleRec.pdf = 1.0 / ( 4.0 * PI );
-			sampleRec.direction = sampleSphere( sobol2( 16 ) );
+			sampleRec.direction = sampleSphere( rand2( 16 ) );
 			sampleRec.color = surf.color / ( 4.0 * PI );
 			return sampleRec;
 
@@ -5471,7 +5504,7 @@ const bsdfSamplingGLSL = /* glsl */`
 		vec3 wi;
 		vec3 clearcoatWi;
 
-		float r = sobol( 15 );
+		float r = rand( 15 );
 		if ( r <= cdf[0] ) { // diffuse
 
 			wi = diffuseDirection( wo, surf );
@@ -5553,14 +5586,14 @@ const equirectSamplingGLSL = /* glsl */`
 	}
 
 	// samples the color given env map with CDF and returns the pdf of the direction
-	float sampleEquirect( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
+	float sampleEquirect( vec3 direction, inout vec3 color ) {
 
 		vec2 uv = equirectDirectionToUv( direction );
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
@@ -5568,20 +5601,20 @@ const equirectSamplingGLSL = /* glsl */`
 	}
 
 	// samples a direction of the envmap with color and retrieves pdf
-	float sampleEquirectProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
+	float sampleEquirectProbability( vec2 r, inout vec3 color, inout vec3 direction ) {
 
 		// sample env map cdf
-		float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
-		float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
+		float v = texture2D( envMapInfo.marginalWeights, vec2( r.x, 0.0 ) ).x;
+		float u = texture2D( envMapInfo.conditionalWeights, vec2( r.y, v ) ).x;
 		vec2 uv = vec2( u, v );
 
 		vec3 derivedDirection = equirectUvToDirection( uv );
 		direction = derivedDirection;
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
@@ -5634,24 +5667,17 @@ const lightSamplingGLSL = /* glsl */`
 
 	};
 
-	bool lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection, out LightRecord lightRec ) {
+	bool intersectLightAtIndex( sampler2D lights, vec3 rayOrigin, vec3 rayDirection, uint l, inout LightRecord lightRec ) {
 
 		bool didHit = false;
-		uint l;
-		for ( l = 0u; l < lightCount; l ++ ) {
-
-			Light light = readLightInfo( lights, l );
-
-			vec3 u = light.u;
-			vec3 v = light.v;
-
-			// check for backface
-			vec3 normal = normalize( cross( u, v ) );
-			if ( dot( normal, rayDirection ) < 0.0 ) {
+		Light light = readLightInfo( lights, l );
 
-				continue;
+		vec3 u = light.u;
+		vec3 v = light.v;
 
-			}
+		// check for backface
+		vec3 normal = normalize( cross( u, v ) );
+		if ( dot( normal, rayDirection ) > 0.0 ) {
 
 			u *= 1.0 / dot( u, u );
 			v *= 1.0 / dot( v, v );
@@ -5664,17 +5690,13 @@ const lightSamplingGLSL = /* glsl */`
 				( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
 			) {
 
-				if ( ! didHit || dist < lightRec.dist ) {
-
-					float cosTheta = dot( rayDirection, normal );
-					didHit = true;
-					lightRec.dist = dist;
-					lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-					lightRec.emission = light.color * light.intensity;
-					lightRec.direction = rayDirection;
-					lightRec.type = light.type;
-
-				}
+				float cosTheta = dot( rayDirection, normal );
+				didHit = true;
+				lightRec.dist = dist;
+				lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+				lightRec.emission = light.color * light.intensity;
+				lightRec.direction = rayDirection;
+				lightRec.type = light.type;
 
 			}
 
@@ -5686,11 +5708,6 @@ const lightSamplingGLSL = /* glsl */`
 
 	LightRecord randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
 
-		LightRecord lightRec;
-		lightRec.type = light.type;
-
-		lightRec.emission = light.color * light.intensity;
-
 		vec3 randomPos;
 		if( light.type == RECT_AREA_LIGHT_TYPE ) {
 
@@ -5711,12 +5728,17 @@ const lightSamplingGLSL = /* glsl */`
 
 		vec3 toLight = randomPos - rayOrigin;
 		float lightDistSq = dot( toLight, toLight );
-		lightRec.dist = sqrt( lightDistSq );
+		float dist = sqrt( lightDistSq );
+		vec3 direction = toLight / dist;
+		vec3 lightNormal = normalize( cross( light.u, light.v ) );
 
-		vec3 direction = toLight / lightRec.dist;
+		LightRecord lightRec;
+		lightRec.type = light.type;
+		lightRec.emission = light.color * light.intensity;
+		lightRec.dist = dist;
 		lightRec.direction = direction;
 
-		vec3 lightNormal = normalize( cross( light.u, light.v ) );
+		// TODO: the denominator is potentially zero
 		lightRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
 
 		return lightRec;
@@ -5764,13 +5786,15 @@ const lightSamplingGLSL = /* glsl */`
 
 	LightRecord randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
 
+		LightRecord result;
+
 		// pick a random light
 		uint l = uint( ruv.x * float( lightCount ) );
 		Light light = readLightInfo( lights, l );
 
 		if ( light.type == SPOT_LIGHT_TYPE ) {
 
-			return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+			result = randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
 
 		} else if ( light.type == POINT_LIGHT_TYPE ) {
 
@@ -5790,7 +5814,7 @@ const lightSamplingGLSL = /* glsl */`
 			rec.pdf = 1.0;
 			rec.emission = light.color * light.intensity * distanceFalloff;
 			rec.type = light.type;
-			return rec;
+			result = rec;
 
 		} else if ( light.type == DIR_LIGHT_TYPE ) {
 
@@ -5801,15 +5825,17 @@ const lightSamplingGLSL = /* glsl */`
 			rec.emission = light.color * light.intensity;
 			rec.type = light.type;
 
-			return rec;
+			result = rec;
 
 		} else {
 
 			// sample the light
-			return randomAreaLightSample( light, rayOrigin, ruv.yz );
+			result = randomAreaLightSample( light, rayOrigin, ruv.yz );
 
 		}
 
+		return result;
+
 	}
 
 `;
@@ -5906,7 +5932,7 @@ const intersectShapesGLSL = /* glsl */`
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the rectangle on that same plane.
 	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
-	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -5937,7 +5963,7 @@ const intersectShapesGLSL = /* glsl */`
 
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the circle on that same plane. See above URL for a description of the plane intersection algorithm.
-	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -6117,32 +6143,38 @@ const fresnelGLSL = /* glsl */`
 
 	}
 
-	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
+	// TODO: disney fresnel was removed and replaced with this fresnel function to better align with
+	// the glTF but is causing blown out pixels. Should be revisited
+	// float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
 
-		if ( totalInternalReflection( cosTheta, eta ) ) {
+	// 	if ( totalInternalReflection( cosTheta, eta ) ) {
 
-			return 1.0;
+	// 		return 1.0;
 
-		}
+	// 	}
 
-		return schlickFresnel( cosTheta, f0 );
+	// 	return schlickFresnel( cosTheta, f0 );
 
-	}
+	// }
 
-	/*
 	// https://schuttejoe.github.io/post/disneybsdf/
 	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
 
 		float dotHV = dot( wo, wh );
-		float dotHL = dot( wi, wh );
+		if ( totalInternalReflection( dotHV, eta ) ) {
+
+			return 1.0;
 
+		}
+
+		float dotHL = dot( wi, wh );
 		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
 		float metallicFresnel = schlickFresnel( dotHL, f0 );
 
 		return mix( dielectricFresnel, metallicFresnel, metalness );
 
 	}
-	*/
+
 `;
 
 const arraySamplerTexelFetchGLSL = /*glsl */`
@@ -6199,28 +6231,28 @@ const pcgGLSL = /* glsl */`
 	}
 
 	// returns [ 0, 1 ]
-	float rand() {
+	float pcgRand() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
 
 	}
 
-	vec2 rand2() {
+	vec2 pcgRand2() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
 
 	}
 
-	vec3 rand3() {
+	vec3 pcgRand3() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
 
 	}
 
-	vec4 rand4() {
+	vec4 pcgRand4() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
@@ -6293,7 +6325,7 @@ const cameraUtilsGLSL = /* glsl */`
 
 		// Jitter the camera ray by finding a uv coordinate at a random sample
 		// around this pixel's UV coordinate for AA
-		vec2 ruv = sobol2( 0 );
+		vec2 ruv = rand2( 0 );
 		vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
 		Ray ray;
 
@@ -6338,7 +6370,7 @@ const cameraUtilsGLSL = /* glsl */`
 
 			// get the aperture sample
 			// if blades === 0 then we assume a circle
-			vec3 shapeUVW= sobol3( 1 );
+			vec3 shapeUVW= rand3( 1 );
 			int blades = physicalCamera.apertureBlades;
 			float anamorphicRatio = physicalCamera.anamorphicRatio;
 			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
@@ -6369,11 +6401,14 @@ const attenuateHitGLSL = /* glsl */`
 	// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
 	// returns true if a solid surface was hit
 	bool attenuateHit(
-		BVH bvh, RenderState state,
+		RenderState state,
 		Ray ray, float rayDist,
 		out vec3 color
 	) {
 
+		// store the original bounce index so we can reset it after
+		uint originalBounceIndex = sobolBounceIndex;
+
 		int traversals = state.traversals;
 		int transmissiveTraversals = state.transmissiveTraversals;
 		bool isShadowRay = state.isShadowRay;
@@ -6383,34 +6418,28 @@ const attenuateHitGLSL = /* glsl */`
 
 		// hit results
 		SurfaceHit surfaceHit;
-		LightRecord lightRec;
 
 		color = vec3( 1.0 );
 
-		// TODO: we should be using sobol sampling here instead of rand but the sobol bounce and path indices need to be incremented
-		// and then reset.
+		bool result = true;
 		for ( int i = 0; i < traversals; i ++ ) {
 
-			int hitType = traceScene(
-				ray, bvh, lights, fogMaterial,
-				surfaceHit, lightRec
-			);
-
-			if ( hitType == FOG_HIT ) {
+			sobolBounceIndex ++;
 
-				return true;
+			int hitType = traceScene( ray, fogMaterial, surfaceHit );
 
-			} else if ( hitType == LIGHT_HIT ) {
+			if ( hitType == FOG_HIT ) {
 
-				float totalDist = distance( startPoint, ray.origin + ray.direction * lightRec.dist );
-				return totalDist < rayDist - max( totalDist, rayDist ) * 1e-4;
+				result = true;
+				break;
 
 			} else if ( hitType == SURFACE_HIT ) {
 
 				float totalDist = distance( startPoint, ray.origin + ray.direction * surfaceHit.dist );
 				if ( totalDist > rayDist ) {
 
-					return false;
+					result = false;
+					break;
 
 				}
 
@@ -6492,7 +6521,7 @@ const attenuateHitGLSL = /* glsl */`
 				bool useAlphaTest = alphaTest != 0.0;
 				float transmissionFactor = ( 1.0 - metalness ) * transmission;
 				if (
-					transmissionFactor < rand() && ! (
+					transmissionFactor < rand( 9 ) && ! (
 						// material sidedness
 						material.side != 0.0 && surfaceHit.side == material.side
 
@@ -6500,11 +6529,12 @@ const attenuateHitGLSL = /* glsl */`
 						|| useAlphaTest && albedo.a < alphaTest
 
 						// opacity
-						|| material.transparent && ! useAlphaTest && albedo.a < rand()
+						|| material.transparent && ! useAlphaTest && albedo.a < rand( 10 )
 					)
 				) {
 
-					return true;
+					result = true;
+					break;
 
 				}
 
@@ -6530,13 +6560,16 @@ const attenuateHitGLSL = /* glsl */`
 
 			} else {
 
-				return false;
+				result = false;
+				break;
 
 			}
 
 		}
 
-		return true;
+		// reset the bounce index
+		sobolBounceIndex = originalBounceIndex;
+		return result;
 
 	}
 
@@ -6549,22 +6582,26 @@ const traceSceneGLSL = /* glsl */`
 	#define LIGHT_HIT 2
 	#define FOG_HIT 3
 
+	// Passing the global variable 'lights' into this function caused shader program errors.
+	// So global variables like 'lights' and 'bvh' were moved out of the function parameters.
+	// For more information, refer to: https://github.com/gkjohnson/three-gpu-pathtracer/pull/457
 	int traceScene(
 
-		Ray ray, BVH bvh, LightsInfo lights, Material fogMaterial,
-		out SurfaceHit surfaceHit, out LightRecord lightRec
+		Ray ray, Material fogMaterial, inout SurfaceHit surfaceHit
 
 	) {
 
+		int result = NO_HIT;
 		bool hit = bvhIntersectFirstHit( bvh, ray.origin, ray.direction, surfaceHit.faceIndices, surfaceHit.faceNormal, surfaceHit.barycoord, surfaceHit.side, surfaceHit.dist );
-		bool lightHit = lightsClosestHit( lights.tex, lights.count, ray.origin, ray.direction, lightRec );
 
 		#if FEATURE_FOG
 
 		if ( fogMaterial.fogVolume ) {
 
-			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
-			if ( particleDist + 1e-4 < surfaceHit.dist && ( particleDist + 1e-4 < lightRec.dist || ! lightHit ) ) {
+			// offset the distance so we don't run into issues with particles on the same surface
+			// as other objects
+			float particleDist = intersectFogVolume( fogMaterial, rand( 1 ) );
+			if ( particleDist + RAY_OFFSET < surfaceHit.dist ) {
 
 				surfaceHit.side = 1.0;
 				surfaceHit.faceNormal = normalize( - ray.direction );
@@ -6577,19 +6614,13 @@ const traceSceneGLSL = /* glsl */`
 
 		#endif
 
-		if ( lightHit && ( lightRec.dist < surfaceHit.dist || ! hit ) ) {
-
-			return LIGHT_HIT;
-
-		}
-
 		if ( hit ) {
 
-			return SURFACE_HIT;
+			result = SURFACE_HIT;
 
 		}
 
-		return NO_HIT;
+		return result;
 
 	}
 
@@ -6602,7 +6633,7 @@ const getSurfaceRecordGLSL = /* glsl */`
 	int getSurfaceRecord(
 		Material material, SurfaceHit surfaceHit, sampler2DArray attributesArray,
 		float accumulatedRoughness,
-		out SurfaceRecord surf
+		inout SurfaceRecord surf
 	) {
 
 		if ( material.fogVolume ) {
@@ -6632,6 +6663,7 @@ const getSurfaceRecordGLSL = /* glsl */`
 
 			vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
 			albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
 		}
 
 		if ( material.vertexColors ) {
@@ -6663,7 +6695,7 @@ const getSurfaceRecordGLSL = /* glsl */`
 			|| useAlphaTest && albedo.a < alphaTest
 
 			// opacity
-			|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
+			|| material.transparent && ! useAlphaTest && albedo.a < rand( 3 )
 		) {
 
 			return SKIP_SURFACE;
@@ -6922,11 +6954,13 @@ const directLightContributionGLSL = /*glsl*/`
 
 	vec3 directLightContribution( vec3 worldWo, SurfaceRecord surf, RenderState state, vec3 rayOrigin ) {
 
+		vec3 result = vec3( 0.0 );
+
 		// uniformly pick a light or environment map
-		if( lightsDenom != 0.0 && sobol( 5 ) < float( lights.count ) / lightsDenom ) {
+		if( lightsDenom != 0.0 && rand( 5 ) < float( lights.count ) / lightsDenom ) {
 
 			// sample a light or environment
-			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
+			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, rand3( 6 ) );
 
 			bool isSampleBelowSurface = ! surf.volumeParticle && dot( surf.faceNormal, lightRec.direction ) < 0.0;
 			if ( isSampleBelowSurface ) {
@@ -6943,7 +6977,7 @@ const directLightContributionGLSL = /*glsl*/`
 			if (
 				lightRec.pdf > 0.0 &&
 				isDirectionValid( lightRec.direction, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, lightRay, lightRec.dist, attenuatedColor )
+				! attenuateHit( state, lightRay, lightRec.dist, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -6955,7 +6989,7 @@ const directLightContributionGLSL = /*glsl*/`
 					// weight the direct light contribution
 					float lightPdf = lightRec.pdf / lightsDenom;
 					float misWeight = lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
-					return attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
+					result = attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
 
 				}
 
@@ -6965,7 +6999,7 @@ const directLightContributionGLSL = /*glsl*/`
 
 			// find a sample in the environment map to include in the contribution
 			vec3 envColor, envDirection;
-			float envPdf = sampleEquirectProbability( envMapInfo, sobol2( 7 ), envColor, envDirection );
+			float envPdf = sampleEquirectProbability( rand2( 7 ), envColor, envDirection );
 			envDirection = invEnvRotation3x3 * envDirection;
 
 			// this env sampling is not set up for transmissive sampling and yields overly bright
@@ -6986,7 +7020,7 @@ const directLightContributionGLSL = /*glsl*/`
 			if (
 				envPdf > 0.0 &&
 				isDirectionValid( envDirection, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, envRay, INFINITY, attenuatedColor )
+				! attenuateHit( state, envRay, INFINITY, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -6998,7 +7032,7 @@ const directLightContributionGLSL = /*glsl*/`
 					// weight the direct light contribution
 					envPdf /= lightsDenom;
 					float misWeight = misHeuristic( envPdf, envMaterialPdf );
-					return attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
+					result = attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
 
 				}
 
@@ -7006,12 +7040,675 @@ const directLightContributionGLSL = /*glsl*/`
 
 		}
 
-		return vec3( 0.0 );
+		// Function changed to have a single return statement to potentially help with crashes on Mac OS.
+		// See issue #470
+		return result;
+
+	}
+
+`;
+
+const stratifiedTextureGLSL = /* glsl */`
+
+	uniform sampler2D stratifiedTexture;
+	uniform sampler2D stratifiedOffsetTexture;
+
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
+	vec4 pixelSeed = vec4( 0 );
+
+	vec4 rand4( int v ) {
+
+		ivec2 uv = ivec2( v, sobolBounceIndex );
+		vec4 stratifiedSample = texelFetch( stratifiedTexture, uv, 0 );
+		return fract( stratifiedSample + pixelSeed.r ); // blue noise + stratified samples
+
+	}
+
+	vec3 rand3( int v ) {
+
+		return rand4( v ).xyz;
+
+	}
+
+	vec2 rand2( int v ) {
+
+		return rand4( v ).xy;
+
+	}
+
+	float rand( int v ) {
+
+		return rand4( v ).x;
+
+	}
+
+	void rng_initialize( vec2 screenCoord, int frame ) {
+
+		// tile the small noise texture across the entire screen
+		ivec2 noiseSize = ivec2( textureSize( stratifiedOffsetTexture, 0 ) );
+		pixelSeed = texelFetch( stratifiedOffsetTexture, ivec2( screenCoord.xy ) % noiseSize, 0 );
 
 	}
 
 `;
 
+// Stratified Sampling based on implementation from hoverinc pathtracer
+// - https://github.com/hoverinc/ray-tracing-renderer
+// - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
+
+function shuffle( arr ) {
+
+	for ( let i = arr.length - 1; i > 0; i -- ) {
+
+	  const j = Math.floor( Math.random() * ( i + 1 ) );
+	  const x = arr[ i ];
+	  arr[ i ] = arr[ j ];
+	  arr[ j ] = x;
+
+	}
+
+	return arr;
+
+}
+
+// strataCount : The number of bins per dimension
+// dimensions  : The number of dimensions to generate stratified values for
+class StratifiedSampler {
+
+	constructor( strataCount, dimensions ) {
+
+		const l = strataCount ** dimensions;
+		const strata = new Uint16Array( l );
+		let index = l;
+
+		// each integer represents a statum bin
+		for ( let i = 0; i < l; i ++ ) {
+
+			strata[ i ] = i;
+
+		}
+
+		this.samples = new Float32Array( dimensions );
+
+		this.strataCount = strataCount;
+
+		this.restart = function () {
+
+			index = 0;
+
+		};
+
+		this.next = function () {
+
+			const { samples } = this;
+
+			if ( index >= strata.length ) {
+
+				shuffle( strata );
+				this.restart();
+
+			}
+
+			let stratum = strata[ index ++ ];
+
+			for ( let i = 0; i < dimensions; i ++ ) {
+
+				samples[ i ] = ( stratum % strataCount + Math.random() ) / strataCount;
+				stratum = Math.floor( stratum / strataCount );
+
+			}
+
+			return samples;
+
+		};
+
+	}
+
+}
+
+// Stratified Sampling based on implementation from hoverinc pathtracer
+
+// Stratified set of data with each tuple stratified separately and combined
+class StratifiedSamplerCombined {
+
+	constructor( strataCount, listOfDimensions ) {
+
+		let totalDim = 0;
+		for ( const dim of listOfDimensions ) {
+
+			totalDim += dim;
+
+		}
+
+		const combined = new Float32Array( totalDim );
+		const strataObjs = [];
+		let offset = 0;
+		for ( const dim of listOfDimensions ) {
+
+			const sampler = new StratifiedSampler( strataCount, dim );
+			sampler.samples = new Float32Array( combined.buffer, offset, sampler.samples.length );
+			offset += sampler.samples.length * 4;
+			strataObjs.push( sampler );
+
+		}
+
+		this.samples = combined;
+
+		this.strataCount = strataCount;
+
+		this.next = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.next();
+
+			}
+
+			return combined;
+
+		};
+
+		this.restart = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.restart();
+
+			}
+
+		};
+
+	}
+
+}
+
+class StratifiedSamplesTexture extends DataTexture {
+
+	constructor( count = 1, depth = 1, strata = 8 ) {
+
+		super( new Float32Array( 1 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
+
+		this.strata = strata;
+		this.sampler = null;
+
+		this.init( count, depth, strata );
+
+	}
+
+	init( count, depth, strata = this.strata ) {
+
+		const { image } = this;
+		if ( image.width === depth && image.height === count ) {
+
+			return;
+
+		}
+
+		const dimensions = new Array( count * depth ).fill( 4 );
+		const sampler = new StratifiedSamplerCombined( strata, dimensions );
+
+		image.width = depth;
+		image.height = count;
+		image.data = sampler.samples;
+
+		this.sampler = sampler;
+
+		this.dispose();
+		this.next();
+
+	}
+
+	next() {
+
+		this.sampler.next();
+		this.needsUpdate = true;
+
+	}
+
+}
+
+function shuffleArray( array, random = Math.random ) {
+
+	for ( let i = array.length - 1; i > 0; i -- ) {
+
+		const replaceIndex = ~ ~ ( ( random() - 1e-6 ) * i );
+		const tmp = array[ i ];
+		array[ i ] = array[ replaceIndex ];
+		array[ replaceIndex ] = tmp;
+
+	}
+
+}
+
+function fillWithOnes( array, count ) {
+
+	array.fill( 0 );
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		array[ i ] = 1;
+
+	}
+
+}
+
+class BlueNoiseSamples {
+
+	constructor( size ) {
+
+		this.count = 0;
+		this.size = - 1;
+		this.sigma = - 1;
+		this.radius = - 1;
+		this.lookupTable = null;
+		this.score = null;
+		this.binaryPattern = null;
+
+		this.resize( size );
+		this.setSigma( 1.5 );
+
+	}
+
+	findVoid() {
+
+		const { score, binaryPattern } = this;
+
+		let currValue = Infinity;
+		let currIndex = - 1;
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] !== 0 ) {
+
+				continue;
+
+			}
+
+			const pScore = score[ i ];
+			if ( pScore < currValue ) {
+
+				currValue = pScore;
+				currIndex = i;
+
+			}
+
+		}
+
+		return currIndex;
+
+	}
+
+	findCluster() {
+
+		const { score, binaryPattern } = this;
+
+		let currValue = - Infinity;
+		let currIndex = - 1;
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] !== 1 ) {
+
+				continue;
+
+			}
+
+			const pScore = score[ i ];
+			if ( pScore > currValue ) {
+
+				currValue = pScore;
+				currIndex = i;
+
+			}
+
+		}
+
+		return currIndex;
+
+	}
+
+	setSigma( sigma ) {
+
+		if ( sigma === this.sigma ) {
+
+			return;
+
+		}
+
+		// generate a radius in which the score will be updated under the
+		// assumption that e^-10 is insignificant enough to be the border at
+		// which we drop off.
+		const radius = ~ ~ ( Math.sqrt( 10 * 2 * ( sigma ** 2 ) ) + 1 );
+		const lookupWidth = 2 * radius + 1;
+		const lookupTable = new Float32Array( lookupWidth * lookupWidth );
+		const sigma2 = sigma * sigma;
+		for ( let x = - radius; x <= radius; x ++ ) {
+
+			for ( let y = - radius; y <= radius; y ++ ) {
+
+				const index = ( radius + y ) * lookupWidth + x + radius;
+				const dist2 = x * x + y * y;
+				lookupTable[ index ] = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+			}
+
+		}
+
+		this.lookupTable = lookupTable;
+		this.sigma = sigma;
+		this.radius = radius;
+
+	}
+
+	resize( size ) {
+
+		if ( this.size !== size ) {
+
+			this.size = size;
+			this.score = new Float32Array( size * size );
+			this.binaryPattern = new Uint8Array( size * size );
+
+		}
+
+
+	}
+
+	invert() {
+
+		const { binaryPattern, score, size } = this;
+
+		score.fill( 0 );
+
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] === 0 ) {
+
+				const y = ~ ~ ( i / size );
+				const x = i - y * size;
+				this.updateScore( x, y, 1 );
+				binaryPattern[ i ] = 1;
+
+			} else {
+
+				binaryPattern[ i ] = 0;
+
+			}
+
+		}
+
+	}
+
+	updateScore( x, y, multiplier ) {
+
+		// TODO: Is there a way to keep track of the highest and lowest scores here to avoid have to search over
+		// everything in the buffer?
+		const { size, score, lookupTable } = this;
+
+		// const sigma2 = sigma * sigma;
+		// const radius = Math.floor( size / 2 );
+		const radius = this.radius;
+		const lookupWidth = 2 * radius + 1;
+		for ( let px = - radius; px <= radius; px ++ ) {
+
+			for ( let py = - radius; py <= radius; py ++ ) {
+
+				// const dist2 = px * px + py * py;
+				// const value = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+				const lookupIndex = ( radius + py ) * lookupWidth + px + radius;
+				const value = lookupTable[ lookupIndex ];
+
+				let sx = ( x + px );
+				sx = sx < 0 ? size + sx : sx % size;
+
+				let sy = ( y + py );
+				sy = sy < 0 ? size + sy : sy % size;
+
+				const sindex = sy * size + sx;
+				score[ sindex ] += multiplier * value;
+
+			}
+
+		}
+
+	}
+
+	addPointIndex( index ) {
+
+		this.binaryPattern[ index ] = 1;
+
+		const size = this.size;
+		const y = ~ ~ ( index / size );
+		const x = index - y * size;
+		this.updateScore( x, y, 1 );
+		this.count ++;
+
+	}
+
+	removePointIndex( index ) {
+
+		this.binaryPattern[ index ] = 0;
+
+		const size = this.size;
+		const y = ~ ~ ( index / size );
+		const x = index - y * size;
+		this.updateScore( x, y, - 1 );
+		this.count --;
+
+	}
+
+	copy( source ) {
+
+		this.resize( source.size );
+		this.score.set( source.score );
+		this.binaryPattern.set( source.binaryPattern );
+		this.setSigma( source.sigma );
+		this.count = source.count;
+
+	}
+
+}
+
+class BlueNoiseGenerator {
+
+	constructor() {
+
+		this.random = Math.random;
+		this.sigma = 1.5;
+		this.size = 64;
+		this.majorityPointsRatio = 0.1;
+
+		this.samples = new BlueNoiseSamples( 1 );
+		this.savedSamples = new BlueNoiseSamples( 1 );
+
+	}
+
+	generate() {
+
+		// http://cv.ulichney.com/papers/1993-void-cluster.pdf
+
+		const {
+			samples,
+			savedSamples,
+			sigma,
+			majorityPointsRatio,
+			size,
+		} = this;
+
+		samples.resize( size );
+		samples.setSigma( sigma );
+
+		// 1. Randomly place the minority points.
+		const pointCount = Math.floor( size * size * majorityPointsRatio );
+		const initialSamples = samples.binaryPattern;
+
+		fillWithOnes( initialSamples, pointCount );
+		shuffleArray( initialSamples, this.random );
+
+		for ( let i = 0, l = initialSamples.length; i < l; i ++ ) {
+
+			if ( initialSamples[ i ] === 1 ) {
+
+				samples.addPointIndex( i );
+
+			}
+
+		}
+
+		// 2. Remove minority point that is in densest cluster and place it in the largest void.
+		while ( true ) {
+
+			const clusterIndex = samples.findCluster();
+			samples.removePointIndex( clusterIndex );
+
+			const voidIndex = samples.findVoid();
+			if ( clusterIndex === voidIndex ) {
+
+				samples.addPointIndex( clusterIndex );
+				break;
+
+			}
+
+			samples.addPointIndex( voidIndex );
+
+		}
+
+		// 3. PHASE I: Assign a rank to each progressively less dense cluster point and put it
+		// in the dither array.
+		const ditherArray = new Uint32Array( size * size );
+		savedSamples.copy( samples );
+
+		let rank;
+		rank = samples.count - 1;
+		while ( rank >= 0 ) {
+
+			const clusterIndex = samples.findCluster();
+			samples.removePointIndex( clusterIndex );
+
+			ditherArray[ clusterIndex ] = rank;
+			rank --;
+
+		}
+
+		// 4. PHASE II: Do the same thing for the largest voids up to half of the total pixels using
+		// the initial binary pattern.
+		const totalSize = size * size;
+		rank = savedSamples.count;
+		while ( rank < totalSize / 2 ) {
+
+			const voidIndex = savedSamples.findVoid();
+			savedSamples.addPointIndex( voidIndex );
+			ditherArray[ voidIndex ] = rank;
+			rank ++;
+
+		}
+
+		// 5. PHASE III: Invert the pattern and finish out by assigning a rank to the remaining
+		// and iteratively removing them.
+		savedSamples.invert();
+
+		while ( rank < totalSize ) {
+
+			const clusterIndex = savedSamples.findCluster();
+			savedSamples.removePointIndex( clusterIndex );
+			ditherArray[ clusterIndex ] = rank;
+			rank ++;
+
+		}
+
+		return { data: ditherArray, maxValue: totalSize };
+
+	}
+
+}
+
+function getStride( channels ) {
+
+	if ( channels >= 3 ) {
+
+		return 4;
+
+	} else {
+
+		return channels;
+
+	}
+
+}
+
+function getFormat( channels ) {
+
+	switch ( channels ) {
+
+	case 1:
+		return RedFormat;
+	case 2:
+		return RGFormat;
+	default:
+		return RGBAFormat;
+
+	}
+
+}
+
+class BlueNoiseTexture extends DataTexture {
+
+	constructor( size = 64, channels = 1 ) {
+
+		super( new Float32Array( 4 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
+
+		this.size = size;
+		this.channels = channels;
+		this.update();
+
+	}
+
+	update() {
+
+		const channels = this.channels;
+		const size = this.size;
+		const generator = new BlueNoiseGenerator();
+		generator.channels = channels;
+		generator.size = size;
+
+		const stride = getStride( channels );
+		const format = getFormat( stride );
+		if ( this.image.width !== size || format !== this.format ) {
+
+			this.image.width = size;
+			this.image.height = size;
+			this.image.data = new Float32Array( ( size ** 2 ) * stride );
+			this.format = format;
+			this.dispose();
+
+		}
+
+		const data = this.image.data;
+		for ( let i = 0, l = channels; i < l; i ++ ) {
+
+			const result = generator.generate();
+			const bin = result.data;
+			const maxValue = result.maxValue;
+
+			for ( let j = 0, l2 = bin.length; j < l2; j ++ ) {
+
+				const value = bin[ j ] / maxValue;
+				data[ j * stride + i ] = value;
+
+			}
+
+		}
+
+		this.needsUpdate = true;
+
+	}
+
+}
+
 class PhysicalPathTracingMaterial extends MaterialBase {
 
 	onBeforeRender() {
@@ -7035,6 +7732,12 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				FEATURE_DOF: 1,
 				FEATURE_BACKGROUND_MAP: 0,
 				FEATURE_FOG: 1,
+
+				// 0 = PCG
+				// 1 = Sobol
+				// 2 = Stratified List
+				RANDOM_TYPE: 2,
+
 				// 0 = Perspective
 				// 1 = Orthographic
 				// 2 = Equirectangular
@@ -7076,6 +7779,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				backgroundAlpha: { value: 1.0 },
 				sobolTexture: { value: null },
+				stratifiedTexture: { value: new StratifiedSamplesTexture() },
+				stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
 			},
 
 			vertexShader: /* glsl */`
@@ -7104,13 +7809,48 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				#include <common>
 
 				// bvh intersection
-				${ shaderStructs }
-				${ shaderIntersectFunction }
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ BVHShaderGLSL.bvh_ray_functions }
+
+				// uniform structs
+				${ cameraStructGLSL }
+				${ lightsStructGLSL }
+				${ equirectStructGLSL }
+				${ materialStructGLSL }
 
 				// random
-				${ pcgGLSL }
-				${ sobolCommonGLSL }
-				${ sobolSamplingGLSL }
+				#if RANDOM_TYPE == 2 	// Stratified List
+
+					${ stratifiedTextureGLSL }
+
+				#elif RANDOM_TYPE == 1 	// Sobol
+
+					${ pcgGLSL }
+					${ sobolCommonGLSL }
+					${ sobolSamplingGLSL }
+
+					#define rand(v) sobol(v)
+					#define rand2(v) sobol2(v)
+					#define rand3(v) sobol3(v)
+					#define rand4(v) sobol4(v)
+
+				#else 					// PCG
+
+					${ pcgGLSL }
+
+					// Using the sobol functions seems to break the the compiler on MacOS
+					// - specifically the "sobolReverseBits" function.
+					uint sobolPixelIndex = 0u;
+					uint sobolPathIndex = 0u;
+					uint sobolBounceIndex = 0u;
+
+					#define rand(v) pcgRand()
+					#define rand2(v) pcgRand2()
+					#define rand3(v) pcgRand3()
+					#define rand4(v) pcgRand4()
+
+				#endif
 
 				// common
 				${ arraySamplerTexelFetchGLSL }
@@ -7119,20 +7859,6 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				${ mathGLSL }
 				${ intersectShapesGLSL }
 
-				// uniform structs
-				${ cameraStructGLSL }
-				${ lightsStructGLSL }
-				${ equirectStructGLSL }
-				${ materialStructGLSL }
-				${ fogMaterialBvhGLSL }
-
-				// sampling
-				${ shapeSamplingGLSL }
-				${ bsdfSamplingGLSL }
-				${ equirectSamplingGLSL }
-				${ lightSamplingGLSL }
-				${ fogGLSL }
-
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
 				uniform mat4 environmentRotation;
@@ -7184,6 +7910,14 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				mat3 invEnvRotation3x3;
 				float lightsDenom;
 
+				// sampling
+				${ fogMaterialBvhGLSL }
+				${ shapeSamplingGLSL }
+				${ bsdfSamplingGLSL }
+				${ equirectSamplingGLSL }
+				${ lightSamplingGLSL }
+				${ fogGLSL }
+
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
 					return clamp(
@@ -7223,7 +7957,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 					// init
 					rng_initialize( gl_FragCoord.xy, seed );
-					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) |  uint( gl_FragCoord.y );
+					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) | uint( gl_FragCoord.y );
 					sobolPathIndex = uint( seed );
 
 					// get camera ray
@@ -7239,7 +7973,6 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 					// surface results
 					SurfaceHit surfaceHit;
-					LightRecord lightRec;
 					ScatterRecord scatterRec;
 
 					// path tracing state
@@ -7248,7 +7981,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					#if FEATURE_FOG
 
 					state.fogMaterial.fogVolume = bvhIntersectFogVolumeHit(
-						bvh, ray.origin, - ray.direction,
+						ray.origin, - ray.direction,
 						materialIndexAttribute, materials,
 						state.fogMaterial
 					);
@@ -7263,48 +7996,46 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						state.traversals = bounces - i;
 						state.firstRay = i == 0 && state.transmissiveTraversals == transmissiveBounces;
 
-						int hitType = traceScene(
-							ray, bvh, lights, state.fogMaterial,
-							surfaceHit, lightRec
-						);
+						int hitType = traceScene( ray, state.fogMaterial, surfaceHit );
 
-						if ( hitType == LIGHT_HIT ) {
+						// check if we intersect any lights and accumulate the light contribution
+						// TODO: we can add support for light surface rendering in the else condition if we
+						// add the ability to toggle visibility of the the light
+						if ( ! state.firstRay && ! state.transmissiveRay ) {
 
-							if ( state.firstRay || state.transmissiveRay ) {
+							LightRecord lightRec;
+							float lightDist = hitType == NO_HIT ? INFINITY : surfaceHit.dist;
+							for ( uint i = 0u; i < lights.count; i ++ ) {
 
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+								if (
+									intersectLightAtIndex( lights.tex, ray.origin, ray.direction, i, lightRec ) &&
+									lightRec.dist < lightDist
+								) {
 
-							} else {
-
-								#if FEATURE_MIS
-
-								// NOTE: we skip MIS for punctual lights since they are not supported in forward PT case
-								if ( lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ) {
-
-									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
-
-								} else {
+									#if FEATURE_MIS
 
 									// weight the contribution
+									// NOTE: Only area lights are supported for forward sampling and can be hit
 									float misWeight = misHeuristic( scatterRec.pdf, lightRec.pdf / lightsDenom );
 									gl_FragColor.rgb += lightRec.emission * state.throughputColor * misWeight;
 
-								}
+									#else
 
-								#else
+									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
 
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+									#endif
 
-								#endif
+								}
 
 							}
-							break;
 
-						} else if ( hitType == NO_HIT ) {
+						}
+
+						if ( hitType == NO_HIT ) {
 
 							if ( state.firstRay || state.transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, sobol2( 2 ) ) * state.throughputColor;
+								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, rand2( 2 ) ) * state.throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {
@@ -7313,7 +8044,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 								// get the PDF of the hit envmap point
 								vec3 envColor;
-								float envPdf = sampleEquirect( envMapInfo, envRotation3x3 * ray.direction, envColor );
+								float envPdf = sampleEquirect( envRotation3x3 * ray.direction, envColor );
 								envPdf /= lightsDenom;
 
 								// and weight the contribution
@@ -7395,7 +8126,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						}
 
 						scatterRec = bsdfSample( - ray.direction, surf );
-						state.isShadowRay = scatterRec.specularPdf < sobol( 4 );
+						state.isShadowRay = scatterRec.specularPdf < rand( 4 );
 
 						bool isBelowSurface = ! surf.volumeParticle && dot( scatterRec.direction, surf.faceNormal ) < 0.0;
 						vec3 hitPoint = stepRayOrigin( ray.origin, ray.direction, isBelowSurface ? - surf.faceNormal : surf.faceNormal, surfaceHit.dist );
@@ -7465,7 +8196,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						rrProb = sqrt( rrProb );
 						rrProb = max( rrProb, depthProb );
 						rrProb = min( rrProb, 1.0 );
-						if ( sobol( 8 ) > rrProb ) {
+						if ( rand( 8 ) > rrProb ) {
 
 							break;
 
@@ -7870,5 +8601,5 @@ class CompatibilityDetector {
 
 // core
 
-export { BlurredEnvMapGenerator, CompatibilityDetector, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, FogVolumeMaterial, GradientEquirectTexture, GradientMapMaterial, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, QuiltPathTracingRenderer, RenderTarget2DArray, ShapedAreaLight, getGroupMaterialIndicesAttribute, mergeMeshes, setCommonAttributes, trimToAttributes };
+export { BlurredEnvMapGenerator, CompatibilityDetector, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, EquirectHdrInfoUniform, FogVolumeMaterial, GradientEquirectTexture, GradientMapMaterial, GraphMaterial, IESLoader, IESProfilesTexture, LightsInfoUniformStruct, MaterialBase, MaterialReducer, MaterialsTexture, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalCameraUniform, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, QuiltPathTracingRenderer, RenderTarget2DArray, ShapedAreaLight, getDummyMesh, getGroupMaterialIndicesAttribute, setCommonAttributes };
 //# sourceMappingURL=index.module.js.map