three-gpu-pathtracer 0.0.20 → 0.0.21

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "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",
   "type": "module",
+  "types": "src/index.d.ts",
   "sideEffects": false,
   "files": [
     "src/*",
@@ -30,24 +31,29 @@
   ],
   "devDependencies": {
     "@lookingglass/webxr": "^0.3.1",
+    "@monogrid/gainmap-js": "^3.0.5",
+    "@types/node": "^20.12.7",
+    "@types/three": "^0.163.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "canvas-capture": "^2.0.5",
     "eslint": "^7.32.0",
     "eslint-config-mdcs": "^5.0.0",
     "node-fetch": "^3.2.9",
-    "parcel": "^2.4.0",
+    "parcel": "^2.12.0",
     "pixelmatch": "^5.3.0",
     "pngjs": "^6.0.0",
     "process": "^0.11.10",
     "puppeteer": "^15.4.0",
     "rollup": "^2.70.0",
     "simple-git": "^3.10.0",
-    "three": "^0.160.0",
-    "three-mesh-bvh": "^0.7.3",
+    "three": "^0.163.0",
+    "three-mesh-bvh": "^0.7.4",
+    "typescript": "5.3.3",
     "yargs": "^17.5.1"
   },
   "peerDependencies": {
     "three": ">=0.151.0",
-    "three-mesh-bvh": ">=0.7.0",
+    "three-mesh-bvh": ">=0.7.4",
     "xatlas-web": "^0.1.0"
   },
   "scripts": {
@@ -56,7 +62,7 @@
     "update-screenshots": "node ./scripts/push-screenshots.js",
     "screenshot-diff": "node ./scripts/regression-test.js",
     "build": "rollup -c",
-    "lint": "eslint \"./src/**/*.{js,ts}\" \"./example/*.js\"",
+    "lint": "eslint \"./src/**/*.{js,ts}\" \"./example/*.js\" && tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "repository": {

package/src/core/PathTracingRenderer.js

@@ -1,7 +1,8 @@
-import { RGBAFormat, FloatType, HalfFloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4 } from 'three';
+import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4, NearestFilter } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { BlendMaterial } from '../materials/fullscreen/BlendMaterial.js';
 import { SobolNumberMapGenerator } from '../utils/SobolNumberMapGenerator.js';
+import { PhysicalPathTracingMaterial } from '../materials/pathtracing/PhysicalPathTracingMaterial.js';
 
 function* renderTask() {
 
@@ -14,7 +15,6 @@ function* renderTask() {
 		_sobolTarget,
 		_subframe,
 		alpha,
-		camera,
 		material,
 	} = this;
 	const _ogScissor = new Vector4();
@@ -27,13 +27,13 @@ function* renderTask() {
 
 		if ( alpha ) {
 
-			blendMaterial.opacity = this._opacityFactor / ( this._samples + 1 );
+			blendMaterial.opacity = this._opacityFactor / ( this.samples + 1 );
 			material.blending = NoBlending;
 			material.opacity = 1;
 
 		} else {
 
-			material.opacity = this._opacityFactor / ( this._samples + 1 );
+			material.opacity = this._opacityFactor / ( this.samples + 1 );
 			material.blending = NormalBlending;
 
 		}
@@ -64,30 +64,6 @@ function* renderTask() {
 
 			for ( let x = 0; x < tilesX; x ++ ) {
 
-				material.cameraWorldMatrix.copy( camera.matrixWorld );
-				material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
-
-				// Perspective camera (default)
-				let cameraType = 0;
-
-				// An orthographic projection matrix will always have the bottom right element == 1
-				// And a perspective projection matrix will always have the bottom right element == 0
-				if ( camera.projectionMatrix.elements[ 15 ] > 0 ) {
-
-					// Orthographic
-					cameraType = 1;
-
-				}
-
-				if ( camera.isEquirectCamera ) {
-
-					// Equirectangular
-					cameraType = 2;
-
-				}
-
-				material.setDefine( 'CAMERA_TYPE', cameraType );
-
 				// store og state
 				const ogRenderTarget = _renderer.getRenderTarget();
 				const ogAutoClear = _renderer.autoClear;
@@ -151,12 +127,12 @@ function* renderTask() {
 
 				}
 
-				this._samples += ( 1 / totalTiles );
+				this.samples += ( 1 / totalTiles );
 
 				// round the samples value if we've finished the tiles
 				if ( x === tilesX - 1 && y === tilesY - 1 ) {
 
-					this._samples = Math.round( this._samples );
+					this.samples = Math.round( this.samples );
 
 				}
 
@@ -219,52 +195,82 @@ export class PathTracingRenderer {
 
 	}
 
-	get samples() {
-
-		return this._samples;
-
-	}
-
 	constructor( renderer ) {
 
 		this.camera = null;
-		this.tiles = new Vector2( 1, 1 );
+		this.tiles = new Vector2( 3, 3 );
 
 		this.stableNoise = false;
 		this.stableTiles = true;
 
-		this._samples = 0;
+		this.samples = 0;
 		this._subframe = new Vector4( 0, 0, 1, 1 );
 		this._opacityFactor = 1.0;
 		this._renderer = renderer;
 		this._alpha = false;
-		this._fsQuad = new FullScreenQuad( null );
+		this._fsQuad = new FullScreenQuad( new PhysicalPathTracingMaterial() );
 		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
 		this._task = null;
 		this._currentTile = 0;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 
-		// will be null if extension not supported
-		const floatLinearExtensionSupported = renderer.extensions.get( 'OES_texture_float_linear' );
-
 		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
 			format: RGBAFormat,
-			type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
+			type: FloatType,
+			magFilter: NearestFilter,
+			minFilter: NearestFilter,
 		} );
 		this._blendTargets = [
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
+				type: FloatType,
+				magFilter: NearestFilter,
+				minFilter: NearestFilter,
 			} ),
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
+				type: FloatType,
+				magFilter: NearestFilter,
+				minFilter: NearestFilter,
 			} ),
 		];
 
 	}
 
+	setCamera( camera ) {
+
+		const { material } = this;
+		material.cameraWorldMatrix.copy( camera.matrixWorld );
+		material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
+		material.physicalCamera.updateFrom( camera );
+
+		// Perspective camera (default)
+		let cameraType = 0;
+
+		// An orthographic projection matrix will always have the bottom right element == 1
+		// And a perspective projection matrix will always have the bottom right element == 0
+		if ( camera.projectionMatrix.elements[ 15 ] > 0 ) {
+
+			// Orthographic
+			cameraType = 1;
+
+		}
+
+		if ( camera.isEquirectCamera ) {
+
+			// Equirectangular
+			cameraType = 2;
+
+		}
+
+		material.setDefine( 'CAMERA_TYPE', cameraType );
+
+		this.camera = camera;
+		// this.reset();
+
+	}
+
 	setSize( w, h ) {
 
 		w = Math.ceil( w );
@@ -283,6 +289,13 @@ export class PathTracingRenderer {
 
 	}
 
+	getSize( target ) {
+
+		target.x = this._primaryTarget.width;
+		target.y = this._primaryTarget.height;
+
+	}
+
 	dispose() {
 
 		this._primaryTarget.dispose();
@@ -318,7 +331,7 @@ export class PathTracingRenderer {
 		_renderer.setClearColor( ogClearColor, ogClearAlpha );
 		_renderer.setRenderTarget( ogRenderTarget );
 
-		this._samples = 0;
+		this.samples = 0;
 		this._task = null;
 
 		if ( this.stableNoise ) {

package/src/core/PathTracingSceneGenerator.js

@@ -1,24 +1,259 @@
-import { DynamicPathTracingSceneGenerator } from './DynamicPathTracingSceneGenerator.js';
+import { BufferGeometry } from 'three';
+import { MeshBVH, SAH } from 'three-mesh-bvh';
+import { StaticGeometryGenerator, NO_CHANGE, GEOMETRY_ADJUSTED, GEOMETRY_REBUILT } from './utils/StaticGeometryGenerator.js';
+import { updateMaterialIndexAttribute } from './utils/GeometryPreparationUtils.js';
+
+// collect the textures from the materials
+function getTextures( materials ) {
+
+	const textureSet = new Set();
+	for ( let i = 0, l = materials.length; i < l; i ++ ) {
+
+		const material = materials[ i ];
+		for ( const key in material ) {
+
+			const value = material[ key ];
+			if ( value && value.isTexture ) {
+
+				textureSet.add( value );
+
+			}
+
+		}
+
+	}
+
+	return Array.from( textureSet );
+
+}
+
+// collect the lights in the scene
+function getLights( objects ) {
+
+	const lights = [];
+	const iesSet = new Set();
+	for ( let i = 0, l = objects.length; i < l; i ++ ) {
+
+		objects[ i ].traverse( c => {
+
+			if ( c.visible ) {
+
+				if (
+					c.isRectAreaLight ||
+					c.isSpotLight ||
+					c.isPointLight ||
+					c.isDirectionalLight
+				) {
+
+					lights.push( c );
+
+					if ( c.iesMap ) {
+
+						iesSet.add( c.iesMap );
+
+					}
+
+				}
+
+			}
+
+		} );
+
+	}
+
+	const iesTextures = Array.from( iesSet ).sort( ( a, b ) => {
+
+		if ( a.uuid < b.uuid ) return 1;
+		if ( a.uuid > b.uuid ) return - 1;
+		return 0;
+
+	} );
+
+	return { lights, iesTextures };
+
+}
 
 export class PathTracingSceneGenerator {
 
-	generate( scene, options = {} ) {
+	get initialized() {
+
+		return Boolean( this.bvh );
+
+	}
+
+	constructor( objects ) {
+
+		// options
+		this.bvhOptions = {};
+		this.attributes = [ 'position', 'normal', 'tangent', 'color', 'uv', 'uv2' ];
+		this.generateBVH = true;
+
+		// state
+		this.bvh = null;
+		this.geometry = new BufferGeometry();
+		this.staticGeometryGenerator = new StaticGeometryGenerator( objects );
+		this._bvhWorker = null;
+		this._pendingGenerate = null;
+		this._buildAsync = false;
+
+	}
+
+	setObjects( objects ) {
+
+		this.staticGeometryGenerator.setObjects( objects );
+
+	}
+
+	setBVHWorker( bvhWorker ) {
+
+		this._bvhWorker = bvhWorker;
+
+	}
+
+	async generateAsync( onProgress = null ) {
+
+		if ( ! this._bvhWorker ) {
+
+			throw new Error( 'PathTracingSceneGenerator: "setBVHWorker" must be called before "generateAsync" can be called.' );
+
+		}
 
-		// ensure scene transforms are up to date
-		// TODO: remove this?
-		if ( Array.isArray( scene ) ) {
+		if ( this.bvh instanceof Promise ) {
 
-			scene.forEach( s => s.updateMatrixWorld( true ) );
+			// if a bvh is already being generated we can wait for that to finish
+			// and build another with the latest data while sharing the results.
+			if ( ! this._pendingGenerate ) {
+
+				this._pendingGenerate = new Promise( async () => {
+
+					await this.bvh;
+					this._pendingGenerate = null;
+
+					// TODO: support multiple callbacks queued?
+					return this.generateAsync( onProgress );
+
+				} );
+
+			}
+
+			return this._pendingGenerate;
 
 		} else {
 
-			scene.updateMatrixWorld( true );
+			this._buildAsync = true;
+			const result = this.generate( onProgress );
+			this._buildAsync = false;
+
+			result.bvh = this.bvh = await result.bvh;
+			return result;
 
 		}
 
-		const generator = new DynamicPathTracingSceneGenerator( scene );
-		generator.bvhOptions = options;
-		return generator.generate();
+	}
+
+	generate( onProgress = null ) {
+
+		const { staticGeometryGenerator, geometry, attributes } = this;
+		const objects = staticGeometryGenerator.objects;
+		staticGeometryGenerator.attributes = attributes;
+
+		// update the skeleton animations in case WebGLRenderer is not running
+		// to update it.
+		objects.forEach( o => {
+
+			o.traverse( c => {
+
+				if ( c.isSkinnedMesh && c.skeleton ) {
+
+					c.skeleton.update();
+
+				}
+
+			} );
+
+		} );
+
+		// generate the geometry
+		const result = staticGeometryGenerator.generate( geometry );
+		const materials = result.materials;
+		const textures = getTextures( materials );
+		const { lights, iesTextures } = getLights( objects );
+
+		if ( result.changeType !== NO_CHANGE ) {
+
+			updateMaterialIndexAttribute( geometry, materials, materials );
+
+		}
+
+		// only generate a new bvh if the objects used have changed
+		if ( this.generateBVH ) {
+
+			if ( this.bvh instanceof Promise ) {
+
+				throw new Error( 'PathTracingSceneGenerator: BVH is already building asynchronously.' );
+
+			}
+
+			if ( result.changeType === GEOMETRY_REBUILT ) {
+
+				const bvhOptions = {
+					strategy: SAH,
+					maxLeafTris: 1,
+					indirect: true,
+					onProgress,
+					...this.bvhOptions,
+				};
+
+				if ( this._buildAsync ) {
+
+					this.bvh = this._bvhWorker.generate( geometry, bvhOptions );
+
+				} else {
+
+					this.bvh = new MeshBVH( geometry, bvhOptions );
+
+				}
+
+			} else if ( result.changeType === GEOMETRY_ADJUSTED ) {
+
+				this.bvh.refit();
+
+			}
+
+		}
+
+		return {
+			bvhChanged: result.changeType !== NO_CHANGE,
+			bvh: this.bvh,
+			lights,
+			iesTextures,
+			geometry,
+			materials,
+			textures,
+			objects,
+		};
+
+	}
+
+}
+
+export class DynamicPathTracingSceneGenerator extends PathTracingSceneGenerator {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		console.warn( 'DynamicPathTracingSceneGenerator has been deprecated and renamed to "PathTracingSceneGenerator".' );
+
+	}
+
+}
+
+export class PathTracingSceneWorker extends PathTracingSceneGenerator {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		console.warn( 'PathTracingSceneWorker has been deprecated and renamed to "PathTracingSceneGenerator".' );
 
 	}