three-gpu-pathtracer 0.0.21 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "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",

package/src/core/PathTracingRenderer.js

@@ -159,6 +159,9 @@ export class PathTracingRenderer {
 
 	set material( v ) {
 
+		this._fsQuad.material.removeEventListener( 'recompilation', this._compileFunction );
+		v.addEventListener( 'recompilation', this._compileFunction );
+
 		this._fsQuad.material = v;
 
 	}
@@ -195,6 +198,12 @@ export class PathTracingRenderer {
 
 	}
 
+	get isCompiling() {
+
+		return Boolean( this._compilePromise );
+
+	}
+
 	constructor( renderer ) {
 
 		this.camera = null;
@@ -212,6 +221,7 @@ export class PathTracingRenderer {
 		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
 		this._task = null;
 		this._currentTile = 0;
+		this._compilePromise = null;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
@@ -236,6 +246,33 @@ export class PathTracingRenderer {
 			} ),
 		];
 
+		// function for listening to for triggered compilation so we can wait for compilation to finish
+		// before starting to render
+		this._compileFunction = () => {
+
+			const promise = this.compileMaterial( this._fsQuad._mesh );
+			promise.then( () => {
+
+				if ( this._compilePromise === promise ) {
+
+					this._compilePromise = null;
+
+				}
+
+			} );
+
+			this._compilePromise = promise;
+
+		};
+
+		this.material.addEventListener( 'recompilation', this._compileFunction );
+
+	}
+
+	compileMaterial() {
+
+		return this._renderer.compileAsync( this._fsQuad._mesh );
+
 	}
 
 	setCamera( camera ) {
@@ -267,7 +304,6 @@ export class PathTracingRenderer {
 		material.setDefine( 'CAMERA_TYPE', cameraType );
 
 		this.camera = camera;
-		// this.reset();
 
 	}
 
@@ -334,9 +370,11 @@ export class PathTracingRenderer {
 		this.samples = 0;
 		this._task = null;
 
+		this.material.stratifiedTexture.stableNoise = this.stableNoise;
 		if ( this.stableNoise ) {
 
 			this.material.seed = 0;
+			this.material.stratifiedTexture.reset();
 
 		}
 
@@ -344,6 +382,15 @@ export class PathTracingRenderer {
 
 	update() {
 
+		// ensure we've updated our defines before rendering so we can ensure we
+		// can wait for compilation to finish
+		this.material.onBeforeRender();
+		if ( this.isCompiling ) {
+
+			return;
+
+		}
+
 		if ( ! this._task ) {
 
 			this._task = renderTask.call( this );

package/src/core/WebGLPathTracer.js

@@ -5,6 +5,7 @@ import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { GradientEquirectTexture } from '../textures/GradientEquirectTexture.js';
 import { getIesTextures, getLights, getTextures } from './utils/sceneUpdateUtils.js';
 import { ClampedInterpolationMaterial } from '../materials/fullscreen/ClampedInterpolationMaterial.js';
+import { CubeToEquirectGenerator } from '../utils/CubeToEquirectGenerator.js';
 
 function supportsFloatBlending( renderer ) {
 
@@ -81,6 +82,24 @@ export class WebGLPathTracer {
 
 	}
 
+	get stableNoise() {
+
+		return this._pathTracer.stableNoise;
+
+	}
+
+	set stableNoise( v ) {
+
+		this._pathTracer.stableNoise = v;
+
+	}
+
+	get isCompiling() {
+
+		return Boolean( this._pathTracer.isCompiling );
+
+	}
+
 	constructor( renderer ) {
 
 		// members
@@ -89,6 +108,7 @@ export class WebGLPathTracer {
 		this._pathTracer = new PathTracingRenderer( renderer );
 		this._queueReset = false;
 		this._clock = new Clock();
+		this._compilePromise = null;
 
 		this._lowResPathTracer = new PathTracingRenderer( renderer );
 		this._lowResPathTracer.tiles.set( 1, 1 );
@@ -101,6 +121,10 @@ export class WebGLPathTracer {
 		} ) );
 		this._materials = null;
 
+		this._previousEnvironment = null;
+		this._previousBackground = null;
+		this._internalBackground = null;
+
 		// options
 		this.renderDelay = 100;
 		this.minSamples = 5;
@@ -229,6 +253,13 @@ export class WebGLPathTracer {
 		const scene = this.scene;
 		const material = this._pathTracer.material;
 
+		if ( this._internalBackground ) {
+
+			this._internalBackground.dispose();
+			this._internalBackground = null;
+
+		}
+
 		// update scene background
 		material.backgroundBlur = scene.backgroundBlurriness;
 		material.backgroundIntensity = scene.backgroundIntensity ?? 1;
@@ -256,6 +287,17 @@ export class WebGLPathTracer {
 			material.backgroundMap = colorBackground;
 			material.backgroundAlpha = 1;
 
+		} else if ( scene.background.isCubeTexture ) {
+
+			if ( scene.background !== this._previousBackground ) {
+
+				const background = new CubeToEquirectGenerator( this._renderer ).generate( scene.background );
+				this._internalBackground = background;
+				material.backgroundMap = background;
+				material.backgroundAlpha = 1;
+
+			}
+
 		} else {
 
 			material.backgroundMap = scene.background;
@@ -268,12 +310,21 @@ export class WebGLPathTracer {
 		material.environmentRotation.makeRotationFromEuler( scene.environmentRotation ).invert();
 		if ( this._previousEnvironment !== scene.environment ) {
 
-			if ( scene.environment ) {
+			if ( scene.environment !== null ) {
+
+				if ( scene.environment.isCubeTexture ) {
 
-				// TODO: Consider setting this to the highest supported bit depth by checking for
-				// OES_texture_float_linear or OES_texture_half_float_linear. Requires changes to
-				// the equirect uniform
-				material.envMapInfo.updateFrom( scene.environment );
+					const environment = new CubeToEquirectGenerator( this._renderer ).generate( scene.environment );
+					material.envMapInfo.updateFrom( environment );
+
+				} else {
+
+					// TODO: Consider setting this to the highest supported bit depth by checking for
+					// OES_texture_float_linear or OES_texture_half_float_linear. Requires changes to
+					// the equirect uniform
+					material.envMapInfo.updateFrom( scene.environment );
+
+				}
 
 			} else {
 
@@ -284,6 +335,7 @@ export class WebGLPathTracer {
 		}
 
 		this._previousEnvironment = scene.environment;
+		this._previousBackground = scene.background;
 		this.reset();
 
 	}
@@ -354,7 +406,7 @@ export class WebGLPathTracer {
 		// render the path tracing sample after enough time has passed
 		const delta = clock.getDelta() * 1e3;
 		const elapsedTime = clock.getElapsedTime() * 1e3;
-		if ( ! this.pausePathTracing && this.enablePathTracing && this.renderDelay <= elapsedTime ) {
+		if ( ! this.pausePathTracing && this.enablePathTracing && this.renderDelay <= elapsedTime && ! this.isCompiling ) {
 
 			pathTracer.update();
 
@@ -387,7 +439,7 @@ export class WebGLPathTracer {
 			// render the fallback if we haven't rendered enough samples, are paused, or are occluded
 			if ( ! this.enablePathTracing || this.samples < minSamples || quad.material.opacity < 1 ) {
 
-				if ( this.dynamicLowRes ) {
+				if ( this.dynamicLowRes && ! this.isCompiling ) {
 
 					if ( lowResPathTracer.samples < 1 ) {
 
@@ -402,7 +454,9 @@ export class WebGLPathTracer {
 					quad.render( renderer );
 					quad.material.opacity = currentOpacity;
 
-				} else if ( this.rasterizeScene ) {
+				}
+
+				if ( ! this.dynamicLowRes && this.rasterizeScene || this.dynamicLowRes && this.isCompiling ) {
 
 					this.rasterizeSceneCallback( this.scene, this.camera );
 

package/src/core/utils/BakedGeometry.js

@@ -1,6 +1,7 @@
 import { BufferGeometry } from 'three';
 import { MeshDiff } from './MeshDiff.js';
 import { convertToStaticGeometry } from './convertToStaticGeometry.js';
+import { validateAttributes } from './BufferAttributeUtils.js';
 
 export class BakedGeometry extends BufferGeometry {
 
@@ -13,6 +14,28 @@ export class BakedGeometry extends BufferGeometry {
 
 	}
 
+	// returns whether the passed mesh is compatible with this baked geometry
+	// such that it can be updated without resizing attributes
+	isCompatible( mesh, attributes ) {
+
+		const geometry = mesh.geometry;
+		for ( let i = 0; i < attributes.length; i ++ ) {
+
+			const key = attributes[ i ];
+			const attr1 = geometry.attributes[ key ];
+			const attr2 = this.attributes[ key ];
+			if ( attr1 && ! validateAttributes( attr1, attr2 ) ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
 	updateFrom( mesh, options ) {
 
 		const diff = this._diff;

package/src/core/utils/BufferAttributeUtils.js

@@ -41,12 +41,18 @@ export function createAttributeClone( attr, countOverride = null ) {
 
 }
 
-// Confirms that the two provided attributes are compatible
+// Confirms that the two provided attributes are compatible. Returns false if they are not.
 export function validateAttributes( attr1, attr2 ) {
 
 	if ( ! attr1 && ! attr2 ) {
 
-		return;
+		return true;
+
+	}
+
+	if ( Boolean( attr1 ) !== Boolean( attr2 ) ) {
+
+		return false;
 
 	}
 
@@ -57,8 +63,10 @@ export function validateAttributes( attr1, attr2 ) {
 
 	if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
 
-		throw new Error();
+		return false;
 
 	}
 
+	return true;
+
 }

package/src/core/utils/MeshDiff.js

@@ -1,29 +1,22 @@
 import { Matrix4 } from 'three';
 import { bufferToHash } from '../../utils/bufferToHash.js';
 
-function attributeSort( a, b ) {
-
-	if ( a.uuid > b.uuid ) return 1;
-	if ( a.uuid < b.uuid ) return - 1;
-	return 0;
-
-}
-
 function getGeometryHash( geometry ) {
 
-	let hash = '';
+	let hash = geometry.uuid;
 	const attributes = Object.values( geometry.attributes );
 	if ( geometry.index ) {
 
 		attributes.push( geometry.index );
+		hash += `index|${ geometry.index.version }`;
 
 	}
 
-	attributes.sort( attributeSort );
-
-	for ( const attr of attributes ) {
+	const keys = Object.keys( attributes ).sort();
+	for ( const key of keys ) {
 
-		hash += `${ attr.uuid }_${ attr.version }|`;
+		const attr = attributes[ key ];
+		hash += `${ key }_${ attr.version }|`;
 
 	}
 

package/src/core/utils/StaticGeometryGenerator.js

@@ -13,7 +13,7 @@ function flatTraverseMeshes( objects, cb ) {
 	for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
 		const object = objects[ i ];
-		object.traverse( o => {
+		object.traverseVisible( o => {
 
 			if ( o.isMesh ) {
 
@@ -171,15 +171,24 @@ export class StaticGeometryGenerator {
 			unusedMeshKeys.delete( meshKey );
 
 			// initialize the intermediate geometry
-			if ( ! _intermediateGeometry.has( meshKey ) ) {
+			// if the mesh and source geometry have changed in such a way that they are no longer
+			// compatible then regenerate the baked geometry from scratch
+			let geom = _intermediateGeometry.get( meshKey );
+			if ( ! geom || ! geom.isCompatible( mesh, this.attributes ) ) {
 
-				_intermediateGeometry.set( meshKey, new BakedGeometry() );
+				if ( geom ) {
+
+					geom.dispose();
+
+				}
+
+				geom = new BakedGeometry();
+				_intermediateGeometry.set( meshKey, geom );
 
 			}
 
 			// transform the geometry into the intermediate buffer geometry, saving whether
 			// or not it changed.
-			const geom = _intermediateGeometry.get( meshKey );
 			if ( geom.updateFrom( mesh, convertOptions ) ) {
 
 				// TODO: provide option for only generating the set of attributes that are present
@@ -231,6 +240,12 @@ export class StaticGeometryGenerator {
 
 		// get the list of geometries to merge
 		let forceUpdate = false;
+		if ( meshes.length !== previousMergeInfo.length ) {
+
+			forceUpdate = true;
+
+		}
+
 		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
 
 			const mesh = meshes[ i ];

package/src/materials/MaterialBase.js

@@ -2,6 +2,17 @@ import { ShaderMaterial } from 'three';
 
 export class MaterialBase extends ShaderMaterial {
 
+	set needsUpdate( v ) {
+
+		super.needsUpdate = true;
+		this.dispatchEvent( {
+
+			type: 'recompilation',
+
+		} );
+
+	}
+
 	constructor( shader ) {
 
 		super( shader );

package/src/uniforms/StratifiedSamplesTexture.js

@@ -1,6 +1,36 @@
 import { DataTexture, FloatType, NearestFilter, RGBAFormat } from 'three';
 import { StratifiedSamplerCombined } from './stratified/StratifiedSamplerCombined.js';
 
+// https://stackoverflow.com/questions/424292/seedable-javascript-random-number-generator
+class RandomGenerator {
+
+	constructor( seed = 0 ) {
+
+		// LCG using GCC's constants
+		this.m = 0x80000000; // 2**31;
+		this.a = 1103515245;
+		this.c = 12345;
+
+		this.seed = seed;
+
+	}
+
+	nextInt() {
+
+		this.seed = ( this.a * this.seed + this.c ) % this.m;
+		return this.seed;
+
+	}
+
+	nextFloat() {
+
+		// returns in range [0,1]
+		return this.nextInt() / ( this.m - 1 );
+
+	}
+
+}
+
 export class StratifiedSamplesTexture extends DataTexture {
 
 	constructor( count = 1, depth = 1, strata = 8 ) {
@@ -11,22 +41,37 @@ export class StratifiedSamplesTexture extends DataTexture {
 
 		this.strata = strata;
 		this.sampler = null;
+		this.generator = new RandomGenerator();
+		this.stableNoise = false;
+		this.random = () => {
+
+			if ( this.stableNoise ) {
+
+				return this.generator.nextFloat();
+
+			} else {
+
+				return Math.random();
+
+			}
+
+		};
 
 		this.init( count, depth, strata );
 
 	}
 
-	init( count, depth, strata = this.strata ) {
+	init( count = this.image.height, depth = this.image.width, strata = this.strata ) {
 
 		const { image } = this;
-		if ( image.width === depth && image.height === count ) {
+		if ( image.width === depth && image.height === count && this.sampler !== null ) {
 
 			return;
 
 		}
 
 		const dimensions = new Array( count * depth ).fill( 4 );
-		const sampler = new StratifiedSamplerCombined( strata, dimensions );
+		const sampler = new StratifiedSamplerCombined( strata, dimensions, this.random );
 
 		image.width = depth;
 		image.height = count;
@@ -46,4 +91,11 @@ export class StratifiedSamplesTexture extends DataTexture {
 
 	}
 
+	reset() {
+
+		this.sampler.reset();
+		this.generator.seed = 0;
+
+	}
+
 }

package/src/uniforms/stratified/StratifiedSampler.js

@@ -2,11 +2,11 @@
 // - https://github.com/hoverinc/ray-tracing-renderer
 // - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
 
-export function shuffle( arr ) {
+export function shuffle( arr, random = Math.random() ) {
 
 	for ( let i = arr.length - 1; i > 0; i -- ) {
 
-	  const j = Math.floor( Math.random() * ( i + 1 ) );
+	  const j = Math.floor( random() * ( i + 1 ) );
 	  const x = arr[ i ];
 	  arr[ i ] = arr[ j ];
 	  arr[ j ] = x;
@@ -21,7 +21,7 @@ export function shuffle( arr ) {
 // dimensions  : The number of dimensions to generate stratified values for
 export class StratifiedSampler {
 
-	constructor( strataCount, dimensions ) {
+	constructor( strataCount, dimensions, random = Math.random ) {
 
 		const l = strataCount ** dimensions;
 		const strata = new Uint16Array( l );
@@ -38,7 +38,19 @@ export class StratifiedSampler {
 
 		this.strataCount = strataCount;
 
-		this.restart = function () {
+		this.reset = function () {
+
+			for ( let i = 0; i < l; i ++ ) {
+
+				strata[ i ] = i;
+
+			}
+
+			index = 0;
+
+		};
+
+		this.reshuffle = function () {
 
 			index = 0;
 
@@ -50,8 +62,8 @@ export class StratifiedSampler {
 
 			if ( index >= strata.length ) {
 
-				shuffle( strata );
-				this.restart();
+				shuffle( strata, random );
+				this.reshuffle();
 
 			}
 
@@ -59,7 +71,7 @@ export class StratifiedSampler {
 
 			for ( let i = 0; i < dimensions; i ++ ) {
 
-				samples[ i ] = ( stratum % strataCount + Math.random() ) / strataCount;
+				samples[ i ] = ( stratum % strataCount + random() ) / strataCount;
 				stratum = Math.floor( stratum / strataCount );
 
 			}

package/src/uniforms/stratified/StratifiedSamplerCombined.js

@@ -7,7 +7,7 @@ import { StratifiedSampler } from './StratifiedSampler.js';
 // Stratified set of data with each tuple stratified separately and combined
 export class StratifiedSamplerCombined {
 
-	constructor( strataCount, listOfDimensions ) {
+	constructor( strataCount, listOfDimensions, random = Math.random ) {
 
 		let totalDim = 0;
 		for ( const dim of listOfDimensions ) {
@@ -21,7 +21,7 @@ export class StratifiedSamplerCombined {
 		let offset = 0;
 		for ( const dim of listOfDimensions ) {
 
-			const sampler = new StratifiedSampler( strataCount, dim );
+			const sampler = new StratifiedSampler( strataCount, dim, random );
 			sampler.samples = new Float32Array( combined.buffer, offset, sampler.samples.length );
 			offset += sampler.samples.length * 4;
 			strataObjs.push( sampler );
@@ -44,11 +44,21 @@ export class StratifiedSamplerCombined {
 
 		};
 
-		this.restart = function () {
+		this.reshuffle = function () {
 
 			for ( const strata of strataObjs ) {
 
-				strata.restart();
+				strata.reshuffle();
+
+			}
+
+		};
+
+		this.reset = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.reset();
 
 			}