three-gpu-pathtracer 0.0.21 → 0.0.23

package/build/index.module.js

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial } from 'three';
+import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, LinearMipMapLinearFilter, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial } from 'three';
 import { SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 
@@ -43,12 +43,18 @@ 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.
 function validateAttributes( attr1, attr2 ) {
 
 	if ( ! attr1 && ! attr2 ) {
 
-		return;
+		return true;
+
+	}
+
+	if ( Boolean( attr1 ) !== Boolean( attr2 ) ) {
+
+		return false;
 
 	}
 
@@ -59,10 +65,12 @@ function validateAttributes( attr1, attr2 ) {
 
 	if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
 
-		throw new Error();
+		return false;
 
 	}
 
+	return true;
+
 }
 
 function validateMergeability( geometries ) {
@@ -430,29 +438,22 @@ function bufferToHash( buffer ) {
 
 }
 
-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 }|`;
 
 	}
 
@@ -883,6 +884,28 @@ 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;
@@ -914,7 +937,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 ) {
 
@@ -1072,15 +1095,24 @@ 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 ) ) {
+
+				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
@@ -1132,6 +1164,12 @@ 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 ];
@@ -1443,6 +1481,17 @@ class PathTracingSceneWorker extends PathTracingSceneGenerator {
 
 class MaterialBase extends ShaderMaterial {
 
+	set needsUpdate( v ) {
+
+		super.needsUpdate = true;
+		this.dispatchEvent( {
+
+			type: 'recompilation',
+
+		} );
+
+	}
+
 	constructor( shader ) {
 
 		super( shader );
@@ -3443,11 +3492,11 @@ class CopyMaterial extends ShaderMaterial {
 // - 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;
@@ -3462,7 +3511,7 @@ function shuffle( arr ) {
 // 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 );
@@ -3479,7 +3528,19 @@ 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;
 
@@ -3491,8 +3552,8 @@ class StratifiedSampler {
 
 			if ( index >= strata.length ) {
 
-				shuffle( strata );
-				this.restart();
+				shuffle( strata, random );
+				this.reshuffle();
 
 			}
 
@@ -3500,7 +3561,7 @@ 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 );
 
 			}
@@ -3518,7 +3579,7 @@ class StratifiedSampler {
 // 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 ) {
@@ -3532,7 +3593,7 @@ 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 );
@@ -3555,11 +3616,21 @@ 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();
 
 			}
 
@@ -3569,6 +3640,36 @@ class StratifiedSamplerCombined {
 
 }
 
+// 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 DataTexture {
 
 	constructor( count = 1, depth = 1, strata = 8 ) {
@@ -3579,22 +3680,37 @@ 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;
@@ -3614,6 +3730,13 @@ class StratifiedSamplesTexture extends DataTexture {
 
 	}
 
+	reset() {
+
+		this.sampler.reset();
+		this.generator.seed = 0;
+
+	}
+
 }
 
 function shuffleArray( array, random = Math.random ) {
@@ -7777,6 +7900,9 @@ class PathTracingRenderer {
 
 	set material( v ) {
 
+		this._fsQuad.material.removeEventListener( 'recompilation', this._compileFunction );
+		v.addEventListener( 'recompilation', this._compileFunction );
+
 		this._fsQuad.material = v;
 
 	}
@@ -7813,6 +7939,12 @@ class PathTracingRenderer {
 
 	}
 
+	get isCompiling() {
+
+		return Boolean( this._compilePromise );
+
+	}
+
 	constructor( renderer ) {
 
 		this.camera = null;
@@ -7830,6 +7962,7 @@ class PathTracingRenderer {
 		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
 		this._task = null;
 		this._currentTile = 0;
+		this._compilePromise = null;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
@@ -7854,6 +7987,33 @@ 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 ) {
@@ -7885,7 +8045,6 @@ class PathTracingRenderer {
 		material.setDefine( 'CAMERA_TYPE', cameraType );
 
 		this.camera = camera;
-		// this.reset();
 
 	}
 
@@ -7952,9 +8111,11 @@ 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();
 
 		}
 
@@ -7962,6 +8123,15 @@ 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 );
@@ -8181,6 +8351,150 @@ class ClampedInterpolationMaterial extends ShaderMaterial {
 
 }
 
+class CubeToEquirectMaterial extends 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 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 WebGLRenderTarget( width, height, {
+			type: 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 ] = DataUtils.toHalfFloat( readBuffer[ i ] );
+
+		}
+
+		// produce the data texture
+		const result = new DataTexture( buffer, width, height, RGBAFormat, HalfFloatType );
+		result.minFilter = LinearMipMapLinearFilter;
+		result.magFilter = LinearFilter;
+		result.wrapS = RepeatWrapping;
+		result.wrapT = RepeatWrapping;
+		result.mapping = EquirectangularReflectionMapping;
+		result.needsUpdate = true;
+
+		return result;
+
+	}
+
+	dispose() {
+
+		this._quad.dispose();
+
+	}
+
+}
+
 function supportsFloatBlending( renderer ) {
 
 	return renderer.extensions.get( 'EXT_float_blend' );
@@ -8256,6 +8570,24 @@ 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
@@ -8264,6 +8596,7 @@ 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 );
@@ -8276,6 +8609,10 @@ class WebGLPathTracer {
 		} ) );
 		this._materials = null;
 
+		this._previousEnvironment = null;
+		this._previousBackground = null;
+		this._internalBackground = null;
+
 		// options
 		this.renderDelay = 100;
 		this.minSamples = 5;
@@ -8404,6 +8741,13 @@ 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;
@@ -8431,6 +8775,17 @@ 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;
@@ -8443,12 +8798,21 @@ 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 {
 
@@ -8459,6 +8823,7 @@ class WebGLPathTracer {
 		}
 
 		this._previousEnvironment = scene.environment;
+		this._previousBackground = scene.background;
 		this.reset();
 
 	}
@@ -8529,7 +8894,7 @@ 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();
 
@@ -8562,7 +8927,7 @@ 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 ) {
 
@@ -8577,7 +8942,9 @@ 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 );