three-gpu-pathtracer 0.0.17 → 0.0.19

package/src/textures/blueNoise/BlueNoiseSamples.js

@@ -0,0 +1,214 @@
+export class BlueNoiseSamples {
+
+	constructor( size ) {
+
+		this.count = 0;
+		this.size = - 1;
+		this.sigma = - 1;
+		this.radius = - 1;
+		this.lookupTable = null;
+		this.score = null;
+		this.binaryPattern = null;
+
+		this.resize( size );
+		this.setSigma( 1.5 );
+
+	}
+
+	findVoid() {
+
+		const { score, binaryPattern } = this;
+
+		let currValue = Infinity;
+		let currIndex = - 1;
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] !== 0 ) {
+
+				continue;
+
+			}
+
+			const pScore = score[ i ];
+			if ( pScore < currValue ) {
+
+				currValue = pScore;
+				currIndex = i;
+
+			}
+
+		}
+
+		return currIndex;
+
+	}
+
+	findCluster() {
+
+		const { score, binaryPattern } = this;
+
+		let currValue = - Infinity;
+		let currIndex = - 1;
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] !== 1 ) {
+
+				continue;
+
+			}
+
+			const pScore = score[ i ];
+			if ( pScore > currValue ) {
+
+				currValue = pScore;
+				currIndex = i;
+
+			}
+
+		}
+
+		return currIndex;
+
+	}
+
+	setSigma( sigma ) {
+
+		if ( sigma === this.sigma ) {
+
+			return;
+
+		}
+
+		// generate a radius in which the score will be updated under the
+		// assumption that e^-10 is insignificant enough to be the border at
+		// which we drop off.
+		const radius = ~ ~ ( Math.sqrt( 10 * 2 * ( sigma ** 2 ) ) + 1 );
+		const lookupWidth = 2 * radius + 1;
+		const lookupTable = new Float32Array( lookupWidth * lookupWidth );
+		const sigma2 = sigma * sigma;
+		for ( let x = - radius; x <= radius; x ++ ) {
+
+			for ( let y = - radius; y <= radius; y ++ ) {
+
+				const index = ( radius + y ) * lookupWidth + x + radius;
+				const dist2 = x * x + y * y;
+				lookupTable[ index ] = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+			}
+
+		}
+
+		this.lookupTable = lookupTable;
+		this.sigma = sigma;
+		this.radius = radius;
+
+	}
+
+	resize( size ) {
+
+		if ( this.size !== size ) {
+
+			this.size = size;
+			this.score = new Float32Array( size * size );
+			this.binaryPattern = new Uint8Array( size * size );
+
+		}
+
+
+	}
+
+	invert() {
+
+		const { binaryPattern, score, size } = this;
+
+		score.fill( 0 );
+
+		for ( let i = 0, l = binaryPattern.length; i < l; i ++ ) {
+
+			if ( binaryPattern[ i ] === 0 ) {
+
+				const y = ~ ~ ( i / size );
+				const x = i - y * size;
+				this.updateScore( x, y, 1 );
+				binaryPattern[ i ] = 1;
+
+			} else {
+
+				binaryPattern[ i ] = 0;
+
+			}
+
+		}
+
+	}
+
+	updateScore( x, y, multiplier ) {
+
+		// TODO: Is there a way to keep track of the highest and lowest scores here to avoid have to search over
+		// everything in the buffer?
+		const { size, score, lookupTable } = this;
+
+		// const sigma2 = sigma * sigma;
+		// const radius = Math.floor( size / 2 );
+		const radius = this.radius;
+		const lookupWidth = 2 * radius + 1;
+		for ( let px = - radius; px <= radius; px ++ ) {
+
+			for ( let py = - radius; py <= radius; py ++ ) {
+
+				// const dist2 = px * px + py * py;
+				// const value = Math.E ** ( - dist2 / ( 2 * sigma2 ) );
+
+				const lookupIndex = ( radius + py ) * lookupWidth + px + radius;
+				const value = lookupTable[ lookupIndex ];
+
+				let sx = ( x + px );
+				sx = sx < 0 ? size + sx : sx % size;
+
+				let sy = ( y + py );
+				sy = sy < 0 ? size + sy : sy % size;
+
+				const sindex = sy * size + sx;
+				score[ sindex ] += multiplier * value;
+
+			}
+
+		}
+
+	}
+
+	addPointIndex( index ) {
+
+		this.binaryPattern[ index ] = 1;
+
+		const size = this.size;
+		const y = ~ ~ ( index / size );
+		const x = index - y * size;
+		this.updateScore( x, y, 1 );
+		this.count ++;
+
+	}
+
+	removePointIndex( index ) {
+
+		this.binaryPattern[ index ] = 0;
+
+		const size = this.size;
+		const y = ~ ~ ( index / size );
+		const x = index - y * size;
+		this.updateScore( x, y, - 1 );
+		this.count --;
+
+	}
+
+	copy( source ) {
+
+		this.resize( source.size );
+		this.score.set( source.score );
+		this.binaryPattern.set( source.binaryPattern );
+		this.setSigma( source.sigma );
+		this.count = source.count;
+
+	}
+
+}

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 * 4; 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/MaterialsTexture.js

@@ -186,7 +186,7 @@ export class MaterialsTexture extends DataTexture {
 
 		let index = 0;
 		const pixelCount = materials.length * MATERIAL_PIXELS;
-		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
+		const dimension = Math.ceil( Math.sqrt( pixelCount ) ) || 1;
 		const { threeCompatibilityTransforms, image, features } = this;
 
 		// get the list of textures with unique sources

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