three-gpu-pathtracer 0.0.8 → 0.0.9

package/build/index.module.js

@@ -1,5 +1,6 @@
-import { ShaderMaterial, NoBlending, NormalBlending, Color, Vector2, WebGLRenderTarget, RGBAFormat, FloatType, BufferAttribute, Mesh, BufferGeometry, PerspectiveCamera, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, Vector3, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, HalfFloatType, DataUtils, RedFormat, Matrix4, Quaternion, Loader, MathUtils, FileLoader, PMREMGenerator, Vector4, DataArrayTexture } from 'three';
-import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, NormalBlending, Color, BufferAttribute, Mesh, BufferGeometry, PerspectiveCamera, Camera, SpotLight, RectAreaLight, Spherical, DataTexture, EquirectangularReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, LinearFilter, Vector3, DoubleSide, BackSide, FrontSide, WebGLArrayRenderTarget, UnsignedByteType, MeshBasicMaterial, NoToneMapping, Source, HalfFloatType, DataUtils, RedFormat, Matrix4, Quaternion, Loader, MathUtils, FileLoader, PMREMGenerator, Vector4, DataArrayTexture } from 'three';
+import { FullScreenQuad as FullScreenQuad$1 } from 'three/examples/jsm/postprocessing/Pass.js';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass';
 import { StaticGeometryGenerator, SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
 import { mergeVertices, mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
@@ -123,6 +124,339 @@ class BlendMaterial extends MaterialBase {
 
 }
 
+// References
+// - https://jcgt.org/published/0009/04/01/
+// - Code from https://www.shadertoy.com/view/WtGyDm
+
+// functions to generate multi-dimensions variables of the same functions
+// to support 1, 2, 3, and 4 dimensional sobol sampling.
+function generateSobolFunctionVariants( dim = 1 ) {
+
+	let type = 'uint';
+	if ( dim > 1 ) {
+
+		type = 'uvec' + dim;
+
+	}
+
+	return /* glsl */`
+		${ type } sobolReverseBits( ${ type } x ) {
+
+			x = ( ( ( x & 0xaaaaaaaau ) >> 1 ) | ( ( x & 0x55555555u ) << 1 ) );
+			x = ( ( ( x & 0xccccccccu ) >> 2 ) | ( ( x & 0x33333333u ) << 2 ) );
+			x = ( ( ( x & 0xf0f0f0f0u ) >> 4 ) | ( ( x & 0x0f0f0f0fu ) << 4 ) );
+			x = ( ( ( x & 0xff00ff00u ) >> 8 ) | ( ( x & 0x00ff00ffu ) << 8 ) );
+			return ( ( x >> 16 ) | ( x << 16 ) );
+
+		}
+
+		${ type } sobolHashCombine( uint seed, ${ type } v ) {
+
+			return seed ^ ( v + ${ type }( ( seed << 6 ) + ( seed >> 2 ) ) );
+
+		}
+
+		${ type } sobolLaineKarrasPermutation( ${ type } x, ${ type } seed ) {
+
+			x += seed;
+			x ^= x * 0x6c50b47cu;
+			x ^= x * 0xb82f1e52u;
+			x ^= x * 0xc7afe638u;
+			x ^= x * 0x8d22f6e6u;
+			return x;
+
+		}
+
+		${ type } nestedUniformScrambleBase2( ${ type } x, ${ type } seed ) {
+
+			x = sobolLaineKarrasPermutation( x, seed );
+			x = sobolReverseBits( x );
+			return x;
+
+		}
+	`;
+
+}
+
+function generateSobolSampleFunctions( dim = 1 ) {
+
+	let utype = 'uint';
+	let vtype = 'float';
+	let num = '';
+	let components = '.r';
+	let combineValues = '1u';
+	if ( dim > 1 ) {
+
+		utype = 'uvec' + dim;
+		vtype = 'vec' + dim;
+		num = dim + '';
+		if ( dim === 2 ) {
+
+			components = '.rg';
+			combineValues = 'uvec2( 1u, 2u )';
+
+		} else if ( dim === 3 ) {
+
+			components = '.rgb';
+			combineValues = 'uvec3( 1u, 2u, 3u )';
+
+		} else {
+
+			components = '';
+			combineValues = 'uvec4( 1u, 2u, 3u, 4u )';
+
+		}
+
+	}
+
+	return /* glsl */`
+
+		${ vtype } sobol${ num }( int effect ) {
+
+			uint seed = sobolGetSeed( sobolBounceIndex, uint( effect ) );
+			uint index = sobolPathIndex;
+
+			uint shuffle_seed = sobolHashCombine( seed, 0u );
+			uint shuffled_index = nestedUniformScrambleBase2( sobolReverseBits( index ), shuffle_seed );
+			${ vtype } sobol_pt = sobolGetTexturePoint( shuffled_index )${ components };
+			${ utype } result = ${ utype }( sobol_pt * 16777216.0 );
+
+			${ utype } seed2 = sobolHashCombine( seed, ${ combineValues } );
+			result = nestedUniformScrambleBase2( result, seed2 );
+
+			return SOBOL_FACTOR * ${ vtype }( result >> 8 );
+
+		}
+	`;
+
+}
+
+const shaderSobolCommon = /* glsl */`
+
+	// Utils
+	const float SOBOL_FACTOR = 1.0 / 16777216.0;
+	const uint SOBOL_MAX_POINTS = 256u * 256u;
+
+	${ generateSobolFunctionVariants( 1 ) }
+	${ generateSobolFunctionVariants( 2 ) }
+	${ generateSobolFunctionVariants( 3 ) }
+	${ generateSobolFunctionVariants( 4 ) }
+
+	uint sobolHash( uint x ) {
+
+		// finalizer from murmurhash3
+		x ^= x >> 16;
+		x *= 0x85ebca6bu;
+		x ^= x >> 13;
+		x *= 0xc2b2ae35u;
+		x ^= x >> 16;
+		return x;
+
+	}
+
+`;
+
+const shaderSobolGeneration = /* glsl */`
+
+	const uint SOBOL_DIRECTIONS_1[ 32 ] = uint[ 32 ](
+		0x80000000u, 0xc0000000u, 0xa0000000u, 0xf0000000u,
+		0x88000000u, 0xcc000000u, 0xaa000000u, 0xff000000u,
+		0x80800000u, 0xc0c00000u, 0xa0a00000u, 0xf0f00000u,
+		0x88880000u, 0xcccc0000u, 0xaaaa0000u, 0xffff0000u,
+		0x80008000u, 0xc000c000u, 0xa000a000u, 0xf000f000u,
+		0x88008800u, 0xcc00cc00u, 0xaa00aa00u, 0xff00ff00u,
+		0x80808080u, 0xc0c0c0c0u, 0xa0a0a0a0u, 0xf0f0f0f0u,
+		0x88888888u, 0xccccccccu, 0xaaaaaaaau, 0xffffffffu
+	);
+
+	const uint SOBOL_DIRECTIONS_2[ 32 ] = uint[ 32 ](
+		0x80000000u, 0xc0000000u, 0x60000000u, 0x90000000u,
+		0xe8000000u, 0x5c000000u, 0x8e000000u, 0xc5000000u,
+		0x68800000u, 0x9cc00000u, 0xee600000u, 0x55900000u,
+		0x80680000u, 0xc09c0000u, 0x60ee0000u, 0x90550000u,
+		0xe8808000u, 0x5cc0c000u, 0x8e606000u, 0xc5909000u,
+		0x6868e800u, 0x9c9c5c00u, 0xeeee8e00u, 0x5555c500u,
+		0x8000e880u, 0xc0005cc0u, 0x60008e60u, 0x9000c590u,
+		0xe8006868u, 0x5c009c9cu, 0x8e00eeeeu, 0xc5005555u
+	);
+
+	const uint SOBOL_DIRECTIONS_3[ 32 ] = uint[ 32 ](
+		0x80000000u, 0xc0000000u, 0x20000000u, 0x50000000u,
+		0xf8000000u, 0x74000000u, 0xa2000000u, 0x93000000u,
+		0xd8800000u, 0x25400000u, 0x59e00000u, 0xe6d00000u,
+		0x78080000u, 0xb40c0000u, 0x82020000u, 0xc3050000u,
+		0x208f8000u, 0x51474000u, 0xfbea2000u, 0x75d93000u,
+		0xa0858800u, 0x914e5400u, 0xdbe79e00u, 0x25db6d00u,
+		0x58800080u, 0xe54000c0u, 0x79e00020u, 0xb6d00050u,
+		0x800800f8u, 0xc00c0074u, 0x200200a2u, 0x50050093u
+	);
+
+	const uint SOBOL_DIRECTIONS_4[ 32 ] = uint[ 32 ](
+		0x80000000u, 0x40000000u, 0x20000000u, 0xb0000000u,
+		0xf8000000u, 0xdc000000u, 0x7a000000u, 0x9d000000u,
+		0x5a800000u, 0x2fc00000u, 0xa1600000u, 0xf0b00000u,
+		0xda880000u, 0x6fc40000u, 0x81620000u, 0x40bb0000u,
+		0x22878000u, 0xb3c9c000u, 0xfb65a000u, 0xddb2d000u,
+		0x78022800u, 0x9c0b3c00u, 0x5a0fb600u, 0x2d0ddb00u,
+		0xa2878080u, 0xf3c9c040u, 0xdb65a020u, 0x6db2d0b0u,
+		0x800228f8u, 0x400b3cdcu, 0x200fb67au, 0xb00ddb9du
+	);
+
+	uint getMaskedSobol( uint index, uint directions[ 32 ] ) {
+
+		uint X = 0u;
+		for ( int bit = 0; bit < 32; bit ++ ) {
+
+			uint mask = ( index >> bit ) & 1u;
+			X ^= mask * directions[ bit ];
+
+		}
+		return X;
+
+	}
+
+	vec4 generateSobolPoint( uint index ) {
+
+		if ( index >= SOBOL_MAX_POINTS ) {
+
+			return vec4( 0.0 );
+
+		}
+
+		// NOTEL this sobol "direction" is also available but we can't write out 5 components
+		// uint x = index & 0x00ffffffu;
+		uint x = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_1 ) ) & 0x00ffffffu;
+		uint y = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_2 ) ) & 0x00ffffffu;
+		uint z = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_3 ) ) & 0x00ffffffu;
+		uint w = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_4 ) ) & 0x00ffffffu;
+
+		return vec4( x, y, z, w ) * SOBOL_FACTOR;
+
+	}
+
+`;
+
+const shaderSobolSampling = /* glsl */`
+
+	// Seeds
+	uniform sampler2D sobolTexture;
+	uint sobolPixelIndex;
+	uint sobolPathIndex;
+	uint sobolBounceIndex;
+
+	uint sobolGetSeed( uint bounce, uint effect ) {
+
+		return sobolHash(
+			sobolHashCombine(
+				sobolHashCombine(
+					sobolHash( bounce ),
+					sobolPixelIndex
+				),
+				effect
+			)
+		);
+
+	}
+
+	vec4 sobolGetTexturePoint( uint index ) {
+
+		if ( index >= SOBOL_MAX_POINTS ) {
+
+			index = index % SOBOL_MAX_POINTS;
+
+		}
+
+		uvec2 dim = uvec2( textureSize( sobolTexture, 0 ).xy );
+		uint y = index / dim.x;
+		uint x = index - y * dim.x;
+		vec2 uv = vec2( x, y ) / vec2( dim );
+		return texture( sobolTexture, uv );
+
+	}
+
+	${ generateSobolSampleFunctions( 1 ) }
+	${ generateSobolSampleFunctions( 2 ) }
+	${ generateSobolSampleFunctions( 3 ) }
+	${ generateSobolSampleFunctions( 4 ) }
+
+`;
+
+class SobolNumbersMaterial extends MaterialBase {
+
+	constructor() {
+
+		super( {
+
+			blending: NoBlending,
+
+			uniforms: {
+
+				resolution: { value: new Vector2() },
+
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+
+			fragmentShader: /* glsl */`
+
+				${ shaderSobolCommon }
+				${ shaderSobolGeneration }
+
+				varying vec2 vUv;
+				uniform vec2 resolution;
+				void main() {
+
+					uint index = uint( gl_FragCoord.y ) * uint( resolution.x ) + uint( gl_FragCoord.x );
+					gl_FragColor = generateSobolPoint( index );
+
+				}
+			`,
+
+		} );
+
+	}
+
+}
+
+class SobolNumberMapGenerator {
+
+	generate( renderer, dimensions = 256 ) {
+
+		const target = new WebGLRenderTarget( dimensions, dimensions, {
+
+			type: FloatType,
+			format: RGBAFormat,
+			minFilter: NearestFilter,
+			magFilter: NearestFilter,
+			generateMipmaps: false,
+
+		} );
+
+		const ogTarget = renderer.getRenderTarget();
+		renderer.setRenderTarget( target );
+
+		const quad = new FullScreenQuad( new SobolNumbersMaterial() );
+		quad.material.resolution.set( dimensions, dimensions );
+		quad.render( renderer );
+
+		renderer.setRenderTarget( ogTarget );
+		quad.dispose();
+
+		return target;
+
+	}
+
+}
+
 function* renderTask() {
 
 	const {
@@ -131,6 +465,7 @@ function* renderTask() {
 		_blendQuad,
 		_primaryTarget,
 		_blendTargets,
+		_sobolTarget,
 		alpha,
 		camera,
 		material,
@@ -157,6 +492,7 @@ function* renderTask() {
 		const w = _primaryTarget.width;
 		const h = _primaryTarget.height;
 		material.resolution.set( w, h );
+		material.sobolTexture = _sobolTarget.texture;
 		material.seed ++;
 
 		const tilesX = this.tiles.x || 1;
@@ -300,11 +636,12 @@ class PathTracingRenderer {
 
 		this._renderer = renderer;
 		this._alpha = false;
-		this._fsQuad = new FullScreenQuad( null );
-		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
+		this._fsQuad = new FullScreenQuad$1( null );
+		this._blendQuad = new FullScreenQuad$1( new BlendMaterial() );
 		this._task = null;
 		this._currentTile = 0;
 
+		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
 			format: RGBAFormat,
 			type: FloatType,
@@ -336,6 +673,7 @@ class PathTracingRenderer {
 		this._primaryTarget.dispose();
 		this._blendTargets[ 0 ].dispose();
 		this._blendTargets[ 1 ].dispose();
+		this._sobolTarget.dispose();
 
 		this._fsQuad.dispose();
 		this._blendQuad.dispose();
@@ -1201,6 +1539,14 @@ class GradientEquirectTexture extends ProceduralEquirectTexture {
 
 }
 
+// we must hash the texture to determine uniqueness using the encoding, as well, because the
+// when rendering each texture to the texture array they must have a consistent color space.
+function getTextureHash( t ) {
+
+	return `${ t.source.uuid }:${ t.encoding }`;
+
+}
+
 // reduce the set of textures to just those with a unique source while retaining
 // the order of the textures.
 function reduceTexturesToUniqueSources( textures ) {
@@ -1210,9 +1556,10 @@ function reduceTexturesToUniqueSources( textures ) {
 	for ( let i = 0, l = textures.length; i < l; i ++ ) {
 
 		const tex = textures[ i ];
-		if ( ! sourceSet.has( tex.source ) ) {
+		const hash = getTextureHash( tex );
+		if ( ! sourceSet.has( hash ) ) {
 
-			sourceSet.add( tex.source );
+			sourceSet.add( hash );
 			result.push( tex );
 
 		}
@@ -1283,8 +1630,8 @@ class MaterialsTexture extends DataTexture {
 
 			if ( key in material && material[ key ] ) {
 
-				const source = material[ key ].source;
-				return uniqueTextures.findIndex( tex => tex.source === source );
+				const hash = getTextureHash( material[ key ] );
+				return uniqueTextureLookup[ hash ];
 
 			} else {
 
@@ -1374,6 +1721,12 @@ class MaterialsTexture extends DataTexture {
 
 		// get the list of textures with unique sources
 		const uniqueTextures = reduceTexturesToUniqueSources( textures );
+		const uniqueTextureLookup = {};
+		for ( let i = 0, l = uniqueTextures.length; i < l; i ++ ) {
+
+			uniqueTextureLookup[ getTextureHash( uniqueTextures[ i ] ) ] = i;
+
+		}
 
 		if ( image.width !== dimension ) {
 
@@ -1405,9 +1758,9 @@ class MaterialsTexture extends DataTexture {
 			// sample 1
 			// metalness & roughness
 			floatArray[ index ++ ] = getField( m, 'metalness', 0.0 );
-			floatArray[ index ++ ] = uniqueTextures.indexOf( m.metalnessMap );
+			floatArray[ index ++ ] = getTexture( m, 'metalnessMap' );
 			floatArray[ index ++ ] = getField( m, 'roughness', 0.0 );
-			floatArray[ index ++ ] = uniqueTextures.indexOf( m.roughnessMap );
+			floatArray[ index ++ ] = getTexture( m, 'roughnessMap' );
 
 			// sample 2
 			// transmission & emissiveIntensity
@@ -1585,7 +1938,7 @@ class MaterialsTexture extends DataTexture {
 			// sample 14
 			index ++; // matte
 			index ++; // shadow
-			floatArray[ index ++ ] = Number( m.vertexColors ); // vertexColors
+			floatArray[ index ++ ] = Number( m.vertexColors ) | ( Number( m.flatShading ) << 1 ); // vertexColors & flatShading
 			floatArray[ index ++ ] = Number( m.transparent ); // transparent
 
 			// map transform 15
@@ -1661,7 +2014,7 @@ class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 		};
 
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		const fsQuad = new FullScreenQuad$1( new MeshBasicMaterial() );
 		this.fsQuad = fsQuad;
 
 	}
@@ -2024,6 +2377,8 @@ const LIGHT_PIXELS = 6;
 const RECT_AREA_LIGHT = 0;
 const CIRC_AREA_LIGHT = 1;
 const SPOT_LIGHT = 2;
+const DIR_LIGHT = 3;
+const POINT_LIGHT = 4;
 class LightsInfoUniformStruct {
 
 	constructor() {
@@ -2082,8 +2437,24 @@ class LightsInfoUniformStruct {
 
 			// type
 			let type = RECT_AREA_LIGHT;
-			if ( l.isRectAreaLight && l.isCircular ) type = CIRC_AREA_LIGHT;
-			else if ( l.isSpotLight ) type = SPOT_LIGHT;
+			if ( l.isRectAreaLight && l.isCircular ) {
+
+				type = CIRC_AREA_LIGHT;
+
+			} else if ( l.isSpotLight ) {
+
+				type = SPOT_LIGHT;
+
+			} else if ( l.isDirectionalLight ) {
+
+				type = DIR_LIGHT;
+
+			} else if ( l.isPointLight ) {
+
+				type = POINT_LIGHT;
+
+			}
+
 			floatArray[ baseIndex + ( index ++ ) ] = type;
 
 			// sample 2
@@ -2170,6 +2541,33 @@ class LightsInfoUniformStruct {
 				// iesProfile
 				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
 
+			} else if ( l.isPointLight ) {
+
+				const worldPosition = l.getWorldPosition( u );
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.x;
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.y;
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.z;
+				index ++;
+
+				// sample 4
+				index += 4;
+
+				// sample 5
+				index += 2;
+
+				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
+				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
+
+			} else if ( l.isDirectionalLight ) {
+
+				const worldPosition = l.getWorldPosition( u );
+				const targetPosition = l.target.getWorldPosition( v );
+
+				target.subVectors( worldPosition, targetPosition ).normalize();
+				floatArray[ baseIndex + ( index ++ ) ] = target.x;
+				floatArray[ baseIndex + ( index ++ ) ] = target.y;
+				floatArray[ baseIndex + ( index ++ ) ] = target.z;
+
 			}
 
 		}
@@ -2519,7 +2917,7 @@ class IESProfilesTexture extends WebGLArrayRenderTarget {
 
 		};
 
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		const fsQuad = new FullScreenQuad$1( new MeshBasicMaterial() );
 		this.fsQuad = fsQuad;
 
 		this.iesLoader = new IESLoader();
@@ -2718,74 +3116,7 @@ const shaderUtils = /* glsl */`
 
 	}
 
-	// https://www.shadertoy.com/view/wltcRS
-	uvec4 s0;
-
-	void rng_initialize(vec2 p, int frame) {
-
-		// white noise seed
-		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
-
-	}
-
-	// https://www.pcg-random.org/
-	void pcg4d( inout uvec4 v ) {
-
-		v = v * 1664525u + 1013904223u;
-		v.x += v.y * v.w;
-		v.y += v.z * v.x;
-		v.z += v.x * v.y;
-		v.w += v.y * v.z;
-		v = v ^ ( v >> 16u );
-		v.x += v.y*v.w;
-		v.y += v.z*v.x;
-		v.z += v.x*v.y;
-		v.w += v.y*v.z;
-
-	}
-
-	// returns [ 0, 1 ]
-	float rand() {
-
-		pcg4d(s0);
-		return float( s0.x ) / float( 0xffffffffu );
-
-	}
-
-	vec2 rand2() {
-
-		pcg4d( s0 );
-		return vec2( s0.xy ) / float(0xffffffffu);
-
-	}
-
-	vec3 rand3() {
-
-		pcg4d(s0);
-		return vec3( s0.xyz ) / float( 0xffffffffu );
-
-	}
-
-	vec4 rand4() {
-
-		pcg4d(s0);
-		return vec4(s0)/float(0xffffffffu);
-
-	}
-
-	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
-	vec3 randDirection() {
-
-		vec2 r = rand2();
-		float u = ( r.x - 0.5 ) * 2.0;
-		float t = r.y * PI * 2.0;
-		float f = sqrt( 1.0 - u * u );
-
-		return vec3( f * cos( t ), f * sin( t ), u );
-
-	}
-
-	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
+	vec2 sampleTriangle( vec2 a, vec2 b, vec2 c, vec2 r ) {
 
 		// get the edges of the triangle and the diagonal across the
 		// center of the parallelogram
@@ -2793,8 +3124,7 @@ const shaderUtils = /* glsl */`
 		vec2 e2 = c - b;
 		vec2 diag = normalize( e1 + e2 );
 
-		// pick a random point in the parallelogram
-		vec2 r = rand2();
+		// pick the point in the parallelogram
 		if ( r.x + r.y > 1.0 ) {
 
 			r = vec2( 1.0 ) - r;
@@ -2805,40 +3135,48 @@ const shaderUtils = /* glsl */`
 
 	}
 
-	// samples an aperture shape with the given number of sides. 0 means circle
-	vec2 sampleAperture( int blades ) {
+	vec2 sampleCircle( vec2 uv ) {
 
-		if ( blades == 0 ) {
+		float angle = 2.0 * PI * uv.x;
+		float radius = sqrt( uv.y );
+		return vec2( cos( angle ), sin( angle ) ) * radius;
 
-			vec2 r = rand2();
-			float angle = 2.0 * PI * r.x;
-			float radius = sqrt( rand() );
-			return vec2( cos( angle ), sin( angle ) ) * radius;
+	}
 
-		} else {
+	vec3 sampleSphere( vec2 uv ) {
 
-			blades = max( blades, 3 );
+		float u = ( uv.x - 0.5 ) * 2.0;
+		float t = uv.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
 
-			vec3 r = rand3();
-			float anglePerSegment = 2.0 * PI / float( blades );
-			float segment = floor( float( blades ) * r.x );
+		return vec3( f * cos( t ), f * sin( t ), u );
 
-			float angle1 = anglePerSegment * segment;
-			float angle2 = angle1 + anglePerSegment;
-			vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
-			vec2 b = vec2( 0.0, 0.0 );
-			vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+	}
 
-			return triangleSample( a, b, c );
+	vec2 sampleRegularNGon( int sides, vec3 uvw ) {
 
-		}
+		sides = max( sides, 3 );
+
+		vec3 r = uvw;
+		float anglePerSegment = 2.0 * PI / float( sides );
+		float segment = floor( float( sides ) * r.x );
+
+		float angle1 = anglePerSegment * segment;
+		float angle2 = angle1 + anglePerSegment;
+		vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
+		vec2 b = vec2( 0.0, 0.0 );
+		vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+
+		return sampleTriangle( a, b, c, r.yz );
 
 	}
 
-	float colorToLuminance( vec3 color ) {
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades, vec3 uvw ) {
 
-		// https://en.wikipedia.org/wiki/Relative_luminance
-		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+		return blades == 0 ?
+			sampleCircle( uvw.xy ) :
+			sampleRegularNGon( blades, uvw );
 
 	}
 
@@ -2919,6 +3257,17 @@ const shaderUtils = /* glsl */`
 
 	}
 
+	vec2 rotateVector( vec2 v, float t ) {
+
+		float ac = cos( t );
+		float as = sin( t );
+		return vec2(
+			v.x * ac - v.y * as,
+			v.x * as + v.y * ac
+		);
+
+	}
+
 	// 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/
@@ -2987,6 +3336,13 @@ const shaderUtils = /* glsl */`
 
 	}
 
+	// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
+	// erichlof/THREE.js-PathTracing-Renderer/
+	float tentFilter( float x ) {
+
+		return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
+
+	}
 `;
 
 class PMREMCopyMaterial extends MaterialBase {
@@ -3043,7 +3399,7 @@ class BlurredEnvMapGenerator {
 
 		this.renderer = renderer;
 		this.pmremGenerator = new PMREMGenerator( renderer );
-		this.copyQuad = new FullScreenQuad( new PMREMCopyMaterial() );
+		this.copyQuad = new FullScreenQuad$1( new PMREMCopyMaterial() );
 		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: FloatType, format: RGBAFormat } );
 
 	}
@@ -3566,6 +3922,7 @@ const shaderMaterialStructs = /* glsl */ `
 		int sheenRoughnessMap;
 
 		bool vertexColors;
+		bool flatShading;
 		bool transparent;
 
 		mat3 mapTransform;
@@ -3678,7 +4035,8 @@ const shaderMaterialStructs = /* glsl */ `
 
 		m.matte = bool( s14.r );
 		m.castShadow = ! bool( s14.g );
-		m.vertexColors = bool( s14.b );
+		m.vertexColors = bool( int( s14.b ) & 1 );
+		m.flatShading = bool( int( s14.b ) & 2 );
 		m.transparent = bool( s14.a );
 
 		uint firstTextureTransformIdx = i + 15u;
@@ -3710,6 +4068,8 @@ const shaderLightStruct = /* glsl */ `
 	#define RECT_AREA_LIGHT_TYPE 0
 	#define CIRC_AREA_LIGHT_TYPE 1
 	#define SPOT_LIGHT_TYPE 2
+	#define DIR_LIGHT_TYPE 3
+	#define POINT_LIGHT_TYPE 4
 
 	struct LightsInfo {
 
@@ -3761,7 +4121,7 @@ const shaderLightStruct = /* glsl */ `
 		l.v = s3.rgb;
 		l.area = s3.a;
 
-		if ( l.type == SPOT_LIGHT_TYPE ) {
+		if ( l.type == SPOT_LIGHT_TYPE || l.type == POINT_LIGHT_TYPE ) {
 
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );
@@ -3814,14 +4174,14 @@ const shaderGGXFunctions = /* glsl */`
 
 // trowbridge-reitz === GGX === GTR
 
-vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float random1, float random2 ) {
+vec3 ggxDirection( vec3 incidentDir, vec2 roughness, vec2 uv ) {
 
 	// TODO: try GGXVNDF implementation from reference [2], here. Needs to update ggxDistribution
 	// function below, as well
 
 	// Implementation from reference [1]
 	// stretch view
-	vec3 V = normalize( vec3( roughnessX * incidentDir.x, roughnessY * incidentDir.y, incidentDir.z ) );
+	vec3 V = normalize( vec3( roughness * incidentDir.xy, incidentDir.z ) );
 
 	// orthonormal basis
 	vec3 T1 = ( V.z < 0.9999 ) ? normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) ) : vec3( 1.0, 0.0, 0.0 );
@@ -3829,16 +4189,16 @@ vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float r
 
 	// sample point with polar coordinates (r, phi)
 	float a = 1.0 / ( 1.0 + V.z );
-	float r = sqrt( random1 );
-	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
+	float r = sqrt( uv.x );
+	float phi = ( uv.y < a ) ? uv.y / a * PI : PI + ( uv.y - a ) / ( 1.0 - a ) * PI;
 	float P1 = r * cos( phi );
-	float P2 = r * sin( phi ) * ( ( random2 < a ) ? 1.0 : V.z );
+	float P2 = r * sin( phi ) * ( ( uv.y < a ) ? 1.0 : V.z );
 
 	// compute normal
 	vec3 N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );
 
 	// unstretch
-	N = normalize( vec3( roughnessX * N.x, roughnessY * N.y, max( 0.0, N.z ) ) );
+	N = normalize( vec3( roughness * N.xy, max( 0.0, N.z ) ) );
 
 	return N;
 
@@ -4226,7 +4586,7 @@ float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 color )
 
 vec3 diffuseDirection( vec3 wo, SurfaceRec surf ) {
 
-	vec3 lightDirection = randDirection();
+	vec3 lightDirection = sampleSphere( sobol2( 11 ) );
 	lightDirection.z += 1.0;
 	lightDirection = normalize( lightDirection );
 
@@ -4280,10 +4640,8 @@ vec3 specularDirection( vec3 wo, SurfaceRec surf ) {
 	float filteredRoughness = surf.filteredRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredRoughness,
-		filteredRoughness,
-		rand(),
-		rand()
+		vec2( filteredRoughness ),
+		sobol2( 12 )
 	);
 
 	// apply to new ray by reflecting off the new normal
@@ -4320,10 +4678,8 @@ vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 	// sample ggx vndf distribution which gives a new normal
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredRoughness,
-		filteredRoughness,
-		rand(),
-		rand()
+		vec2( filteredRoughness ),
+		sobol2( 13 )
 	);
 
 
@@ -4363,7 +4719,7 @@ vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 
 	float roughness = surf.roughness;
 	float eta = surf.eta;
-	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + randDirection() * roughness );
+	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
 	vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 	if ( surf.thinFilm ) {
@@ -4411,10 +4767,8 @@ vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
 	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredClearcoatRoughness,
-		filteredClearcoatRoughness,
-		rand(),
-		rand()
+		vec2( filteredClearcoatRoughness ),
+		sobol2( 14 )
 	);
 
 	// apply to new ray by reflecting off the new normal
@@ -4603,7 +4957,7 @@ SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis
 	vec3 wi;
 	vec3 clearcoatWi;
 
-	float r = rand();
+	float r = sobol( 15 );
 	if ( r <= cdf[0] ) { // diffuse
 
 		wi = diffuseDirection( wo, surf );
@@ -4659,13 +5013,13 @@ float envMapDirectionPdf( vec3 direction ) {
 
 }
 
-float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
+float sampleEnvMap( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
 
 	vec2 uv = equirectDirectionToUv( direction );
 	color = texture2D( info.map, uv ).rgb;
 
 	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = colorToLuminance( color );
+	float lum = luminance( color );
 	ivec2 resolution = textureSize( info.map, 0 );
 	float pdf = lum / totalSum;
 
@@ -4673,10 +5027,9 @@ float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
 
 }
 
-float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 direction ) {
+float sampleEnvMapProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
 
 	// sample env map cdf
-	vec2 r = rand2();
 	float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
 	float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
 	vec2 uv = vec2( u, v );
@@ -4686,7 +5039,7 @@ float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 directi
 	color = texture2D( info.map, uv ).rgb;
 
 	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = colorToLuminance( color );
+	float lum = luminance( color );
 	ivec2 resolution = textureSize( info.map, 0 );
 	float pdf = lum / totalSum;
 
@@ -4765,6 +5118,7 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 		float dist;
 
+		// MIS / light intersection is not supported for punctual lights.
 		if(
 			( light.type == RECT_AREA_LIGHT_TYPE && intersectsRectangle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) ) ||
 			( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
@@ -4783,38 +5137,6 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 			}
 
-		} else if ( light.type == SPOT_LIGHT_TYPE ) {
-
-			// TODO: forward path tracing sampling needs to be made consistent with direct light sampling logic
-			// float radius = light.radius;
-			// vec3 lightNormal = normalize( cross( light.u, light.v ) );
-			// float angle = acos( light.coneCos );
-			// float angleTan = tan( angle );
-			// float startDistance = radius / max( angleTan, EPSILON );
-
-			// u = light.u / radius;
-			// v = light.v / radius;
-
-			// if (
-			// 	intersectsCircle( light.position - normal * startDistance, normal, u, v, rayOrigin, rayDirection, dist ) &&
-			// 	( dist < lightSampleRec.dist || ! lightSampleRec.hit )
-			// ) {
-
-			// 	float cosTheta = dot( rayDirection, normal );
-			// 	float spotAttenuation = light.iesProfile != - 1 ?
-			// 		getPhotometricAttenuation( iesProfiles, light.iesProfile, rayDirection, normal, u, v )
-			// 		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
-
-			// 	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
-
-			// 	lightSampleRec.hit = true;
-			// 	lightSampleRec.dist = dist;
-			// 	lightSampleRec.direction = rayDirection;
-			// 	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
-			// 	lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-
-			// }
-
 		}
 
 	}
@@ -4823,7 +5145,7 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 }
 
-LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
+LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
 
 	LightSampleRec lightSampleRec;
 	lightSampleRec.hit = true;
@@ -4835,13 +5157,13 @@ LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
 	if( light.type == RECT_AREA_LIGHT_TYPE ) {
 
 		// rectangular area light
-		randomPos = light.position + light.u * ( rand() - 0.5 ) + light.v * ( rand() - 0.5 );
+		randomPos = light.position + light.u * ( ruv.x - 0.5 ) + light.v * ( ruv.y - 0.5 );
 
-	} else if( light.type == 1 ) {
+	} else if( light.type == CIRC_AREA_LIGHT_TYPE ) {
 
 		// circular area light
-		float r = 0.5 * sqrt( rand() );
-		float theta = rand() * 2.0 * PI;
+		float r = 0.5 * sqrt( ruv.x );
+		float theta = ruv.y * 2.0 * PI;
 		float x = r * cos( theta );
 		float y = r * sin( theta );
 
@@ -4863,10 +5185,10 @@ LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
 
 }
 
-LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin ) {
+LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin, vec2 ruv ) {
 
-	float radius = light.radius * sqrt( rand() );
-	float theta = rand() * 2.0 * PI;
+	float radius = light.radius * sqrt( ruv.x );
+	float theta = ruv.y * 2.0 * PI;
 	float x = radius * cos( theta );
 	float y = radius * sin( theta );
 
@@ -4887,8 +5209,8 @@ LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, v
 	float cosTheta = dot( direction, normal );
 
 	float spotAttenuation = light.iesProfile != - 1 ?
-		  getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v )
-		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
+		getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v ) :
+		getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
 
 	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
 	LightSampleRec lightSampleRec;
@@ -4897,30 +5219,59 @@ LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, v
 	lightSampleRec.dist = dist;
 	lightSampleRec.direction = direction;
 	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
-
-	// TODO: this makes the result consistent between MIS and non MIS paths but at radius 0 the pdf is infinite
-	// and the intensity of the light is not correct
 	lightSampleRec.pdf = 1.0;
-	// lightSampleRec.pdf = lightDistSq / ( light.area * cosTheta );
 
 	return lightSampleRec;
 
 }
 
-LightSampleRec randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin ) {
+LightSampleRec randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
 
 	// pick a random light
-	uint l = uint( rand() * float( lightCount ) );
+	uint l = uint( ruv.x * float( lightCount ) );
 	Light light = readLightInfo( lights, l );
 
 	if ( light.type == SPOT_LIGHT_TYPE ) {
 
-		return randomSpotLightSample( light, iesProfiles, rayOrigin );
+		return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+
+	} else if ( light.type == POINT_LIGHT_TYPE ) {
+
+		vec3 lightRay = light.u - rayOrigin;
+		float lightDist = length( lightRay );
+		float cutoffDistance = light.distance;
+		float distanceFalloff = 1.0 / max( pow( lightDist, light.decay ), 0.01 );
+		if ( cutoffDistance > 0.0 ) {
+
+			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDist / cutoffDistance ) ) );
+
+		}
+
+		LightSampleRec rec;
+		rec.hit = true;
+		rec.direction = normalize( lightRay );
+		rec.dist = length( lightRay );
+		rec.pdf = 1.0;
+		rec.emission = light.color * light.intensity * distanceFalloff;
+		rec.type = light.type;
+		return rec;
+
+	} else if ( light.type == DIR_LIGHT_TYPE ) {
+
+		LightSampleRec rec;
+		rec.hit = true;
+		rec.dist = 1e10;
+		rec.direction = light.u;
+		rec.pdf = 1.0;
+		rec.emission = light.color * light.intensity;
+		rec.type = light.type;
+
+		return rec;
 
 	} else {
 
 		// sample the light
-		return randomAreaLightSample( light, rayOrigin );
+		return randomAreaLightSample( light, rayOrigin, ruv.yz );
 
 	}
 
@@ -4953,6 +5304,64 @@ const shaderLayerTexelFetchFunctions = /*glsl */`
 
 `;
 
+const shaderRandFunctions = /* glsl */`
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 WHITE_NOISE_SEED;
+
+	void rng_initialize( vec2 p, int frame ) {
+
+		// white noise seed
+		WHITE_NOISE_SEED = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
+
+	}
+
+	// https://www.pcg-random.org/
+	void pcg4d( inout uvec4 v ) {
+
+		v = v * 1664525u + 1013904223u;
+		v.x += v.y * v.w;
+		v.y += v.z * v.x;
+		v.z += v.x * v.y;
+		v.w += v.y * v.z;
+		v = v ^ ( v >> 16u );
+		v.x += v.y*v.w;
+		v.y += v.z*v.x;
+		v.z += v.x*v.y;
+		v.w += v.y*v.z;
+
+	}
+
+	// returns [ 0, 1 ]
+	float rand() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
+
+	}
+`;
+
 function copyArrayToArray( fromArray, fromStride, toArray, toStride, offset ) {
 
 	if ( fromStride > toStride ) {
@@ -5212,6 +5621,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				filterGlossyFactor: { value: 0.0 },
 
 				backgroundAlpha: { value: 1.0 },
+				sobolTexture: { value: null },
 			},
 
 			vertexShader: /* glsl */`
@@ -5238,6 +5648,9 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				vec4 envMapTexelToLinear( vec4 a ) { return a; }
 				#include <common>
 
+				${ shaderRandFunctions }
+				${ shaderSobolCommon }
+				${ shaderSobolSampling }
 				${ shaderStructs }
 				${ shaderIntersectFunction }
 				${ shaderMaterialStructs }
@@ -5298,9 +5711,9 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				}
 
-				vec3 sampleBackground( vec3 direction ) {
+				vec3 sampleBackground( vec3 direction, vec2 uv ) {
 
-					vec3 sampleDir = normalize( direction + getHemisphereSample( direction, rand2() ) * 0.5 * backgroundBlur );
+					vec3 sampleDir = normalize( direction + getHemisphereSample( direction, uv ) * 0.5 * backgroundBlur );
 
 					#if FEATURE_BACKGROUND_MAP
 
@@ -5326,6 +5739,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 					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.
 					for ( int i = 0; i < traversals; i ++ ) {
 
 						if ( bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
@@ -5452,14 +5867,6 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				}
 
-				// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
-				// erichlof/THREE.js-PathTracing-Renderer/
-				float tentFilter( float x ) {
-
-					return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
-
-				}
-
 				vec3 ndcToRayOrigin( vec2 coord ) {
 
 					vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
@@ -5471,13 +5878,13 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					vec2 ssd = vec2( 1.0 ) / resolution;
 
 					// Jitter the camera ray by finding a uv coordinate at a random sample
-					// around this pixel's UV coordinate
-					vec2 jitteredUv = vUv + vec2( tentFilter( rand() ) * ssd.x, tentFilter( rand() ) * ssd.y );
+					// around this pixel's UV coordinate for AA
+					vec2 ruv = sobol2( 0 );
+					vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
 
 					#if CAMERA_TYPE == 2
 
 						// Equirectangular projection
-
 						vec4 rayDirection4 = vec4( equirectUvToDirection( jitteredUv ), 0.0 );
 						vec4 rayOrigin4 = vec4( 0.0, 0.0, 0.0, 1.0 );
 
@@ -5491,20 +5898,17 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						// get [- 1, 1] normalized device coordinates
 						vec2 ndc = 2.0 * jitteredUv - vec2( 1.0 );
-
 						rayOrigin = ndcToRayOrigin( ndc );
 
 						#if CAMERA_TYPE == 1
 
 							// Orthographic projection
-
 							rayDirection = ( cameraWorldMatrix * vec4( 0.0, 0.0, - 1.0, 0.0 ) ).xyz;
 							rayDirection = normalize( rayDirection );
 
 						#else
 
 							// Perspective projection
-
 							rayDirection = normalize( mat3(cameraWorldMatrix) * ( invProjectionMatrix * vec4( ndc, 0.0, 1.0 ) ).xyz );
 
 						#endif
@@ -5518,17 +5922,17 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						vec3 focalPoint = rayOrigin + normalize( rayDirection ) * physicalCamera.focusDistance;
 
 						// get the aperture sample
-						vec2 apertureSample = sampleAperture( physicalCamera.apertureBlades ) * physicalCamera.bokehSize * 0.5 * 1e-3;
+						// if blades === 0 then we assume a circle
+						vec3 shapeUVW= sobol3( 1 );
+						int blades = physicalCamera.apertureBlades;
+						float anamorphicRatio = physicalCamera.anamorphicRatio;
+						vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularNGon( blades, shapeUVW );
+						apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
 
 						// rotate the aperture shape
-						float ac = cos( physicalCamera.apertureRotation );
-						float as = sin( physicalCamera.apertureRotation );
-						apertureSample = vec2(
-							apertureSample.x * ac - apertureSample.y * as,
-							apertureSample.x * as + apertureSample.y * ac
-						);
-						apertureSample.x *= saturate( physicalCamera.anamorphicRatio );
-						apertureSample.y *= saturate( 1.0 / physicalCamera.anamorphicRatio );
+						apertureSample =
+							rotateVector( apertureSample, physicalCamera.apertureRotation ) *
+							saturate( vec2( anamorphicRatio, 1.0 / anamorphicRatio ) );
 
 						// create the new ray
 						rayOrigin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
@@ -5544,6 +5948,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				void main() {
 
 					rng_initialize( gl_FragCoord.xy, seed );
+					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) | ( uint( gl_FragCoord.y ) );
+					sobolPathIndex = uint( seed );
 
 					vec3 rayDirection;
 					vec3 rayOrigin;
@@ -5577,6 +5983,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 					for ( i = 0; i < bounces; i ++ ) {
 
+						sobolBounceIndex ++;
+
 						bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
 
 						LightSampleRec lightHit = lightsClosestHit( lights.tex, lights.count, rayOrigin, rayDirection );
@@ -5591,9 +5999,8 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 								#if FEATURE_MIS
 
-								// NOTE: we skip MIS for spotlights since we haven't fixed the forward
-								// path tracing code path, yet
-								if ( lightHit.type == SPOT_LIGHT_TYPE ) {
+								// NOTE: we skip MIS for punctual lights since they are not supported in forward PT case
+								if ( lightHit.type == SPOT_LIGHT_TYPE || lightHit.type == DIR_LIGHT_TYPE || lightHit.type == POINT_LIGHT_TYPE ) {
 
 									gl_FragColor.rgb += lightHit.emission * throughputColor;
 
@@ -5620,7 +6027,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 							if ( i == 0 || transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * rayDirection ) * throughputColor;
+								gl_FragColor.rgb += sampleBackground( envRotation3x3 * rayDirection, sobol2( 2 ) ) * throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {
@@ -5629,7 +6036,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 								// get the PDF of the hit envmap point
 								vec3 envColor;
-								float envPdf = envMapSample( envRotation3x3 * rayDirection, envMapInfo, envColor );
+								float envPdf = sampleEnvMap( envMapInfo, envRotation3x3 * rayDirection, envColor );
 								envPdf /= float( lights.count + 1u );
 
 								// and weight the contribution
@@ -5714,7 +6121,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 							|| useAlphaTest && albedo.a < alphaTest
 
 							// opacity
-							|| material.transparent && ! useAlphaTest && albedo.a < rand()
+							|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
 						) {
 
 							vec3 point = rayOrigin + rayDirection * dist;
@@ -5775,6 +6182,15 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						}
 
 						// normal
+						if ( material.flatShading ) {
+
+							// if we're rendering a flat shaded object then use the face normals - the face normal
+							// is provided based on the side the ray hits the mesh so flip it to align with the
+							// interpolated vertex normals.
+							normal = faceNormal * side;
+
+						}
+
 						vec3 baseNormal = normal;
 						if ( material.normalMap != - 1 ) {
 
@@ -5957,7 +6373,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						vec3 clearcoatOutgoing = - normalize( clearcoatInvBasis * rayDirection );
 						sampleRec = bsdfSample( outgoing, clearcoatOutgoing, normalBasis, invBasis, clearcoatNormalBasis, clearcoatInvBasis, surfaceRec );
 
-						isShadowRay = sampleRec.specularPdf < rand();
+						isShadowRay = sampleRec.specularPdf < sobol( 4 );
 
 						// adjust the hit point by the surface normal by a factor of some offset and the
 						// maximum component-wise value of the current point to accommodate floating point
@@ -5974,10 +6390,10 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						#if FEATURE_MIS
 
 						// uniformly pick a light or environment map
-						if( rand() > 1.0 / float( lights.count + 1u ) ) {
+						if( sobol( 5 ) > 1.0 / float( lights.count + 1u ) ) {
 
 							// sample a light or environment
-							LightSampleRec lightSampleRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin );
+							LightSampleRec lightSampleRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
 
 							bool isSampleBelowSurface = dot( faceNormal, lightSampleRec.direction ) < 0.0;
 							if ( isSampleBelowSurface ) {
@@ -6001,7 +6417,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 									// weight the direct light contribution
 									float lightPdf = lightSampleRec.pdf / float( lights.count + 1u );
-									float misWeight = misHeuristic( lightPdf, lightMaterialPdf );
+									float misWeight = lightSampleRec.type == SPOT_LIGHT_TYPE || lightSampleRec.type == DIR_LIGHT_TYPE || lightSampleRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
 									gl_FragColor.rgb += lightSampleRec.emission * throughputColor * sampleColor * misWeight / lightPdf;
 
 								}
@@ -6012,7 +6428,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 							// find a sample in the environment map to include in the contribution
 							vec3 envColor, envDirection;
-							float envPdf = randomEnvMapSample( envMapInfo, envColor, envDirection );
+							float envPdf = sampleEnvMapProbability( envMapInfo, sobol2( 7 ), envColor, envDirection );
 							envDirection = invEnvRotation3x3 * envDirection;
 
 							// this env sampling is not set up for transmissive sampling and yields overly bright