three-gpu-pathtracer 0.0.17 → 0.0.18

package/src/textures/blueNoise/utils.js

@@ -0,0 +1,24 @@
+export function shuffleArray( array, random = Math.random ) {
+
+	for ( let i = array.length - 1; i > 0; i -- ) {
+
+		const replaceIndex = ~ ~ ( ( random() - 1e-6 ) * i );
+		const tmp = array[ i ];
+		array[ i ] = array[ replaceIndex ];
+		array[ replaceIndex ] = tmp;
+
+	}
+
+}
+
+export function fillWithOnes( array, count ) {
+
+	array.fill( 0 );
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		array[ i ] = 1;
+
+	}
+
+}

package/src/uniforms/EquirectHdrInfoUniform.js

@@ -1,4 +1,4 @@
-import { DataTexture, RedFormat, LinearFilter, DataUtils, HalfFloatType, Source, RepeatWrapping, RGBAFormat } from 'three';
+import { DataTexture, RedFormat, LinearFilter, DataUtils, HalfFloatType, Source, RepeatWrapping, RGBAFormat, FloatType, ClampToEdgeWrapping } from 'three';
 import { toHalfFloatArray } from '../utils/TextureUtils.js';
 
 function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
@@ -39,7 +39,7 @@ function colorToLuminance( r, g, b ) {
 }
 
 // ensures the data is all floating point values and flipY is false
-function preprocessEnvMap( envMap ) {
+function preprocessEnvMap( envMap, targetType = HalfFloatType ) {
 
 	const map = envMap.clone();
 	map.source = new Source( { ...map.image } );
@@ -48,17 +48,54 @@ function preprocessEnvMap( envMap ) {
 	// TODO: is there a simple way to avoid cloning and adjusting the env map data here?
 	// convert the data from half float uint 16 arrays to float arrays for cdf computation
 	let newData = data;
-	if ( map.type === HalfFloatType ) {
+	if ( map.type !== targetType ) {
 
-		newData = new Uint16Array( data.length );
-		for ( const i in data ) {
+		if ( targetType === HalfFloatType ) {
 
-			newData[ i ] = data[ i ];
+			newData = new Uint16Array( data.length );
+
+		} else {
+
+			newData = new Float32Array( data.length );
+
+		}
+
+		let maxIntValue;
+		if ( data instanceof Int8Array || data instanceof Int16Array || data instanceof Int32Array ) {
+
+			maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT - 1 ) - 1;
+
+		} else {
+
+			maxIntValue = 2 ** ( 8 * data.BYTES_PER_ELEMENT ) - 1;
+
+		}
+
+		for ( let i = 0, l = data.length; i < l; i ++ ) {
+
+			let v = data[ i ];
+			if ( map.type === HalfFloatType ) {
+
+				v = DataUtils.fromHalfFloat( data[ i ] );
+
+			}
+
+			if ( map.type !== FloatType && map.type !== HalfFloatType ) {
+
+				v /= maxIntValue;
+
+			}
+
+			if ( targetType === HalfFloatType ) {
+
+				newData[ i ] = DataUtils.toHalfFloat( v );
+
+			}
 
 		}
 
 		map.image.data = newData;
-		map.type = HalfFloatType;
+		map.type = targetType;
 
 	}
 
@@ -150,7 +187,7 @@ export class EquirectHdrInfoUniform {
 		// https://pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources#InfiniteAreaLights
 		const map = preprocessEnvMap( hdr );
 		map.wrapS = RepeatWrapping;
-		map.wrapT = RepeatWrapping;
+		map.wrapT = ClampToEdgeWrapping;
 
 		const { width, height, data } = map.image;
 

package/src/uniforms/LightsInfoUniformStruct.js

@@ -57,6 +57,13 @@ export class LightsInfoUniformStruct {
 			const baseIndex = i * LIGHT_PIXELS * 4;
 			let index = 0;
 
+			// initialize to 0
+			for ( let p = 0; p < LIGHT_PIXELS; p ++ ) {
+
+				floatArray[ baseIndex + p ] = 0;
+
+			}
+
 			// sample 1
 		    // position
 			l.getWorldPosition( v );
@@ -121,7 +128,7 @@ export class LightsInfoUniformStruct {
 
 			} else if ( l.isSpotLight ) {
 
-				const radius = l.radius;
+				const radius = l.radius || 0;
 				eye.setFromMatrixPosition( l.matrixWorld );
 				target.setFromMatrixPosition( l.target.matrixWorld );
 				m.lookAt( eye, target, up );
@@ -151,24 +158,21 @@ export class LightsInfoUniformStruct {
 				// radius
 				floatArray[ baseIndex + ( index ++ ) ] = radius;
 
-				// near
-				floatArray[ baseIndex + ( index ++ ) ] = l.shadow.camera.near;
-
 				// decay
 				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 
 				// distance
 				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
 
-				// sample 6
 				// coneCos
 				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle );
 
+				// sample 6
 				// penumbraCos
 				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
 
 				// iesProfile
-				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
+				floatArray[ baseIndex + ( index ++ ) ] = l.iesTexture ? iesTextures.indexOf( l.iesTexture ) : - 1;
 
 			} else if ( l.isPointLight ) {
 
@@ -185,7 +189,7 @@ export class LightsInfoUniformStruct {
 				index += 4;
 
 				// sample 5
-				index += 2;
+				index += 1;
 
 				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
 				floatArray[ baseIndex + ( index ++ ) ] = l.distance;

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/GeometryPreparationUtils.js

@@ -1,5 +1,5 @@
 import { BufferAttribute } from 'three';
-import { mergeGeometries, 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,84 +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 );
-
-		if ( mesh.matrixWorld.determinant() < 0 ) {
-
-			geometry.index.array.reverse();
-
-		}
-
-		// 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 = mergeGeometries( transformedGeometry, false );
-	const textures = Array.from( textureSet );
-	return { geometry, materials, textures };
-
-}

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,
 			};