three-gpu-pathtracer 0.0.16 → 0.0.18

package/src/uniforms/RenderTarget2DArray.js

@@ -2,11 +2,11 @@ import {
 	WebGLArrayRenderTarget,
 	RGBAFormat,
 	UnsignedByteType,
-	MeshBasicMaterial,
 	Color,
 	RepeatWrapping,
 	LinearFilter,
 	NoToneMapping,
+	ShaderMaterial,
 } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { reduceTexturesToUniqueSources } from './utils.js';
@@ -31,7 +31,7 @@ export class RenderTarget2DArray extends WebGLArrayRenderTarget {
 
 		};
 
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		const fsQuad = new FullScreenQuad( new CopyMaterial() );
 		this.fsQuad = fsQuad;
 
 	}
@@ -66,7 +66,6 @@ export class RenderTarget2DArray extends WebGLArrayRenderTarget {
 				texture.matrix.identity();
 
 				fsQuad.material.map = texture;
-				fsQuad.material.transparent = true;
 
 				renderer.setRenderTarget( this, i );
 				fsQuad.render( renderer );
@@ -95,3 +94,51 @@ export class RenderTarget2DArray extends WebGLArrayRenderTarget {
 	}
 
 }
+
+class CopyMaterial extends ShaderMaterial {
+
+	get map() {
+
+		return this.uniforms.map.value;
+
+	}
+	set map( v ) {
+
+		this.uniforms.map.value = v;
+
+	}
+
+	constructor() {
+
+		super( {
+			uniforms: {
+
+				map: { value: null },
+
+			},
+
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+
+			fragmentShader: /* glsl */`
+				uniform sampler2D map;
+				varying vec2 vUv;
+				void main() {
+
+					gl_FragColor = texture2D( map, vUv );
+
+				}
+			`
+		} );
+
+	}
+
+
+}

package/src/uniforms/StratifiedSamplesTexture.js

@@ -0,0 +1,49 @@
+import { DataTexture, FloatType, NearestFilter, RGBAFormat } from 'three';
+import { StratifiedSamplerCombined } from './stratified/StratifiedSamplerCombined.js';
+
+export class StratifiedSamplesTexture extends DataTexture {
+
+	constructor( count = 1, depth = 1, strata = 8 ) {
+
+		super( new Float32Array( 1 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
+
+		this.strata = strata;
+		this.sampler = null;
+
+		this.init( count, depth, strata );
+
+	}
+
+	init( count, depth, strata = this.strata ) {
+
+		const { image } = this;
+		if ( image.width === depth && image.height === count ) {
+
+			return;
+
+		}
+
+		const dimensions = new Array( count * depth ).fill( 4 );
+		const sampler = new StratifiedSamplerCombined( strata, dimensions );
+
+		image.width = depth;
+		image.height = count;
+		image.data = sampler.samples;
+
+		this.sampler = sampler;
+
+		this.dispose();
+		this.next();
+
+	}
+
+	next() {
+
+		this.sampler.next();
+		this.needsUpdate = true;
+
+	}
+
+}

package/src/uniforms/stratified/StratifiedSampler.js

@@ -0,0 +1,73 @@
+// Stratified Sampling based on implementation from hoverinc pathtracer
+// - https://github.com/hoverinc/ray-tracing-renderer
+// - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
+
+export function shuffle( arr ) {
+
+	for ( let i = arr.length - 1; i > 0; i -- ) {
+
+	  const j = Math.floor( Math.random() * ( i + 1 ) );
+	  const x = arr[ i ];
+	  arr[ i ] = arr[ j ];
+	  arr[ j ] = x;
+
+	}
+
+	return arr;
+
+}
+
+// strataCount : The number of bins per dimension
+// dimensions  : The number of dimensions to generate stratified values for
+export class StratifiedSampler {
+
+	constructor( strataCount, dimensions ) {
+
+		const l = strataCount ** dimensions;
+		const strata = new Uint16Array( l );
+		let index = l;
+
+		// each integer represents a statum bin
+		for ( let i = 0; i < l; i ++ ) {
+
+			strata[ i ] = i;
+
+		}
+
+		this.samples = new Float32Array( dimensions );
+
+		this.strataCount = strataCount;
+
+		this.restart = function () {
+
+			index = 0;
+
+		};
+
+		this.next = function () {
+
+			const { samples } = this;
+
+			if ( index >= strata.length ) {
+
+				shuffle( strata );
+				this.restart();
+
+			}
+
+			let stratum = strata[ index ++ ];
+
+			for ( let i = 0; i < dimensions; i ++ ) {
+
+				samples[ i ] = ( stratum % strataCount + Math.random() ) / strataCount;
+				stratum = Math.floor( stratum / strataCount );
+
+			}
+
+			return samples;
+
+		};
+
+	}
+
+}

package/src/uniforms/stratified/StratifiedSamplerCombined.js

@@ -0,0 +1,59 @@
+// Stratified Sampling based on implementation from hoverinc pathtracer
+// - https://github.com/hoverinc/ray-tracing-renderer
+// - http://www.pbr-book.org/3ed-2018/Sampling_and_Reconstruction/Stratified_Sampling.html
+
+import { StratifiedSampler } from './StratifiedSampler.js';
+
+// Stratified set of data with each tuple stratified separately and combined
+export class StratifiedSamplerCombined {
+
+	constructor( strataCount, listOfDimensions ) {
+
+		let totalDim = 0;
+		for ( const dim of listOfDimensions ) {
+
+			totalDim += dim;
+
+		}
+
+		const combined = new Float32Array( totalDim );
+		const strataObjs = [];
+		let offset = 0;
+		for ( const dim of listOfDimensions ) {
+
+			const sampler = new StratifiedSampler( strataCount, dim );
+			sampler.samples = new Float32Array( combined.buffer, offset, sampler.samples.length );
+			offset += sampler.samples.length * 4;
+			strataObjs.push( sampler );
+
+		}
+
+		this.samples = combined;
+
+		this.strataCount = strataCount;
+
+		this.next = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.next();
+
+			}
+
+			return combined;
+
+		};
+
+		this.restart = function () {
+
+			for ( const strata of strataObjs ) {
+
+				strata.restart();
+
+			}
+
+		};
+
+	}
+
+}

package/src/uniforms/utils.js

@@ -2,7 +2,7 @@
 // when rendering each texture to the texture array they must have a consistent color space.
 export function getTextureHash( t ) {
 
-	return `${ t.source.uuid }:${ t.encoding }`;
+	return `${ t.source.uuid }:${ t.colorSpace }`;
 
 }
 

package/src/utils/BlurredEnvMapGenerator.js

@@ -1,4 +1,4 @@
-import { WebGLRenderTarget, RGBAFormat, FloatType, PMREMGenerator, DataTexture, EquirectangularReflectionMapping } from 'three';
+import { WebGLRenderTarget, RGBAFormat, HalfFloatType, PMREMGenerator, DataTexture, EquirectangularReflectionMapping } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { MaterialBase } from '../materials/MaterialBase.js';
 import { utilsGLSL } from '../shader/common/utils.glsl.js';
@@ -58,7 +58,7 @@ export class BlurredEnvMapGenerator {
 		this.renderer = renderer;
 		this.pmremGenerator = new PMREMGenerator( renderer );
 		this.copyQuad = new FullScreenQuad( new PMREMCopyMaterial() );
-		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: FloatType, format: RGBAFormat } );
+		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: HalfFloatType, format: RGBAFormat } );
 
 	}
 
@@ -95,10 +95,10 @@ export class BlurredEnvMapGenerator {
 		renderer.autoClear = prevClear;
 
 		// read the data back
-		const buffer = new Float32Array( width * height * 4 );
+		const buffer = new Uint16Array( width * height * 4 );
 		renderer.readRenderTargetPixels( renderTarget, 0, 0, width, height, buffer );
 
-		const result = new DataTexture( buffer, width, height, RGBAFormat, FloatType );
+		const result = new DataTexture( buffer, width, height, RGBAFormat, HalfFloatType );
 		result.minFilter = texture.minFilter;
 		result.magFilter = texture.magFilter;
 		result.wrapS = texture.wrapS;

package/src/utils/GeometryPreparationUtils.js

@@ -1,5 +1,5 @@
 import { BufferAttribute } from 'three';
-import { mergeBufferGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 export function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
 
 	const indexAttr = geometry.index;
@@ -54,25 +54,6 @@ export function getGroupMaterialIndicesAttribute( geometry, materials, allMateri
 
 }
 
-export function trimToAttributes( geometry, attributes ) {
-
-	// trim any unneeded attributes
-	if ( attributes ) {
-
-		for ( const key in geometry.attributes ) {
-
-			if ( ! attributes.includes( key ) ) {
-
-				geometry.deleteAttribute( key );
-
-			}
-
-		}
-
-	}
-
-}
-
 export function setCommonAttributes( geometry, options ) {
 
 	const { attributes = [], normalMapRequired = false } = options;
@@ -90,6 +71,13 @@ export function setCommonAttributes( geometry, options ) {
 
 	}
 
+	if ( ! geometry.attributes.uv2 && ( attributes && attributes.includes( 'uv2' ) ) ) {
+
+		const vertCount = geometry.attributes.position.count;
+		geometry.setAttribute( 'uv2', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+	}
+
 	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
 
 		if ( normalMapRequired ) {
@@ -137,78 +125,3 @@ export function setCommonAttributes( geometry, options ) {
 	}
 
 }
-
-export function mergeMeshes( meshes, options = {} ) {
-
-	options = { attributes: null, cloneGeometry: true, ...options };
-
-	const transformedGeometry = [];
-	const materialSet = new Set();
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// save any materials
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
-
-		if ( Array.isArray( mesh.material ) ) {
-
-			mesh.material.forEach( m => materialSet.add( m ) );
-
-		} else {
-
-			materialSet.add( mesh.material );
-
-		}
-
-	}
-
-	const materials = Array.from( materialSet );
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// ensure the matrix world is up to date
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
-
-		mesh.updateMatrixWorld();
-
-		// apply the matrix world to the geometry
-		const originalGeometry = meshes[ i ].geometry;
-		const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-		geometry.applyMatrix4( mesh.matrixWorld );
-
-		// ensure our geometry has common attributes
-		setCommonAttributes( geometry, {
-			attributes: options.attributes,
-			normalMapRequired: ! ! mesh.material.normalMap,
-		} );
-		trimToAttributes( geometry, options.attributes );
-
-		// create the material index attribute
-		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
-		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-
-		transformedGeometry.push( geometry );
-
-	}
-
-	const textureSet = new Set();
-	materials.forEach( material => {
-
-		for ( const key in material ) {
-
-			const value = material[ key ];
-			if ( value && value.isTexture ) {
-
-				textureSet.add( value );
-
-			}
-
-		}
-
-	} );
-
-	const geometry = mergeBufferGeometries( transformedGeometry, false );
-	const textures = Array.from( textureSet );
-	return { geometry, materials, textures };
-
-}

package/src/utils/IESLoader.js

@@ -1,13 +1,15 @@
 import {
 	DataTexture,
 	FileLoader,
-	FloatType,
+	HalfFloatType,
 	LinearFilter,
 	RedFormat,
 	MathUtils,
 	Loader,
 } from 'three';
 
+import { toHalfFloatArray } from './TextureUtils.js';
+
 function IESLamp( text ) {
 
 	const _self = this;
@@ -286,7 +288,7 @@ export class IESLoader extends Loader {
 		loader.setPath( this.path );
 		loader.setRequestHeader( this.requestHeader );
 
-		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		const texture = new DataTexture( null, 360, 180, RedFormat, HalfFloatType );
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
 
@@ -294,7 +296,7 @@ export class IESLoader extends Loader {
 
 			const iesLamp = new IESLamp( text );
 
-			texture.image.data = this._getIESValues( iesLamp );
+			texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 			texture.needsUpdate = true;
 
 			if ( onLoad !== undefined ) {
@@ -312,10 +314,10 @@ export class IESLoader extends Loader {
 	parse( text ) {
 
 		const iesLamp = new IESLamp( text );
-		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		const texture = new DataTexture( null, 360, 180, RedFormat, HalfFloatType );
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
-		texture.image.data = this._getIESValues( iesLamp );
+		texture.image.data = toHalfFloatArray( this._getIESValues( iesLamp ) );
 		texture.needsUpdate = true;
 
 		return texture;

package/src/utils/TextureUtils.js

@@ -0,0 +1,15 @@
+import { DataUtils } from 'three';
+
+
+export function toHalfFloatArray( f32Array ) {
+
+	const f16Array = new Uint16Array( f32Array.length );
+	for ( let i = 0, n = f32Array.length; i < n; ++ i ) {
+
+		f16Array[ i ] = DataUtils.toHalfFloat( f32Array[ i ] );
+
+	}
+
+	return f16Array;
+
+}

package/src/workers/PathTracingSceneWorker.js

@@ -1,23 +1,34 @@
-import { PathTracingSceneGenerator } from '../core/PathTracingSceneGenerator.js';
-import { SAH } from 'three-mesh-bvh';
 import { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
+import { DynamicPathTracingSceneGenerator } from '../core/DynamicPathTracingSceneGenerator.js';
 
-export class PathTracingSceneWorker extends PathTracingSceneGenerator {
+export class PathTracingSceneWorker {
 
 	constructor() {
 
-		super();
 		this.bvhGenerator = new GenerateMeshBVHWorker();
 
 	}
 
 	generate( scene, options = {} ) {
 
+		// ensure scene transforms are up to date
+		// TODO: remove this?
+		if ( Array.isArray( scene ) ) {
+
+			scene.forEach( s => s.updateMatrixWorld( true ) );
+
+		} else {
+
+			scene.updateMatrixWorld( true );
+
+		}
+
 		const { bvhGenerator } = this;
-		const { geometry, materials, textures, lights, spotLights } = this.prepScene( scene );
+		const sceneGenerator = new DynamicPathTracingSceneGenerator( scene );
+		sceneGenerator.prepScene();
 
-		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
-		const bvhPromise = bvhGenerator.generate( geometry, bvhOptions );
+		const { geometry, materials, textures, lights } = sceneGenerator;
+		const bvhPromise = bvhGenerator.generate( geometry, options );
 		return bvhPromise.then( bvh => {
 
 			return {
@@ -25,7 +36,6 @@ export class PathTracingSceneWorker extends PathTracingSceneGenerator {
 				materials,
 				textures,
 				lights,
-				spotLights,
 				bvh,
 			};