three-gpu-pathtracer 0.0.20 → 0.0.21

package/src/core/WebGLPathTracer.js

@@ -0,0 +1,472 @@
+import { PerspectiveCamera, Scene, Vector2, Clock, NormalBlending, NoBlending, AdditiveBlending } from 'three';
+import { PathTracingSceneGenerator } from './PathTracingSceneGenerator.js';
+import { PathTracingRenderer } from './PathTracingRenderer.js';
+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';
+
+function supportsFloatBlending( renderer ) {
+
+	return renderer.extensions.get( 'EXT_float_blend' );
+
+}
+
+const _resolution = new Vector2();
+export class WebGLPathTracer {
+
+	get multipleImportanceSampling() {
+
+		return Boolean( this._pathTracer.material.defines.FEATURE_MIS );
+
+	}
+
+	set multipleImportanceSampling( v ) {
+
+		this._pathTracer.material.setDefine( 'FEATURE_MIS', v ? 1 : 0 );
+
+	}
+
+	get transmissiveBounces() {
+
+		return this._pathTracer.material.transmissiveBounces;
+
+	}
+
+	set transmissiveBounces( v ) {
+
+		this._pathTracer.material.transmissiveBounces = v;
+
+	}
+
+	get bounces() {
+
+		return this._pathTracer.material.bounces;
+
+	}
+
+	set bounces( v ) {
+
+		this._pathTracer.material.bounces = v;
+
+	}
+
+	get filterGlossyFactor() {
+
+		return this._pathTracer.material.filterGlossyFactor;
+
+	}
+
+	set filterGlossyFactor( v ) {
+
+		this._pathTracer.material.filterGlossyFactor = v;
+
+	}
+
+	get samples() {
+
+		return this._pathTracer.samples;
+
+	}
+
+	get target() {
+
+		return this._pathTracer.target;
+
+	}
+
+	get tiles() {
+
+		return this._pathTracer.tiles;
+
+	}
+
+	constructor( renderer ) {
+
+		// members
+		this._renderer = renderer;
+		this._generator = new PathTracingSceneGenerator();
+		this._pathTracer = new PathTracingRenderer( renderer );
+		this._queueReset = false;
+		this._clock = new Clock();
+
+		this._lowResPathTracer = new PathTracingRenderer( renderer );
+		this._lowResPathTracer.tiles.set( 1, 1 );
+		this._quad = new FullScreenQuad( new ClampedInterpolationMaterial( {
+			map: null,
+			transparent: true,
+			blending: NoBlending,
+
+			premultipliedAlpha: renderer.getContextAttributes().premultipliedAlpha,
+		} ) );
+		this._materials = null;
+
+		// options
+		this.renderDelay = 100;
+		this.minSamples = 5;
+		this.fadeDuration = 500;
+		this.enablePathTracing = true;
+		this.pausePathTracing = false;
+		this.dynamicLowRes = false;
+		this.lowResScale = 0.25;
+		this.renderScale = 1;
+		this.synchronizeRenderSize = true;
+		this.rasterizeScene = true;
+		this.renderToCanvas = true;
+		this.textureSize = new Vector2( 1024, 1024 );
+		this.rasterizeSceneCallback = ( scene, camera ) => {
+
+			this._renderer.render( scene, camera );
+
+		};
+
+		this.renderToCanvasCallback = ( target, renderer, quad ) => {
+
+			const currentAutoClear = renderer.autoClear;
+			renderer.autoClear = false;
+			quad.render( renderer );
+			renderer.autoClear = currentAutoClear;
+
+		};
+
+		// initialize the scene so it doesn't fail
+		this.setScene( new Scene(), new PerspectiveCamera() );
+
+	}
+
+	setBVHWorker( worker ) {
+
+		this._generator.setBVHWorker( worker );
+
+	}
+
+	setScene( scene, camera, options = {} ) {
+
+		scene.updateMatrixWorld( true );
+		camera.updateMatrixWorld();
+
+		const generator = this._generator;
+		generator.setObjects( scene );
+
+		if ( this._buildAsync ) {
+
+			return generator.generateAsync( options.onProgress ).then( result => {
+
+				return this._updateFromResults( scene, camera, result );
+
+			} );
+
+		} else {
+
+			const result = generator.generate();
+			return this._updateFromResults( scene, camera, result );
+
+		}
+
+	}
+
+	setSceneAsync( ...args ) {
+
+		this._buildAsync = true;
+		const result = this.setScene( ...args );
+		this._buildAsync = false;
+
+		return result;
+
+	}
+
+	setCamera( camera ) {
+
+		this.camera = camera;
+		this.updateCamera();
+
+	}
+
+	updateCamera() {
+
+		const camera = this.camera;
+		camera.updateMatrixWorld();
+
+		this._pathTracer.setCamera( camera );
+		this._lowResPathTracer.setCamera( camera );
+		this.reset();
+
+	}
+
+	updateMaterials() {
+
+		const material = this._pathTracer.material;
+		const renderer = this._renderer;
+		const materials = this._materials;
+		const textureSize = this.textureSize;
+
+		// reduce texture sources here - we don't want to do this in the
+		// textures array because we need to pass the textures array into the
+		// material target
+		const textures = getTextures( materials );
+		material.textures.setTextures( renderer, textures, textureSize.x, textureSize.y );
+		material.materials.updateFrom( materials, textures );
+		this.reset();
+
+	}
+
+	updateLights() {
+
+		const scene = this.scene;
+		const renderer = this._renderer;
+		const material = this._pathTracer.material;
+
+		const lights = getLights( scene );
+		const iesTextures = getIesTextures( lights );
+		material.lights.updateFrom( lights, iesTextures );
+		material.iesProfiles.setTextures( renderer, iesTextures );
+		this.reset();
+
+	}
+
+	updateEnvironment() {
+
+		const scene = this.scene;
+		const material = this._pathTracer.material;
+
+		// update scene background
+		material.backgroundBlur = scene.backgroundBlurriness;
+		material.backgroundIntensity = scene.backgroundIntensity ?? 1;
+		material.backgroundRotation.makeRotationFromEuler( scene.backgroundRotation ).invert();
+		if ( scene.background === null ) {
+
+			material.backgroundMap = null;
+			material.backgroundAlpha = 0;
+
+		} else if ( scene.background.isColor ) {
+
+			this._colorBackground = this._colorBackground || new GradientEquirectTexture( 16 );
+
+			const colorBackground = this._colorBackground;
+			if ( ! colorBackground.topColor.equals( scene.background ) ) {
+
+				// set the texture color
+				colorBackground.topColor.set( scene.background );
+				colorBackground.bottomColor.set( scene.background );
+				colorBackground.update();
+
+			}
+
+			// assign to material
+			material.backgroundMap = colorBackground;
+			material.backgroundAlpha = 1;
+
+		} else {
+
+			material.backgroundMap = scene.background;
+			material.backgroundAlpha = 1;
+
+		}
+
+		// update scene environment
+		material.environmentIntensity = scene.environmentIntensity ?? 1;
+		material.environmentRotation.makeRotationFromEuler( scene.environmentRotation ).invert();
+		if ( this._previousEnvironment !== scene.environment ) {
+
+			if ( scene.environment ) {
+
+				// 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 {
+
+				material.environmentIntensity = 0;
+
+			}
+
+		}
+
+		this._previousEnvironment = scene.environment;
+		this.reset();
+
+	}
+
+	_updateFromResults( scene, camera, results ) {
+
+		const {
+			materials,
+			geometry,
+			bvh,
+			bvhChanged,
+		} = results;
+
+		this._materials = materials;
+
+		const pathTracer = this._pathTracer;
+		const material = pathTracer.material;
+
+		if ( bvhChanged ) {
+
+			material.bvh.updateFrom( bvh );
+			material.attributesArray.updateFrom(
+				geometry.attributes.normal,
+				geometry.attributes.tangent,
+				geometry.attributes.uv,
+				geometry.attributes.color,
+			);
+
+			material.materialIndexAttribute.updateFrom( geometry.attributes.materialIndex );
+
+		}
+
+		// save previously used items
+		this._previousScene = scene;
+		this.scene = scene;
+		this.camera = camera;
+
+		this.updateCamera();
+		this.updateMaterials();
+		this.updateEnvironment();
+		this.updateLights();
+
+		return results;
+
+	}
+
+	renderSample() {
+
+		const lowResPathTracer = this._lowResPathTracer;
+		const pathTracer = this._pathTracer;
+		const renderer = this._renderer;
+		const clock = this._clock;
+		const quad = this._quad;
+
+		this._updateScale();
+
+		if ( this._queueReset ) {
+
+			pathTracer.reset();
+			lowResPathTracer.reset();
+			this._queueReset = false;
+
+			quad.material.opacity = 0;
+			clock.start();
+
+		}
+
+		// 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 ) {
+
+			pathTracer.update();
+
+		}
+
+		// when alpha is enabled we use a manual blending system rather than
+		// rendering with a blend function
+		pathTracer.alpha = pathTracer.material.backgroundAlpha !== 1 || ! supportsFloatBlending( renderer );
+		lowResPathTracer.alpha = pathTracer.alpha;
+
+		if ( this.renderToCanvas ) {
+
+			const renderer = this._renderer;
+			const minSamples = this.minSamples;
+
+			if ( elapsedTime >= this.renderDelay && this.samples >= this.minSamples ) {
+
+				if ( this.fadeDuration !== 0 ) {
+
+					quad.material.opacity = Math.min( quad.material.opacity + delta / this.fadeDuration, 1 );
+
+				} else {
+
+					quad.material.opacity = 1;
+
+				}
+
+			}
+
+			// 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 ( lowResPathTracer.samples < 1 ) {
+
+						lowResPathTracer.material = pathTracer.material;
+						lowResPathTracer.update();
+
+					}
+
+					const currentOpacity = quad.material.opacity;
+					quad.material.opacity = 1 - quad.material.opacity;
+					quad.material.map = lowResPathTracer.target.texture;
+					quad.render( renderer );
+					quad.material.opacity = currentOpacity;
+
+				} else if ( this.rasterizeScene ) {
+
+					this.rasterizeSceneCallback( this.scene, this.camera );
+
+				}
+
+			}
+
+
+			if ( this.enablePathTracing && quad.material.opacity > 0 ) {
+
+				if ( quad.material.opacity < 1 ) {
+
+					// use additive blending when the low res texture is rendered so we can fade the
+					// background out while the full res fades in
+					quad.material.blending = this.dynamicLowRes ? AdditiveBlending : NormalBlending;
+
+				}
+
+				quad.material.map = pathTracer.target.texture;
+				this.renderToCanvasCallback( pathTracer.target, renderer, quad );
+				quad.material.blending = NoBlending;
+
+			}
+
+		}
+
+	}
+
+	reset() {
+
+		this._queueReset = true;
+		this._pathTracer.samples = 0;
+
+	}
+
+	dispose() {
+
+		this._renderQuad.dispose();
+		this._renderQuad.material.dispose();
+		this._pathTracer.dispose();
+
+	}
+
+	_updateScale() {
+
+		// update the path tracer scale if it has changed
+		if ( this.synchronizeRenderSize ) {
+
+			this._renderer.getDrawingBufferSize( _resolution );
+
+			const w = Math.floor( this.renderScale * _resolution.x );
+			const h = Math.floor( this.renderScale * _resolution.y );
+
+			this._pathTracer.getSize( _resolution );
+			if ( _resolution.x !== w || _resolution.y !== h ) {
+
+				const lowResScale = this.lowResScale;
+				this._pathTracer.setSize( w, h );
+				this._lowResPathTracer.setSize( Math.floor( w * lowResScale ), Math.floor( h * lowResScale ) );
+
+			}
+
+		}
+
+	}
+
+}

package/src/core/utils/BakedGeometry.js

@@ -0,0 +1,35 @@
+import { BufferGeometry } from 'three';
+import { MeshDiff } from './MeshDiff.js';
+import { convertToStaticGeometry } from './convertToStaticGeometry.js';
+
+export class BakedGeometry extends BufferGeometry {
+
+	constructor() {
+
+		super();
+		this.version = 0;
+		this.hash = null;
+		this._diff = new MeshDiff();
+
+	}
+
+	updateFrom( mesh, options ) {
+
+		const diff = this._diff;
+		if ( diff.didChange( mesh ) ) {
+
+			convertToStaticGeometry( mesh, options, this );
+			diff.updateFrom( mesh );
+			this.version ++;
+			this.hash = `${ this.uuid }_${ this.version }`;
+			return true;
+
+		} else {
+
+			return false;
+
+		}
+
+	}
+
+}

package/src/core/utils/BufferAttributeUtils.js

@@ -0,0 +1,64 @@
+import { BufferAttribute } from 'three';
+
+// target offset is the number of elements in the target buffer stride to skip before copying the
+// attributes contents in to.
+export function copyAttributeContents( attr, target, targetOffset = 0 ) {
+
+	if ( attr.isInterleavedBufferAttribute ) {
+
+		const itemSize = attr.itemSize;
+		for ( let i = 0, l = attr.count; i < l; i ++ ) {
+
+			const io = i + targetOffset;
+			target.setX( io, attr.getX( i ) );
+			if ( itemSize >= 2 ) target.setY( io, attr.getY( i ) );
+			if ( itemSize >= 3 ) target.setZ( io, attr.getZ( i ) );
+			if ( itemSize >= 4 ) target.setW( io, attr.getW( i ) );
+
+		}
+
+	} else {
+
+		const array = target.array;
+		const cons = array.constructor;
+		const byteOffset = array.BYTES_PER_ELEMENT * attr.itemSize * targetOffset;
+		const temp = new cons( array.buffer, byteOffset, attr.array.length );
+		temp.set( attr.array );
+
+	}
+
+}
+
+// Clones the given attribute with a new compatible buffer attribute but no data
+export function createAttributeClone( attr, countOverride = null ) {
+
+	const cons = attr.array.constructor;
+	const normalized = attr.normalized;
+	const itemSize = attr.itemSize;
+	const count = countOverride === null ? attr.count : countOverride;
+
+	return new BufferAttribute( new cons( itemSize * count ), itemSize, normalized );
+
+}
+
+// Confirms that the two provided attributes are compatible
+export function validateAttributes( attr1, attr2 ) {
+
+	if ( ! attr1 && ! attr2 ) {
+
+		return;
+
+	}
+
+	const sameCount = attr1.count === attr2.count;
+	const sameNormalized = attr1.normalized === attr2.normalized;
+	const sameType = attr1.array.constructor === attr2.array.constructor;
+	const sameItemSize = attr1.itemSize === attr2.itemSize;
+
+	if ( ! sameCount || ! sameNormalized || ! sameType || ! sameItemSize ) {
+
+		throw new Error();
+
+	}
+
+}

package/src/{utils → core/utils}/GeometryPreparationUtils.js

@@ -1,6 +1,6 @@
 import { BufferAttribute } from 'three';
-import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
-export function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
+
+export function updateMaterialIndexAttribute( geometry, materials, allMaterials ) {
 
 	const indexAttr = geometry.index;
 	const posAttr = geometry.attributes.position;
@@ -13,18 +13,28 @@ export function getGroupMaterialIndicesAttribute( geometry, materials, allMateri
 
 	}
 
-	// use an array with the minimum precision required to store all material id references.
-	let materialArray;
-	if ( allMaterials.length <= 255 ) {
+	let materialIndexAttribute = geometry.getAttribute( 'materialIndex' );
+	if ( ! materialIndexAttribute || materialIndexAttribute.count !== vertCount ) {
+
+		// use an array with the minimum precision required to store all material id references.
+		let array;
+		if ( allMaterials.length <= 255 ) {
+
+			array = new Uint8Array( vertCount );
+
+		} else {
 
-		materialArray = new Uint8Array( vertCount );
+			array = new Uint16Array( vertCount );
 
-	} else {
+		}
 
-		materialArray = new Uint16Array( vertCount );
+		materialIndexAttribute = new BufferAttribute( array, 1, false );
+		geometry.deleteAttribute( 'materialIndex' );
+		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
 
 	}
 
+	const materialArray = materialIndexAttribute.array;
 	for ( let i = 0; i < groups.length; i ++ ) {
 
 		const group = groups[ i ];
@@ -50,13 +60,24 @@ export function getGroupMaterialIndicesAttribute( geometry, materials, allMateri
 
 	}
 
-	return new BufferAttribute( materialArray, 1, false );
-
 }
 
-export function setCommonAttributes( geometry, options ) {
+export function setCommonAttributes( geometry, attributes ) {
+
+	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 );
 
-	const { attributes = [], normalMapRequired = false } = options;
+	}
 
 	if ( ! geometry.attributes.normal && ( attributes && attributes.includes( 'normal' ) ) ) {
 
@@ -80,14 +101,8 @@ export function setCommonAttributes( geometry, options ) {
 
 	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
 
-		if ( normalMapRequired ) {
-
-			// computeTangents requires an index buffer
-			if ( geometry.index === null ) {
-
-				geometry = mergeVertices( geometry );
-
-			}
+		// compute tangents requires a uv and normal buffer
+		if ( geometry.attributes.uv && geometry.attributes.normal ) {
 
 			geometry.computeTangents();
 
@@ -109,19 +124,4 @@ export function setCommonAttributes( geometry, options ) {
 
 	}
 
-	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 );
-
-	}
-
 }