three-gpu-pathtracer 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "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",
@@ -28,9 +28,6 @@
     "path",
     "tracer"
   ],
-  "dependencies": {
-    "three-mesh-bvh": "^0.5.19"
-  },
   "devDependencies": {
     "@lookingglass/webxr": "^0.3.1",
     "canvas-capture": "^2.0.5",
@@ -44,11 +41,13 @@
     "puppeteer": "^15.4.0",
     "rollup": "^2.70.0",
     "simple-git": "^3.10.0",
-    "three": "^0.147.0",
+    "three": "^0.160.0",
+    "three-mesh-bvh": "0.7.2",
     "yargs": "^17.5.1"
   },
   "peerDependencies": {
-    "three": ">=0.139.2",
+    "three": ">=0.151.0",
+    "three-mesh-bvh": "0.7.0",
     "xatlas-web": "^0.1.0"
   },
   "scripts": {

package/src/core/DynamicPathTracingSceneGenerator.js

@@ -1,7 +1,16 @@
-import { BufferGeometry } from 'three';
-import { StaticGeometryGenerator, MeshBVH } from 'three-mesh-bvh';
+import { BufferGeometry, MeshBasicMaterial, BufferAttribute, Mesh } from 'three';
+import { StaticGeometryGenerator, MeshBVH, SAH } from 'three-mesh-bvh';
 import { setCommonAttributes, getGroupMaterialIndicesAttribute } from '../utils/GeometryPreparationUtils.js';
 
+const dummyMaterial = new MeshBasicMaterial();
+export function getDummyMesh() {
+
+	const emptyGeometry = new BufferGeometry();
+	emptyGeometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 9 ), 3 ) );
+	return new Mesh( emptyGeometry, dummyMaterial );
+
+}
+
 export class DynamicPathTracingSceneGenerator {
 
 	get initialized() {
@@ -10,9 +19,29 @@ export class DynamicPathTracingSceneGenerator {
 
 	}
 
-	constructor( scene ) {
+	constructor( objects ) {
+
+		// ensure the objects is an array
+		if ( ! Array.isArray( objects ) ) {
+
+			objects = [ objects ];
+
+		}
+
+		// use a dummy object for a fallback
+		const finalObjects = [ ...objects ];
+		if ( finalObjects.length === 0 ) {
+
+			finalObjects.push( getDummyMesh() );
+
+		}
+
+		// options
+		this.bvhOptions = {};
+		this.attributes = [ 'position', 'normal', 'tangent', 'color', 'uv', 'uv2' ];
 
-		this.objects = Array.isArray( scene ) ? scene : [ scene ];
+		// state
+		this.objects = finalObjects;
 		this.bvh = null;
 		this.geometry = new BufferGeometry();
 		this.materials = null;
@@ -36,59 +65,75 @@ export class DynamicPathTracingSceneGenerator {
 
 	dispose() {}
 
-	generate() {
+	prepScene() {
 
-		const { objects, staticGeometryGenerator, geometry } = this;
-		if ( this.bvh === null ) {
+		if ( this.bvh !== null ) {
 
-			const attributes = [ 'position', 'normal', 'tangent', 'uv', 'color' ];
+			return;
 
-			for ( let i = 0, l = objects.length; i < l; i ++ ) {
+		}
 
-				objects[ i ].traverse( c => {
+		const { objects, staticGeometryGenerator, geometry, lights, attributes } = this;
+		for ( let i = 0, l = objects.length; i < l; i ++ ) {
 
-					if ( c.isMesh ) {
+			objects[ i ].traverse( c => {
 
-						const normalMapRequired = ! ! c.material.normalMap;
-						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
+				if ( c.isMesh ) {
 
-					} else if ( c.isRectAreaLight || c.isSpotLight ) {
+					const normalMapRequired = ! ! c.material.normalMap;
+					setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-						this.lights.push( c );
+				} else if (
+					c.isRectAreaLight ||
+					c.isSpotLight ||
+					c.isPointLight ||
+					c.isDirectionalLight
+				) {
 
-					}
+					lights.push( c );
 
-				} );
+				}
 
-			}
+			} );
 
-			const textureSet = new Set();
-			const materials = staticGeometryGenerator.getMaterials();
-			materials.forEach( material => {
+		}
 
-				for ( const key in material ) {
+		const textureSet = new Set();
+		const materials = staticGeometryGenerator.getMaterials();
+		materials.forEach( material => {
 
-					const value = material[ key ];
-					if ( value && value.isTexture ) {
+			for ( const key in material ) {
 
-						textureSet.add( value );
+				const value = material[ key ];
+				if ( value && value.isTexture ) {
 
-					}
+					textureSet.add( value );
 
 				}
 
-			} );
+			}
 
-			staticGeometryGenerator.attributes = attributes;
-			staticGeometryGenerator.generate( geometry );
+		} );
+
+		staticGeometryGenerator.attributes = attributes;
+		staticGeometryGenerator.generate( geometry );
 
-			const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
-			geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-			geometry.clearGroups();
+		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, materials, materials );
+		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+		geometry.clearGroups();
+
+		this.materials = materials;
+		this.textures = Array.from( textureSet );
+
+	}
+
+	generate() {
+
+		const { objects, staticGeometryGenerator, geometry, bvhOptions } = this;
+		if ( this.bvh === null ) {
 
-			this.bvh = new MeshBVH( geometry );
-			this.materials = materials;
-			this.textures = Array.from( textureSet );
+			this.prepScene();
+			this.bvh = new MeshBVH( geometry, { strategy: SAH, maxLeafTris: 1, ...bvhOptions } );
 
 			return {
 				lights: this.lights,

package/src/core/PathTracingRenderer.js

@@ -1,11 +1,8 @@
-import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4 } from 'three';
+import { RGBAFormat, FloatType, HalfFloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4 } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { BlendMaterial } from '../materials/fullscreen/BlendMaterial.js';
 import { SobolNumberMapGenerator } from '../utils/SobolNumberMapGenerator.js';
 
-const _scissor = new Vector4();
-const _viewport = new Vector4();
-
 function* renderTask() {
 
 	const {
@@ -47,12 +44,21 @@ function* renderTask() {
 		const h = _primaryTarget.height;
 		material.resolution.set( w * subW, h * subH );
 		material.sobolTexture = _sobolTarget.texture;
+		material.stratifiedTexture.init( 20, material.bounces + material.transmissiveBounces + 5 );
+		material.stratifiedTexture.next();
 		material.seed ++;
 
 		const tilesX = this.tiles.x || 1;
 		const tilesY = this.tiles.y || 1;
 		const totalTiles = tilesX * tilesY;
-		const dprInv = ( 1 / _renderer.getPixelRatio() );
+
+		const pxSubW = Math.ceil( w * subW );
+		const pxSubH = Math.ceil( h * subH );
+		const pxSubX = Math.floor( subX * w );
+		const pxSubY = Math.floor( subY * h );
+
+		const pxTileW = Math.ceil( pxSubW / tilesX );
+		const pxTileH = Math.ceil( pxSubH / tilesY );
 
 		for ( let y = 0; y < tilesY; y ++ ) {
 
@@ -101,40 +107,28 @@ function* renderTask() {
 
 				}
 
+				// set the scissor and the viewport on the render target
+				// note that when using the webgl renderer set viewport the device pixel ratio
+				// is multiplied into the field causing some pixels to not be rendered
+				const reverseTy = tilesY - ty - 1;
+				_primaryTarget.scissor.set(
+					pxSubX + tx * pxTileW,
+					pxSubY + reverseTy * pxTileH,
+					Math.min( pxTileW, pxSubW - tx * pxTileW ),
+					Math.min( pxTileH, pxSubH - reverseTy * pxTileH ),
+				);
+
+				_primaryTarget.viewport.set(
+					pxSubX,
+					pxSubY,
+					pxSubW,
+					pxSubH,
+				);
+
 				// three.js renderer takes values relative to the current pixel ratio
 				_renderer.setRenderTarget( _primaryTarget );
 				_renderer.setScissorTest( true );
 
-				// set the scissor window for a subtile
-				_scissor.x = tx * w / tilesX;
-				_scissor.y = ( tilesY - ty - 1 ) * h / tilesY;
-				_scissor.z = w / tilesX;
-				_scissor.w = h / tilesY;
-
-				// adjust for the subframe
-				_scissor.x = subX * w + subW * _scissor.x;
-				_scissor.y = subY * h + subH * _scissor.y;
-				_scissor.z = subW * _scissor.z;
-				_scissor.w = subH * _scissor.w;
-
-				// round for floating point cases
-				_scissor.x = _scissor.x;
-				_scissor.y = _scissor.y;
-				_scissor.z = _scissor.z;
-				_scissor.w = _scissor.w;
-
-				// multiply inverse of DPR in because threes multiplies it in
-				_scissor.multiplyScalar( dprInv ).ceil();
-
-				_viewport.x = subX * w;
-				_viewport.y = subY * h;
-				_viewport.z = subW * w;
-				_viewport.w = subH * h;
-				_viewport.multiplyScalar( dprInv ).ceil();
-
-				_renderer.setScissor( _scissor );
-				_renderer.setViewport( _viewport );
-
 				_renderer.autoClear = false;
 				_fsQuad.render( _renderer );
 
@@ -250,18 +244,22 @@ export class PathTracingRenderer {
 		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: FloatType,
+			type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 		} );
 		this._blendTargets = [
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 		];
 

package/src/core/PathTracingSceneGenerator.js

@@ -1,68 +1,24 @@
-import { Mesh } from 'three';
-import { SAH, MeshBVH, StaticGeometryGenerator } from 'three-mesh-bvh';
-import { mergeMeshes } from '../utils/GeometryPreparationUtils.js';
+import { DynamicPathTracingSceneGenerator } from './DynamicPathTracingSceneGenerator.js';
 
 export class PathTracingSceneGenerator {
 
-	prepScene( scene ) {
-
-		scene = Array.isArray( scene ) ? scene : [ scene ];
-
-		const meshes = [];
-		const lights = [];
-
-		for ( let i = 0, l = scene.length; i < l; i ++ ) {
-
-			scene[ i ].traverseVisible( c => {
-
-				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
-
-					const generator = new StaticGeometryGenerator( c );
-					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-					generator.applyWorldTransforms = false;
-					const mesh = new Mesh(
-						generator.generate(),
-						c.material,
-					);
-					mesh.matrixWorld.copy( c.matrixWorld );
-					mesh.matrix.copy( c.matrixWorld );
-					mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
-					meshes.push( mesh );
-
-				} else if ( c.isMesh ) {
-
-					meshes.push( c );
+	generate( scene, options = {} ) {
 
-				} else if ( c.isRectAreaLight || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
+		// ensure scene transforms are up to date
+		// TODO: remove this?
+		if ( Array.isArray( scene ) ) {
 
-					lights.push( c );
+			scene.forEach( s => s.updateMatrixWorld( true ) );
 
-				}
+		} else {
 
-			} );
+			scene.updateMatrixWorld( true );
 
 		}
 
-		return {
-			...mergeMeshes( meshes, {
-				attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
-			} ),
-			lights,
-		};
-
-	}
-
-	generate( scene, options = {} ) {
-
-		const { materials, textures, geometry, lights } = this.prepScene( scene );
-		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
-		return {
-			scene,
-			materials,
-			textures,
-			lights,
-			bvh: new MeshBVH( geometry, bvhOptions ),
-		};
+		const generator = new DynamicPathTracingSceneGenerator( scene );
+		generator.bvhOptions = options;
+		return generator.generate();
 
 	}
 

package/src/materials/debug/GraphMaterial.js

@@ -198,7 +198,7 @@ export class GraphMaterial extends MaterialBase {
 
 					}
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}
 

package/src/materials/fullscreen/AlphaDisplayMaterial.js

@@ -37,7 +37,7 @@ export class AlphaDisplayMaterial extends MaterialBase {
 					gl_FragColor = vec4( texture( map, vUv ).a );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`
 

package/src/materials/fullscreen/DenoiseMaterial.js

@@ -126,7 +126,7 @@ export class DenoiseMaterial extends MaterialBase {
 
 					gl_FragColor = smartDeNoise( map, vec2( vUv.x, vUv.y ), sigma, kSigma, threshold );
 					#include <tonemapping_fragment>
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 					#include <premultiplied_alpha_fragment>
 
 				}

package/src/materials/fullscreen/GradientMapMaterial.js

@@ -69,7 +69,7 @@ export class GradientMapMaterial extends MaterialBase {
 					gl_FragColor.rgb = vec3( mix( minColor, maxColor, t ) );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`,
 

package/src/materials/pathtracing/LambertPathTracingMaterial.js

@@ -2,7 +2,7 @@ import { Matrix4, Color } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
 import {
 	MeshBVHUniformStruct, FloatVertexAttributeTexture, UIntVertexAttributeTexture,
-	shaderStructs, shaderIntersectFunction,
+	BVHShaderGLSL,
 } from 'three-mesh-bvh';
 
 // uniforms
@@ -85,8 +85,9 @@ export class LambertPathTracingMaterial extends MaterialBase {
 				#include <common>
 				#include <cube_uv_reflection_fragment>
 
-				${ shaderStructs }
-				${ shaderIntersectFunction }
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ BVHShaderGLSL.bvh_ray_functions }
 
 				// uniform structs
 				${ materialStructGLSL }
@@ -193,7 +194,7 @@ export class LambertPathTracingMaterial extends MaterialBase {
 						uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
 						Material material = materials[ materialIndex ];
 
-						if ( material.opacity < rand() ) {
+						if ( material.opacity < pcgRand() ) {
 
 							vec3 point = rayOrigin + rayDirection * dist;
 							rayOrigin += rayDirection * dist - faceNormal * RAY_OFFSET;