three-gpu-pathtracer 0.0.12 → 0.0.14

package/src/uniforms/EquirectHdrInfoUniform.js

@@ -1,16 +1,20 @@
-import { DataTexture, FloatType, RedFormat, LinearFilter, DataUtils, HalfFloatType, Source, RepeatWrapping } from 'three';
+import { DataTexture, FloatType, RedFormat, LinearFilter, DataUtils, HalfFloatType, Source, RepeatWrapping, RGBAFormat } from 'three';
 
 function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
 
-	let lower = 0;
-	let upper = count - 1;
+	let lower = offset;
+	let upper = offset + count - 1;
+
 	while ( lower < upper ) {
 
-		const mid = ~ ~ ( 0.5 * upper + 0.5 * lower );
+		// calculate the midpoint for this iteration using a bitwise shift right operator to save 1 floating point multiplication
+		// and 1 truncation from the double tilde operator to improve performance
+		// this results in much better performance over using standard "~ ~ ( (lower + upper) ) / 2" to calculate the midpoint
+		const mid = ( lower + upper ) >> 1;
 
 		// check if the middle array value is above or below the target and shift
 		// which half of the array we're looking at
-		if ( array[ offset + mid ] < targetValue ) {
+		if ( array[ mid ] < targetValue ) {
 
 			lower = mid + 1;
 
@@ -22,7 +26,7 @@ function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count =
 
 	}
 
-	return lower;
+	return lower - offset;
 
 }
 
@@ -92,31 +96,45 @@ export class EquirectHdrInfoUniform {
 
 	constructor() {
 
+		// Default to a white texture and associated weights so we don't
+		// just render black initially.
+		const whiteTex = new DataTexture( new Float32Array( [ 1, 1, 1, 1 ] ), 1, 1 );
+		whiteTex.type = FloatType;
+		whiteTex.format = RGBAFormat;
+		whiteTex.minFilter = LinearFilter;
+		whiteTex.magFilter = LinearFilter;
+		whiteTex.wrapS = RepeatWrapping;
+		whiteTex.wrapT = RepeatWrapping;
+		whiteTex.generateMipmaps = false;
+		whiteTex.needsUpdate = true;
+
 		// Stores a map of [0, 1] value -> cumulative importance row & pdf
 		// used to sampling a random value to a relevant row to sample from
-		const marginalWeights = new DataTexture();
+		const marginalWeights = new DataTexture( new Float32Array( [ 0, 1 ] ), 1, 2 );
 		marginalWeights.type = FloatType;
 		marginalWeights.format = RedFormat;
 		marginalWeights.minFilter = LinearFilter;
 		marginalWeights.magFilter = LinearFilter;
 		marginalWeights.generateMipmaps = false;
+		marginalWeights.needsUpdate = true;
 
 		// Stores a map of [0, 1] value -> cumulative importance column & pdf
 		// used to sampling a random value to a relevant pixel to sample from
-		const conditionalWeights = new DataTexture();
+		const conditionalWeights = new DataTexture( new Float32Array( [ 0, 0, 1, 1 ] ), 2, 2 );
 		conditionalWeights.type = FloatType;
 		conditionalWeights.format = RedFormat;
 		conditionalWeights.minFilter = LinearFilter;
 		conditionalWeights.magFilter = LinearFilter;
 		conditionalWeights.generateMipmaps = false;
+		conditionalWeights.needsUpdate = true;
 
+		this.map = whiteTex;
 		this.marginalWeights = marginalWeights;
 		this.conditionalWeights = conditionalWeights;
-		this.map = null;
 
 		// the total sum value is separated into two values to work around low precision
 		// storage of floating values in structs
-		this.totalSumWhole = 0;
+		this.totalSumWhole = 1;
 		this.totalSumDecimal = 0;
 
 	}
@@ -125,7 +143,7 @@ export class EquirectHdrInfoUniform {
 
 		this.marginalWeights.dispose();
 		this.conditionalWeights.dispose();
-		if ( this.map ) this.map.dispose();
+		this.map.dispose();
 
 	}
 

package/src/uniforms/LightsInfoUniformStruct.js

@@ -170,7 +170,10 @@ export class LightsInfoUniformStruct {
 
 			} else if ( l.isPointLight ) {
 
-				const worldPosition = l.getWorldPosition( u );
+				const worldPosition = u.setFromMatrixPosition( l.matrixWorld );
+
+				// sample 3
+				// u vector
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.x;
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.y;
 				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.z;
@@ -187,10 +190,12 @@ export class LightsInfoUniformStruct {
 
 			} else if ( l.isDirectionalLight ) {
 
-				const worldPosition = l.getWorldPosition( u );
-				const targetPosition = l.target.getWorldPosition( v );
-
+				const worldPosition = u.setFromMatrixPosition( l.matrixWorld );
+				const targetPosition = v.setFromMatrixPosition( l.target.matrixWorld );
 				target.subVectors( worldPosition, targetPosition ).normalize();
+
+				// sample 3
+				// u vector
 				floatArray[ baseIndex + ( index ++ ) ] = target.x;
 				floatArray[ baseIndex + ( index ++ ) ] = target.y;
 				floatArray[ baseIndex + ( index ++ ) ] = target.z;

package/src/uniforms/MaterialsTexture.js

@@ -7,6 +7,42 @@ const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
 const MATTE_OFFSET = 14 * 4 + 0; // s14.r
 const SHADOW_OFFSET = 14 * 4 + 1; // s14.g
 
+class MaterialFeatures {
+
+	constructor() {
+
+		this._features = {};
+
+	}
+
+	isUsed( feature ) {
+
+		return feature in this._features;
+
+	}
+
+	setUsed( feature, used = true ) {
+
+		if ( used === false ) {
+
+			delete this._features[ feature ];
+
+		} else {
+
+			this._features[ feature ] = true;
+
+		}
+
+	}
+
+	reset() {
+
+		this._features = {};
+
+	}
+
+}
+
 export class MaterialsTexture extends DataTexture {
 
 	constructor() {
@@ -19,6 +55,7 @@ export class MaterialsTexture extends DataTexture {
 		this.wrapT = ClampToEdgeWrapping;
 		this.generateMipmaps = false;
 		this.threeCompatibilityTransforms = false;
+		this.features = new MaterialFeatures();
 
 	}
 
@@ -148,7 +185,7 @@ export class MaterialsTexture extends DataTexture {
 		let index = 0;
 		const pixelCount = materials.length * MATERIAL_PIXELS;
 		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
-		const { threeCompatibilityTransforms, image } = this;
+		const { threeCompatibilityTransforms, image, features } = this;
 
 		// get the list of textures with unique sources
 		const uniqueTextures = reduceTexturesToUniqueSources( textures );
@@ -175,10 +212,49 @@ export class MaterialsTexture extends DataTexture {
 		// can't encode texture ids that way.
 		// const intArray = new Int32Array( floatArray.buffer );
 
+		features.reset();
 		for ( let i = 0, l = materials.length; i < l; i ++ ) {
 
 			const m = materials[ i ];
 
+			if ( m.isFogVolumeMaterial ) {
+
+				features.setUsed( 'FOG' );
+
+				for ( let j = 0; j < MATERIAL_STRIDE; j ++ ) {
+
+					floatArray[ index + j ] = 0;
+
+				}
+
+				// sample 0 .rgb
+				floatArray[ index + 0 * 4 + 0 ] = m.color.r;
+				floatArray[ index + 0 * 4 + 1 ] = m.color.g;
+				floatArray[ index + 0 * 4 + 2 ] = m.color.b;
+
+				// sample 2 .a
+				floatArray[ index + 2 * 4 + 3 ] = getField( m, 'emissiveIntensity', 0.0 );
+
+				// sample 3 .rgb
+				floatArray[ index + 3 * 4 + 0 ] = m.emissive.r;
+				floatArray[ index + 3 * 4 + 1 ] = m.emissive.g;
+				floatArray[ index + 3 * 4 + 2 ] = m.emissive.b;
+
+				// sample 13 .g
+				// reusing opacity field
+				floatArray[ index + 13 * 4 + 1 ] = m.density;
+
+				// side
+				floatArray[ index + 13 * 4 + 3 ] = 0.0;
+
+				// sample 14 .b
+				floatArray[ index + 14 * 4 + 2 ] = 1 << 2;
+
+				index += MATERIAL_STRIDE;
+				continue;
+
+			}
+
 			// sample 0
 			// color
 			floatArray[ index ++ ] = m.color.r;
@@ -257,7 +333,7 @@ export class MaterialsTexture extends DataTexture {
 			}
 
 			index ++;
-			index ++;
+			floatArray[ index ++ ] = getField( m, 'sheen', 0.0 );
 
 			// sample 7
 			// sheen
@@ -285,7 +361,8 @@ export class MaterialsTexture extends DataTexture {
 			floatArray[ index ++ ] = getTexture( m, 'iridescenceMap' );
 			floatArray[ index ++ ] = getTexture( m, 'iridescenceThicknessMap' );
 
-			floatArray[ index ++ ] = getField( m, 'iridescence', 0.0 ); // sample 9
+			// sample 9
+			floatArray[ index ++ ] = getField( m, 'iridescence', 0.0 );
 			floatArray[ index ++ ] = getField( m, 'iridescenceIOR', 1.3 );
 
 			const iridescenceThicknessRange = getField( m, 'iridescenceThicknessRange', [ 100, 400 ] );

package/src/utils/BlurredEnvMapGenerator.js

@@ -1,7 +1,7 @@
 import { WebGLRenderTarget, RGBAFormat, FloatType, PMREMGenerator, DataTexture, EquirectangularReflectionMapping } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { MaterialBase } from '../materials/MaterialBase.js';
-import { shaderUtils } from '../shader/shaderUtils.js';
+import { utilsGLSL } from '../shader/common/utils.glsl.js';
 
 class PMREMCopyMaterial extends MaterialBase {
 
@@ -31,7 +31,7 @@ class PMREMCopyMaterial extends MaterialBase {
 				#include <common>
 				#include <cube_uv_reflection_fragment>
 
-				${ shaderUtils }
+				${ utilsGLSL }
 
 				uniform sampler2D envMap;
 				uniform float blur;

package/src/utils/SobolNumberMapGenerator.js

@@ -1,7 +1,7 @@
 import { FloatType, NearestFilter, NoBlending, RGBAFormat, Vector2, WebGLRenderTarget } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { MaterialBase } from '../materials/MaterialBase.js';
-import { shaderSobolCommon, shaderSobolGeneration } from '../shader/shaderSobolSampling.js';
+import { sobolCommonGLSL, sobolGenerationGLSL } from '../shader/rand/sobol.glsl.js';
 
 class SobolNumbersMaterial extends MaterialBase {
 
@@ -30,8 +30,8 @@ class SobolNumbersMaterial extends MaterialBase {
 
 			fragmentShader: /* glsl */`
 
-				${ shaderSobolCommon }
-				${ shaderSobolGeneration }
+				${ sobolCommonGLSL }
+				${ sobolGenerationGLSL }
 
 				varying vec2 vUv;
 				uniform vec2 resolution;

package/src/utils/macroify.js

@@ -0,0 +1,9 @@
+export function macroify( contents ) {
+
+	return contents
+		.trim()
+		.replace( /\/\/.*[\n\r]/g, '' )
+		.split( /[\n\r]+/ )
+		.join( '\\\n' ) + '\\\n';
+
+}