three-gpu-pathtracer 0.0.1

package/build/index.umd.cjs

@@ -0,0 +1,1840 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('three'), require('three/examples/jsm/postprocessing/Pass.js'), require('three-mesh-bvh'), require('three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js'), require('three/examples/jsm/utils/BufferGeometryUtils.js')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'three', 'three/examples/jsm/postprocessing/Pass.js', 'three-mesh-bvh', 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js', 'three/examples/jsm/utils/BufferGeometryUtils.js'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ThreePathTracer = global.ThreePathTracer || {}, global.THREE, global.THREE, global.MeshBVHLib, global.MeshBVHLib, global.THREE));
+})(this, (function (exports, three, Pass_js, threeMeshBvh, GenerateMeshBVHWorker_js, BufferGeometryUtils_js) { 'use strict';
+
+	function* renderTask() {
+
+		const { _fsQuad, _renderer, target, camera, material } = this;
+		while ( true ) {
+
+			material.opacity = 1 / ( this.samples + 1 );
+			material.seed ++;
+
+			const w = target.width;
+			const h = target.height;
+			camera.setViewOffset(
+				w, h,
+				Math.random() - 0.5, Math.random() - 0.5,
+				w, h,
+			);
+			camera.updateProjectionMatrix();
+
+			const tx = this.tiles.x || 1;
+			const ty = this.tiles.y || 1;
+			const totalTiles = tx * ty;
+			const dprInv = ( 1 / _renderer.getPixelRatio() );
+			for ( let y = 0; y < ty; y ++ ) {
+
+				for ( let x = 0; x < tx; x ++ ) {
+
+					material.cameraWorldMatrix.copy( camera.matrixWorld );
+					material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
+
+					const ogRenderTarget = _renderer.getRenderTarget();
+					const ogAutoClear = _renderer.autoClear;
+
+					// three.js renderer takes values relative to the current pixel ratio
+					_renderer.setRenderTarget( target );
+					_renderer.setScissorTest( true );
+					_renderer.setScissor(
+						dprInv * Math.ceil( x * w / tx ),
+						dprInv * Math.ceil( ( ty - y - 1 ) * h / ty ),
+						dprInv * Math.ceil( w / tx ),
+						dprInv * Math.ceil( h / ty ) );
+					_renderer.autoClear = false;
+					_fsQuad.render( _renderer );
+
+					_renderer.setScissorTest( false );
+					_renderer.setRenderTarget( ogRenderTarget );
+					_renderer.autoClear = ogAutoClear;
+
+					this.samples += ( 1 / totalTiles );
+
+					yield;
+
+				}
+
+			}
+
+			this.samples = Math.round( this.samples );
+
+		}
+
+	}
+
+	const ogClearColor = new three.Color();
+	class PathTracingRenderer {
+
+		get material() {
+
+			return this._fsQuad.material;
+
+		}
+
+		set material( v ) {
+
+			this._fsQuad.material = v;
+
+		}
+
+		constructor( renderer ) {
+
+			this.camera = null;
+			this.tiles = new three.Vector2( 1, 1 );
+			this.target = new three.WebGLRenderTarget( 1, 1, {
+				format: three.RGBAFormat,
+				type: three.FloatType,
+			} );
+			this.samples = 0;
+			this.stableNoise = false;
+			this._renderer = renderer;
+			this._fsQuad = new Pass_js.FullScreenQuad( null );
+			this._task = null;
+
+		}
+
+		setSize( w, h ) {
+
+			this.target.setSize( w, h );
+			this.reset();
+
+		}
+
+		reset() {
+
+			const renderer = this._renderer;
+			const target = this.target;
+			const ogRenderTarget = renderer.getRenderTarget();
+			const ogClearAlpha = renderer.getClearAlpha();
+			renderer.getClearColor( ogClearColor );
+
+			renderer.setRenderTarget( target );
+			renderer.setClearColor( 0, 0 );
+			renderer.clearColor();
+
+			renderer.setClearColor( ogClearColor, ogClearAlpha );
+			renderer.setRenderTarget( ogRenderTarget );
+
+			this.samples = 0;
+			this._task = null;
+
+			if ( this.stableNoise ) {
+
+				this.material.seed = 0;
+
+			}
+
+		}
+
+		update() {
+
+			if ( ! this._task ) {
+
+				this._task = renderTask.call( this );
+
+			}
+
+			this._task.next();
+
+		}
+
+	}
+
+	function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
+
+		if ( ! Array.isArray( materials ) ) {
+
+			materials = [ materials ];
+
+		}
+
+		const vertCount = geometry.attributes.position.count;
+		const materialArray = new Uint8Array( vertCount );
+		let groups = geometry.groups;
+		if ( groups.length === 0 ) {
+
+			groups = [ { count: vertCount, start: 0, materialIndex: 0 } ];
+
+		}
+
+		for ( let i = 0; i < groups.length; i ++ ) {
+
+			const group = groups[ i ];
+			const { count, start } = group;
+			const endCount = Math.min( count, vertCount - start );
+			const mat = materials[ group.materialIndex ];
+			const materialIndex = allMaterials.indexOf( mat );
+
+			for ( let j = 0; j < endCount; j ++ ) {
+
+				materialArray[ start + j ] = materialIndex;
+
+			}
+
+		}
+
+		return new three.BufferAttribute( materialArray, 1, false );
+
+	}
+
+	function mergeMeshes( meshes, options = {} ) {
+
+		options = { attributes: null, cloneGeometry: true, ...options };
+
+		const transformedGeometry = [];
+		const materialSet = new Set();
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+			// save any materials
+			const mesh = meshes[ i ];
+			if ( mesh.visible === false ) continue;
+
+			if ( Array.isArray( mesh.material ) ) {
+
+				mesh.material.forEach( m => materialSet.add( m ) );
+
+			} else {
+
+				materialSet.add( mesh.material );
+
+			}
+
+		}
+
+		const materials = Array.from( materialSet );
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+			// ensure the matrix world is up to date
+			const mesh = meshes[ i ];
+			if ( mesh.visible === false ) continue;
+
+			mesh.updateMatrixWorld();
+
+			// apply the matrix world to the geometry
+			const originalGeometry = meshes[ i ].geometry;
+			let geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
+			geometry.applyMatrix4( mesh.matrixWorld );
+
+			const attrs = options.attributes;
+			if ( ! geometry.attributes.normal && ( attrs && attrs.includes( 'normal' ) ) ) {
+
+				geometry.computeVertexNormals();
+
+			}
+
+			if ( ! geometry.attributes.uv && ( attrs && attrs.includes( 'uv' ) ) ) {
+
+				const vertCount = geometry.attributes.position.count;
+				geometry.setAttribute( 'uv', new three.BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+			}
+
+			if ( ! geometry.attributes.tangent && ( attrs && attrs.includes( 'tangent' ) ) ) {
+
+				if ( mesh.material.normalMap ) {
+
+					// computeTangents requires an index buffer
+					if ( geometry.index === null ) {
+
+						geometry = BufferGeometryUtils_js.mergeVertices( geometry );
+
+					}
+
+					geometry.computeTangents();
+
+				} else {
+
+					const vertCount = geometry.attributes.position.count;
+					geometry.setAttribute( 'tangent', new three.BufferAttribute( new Float32Array( vertCount * 4 ), 4, false ) );
+
+				}
+
+			}
+
+			if ( ! geometry.index ) {
+
+				// TODO: compute a typed array
+				const indexCount = geometry.attributes.position.count;
+				const array = new Array( indexCount );
+				for ( let i = 0; i < indexCount; i ++ ) {
+
+					array[ i ] = i;
+
+				}
+
+				geometry.setIndex( array );
+
+			}
+
+			// trim any unneeded attributes
+			if ( options.attributes ) {
+
+				for ( const key in geometry.attributes ) {
+
+					if ( ! options.attributes.includes( key ) ) {
+
+						geometry.deleteAttribute( key );
+
+					}
+
+				}
+
+			}
+
+			// create the material index attribute
+			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
+			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+
+			transformedGeometry.push( geometry );
+
+		}
+
+		const textureSet = new Set();
+		materials.forEach( material => {
+
+			for ( const key in material ) {
+
+				const value = material[ key ];
+				if ( value && value.isTexture ) {
+
+					textureSet.add( value );
+
+				}
+
+			}
+
+		} );
+
+		const geometry = BufferGeometryUtils_js.mergeBufferGeometries( transformedGeometry, false );
+		const textures = Array.from( textureSet );
+		return { geometry, materials, textures };
+
+	}
+
+	class PathTracingSceneGenerator {
+
+		constructor() {
+
+			this.bvhGenerator = new GenerateMeshBVHWorker_js.GenerateMeshBVHWorker();
+
+		}
+
+		async generate( scene, options = {} ) {
+
+			const { bvhGenerator } = this;
+			const meshes = [];
+
+			scene.traverse( c => {
+
+				if ( c.isMesh ) {
+
+					meshes.push( c );
+
+				}
+
+			} );
+
+			const { geometry, materials, textures } = mergeMeshes( meshes, { attributes: [ 'position', 'normal', 'tangent', 'uv' ] } );
+			const bvhPromise = bvhGenerator.generate( geometry, { strategy: threeMeshBvh.SAH, ...options, maxLeafTris: 1 } );
+
+			return {
+				scene,
+				materials,
+				textures,
+				bvh: await bvhPromise,
+			};
+
+		}
+
+		dispose() {
+
+			this.bvhGenerator.terminate();
+
+		}
+
+	}
+
+	// https://github.com/gkjohnson/webxr-sandbox/blob/main/skinned-mesh-batching/src/MaterialReducer.js
+
+	function isTypedArray( arr ) {
+
+		return arr.buffer instanceof ArrayBuffer && 'BYTES_PER_ELEMENT' in arr;
+
+	}
+
+	class MaterialReducer {
+
+		constructor() {
+
+			const ignoreKeys = new Set();
+			ignoreKeys.add( 'uuid' );
+
+			this.ignoreKeys = ignoreKeys;
+			this.shareTextures = true;
+			this.textures = [];
+			this.materials = [];
+
+		}
+
+		areEqual( objectA, objectB ) {
+
+			const keySet = new Set();
+			const traverseSet = new Set();
+			const ignoreKeys = this.ignoreKeys;
+
+			const traverse = ( a, b ) => {
+
+				if ( a === b ) {
+
+					return true;
+
+				}
+
+				if ( a && b && a instanceof Object && b instanceof Object ) {
+
+					if ( traverseSet.has( a ) || traverseSet.has( b ) ) {
+
+						throw new Error( 'MaterialReducer: Material is recursive.' );
+
+					}
+
+					const aIsElement = a instanceof Element;
+					const bIsElement = b instanceof Element;
+					if ( aIsElement || bIsElement ) {
+
+						if ( aIsElement !== bIsElement || ! ( a instanceof Image ) || ! ( b instanceof Image ) ) {
+
+							return false;
+
+						}
+
+						return a.src === b.src;
+
+					}
+
+					const aIsImageBitmap = a instanceof ImageBitmap;
+					const bIsImageBitmap = b instanceof ImageBitmap;
+					if ( aIsImageBitmap || bIsImageBitmap ) {
+
+						return false;
+
+					}
+
+					if ( a.equals ) {
+
+						return a.equals( b );
+
+					}
+
+					const aIsTypedArray = isTypedArray( a );
+					const bIsTypedArray = isTypedArray( b );
+					if ( aIsTypedArray || bIsTypedArray ) {
+
+						if ( aIsTypedArray !== bIsTypedArray || a.constructor !== b.constructor || a.length !== b.length ) {
+
+							return false;
+
+						}
+
+						for ( let i = 0, l = a.length; i < l; i ++ ) {
+
+							if ( a[ i ] !== b[ i ] ) return false;
+
+						}
+
+						return true;
+
+					}
+
+					traverseSet.add( a );
+					traverseSet.add( b );
+
+					keySet.clear();
+					for ( const key in a ) {
+
+						if ( ! a.hasOwnProperty( key ) || a[ key ] instanceof Function || ignoreKeys.has( key ) ) {
+
+							continue;
+
+						}
+
+						keySet.add( key );
+
+					}
+
+					for ( const key in b ) {
+
+						if ( ! b.hasOwnProperty( key ) || b[ key ] instanceof Function || ignoreKeys.has( key ) ) {
+
+							continue;
+
+						}
+
+						keySet.add( key );
+
+					}
+
+					const keys = Array.from( keySet.values() );
+					let result = true;
+					for ( const i in keys ) {
+
+						const key = keys[ i ];
+						if ( ignoreKeys.has( key ) ) {
+
+							continue;
+
+						}
+
+						result = traverse( a[ key ], b[ key ] );
+						if ( ! result ) {
+
+							break;
+
+						}
+
+					}
+
+					traverseSet.delete( a );
+					traverseSet.delete( b );
+					return result;
+
+				}
+
+				return false;
+
+			};
+
+			return traverse( objectA, objectB );
+
+		}
+
+		process( object ) {
+
+			const { textures, materials } = this;
+			let replaced = 0;
+
+			const processMaterial = material => {
+
+				// Check if another material matches this one
+				let foundMaterial = null;
+				for ( const i in materials ) {
+
+					const otherMaterial = materials[ i ];
+					if ( this.areEqual( material, otherMaterial ) ) {
+
+						foundMaterial = otherMaterial;
+
+					}
+
+				}
+
+				if ( foundMaterial ) {
+
+					replaced ++;
+					return foundMaterial;
+
+				} else {
+
+					materials.push( material );
+
+					if ( this.shareTextures ) {
+
+						// See if there's another texture that matches the ones on this material
+						for ( const key in material ) {
+
+							if ( ! material.hasOwnProperty( key ) ) continue;
+
+							const value = material[ key ];
+							if ( value && value.isTexture && value.image instanceof Image ) {
+
+								let foundTexture = null;
+								for ( const i in textures ) {
+
+									const texture = textures[ i ];
+									if ( this.areEqual( texture, value ) ) {
+
+										foundTexture = texture;
+										break;
+
+									}
+
+								}
+
+								if ( foundTexture ) {
+
+									material[ key ] = foundTexture;
+
+								} else {
+
+									textures.push( value );
+
+								}
+
+							}
+
+						}
+
+					}
+
+					return material;
+
+				}
+
+			};
+
+			object.traverse( c => {
+
+				if ( c.isMesh && c.material ) {
+
+					const material = c.material;
+					if ( Array.isArray( material ) ) {
+
+						for ( let i = 0; i < material.length; i ++ ) {
+
+							material[ i ] = processMaterial( material[ i ] );
+
+						}
+
+					} else {
+
+						c.material = processMaterial( material );
+
+					}
+
+				}
+
+			} );
+
+			return { replaced, retained: materials.length };
+
+		}
+
+	}
+
+	class MaterialStructUniform {
+
+		constructor() {
+
+			this.init();
+
+		}
+
+		init() {
+
+			this.color = new three.Color( 0xffffff );
+			this.map = - 1;
+
+			this.metalness = 1.0;
+			this.metalnessMap = - 1;
+
+			this.roughness = 1.0;
+			this.roughnessMap = - 1;
+
+			this.ior = 1.0;
+			this.transmission = 0.0;
+			this.transmissionMap = - 1;
+
+			this.emissive = new three.Color( 0 );
+			this.emissiveIntensity = 1.0;
+			this.emissiveMap = - 1;
+
+			this.normalMap = - 1;
+			this.normalScale = new three.Vector2( 1, 1 );
+
+			this.opacity = 1.0;
+			this.alphaTest = 0.0;
+
+			// TODO: Clearcoat
+
+			// TODO: Sheen
+
+		}
+
+		updateFrom( material, textures = [] ) {
+
+			this.init();
+
+			// color
+			if ( 'color' in material ) this.color.copy( material.color );
+			else material.color.set( 0xffffff );
+
+			this.map = textures.indexOf( material.map );
+
+			// metalness
+			if ( 'metalness' in material ) this.metalness = material.metalness;
+			else this.metalness = 1.0;
+
+			this.metalnessMap = textures.indexOf( material.metalnessMap );
+
+			// roughness
+			if ( 'roughness' in material ) this.roughness = material.roughness;
+			else this.roughness = 1.0;
+
+			this.roughnessMap = textures.indexOf( material.roughnessMap );
+
+			// transmission
+			if ( 'ior' in material ) this.ior = material.ior;
+			else this.ior = 1.0;
+
+			if ( 'transmission' in material ) this.transmission = material.transmission;
+			else this.transmission = 0.0;
+
+			if ( 'transmissionMap' in material ) this.transmissionMap = textures.indexOf( material.transmissionMap );
+
+			// emission
+			if ( 'emissive' in material ) this.emissive.copy( material.emissive );
+			else this.emissive.set( 0 );
+
+			if ( 'emissiveIntensity' in material ) this.emissiveIntensity = material.emissiveIntensity;
+			else this.emissiveIntensity = 1.0;
+
+			this.emissiveMap = textures.indexOf( material.emissiveMap );
+
+			// normals
+			this.normalMap = textures.indexOf( material.normalMap );
+			if ( 'normalScale' in material ) this.normalScale.copy( material.normalScale );
+			else this.normalScale.set( 1, 1 );
+
+			// opacity
+			this.opacity = material.opacity;
+
+			// alpha test
+			this.alphaTest = material.alphaTest;
+
+		}
+
+	}
+
+	class MaterialStructArrayUniform extends Array {
+
+		updateFrom( materials, textures ) {
+
+			while ( this.length > materials.length ) this.pop();
+			while ( this.length < materials.length ) this.push( new MaterialStructUniform() );
+
+			for ( let i = 0, l = this.length; i < l; i ++ ) {
+
+				this[ i ].updateFrom( materials[ i ], textures );
+
+			}
+
+		}
+
+	}
+
+	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
+			const depth = textures.length;
+			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();
+
+		}
+
+	}
+
+	class MaterialBase extends three.ShaderMaterial {
+
+		constructor( shader ) {
+
+			super( shader );
+
+			for ( const key in this.uniforms ) {
+
+				Object.defineProperty( this, key, {
+
+					get() {
+
+						return this.uniforms[ key ].value;
+
+					},
+
+					set( v ) {
+
+						this.uniforms[ key ].value = v;
+
+					}
+
+				} );
+
+			}
+
+		}
+
+		// sets the given named define value and sets "needsUpdate" to true if it's different
+		setDefine( name, value = undefined ) {
+
+			if ( value === undefined || value === null ) {
+
+				if ( name in this.defines ) {
+
+					delete this.defines[ name ];
+					this.needsUpdate = true;
+
+				}
+
+			} else {
+
+				if ( this.defines[ name ] !== value ) {
+
+					this.defines[ name ] = value;
+					this.needsUpdate = true;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	const shaderMaterialStructs = /* glsl */ `
+
+	struct Material {
+
+		vec3 color;
+		int map;
+
+		float metalness;
+		int metalnessMap;
+
+		float roughness;
+		int roughnessMap;
+
+		float ior;
+		float transmission;
+		int transmissionMap;
+
+		vec3 emissive;
+		float emissiveIntensity;
+		int emissiveMap;
+
+		int normalMap;
+		vec2 normalScale;
+
+		float opacity;
+		float alphaTest;
+
+	};
+
+`;
+
+	const shaderGGXFunctions = /* glsl */`
+// The GGX functions provide sampling and distribution information for normals as output so
+// in order to get probability of scatter direction the half vector must be computed and provided.
+// [0] https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
+// [1] https://hal.archives-ouvertes.fr/hal-01509746/document
+// [2] http://jcgt.org/published/0007/04/01/
+// [4] http://jcgt.org/published/0003/02/03/
+
+// trowbridge-reitz === GGX === GTR
+
+vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float random1, float random2 ) {
+
+	// TODO: try GGXVNDF implementation from reference [2], here. Needs to update ggxDistribution
+	// function below, as well
+
+	// Implementation from reference [1]
+	// stretch view
+	vec3 V = normalize( vec3( roughnessX * incidentDir.x, roughnessY * incidentDir.y, incidentDir.z ) );
+
+	// orthonormal basis
+	vec3 T1 = ( V.z < 0.9999 ) ? normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) ) : vec3( 1.0, 0.0, 0.0 );
+	vec3 T2 = cross( T1, V );
+
+	// sample point with polar coordinates (r, phi)
+	float a = 1.0 / ( 1.0 + V.z );
+	float r = sqrt( random1 );
+	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
+	float P1 = r * cos( phi );
+	float P2 = r * sin( phi ) * ( ( random2 < a ) ? 1.0 : V.z );
+
+	// compute normal
+	vec3 N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );
+
+	// unstretch
+	N = normalize( vec3( roughnessX * N.x, roughnessY * N.y, max( 0.0, N.z ) ) );
+
+	return N;
+
+}
+
+// Below are PDF and related functions for use in a Monte Carlo path tracer
+// as specified in Appendix B of the following paper
+// See equation (2) from reference [2]
+float ggxLamda( float theta, float roughness ) {
+
+	float tanTheta = tan( theta );
+	float tanTheta2 = tanTheta * tanTheta;
+	float alpha2 = roughness * roughness;
+
+	float numerator = - 1.0 + sqrt( 1.0 + alpha2 * tanTheta2 );
+	return numerator / 2.0;
+
+}
+
+// See equation (2) from reference [2]
+float ggxShadowMaskG1( float theta, float roughness ) {
+
+	return 1.0 / ( 1.0 + ggxLamda( theta, roughness ) );
+
+}
+
+// See equation (125) from reference [4]
+float ggxShadowMaskG2( vec3 wi, vec3 wo, float roughness ) {
+
+	float incidentTheta = acos( wi.z );
+	float scatterTheta = acos( wo.z );
+	return 1.0 / ( 1.0 + ggxLamda( incidentTheta, roughness ) + ggxLamda( scatterTheta, roughness ) );
+
+}
+
+float ggxDistribution( vec3 halfVector, float roughness ) {
+
+	// See equation (33) from reference [0]
+	float a2 = roughness * roughness;
+	float cosTheta = halfVector.z;
+	float cosTheta4 = pow( cosTheta, 4.0 );
+
+	if ( cosTheta == 0.0 ) return 0.0;
+
+	float theta = acos( halfVector.z );
+	float tanTheta = tan( theta );
+	float tanTheta2 = pow( tanTheta, 2.0 );
+
+	float denom = PI * cosTheta4 * pow( a2 + tanTheta2, 2.0 );
+	return a2 / denom;
+
+	// See equation (1) from reference [2]
+	// const { x, y, z } = halfVector;
+	// const a2 = roughness * roughness;
+	// const mult = x * x / a2 + y * y / a2 + z * z;
+	// const mult2 = mult * mult;
+
+	// return 1.0 / Math.PI * a2 * mult2;
+
+}
+
+// See equation (3) from reference [2]
+float ggxPDF( vec3 wi, vec3 halfVector, float roughness ) {
+
+	float incidentTheta = acos( wi.z );
+	float D = ggxDistribution( halfVector, roughness );
+	float G1 = ggxShadowMaskG1( incidentTheta, roughness );
+
+	return D * G1 * max( 0.0, dot( wi, halfVector ) ) / wi.z;
+
+}
+`;
+
+	const shaderMaterialSampling = /* glsl */`
+
+struct SurfaceRec {
+	vec3 normal;
+	vec3 faceNormal;
+	bool frontFace;
+	float roughness;
+	float filteredRoughness;
+	float metalness;
+	vec3 color;
+	vec3 emission;
+	float transmission;
+	float ior;
+};
+
+struct SampleRec {
+	float pdf;
+	vec3 direction;
+	vec3 color;
+};
+
+${ shaderGGXFunctions }
+
+// diffuse
+float diffusePDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
+	float cosValue = wi.z;
+	return cosValue / PI;
+
+}
+
+vec3 diffuseDirection( vec3 wo, SurfaceRec surf ) {
+
+	vec3 lightDirection = randDirection();
+	lightDirection.z += 1.0;
+	lightDirection = normalize( lightDirection );
+
+	return lightDirection;
+
+}
+
+vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// TODO: scale by 1 - F here
+	// note on division by PI
+	// https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
+	float metalFactor = ( 1.0 - surf.metalness ) * wi.z / ( PI * PI );
+	float transmissionFactor = 1.0 - surf.transmission;
+	return surf.color * metalFactor * transmissionFactor;
+
+}
+
+// specular
+float specularPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// See equation (17) in http://jcgt.org/published/0003/02/03/
+	float filteredRoughness = surf.filteredRoughness;
+	vec3 halfVector = getHalfVector( wi, wo );
+	return ggxPDF( wi, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+}
+
+vec3 specularDirection( vec3 wo, SurfaceRec surf ) {
+
+	// sample ggx vndf distribution which gives a new normal
+	float filteredRoughness = surf.filteredRoughness;
+	vec3 halfVector = ggxDirection(
+		wo,
+		filteredRoughness,
+		filteredRoughness,
+		rand(),
+		rand()
+	);
+
+	// apply to new ray by reflecting off the new normal
+	return - reflect( wo, halfVector );
+
+}
+
+vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// if roughness is set to 0 then D === NaN which results in black pixels
+	float metalness = surf.metalness;
+	float ior = surf.ior;
+	bool frontFace = surf.frontFace;
+	float filteredRoughness = surf.filteredRoughness;
+
+	vec3 halfVector = getHalfVector( wo, wi );
+	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
+	float D = ggxDistribution( halfVector, filteredRoughness );
+
+	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;
+
+	}
+
+	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 *= wi.z; // scale the light by the direction the light is coming in from
+
+	return color;
+
+}
+
+/*
+// transmission
+function transmissionPDF( wo, wi, material, surf ) {
+
+	// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
+
+	const { roughness, ior } = material;
+	const { frontFace } = hit;
+	const ratio = frontFace ? ior : 1 / ior;
+	const minRoughness = Math.max( roughness, MIN_ROUGHNESS );
+
+	halfVector.set( 0, 0, 0 ).addScaledVector( wi, ratio ).addScaledVector( wo, 1.0 ).normalize().multiplyScalar( - 1 );
+
+	const denom = Math.pow( ratio * halfVector.dot( wi ) + 1.0 * halfVector.dot( wo ), 2.0 );
+	return ggxPDF( wo, halfVector, minRoughness ) / denom;
+
+}
+
+function transmissionDirection( wo, hit, material, lightDirection ) {
+
+	const { roughness, ior } = material;
+	const { frontFace } = hit;
+	const ratio = frontFace ? 1 / ior : ior;
+	const minRoughness = Math.max( roughness, MIN_ROUGHNESS );
+
+	// sample ggx vndf distribution which gives a new normal
+	ggxDirection(
+		wo,
+		minRoughness,
+		minRoughness,
+		Math.random(),
+		Math.random(),
+		halfVector,
+	);
+
+	// apply to new ray by reflecting off the new normal
+	tempDir.copy( wo ).multiplyScalar( - 1 );
+	refract( tempDir, halfVector, ratio, lightDirection );
+
+}
+
+function transmissionColor( wo, wi, material, hit, colorTarget ) {
+
+	const { metalness, transmission } = material;
+	colorTarget
+		.copy( material.color )
+		.multiplyScalar( ( 1.0 - metalness ) * wo.z )
+		.multiplyScalar( transmission );
+
+}
+*/
+
+// TODO: This is just using a basic cosine-weighted specular distribution with an
+// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
+float transmissionPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = surf.ior;
+	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 ) {
+
+		return 0.0;
+
+	}
+
+	return 1.0 / ( 1.0 - reflectance );
+
+}
+
+vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
+
+	float roughness = surf.roughness;
+	float ior = surf.ior;
+	bool frontFace = surf.frontFace;
+	float ratio = frontFace ? 1.0 / ior : ior;
+
+	vec3 lightDirection = refract( - wo, vec3( 0.0, 0.0, 1.0 ), ratio );
+	lightDirection += randDirection() * roughness;
+	return normalize( lightDirection );
+
+}
+
+vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+
+	vec3 color = surf.color;
+	color *= ( 1.0 - metalness );
+	color *= transmission;
+
+	return color;
+
+}
+
+float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	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;
+
+	if ( wi.z < 0.0 ) {
+
+		tpdf = transmissionPDF( wo, wi, surf );
+
+	} 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;
+
+}
+
+vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	vec3 color = vec3( 0.0 );
+	if ( wi.z < 0.0 ) {
+
+		color = transmissionColor( wo, wi, surf );
+
+	} else {
+
+		color = diffuseColor( wo, wi, surf );
+		color *= 1.0 - surf.transmission;
+
+		color += specularColor( wo, wi, surf );
+
+	}
+
+	return color;
+
+}
+
+SampleRec bsdfSample( vec3 wo, SurfaceRec surf ) {
+
+	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;
+
+	}
+
+	SampleRec result;
+	if ( rand() < transmission ) {
+
+		float specularProb = mix( reflectance, 1.0, metalness );
+		if ( rand() < specularProb ) {
+
+			result.direction = specularDirection( wo, surf );
+
+		} else {
+
+			result.direction = transmissionDirection( wo, surf );
+
+		}
+
+	} else {
+
+		float specularProb = 0.5 + 0.5 * metalness;
+		if ( rand() < specularProb ) {
+
+			result.direction = specularDirection( wo, surf );
+
+		} else {
+
+			result.direction = diffuseDirection( wo, surf );
+
+		}
+
+	}
+
+	result.pdf = bsdfPdf( wo, result.direction, surf );
+	result.color = bsdfColor( wo, result.direction, surf );
+	return result;
+
+}
+`;
+
+	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 );
+
+	}
+
+	// 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
+		float sign = n.z == 0.0 ? 1.0 : sign( n.z );
+		float a = - 1.0 / ( sign + n.z );
+		float b = n.x * n.y * a;
+		vec3 b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );
+		vec3 b2 = vec3( b, sign + n.y * n.y * a, - n.y );
+
+		float r = sqrt( uv.x );
+		float theta = 2.0 * PI * uv.y;
+		float x = r * cos( theta );
+		float y = r * sin( theta );
+		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;
+
+	}
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 s0;
+
+	void rng_initialize(vec2 p, int frame) {
+
+		// white noise seed
+		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
+
+	}
+
+	// https://www.pcg-random.org/
+	void pcg4d( inout uvec4 v ) {
+
+		v = v * 1664525u + 1013904223u;
+		v.x += v.y * v.w;
+		v.y += v.z * v.x;
+		v.z += v.x * v.y;
+		v.w += v.y * v.z;
+		v = v ^ ( v >> 16u );
+		v.x += v.y*v.w;
+		v.y += v.z*v.x;
+		v.z += v.x*v.y;
+		v.w += v.y*v.z;
+
+	}
+
+	float rand() {
+
+		pcg4d(s0);
+		return float( s0.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( s0 );
+		return vec2( s0.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d(s0);
+		return vec3( s0.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d(s0);
+		return vec4(s0)/float(0xffffffffu);
+
+	}
+
+	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
+	vec3 randDirection() {
+
+		vec2 r = rand2();
+		float u = ( r.x - 0.5 ) * 2.0;
+		float t = r.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
+
+		return vec3( f * cos( t ), f * sin( t ), u );
+
+	}
+`;
+
+	class PhysicalPathTracingMaterial extends MaterialBase {
+
+		// three.js relies on this field to add env map functions and defines
+		get envMap() {
+
+			return this.environmentMap;
+
+		}
+
+		constructor( parameters ) {
+
+			super( {
+
+				transparent: true,
+				depthWrite: false,
+
+				defines: {
+					BOUNCES: 3,
+					TRANSPARENT_TRAVERSALS: 5,
+					MATERIAL_LENGTH: 0,
+					GRADIENT_BG: 0,
+				},
+
+				uniforms: {
+					bvh: { value: new threeMeshBvh.MeshBVHUniformStruct() },
+					normalAttribute: { value: new threeMeshBvh.FloatVertexAttributeTexture() },
+					tangentAttribute: { value: new threeMeshBvh.FloatVertexAttributeTexture() },
+					uvAttribute: { value: new threeMeshBvh.FloatVertexAttributeTexture() },
+					materialIndexAttribute: { value: new threeMeshBvh.UIntVertexAttributeTexture() },
+					materials: { value: new MaterialStructArrayUniform() },
+					textures: { value: new RenderTarget2DArray().texture },
+					cameraWorldMatrix: { value: new three.Matrix4() },
+					invProjectionMatrix: { value: new three.Matrix4() },
+					environmentBlur: { value: 0.2 },
+					environmentIntensity: { value: 2.0 },
+					environmentMap: { value: null },
+					environmentRotation: { value: new three.Matrix3() },
+					seed: { value: 0 },
+					opacity: { value: 1 },
+					filterGlossyFactor: { value: 0.0 },
+
+					gradientTop: { value: new three.Color( 0xbfd8ff ) },
+					gradientBottom: { value: new three.Color( 0xffffff ) },
+
+					bgGradientTop: { value: new three.Color( 0x111111 ) },
+					bgGradientBottom: { value: new three.Color( 0x000000 ) },
+				},
+
+				vertexShader: /* glsl */`
+
+				varying vec2 vUv;
+				void main() {
+
+					vec4 mvPosition = vec4( position, 1.0 );
+					mvPosition = modelViewMatrix * mvPosition;
+					gl_Position = projectionMatrix * mvPosition;
+
+					vUv = uv;
+
+				}
+
+			`,
+
+				fragmentShader: /* glsl */`
+				#define RAY_OFFSET 1e-5
+
+				precision highp isampler2D;
+				precision highp usampler2D;
+				precision highp sampler2DArray;
+				vec4 envMapTexelToLinear( vec4 a ) { return a; }
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${ threeMeshBvh.shaderStructs }
+				${ threeMeshBvh.shaderIntersectFunction }
+				${ shaderMaterialStructs }
+
+				${ shaderUtils }
+				${ shaderMaterialSampling }
+
+				#ifdef USE_ENVMAP
+
+				uniform float environmentBlur;
+				uniform sampler2D environmentMap;
+				uniform mat3 environmentRotation;
+
+				#else
+
+				uniform vec3 gradientTop;
+				uniform vec3 gradientBottom;
+
+				#endif
+
+				#if GRADIENT_BG
+
+				uniform vec3 bgGradientTop;
+				uniform vec3 bgGradientBottom;
+
+				#endif
+
+				uniform mat4 cameraWorldMatrix;
+				uniform mat4 invProjectionMatrix;
+				uniform sampler2D normalAttribute;
+				uniform sampler2D tangentAttribute;
+				uniform sampler2D uvAttribute;
+				uniform usampler2D materialIndexAttribute;
+				uniform BVH bvh;
+				uniform float environmentIntensity;
+				uniform float filterGlossyFactor;
+				uniform int seed;
+				uniform float opacity;
+				uniform Material materials[ MATERIAL_LENGTH ];
+				uniform sampler2DArray textures;
+				varying vec2 vUv;
+
+				void main() {
+
+					rng_initialize( gl_FragCoord.xy, seed );
+
+					// get [-1, 1] normalized device coordinates
+					vec2 ndc = 2.0 * vUv - vec2( 1.0 );
+					vec3 rayOrigin, rayDirection;
+					ndcToCameraRay( ndc, cameraWorldMatrix, invProjectionMatrix, rayOrigin, rayDirection );
+
+					// Lambertian render
+					gl_FragColor = vec4( 0.0 );
+
+					vec3 throughputColor = vec3( 1.0 );
+
+					// hit results
+					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;
+					float accumulatedRoughness = 0.0;
+					int i;
+					int transparentTraversals = TRANSPARENT_TRAVERSALS;
+					for ( i = 0; i < BOUNCES; i ++ ) {
+
+						if ( ! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
+
+							#if GRADIENT_BG
+
+							if ( i == 0 ) {
+
+								rayDirection = normalize( rayDirection + randDirection() * 0.05 );
+								float value = ( rayDirection.y + 1.0 ) / 2.0;
+
+								value = pow( value, 2.0 );
+
+								gl_FragColor = vec4( mix( bgGradientBottom, bgGradientTop, value ), 1.0 );
+								break;
+
+							}
+
+							#endif
+
+							#ifdef USE_ENVMAP
+
+                            vec3 skyColor = textureCubeUV( environmentMap, environmentRotation * rayDirection, environmentBlur ).rgb;
+
+							#else
+
+							rayDirection = normalize( rayDirection );
+							float value = ( rayDirection.y + 1.0 ) / 2.0;
+							vec3 skyColor = mix( gradientBottom, gradientTop, value );
+
+							#endif
+
+							gl_FragColor += vec4( skyColor * throughputColor * environmentIntensity, 1.0 );
+
+							break;
+
+						}
+
+						uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
+						Material material = materials[ materialIndex ];
+
+						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 ) );
+
+						}
+
+						// possibly skip this sample if it's transparent or alpha test is enabled
+						// alpha test is disabled when it === 0
+						float alphaTest = material.alphaTest;
+						bool useAlphaTest = alphaTest != 0.0;
+						if (
+							useAlphaTest && albedo.a < alphaTest
+							|| ! useAlphaTest && albedo.a < rand()
+						) {
+
+							vec3 point = rayOrigin + rayDirection * dist;
+							rayOrigin += rayDirection * dist - faceNormal * RAY_OFFSET;
+
+							// only allow a limited number of transparency discards otherwise we could
+							// crash the context with too long a loop.
+							i -= sign( transparentTraversals );
+							transparentTraversals -= sign( transparentTraversals );
+							continue;
+
+						}
+
+						// fetch the interpolated smooth normal
+						vec3 normal = normalize( textureSampleBarycoord(
+							normalAttribute,
+							barycoord,
+							faceIndices.xyz
+						).xyz );
+
+						// roughness
+						float roughness = material.roughness;
+						if ( material.roughnessMap != - 1 ) {
+
+							roughness *= texture2D( textures, vec3( uv, material.roughnessMap ) ).g;
+
+						}
+
+						// metalness
+						float metalness = material.metalness;
+						if ( material.metalnessMap != - 1 ) {
+
+							metalness *= texture2D( textures, vec3( uv, material.metalnessMap ) ).b;
+
+						}
+
+						// emission
+						vec3 emission = material.emissiveIntensity * material.emissive;
+						if ( material.emissiveMap != - 1 ) {
+
+							emission *= texture2D( textures, vec3( uv, material.emissiveMap ) ).xyz;
+
+						}
+
+						// transmission
+						float transmission = material.transmission;
+						if ( material.transmissionMap != - 1 ) {
+
+							transmission *= texture2D( textures, vec3( uv, material.transmissionMap ) ).r;
+
+						}
+
+						// normal
+						if ( material.normalMap != - 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( normal, tangent ) * tangentSample.w );
+								mat3 vTBN = mat3( tangent, bitangent, normal );
+
+								vec3 texNormal = texture2D( textures, vec3( uv, material.normalMap ) ).xyz * 2.0 - 1.0;
+								texNormal.xy *= material.normalScale;
+								normal = vTBN * texNormal;
+
+							}
+
+						}
+
+						normal *= side;
+
+						SurfaceRec surfaceRec;
+						surfaceRec.normal = normal;
+						surfaceRec.faceNormal = faceNormal;
+						surfaceRec.frontFace = side == 1.0;
+						surfaceRec.transmission = transmission;
+						surfaceRec.ior = material.ior;
+						surfaceRec.emission = emission;
+						surfaceRec.metalness = metalness;
+						surfaceRec.color = albedo.rgb;
+						surfaceRec.roughness = roughness;
+
+						// 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.
+						// 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
+						);
+
+						mat3 normalBasis = getBasisFromNormal( surfaceRec.normal );
+						mat3 invBasis = inverse( normalBasis );
+
+						vec3 outgoing = - normalize( invBasis * rayDirection );
+						SampleRec sampleRec = bsdfSample( outgoing, surfaceRec );
+
+						// 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
+						// error as values increase.
+						vec3 point = rayOrigin + rayDirection * dist;
+						vec3 absPoint = abs( point );
+						float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+						rayDirection = normalize( normalBasis * sampleRec.direction );
+
+						bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
+						rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
+
+						// accumulate a roughness value to offset diffuse, specular, diffuse rays that have high contribution
+						// to a single pixel resulting in fireflies
+						if ( ! isBelowSurface ) {
+
+							// 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 ) );
+
+						}
+
+						// accumulate color
+						gl_FragColor.rgb += ( emission * throughputColor );
+
+						// skip the sample if our PDF or ray is impossible
+						if ( sampleRec.pdf <= 0.0 || ! isDirectionValid( rayDirection, normal, faceNormal) ) {
+
+							break;
+
+						}
+
+						throughputColor *= sampleRec.color / sampleRec.pdf;
+
+						// discard the sample if there are any NaNs
+						if ( any( isnan( throughputColor ) ) || any( isinf( throughputColor ) ) ) {
+
+							break;
+
+						}
+
+					}
+
+					gl_FragColor.a = opacity;
+
+				}
+
+			`
+
+			} );
+
+			this.setValues( parameters );
+
+		}
+
+	}
+
+	// core
+
+	exports.MaterialBase = MaterialBase;
+	exports.MaterialReducer = MaterialReducer;
+	exports.MaterialStructArrayUniform = MaterialStructArrayUniform;
+	exports.MaterialStructUniform = MaterialStructUniform;
+	exports.PathTracingRenderer = PathTracingRenderer;
+	exports.PathTracingSceneGenerator = PathTracingSceneGenerator;
+	exports.PhysicalPathTracingMaterial = PhysicalPathTracingMaterial;
+	exports.RenderTarget2DArray = RenderTarget2DArray;
+	exports.mergeMeshes = mergeMeshes;
+	exports.shaderMaterialSampling = shaderMaterialSampling;
+	exports.shaderMaterialStructs = shaderMaterialStructs;
+	exports.shaderUtils = shaderUtils;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.cjs.map