three-gpu-pathtracer 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Path tracing renderer and utilities for three.js built on top of three-mesh-bvh.",
   "module": "src/index.js",
   "main": "build/index.umd.cjs",
@@ -42,7 +42,7 @@
     "rollup": "^2.70.0",
     "simple-git": "^3.10.0",
     "three": "^0.160.0",
-    "three-mesh-bvh": "0.7.0",
+    "three-mesh-bvh": "0.7.3",
     "yargs": "^17.5.1"
   },
   "peerDependencies": {

package/src/core/DynamicPathTracingSceneGenerator.js

@@ -1,7 +1,16 @@
-import { BufferGeometry } from 'three';
-import { StaticGeometryGenerator, MeshBVH } from 'three-mesh-bvh';
+import { BufferGeometry, MeshBasicMaterial, BufferAttribute, Mesh } from 'three';
+import { StaticGeometryGenerator, MeshBVH, SAH } from 'three-mesh-bvh';
 import { setCommonAttributes, getGroupMaterialIndicesAttribute } from '../utils/GeometryPreparationUtils.js';
 
+const dummyMaterial = new MeshBasicMaterial();
+export function getDummyMesh() {
+
+	const emptyGeometry = new BufferGeometry();
+	emptyGeometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 9 ), 3 ) );
+	return new Mesh( emptyGeometry, dummyMaterial );
+
+}
+
 export class DynamicPathTracingSceneGenerator {
 
 	get initialized() {
@@ -10,9 +19,29 @@ export class DynamicPathTracingSceneGenerator {
 
 	}
 
-	constructor( scene ) {
+	constructor( objects ) {
+
+		// ensure the objects is an array
+		if ( ! Array.isArray( objects ) ) {
+
+			objects = [ objects ];
+
+		}
+
+		// use a dummy object for a fallback
+		const finalObjects = [ ...objects ];
+		if ( finalObjects.length === 0 ) {
+
+			finalObjects.push( getDummyMesh() );
+
+		}
+
+		// options
+		this.bvhOptions = {};
+		this.attributes = [ 'position', 'normal', 'tangent', 'color', 'uv', 'uv2' ];
 
-		this.objects = Array.isArray( scene ) ? scene : [ scene ];
+		// state
+		this.objects = finalObjects;
 		this.bvh = null;
 		this.geometry = new BufferGeometry();
 		this.materials = null;
@@ -36,64 +65,75 @@ export class DynamicPathTracingSceneGenerator {
 
 	dispose() {}
 
-	generate() {
+	prepScene() {
 
-		const { objects, staticGeometryGenerator, geometry, lights } = this;
-		if ( this.bvh === null ) {
+		if ( this.bvh !== null ) {
 
-			const attributes = [ 'position', 'normal', 'tangent', 'uv', 'color' ];
+			return;
 
-			for ( let i = 0, l = objects.length; i < l; i ++ ) {
+		}
 
-				objects[ i ].traverse( c => {
+		const { objects, staticGeometryGenerator, geometry, lights, attributes } = this;
+		for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
-					if ( c.isMesh ) {
+			objects[ i ].traverse( c => {
 
-						const normalMapRequired = ! ! c.material.normalMap;
-						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+				if ( c.isMesh ) {
 
-					} else if (
-						c.isRectAreaLight ||
-						c.isSpotLight ||
-						c.isPointLight ||
-						c.isDirectionalLight
-					) {
+					const normalMapRequired = ! ! c.material.normalMap;
+					setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-						lights.push( c );
+				} else if (
+					c.isRectAreaLight ||
+					c.isSpotLight ||
+					c.isPointLight ||
+					c.isDirectionalLight
+				) {
 
-					}
+					lights.push( c );
 
-				} );
+				}
 
-			}
+			} );
 
-			const textureSet = new Set();
-			const materials = staticGeometryGenerator.getMaterials();
-			materials.forEach( material => {
+		}
 
-				for ( const key in material ) {
+		const textureSet = new Set();
+		const materials = staticGeometryGenerator.getMaterials();
+		materials.forEach( material => {
 
-					const value = material[ key ];
-					if ( value && value.isTexture ) {
+			for ( const key in material ) {
 
-						textureSet.add( value );
+				const value = material[ key ];
+				if ( value && value.isTexture ) {
 
-					}
+					textureSet.add( value );
 
 				}
 
-			} );
+			}
 
-			staticGeometryGenerator.attributes = attributes;
-			staticGeometryGenerator.generate( geometry );
+		} );
+
+		staticGeometryGenerator.attributes = attributes;
+		staticGeometryGenerator.generate( geometry );
 
-			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
-			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-			geometry.clearGroups();
+		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
+		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+		geometry.clearGroups();
+
+		this.materials = materials;
+		this.textures = Array.from( textureSet );
+
+	}
+
+	generate() {
+
+		const { objects, staticGeometryGenerator, geometry, bvhOptions } = this;
+		if ( this.bvh === null ) {
 
-			this.bvh = new MeshBVH( geometry );
-			this.materials = materials;
-			this.textures = Array.from( textureSet );
+			this.prepScene();
+			this.bvh = new MeshBVH( geometry, { strategy: SAH, maxLeafTris: 1, ...bvhOptions } );
 
 			return {
 				lights: this.lights,

package/src/core/PathTracingRenderer.js

@@ -3,9 +3,6 @@ import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { BlendMaterial } from '../materials/fullscreen/BlendMaterial.js';
 import { SobolNumberMapGenerator } from '../utils/SobolNumberMapGenerator.js';
 
-const _scissor = new Vector4();
-const _viewport = new Vector4();
-
 function* renderTask() {
 
 	const {
@@ -47,12 +44,21 @@ function* renderTask() {
 		const h = _primaryTarget.height;
 		material.resolution.set( w * subW, h * subH );
 		material.sobolTexture = _sobolTarget.texture;
+		material.stratifiedTexture.init( 20, material.bounces + material.transmissiveBounces + 5 );
+		material.stratifiedTexture.next();
 		material.seed ++;
 
 		const tilesX = this.tiles.x || 1;
 		const tilesY = this.tiles.y || 1;
 		const totalTiles = tilesX * tilesY;
-		const dprInv = ( 1 / _renderer.getPixelRatio() );
+
+		const pxSubW = Math.ceil( w * subW );
+		const pxSubH = Math.ceil( h * subH );
+		const pxSubX = Math.floor( subX * w );
+		const pxSubY = Math.floor( subY * h );
+
+		const pxTileW = Math.ceil( pxSubW / tilesX );
+		const pxTileH = Math.ceil( pxSubH / tilesY );
 
 		for ( let y = 0; y < tilesY; y ++ ) {
 
@@ -101,40 +107,28 @@ function* renderTask() {
 
 				}
 
+				// set the scissor and the viewport on the render target
+				// note that when using the webgl renderer set viewport the device pixel ratio
+				// is multiplied into the field causing some pixels to not be rendered
+				const reverseTy = tilesY - ty - 1;
+				_primaryTarget.scissor.set(
+					pxSubX + tx * pxTileW,
+					pxSubY + reverseTy * pxTileH,
+					Math.min( pxTileW, pxSubW - tx * pxTileW ),
+					Math.min( pxTileH, pxSubH - reverseTy * pxTileH ),
+				);
+
+				_primaryTarget.viewport.set(
+					pxSubX,
+					pxSubY,
+					pxSubW,
+					pxSubH,
+				);
+
 				// three.js renderer takes values relative to the current pixel ratio
 				_renderer.setRenderTarget( _primaryTarget );
 				_renderer.setScissorTest( true );
 
-				// set the scissor window for a subtile
-				_scissor.x = tx * w / tilesX;
-				_scissor.y = ( tilesY - ty - 1 ) * h / tilesY;
-				_scissor.z = w / tilesX;
-				_scissor.w = h / tilesY;
-
-				// adjust for the subframe
-				_scissor.x = subX * w + subW * _scissor.x;
-				_scissor.y = subY * h + subH * _scissor.y;
-				_scissor.z = subW * _scissor.z;
-				_scissor.w = subH * _scissor.w;
-
-				// round for floating point cases
-				_scissor.x = _scissor.x;
-				_scissor.y = _scissor.y;
-				_scissor.z = _scissor.z;
-				_scissor.w = _scissor.w;
-
-				// multiply inverse of DPR in because threes multiplies it in
-				_scissor.multiplyScalar( dprInv ).ceil();
-
-				_viewport.x = subX * w;
-				_viewport.y = subY * h;
-				_viewport.z = subW * w;
-				_viewport.w = subH * h;
-				_viewport.multiplyScalar( dprInv ).ceil();
-
-				_renderer.setScissor( _scissor );
-				_renderer.setViewport( _viewport );
-
 				_renderer.autoClear = false;
 				_fsQuad.render( _renderer );
 

package/src/core/PathTracingSceneGenerator.js

@@ -1,73 +1,24 @@
-import { Mesh } from 'three';
-import { SAH, MeshBVH, StaticGeometryGenerator } from 'three-mesh-bvh';
-import { mergeMeshes } from '../utils/GeometryPreparationUtils.js';
+import { DynamicPathTracingSceneGenerator } from './DynamicPathTracingSceneGenerator.js';
 
 export class PathTracingSceneGenerator {
 
-	prepScene( scene ) {
-
-		scene = Array.isArray( scene ) ? scene : [ scene ];
-
-		const meshes = [];
-		const lights = [];
-
-		for ( let i = 0, l = scene.length; i < l; i ++ ) {
-
-			scene[ i ].traverseVisible( c => {
-
-				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
-
-					const generator = new StaticGeometryGenerator( c );
-					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-					generator.applyWorldTransforms = false;
-					const mesh = new Mesh(
-						generator.generate(),
-						c.material,
-					);
-					mesh.matrixWorld.copy( c.matrixWorld );
-					mesh.matrix.copy( c.matrixWorld );
-					mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
-					meshes.push( mesh );
-
-				} else if ( c.isMesh ) {
-
-					meshes.push( c );
+	generate( scene, options = {} ) {
 
-				} else if (
-					c.isRectAreaLight ||
-					c.isSpotLight ||
-					c.isPointLight ||
-					c.isDirectionalLight
-				) {
+		// ensure scene transforms are up to date
+		// TODO: remove this?
+		if ( Array.isArray( scene ) ) {
 
-					lights.push( c );
+			scene.forEach( s => s.updateMatrixWorld( true ) );
 
-				}
+		} else {
 
-			} );
+			scene.updateMatrixWorld( true );
 
 		}
 
-		return {
-			...mergeMeshes( meshes, {
-				attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
-			} ),
-			lights,
-		};
-
-	}
-
-	generate( scene, options = {} ) {
-
-		const { materials, textures, geometry, lights } = this.prepScene( scene );
-		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
-		return {
-			scene,
-			materials,
-			textures,
-			lights,
-			bvh: new MeshBVH( geometry, bvhOptions ),
-		};
+		const generator = new DynamicPathTracingSceneGenerator( scene );
+		generator.bvhOptions = options;
+		return generator.generate();
 
 	}
 

package/src/materials/pathtracing/LambertPathTracingMaterial.js

@@ -194,7 +194,7 @@ export class LambertPathTracingMaterial extends MaterialBase {
 						uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
 						Material material = materials[ materialIndex ];
 
-						if ( material.opacity < rand() ) {
+						if ( material.opacity < pcgRand() ) {
 
 							vec3 point = rayOrigin + rayDirection * dist;
 							rayOrigin += rayDirection * dist - faceNormal * RAY_OFFSET;

package/src/materials/pathtracing/PhysicalPathTracingMaterial.js

@@ -48,6 +48,9 @@ import { attenuateHitGLSL } from './glsl/attenuateHit.glsl.js';
 import { traceSceneGLSL } from './glsl/traceScene.glsl.js';
 import { getSurfaceRecordGLSL } from './glsl/getSurfaceRecord.glsl.js';
 import { directLightContributionGLSL } from './glsl/directLightContribution.glsl.js';
+import { stratifiedTextureGLSL } from '../../shader/rand/stratifiedTexture.glsl.js';
+import { StratifiedSamplesTexture } from '../../uniforms/StratifiedSamplesTexture.js';
+import { BlueNoiseTexture } from '../../textures/BlueNoiseTexture.js';
 
 export class PhysicalPathTracingMaterial extends MaterialBase {
 
@@ -72,7 +75,12 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				FEATURE_DOF: 1,
 				FEATURE_BACKGROUND_MAP: 0,
 				FEATURE_FOG: 1,
-				FEATURE_SOBOL: 0,
+
+				// 0 = PCG
+				// 1 = Sobol
+				// 2 = Stratified List
+				RANDOM_TYPE: 2,
+
 				// 0 = Perspective
 				// 1 = Orthographic
 				// 2 = Equirectangular
@@ -114,6 +122,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				backgroundAlpha: { value: 1.0 },
 				sobolTexture: { value: null },
+				stratifiedTexture: { value: new StratifiedSamplesTexture() },
+				stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
 			},
 
 			vertexShader: /* glsl */`
@@ -153,23 +163,35 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				${ materialStructGLSL }
 
 				// random
-				${ pcgGLSL }
-				#if FEATURE_SOBOL
+				#if RANDOM_TYPE == 2 	// Stratified List
+
+					${ stratifiedTextureGLSL }
+
+				#elif RANDOM_TYPE == 1 	// Sobol
 
+					${ pcgGLSL }
 					${ sobolCommonGLSL }
 					${ sobolSamplingGLSL }
 
-				#else
+					#define rand(v) sobol(v)
+					#define rand2(v) sobol2(v)
+					#define rand3(v) sobol3(v)
+					#define rand4(v) sobol4(v)
+
+				#else 					// PCG
+
+					${ pcgGLSL }
 
 					// Using the sobol functions seems to break the the compiler on MacOS
 					// - specifically the "sobolReverseBits" function.
 					uint sobolPixelIndex = 0u;
 					uint sobolPathIndex = 0u;
 					uint sobolBounceIndex = 0u;
-					float sobol( int v ) { return rand(); }
-					vec2 sobol2( int v ) { return rand2(); }
-					vec3 sobol3( int v ) { return rand3(); }
-					vec4 sobol4( int v ) { return rand4(); }
+
+					#define rand(v) pcgRand()
+					#define rand2(v) pcgRand2()
+					#define rand3(v) pcgRand3()
+					#define rand4(v) pcgRand4()
 
 				#endif
 
@@ -287,7 +309,10 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 					// inverse environment rotation
 					envRotation3x3 = mat3( environmentRotation );
 					invEnvRotation3x3 = inverse( envRotation3x3 );
-					lightsDenom = environmentIntensity == 0.0 && lights.count != 0u ? float( lights.count ) : float( lights.count + 1u );
+					lightsDenom =
+						( environmentIntensity == 0.0 || envMapInfo.totalSum == 0.0 ) && lights.count != 0u ?
+							float( lights.count ) :
+							float( lights.count + 1u );
 
 					// final color
 					gl_FragColor = vec4( 0, 0, 0, 1 );
@@ -356,7 +381,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							if ( state.firstRay || state.transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, sobol2( 2 ) ) * state.throughputColor;
+								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, rand2( 2 ) ) * state.throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {
@@ -447,7 +472,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						}
 
 						scatterRec = bsdfSample( - ray.direction, surf );
-						state.isShadowRay = scatterRec.specularPdf < sobol( 4 );
+						state.isShadowRay = scatterRec.specularPdf < rand( 4 );
 
 						bool isBelowSurface = ! surf.volumeParticle && dot( scatterRec.direction, surf.faceNormal ) < 0.0;
 						vec3 hitPoint = stepRayOrigin( ray.origin, ray.direction, isBelowSurface ? - surf.faceNormal : surf.faceNormal, surfaceHit.dist );
@@ -517,7 +542,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						rrProb = sqrt( rrProb );
 						rrProb = max( rrProb, depthProb );
 						rrProb = min( rrProb, 1.0 );
-						if ( sobol( 8 ) > rrProb ) {
+						if ( rand( 8 ) > rrProb ) {
 
 							break;
 

package/src/materials/pathtracing/glsl/attenuateHit.glsl.js

@@ -8,6 +8,9 @@ export const attenuateHitGLSL = /* glsl */`
 		out vec3 color
 	) {
 
+		// store the original bounce index so we can reset it after
+		uint originalBounceIndex = sobolBounceIndex;
+
 		int traversals = state.traversals;
 		int transmissiveTraversals = state.transmissiveTraversals;
 		bool isShadowRay = state.isShadowRay;
@@ -20,22 +23,25 @@ export const attenuateHitGLSL = /* glsl */`
 
 		color = vec3( 1.0 );
 
-		// TODO: we should be using sobol sampling here instead of rand but the sobol bounce and path indices need to be incremented
-		// and then reset.
+		bool result = true;
 		for ( int i = 0; i < traversals; i ++ ) {
 
+			sobolBounceIndex ++;
+
 			int hitType = traceScene( ray, fogMaterial, surfaceHit );
 
 			if ( hitType == FOG_HIT ) {
 
-				return true;
+				result = true;
+				break;
 
 			} else if ( hitType == SURFACE_HIT ) {
 
 				float totalDist = distance( startPoint, ray.origin + ray.direction * surfaceHit.dist );
 				if ( totalDist > rayDist ) {
 
-					return false;
+					result = false;
+					break;
 
 				}
 
@@ -117,7 +123,7 @@ export const attenuateHitGLSL = /* glsl */`
 				bool useAlphaTest = alphaTest != 0.0;
 				float transmissionFactor = ( 1.0 - metalness ) * transmission;
 				if (
-					transmissionFactor < rand() && ! (
+					transmissionFactor < rand( 9 ) && ! (
 						// material sidedness
 						material.side != 0.0 && surfaceHit.side == material.side
 
@@ -125,11 +131,12 @@ export const attenuateHitGLSL = /* glsl */`
 						|| useAlphaTest && albedo.a < alphaTest
 
 						// opacity
-						|| material.transparent && ! useAlphaTest && albedo.a < rand()
+						|| material.transparent && ! useAlphaTest && albedo.a < rand( 10 )
 					)
 				) {
 
-					return true;
+					result = true;
+					break;
 
 				}
 
@@ -155,13 +162,16 @@ export const attenuateHitGLSL = /* glsl */`
 
 			} else {
 
-				return false;
+				result = false;
+				break;
 
 			}
 
 		}
 
-		return true;
+		// reset the bounce index
+		sobolBounceIndex = originalBounceIndex;
+		return result;
 
 	}
 

package/src/materials/pathtracing/glsl/cameraUtils.glsl.js

@@ -12,7 +12,7 @@ export const cameraUtilsGLSL = /* glsl */`
 
 		// Jitter the camera ray by finding a uv coordinate at a random sample
 		// around this pixel's UV coordinate for AA
-		vec2 ruv = sobol2( 0 );
+		vec2 ruv = rand2( 0 );
 		vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
 		Ray ray;
 
@@ -57,7 +57,7 @@ export const cameraUtilsGLSL = /* glsl */`
 
 			// get the aperture sample
 			// if blades === 0 then we assume a circle
-			vec3 shapeUVW= sobol3( 1 );
+			vec3 shapeUVW= rand3( 1 );
 			int blades = physicalCamera.apertureBlades;
 			float anamorphicRatio = physicalCamera.anamorphicRatio;
 			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );

package/src/materials/pathtracing/glsl/directLightContribution.glsl.js

@@ -5,10 +5,10 @@ export const directLightContributionGLSL = /*glsl*/`
 		vec3 result = vec3( 0.0 );
 
 		// uniformly pick a light or environment map
-		if( lightsDenom != 0.0 && sobol( 5 ) < float( lights.count ) / lightsDenom ) {
+		if( lightsDenom != 0.0 && rand( 5 ) < float( lights.count ) / lightsDenom ) {
 
 			// sample a light or environment
-			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
+			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, rand3( 6 ) );
 
 			bool isSampleBelowSurface = ! surf.volumeParticle && dot( surf.faceNormal, lightRec.direction ) < 0.0;
 			if ( isSampleBelowSurface ) {
@@ -43,11 +43,11 @@ export const directLightContributionGLSL = /*glsl*/`
 
 			}
 
-		} else {
+		} else if ( envMapInfo.totalSum != 0.0 && environmentIntensity != 0.0 ) {
 
 			// find a sample in the environment map to include in the contribution
 			vec3 envColor, envDirection;
-			float envPdf = sampleEquirectProbability( sobol2( 7 ), envColor, envDirection );
+			float envPdf = sampleEquirectProbability( rand2( 7 ), envColor, envDirection );
 			envDirection = invEnvRotation3x3 * envDirection;
 
 			// this env sampling is not set up for transmissive sampling and yields overly bright

package/src/materials/pathtracing/glsl/getSurfaceRecord.glsl.js

@@ -36,6 +36,7 @@ export const getSurfaceRecordGLSL = /* glsl */`
 
 			vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
 			albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
 		}
 
 		if ( material.vertexColors ) {
@@ -67,7 +68,7 @@ export const getSurfaceRecordGLSL = /* glsl */`
 			|| useAlphaTest && albedo.a < alphaTest
 
 			// opacity
-			|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
+			|| material.transparent && ! useAlphaTest && albedo.a < rand( 3 )
 		) {
 
 			return SKIP_SURFACE;

package/src/materials/pathtracing/glsl/traceScene.glsl.js

@@ -23,7 +23,7 @@ export const traceSceneGLSL = /* glsl */`
 
 			// offset the distance so we don't run into issues with particles on the same surface
 			// as other objects
-			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
+			float particleDist = intersectFogVolume( fogMaterial, rand( 1 ) );
 			if ( particleDist + RAY_OFFSET < surfaceHit.dist ) {
 
 				surfaceHit.side = 1.0;