three-gpu-pathtracer 0.0.21 → 0.0.23

package/build/index.umd.cjs

@@ -45,12 +45,18 @@
 
 	}
 
-	// Confirms that the two provided attributes are compatible
+	// Confirms that the two provided attributes are compatible. Returns false if they are not.
 	function validateAttributes( attr1, attr2 ) {
 
 		if ( ! attr1 && ! attr2 ) {
 
-			return;
+			return true;
+
+		}
+
+		if ( Boolean( attr1 ) !== Boolean( attr2 ) ) {
+
+			return false;
 
 		}
 
@@ -61,10 +67,12 @@
 
 		if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
 
-			throw new Error();
+			return false;
 
 		}
 
+		return true;
+
 	}
 
 	function validateMergeability( geometries ) {
@@ -432,29 +440,22 @@
 
 	}
 
-	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 }|`;
 
 		}
 
@@ -885,6 +886,28 @@
 
 		}
 
+		// 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;
@@ -916,7 +939,7 @@
 		for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
 			const object = objects[ i ];
-			object.traverse( o => {
+			object.traverseVisible( o => {
 
 				if ( o.isMesh ) {
 
@@ -1074,15 +1097,24 @@
 				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 ) ) {
+
+					if ( geom ) {
+
+						geom.dispose();
+
+					}
 
-					_intermediateGeometry.set( meshKey, new BakedGeometry() );
+					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
@@ -1134,6 +1166,12 @@
 
 			// 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 ];
@@ -1445,6 +1483,17 @@
 
 	class MaterialBase extends three.ShaderMaterial {
 
+		set needsUpdate( v ) {
+
+			super.needsUpdate = true;
+			this.dispatchEvent( {
+
+				type: 'recompilation',
+
+			} );
+
+		}
+
 		constructor( shader ) {
 
 			super( shader );
@@ -3445,11 +3494,11 @@
 	// - https://github.com/hoverinc/ray-tracing-renderer
 	// - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
 
-	function shuffle( arr ) {
+	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;
@@ -3464,7 +3513,7 @@
 	// dimensions  : The number of dimensions to generate stratified values for
 	class StratifiedSampler {
 
-		constructor( strataCount, dimensions ) {
+		constructor( strataCount, dimensions, random = Math.random ) {
 
 			const l = strataCount ** dimensions;
 			const strata = new Uint16Array( l );
@@ -3481,7 +3530,19 @@
 
 			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;
 
@@ -3493,8 +3554,8 @@
 
 				if ( index >= strata.length ) {
 
-					shuffle( strata );
-					this.restart();
+					shuffle( strata, random );
+					this.reshuffle();
 
 				}
 
@@ -3502,7 +3563,7 @@
 
 				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 );
 
 				}
@@ -3520,7 +3581,7 @@
 	// Stratified set of data with each tuple stratified separately and combined
 	class StratifiedSamplerCombined {
 
-		constructor( strataCount, listOfDimensions ) {
+		constructor( strataCount, listOfDimensions, random = Math.random ) {
 
 			let totalDim = 0;
 			for ( const dim of listOfDimensions ) {
@@ -3534,7 +3595,7 @@
 			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 );
@@ -3557,11 +3618,21 @@
 
 			};
 
-			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();
 
 				}
 
@@ -3571,6 +3642,36 @@
 
 	}
 
+	// 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 );
+
+		}
+
+	}
+
 	class StratifiedSamplesTexture extends three.DataTexture {
 
 		constructor( count = 1, depth = 1, strata = 8 ) {
@@ -3581,22 +3682,37 @@
 
 			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;
@@ -3616,6 +3732,13 @@
 
 		}
 
+		reset() {
+
+			this.sampler.reset();
+			this.generator.seed = 0;
+
+		}
+
 	}
 
 	function shuffleArray( array, random = Math.random ) {
@@ -7779,6 +7902,9 @@ bool bvhIntersectFogVolumeHit(
 
 		set material( v ) {
 
+			this._fsQuad.material.removeEventListener( 'recompilation', this._compileFunction );
+			v.addEventListener( 'recompilation', this._compileFunction );
+
 			this._fsQuad.material = v;
 
 		}
@@ -7815,6 +7941,12 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		get isCompiling() {
+
+			return Boolean( this._compilePromise );
+
+		}
+
 		constructor( renderer ) {
 
 			this.camera = null;
@@ -7832,6 +7964,7 @@ bool bvhIntersectFogVolumeHit(
 			this._blendQuad = new Pass_js.FullScreenQuad( new BlendMaterial() );
 			this._task = null;
 			this._currentTile = 0;
+			this._compilePromise = null;
 
 			this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
@@ -7856,6 +7989,33 @@ bool bvhIntersectFogVolumeHit(
 				} ),
 			];
 
+			// 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 ) {
@@ -7887,7 +8047,6 @@ bool bvhIntersectFogVolumeHit(
 			material.setDefine( 'CAMERA_TYPE', cameraType );
 
 			this.camera = camera;
-			// this.reset();
 
 		}
 
@@ -7954,9 +8113,11 @@ bool bvhIntersectFogVolumeHit(
 			this.samples = 0;
 			this._task = null;
 
+			this.material.stratifiedTexture.stableNoise = this.stableNoise;
 			if ( this.stableNoise ) {
 
 				this.material.seed = 0;
+				this.material.stratifiedTexture.reset();
 
 			}
 
@@ -7964,6 +8125,15 @@ bool bvhIntersectFogVolumeHit(
 
 		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 );
@@ -8183,6 +8353,150 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
+	class CubeToEquirectMaterial extends three.ShaderMaterial {
+
+		constructor() {
+
+			super( {
+
+				uniforms: {
+
+					envMap: { value: null },
+					flipEnvMap: { value: - 1 },
+
+				},
+
+				vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}`,
+
+				fragmentShader: /* glsl */`
+				#define ENVMAP_TYPE_CUBE_UV
+
+				uniform samplerCube envMap;
+				uniform float flipEnvMap;
+				varying vec2 vUv;
+
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${ util_functions }
+
+				void main() {
+
+					vec3 rayDirection = equirectUvToDirection( vUv );
+					rayDirection.x *= flipEnvMap;
+					gl_FragColor = textureCube( envMap, rayDirection );
+
+				}`
+			} );
+
+			this.depthWrite = false;
+			this.depthTest = false;
+
+		}
+
+	}
+
+	class CubeToEquirectGenerator {
+
+		constructor( renderer ) {
+
+			this._renderer = renderer;
+			this._quad = new Pass_js.FullScreenQuad( new CubeToEquirectMaterial() );
+
+		}
+
+		generate( source, width = null, height = null ) {
+
+			if ( ! source.isCubeTexture ) {
+
+				throw new Error( 'CubeToEquirectMaterial: Source can only be cube textures.' );
+
+			}
+
+			const image = source.images[ 0 ];
+			const renderer = this._renderer;
+			const quad = this._quad;
+
+			// determine the dimensions if not provided
+			if ( width === null ) {
+
+				width = 4 * image.height;
+
+			}
+
+			if ( height === null ) {
+
+				height = 2 * image.height;
+
+			}
+
+			const target = new three.WebGLRenderTarget( width, height, {
+				type: three.FloatType,
+				colorSpace: image.colorSpace,
+			} );
+
+			// prep the cube map data
+			const imageHeight = image.height;
+			const maxMip = Math.log2( imageHeight ) - 2;
+			const texelHeight = 1.0 / imageHeight;
+			const texelWidth = 1.0 / ( 3 * Math.max( Math.pow( 2, maxMip ), 7 * 16 ) );
+
+			quad.material.defines.CUBEUV_MAX_MIP = `${ maxMip }.0`;
+			quad.material.defines.CUBEUV_TEXEL_WIDTH = texelWidth;
+			quad.material.defines.CUBEUV_TEXEL_HEIGHT = texelHeight;
+			quad.material.uniforms.envMap.value = source;
+			quad.material.uniforms.flipEnvMap.value = source.isRenderTargetTexture ? 1 : - 1;
+			quad.material.needsUpdate = true;
+
+			// save state and render the contents
+			const currentTarget = renderer.getRenderTarget();
+			const currentAutoClear = renderer.autoClear;
+			renderer.autoClear = true;
+			renderer.setRenderTarget( target );
+			quad.render( renderer );
+			renderer.setRenderTarget( currentTarget );
+			renderer.autoClear = currentAutoClear;
+
+			// read the data back
+			const buffer = new Uint16Array( width * height * 4 );
+			const readBuffer = new Float32Array( width * height * 4 );
+			renderer.readRenderTargetPixels( target, 0, 0, width, height, readBuffer );
+			target.dispose();
+
+			for ( let i = 0, l = readBuffer.length; i < l; i ++ ) {
+
+				buffer[ i ] = three.DataUtils.toHalfFloat( readBuffer[ i ] );
+
+			}
+
+			// produce the data texture
+			const result = new three.DataTexture( buffer, width, height, three.RGBAFormat, three.HalfFloatType );
+			result.minFilter = three.LinearMipMapLinearFilter;
+			result.magFilter = three.LinearFilter;
+			result.wrapS = three.RepeatWrapping;
+			result.wrapT = three.RepeatWrapping;
+			result.mapping = three.EquirectangularReflectionMapping;
+			result.needsUpdate = true;
+
+			return result;
+
+		}
+
+		dispose() {
+
+			this._quad.dispose();
+
+		}
+
+	}
+
 	function supportsFloatBlending( renderer ) {
 
 		return renderer.extensions.get( 'EXT_float_blend' );
@@ -8258,6 +8572,24 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		get stableNoise() {
+
+			return this._pathTracer.stableNoise;
+
+		}
+
+		set stableNoise( v ) {
+
+			this._pathTracer.stableNoise = v;
+
+		}
+
+		get isCompiling() {
+
+			return Boolean( this._pathTracer.isCompiling );
+
+		}
+
 		constructor( renderer ) {
 
 			// members
@@ -8266,6 +8598,7 @@ bool bvhIntersectFogVolumeHit(
 			this._pathTracer = new PathTracingRenderer( renderer );
 			this._queueReset = false;
 			this._clock = new three.Clock();
+			this._compilePromise = null;
 
 			this._lowResPathTracer = new PathTracingRenderer( renderer );
 			this._lowResPathTracer.tiles.set( 1, 1 );
@@ -8278,6 +8611,10 @@ bool bvhIntersectFogVolumeHit(
 			} ) );
 			this._materials = null;
 
+			this._previousEnvironment = null;
+			this._previousBackground = null;
+			this._internalBackground = null;
+
 			// options
 			this.renderDelay = 100;
 			this.minSamples = 5;
@@ -8406,6 +8743,13 @@ bool bvhIntersectFogVolumeHit(
 			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;
@@ -8433,6 +8777,17 @@ bool bvhIntersectFogVolumeHit(
 				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;
@@ -8445,12 +8800,21 @@ bool bvhIntersectFogVolumeHit(
 			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 {
 
@@ -8461,6 +8825,7 @@ bool bvhIntersectFogVolumeHit(
 			}
 
 			this._previousEnvironment = scene.environment;
+			this._previousBackground = scene.background;
 			this.reset();
 
 		}
@@ -8531,7 +8896,7 @@ bool bvhIntersectFogVolumeHit(
 			// 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();
 
@@ -8564,7 +8929,7 @@ bool bvhIntersectFogVolumeHit(
 				// 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 ) {
 
@@ -8579,7 +8944,9 @@ bool bvhIntersectFogVolumeHit(
 						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 );