three-gpu-pathtracer 0.0.3 → 0.0.6

package/build/index.umd.cjs

@@ -146,6 +146,7 @@
 
 				blendMaterial.opacity = 1 / ( this.samples + 1 );
 				material.blending = three.NoBlending;
+				material.opacity = 1;
 
 			} else {
 
@@ -170,6 +171,27 @@
 					material.cameraWorldMatrix.copy( camera.matrixWorld );
 					material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
 
+					// Perspective camera (default)
+					let cameraType = 0;
+
+					// An orthographic projection matrix will always have the bottom right element == 1
+					// And a perspective projection matrix will always have the bottom right element == 0
+					if ( camera.projectionMatrix.elements[ 15 ] > 0 ) {
+
+						// Orthographic
+						cameraType = 1;
+
+					}
+
+					if ( camera.isEquirectCamera ) {
+
+						// Equirectangular
+						cameraType = 2;
+
+					}
+
+					material.setDefine( 'CAMERA_TYPE', cameraType );
+
 					const ogRenderTarget = _renderer.getRenderTarget();
 					const ogAutoClear = _renderer.autoClear;
 
@@ -507,7 +529,7 @@
 
 			// apply the matrix world to the geometry
 			const originalGeometry = meshes[ i ].geometry;
-			let geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
+			const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
 			geometry.applyMatrix4( mesh.matrixWorld );
 
 			// ensure our geometry has common attributes
@@ -551,44 +573,60 @@
 
 		prepScene( scene ) {
 
+			scene = Array.isArray( scene ) ? scene : [ scene ];
+
 			const meshes = [];
-			scene.traverse( c => {
+			const lights = [];
+
+			for ( let i = 0, l = scene.length; i < l; i ++ ) {
 
-				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
+				scene[ i ].traverse( c => {
 
-					const generator = new threeMeshBvh.StaticGeometryGenerator( c );
-					generator.applyWorldTransforms = false;
-					const mesh = new three.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 );
+					if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
 
-				} else if ( c.isMesh ) {
+						const generator = new threeMeshBvh.StaticGeometryGenerator( c );
+						generator.applyWorldTransforms = false;
+						const mesh = new three.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 );
 
-					meshes.push( c );
+					} else if ( c.isMesh ) {
 
-				}
+						meshes.push( c );
 
-			} );
+					} else if ( c.isRectAreaLight || c.isSpotLight ) {
 
-			return mergeMeshes( meshes, {
-				attributes: [ 'position', 'normal', 'tangent', 'uv' ],
-			} );
+						lights.push( c );
+
+					}
+
+				} );
+
+			}
+
+			return {
+				...mergeMeshes( meshes, {
+					attributes: [ 'position', 'normal', 'tangent', 'uv' ],
+				} ),
+				lights,
+			};
 
 		}
 
 		generate( scene, options = {} ) {
 
-			const { materials, textures, geometry } = this.prepScene( scene );
+			const { materials, textures, geometry, lights } = this.prepScene( scene );
 			const bvhOptions = { strategy: threeMeshBvh.SAH, ...options, maxLeafTris: 1 };
 			return {
 				scene,
 				materials,
 				textures,
+				lights,
 				bvh: new threeMeshBvh.MeshBVH( geometry, bvhOptions ),
 			};
 
@@ -606,11 +644,12 @@
 
 		constructor( scene ) {
 
-			this.scene = scene;
+			this.objects = Array.isArray( scene ) ? scene : [ scene ];
 			this.bvh = null;
 			this.geometry = new three.BufferGeometry();
 			this.materials = null;
 			this.textures = null;
+			this.lights = [];
 			this.staticGeometryGenerator = new threeMeshBvh.StaticGeometryGenerator( scene );
 
 		}
@@ -622,7 +661,8 @@
 			this.geometry = new three.BufferGeometry();
 			this.materials = null;
 			this.textures = null;
-			this.staticGeometryGenerator = new threeMeshBvh.StaticGeometryGenerator( this.scene );
+			this.lights = [];
+			this.staticGeometryGenerator = new threeMeshBvh.StaticGeometryGenerator( this.objects );
 
 		}
 
@@ -630,20 +670,29 @@
 
 		generate() {
 
-			const { scene, staticGeometryGenerator, geometry } = this;
+			const { objects, staticGeometryGenerator, geometry } = this;
 			if ( this.bvh === null ) {
 
 				const attributes = [ 'position', 'normal', 'tangent', 'uv' ];
-				scene.traverse( c => {
 
-					if ( c.isMesh ) {
+				for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
-						const normalMapRequired = ! ! c.material.normalMap;
-						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+					objects[ i ].traverse( c => {
 
-					}
+						if ( c.isMesh ) {
 
-				} );
+							const normalMapRequired = ! ! c.material.normalMap;
+							setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+
+						} else if ( c.isRectAreaLight || c.isSpotLight ) {
+
+							this.lights.push( c );
+
+						}
+
+					} );
+
+				}
 
 				const textureSet = new Set();
 				const materials = staticGeometryGenerator.getMaterials();
@@ -674,10 +723,11 @@
 				this.textures = Array.from( textureSet );
 
 				return {
+					lights: this.lights,
 					bvh: this.bvh,
 					materials: this.materials,
 					textures: this.textures,
-					scene,
+					objects,
 				};
 
 			} else {
@@ -686,10 +736,11 @@
 				staticGeometryGenerator.generate( geometry );
 				bvh.refit();
 				return {
+					lights: this.lights,
 					bvh: this.bvh,
 					materials: this.materials,
 					textures: this.textures,
-					scene,
+					objects,
 				};
 
 			}
@@ -983,8 +1034,48 @@
 
 	}
 
-	const MATERIAL_PIXELS = 6;
-	const MATERIAL_STRIDE = 6 * 4;
+	class EquirectCamera extends three.Camera {
+
+		constructor() {
+
+			super();
+
+			this.isEquirectCamera = true;
+
+		}
+
+	}
+
+	class PhysicalSpotLight extends three.SpotLight {
+
+		constructor( ...args ) {
+
+			super( ...args );
+
+			this.iesTexture = null;
+			this.radius = 0;
+
+		}
+
+	}
+
+	class ShapedAreaLight extends three.RectAreaLight {
+
+		constructor( ...args ) {
+
+			super( ...args );
+			this.isCircular = false;
+
+		}
+
+	}
+
+	const MATERIAL_PIXELS = 44;
+	const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
+
+	const SIDE_OFFSET = 12 * 4 + 3; // s12.a
+	const MATTE_OFFSET = 13 * 4 + 0; // s13.r
+	const SHADOW_OFFSET = 13 * 4 + 1; // s13.g
 
 	class MaterialsTexture extends three.DataTexture {
 
@@ -997,24 +1088,42 @@
 			this.wrapS = three.ClampToEdgeWrapping;
 			this.wrapT = three.ClampToEdgeWrapping;
 			this.generateMipmaps = false;
+			this.threeCompatibilityTransforms = false;
+
+		}
+
+		setCastShadow( materialIndex, cast ) {
+
+			// invert the shadow value so we default to "true" when initializing a material
+			const array = this.image.data;
+			const index = materialIndex * MATERIAL_STRIDE + SHADOW_OFFSET;
+			array[ index ] = ! cast ? 1 : 0;
+
+		}
+
+		getCastShadow( materialIndex ) {
+
+			const array = this.image.data;
+			const index = materialIndex * MATERIAL_STRIDE + SHADOW_OFFSET;
+			return ! Boolean( array[ index ] );
 
 		}
 
 		setSide( materialIndex, side ) {
 
 			const array = this.image.data;
-			const index = materialIndex * MATERIAL_STRIDE + 5 * 4 + 2;
+			const index = materialIndex * MATERIAL_STRIDE + SIDE_OFFSET;
 			switch ( side ) {
 
-				case three.FrontSide:
-					array[ index ] = 1;
-					break;
-				case three.BackSide:
-					array[ index ] = - 1;
-					break;
-				case three.DoubleSide:
-					array[ index ] = 0;
-					break;
+			case three.FrontSide:
+				array[ index ] = 1;
+				break;
+			case three.BackSide:
+				array[ index ] = - 1;
+				break;
+			case three.DoubleSide:
+				array[ index ] = 0;
+				break;
 
 			}
 
@@ -1023,15 +1132,15 @@
 		getSide( materialIndex ) {
 
 			const array = this.image.data;
-			const index = materialIndex * MATERIAL_STRIDE + 5 * 4 + 2;
+			const index = materialIndex * MATERIAL_STRIDE + SIDE_OFFSET;
 			switch ( array[ index ] ) {
 
-				case 0:
-					return three.DoubleSide;
-				case 1:
-					return three.FrontSide;
-				case - 1:
-					return three.BackSide;
+			case 0:
+				return three.DoubleSide;
+			case 1:
+				return three.FrontSide;
+			case - 1:
+				return three.BackSide;
 
 			}
 
@@ -1042,7 +1151,7 @@
 		setMatte( materialIndex, matte ) {
 
 			const array = this.image.data;
-			const index = materialIndex * MATERIAL_STRIDE + 5 * 4 + 3;
+			const index = materialIndex * MATERIAL_STRIDE + MATTE_OFFSET;
 			array[ index ] = matte ? 1 : 0;
 
 		}
@@ -1050,7 +1159,7 @@
 		getMatte( materialIndex ) {
 
 			const array = this.image.data;
-			const index = materialIndex * MATERIAL_STRIDE + 5 * 4 + 3;
+			const index = materialIndex * MATERIAL_STRIDE + MATTE_OFFSET;
 			return Boolean( array[ index ] );
 
 		}
@@ -1069,45 +1178,120 @@
 
 			}
 
+			function getUVTransformTexture( material ) {
+
+				// https://github.com/mrdoob/three.js/blob/f3a832e637c98a404c64dae8174625958455e038/src/renderers/webgl/WebGLMaterials.js#L204-L306
+				// https://threejs.org/docs/#api/en/textures/Texture.offset
+				// fallback order of textures to use as a common uv transform
+				return material.map ||
+					material.specularMap ||
+					material.displacementMap ||
+					material.normalMap ||
+					material.bumpMap ||
+					material.roughnessMap ||
+					material.metalnessMap ||
+					material.alphaMap ||
+					material.emissiveMap ||
+					material.clearcoatMap ||
+					material.clearcoatNormalMap ||
+					material.clearcoatRoughnessMap ||
+					material.iridescenceMap ||
+					material.iridescenceThicknessMap ||
+					material.specularIntensityMap ||
+					material.specularColorMap ||
+					material.transmissionMap ||
+					material.thicknessMap ||
+					material.sheenColorMap ||
+					material.sheenRoughnessMap ||
+					null;
+
+			}
+
+			function writeTextureMatrixToArray( material, textureKey, array, offset ) {
+
+				let texture;
+				if ( threeCompatibilityTransforms ) {
+
+					texture = getUVTransformTexture( material );
+
+				} else {
+
+					texture = material[ textureKey ] && material[ textureKey ].isTexture ? material[ textureKey ] : null;
+
+				}
+
+				// check if texture exists
+				if ( texture ) {
+
+					const elements = texture.matrix.elements;
+
+					let i = 0;
+
+					// first row
+					array[ offset + i ++ ] = elements[ 0 ];
+					array[ offset + i ++ ] = elements[ 3 ];
+					array[ offset + i ++ ] = elements[ 6 ];
+					i ++;
+
+					// second row
+					array[ offset + i ++ ] = elements[ 1 ];
+					array[ offset + i ++ ] = elements[ 4 ];
+					array[ offset + i ++ ] = elements[ 7 ];
+					i ++;
+
+				}
+
+				return 8;
+
+			}
+
 			let index = 0;
 			const pixelCount = materials.length * MATERIAL_PIXELS;
 			const dimension = Math.ceil( Math.sqrt( pixelCount ) );
+			const { threeCompatibilityTransforms, image } = this;
 
-			if ( this.image.width !== dimension ) {
+			if ( image.width !== dimension ) {
 
 				this.dispose();
 
-				this.image.data = new Float32Array( dimension * dimension * 4 );
-				this.image.width = dimension;
-				this.image.height = dimension;
+				image.data = new Float32Array( dimension * dimension * 4 );
+				image.width = dimension;
+				image.height = dimension;
 
 			}
 
-			const floatArray = this.image.data;
-			const intArray = new Int32Array( floatArray.buffer );
+			const floatArray = image.data;
+
+			// on some devices (Google Pixel 6) the "floatBitsToInt" function does not work correctly so we
+			// can't encode texture ids that way.
+			// const intArray = new Int32Array( floatArray.buffer );
 
 			for ( let i = 0, l = materials.length; i < l; i ++ ) {
 
 				const m = materials[ i ];
 
+				// sample 0
 				// color
 				floatArray[ index ++ ] = m.color.r;
 				floatArray[ index ++ ] = m.color.g;
 				floatArray[ index ++ ] = m.color.b;
-				intArray[ index ++ ] = getTexture( m, 'map' );
+				floatArray[ index ++ ] = getTexture( m, 'map' );
 
+				// sample 1
 				// metalness & roughness
 				floatArray[ index ++ ] = getField( m, 'metalness', 0.0 );
-				intArray[ index ++ ] = textures.indexOf( m.metalnessMap );
+				floatArray[ index ++ ] = textures.indexOf( m.metalnessMap );
 				floatArray[ index ++ ] = getField( m, 'roughness', 0.0 );
-				intArray[ index ++ ] = textures.indexOf( m.roughnessMap );
+				floatArray[ index ++ ] = textures.indexOf( m.roughnessMap );
 
+				// sample 2
 				// transmission & emissiveIntensity
 				floatArray[ index ++ ] = getField( m, 'ior', 1.0 );
 				floatArray[ index ++ ] = getField( m, 'transmission', 0.0 );
-				intArray[ index ++ ] = getTexture( m, 'transmissionMap' );
+				floatArray[ index ++ ] = getTexture( m, 'transmissionMap' );
 				floatArray[ index ++ ] = getField( m, 'emissiveIntensity', 0.0 );
 
+				// sample 3
 				// emission
 				if ( 'emissive' in m ) {
 
@@ -1123,10 +1307,11 @@
 
 				}
 
-				intArray[ index ++ ] = getTexture( m, 'emissiveMap' );
+				floatArray[ index ++ ] = getTexture( m, 'emissiveMap' );
 
+				// sample 4
 				// normals
-				intArray[ index ++ ] = getTexture( m, 'normalMap' );
+				floatArray[ index ++ ] = getTexture( m, 'normalMap' );
 				if ( 'normalScale' in m ) {
 
 					floatArray[ index ++ ] = m.normalScale.x;
@@ -1139,13 +1324,148 @@
 
 	 			}
 
+				// clearcoat
+				floatArray[ index ++ ] = getField( m, 'clearcoat', 0.0 );
+				floatArray[ index ++ ] = getTexture( m, 'clearcoatMap' ); // sample 5
+
+				floatArray[ index ++ ] = getField( m, 'clearcoatRoughness', 0.0 );
+				floatArray[ index ++ ] = getTexture( m, 'clearcoatRoughnessMap' );
+
+				floatArray[ index ++ ] = getTexture( m, 'clearcoatNormalMap' );
+
+				// sample 6
+				if ( 'clearcoatNormalScale' in m ) {
+
+					floatArray[ index ++ ] = m.clearcoatNormalScale.x;
+					floatArray[ index ++ ] = m.clearcoatNormalScale.y;
+
+				} else {
+
+					floatArray[ index ++ ] = 1;
+					floatArray[ index ++ ] = 1;
+
+				}
+
+				index ++;
+				index ++;
+
+				// sample 7
+				// sheen
+				if ( 'sheenColor' in m ) {
+
+					floatArray[ index ++ ] = m.sheenColor.r;
+					floatArray[ index ++ ] = m.sheenColor.g;
+					floatArray[ index ++ ] = m.sheenColor.b;
+
+				} else {
+
+					floatArray[ index ++ ] = 0.0;
+					floatArray[ index ++ ] = 0.0;
+					floatArray[ index ++ ] = 0.0;
+
+				}
+
+				floatArray[ index ++ ] = getTexture( m, 'sheenColorMap' );
+
+				// sample 8
+				floatArray[ index ++ ] = getField( m, 'sheenRoughness', 0.0 );
+				floatArray[ index ++ ] = getTexture( m, 'sheenRoughnessMap' );
+
+				// iridescence
+				floatArray[ index ++ ] = getTexture( m, 'iridescenceMap' );
+				floatArray[ index ++ ] = getTexture( m, 'iridescenceThicknessMap' );
+
+				floatArray[ index ++ ] = getField( m, 'iridescence', 0.0 ); // sample 9
+				floatArray[ index ++ ] = getField( m, 'iridescenceIOR', 1.3 );
+
+				const iridescenceThicknessRange = getField( m, 'iridescenceThicknessRange', [ 100, 400 ] );
+				floatArray[ index ++ ] = iridescenceThicknessRange[ 0 ];
+				floatArray[ index ++ ] = iridescenceThicknessRange[ 1 ];
+
+				// sample 10
+				// specular color
+				if ( 'specularColor' in m ) {
+
+					floatArray[ index ++ ] = m.specularColor.r;
+					floatArray[ index ++ ] = m.specularColor.g;
+					floatArray[ index ++ ] = m.specularColor.b;
+
+				} else {
+
+					floatArray[ index ++ ] = 0.0;
+					floatArray[ index ++ ] = 0.0;
+					floatArray[ index ++ ] = 0.0;
+
+				}
+
+				floatArray[ index ++ ] = getTexture( m, 'specularColorMap' );
+
+				// sample 11
+				// specular intensity
+				floatArray[ index ++ ] = getField( m, 'specularIntensity', 1.0 );
+				floatArray[ index ++ ] = getTexture( m, 'specularIntensityMap' );
 				index ++;
+				index ++;
+
+				// sample 12
+				// alphaMap
+				floatArray[ index ++ ] = getTexture( m, 'alphaMap' );
 
 				// side & matte
 				floatArray[ index ++ ] = m.opacity;
 				floatArray[ index ++ ] = m.alphaTest;
 				index ++; // side
+
+				// sample 13
 				index ++; // matte
+				index ++; // shadow
+				index ++;
+				index ++;
+
+				// map transform 14
+				index += writeTextureMatrixToArray( m, 'map', floatArray, index );
+
+				// metalnessMap transform 16
+				index += writeTextureMatrixToArray( m, 'metalnessMap', floatArray, index );
+
+				// roughnessMap transform 18
+				index += writeTextureMatrixToArray( m, 'roughnessMap', floatArray, index );
+
+				// transmissionMap transform 20
+				index += writeTextureMatrixToArray( m, 'transmissionMap', floatArray, index );
+
+				// emissiveMap transform 22
+				index += writeTextureMatrixToArray( m, 'emissiveMap', floatArray, index );
+
+				// normalMap transform 24
+				index += writeTextureMatrixToArray( m, 'normalMap', floatArray, index );
+
+				// clearcoatMap transform 26
+				index += writeTextureMatrixToArray( m, 'clearcoatMap', floatArray, index );
+
+				// clearcoatNormalMap transform 28
+				index += writeTextureMatrixToArray( m, 'clearcoatNormalMap', floatArray, index );
+
+				// clearcoatRoughnessMap transform 30
+				index += writeTextureMatrixToArray( m, 'clearcoatRoughnessMap', floatArray, index );
+
+				// sheenColorMap transform 32
+				index += writeTextureMatrixToArray( m, 'sheenColorMap', floatArray, index );
+
+				// sheenRoughnessMap transform 34
+				index += writeTextureMatrixToArray( m, 'sheenRoughnessMap', floatArray, index );
+
+				// iridescenceMap transform 36
+				index += writeTextureMatrixToArray( m, 'iridescenceMap', floatArray, index );
+
+				// iridescenceThicknessMap transform 38
+				index += writeTextureMatrixToArray( m, 'iridescenceThicknessMap', floatArray, index );
+
+				// specularColorMap transform 40
+				index += writeTextureMatrixToArray( m, 'specularColorMap', floatArray, index );
+
+				// specularIntensityMap transform 42
+				index += writeTextureMatrixToArray( m, 'specularIntensityMap', floatArray, index );
 
 			}
 
@@ -1155,73 +1475,86 @@
 
 	}
 
-	const prevColor = new three.Color();
-	class RenderTarget2DArray extends three.WebGLArrayRenderTarget {
-
-		constructor( ...args ) {
-
-			super( ...args );
-
-			const tex = this.texture;
-			tex.format = three.RGBAFormat;
-			tex.type = three.UnsignedByteType;
-			tex.minFilter = three.LinearFilter;
-			tex.magFilter = three.LinearFilter;
-			tex.wrapS = three.RepeatWrapping;
-			tex.wrapT = three.RepeatWrapping;
-			tex.setTextures = ( ...args ) => {
-
-				this.setTextures( ...args );
-
-			};
-
-			const fsQuad = new Pass_js.FullScreenQuad( new three.MeshBasicMaterial() );
-			this.fsQuad = fsQuad;
-
-		}
-
-		setTextures( renderer, width, height, textures ) {
-
-			// save previous renderer state
-			const prevRenderTarget = renderer.getRenderTarget();
-			const prevToneMapping = renderer.toneMapping;
-			const prevAlpha = renderer.getClearAlpha();
-			renderer.getClearColor( prevColor );
-
-			// resize the render target and ensure we don't have an empty texture
-			const depth = textures.length || 1;
-			this.setSize( width, height, depth );
-			renderer.setClearColor( 0, 0 );
-			renderer.toneMapping = three.NoToneMapping;
-
-			// render each texture into each layer of the target
-			const fsQuad = this.fsQuad;
-			for ( let i = 0, l = depth; i < l; i ++ ) {
-
-				const texture = textures[ i ];
-				fsQuad.material.map = texture;
-				fsQuad.material.transparent = true;
-
-				renderer.setRenderTarget( this, i );
-				fsQuad.render( renderer );
-
-			}
-
-			// reset the renderer
-			fsQuad.material.map = null;
-			renderer.setClearColor( prevColor, prevAlpha );
-			renderer.setRenderTarget( prevRenderTarget );
-			renderer.toneMapping = prevToneMapping;
-
-		}
-
-		dispose() {
-
-			super.dispose();
-			this.fsQuad.dispose();
-
-		}
-
+	const prevColor$1 = new three.Color();
+	class RenderTarget2DArray extends three.WebGLArrayRenderTarget {
+
+		constructor( ...args ) {
+
+			super( ...args );
+
+			const tex = this.texture;
+			tex.format = three.RGBAFormat;
+			tex.type = three.UnsignedByteType;
+			tex.minFilter = three.LinearFilter;
+			tex.magFilter = three.LinearFilter;
+			tex.wrapS = three.RepeatWrapping;
+			tex.wrapT = three.RepeatWrapping;
+			tex.setTextures = ( ...args ) => {
+
+				this.setTextures( ...args );
+
+			};
+
+			const fsQuad = new Pass_js.FullScreenQuad( new three.MeshBasicMaterial() );
+			this.fsQuad = fsQuad;
+
+		}
+
+		setTextures( renderer, width, height, textures ) {
+
+			// save previous renderer state
+			const prevRenderTarget = renderer.getRenderTarget();
+			const prevToneMapping = renderer.toneMapping;
+			const prevAlpha = renderer.getClearAlpha();
+			renderer.getClearColor( prevColor$1 );
+
+			// resize the render target and ensure we don't have an empty texture
+			// render target depth must be >= 1 to avoid unbound texture error on android devices
+			const depth = textures.length || 1;
+			this.setSize( width, height, depth );
+			renderer.setClearColor( 0, 0 );
+			renderer.toneMapping = three.NoToneMapping;
+
+			// render each texture into each layer of the target
+			const fsQuad = this.fsQuad;
+			for ( let i = 0, l = depth; i < l; i ++ ) {
+
+				const texture = textures[ i ];
+				if ( texture ) {
+
+					// revert to default texture transform before rendering
+					texture.matrixAutoUpdate = false;
+					texture.matrix.identity();
+
+					fsQuad.material.map = texture;
+					fsQuad.material.transparent = true;
+
+					renderer.setRenderTarget( this, i );
+					fsQuad.render( renderer );
+
+					// restore custom texture transform
+					texture.updateMatrix();
+					texture.matrixAutoUpdate = true;
+
+				}
+
+			}
+
+			// reset the renderer
+			fsQuad.material.map = null;
+			renderer.setClearColor( prevColor$1, prevAlpha );
+			renderer.setRenderTarget( prevRenderTarget );
+			renderer.toneMapping = prevToneMapping;
+
+		}
+
+		dispose() {
+
+			super.dispose();
+			this.fsQuad.dispose();
+
+		}
+
 	}
 
 	function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
@@ -1335,27 +1668,21 @@
 			conditionalWeights.magFilter = three.LinearFilter;
 			conditionalWeights.generateMipmaps = false;
 
-			// store the total sum in a 1x1 tex since some android mobile devices have issues
-			// storing large values in structs.
-			const totalSumTex = new three.DataTexture();
-			totalSumTex.type = three.FloatType;
-			totalSumTex.format = three.RedFormat;
-			totalSumTex.minFilter = three.LinearFilter;
-			totalSumTex.magFilter = three.LinearFilter;
-			totalSumTex.generateMipmaps = false;
-
 			this.marginalWeights = marginalWeights;
 			this.conditionalWeights = conditionalWeights;
-			this.totalSum = totalSumTex;
 			this.map = null;
 
+			// the total sum value is separated into two values to work around low precision
+			// storage of floating values in structs
+			this.totalSumWhole = 0;
+			this.totalSumDecimal = 0;
+
 		}
 
 		dispose() {
 
 			this.marginalWeights.dispose();
 			this.conditionalWeights.dispose();
-			this.totalSum.dispose();
 			if ( this.map ) this.map.dispose();
 
 		}
@@ -1470,15 +1797,17 @@
 
 			this.dispose();
 
-			const { marginalWeights, conditionalWeights, totalSum } = this;
+			const { marginalWeights, conditionalWeights } = this;
 			marginalWeights.image = { width: height, height: 1, data: marginalDataArray };
 			marginalWeights.needsUpdate = true;
 
 			conditionalWeights.image = { width, height, data: conditionalDataArray };
 			conditionalWeights.needsUpdate = true;
 
-			totalSum.image = { width: 1, height: 1, data: new Float32Array( [ totalSumValue ] ) };
-			totalSum.needsUpdate = true;
+			const totalSumWhole = ~ ~ totalSumValue;
+			const totalSumDecimal = ( totalSumValue - totalSumWhole );
+			this.totalSumWhole = totalSumWhole;
+			this.totalSumDecimal = totalSumDecimal;
 
 			this.map = map;
 
@@ -1522,63 +1851,634 @@
 
 	}
 
-	const shaderUtils = /* glsl */`
+	const LIGHT_PIXELS = 6;
+	const RECT_AREA_LIGHT = 0;
+	const CIRC_AREA_LIGHT = 1;
+	const SPOT_LIGHT = 2;
+	class LightsInfoUniformStruct {
 
-	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
-	float schlickFresnel( float cosine, float f0 ) {
+		constructor() {
 
-		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+			const tex = new three.DataTexture( new Float32Array( 4 ), 1, 1 );
+			tex.format = three.RGBAFormat;
+			tex.type = three.FloatType;
+			tex.wrapS = three.ClampToEdgeWrapping;
+			tex.wrapT = three.ClampToEdgeWrapping;
+			tex.generateMipmaps = false;
 
-	}
+			this.tex = tex;
+			this.count = 0;
 
-	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
-	float schlickFresnelFromIor( float cosine, float iorRatio ) {
+		}
 
-		// Schlick approximation
-		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
-		return schlickFresnel( cosine, r_0 );
+		updateFrom( lights, iesTextures = [] ) {
 
-	}
+			const tex = this.tex;
+			const pixelCount = Math.max( lights.length * LIGHT_PIXELS, 1 );
+			const dimension = Math.ceil( Math.sqrt( pixelCount ) );
 
-	// forms a basis with the normal vector as Z
-	mat3 getBasisFromNormal( vec3 normal ) {
+			if ( tex.image.width !== dimension ) {
 
-		vec3 other;
-		if ( abs( normal.x ) > 0.5 ) {
+				tex.dispose();
 
-			other = vec3( 0.0, 1.0, 0.0 );
+				tex.image.data = new Float32Array( dimension * dimension * 4 );
+				tex.image.width = dimension;
+				tex.image.height = dimension;
 
-		} else {
+			}
 
-			other = vec3( 1.0, 0.0, 0.0 );
+			const floatArray = tex.image.data;
 
-		}
+			const u = new three.Vector3();
+			const v = new three.Vector3();
+			const m = new three.Matrix4();
+			const worldQuaternion = new three.Quaternion();
+			const eye = new three.Vector3();
+			const target = new three.Vector3();
+			const up = new three.Vector3();
 
-		vec3 ortho = normalize( cross( normal, other ) );
-		vec3 ortho2 = normalize( cross( normal, ortho ) );
-		return mat3( ortho2, ortho, normal );
+			for ( let i = 0, l = lights.length; i < l; i ++ ) {
 
-	}
+				const l = lights[ i ];
 
-	vec3 getHalfVector( vec3 a, vec3 b ) {
+				const baseIndex = i * LIGHT_PIXELS * 4;
+				let index = 0;
 
-		return normalize( a + b );
+				// sample 1
+			    // position
+				l.getWorldPosition( v );
+				floatArray[ baseIndex + ( index ++ ) ] = v.x;
+				floatArray[ baseIndex + ( index ++ ) ] = v.y;
+				floatArray[ baseIndex + ( index ++ ) ] = v.z;
 
-	}
+				// type
+				let type = RECT_AREA_LIGHT;
+				if ( l.isRectAreaLight && l.isCircular ) type = CIRC_AREA_LIGHT;
+				else if ( l.isSpotLight ) type = SPOT_LIGHT;
+				floatArray[ baseIndex + ( index ++ ) ] = type;
 
-	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray
-	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If
-	// we find a ray like that we ignore it to avoid artifacts.
-	// This function returns if the direction is on the same side of both planes.
-	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {
+				// sample 2
+				// color
+				floatArray[ baseIndex + ( index ++ ) ] = l.color.r;
+				floatArray[ baseIndex + ( index ++ ) ] = l.color.g;
+				floatArray[ baseIndex + ( index ++ ) ] = l.color.b;
 
-		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;
-		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;
-		return aboveSurfaceNormal == aboveGeometryNormal;
+				// intensity
+				floatArray[ baseIndex + ( index ++ ) ] = l.intensity;
 
-	}
+				l.getWorldQuaternion( worldQuaternion );
 
-	vec3 getHemisphereSample( vec3 n, vec2 uv ) {
+				if ( l.isRectAreaLight ) {
+
+					// sample 3
+					// u vector
+					u.set( l.width, 0, 0 ).applyQuaternion( worldQuaternion );
+
+					floatArray[ baseIndex + ( index ++ ) ] = u.x;
+					floatArray[ baseIndex + ( index ++ ) ] = u.y;
+					floatArray[ baseIndex + ( index ++ ) ] = u.z;
+					index ++;
+
+					// sample 4
+					// v vector
+					v.set( 0, l.height, 0 ).applyQuaternion( worldQuaternion );
+
+					floatArray[ baseIndex + ( index ++ ) ] = v.x;
+					floatArray[ baseIndex + ( index ++ ) ] = v.y;
+					floatArray[ baseIndex + ( index ++ ) ] = v.z;
+
+					// area
+					floatArray[ baseIndex + ( index ++ ) ] = u.cross( v ).length() * ( l.isCircular ? ( Math.PI / 4.0 ) : 1.0 );
+
+				} else if ( l.isSpotLight ) {
+
+					const radius = l.radius;
+					eye.setFromMatrixPosition( l.matrixWorld );
+					target.setFromMatrixPosition( l.target.matrixWorld );
+					m.lookAt( eye, target, up );
+					worldQuaternion.setFromRotationMatrix( m );
+
+					// sample 3
+					// u vector
+					u.set( 1, 0, 0 ).applyQuaternion( worldQuaternion );
+
+					floatArray[ baseIndex + ( index ++ ) ] = u.x;
+					floatArray[ baseIndex + ( index ++ ) ] = u.y;
+					floatArray[ baseIndex + ( index ++ ) ] = u.z;
+					index ++;
+
+					// sample 4
+					// v vector
+					v.set( 0, 1, 0 ).applyQuaternion( worldQuaternion );
+
+					floatArray[ baseIndex + ( index ++ ) ] = v.x;
+					floatArray[ baseIndex + ( index ++ ) ] = v.y;
+					floatArray[ baseIndex + ( index ++ ) ] = v.z;
+
+					// area
+					floatArray[ baseIndex + ( index ++ ) ] = Math.PI * radius * radius;
+
+					// sample 5
+					// 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 );
+
+					// penumbraCos
+					floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
+
+					// iesProfile
+					floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
+
+				}
+
+			}
+
+			tex.needsUpdate = true;
+			this.count = lights.length;
+
+		}
+
+	}
+
+	function IESLamp( text ) {
+
+		const _self = this;
+
+		const textArray = text.split( '\n' );
+
+		let lineNumber = 0;
+		let line;
+
+		_self.verAngles = [ ];
+		_self.horAngles = [ ];
+
+		_self.candelaValues = [ ];
+
+		_self.tiltData = { };
+		_self.tiltData.angles = [ ];
+		_self.tiltData.mulFactors = [ ];
+
+		function textToArray( text ) {
+
+			text = text.replace( /^\s+|\s+$/g, '' ); // remove leading or trailing spaces
+			text = text.replace( /,/g, ' ' ); // replace commas with spaces
+			text = text.replace( /\s\s+/g, ' ' ); // replace white space/tabs etc by single whitespace
+
+			const array = text.split( ' ' );
+
+			return array;
+
+		}
+
+		function readArray( count, array ) {
+
+			while ( true ) {
+
+				const line = textArray[ lineNumber ++ ];
+				const lineData = textToArray( line );
+
+				for ( let i = 0; i < lineData.length; ++ i ) {
+
+					array.push( Number( lineData[ i ] ) );
+
+				}
+
+				if ( array.length === count )
+					break;
+
+			}
+
+		}
+
+		function readTilt() {
+
+			let line = textArray[ lineNumber ++ ];
+			let lineData = textToArray( line );
+
+			_self.tiltData.lampToLumGeometry = Number( lineData[ 0 ] );
+
+			line = textArray[ lineNumber ++ ];
+			lineData = textToArray( line );
+
+			_self.tiltData.numAngles = Number( lineData[ 0 ] );
+
+			readArray( _self.tiltData.numAngles, _self.tiltData.angles );
+			readArray( _self.tiltData.numAngles, _self.tiltData.mulFactors );
+
+		}
+
+		function readLampValues() {
+
+			const values = [ ];
+			readArray( 10, values );
+
+			_self.count = Number( values[ 0 ] );
+			_self.lumens = Number( values[ 1 ] );
+			_self.multiplier = Number( values[ 2 ] );
+			_self.numVerAngles = Number( values[ 3 ] );
+			_self.numHorAngles = Number( values[ 4 ] );
+			_self.gonioType = Number( values[ 5 ] );
+			_self.units = Number( values[ 6 ] );
+			_self.width = Number( values[ 7 ] );
+			_self.length = Number( values[ 8 ] );
+			_self.height = Number( values[ 9 ] );
+
+		}
+
+		function readLampFactors() {
+
+			const values = [ ];
+			readArray( 3, values );
+
+			_self.ballFactor = Number( values[ 0 ] );
+			_self.blpFactor = Number( values[ 1 ] );
+			_self.inputWatts = Number( values[ 2 ] );
+
+		}
+
+		while ( true ) {
+
+			line = textArray[ lineNumber ++ ];
+
+			if ( line.includes( 'TILT' ) ) {
+
+				break;
+
+			}
+
+		}
+
+		if ( ! line.includes( 'NONE' ) ) {
+
+			if ( line.includes( 'INCLUDE' ) ) {
+
+				readTilt();
+
+			} else {
+
+				// TODO:: Read tilt data from a file
+
+			}
+
+		}
+
+		readLampValues();
+
+		readLampFactors();
+
+		// Initialize candela value array
+		for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+			_self.candelaValues.push( [ ] );
+
+		}
+
+		// Parse Angles
+		readArray( _self.numVerAngles, _self.verAngles );
+		readArray( _self.numHorAngles, _self.horAngles );
+
+		// Parse Candela values
+		for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+			readArray( _self.numVerAngles, _self.candelaValues[ i ] );
+
+		}
+
+		// Calculate actual candela values, and normalize.
+		for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+			for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+				_self.candelaValues[ i ][ j ] *= _self.candelaValues[ i ][ j ] * _self.multiplier
+					* _self.ballFactor * _self.blpFactor;
+
+			}
+
+		}
+
+		let maxVal = - 1;
+		for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+			for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+				const value = _self.candelaValues[ i ][ j ];
+				maxVal = maxVal < value ? value : maxVal;
+
+			}
+
+		}
+
+		const bNormalize = true;
+		if ( bNormalize && maxVal > 0 ) {
+
+			for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+				for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+					_self.candelaValues[ i ][ j ] /= maxVal;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	class IESLoader extends three.Loader {
+
+		_getIESValues( iesLamp ) {
+
+			const width = 360;
+			const height = 180;
+			const size = width * height;
+
+			const data = new Float32Array( size );
+
+			function interpolateCandelaValues( phi, theta ) {
+
+				let phiIndex = 0, thetaIndex = 0;
+				let startTheta = 0, endTheta = 0, startPhi = 0, endPhi = 0;
+
+				for ( let i = 0; i < iesLamp.numHorAngles - 1; ++ i ) { // numHorAngles = horAngles.length-1 because of extra padding, so this wont cause an out of bounds error
+
+					if ( theta < iesLamp.horAngles[ i + 1 ] || i == iesLamp.numHorAngles - 2 ) {
+
+						thetaIndex = i;
+						startTheta = iesLamp.horAngles[ i ];
+						endTheta = iesLamp.horAngles[ i + 1 ];
+
+						break;
+
+					}
+
+				}
+
+				for ( let i = 0; i < iesLamp.numVerAngles - 1; ++ i ) {
+
+					if ( phi < iesLamp.verAngles[ i + 1 ] || i == iesLamp.numVerAngles - 2 ) {
+
+						phiIndex = i;
+						startPhi = iesLamp.verAngles[ i ];
+						endPhi = iesLamp.verAngles[ i + 1 ];
+
+						break;
+
+					}
+
+				}
+
+				const deltaTheta = endTheta - startTheta;
+				const deltaPhi = endPhi - startPhi;
+
+				if ( deltaPhi === 0 ) // Outside range
+					return 0;
+
+				const t1 = deltaTheta === 0 ? 0 : ( theta - startTheta ) / deltaTheta;
+				const t2 = ( phi - startPhi ) / deltaPhi;
+
+				const nextThetaIndex = deltaTheta === 0 ? thetaIndex : thetaIndex + 1;
+
+				const v1 = three.MathUtils.lerp( iesLamp.candelaValues[ thetaIndex ][ phiIndex ], iesLamp.candelaValues[ nextThetaIndex ][ phiIndex ], t1 );
+				const v2 = three.MathUtils.lerp( iesLamp.candelaValues[ thetaIndex ][ phiIndex + 1 ], iesLamp.candelaValues[ nextThetaIndex ][ phiIndex + 1 ], t1 );
+				const v = three.MathUtils.lerp( v1, v2, t2 );
+
+				return v;
+
+			}
+
+			const startTheta = iesLamp.horAngles[ 0 ], endTheta = iesLamp.horAngles[ iesLamp.numHorAngles - 1 ];
+			for ( let i = 0; i < size; ++ i ) {
+
+				let theta = i % width;
+				const phi = Math.floor( i / width );
+
+				if ( endTheta - startTheta !== 0 && ( theta < startTheta || theta >= endTheta ) ) { // Handle symmetry for hor angles
+
+					theta %= endTheta * 2;
+					if ( theta > endTheta )
+						theta = endTheta * 2 - theta;
+
+				}
+
+				data[ i ] = interpolateCandelaValues( phi, theta );
+
+			}
+
+			return data;
+
+		}
+
+		load( url, onLoad, onProgress, onError ) {
+
+			const loader = new three.FileLoader( this.manager );
+			loader.setResponseType( 'text' );
+			loader.setCrossOrigin( this.crossOrigin );
+			loader.setWithCredentials( this.withCredentials );
+			loader.setPath( this.path );
+			loader.setRequestHeader( this.requestHeader );
+
+			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.FloatType );
+			texture.minFilter = three.LinearFilter;
+			texture.magFilter = three.LinearFilter;
+
+			loader.load( url, text => {
+
+				const iesLamp = new IESLamp( text );
+
+				texture.image.data = this._getIESValues( iesLamp );
+				texture.needsUpdate = true;
+
+				if ( onLoad !== undefined ) {
+
+					onLoad( texture );
+
+				}
+
+			}, onProgress, onError );
+
+			return texture;
+
+		}
+
+		parse( text ) {
+
+			const iesLamp = new IESLamp( text );
+			const texture = new three.DataTexture( null, 360, 180, three.RedFormat, three.FloatType );
+			texture.minFilter = three.LinearFilter;
+			texture.magFilter = three.LinearFilter;
+			texture.image.data = this._getIESValues( iesLamp );
+			texture.needsUpdate = true;
+
+			return texture;
+
+		}
+
+	}
+
+	const prevColor = new three.Color();
+	class IESProfilesTexture extends three.WebGLArrayRenderTarget {
+
+		constructor( ...args ) {
+
+			super( ...args );
+
+			const tex = this.texture;
+			tex.format = three.RGBAFormat;
+			tex.type = three.FloatType;
+			tex.minFilter = three.LinearFilter;
+			tex.magFilter = three.LinearFilter;
+			tex.wrapS = three.ClampToEdgeWrapping;
+			tex.wrapT = three.ClampToEdgeWrapping;
+			tex.generateMipmaps = false;
+
+			tex.updateFrom = ( ...args ) => {
+
+				this.updateFrom( ...args );
+
+			};
+
+			const fsQuad = new Pass_js.FullScreenQuad( new three.MeshBasicMaterial() );
+			this.fsQuad = fsQuad;
+
+			this.iesLoader = new IESLoader();
+
+		}
+
+		async updateFrom( renderer, textures ) {
+
+			// save previous renderer state
+			const prevRenderTarget = renderer.getRenderTarget();
+			const prevToneMapping = renderer.toneMapping;
+			const prevAlpha = renderer.getClearAlpha();
+			renderer.getClearColor( prevColor );
+
+			// resize the render target and ensure we don't have an empty texture
+			// render target depth must be >= 1 to avoid unbound texture error on android devices
+			const depth = textures.length || 1;
+			this.setSize( 360, 180, depth );
+			renderer.setClearColor( 0, 0 );
+			renderer.toneMapping = three.NoToneMapping;
+
+			// render each texture into each layer of the target
+			const fsQuad = this.fsQuad;
+			for ( let i = 0, l = depth; i < l; i ++ ) {
+
+				const texture = textures[ i ];
+				if ( texture ) {
+
+					// revert to default texture transform before rendering
+					texture.matrixAutoUpdate = false;
+					texture.matrix.identity();
+
+					fsQuad.material.map = texture;
+					fsQuad.material.transparent = true;
+
+					renderer.setRenderTarget( this, i );
+					fsQuad.render( renderer );
+
+					// restore custom texture transform
+					texture.updateMatrix();
+					texture.matrixAutoUpdate = true;
+
+				}
+
+			}
+
+			// reset the renderer
+			fsQuad.material.map = null;
+			renderer.setClearColor( prevColor, prevAlpha );
+			renderer.setRenderTarget( prevRenderTarget );
+			renderer.toneMapping = prevToneMapping;
+
+			fsQuad.dispose();
+
+		}
+
+		dispose() {
+
+			super.dispose();
+			this.fsQuad.dispose();
+
+		}
+
+	}
+
+	const shaderUtils = /* glsl */`
+
+	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
+	float schlickFresnel( float cosine, float f0 ) {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+	vec3 schlickFresnel( float cosine, vec3 f0 ) {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
+	float schlickFresnelFromIor( float cosine, float iorRatio ) {
+
+		// Schlick approximation
+		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
+		return schlickFresnel( cosine, r_0 );
+
+	}
+
+	// forms a basis with the normal vector as Z
+	mat3 getBasisFromNormal( vec3 normal ) {
+
+		vec3 other;
+		if ( abs( normal.x ) > 0.5 ) {
+
+			other = vec3( 0.0, 1.0, 0.0 );
+
+		} else {
+
+			other = vec3( 1.0, 0.0, 0.0 );
+
+		}
+
+		vec3 ortho = normalize( cross( normal, other ) );
+		vec3 ortho2 = normalize( cross( normal, ortho ) );
+		return mat3( ortho2, ortho, normal );
+
+	}
+
+	vec3 getHalfVector( vec3 a, vec3 b ) {
+
+		return normalize( a + b );
+
+	}
+
+	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray
+	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If
+	// we find a ray like that we ignore it to avoid artifacts.
+	// This function returns if the direction is on the same side of both planes.
+	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {
+
+		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;
+		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;
+		return aboveSurfaceNormal == aboveGeometryNormal;
+
+	}
+
+	vec3 getHemisphereSample( vec3 n, vec2 uv ) {
 
 		// https://www.rorydriscoll.com/2009/01/07/better-sampling/
 		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf
@@ -1671,84 +2571,200 @@
 		vec2 e2 = c - b;
 		vec2 diag = normalize( e1 + e2 );
 
-		// pick a random point in the parallelogram
-		vec2 r = rand2();
-		if ( r.x + r.y > 1.0 ) {
+		// pick a random point in the parallelogram
+		vec2 r = rand2();
+		if ( r.x + r.y > 1.0 ) {
+
+			r = vec2( 1.0 ) - r;
+
+		}
+
+		return e1 * r.x + e2 * r.y;
+
+	}
+
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades ) {
+
+		if ( blades == 0 ) {
+
+			vec2 r = rand2();
+			float angle = 2.0 * PI * r.x;
+			float radius = sqrt( rand() );
+			return vec2( cos( angle ), sin( angle ) ) * radius;
+
+		} else {
+
+			blades = max( blades, 3 );
+
+			vec3 r = rand3();
+			float anglePerSegment = 2.0 * PI / float( blades );
+			float segment = floor( float( blades ) * 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 triangleSample( a, b, c );
+
+		}
+
+	}
+
+	float colorToLuminance( vec3 color ) {
+
+		// https://en.wikipedia.org/wiki/Relative_luminance
+		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+
+	}
+
+	// ray sampling x and z are swapped to align with expected background view
+	vec2 equirectDirectionToUv( vec3 direction ) {
+
+		// from Spherical.setFromCartesianCoords
+		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
+		uv /= vec2( 2.0 * PI, PI );
+
+		// apply adjustments to get values in range [0, 1] and y right side up
+		uv.x += 0.5;
+		uv.y = 1.0 - uv.y;
+		return uv;
+
+	}
+
+	vec3 equirectUvToDirection( vec2 uv ) {
+
+		// undo above adjustments
+		uv.x -= 0.5;
+		uv.y = 1.0 - uv.y;
+
+		// from Vector3.setFromSphericalCoords
+		float theta = uv.x * 2.0 * PI;
+		float phi = uv.y * PI;
+
+		float sinPhi = sin( phi );
+
+		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+
+	}
+
+	// Fast arccos approximation used to remove banding artifacts caused by numerical errors in acos.
+	// This is a cubic Lagrange interpolating polynomial for x = [-1, -1/2, 0, 1/2, 1].
+	// For more information see: https://github.com/gkjohnson/three-gpu-pathtracer/pull/171#issuecomment-1152275248
+	float acosApprox( float x ) {
+
+		x = clamp( x, -1.0, 1.0 );
+		return ( - 0.69813170079773212 * x * x - 0.87266462599716477 ) * x + 1.5707963267948966;
+
+	}
+
+	// An acos with input values bound to the range [-1, 1].
+	float acosSafe( float x ) {
+
+		return acos( clamp( x, -1.0, 1.0 ) );
+
+	}
+
+	float saturateCos( float val ) {
+
+		return clamp( val, 0.001, 1.0 );
+
+	}
+
+	float square( float t ) {
+
+		return t * t;
+
+	}
+
+	vec2 square( vec2 t) {
+
+		return t * t;
+
+	}
+
+	vec3 square( vec3 t ) {
 
-			r = vec2( 1.0 ) - r;
+		return t * t;
 
-		}
+	}
 
-		return e1 * r.x + e2 * r.y;
+	vec4 square( vec4 t ) {
+
+		return t * t;
 
 	}
 
-	// samples an aperture shape with the given number of sides. 0 means circle
-	vec2 sampleAperture( int blades ) {
+	// 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 ) {
 
-		if ( blades == 0 ) {
+		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
 
-			vec2 r = rand2();
-			float angle = 2.0 * PI * r.x;
-			float radius = sqrt( rand() );
-			return vec2( cos( angle ), sin( angle ) ) * radius;
+		if ( t > EPSILON ) {
 
-		} else {
+			vec3 p = rayOrigin + rayDirection * t;
+			vec3 vi = p - center;
 
-			blades = max( blades, 3 );
+			// check if p falls inside the rectangle
+			float a1 = dot( u, vi );
+			if ( abs( a1 ) <= 0.5 ) {
 
-			vec3 r = rand3();
-			float anglePerSegment = 2.0 * PI / float( blades );
-			float segment = floor( float( blades ) * r.x );
+				float a2 = dot( v, vi );
+				if ( abs( a2 ) <= 0.5 ) {
 
-			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 ) );
+					dist = t;
+					return true;
 
-			return triangleSample( a, b, c );
+				}
+
+			}
 
 		}
 
+		return false;
+
 	}
 
-	float colorToLuminance( vec3 color ) {
+	// 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 ) {
 
-		// https://en.wikipedia.org/wiki/Relative_luminance
-		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
 
-	}
+		if ( t > EPSILON ) {
 
-	// ray sampling x and z are swapped to align with expected background view
-	vec2 equirectDirectionToUv( vec3 direction ) {
+			vec3 hit = rayOrigin + rayDirection * t;
+			vec3 vi = hit - position;
 
-		// from Spherical.setFromCartesianCoords
-		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
-		uv /= vec2( 2.0 * PI, PI );
+			float a1 = dot( u, vi );
+			float a2 = dot( v, vi );
 
-		// apply adjustments to get values in range [0, 1] and y right side up
-		uv.x += 0.5;
-		uv.y = 1.0 - uv.y;
-		return uv;
+			if( length( vec2( a1, a2 ) ) <= 0.5 ) {
 
-	}
+				dist = t;
+				return true;
 
-	vec3 equirectUvToDirection( vec2 uv ) {
+			}
 
-		// undo above adjustments
-		uv.x -= 0.5;
-		uv.y = 1.0 - uv.y;
+		}
 
-		// from Vector3.setFromSphericalCoords
-		float theta = uv.x * 2.0 * PI;
-		float phi = uv.y * PI;
+		return false;
 
-		float sinPhi = sin( phi );
+	}
 
-		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+	// power heuristic for multiple importance sampling
+	float misHeuristic( float a, float b ) {
+
+		float aa = a * a;
+		float bb = b * b;
+		return aa / ( aa + bb );
 
 	}
+
 `;
 
 	class PMREMCopyMaterial extends MaterialBase {
@@ -1860,97 +2876,312 @@
 
 	}
 
-	const shaderMaterialStructs = /* glsl */ `
-
-	struct PhysicalCamera {
-
-		float focusDistance;
-		float anamorphicRatio;
-		float bokehSize;
-		int apertureBlades;
-		float apertureRotation;
-
-	};
-
-	struct EquirectHdrInfo {
-
-		sampler2D marginalWeights;
-		sampler2D conditionalWeights;
-		sampler2D map;
-		sampler2D totalSum;
-
-	};
-
-	struct Material {
-
-		vec3 color;
-		int map;
-
-		float metalness;
-		int metalnessMap;
-
-		float roughness;
-		int roughnessMap;
-
-		float ior;
-		float transmission;
-		int transmissionMap;
-
-		float emissiveIntensity;
-		vec3 emissive;
-		int emissiveMap;
-
-		int normalMap;
-		vec2 normalScale;
-
-		float opacity;
-		float alphaTest;
-
-		float side;
-		bool matte;
-
-	};
-
-	Material readMaterialInfo( sampler2D tex, uint index ) {
-
-		uint i = index * 6u;
-
-		vec4 s0 = texelFetch1D( tex, i + 0u );
-		vec4 s1 = texelFetch1D( tex, i + 1u );
-		vec4 s2 = texelFetch1D( tex, i + 2u );
-		vec4 s3 = texelFetch1D( tex, i + 3u );
-		vec4 s4 = texelFetch1D( tex, i + 4u );
-		vec4 s5 = texelFetch1D( tex, i + 5u );
-
-		Material m;
-		m.color = s0.rgb;
-		m.map = floatBitsToInt( s0.a );
-
-		m.metalness = s1.r;
-		m.metalnessMap = floatBitsToInt( s1.g );
-		m.roughness = s1.b;
-		m.roughnessMap = floatBitsToInt( s1.a );
-
-		m.ior = s2.r;
-		m.transmission = s2.g;
-		m.transmissionMap = floatBitsToInt( s2.b );
-		m.emissiveIntensity = s2.a;
-
-		m.emissive = s3.rgb;
-		m.emissiveMap = floatBitsToInt( s3.a );
-
-		m.normalMap = floatBitsToInt( s4.r );
-		m.normalScale = s4.gb;
-
-		m.opacity = s5.r;
-		m.alphaTest = s5.g;
-		m.side = s5.b;
-		m.matte = bool( s5.a );
-
-		return m;
-
-	}
-
+	const shaderMaterialStructs = /* glsl */ `
+
+	struct PhysicalCamera {
+
+		float focusDistance;
+		float anamorphicRatio;
+		float bokehSize;
+		int apertureBlades;
+		float apertureRotation;
+
+	};
+
+	struct EquirectHdrInfo {
+
+		sampler2D marginalWeights;
+		sampler2D conditionalWeights;
+		sampler2D map;
+
+		float totalSumWhole;
+		float totalSumDecimal;
+
+	};
+
+	struct Material {
+
+		vec3 color;
+		int map;
+
+		float metalness;
+		int metalnessMap;
+
+		float roughness;
+		int roughnessMap;
+
+		float ior;
+		float transmission;
+		int transmissionMap;
+
+		float emissiveIntensity;
+		vec3 emissive;
+		int emissiveMap;
+
+		int normalMap;
+		vec2 normalScale;
+
+		float clearcoat;
+		int clearcoatMap;
+		int clearcoatNormalMap;
+		vec2 clearcoatNormalScale;
+		float clearcoatRoughness;
+		int clearcoatRoughnessMap;
+
+		int iridescenceMap;
+		int iridescenceThicknessMap;
+		float iridescence;
+		float iridescenceIor;
+		float iridescenceThicknessMinimum;
+		float iridescenceThicknessMaximum;
+
+		vec3 specularColor;
+		int specularColorMap;
+
+		float specularIntensity;
+		int specularIntensityMap;
+
+		int alphaMap;
+
+		bool castShadow;
+		float opacity;
+		float alphaTest;
+
+		float side;
+		bool matte;
+
+		vec3 sheenColor;
+		int sheenColorMap;
+		float sheenRoughness;
+		int sheenRoughnessMap;
+
+		mat3 mapTransform;
+		mat3 metalnessMapTransform;
+		mat3 roughnessMapTransform;
+		mat3 transmissionMapTransform;
+		mat3 emissiveMapTransform;
+		mat3 normalMapTransform;
+		mat3 clearcoatMapTransform;
+		mat3 clearcoatNormalMapTransform;
+		mat3 clearcoatRoughnessMapTransform;
+		mat3 sheenColorMapTransform;
+		mat3 sheenRoughnessMapTransform;
+		mat3 iridescenceMapTransform;
+		mat3 iridescenceThicknessMapTransform;
+		mat3 specularColorMapTransform;
+		mat3 specularIntensityMapTransform;
+
+	};
+
+	mat3 readTextureTransform( sampler2D tex, uint index ) {
+
+		mat3 textureTransform;
+
+		vec4 row1 = texelFetch1D( tex, index );
+		vec4 row2 = texelFetch1D( tex, index + 1u );
+
+		textureTransform[0] = vec3(row1.r, row2.r, 0.0);
+		textureTransform[1] = vec3(row1.g, row2.g, 0.0);
+		textureTransform[2] = vec3(row1.b, row2.b, 1.0);
+
+		return textureTransform;
+
+	}
+
+	Material readMaterialInfo( sampler2D tex, uint index ) {
+
+		uint i = index * 44u;
+
+		vec4 s0 = texelFetch1D( tex, i + 0u );
+		vec4 s1 = texelFetch1D( tex, i + 1u );
+		vec4 s2 = texelFetch1D( tex, i + 2u );
+		vec4 s3 = texelFetch1D( tex, i + 3u );
+		vec4 s4 = texelFetch1D( tex, i + 4u );
+		vec4 s5 = texelFetch1D( tex, i + 5u );
+		vec4 s6 = texelFetch1D( tex, i + 6u );
+		vec4 s7 = texelFetch1D( tex, i + 7u );
+		vec4 s8 = texelFetch1D( tex, i + 8u );
+		vec4 s9 = texelFetch1D( tex, i + 9u );
+		vec4 s10 = texelFetch1D( tex, i + 10u );
+		vec4 s11 = texelFetch1D( tex, i + 11u );
+		vec4 s12 = texelFetch1D( tex, i + 12u );
+		vec4 s13 = texelFetch1D( tex, i + 13u );
+
+		Material m;
+		m.color = s0.rgb;
+		m.map = int( round( s0.a ) );
+
+		m.metalness = s1.r;
+		m.metalnessMap = int( round( s1.g ) );
+		m.roughness = s1.b;
+		m.roughnessMap = int( round( s1.a ) );
+
+		m.ior = s2.r;
+		m.transmission = s2.g;
+		m.transmissionMap = int( round( s2.b ) );
+		m.emissiveIntensity = s2.a;
+
+		m.emissive = s3.rgb;
+		m.emissiveMap = int( round( s3.a ) );
+
+		m.normalMap = int( round( s4.r ) );
+		m.normalScale = s4.gb;
+
+		m.clearcoat = s4.a;
+		m.clearcoatMap = int( round( s5.r ) );
+		m.clearcoatRoughness = s5.g;
+		m.clearcoatRoughnessMap = int( round( s5.b ) );
+		m.clearcoatNormalMap = int( round( s5.a ) );
+		m.clearcoatNormalScale = s6.rg;
+
+		m.sheenColor = s7.rgb;
+		m.sheenColorMap = int( round( s7.a ) );
+		m.sheenRoughness = s8.r;
+		m.sheenRoughnessMap = int( round( s8.g ) );
+
+		m.iridescenceMap = int( round( s8.b ) );
+		m.iridescenceThicknessMap = int( round( s8.a ) );
+		m.iridescence = s9.r;
+		m.iridescenceIor = s9.g;
+		m.iridescenceThicknessMinimum = s9.b;
+		m.iridescenceThicknessMaximum = s9.a;
+
+		m.specularColor = s10.rgb;
+		m.specularColorMap = int( round( s10.a ) );
+
+		m.specularIntensity = s11.r;
+		m.specularIntensityMap = int( round( s11.g ) );
+
+		m.alphaMap = int( round( s12.r ) );
+
+		m.opacity = s12.g;
+		m.alphaTest = s12.b;
+		m.side = s12.a;
+
+		m.matte = bool( s13.r );
+		m.castShadow = ! bool( s13.g );
+
+		uint firstTextureTransformIdx = i + 14u;
+
+		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 );
+
+		return m;
+
+	}
+
+`;
+
+	const shaderLightStruct = /* glsl */ `
+
+	#define RECT_AREA_LIGHT_TYPE 0
+	#define CIRC_AREA_LIGHT_TYPE 1
+	#define SPOT_LIGHT_TYPE 2
+
+	struct LightsInfo {
+
+		sampler2D tex;
+		uint count;
+
+	};
+
+	struct Light {
+
+		vec3 position;
+		int type;
+
+		vec3 color;
+		float intensity;
+
+		vec3 u;
+		vec3 v;
+		float area;
+
+		// spot light fields
+		float radius;
+		float near;
+		float decay;
+		float distance;
+		float coneCos;
+		float penumbraCos;
+		int iesProfile;
+
+	};
+
+	Light readLightInfo( sampler2D tex, uint index ) {
+
+		uint i = index * 6u;
+
+		vec4 s0 = texelFetch1D( tex, i + 0u );
+		vec4 s1 = texelFetch1D( tex, i + 1u );
+		vec4 s2 = texelFetch1D( tex, i + 2u );
+		vec4 s3 = texelFetch1D( tex, i + 3u );
+
+		Light l;
+		l.position = s0.rgb;
+		l.type = int( round( s0.a ) );
+
+		l.color = s1.rgb;
+		l.intensity = s1.a;
+
+		l.u = s2.rgb;
+		l.v = s3.rgb;
+		l.area = s3.a;
+
+		if ( l.type == SPOT_LIGHT_TYPE ) {
+
+			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.coneCos = s5.r;
+			l.penumbraCos = s5.g;
+			l.iesProfile = int( round ( s5.b ) );
+
+		}
+
+		return l;
+
+	}
+
+	struct SpotLight {
+
+		vec3 position;
+		int type;
+
+		vec3 color;
+		float intensity;
+
+		vec3 u;
+		vec3 v;
+		float area;
+
+		float radius;
+		float near;
+		float decay;
+		float distance;
+		float coneCos;
+		float penumbraCos;
+		int iesProfile;
+
+	};
+
 `;
 
 	const shaderGGXFunctions = /* glsl */`
@@ -2027,17 +3258,18 @@ float ggxDistribution( vec3 halfVector, float roughness ) {
 
 	// See equation (33) from reference [0]
 	float a2 = roughness * roughness;
+	a2 = max( EPSILON, a2 );
 	float cosTheta = halfVector.z;
 	float cosTheta4 = pow( cosTheta, 4.0 );
 
 	if ( cosTheta == 0.0 ) return 0.0;
 
-	float theta = acos( halfVector.z );
+	float theta = acosSafe( halfVector.z );
 	float tanTheta = tan( theta );
 	float tanTheta2 = pow( tanTheta, 2.0 );
 
 	float denom = PI * cosTheta4 * pow( a2 + tanTheta2, 2.0 );
-	return a2 / denom;
+	return ( a2 / denom );
 
 	// See equation (1) from reference [2]
 	// const { x, y, z } = halfVector;
@@ -2059,6 +3291,236 @@ float ggxPDF( vec3 wi, vec3 halfVector, float roughness ) {
 	return D * G1 * max( 0.0, dot( wi, halfVector ) ) / wi.z;
 
 }
+`;
+
+	const shaderSheenFunctions = /* glsl */`
+
+// See equation (2) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+float velvetD( float cosThetaH, float roughness ) {
+
+	float alpha = max( roughness, 0.07 );
+	alpha = alpha * alpha;
+
+	float invAlpha = 1.0 / alpha;
+
+	float sqrCosThetaH = cosThetaH * cosThetaH;
+	float sinThetaH = max( 1.0 - sqrCosThetaH, 0.001 );
+
+	return ( 2.0 + invAlpha ) * pow( sinThetaH, 0.5 * invAlpha ) / ( 2.0 * PI );
+
+}
+
+float velvetParamsInterpolate( int i, float oneMinusAlphaSquared ) {
+
+	const float p0[5] = float[5]( 25.3245, 3.32435, 0.16801, -1.27393, -4.85967 );
+	const float p1[5] = float[5]( 21.5473, 3.82987, 0.19823, -1.97760, -4.32054 );
+
+	return mix( p1[i], p0[i], oneMinusAlphaSquared );
+
+}
+
+float velvetL( float x, float alpha ) {
+
+	float oneMinusAlpha = 1.0 - alpha;
+	float oneMinusAlphaSquared = oneMinusAlpha * oneMinusAlpha;
+
+	float a = velvetParamsInterpolate( 0, oneMinusAlphaSquared );
+	float b = velvetParamsInterpolate( 1, oneMinusAlphaSquared );
+	float c = velvetParamsInterpolate( 2, oneMinusAlphaSquared );
+	float d = velvetParamsInterpolate( 3, oneMinusAlphaSquared );
+	float e = velvetParamsInterpolate( 4, oneMinusAlphaSquared );
+
+	return a / ( 1.0 + b * pow( abs( x ), c ) ) + d * x + e;
+
+}
+
+// See equation (3) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+float velvetLambda( float cosTheta, float alpha ) {
+
+	return abs( cosTheta ) < 0.5 ? exp( velvetL( cosTheta, alpha ) ) : exp( 2.0 * velvetL( 0.5, alpha ) - velvetL( 1.0 - cosTheta, alpha ) );
+
+}
+
+// See Section 3, Shadowing Term, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+float velvetG( float cosThetaO, float cosThetaI, float roughness ) {
+
+	float alpha = max( roughness, 0.07 );
+	alpha = alpha * alpha;
+
+	return 1.0 / ( 1.0 + velvetLambda( cosThetaO, alpha ) + velvetLambda( cosThetaI, alpha ) );
+
+}
+
+float directionalAlbedoSheen( float cosTheta, float alpha ) {
+
+	cosTheta = saturate( cosTheta );
+
+	float c = 1.0 - cosTheta;
+	float c3 = c * c * c;
+
+	return 0.65584461 * c3 + 1.0 / ( 4.16526551 + exp( -7.97291361 * sqrt( alpha ) + 6.33516894 ) );
+
+}
+
+float sheenAlbedoScaling( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float alpha = max( surf.sheenRoughness, 0.07 );
+	alpha = alpha * alpha;
+
+	float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
+
+	float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
+	float eWi = directionalAlbedoSheen( saturateCos( wi.z ), alpha );
+
+	return min( 1.0 - maxSheenColor * eWo, 1.0 - maxSheenColor * eWi );
+
+}
+
+// See Section 5, Layering, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+float sheenAlbedoScaling( vec3 wo, SurfaceRec surf ) {
+
+	float alpha = max( surf.sheenRoughness, 0.07 );
+	alpha = alpha * alpha;
+
+	float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
+
+	float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
+
+	return 1.0 - maxSheenColor * eWo;
+
+}
+
+`;
+
+	const shaderIridescenceFunctions = /* glsl */`
+
+// XYZ to sRGB color space
+const mat3 XYZ_TO_REC709 = mat3(
+	 3.2404542, -0.9692660,  0.0556434,
+	-1.5371385,  1.8760108, -0.2040259,
+	-0.4985314,  0.0415560,  1.0572252
+);
+
+vec3 fresnel0ToIor( vec3 fresnel0 ) {
+
+	vec3 sqrtF0 = sqrt( fresnel0 );
+	return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );
+
+}
+
+// Conversion FO/IOR
+vec3 iorToFresnel0( vec3 transmittedIor, float incidentIor ) {
+
+	return square( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );
+
+}
+
+// ior is a value between 1.0 and 3.0. 1.0 is air interface
+float iorToFresnel0( float transmittedIor, float incidentIor ) {
+
+	return square( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ) );
+
+}
+
+// Fresnel equations for dielectric/dielectric interfaces. See https://belcour.github.io/blog/research/2017/05/01/brdf-thin-film.html
+vec3 evalSensitivity( float OPD, vec3 shift ) {
+
+	float phase = 2.0 * PI * OPD * 1.0e-9;
+
+	vec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );
+	vec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );
+	vec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );
+
+	vec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - square( phase ) * var );
+	xyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * square( phase ) );
+	xyz /= 1.0685e-7;
+
+	vec3 srgb = XYZ_TO_REC709 * xyz;
+	return srgb;
+
+}
+
+// See Section 4. Analytic Spectral Integration, A Practical Extension to Microfacet Theory for the Modeling of Varying Iridescence, https://hal.archives-ouvertes.fr/hal-01518344/document
+vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {
+
+	vec3 I;
+
+	// Force iridescenceIor -> outsideIOR when thinFilmThickness -> 0.0
+	float iridescenceIor = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );
+
+	// Evaluate the cosTheta on the base layer (Snell law)
+	float sinTheta2Sq = square( outsideIOR / iridescenceIor ) * ( 1.0 - square( cosTheta1 ) );
+
+	// Handle TIR:
+	float cosTheta2Sq = 1.0 - sinTheta2Sq;
+	if ( cosTheta2Sq < 0.0 ) {
+
+		return vec3( 1.0 );
+
+	}
+
+	float cosTheta2 = sqrt( cosTheta2Sq );
+
+	// First interface
+	float R0 = iorToFresnel0( iridescenceIor, outsideIOR );
+	float R12 = schlickFresnel( cosTheta1, R0 );
+	float R21 = R12;
+	float T121 = 1.0 - R12;
+	float phi12 = 0.0;
+	if ( iridescenceIor < outsideIOR ) {
+
+		phi12 = PI;
+
+	}
+	float phi21 = PI - phi12;
+
+	// Second interface
+	vec3 baseIOR = fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) ); // guard against 1.0
+	vec3 R1 = iorToFresnel0( baseIOR, iridescenceIor );
+	vec3 R23 = schlickFresnel( cosTheta2, R1 );
+	vec3 phi23 = vec3( 0.0 );
+	if ( baseIOR[0] < iridescenceIor ) {
+
+		phi23[ 0 ] = PI;
+
+	}
+	if ( baseIOR[1] < iridescenceIor ) {
+
+		phi23[ 1 ] = PI;
+
+	}
+	if ( baseIOR[2] < iridescenceIor ) {
+
+		phi23[ 2 ] = PI;
+
+	}
+
+	// Phase shift
+	float OPD = 2.0 * iridescenceIor * thinFilmThickness * cosTheta2;
+	vec3 phi = vec3( phi21 ) + phi23;
+
+	// Compound terms
+	vec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );
+	vec3 r123 = sqrt( R123 );
+	vec3 Rs = square( T121 ) * R23 / ( vec3( 1.0 ) - R123 );
+
+	// Reflectance term for m = 0 (DC term amplitude)
+	vec3 C0 = R12 + Rs;
+	I = C0;
+
+	// Reflectance term for m > 0 (pairs of diracs)
+	vec3 Cm = Rs - T121;
+	for ( int m = 1; m <= 2; ++ m )
+	{
+		Cm *= r123;
+		vec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );
+		I += Cm * Sm;
+	}
+
+	// Since out of gamut colors might be produced, negative color values are clamped to 0.
+	return max( I, vec3( 0.0 ) );
+}
+
 `;
 
 	const shaderMaterialSampling = /* glsl */`
@@ -2074,15 +3536,29 @@ struct SurfaceRec {
 	vec3 emission;
 	float transmission;
 	float ior;
+	float clearcoat;
+	float clearcoatRoughness;
+	float filteredClearcoatRoughness;
+	vec3 sheenColor;
+	float sheenRoughness;
+	float iridescence;
+	float iridescenceIor;
+	float iridescenceThickness;
+	vec3 specularColor;
+	float specularIntensity;
 };
 
 struct SampleRec {
+	float specularPdf;
 	float pdf;
 	vec3 direction;
+	vec3 clearcoatDirection;
 	vec3 color;
 };
 
 ${ shaderGGXFunctions }
+${ shaderSheenFunctions }
+${ shaderIridescenceFunctions }
 
 // diffuse
 float diffusePDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
@@ -2117,10 +3593,15 @@ vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 // specular
 float specularPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
-	// See equation (17) in http://jcgt.org/published/0003/02/03/
+	// See 14.1.1 Microfacet BxDFs in https://www.pbr-book.org/
 	float filteredRoughness = surf.filteredRoughness;
 	vec3 halfVector = getHalfVector( wi, wo );
-	return ggxPDF( wi, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+	float incidentTheta = acos( wo.z );
+	float D = ggxDistribution( halfVector, filteredRoughness );
+	float G1 = ggxShadowMaskG1( incidentTheta, filteredRoughness );
+	float ggxPdf = D * G1 * max( 0.0, abs( dot( wo, halfVector ) ) ) / abs ( wo.z );
+	return ggxPdf / ( 4.0 * dot( wo, halfVector ) );
 
 }
 
@@ -2153,21 +3634,25 @@ vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 	float iorRatio = frontFace ? 1.0 / ior : ior;
 	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
 	float D = ggxDistribution( halfVector, filteredRoughness );
+	vec3 F = vec3( schlickFresnelFromIor( dot( wi, halfVector ), iorRatio ) ) * surf.specularColor * surf.specularIntensity;
 
-	float F = schlickFresnelFromIor( dot( wi, halfVector ), iorRatio );
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
 	bool cannotRefract = iorRatio * sinTheta > 1.0;
 	if ( cannotRefract ) {
 
-		F = 1.0;
+		F = vec3( 1.0 );
 
 	}
 
+	float f0 = pow( ( iorRatio - 1.0 ) / ( iorRatio + 1.0 ), 2.0 );
+	vec3 iridescenceFresnel = evalIridescence( 1.0, surf.iridescenceIor, dot( wi, halfVector ), surf.iridescenceThickness, vec3( f0 ) );
+	F = mix( F, iridescenceFresnel, surf.iridescence );
+
 	vec3 color = mix( vec3( 1.0 ), surf.color, metalness );
 	color = mix( color, vec3( 1.0 ), F );
 	color *= G * D / ( 4.0 * abs( wi.z * wo.z ) );
-	color *= mix( F, 1.0, metalness );
+	color *= mix( F, vec3( 1.0 ), metalness );
 	color *= wi.z; // scale the light by the direction the light is coming in from
 
 	return color;
@@ -2274,198 +3759,603 @@ vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 }
 
-float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf ) {
+// clearcoat
+float clearcoatPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// See equation (27) in http://jcgt.org/published/0003/02/03/
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = getHalfVector( wi, wo );
+	return ggxPDF( wo, halfVector, filteredClearcoatRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+}
+
+vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
+
+	// sample ggx vndf distribution which gives a new normal
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = ggxDirection(
+		wo,
+		filteredClearcoatRoughness,
+		filteredClearcoatRoughness,
+		rand(),
+		rand()
+	);
+
+	// apply to new ray by reflecting off the new normal
+	return - reflect( wo, halfVector );
+
+}
+
+void clearcoatColor( inout vec3 color, vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = 1.5;
+	bool frontFace = surf.frontFace;
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+
+	vec3 halfVector = getHalfVector( wo, wi );
+	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float G = ggxShadowMaskG2( wi, wo, filteredClearcoatRoughness );
+	float D = ggxDistribution( halfVector, filteredClearcoatRoughness );
+
+	float F = schlickFresnelFromIor( dot( wi, halfVector ), ior );
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		F = 1.0;
+
+	}
+
+	float fClearcoat = F * D * G / ( 4.0 * abs( wi.z * wo.z ) );
+
+	color = color * ( 1.0 - surf.clearcoat * F ) + fClearcoat * surf.clearcoat * wi.z;
+
+}
+
+// sheen
+vec3 sheenColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	vec3 halfVector = getHalfVector( wo, wi );
+
+	float cosThetaO = saturateCos( wo.z );
+	float cosThetaI = saturateCos( wi.z );
+	float cosThetaH = halfVector.z;
+
+	float D = velvetD( cosThetaH, surf.sheenRoughness );
+	float G = velvetG( cosThetaO, cosThetaI, surf.sheenRoughness );
+
+	// See equation (1) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	vec3 color = surf.sheenColor;
+	color *= D * G / ( 4.0 * abs( cosThetaO * cosThetaI ) );
+	color *= wi.z;
+
+	return color;
+
+}
+
+// bsdf
+void getLobeWeights( vec3 wo, vec3 clearcoatWo, SurfaceRec surf, out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	float transSpecularProb = mix( reflectance, 1.0, metalness );
+	float diffSpecularProb = 0.5 + 0.5 * metalness;
+
+	clearcoatWeight = surf.clearcoat * schlickFresnel( clearcoatWo.z, 0.04 );
+	diffuseWeight = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb ) * ( 1.0 - clearcoatWeight );
+	specularWeight = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb * ( 1.0 - clearcoatWeight );
+	transmissionWeight = transmission * ( 1.0 - transSpecularProb ) * ( 1.0 - clearcoatWeight );
+
+	float totalWeight = diffuseWeight + specularWeight + transmissionWeight + clearcoatWeight;
+	float invTotalWeight = 1.0 / totalWeight;
+
+	diffuseWeight *= invTotalWeight;
+	specularWeight *= invTotalWeight;
+	transmissionWeight *= invTotalWeight;
+	clearcoatWeight *= invTotalWeight;
+
+}
+
+float bsdfPdf( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out float specularPdf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	float spdf = 0.0;
+	float dpdf = 0.0;
+	float tpdf = 0.0;
+	float cpdf = 0.0;
+
+	if ( wi.z < 0.0 ) {
+
+		if( transmissionWeight > 0.0 ) {
+
+			tpdf = transmissionPDF( wo, wi, surf );
+
+		}
+
+	} else {
+
+		if( diffuseWeight > 0.0 ) {
+
+			dpdf = diffusePDF( wo, wi, surf );
+
+		}
+
+		if( specularWeight > 0.0 ) {
+
+			spdf = specularPDF( wo, wi, surf );
+
+		}
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		cpdf = clearcoatPDF( clearcoatWo, clearcoatWi, surf );
+
+	}
+
+	float pdf =
+		  dpdf * diffuseWeight
+		+ spdf * specularWeight
+		+ tpdf * transmissionWeight
+		+ cpdf * clearcoatWeight;
+
+	// retrieve specular rays for the shadows flag
+	specularPdf = spdf * specularWeight + cpdf * clearcoatWeight;
+
+	return pdf;
+
+}
+
+vec3 bsdfColor( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
+
+	vec3 color = vec3( 0.0 );
+	if ( wi.z < 0.0 ) {
+
+		if( transmissionWeight > 0.0 ) {
+
+			color = transmissionColor( wo, wi, surf );
+
+		}
+
+	} else {
+
+		if( diffuseWeight > 0.0 ) {
+
+			color = diffuseColor( wo, wi, surf );
+			color *= 1.0 - surf.transmission;
+
+		}
+
+		if( specularWeight > 0.0 ) {
+
+			color += specularColor( wo, wi, surf );
+
+		}
+
+		color *= sheenAlbedoScaling( wo, wi, surf );
+		color += sheenColor( wo, wi, surf );
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		clearcoatColor( color, clearcoatWo, clearcoatWi, surf );
+
+	}
+
+	return color;
+
+}
+
+float bsdfResult( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out vec3 color ) {
+
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+
+	float specularPdf;
+	color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	return bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+
+}
+
+SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis, mat3 clearcoatNormalBasis, mat3 clearcoatInvBasis, SurfaceRec surf ) {
+
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+
+	float pdf[4];
+	pdf[0] = diffuseWeight;
+	pdf[1] = specularWeight;
+	pdf[2] = transmissionWeight;
+	pdf[3] = clearcoatWeight;
+
+	float cdf[4];
+	cdf[0] = pdf[0];
+	cdf[1] = pdf[1] + cdf[0];
+	cdf[2] = pdf[2] + cdf[1];
+	cdf[3] = pdf[3] + cdf[2];
+
+	if( cdf[3] != 0.0 ) {
+
+		float invMaxCdf = 1.0 / cdf[3];
+		cdf[0] *= invMaxCdf;
+		cdf[1] *= invMaxCdf;
+		cdf[2] *= invMaxCdf;
+		cdf[3] *= invMaxCdf;
+
+	} else {
+
+		cdf[0] = 1.0;
+		cdf[1] = 0.0;
+		cdf[2] = 0.0;
+		cdf[3] = 0.0;
+
+	}
+
+	vec3 wi;
+	vec3 clearcoatWi;
+
+	float r = rand();
+	if ( r <= cdf[0] ) {
+
+		wi = diffuseDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
+
+	} else if ( r <= cdf[1] ) {
+
+		wi = specularDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
+
+	} else if ( r <= cdf[2] ) {
+
+		wi = transmissionDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
+
+	} else if ( r <= cdf[3] ) {
+
+		clearcoatWi = clearcoatDirection( clearcoatWo, surf );
+		wi = normalize( invBasis * normalize( clearcoatNormalBasis * clearcoatWi ) );
+
+	}
+
+	SampleRec result;
+	result.pdf = bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, result.specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.direction = wi;
+	result.clearcoatDirection = clearcoatWi;
+
+	return result;
+
+}
+`;
+
+	const shaderEnvMapSampling = /* glsl */`
+
+vec3 sampleEquirectEnvMapColor( vec3 direction, sampler2D map ) {
+
+	return texture2D( map, equirectDirectionToUv( direction ) ).rgb;
+
+}
+
+float envMapDirectionPdf( vec3 direction ) {
+
+	vec2 uv = equirectDirectionToUv( direction );
+	float theta = uv.y * PI;
+	float sinTheta = sin( theta );
+	if ( sinTheta == 0.0 ) {
+
+		return 0.0;
+
+	}
+
+	return 1.0 / ( 2.0 * PI * PI * sinTheta );
+
+}
+
+float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
+
+	vec2 uv = equirectDirectionToUv( direction );
+	color = texture2D( info.map, uv ).rgb;
+
+	float totalSum = info.totalSumWhole + info.totalSumDecimal;
+	float lum = colorToLuminance( color );
+	ivec2 resolution = textureSize( info.map, 0 );
+	float pdf = lum / totalSum;
+
+	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
+
+}
+
+float randomEnvMapSample( EquirectHdrInfo info, 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 );
+
+	vec3 derivedDirection = equirectUvToDirection( uv );
+	direction = derivedDirection;
+	color = texture2D( info.map, uv ).rgb;
+
+	float totalSum = info.totalSumWhole + info.totalSumDecimal;
+	float lum = colorToLuminance( color );
+	ivec2 resolution = textureSize( info.map, 0 );
+	float pdf = lum / totalSum;
+
+	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
+
+}
+
+`;
+
+	const shaderLightSampling = /* glsl */`
+
+float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
+
+	return smoothstep( coneCosine, penumbraCosine, angleCosine );
+
+}
+
+float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
+
+	// based upon Frostbite 3 Moving to Physically-based Rendering
+	// page 32, equation 26: E[window1]
+	// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+	float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), EPSILON );
+
+	if ( cutoffDistance > 0.0 ) {
+
+		distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
+
+	}
+
+	return distanceFalloff;
+
+}
+
+float getPhotometricAttenuation( sampler2DArray iesProfiles, int iesProfile, vec3 posToLight, vec3 lightDir, vec3 u, vec3 v ) {
+
+    float cosTheta = dot( posToLight, lightDir );
+    float angle = acos( cosTheta ) * ( 1.0 / PI );
+
+    return texture2D( iesProfiles, vec3( 0.0, angle, iesProfile ) ).r;
+
+}
+
+struct LightSampleRec {
+
+	bool hit;
+	float dist;
+	vec3 direction;
+	float pdf;
+	vec3 emission;
+	int type;
+
+};
+
+LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection ) {
+
+	LightSampleRec lightSampleRec;
+	lightSampleRec.hit = 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 ) {
+			continue;
+		}
+
+		u *= 1.0 / dot( u, u );
+		v *= 1.0 / dot( v, v );
+
+		float dist;
+
+		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 ) )
+		) {
+
+			if ( dist < lightSampleRec.dist || ! lightSampleRec.hit ) {
+
+				float cosTheta = dot( rayDirection, normal );
+
+				lightSampleRec.hit = true;
+				lightSampleRec.dist = dist;
+				lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+				lightSampleRec.emission = light.color * light.intensity;
+				lightSampleRec.direction = rayDirection;
+				lightSampleRec.type = light.type;
+
+			}
 
-	float ior = surf.ior;
-	float metalness = surf.metalness;
-	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
+		} else if ( light.type == SPOT_LIGHT_TYPE ) {
 
-	float ratio = frontFace ? 1.0 / ior : ior;
-	float cosTheta = min( wo.z, 1.0 );
-	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
-	if ( cannotRefract ) {
+			// 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 );
 
-		reflectance = 1.0;
+			// 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 spdf = 0.0;
-	float dpdf = 0.0;
-	float tpdf = 0.0;
+			// 	float cosTheta = dot( rayDirection, normal );
+			// 	float spotAttenuation = light.iesProfile != - 1 ?
+			// 		getPhotometricAttenuation( iesProfiles, light.iesProfile, rayDirection, normal, u, v )
+			// 		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
 
-	if ( wi.z < 0.0 ) {
+			// 	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
 
-		tpdf = transmissionPDF( wo, wi, surf );
+			// 	lightSampleRec.hit = true;
+			// 	lightSampleRec.dist = dist;
+			// 	lightSampleRec.direction = rayDirection;
+			// 	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
+			// 	lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
 
-	} else {
+			// }
 
-		spdf = specularPDF( wo, wi, surf );
-		dpdf = diffusePDF( wo, wi, surf );
+		}
 
 	}
 
-	float transSpecularProb = mix( reflectance, 1.0, metalness );
-	float diffSpecularProb = 0.5 + 0.5 * metalness;
-	float pdf =
-		spdf * transmission * transSpecularProb
-		+ tpdf * transmission * ( 1.0 - transSpecularProb )
-		+ spdf * ( 1.0 - transmission ) * diffSpecularProb
-		+ dpdf * ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
-
-	return pdf;
+	return lightSampleRec;
 
 }
 
-vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
 
-	vec3 color = vec3( 0.0 );
-	if ( wi.z < 0.0 ) {
+	LightSampleRec lightSampleRec;
+	lightSampleRec.hit = true;
+	lightSampleRec.type = light.type;
 
-		color = transmissionColor( wo, wi, surf );
+	lightSampleRec.emission = light.color * light.intensity;
 
-	} else {
+	vec3 randomPos;
+	if( light.type == RECT_AREA_LIGHT_TYPE ) {
+
+		// rectangular area light
+		randomPos = light.position + light.u * ( rand() - 0.5 ) + light.v * ( rand() - 0.5 );
 
-		color = diffuseColor( wo, wi, surf );
-		color *= 1.0 - surf.transmission;
+	} else if( light.type == 1 ) {
 
-		color += specularColor( wo, wi, surf );
+		// circular area light
+		float r = 0.5 * sqrt( rand() );
+		float theta = rand() * 2.0 * PI;
+		float x = r * cos( theta );
+		float y = r * sin( theta );
+
+		randomPos = light.position + light.u * x + light.v * y;
 
 	}
 
-	return color;
+	vec3 toLight = randomPos - rayOrigin;
+	float lightDistSq = dot( toLight, toLight );
+	lightSampleRec.dist = sqrt( lightDistSq );
 
-}
+	vec3 direction = toLight / lightSampleRec.dist;
+	lightSampleRec.direction = direction;
 
-float bsdfResult( vec3 wo, vec3 wi, SurfaceRec surf, out vec3 color ) {
+	vec3 lightNormal = normalize( cross( light.u, light.v ) );
+	lightSampleRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
 
-	color = bsdfColor( wo, wi, surf );
-	return bsdfPdf( wo, wi, surf );
+	return lightSampleRec;
 
 }
 
-SampleRec bsdfSample( vec3 wo, SurfaceRec surf ) {
+LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin ) {
 
-	float ior = surf.ior;
-	float metalness = surf.metalness;
-	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
+	float radius = light.radius * sqrt( rand() );
+	float theta = rand() * 2.0 * PI;
+	float x = radius * cos( theta );
+	float y = radius * sin( theta );
 
-	float ratio = frontFace ? 1.0 / ior : ior;
-	float cosTheta = min( wo.z, 1.0 );
-	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
-	if ( cannotRefract ) {
+	vec3 u = light.u;
+	vec3 v = light.v;
+	vec3 normal = normalize( cross( u, v ) );
 
-		reflectance = 1.0;
+	float angle = acos( light.coneCos );
+	float angleTan = tan( angle );
+	float startDistance = light.radius / max( angleTan, EPSILON );
 
-	}
+	vec3 randomPos = light.position - normal * startDistance + u * x + v * y;
+	vec3 toLight = randomPos - rayOrigin;
+	float lightDistSq = dot( toLight, toLight );
+	float dist = sqrt( lightDistSq );
 
-	SampleRec result;
-	if ( rand() < transmission ) {
+	vec3 direction = toLight / max( dist, EPSILON );
+	float cosTheta = dot( direction, normal );
 
-		float specularProb = mix( reflectance, 1.0, metalness );
-		if ( rand() < specularProb ) {
+	float spotAttenuation = light.iesProfile != - 1 ?
+		  getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v )
+		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
 
-			result.direction = specularDirection( wo, surf );
+	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
+	LightSampleRec lightSampleRec;
+	lightSampleRec.hit = true;
+	lightSampleRec.type = light.type;
+	lightSampleRec.dist = dist;
+	lightSampleRec.direction = direction;
+	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
 
-		} else {
+	// 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 );
 
-			result.direction = transmissionDirection( wo, surf );
+	return lightSampleRec;
 
-		}
+}
 
-	} else {
+LightSampleRec randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin ) {
 
-		float specularProb = 0.5 + 0.5 * metalness;
-		if ( rand() < specularProb ) {
+	// pick a random light
+	uint l = uint( rand() * float( lightCount ) );
+	Light light = readLightInfo( lights, l );
 
-			result.direction = specularDirection( wo, surf );
+	if ( light.type == SPOT_LIGHT_TYPE ) {
 
-		} else {
+		return randomSpotLightSample( light, iesProfiles, rayOrigin );
 
-			result.direction = diffuseDirection( wo, surf );
+	} else {
 
-		}
+		// sample the light
+		return randomAreaLightSample( light, rayOrigin );
 
 	}
 
-	result.pdf = bsdfPdf( wo, result.direction, surf );
-	result.color = bsdfColor( wo, result.direction, surf );
-	return result;
-
 }
-`;
-
-	const shaderEnvMapSampling = /* glsl */`
-
-vec3 sampleEquirectEnvMapColor( vec3 direction, sampler2D map ) {
-
-	return texture2D( map, equirectDirectionToUv( direction ) ).rgb;
-
-}
-
-float envMapDirectionPdf( vec3 direction ) {
-
-	vec2 uv = equirectDirectionToUv( direction );
-	float theta = uv.y * PI;
-	float sinTheta = sin( theta );
-	if ( sinTheta == 0.0 ) {
-
-		return 0.0;
-
-	}
-
-	return 1.0 / ( 2.0 * PI * PI * sinTheta );
-
-}
-
-float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
-
-	vec2 uv = equirectDirectionToUv( direction );
-	color = texture2D( info.map, uv ).rgb;
-
-	float totalSum = texture2D( info.totalSum, vec2( 0.0 ) ).r;
-	float lum = colorToLuminance( color );
-	ivec2 resolution = textureSize( info.map, 0 );
-	float pdf = lum / totalSum;
-
-	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
-
-}
-
-float randomEnvMapSample( EquirectHdrInfo info, 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 );
-
-	vec3 derivedDirection = equirectUvToDirection( uv );
-	direction = derivedDirection;
-	color = texture2D( info.map, uv ).rgb;
-
-	float totalSum = texture2D( info.totalSum, vec2( 0.0 ) ).r;
-	float lum = colorToLuminance( color );
-	ivec2 resolution = textureSize( info.map, 0 );
-	float pdf = lum / totalSum;
-
-	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
-
-}
-
-float misHeuristic( float a, float b ) {
-
-	float aa = a * a;
-	float bb = a * b;
-	return aa / ( bb + aa );
-
-}
-
+
 `;
 
 	class PhysicalPathTracingMaterial extends MaterialBase {
@@ -2488,6 +4378,10 @@ float misHeuristic( float a, float b ) {
 					FEATURE_DOF: 1,
 					FEATURE_GRADIENT_BG: 0,
 					TRANSPARENT_TRAVERSALS: 5,
+					// 0 = Perspective
+					// 1 = Orthographic
+					// 2 = Equirectangular
+					CAMERA_TYPE: 0,
 				},
 
 				uniforms: {
@@ -2503,10 +4397,12 @@ float misHeuristic( float a, float b ) {
 					materialIndexAttribute: { value: new threeMeshBvh.UIntVertexAttributeTexture() },
 					materials: { value: new MaterialsTexture() },
 					textures: { value: new RenderTarget2DArray().texture },
+					lights: { value: new LightsInfoUniformStruct() },
+					iesProfiles: { value: new IESProfilesTexture().texture },
 					cameraWorldMatrix: { value: new three.Matrix4() },
 					invProjectionMatrix: { value: new three.Matrix4() },
 					backgroundBlur: { value: 0.0 },
-					environmentIntensity: { value: 2.0 },
+					environmentIntensity: { value: 1.0 },
 					environmentRotation: { value: new three.Matrix3() },
 					envMapInfo: { value: new EquirectHdrInfoUniform() },
 
@@ -2546,6 +4442,7 @@ float misHeuristic( float a, float b ) {
 				${ threeMeshBvh.shaderStructs }
 				${ threeMeshBvh.shaderIntersectFunction }
 				${ shaderMaterialStructs }
+				${ shaderLightStruct }
 
 				${ shaderUtils }
 				${ shaderMaterialSampling }
@@ -2582,6 +4479,10 @@ float misHeuristic( float a, float b ) {
 				uniform int seed;
 				uniform float opacity;
 				uniform sampler2D materials;
+				uniform LightsInfo lights;
+				uniform sampler2DArray iesProfiles;
+
+				${ shaderLightSampling }
 
 				uniform EquirectHdrInfo envMapInfo;
 
@@ -2609,7 +4510,7 @@ float misHeuristic( float a, float b ) {
 				}
 
 				// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
-				bool attenuateHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection, int traversals, out vec3 color ) {
+				bool attenuateHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection, int traversals, bool isShadowRay, out vec3 color ) {
 
 					// hit results
 					uvec4 faceIndices = uvec4( 0u );
@@ -2632,13 +4533,34 @@ float misHeuristic( float a, float b ) {
 							uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
 							Material material = readMaterialInfo( materials, materialIndex );
 
+							// adjust the ray to the new surface
+							bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
+							vec3 point = rayOrigin + rayDirection * dist;
+							vec3 absPoint = abs( point );
+							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+							rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
+
+							if ( ! material.castShadow && isShadowRay ) {
+
+								continue;
+
+							}
+
 							// Opacity Test
 
 							// albedo
 							vec4 albedo = vec4( material.color, material.opacity );
 							if ( material.map != - 1 ) {
 
-								albedo *= texture2D( textures, vec3( uv, material.map ) );
+								vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
+								albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
+							}
+
+							// alphaMap
+							if ( material.alphaMap != -1 ) {
+
+								albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
 
 							}
 
@@ -2646,7 +4568,8 @@ float misHeuristic( float a, float b ) {
 							float transmission = material.transmission;
 							if ( material.transmissionMap != - 1 ) {
 
-								transmission *= texture2D( textures, vec3( uv, material.transmissionMap ) ).r;
+								vec3 uvPrime = material.transmissionMapTransform * vec3( uv, 1 );
+								transmission *= texture2D( textures, vec3( uvPrime.xy, material.transmissionMap ) ).r;
 
 							}
 
@@ -2654,7 +4577,8 @@ float misHeuristic( float a, float b ) {
 							float metalness = material.metalness;
 							if ( material.metalnessMap != - 1 ) {
 
-								metalness *= texture2D( textures, vec3( uv, material.metalnessMap ) ).b;
+								vec3 uvPrime = material.metalnessMapTransform * vec3( uv, 1 );
+								metalness *= texture2D( textures, vec3( uvPrime.xy, material.metalnessMap ) ).b;
 
 							}
 
@@ -2679,19 +4603,12 @@ float misHeuristic( float a, float b ) {
 							}
 
 							// only attenuate on the way in
-							bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
 							if ( isBelowSurface ) {
 
-								color *= albedo.rgb;
+								color *= mix( vec3( 1.0 ), albedo.rgb, transmissionFactor );
 
 							}
 
-							// adjust the ray to the new surface
-							vec3 point = rayOrigin + rayDirection * dist;
-							vec3 absPoint = abs( point );
-							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-							rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
-
 						} else {
 
 							return false;
@@ -2704,15 +4621,16 @@ float misHeuristic( float a, float b ) {
 
 				}
 
-				// returns whether the ray hit anything, not just the first surface. Could be optimized to not check the full hierarchy.
-				bool anyHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection ) {
+				// returns whether the ray hit anything before a certain distance, not just the first surface. Could be optimized to not check the full hierarchy.
+				bool anyCloserHit( BVH bvh, vec3 rayOrigin, vec3 rayDirection, float maxDist ) {
 
 					uvec4 faceIndices = uvec4( 0u );
 					vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
 					vec3 barycoord = vec3( 0.0 );
 					float side = 1.0;
 					float dist = 0.0;
-					return bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
+					bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
+					return hit && dist < maxDist;
 
 				}
 
@@ -2724,33 +4642,56 @@ float misHeuristic( float a, float b ) {
 
 				}
 
-				void main() {
+				vec3 ndcToRayOrigin( vec2 coord ) {
 
-					rng_initialize( gl_FragCoord.xy, seed );
+					vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
+					return rayOrigin4.xyz / rayOrigin4.w;
+				}
 
-					// get [-1, 1] normalized device coordinates
-					vec2 ndc = 2.0 * vUv - vec2( 1.0 );
-					vec3 rayOrigin, rayDirection;
-					ndcToCameraRay( ndc, cameraWorldMatrix, invProjectionMatrix, rayOrigin, rayDirection );
+				void getCameraRay( out vec3 rayDirection, out vec3 rayOrigin ) {
 
-					// Jitter the camera ray by finding a new subpixel point to point to from the camera origin
-					// This is better than just jittering the camera position since it actually results in divergent
-					// rays providing better coverage for the pixel
-					{
+					vec2 ssd = vec2( 1.0 ) / resolution;
 
-						// TODO: the complexity here could be improved
-						vec3 cameraOrigin = ( cameraWorldMatrix * vec4( 0.0, 0.0, 0.0, 1.0 ) ).xyz;
-						vec3 ss00, ss01, ss10, temp;
-						ndcToCameraRay( vec2( - 1.0, - 1.0 ), cameraWorldMatrix, invProjectionMatrix, ss00, temp );
-						ndcToCameraRay( vec2( - 1.0, 1.0 ), cameraWorldMatrix, invProjectionMatrix, ss01, temp );
-						ndcToCameraRay( vec2( 1.0, - 1.0 ), cameraWorldMatrix, invProjectionMatrix, ss10, temp );
+					// 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 );
 
-						vec3 ssdX = ( ss10 - ss00 ) / resolution.x;
-						vec3 ssdY = ( ss01 - ss00 ) / resolution.y;
-						rayOrigin += tentFilter( rand() ) * ssdX + tentFilter( rand() ) * ssdY;
-						rayDirection = normalize( rayOrigin - cameraOrigin );
+					#if CAMERA_TYPE == 2
 
-					}
+						// Equirectangular projection
+
+						vec4 rayDirection4 = vec4( equirectUvToDirection( jitteredUv ), 0.0 );
+						vec4 rayOrigin4 = vec4( 0.0, 0.0, 0.0, 1.0 );
+
+						rayDirection4 = cameraWorldMatrix * rayDirection4;
+						rayOrigin4 = cameraWorldMatrix * rayOrigin4;
+
+						rayDirection = normalize( rayDirection4.xyz );
+						rayOrigin = rayOrigin4.xyz / rayOrigin4.w;
+
+					#else
+
+						// 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
+
+					#endif
 
 					#if FEATURE_DOF
 					{
@@ -2777,8 +4718,20 @@ float misHeuristic( float a, float b ) {
 
 					}
 					#endif
+
 					rayDirection = normalize( rayDirection );
 
+				}
+
+				void main() {
+
+					rng_initialize( gl_FragCoord.xy, seed );
+
+					vec3 rayDirection;
+					vec3 rayOrigin;
+
+					getCameraRay( rayDirection, rayOrigin );
+
 					// inverse environment rotation
 					mat3 invEnvironmentRotation = inverse( environmentRotation );
 
@@ -2795,15 +4748,56 @@ float misHeuristic( float a, float b ) {
 
 					// path tracing state
 					float accumulatedRoughness = 0.0;
+					float accumulatedClearcoatRoughness = 0.0;
 					bool transmissiveRay = true;
 					int transparentTraversals = TRANSPARENT_TRAVERSALS;
 					vec3 throughputColor = vec3( 1.0 );
 					SampleRec sampleRec;
 					int i;
+					bool isShadowRay = false;
 
 					for ( i = 0; i < bounces; i ++ ) {
 
-						if ( ! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
+						bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
+
+						LightSampleRec lightHit = lightsClosestHit( lights.tex, lights.count, rayOrigin, rayDirection );
+
+						if ( lightHit.hit && ( lightHit.dist < dist || !hit ) ) {
+
+							if ( i == 0 || transmissiveRay ) {
+
+								gl_FragColor.rgb += lightHit.emission * throughputColor;
+
+							} else {
+
+								#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 ) {
+
+									gl_FragColor.rgb += lightHit.emission * throughputColor;
+
+								} else {
+
+									// weight the contribution
+									float misWeight = misHeuristic( sampleRec.pdf, lightHit.pdf / float( lights.count + 1u ) );
+									gl_FragColor.rgb += lightHit.emission * throughputColor * misWeight;
+
+								}
+
+								#else
+
+								gl_FragColor.rgb += lightHit.emission * throughputColor;
+
+								#endif
+
+							}
+							break;
+
+						}
+
+						if ( ! hit ) {
 
 							if ( i == 0 || transmissiveRay ) {
 
@@ -2817,6 +4811,7 @@ float misHeuristic( float a, float b ) {
 								// get the PDF of the hit envmap point
 								vec3 envColor;
 								float envPdf = envMapSample( environmentRotation * rayDirection, envMapInfo, envColor );
+								envPdf /= float( lights.count + 1u );
 
 								// and weight the contribution
 								float misWeight = misHeuristic( sampleRec.pdf, envPdf );
@@ -2846,13 +4841,32 @@ float misHeuristic( float a, float b ) {
 
 						}
 
-						vec2 uv = textureSampleBarycoord( uvAttribute, barycoord, faceIndices.xyz ).xy;
+						// if we've determined that this is a shadow ray and we've hit an item with no shadow casting
+						// then skip it
+						if ( ! material.castShadow && isShadowRay ) {
+
+							vec3 point = rayOrigin + rayDirection * dist;
+							vec3 absPoint = abs( point );
+							float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+							rayOrigin = point - ( maxPoint + 1.0 ) * faceNormal * RAY_OFFSET;
+
+							continue;
 
+						}
+
+						vec2 uv = textureSampleBarycoord( uvAttribute, barycoord, faceIndices.xyz ).xy;
 						// albedo
 						vec4 albedo = vec4( material.color, material.opacity );
 						if ( material.map != - 1 ) {
 
-							albedo *= texture2D( textures, vec3( uv, material.map ) );
+							vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
+							albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+						}
+
+						// alphaMap
+						if ( material.alphaMap != -1 ) {
+
+							albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
 
 						}
 
@@ -2900,7 +4914,8 @@ float misHeuristic( float a, float b ) {
 						float roughness = material.roughness;
 						if ( material.roughnessMap != - 1 ) {
 
-							roughness *= texture2D( textures, vec3( uv, material.roughnessMap ) ).g;
+							vec3 uvPrime = material.roughnessMapTransform * vec3( uv, 1 );
+							roughness *= texture2D( textures, vec3( uvPrime.xy, material.roughnessMap ) ).g;
 
 						}
 
@@ -2908,7 +4923,8 @@ float misHeuristic( float a, float b ) {
 						float metalness = material.metalness;
 						if ( material.metalnessMap != - 1 ) {
 
-							metalness *= texture2D( textures, vec3( uv, material.metalnessMap ) ).b;
+							vec3 uvPrime = material.metalnessMapTransform * vec3( uv, 1 );
+							metalness *= texture2D( textures, vec3( uvPrime.xy, material.metalnessMap ) ).b;
 
 						}
 
@@ -2916,7 +4932,8 @@ float misHeuristic( float a, float b ) {
 						vec3 emission = material.emissiveIntensity * material.emissive;
 						if ( material.emissiveMap != - 1 ) {
 
-							emission *= texture2D( textures, vec3( uv, material.emissiveMap ) ).xyz;
+							vec3 uvPrime = material.emissiveMapTransform * vec3( uv, 1 );
+							emission *= texture2D( textures, vec3( uvPrime.xy, material.emissiveMap ) ).xyz;
 
 						}
 
@@ -2924,11 +4941,13 @@ float misHeuristic( float a, float b ) {
 						float transmission = material.transmission;
 						if ( material.transmissionMap != - 1 ) {
 
-							transmission *= texture2D( textures, vec3( uv, material.transmissionMap ) ).r;
+							vec3 uvPrime = material.transmissionMapTransform * vec3( uv, 1 );
+							transmission *= texture2D( textures, vec3( uvPrime.xy, material.transmissionMap ) ).r;
 
 						}
 
 						// normal
+						vec3 baseNormal = normal;
 						if ( material.normalMap != - 1 ) {
 
 							vec4 tangentSample = textureSampleBarycoord(
@@ -2945,7 +4964,8 @@ float misHeuristic( float a, float b ) {
 								vec3 bitangent = normalize( cross( normal, tangent ) * tangentSample.w );
 								mat3 vTBN = mat3( tangent, bitangent, normal );
 
-								vec3 texNormal = texture2D( textures, vec3( uv, material.normalMap ) ).xyz * 2.0 - 1.0;
+								vec3 uvPrime = material.normalMapTransform * vec3( uv, 1 );
+								vec3 texNormal = texture2D( textures, vec3( uvPrime.xy, material.normalMap ) ).xyz * 2.0 - 1.0;
 								texNormal.xy *= material.normalScale;
 								normal = vTBN * texNormal;
 
@@ -2955,6 +4975,110 @@ float misHeuristic( float a, float b ) {
 
 						normal *= side;
 
+						// clearcoat
+						float clearcoat = material.clearcoat;
+						if ( material.clearcoatMap != - 1 ) {
+
+							vec3 uvPrime = material.clearcoatMapTransform * vec3( uv, 1 );
+							clearcoat *= texture2D( textures, vec3( uvPrime.xy, material.clearcoatMap ) ).r;
+
+						}
+
+						// clearcoatRoughness
+						float clearcoatRoughness = material.clearcoatRoughness;
+						if ( material.clearcoatRoughnessMap != - 1 ) {
+
+							vec3 uvPrime = material.clearcoatRoughnessMapTransform * vec3( uv, 1 );
+							clearcoat *= texture2D( textures, vec3( uvPrime.xy, material.clearcoatRoughnessMap ) ).g;
+
+						}
+
+						// clearcoatNormal
+						vec3 clearcoatNormal = baseNormal;
+						if ( material.clearcoatNormalMap != - 1 ) {
+
+							vec4 tangentSample = textureSampleBarycoord(
+								tangentAttribute,
+								barycoord,
+								faceIndices.xyz
+							);
+
+							// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate
+							// resulting in NaNs and slow path tracing.
+							if ( length( tangentSample.xyz ) > 0.0 ) {
+
+								vec3 tangent = normalize( tangentSample.xyz );
+								vec3 bitangent = normalize( cross( clearcoatNormal, tangent ) * tangentSample.w );
+								mat3 vTBN = mat3( tangent, bitangent, clearcoatNormal );
+
+								vec3 uvPrime = material.clearcoatNormalMapTransform * vec3( uv, 1 );
+								vec3 texNormal = texture2D( textures, vec3( uvPrime.xy, material.clearcoatNormalMap ) ).xyz * 2.0 - 1.0;
+								texNormal.xy *= material.clearcoatNormalScale;
+								clearcoatNormal = vTBN * texNormal;
+
+							}
+
+						}
+
+						clearcoatNormal *= side;
+
+						// sheenColor
+						vec3 sheenColor = material.sheenColor;
+						if ( material.sheenColorMap != - 1 ) {
+
+							vec3 uvPrime = material.sheenColorMapTransform * vec3( uv, 1 );
+							sheenColor *= texture2D( textures, vec3( uvPrime.xy, material.sheenColorMap ) ).rgb;
+
+						}
+
+						// sheenRoughness
+						float sheenRoughness = material.sheenRoughness;
+						if ( material.sheenRoughnessMap != - 1 ) {
+
+							vec3 uvPrime = material.sheenRoughnessMapTransform * vec3( uv, 1 );
+							sheenRoughness *= texture2D( textures, vec3( uvPrime.xy, material.sheenRoughnessMap ) ).a;
+
+						}
+
+						// iridescence
+						float iridescence = material.iridescence;
+						if ( material.iridescenceMap != - 1 ) {
+
+							vec3 uvPrime = material.iridescenceMapTransform * vec3( uv, 1 );
+							iridescence *= texture2D( textures, vec3( uvPrime.xy, material.iridescenceMap ) ).r;
+
+						}
+
+						// iridescence thickness
+						float iridescenceThickness = material.iridescenceThicknessMaximum;
+						if ( material.iridescenceThicknessMap != - 1 ) {
+
+							vec3 uvPrime = material.iridescenceThicknessMapTransform * vec3( uv, 1 );
+							float iridescenceThicknessSampled = texture2D( textures, vec3( uvPrime.xy, material.iridescenceThicknessMap ) ).g;
+							iridescenceThickness = mix( material.iridescenceThicknessMinimum, material.iridescenceThicknessMaximum, iridescenceThicknessSampled );
+
+						}
+
+						iridescence = iridescenceThickness == 0.0 ? 0.0 : iridescence;
+
+						// specular color
+						vec3 specularColor = material.specularColor;
+						if ( material.specularColorMap != - 1 ) {
+
+							vec3 uvPrime = material.specularColorMapTransform * vec3( uv, 1 );
+							specularColor *= texture2D( textures, vec3( uvPrime.xy, material.specularColorMap ) ).rgb;
+
+						}
+
+						// specular intensity
+						float specularIntensity = material.specularIntensity;
+						if ( material.specularIntensityMap != - 1 ) {
+
+							vec3 uvPrime = material.specularIntensityMapTransform * vec3( uv, 1 );
+							specularIntensity *= texture2D( textures, vec3( uvPrime.xy, material.specularIntensityMap ) ).a;
+
+						}
+
 						SurfaceRec surfaceRec;
 						surfaceRec.normal = normal;
 						surfaceRec.faceNormal = faceNormal;
@@ -2964,27 +5088,38 @@ float misHeuristic( float a, float b ) {
 						surfaceRec.metalness = metalness;
 						surfaceRec.color = albedo.rgb;
 						surfaceRec.roughness = roughness;
+						surfaceRec.clearcoat = clearcoat;
+						surfaceRec.clearcoatRoughness = clearcoatRoughness;
+						surfaceRec.sheenColor = sheenColor;
+						surfaceRec.sheenRoughness = sheenRoughness;
+						surfaceRec.iridescence = iridescence;
+						surfaceRec.iridescenceIor = material.iridescenceIor;
+						surfaceRec.iridescenceThickness = iridescenceThickness;
+						surfaceRec.specularColor = specularColor;
+						surfaceRec.specularIntensity = specularIntensity;
 
 						// frontFace is used to determine transmissive properties and PDF. If no transmission is used
 						// then we can just always assume this is a front face.
 						surfaceRec.frontFace = side == 1.0 || transmission == 0.0;
 
-						// Compute the filtered roughness value to use during specular reflection computations. A minimum
-						// value of 1e-6 is needed because the GGX functions do not work with a roughness value of 0 and
-						// the accumulated roughness value is scaled by a user setting and a "magic value" of 5.0.
+						// Compute the filtered roughness value to use during specular reflection computations.
+						// The accumulated roughness value is scaled by a user setting and a "magic value" of 5.0.
 						// If we're exiting something transmissive then scale the factor down significantly so we can retain
 						// sharp internal reflections
-						surfaceRec.filteredRoughness = clamp(
-							max( surfaceRec.roughness, accumulatedRoughness * filterGlossyFactor * 5.0 ),
-							1e-3,
-							1.0
-						);
+						surfaceRec.filteredRoughness = clamp( max( surfaceRec.roughness, accumulatedRoughness * filterGlossyFactor * 5.0 ), 0.0, 1.0 );
+						surfaceRec.filteredClearcoatRoughness = clamp( max( surfaceRec.clearcoatRoughness, accumulatedClearcoatRoughness * filterGlossyFactor * 5.0 ), 0.0, 1.0 );
 
 						mat3 normalBasis = getBasisFromNormal( surfaceRec.normal );
 						mat3 invBasis = inverse( normalBasis );
 
+						mat3 clearcoatNormalBasis = getBasisFromNormal( clearcoatNormal );
+						mat3 clearcoatInvBasis = inverse( clearcoatNormalBasis );
+
 						vec3 outgoing = - normalize( invBasis * rayDirection );
-						sampleRec = bsdfSample( outgoing, surfaceRec );
+						vec3 clearcoatOutgoing = - normalize( clearcoatInvBasis * rayDirection );
+						sampleRec = bsdfSample( outgoing, clearcoatOutgoing, normalBasis, invBasis, clearcoatNormalBasis, clearcoatInvBasis, surfaceRec );
+
+						isShadowRay = sampleRec.specularPdf < rand();
 
 						// 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
@@ -2999,7 +5134,43 @@ float misHeuristic( float a, float b ) {
 
 						// direct env map sampling
 						#if FEATURE_MIS
-						{
+
+						// uniformly pick a light or environment map
+						if( rand() > 1.0 / float( lights.count + 1u ) ) {
+
+							// sample a light or environment
+							LightSampleRec lightSampleRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin );
+
+							bool isSampleBelowSurface = dot( faceNormal, lightSampleRec.direction ) < 0.0;
+							if ( isSampleBelowSurface ) {
+
+								lightSampleRec.pdf = 0.0;
+
+							}
+
+							// check if a ray could even reach the light area
+							if (
+								lightSampleRec.pdf > 0.0 &&
+								isDirectionValid( lightSampleRec.direction, normal, faceNormal ) &&
+								! anyCloserHit( bvh, rayOrigin, lightSampleRec.direction, lightSampleRec.dist )
+							) {
+
+								// get the material pdf
+								vec3 sampleColor;
+								float lightMaterialPdf = bsdfResult( outgoing, clearcoatOutgoing, normalize( invBasis * lightSampleRec.direction ), normalize( clearcoatInvBasis * lightSampleRec.direction ), surfaceRec, sampleColor );
+								bool isValidSampleColor = all( greaterThanEqual( sampleColor, vec3( 0.0 ) ) );
+								if ( lightMaterialPdf > 0.0 && isValidSampleColor ) {
+
+									// weight the direct light contribution
+									float lightPdf = lightSampleRec.pdf / float( lights.count + 1u );
+									float misWeight = misHeuristic( lightPdf, lightMaterialPdf );
+									gl_FragColor.rgb += lightSampleRec.emission * throughputColor * sampleColor * misWeight / lightPdf;
+
+								}
+
+							}
+
+						} else {
 
 							// find a sample in the environment map to include in the contribution
 							vec3 envColor, envDirection;
@@ -3021,15 +5192,17 @@ float misHeuristic( float a, float b ) {
 							if (
 								envPdf > 0.0 &&
 								isDirectionValid( envDirection, normal, faceNormal ) &&
-								! attenuateHit( bvh, rayOrigin, envDirection, bounces - i, attenuatedColor )
+								! attenuateHit( bvh, rayOrigin, envDirection, bounces - i, isShadowRay, attenuatedColor )
 							) {
 
 								// get the material pdf
 								vec3 sampleColor;
-								float envMaterialPdf = bsdfResult( outgoing, normalize( invBasis * envDirection ), surfaceRec, sampleColor );
-								if ( envMaterialPdf > 0.0 ) {
+								float envMaterialPdf = bsdfResult( outgoing, clearcoatOutgoing, normalize( invBasis * envDirection ), normalize( clearcoatInvBasis * envDirection ), surfaceRec, sampleColor );
+								bool isValidSampleColor = all( greaterThanEqual( sampleColor, vec3( 0.0 ) ) );
+								if ( envMaterialPdf > 0.0 && isValidSampleColor ) {
 
 									// weight the direct light contribution
+									envPdf /= float( lights.count + 1u );
 									float misWeight = misHeuristic( envPdf, envMaterialPdf );
 									gl_FragColor.rgb += attenuatedColor * environmentIntensity * envColor * throughputColor * sampleColor * misWeight / envPdf;
 
@@ -3046,7 +5219,11 @@ float misHeuristic( float a, float b ) {
 
 							// determine if this is a rough normal or not by checking how far off straight up it is
 							vec3 halfVector = normalize( outgoing + sampleRec.direction );
-							accumulatedRoughness += sin( acos( halfVector.z ) );
+							accumulatedRoughness += sin( acosApprox( halfVector.z ) );
+
+							vec3 clearcoatHalfVector = normalize( clearcoatOutgoing + sampleRec.clearcoatDirection );
+							accumulatedClearcoatRoughness += sin( acosApprox( clearcoatHalfVector.z ) );
+
 							transmissiveRay = false;
 
 						}
@@ -3090,7 +5267,11 @@ float misHeuristic( float a, float b ) {
 
 	exports.BlurredEnvMapGenerator = BlurredEnvMapGenerator;
 	exports.DynamicPathTracingSceneGenerator = DynamicPathTracingSceneGenerator;
+	exports.EquirectCamera = EquirectCamera;
 	exports.EquirectHdrInfoUniform = EquirectHdrInfoUniform;
+	exports.IESLoader = IESLoader;
+	exports.IESProfilesTexture = IESProfilesTexture;
+	exports.LightsInfoUniformStruct = LightsInfoUniformStruct;
 	exports.MaterialBase = MaterialBase;
 	exports.MaterialReducer = MaterialReducer;
 	exports.MaterialsTexture = MaterialsTexture;
@@ -3099,10 +5280,13 @@ float misHeuristic( float a, float b ) {
 	exports.PhysicalCamera = PhysicalCamera;
 	exports.PhysicalCameraUniform = PhysicalCameraUniform;
 	exports.PhysicalPathTracingMaterial = PhysicalPathTracingMaterial;
+	exports.PhysicalSpotLight = PhysicalSpotLight;
 	exports.RenderTarget2DArray = RenderTarget2DArray;
+	exports.ShapedAreaLight = ShapedAreaLight;
 	exports.getGroupMaterialIndicesAttribute = getGroupMaterialIndicesAttribute;
 	exports.mergeMeshes = mergeMeshes;
 	exports.setCommonAttributes = setCommonAttributes;
+	exports.shaderLightStruct = shaderLightStruct;
 	exports.shaderMaterialSampling = shaderMaterialSampling;
 	exports.shaderMaterialStructs = shaderMaterialStructs;
 	exports.shaderUtils = shaderUtils;