three-gpu-pathtracer 0.0.1 → 0.0.2

package/build/index.module.js

@@ -1,7 +1,6 @@
-import { Color, Vector2, WebGLRenderTarget, RGBAFormat, FloatType, BufferAttribute, WebGLArrayRenderTarget, UnsignedByteType, LinearFilter, RepeatWrapping, MeshBasicMaterial, NoToneMapping, ShaderMaterial, Matrix4, Matrix3 } from 'three';
+import { Color, Vector2, WebGLRenderTarget, RGBAFormat, FloatType, BufferAttribute, Mesh, BufferGeometry, PerspectiveCamera, BackSide, FrontSide, DoubleSide, WebGLArrayRenderTarget, UnsignedByteType, LinearFilter, RepeatWrapping, MeshBasicMaterial, NoToneMapping, ShaderMaterial, Matrix4, Matrix3 } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { SAH, MeshBVHUniformStruct, FloatVertexAttributeTexture, UIntVertexAttributeTexture, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
-import { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
+import { StaticGeometryGenerator, SAH, MeshBVH, MeshBVHUniformStruct, FloatVertexAttributeTexture, UIntVertexAttributeTexture, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
 import { mergeVertices, mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
 function* renderTask() {
@@ -142,193 +141,226 @@ class PathTracingRenderer {
 
 }
 
-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 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 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 = mergeVertices( geometry );
-
-				}
-
-				geometry.computeTangents();
-
-			} else {
-
-				const vertCount = geometry.attributes.position.count;
-				geometry.setAttribute( 'tangent', new 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 = mergeBufferGeometries( transformedGeometry, false );
-	const textures = Array.from( textureSet );
-	return { geometry, materials, textures };
-
+function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
+
+	if ( ! Array.isArray( materials ) ) {
+
+		materials = [ materials ];
+
+	}
+
+	const indexAttr = geometry.index;
+	const posAttr = geometry.attributes.position;
+	const vertCount = posAttr.count;
+	const materialArray = new Uint8Array( vertCount );
+	const totalCount = indexAttr ? indexAttr.count : vertCount;
+	let groups = geometry.groups;
+	if ( groups.length === 0 ) {
+
+		groups = [ { count: totalCount, start: 0, materialIndex: 0 } ];
+
+	}
+
+	for ( let i = 0; i < groups.length; i ++ ) {
+
+		const group = groups[ i ];
+		const start = group.start;
+		const count = group.count;
+		const endCount = Math.min( count, totalCount - start );
+
+		const mat = materials[ group.materialIndex ];
+		const materialIndex = allMaterials.indexOf( mat );
+
+		for ( let j = 0; j < endCount; j ++ ) {
+
+			let index = start + j;
+			if ( indexAttr ) {
+
+				index = indexAttr.getX( index );
+
+			}
+
+			materialArray[ index ] = materialIndex;
+
+		}
+
+	}
+
+	return new BufferAttribute( materialArray, 1, false );
+
+}
+
+function trimToAttributes( geometry, attributes ) {
+
+	// trim any unneeded attributes
+	if ( attributes ) {
+
+		for ( const key in geometry.attributes ) {
+
+			if ( ! attributes.includes( key ) ) {
+
+				geometry.deleteAttribute( key );
+
+			}
+
+		}
+
+	}
+
+}
+
+function setCommonAttributes( geometry, options ) {
+
+	const { attributes = [], normalMapRequired = false } = options;
+
+	if ( ! geometry.attributes.normal && ( attributes && attributes.includes( 'normal' ) ) ) {
+
+		geometry.computeVertexNormals();
+
+	}
+
+	if ( ! geometry.attributes.uv && ( attributes && attributes.includes( 'uv' ) ) ) {
+
+		const vertCount = geometry.attributes.position.count;
+		geometry.setAttribute( 'uv', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+	}
+
+	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
+
+		if ( normalMapRequired ) {
+
+			// computeTangents requires an index buffer
+			if ( geometry.index === null ) {
+
+				geometry = mergeVertices( geometry );
+
+			}
+
+			geometry.computeTangents();
+
+		} else {
+
+			const vertCount = geometry.attributes.position.count;
+			geometry.setAttribute( 'tangent', new 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 );
+
+	}
+
+}
+
+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 );
+
+		// ensure our geometry has common attributes
+		setCommonAttributes( geometry, {
+			attributes: options.attributes,
+			normalMapRequired: ! ! mesh.material.normalMap,
+		} );
+		trimToAttributes( geometry, options.attributes );
+
+		// 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 = mergeBufferGeometries( transformedGeometry, false );
+	const textures = Array.from( textureSet );
+	return { geometry, materials, textures };
+
 }
 
 class PathTracingSceneGenerator {
 
-	constructor() {
-
-		this.bvhGenerator = new GenerateMeshBVHWorker();
-
-	}
+	prepScene( scene ) {
 
-	async generate( scene, options = {} ) {
-
-		const { bvhGenerator } = this;
 		const meshes = [];
-
 		scene.traverse( c => {
 
-			if ( c.isMesh ) {
+			if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
+
+				const generator = new StaticGeometryGenerator( c );
+				generator.applyWorldTransforms = false;
+				const mesh = new Mesh(
+					generator.generate(),
+					c.material,
+				);
+				mesh.matrixWorld.copy( c.matrixWorld );
+				mesh.matrix.copy( c.matrixWorld );
+				mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
+				meshes.push( mesh );
+
+			} else if ( c.isMesh ) {
 
 				meshes.push( c );
 
@@ -336,24 +368,127 @@ class PathTracingSceneGenerator {
 
 		} );
 
-		const { geometry, materials, textures } = mergeMeshes( meshes, { attributes: [ 'position', 'normal', 'tangent', 'uv' ] } );
-		const bvhPromise = bvhGenerator.generate( geometry, { strategy: SAH, ...options, maxLeafTris: 1 } );
+		return mergeMeshes( meshes, {
+			attributes: [ 'position', 'normal', 'tangent', 'uv' ],
+		} );
 
+	}
+
+	generate( scene, options = {} ) {
+
+		const { materials, textures, geometry } = this.prepScene( scene );
+		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
 		return {
 			scene,
 			materials,
 			textures,
-			bvh: await bvhPromise,
+			bvh: new MeshBVH( geometry, bvhOptions ),
 		};
 
 	}
 
-	dispose() {
-
-		this.bvhGenerator.terminate();
-
-	}
-
+}
+
+class DynamicPathTracingSceneGenerator {
+
+	get initialized() {
+
+		return Boolean( this.bvh );
+
+	}
+
+	constructor( scene ) {
+
+		this.scene = scene;
+		this.bvh = null;
+		this.geometry = new BufferGeometry();
+		this.materials = null;
+		this.textures = null;
+		this.staticGeometryGenerator = new StaticGeometryGenerator( scene );
+
+	}
+
+	reset() {
+
+		this.geometry.dispose();
+		this.geometry = new BufferGeometry();
+		this.materials = null;
+		this.textures = null;
+		this.staticGeometryGenerator = new StaticGeometryGenerator( this.scene );
+
+	}
+
+	dispose() {}
+
+	generate() {
+
+		const { scene, staticGeometryGenerator, geometry } = this;
+		if ( this.bvh === null ) {
+
+			const attributes = [ 'position', 'normal', 'tangent', 'uv' ];
+			scene.traverse( c => {
+
+				if ( c.isMesh ) {
+
+					const normalMapRequired = ! ! c.material.normalMap;
+					setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+
+				}
+
+			} );
+
+			const textureSet = new Set();
+			const materials = staticGeometryGenerator.getMaterials();
+			materials.forEach( material => {
+
+				for ( const key in material ) {
+
+					const value = material[ key ];
+					if ( value && value.isTexture ) {
+
+						textureSet.add( value );
+
+					}
+
+				}
+
+			} );
+
+			staticGeometryGenerator.attributes = attributes;
+			staticGeometryGenerator.generate( geometry );
+
+			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
+			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+			geometry.clearGroups();
+
+			this.bvh = new MeshBVH( geometry );
+			this.materials = materials;
+			this.textures = Array.from( textureSet );
+
+			return {
+				bvh: this.bvh,
+				materials: this.materials,
+				textures: this.textures,
+				scene,
+			};
+
+		} else {
+
+			const { bvh } = this;
+			staticGeometryGenerator.generate( geometry );
+			bvh.refit();
+			return {
+				bvh: this.bvh,
+				materials: this.materials,
+				textures: this.textures,
+				scene,
+			};
+
+		}
+
+	}
+
+
 }
 
 // https://github.com/gkjohnson/webxr-sandbox/blob/main/skinned-mesh-batching/src/MaterialReducer.js
@@ -613,6 +748,33 @@ class MaterialReducer {
 
 }
 
+class PhysicalCamera extends PerspectiveCamera {
+
+	set bokehSize( size ) {
+
+		this.fStop = this.getFocalLength() / size;
+
+	}
+
+	get bokehSize() {
+
+		return this.getFocalLength() / this.fStop;
+
+	}
+
+	constructor( ...args ) {
+
+		super( ...args );
+		this.fStop = 1.4;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 25;
+		this.anamorphicRatio = 1;
+
+	}
+
+}
+
 class MaterialStructUniform {
 
 	constructor() {
@@ -646,6 +808,8 @@ class MaterialStructUniform {
 		this.opacity = 1.0;
 		this.alphaTest = 0.0;
 
+		this.side = 0;
+
 		// TODO: Clearcoat
 
 		// TODO: Sheen
@@ -705,6 +869,24 @@ class MaterialStructUniform {
 
 	}
 
+	setSide( side ) {
+
+		switch ( side ) {
+
+			case DoubleSide:
+				this.side = 0;
+				break;
+			case FrontSide:
+				this.side = 1;
+				break;
+			case BackSide:
+				this.side = - 1;
+				break;
+
+		}
+
+	}
+
 }
 
 class MaterialStructArrayUniform extends Array {
@@ -850,6 +1032,16 @@ class MaterialBase extends ShaderMaterial {
 
 const shaderMaterialStructs = /* glsl */ `
 
+	struct PhysicalCamera {
+
+		float focusDistance;
+		float anamorphicRatio;
+		float bokehSize;
+		int apertureBlades;
+		float apertureRotation;
+
+	};
+
 	struct Material {
 
 		vec3 color;
@@ -875,6 +1067,8 @@ const shaderMaterialStructs = /* glsl */ `
 		float opacity;
 		float alphaTest;
 
+		float side;
+
 	};
 
 `;
@@ -1419,6 +1613,7 @@ const shaderUtils = /* glsl */`
 
 	}
 
+	// returns [ 0, 1 ]
 	float rand() {
 
 		pcg4d(s0);
@@ -1458,8 +1653,94 @@ const shaderUtils = /* glsl */`
 		return vec3( f * cos( t ), f * sin( t ), u );
 
 	}
+
+	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
+
+		// get the edges of the triangle and the diagonal across the
+		// center of the parallelogram
+		vec2 e1 = a - b;
+		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 ) {
+
+			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 );
+
+		}
+
+	}
 `;
 
+class PhysicalCameraUniform {
+
+	constructor() {
+
+		this.bokehSize = 0;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 10;
+		this.anamorphicRatio = 1;
+
+	}
+
+	updateFrom( camera ) {
+
+		if ( camera instanceof PhysicalCamera ) {
+
+			this.bokehSize = camera.bokehSize;
+			this.apertureBlades = camera.apertureBlades;
+			this.apertureRotation = camera.apertureRotation;
+			this.focusDistance = camera.focusDistance;
+			this.anamorphicRatio = camera.anamorphicRatio;
+
+		} else {
+
+			this.bokehSize = 0;
+			this.apertureRotation = 0;
+			this.apertureBlades = 0;
+			this.focusDistance = 10;
+			this.anamorphicRatio = 1;
+
+		}
+
+	}
+
+}
+
 class PhysicalPathTracingMaterial extends MaterialBase {
 
 	// three.js relies on this field to add env map functions and defines
@@ -1477,13 +1758,16 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 			depthWrite: false,
 
 			defines: {
-				BOUNCES: 3,
+				DOF_SUPPORT: 1,
 				TRANSPARENT_TRAVERSALS: 5,
 				MATERIAL_LENGTH: 0,
 				GRADIENT_BG: 0,
 			},
 
 			uniforms: {
+				bounces: { value: 3 },
+				physicalCamera: { value: new PhysicalCameraUniform() },
+
 				bvh: { value: new MeshBVHUniformStruct() },
 				normalAttribute: { value: new FloatVertexAttributeTexture() },
 				tangentAttribute: { value: new FloatVertexAttributeTexture() },
@@ -1560,6 +1844,14 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 				#endif
 
+				#if DOF_SUPPORT
+
+				uniform PhysicalCamera physicalCamera;
+
+				#endif
+
+				uniform int bounces;
+
 				uniform mat4 cameraWorldMatrix;
 				uniform mat4 invProjectionMatrix;
 				uniform sampler2D normalAttribute;
@@ -1584,6 +1876,30 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					vec3 rayOrigin, rayDirection;
 					ndcToCameraRay( ndc, cameraWorldMatrix, invProjectionMatrix, rayOrigin, rayDirection );
 
+					#if DOF_SUPPORT
+
+					// depth of field
+					vec3 focalPoint = rayOrigin + normalize( rayDirection ) * physicalCamera.focusDistance;
+
+					// get the aperture sample
+					vec2 apertureSample = sampleAperture( physicalCamera.apertureBlades ) * physicalCamera.bokehSize * 0.5 * 1e-3;
+
+					// rotate the aperture shape
+					float ac = cos( physicalCamera.apertureRotation );
+					float as = sin( physicalCamera.apertureRotation );
+					apertureSample = vec2(
+						apertureSample.x * ac - apertureSample.y * as,
+						apertureSample.x * as + apertureSample.y * ac
+					);
+					apertureSample.x *= saturate( physicalCamera.anamorphicRatio );
+					apertureSample.y *= saturate( 1.0 / physicalCamera.anamorphicRatio );
+
+					#endif
+
+					// create the new ray
+					rayOrigin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
+					rayDirection = focalPoint - rayOrigin;
+
 					// Lambertian render
 					gl_FragColor = vec4( 0.0 );
 
@@ -1598,7 +1914,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 					float accumulatedRoughness = 0.0;
 					int i;
 					int transparentTraversals = TRANSPARENT_TRAVERSALS;
-					for ( i = 0; i < BOUNCES; i ++ ) {
+					for ( i = 0; i < bounces; i ++ ) {
 
 						if ( ! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
 
@@ -1649,12 +1965,23 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
-						// possibly skip this sample if it's transparent or alpha test is enabled
-						// alpha test is disabled when it === 0
+						// possibly skip this sample if it's transparent, alpha test is enabled, or we hit the wrong material side
+						// and it's single sided.
+						// - alpha test is disabled when it === 0
+						// - the material sidedness test is complicated because we want light to pass through the back side but still
+						// be able to see the front side. This boolean checks if the side we hit is the front side on the first ray
+						// and we're rendering the other then we skip it. Do the opposite on subsequent bounces to get incoming light.
 						float alphaTest = material.alphaTest;
 						bool useAlphaTest = alphaTest != 0.0;
+						bool isFirstHit = i == 0;
 						if (
-							useAlphaTest && albedo.a < alphaTest
+							// material sidedness
+							material.side != 0.0 && ( side != material.side ) == isFirstHit
+
+							// alpha test
+							|| useAlphaTest && albedo.a < alphaTest
+
+							// opacity
 							|| ! useAlphaTest && albedo.a < rand()
 						) {
 
@@ -1738,7 +2065,6 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						SurfaceRec surfaceRec;
 						surfaceRec.normal = normal;
 						surfaceRec.faceNormal = faceNormal;
-						surfaceRec.frontFace = side == 1.0;
 						surfaceRec.transmission = transmission;
 						surfaceRec.ior = material.ior;
 						surfaceRec.emission = emission;
@@ -1746,6 +2072,10 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 						surfaceRec.color = albedo.rgb;
 						surfaceRec.roughness = roughness;
 
+						// 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.
@@ -1821,5 +2151,5 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 
 // core
 
-export { MaterialBase, MaterialReducer, MaterialStructArrayUniform, MaterialStructUniform, PathTracingRenderer, PathTracingSceneGenerator, PhysicalPathTracingMaterial, RenderTarget2DArray, mergeMeshes, shaderMaterialSampling, shaderMaterialStructs, shaderUtils };
+export { DynamicPathTracingSceneGenerator, MaterialBase, MaterialReducer, MaterialStructArrayUniform, MaterialStructUniform, PathTracingRenderer, PathTracingSceneGenerator, PhysicalCamera, PhysicalPathTracingMaterial, RenderTarget2DArray, getGroupMaterialIndicesAttribute, mergeMeshes, setCommonAttributes, shaderMaterialSampling, shaderMaterialStructs, shaderUtils, trimToAttributes };
 //# sourceMappingURL=index.module.js.map