three-gpu-pathtracer 0.0.17 → 0.0.19

package/src/shader/bsdf/bsdfSampling.glsl.js

@@ -94,15 +94,17 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		// TODO: subsurface approx?
 
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		color = ( 1.0 - F ) * transFactor * metalFactor * wi.z * surf.color * ( retro + lambert ) / PI;
+
 		return wi.z / PI;
 
 	}
 
 	vec3 diffuseDirection( vec3 wo, SurfaceRecord surf ) {
 
-		vec3 lightDirection = sampleSphere( sobol2( 11 ) );
+		vec3 lightDirection = sampleSphere( rand2( 11 ) );
 		lightDirection.z += 1.0;
 		lightDirection = normalize( lightDirection );
 
@@ -147,7 +149,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 12 )
+			rand2( 12 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -184,7 +186,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -206,7 +208,8 @@ export const bsdfSamplingGLSL = /* glsl */`
 		color = surf.transmission * surf.color;
 
 		// PDF
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		if ( F >= 1.0 ) {
 
 			return 0.0;
@@ -221,7 +224,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		float roughness = surf.filteredRoughness;
 		float eta = surf.eta;
-		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
+		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( rand2( 13 ) ) * roughness );
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 		if ( surf.thinFilm ) {
@@ -262,7 +265,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 14 )
+			rand2( 14 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -297,7 +300,8 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		float metalness = surf.metalness;
 		float transmission = surf.transmission;
-		float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float fEstimate = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 
 		float transSpecularProb = mix( max( 0.25, fEstimate ), 1.0, metalness );
 		float diffSpecularProb = 0.5 + 0.5 * metalness;
@@ -413,7 +417,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 			ScatterRecord sampleRec;
 			sampleRec.specularPdf = 0.0;
 			sampleRec.pdf = 1.0 / ( 4.0 * PI );
-			sampleRec.direction = sampleSphere( sobol2( 16 ) );
+			sampleRec.direction = sampleSphere( rand2( 16 ) );
 			sampleRec.color = surf.color / ( 4.0 * PI );
 			return sampleRec;
 
@@ -465,7 +469,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 wi;
 		vec3 clearcoatWi;
 
-		float r = sobol( 15 );
+		float r = rand( 15 );
 		if ( r <= cdf[0] ) { // diffuse
 
 			wi = diffuseDirection( wo, surf );

package/src/shader/common/fresnel.glsl.js

@@ -69,30 +69,36 @@ export const fresnelGLSL = /* glsl */`
 
 	}
 
-	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
+	// TODO: disney fresnel was removed and replaced with this fresnel function to better align with
+	// the glTF but is causing blown out pixels. Should be revisited
+	// float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
 
-		if ( totalInternalReflection( cosTheta, eta ) ) {
+	// 	if ( totalInternalReflection( cosTheta, eta ) ) {
 
-			return 1.0;
+	// 		return 1.0;
 
-		}
+	// 	}
 
-		return schlickFresnel( cosTheta, f0 );
+	// 	return schlickFresnel( cosTheta, f0 );
 
-	}
+	// }
 
-	/*
 	// https://schuttejoe.github.io/post/disneybsdf/
 	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
 
 		float dotHV = dot( wo, wh );
-		float dotHL = dot( wi, wh );
+		if ( totalInternalReflection( dotHV, eta ) ) {
 
+			return 1.0;
+
+		}
+
+		float dotHL = dot( wi, wh );
 		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
 		float metallicFresnel = schlickFresnel( dotHL, f0 );
 
 		return mix( dielectricFresnel, metallicFresnel, metalness );
 
 	}
-	*/
+
 `;

package/src/shader/rand/pcg.glsl.js

@@ -27,28 +27,28 @@ export const pcgGLSL = /* glsl */`
 	}
 
 	// returns [ 0, 1 ]
-	float rand() {
+	float pcgRand() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
 
 	}
 
-	vec2 rand2() {
+	vec2 pcgRand2() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
 
 	}
 
-	vec3 rand3() {
+	vec3 pcgRand3() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
 
 	}
 
-	vec4 rand4() {
+	vec4 pcgRand4() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );

package/src/shader/rand/stratifiedTexture.glsl.js

@@ -0,0 +1,45 @@
+export const stratifiedTextureGLSL = /* glsl */`
+
+	uniform sampler2D stratifiedTexture;
+	uniform sampler2D stratifiedOffsetTexture;
+
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
+	vec4 pixelSeed = vec4( 0 );
+
+	vec4 rand4( int v ) {
+
+		ivec2 uv = ivec2( v, sobolBounceIndex );
+		vec4 stratifiedSample = texelFetch( stratifiedTexture, uv, 0 );
+		return fract( stratifiedSample + pixelSeed.r ); // blue noise + stratified samples
+
+	}
+
+	vec3 rand3( int v ) {
+
+		return rand4( v ).xyz;
+
+	}
+
+	vec2 rand2( int v ) {
+
+		return rand4( v ).xy;
+
+	}
+
+	float rand( int v ) {
+
+		return rand4( v ).x;
+
+	}
+
+	void rng_initialize( vec2 screenCoord, int frame ) {
+
+		// tile the small noise texture across the entire screen
+		ivec2 noiseSize = ivec2( textureSize( stratifiedOffsetTexture, 0 ) );
+		pixelSeed = texelFetch( stratifiedOffsetTexture, ivec2( screenCoord.xy ) % noiseSize, 0 );
+
+	}
+
+`;

package/src/shader/sampling/equirectSampling.glsl.js

@@ -26,10 +26,17 @@ export const equirectSamplingGLSL = /* glsl */`
 	// samples the color given env map with CDF and returns the pdf of the direction
 	float sampleEquirect( vec3 direction, inout vec3 color ) {
 
+		float totalSum = envMapInfo.totalSum;
+		if ( totalSum == 0.0 ) {
+
+			color = vec3( 0.0 );
+			return 1.0;
+
+		}
+
 		vec2 uv = equirectDirectionToUv( direction );
 		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
 		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;

package/src/shader/structs/lightsStruct.glsl.js

@@ -61,18 +61,16 @@ export const lightsStructGLSL = /* glsl */`
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );
 			l.radius = s4.r;
-			l.near = s4.g;
-			l.decay = s4.b;
-			l.distance = s4.a;
+			l.decay = s4.g;
+			l.distance = s4.b;
+			l.coneCos = s4.a;
 
-			l.coneCos = s5.r;
-			l.penumbraCos = s5.g;
-			l.iesProfile = int( round( s5.b ) );
+			l.penumbraCos = s5.r;
+			l.iesProfile = int( round( s5.g ) );
 
 		} else {
 
 			l.radius = 0.0;
-			l.near = 0.0;
 			l.decay = 0.0;
 			l.distance = 0.0;
 

package/src/textures/BlueNoiseTexture.js

@@ -0,0 +1,87 @@
+import { DataTexture, FloatType, NearestFilter, RGBAFormat, RGFormat, RedFormat } from 'three';
+import { BlueNoiseGenerator } from './blueNoise/BlueNoiseGenerator.js';
+
+function getStride( channels ) {
+
+	if ( channels >= 3 ) {
+
+		return 4;
+
+	} else {
+
+		return channels;
+
+	}
+
+}
+
+function getFormat( channels ) {
+
+	switch ( channels ) {
+
+	case 1:
+		return RedFormat;
+	case 2:
+		return RGFormat;
+	default:
+		return RGBAFormat;
+
+	}
+
+}
+
+export class BlueNoiseTexture extends DataTexture {
+
+	constructor( size = 64, channels = 1 ) {
+
+		super( new Float32Array( 4 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
+
+		this.size = size;
+		this.channels = channels;
+		this.update();
+
+	}
+
+	update() {
+
+		const channels = this.channels;
+		const size = this.size;
+		const generator = new BlueNoiseGenerator();
+		generator.channels = channels;
+		generator.size = size;
+
+		const stride = getStride( channels );
+		const format = getFormat( stride );
+		if ( this.image.width !== size || format !== this.format ) {
+
+			this.image.width = size;
+			this.image.height = size;
+			this.image.data = new Float32Array( ( size ** 2 ) * stride );
+			this.format = format;
+			this.dispose();
+
+		}
+
+		const data = this.image.data;
+		for ( let i = 0, l = channels; i < l; i ++ ) {
+
+			const result = generator.generate();
+			const bin = result.data;
+			const maxValue = result.maxValue;
+
+			for ( let j = 0, l2 = bin.length; j < l2; j ++ ) {
+
+				const value = bin[ j ] / maxValue;
+				data[ j * stride + i ] = value;
+
+			}
+
+		}
+
+		this.needsUpdate = true;
+
+	}
+
+}

package/src/textures/ProceduralEquirectTexture.js

@@ -2,14 +2,13 @@ import {
 	ClampToEdgeWrapping,
 	Color,
 	DataTexture,
-	DataUtils,
 	EquirectangularReflectionMapping,
-	HalfFloatType,
 	LinearFilter,
 	RepeatWrapping,
 	RGBAFormat,
 	Spherical,
 	Vector2,
+	FloatType
 } from 'three';
 
 const _uv = new Vector2();
@@ -21,8 +20,8 @@ export class ProceduralEquirectTexture extends DataTexture {
 	constructor( width = 512, height = 512 ) {
 
 		super(
-			new Uint16Array( width * height * 4 ),
-			width, height, RGBAFormat, HalfFloatType, EquirectangularReflectionMapping,
+			new Float32Array( width * height * 4 ),
+			width, height, RGBAFormat, FloatType, EquirectangularReflectionMapping,
 			RepeatWrapping, ClampToEdgeWrapping, LinearFilter, LinearFilter,
 		);
 
@@ -54,10 +53,10 @@ export class ProceduralEquirectTexture extends DataTexture {
 
 				const i = y * width + x;
 				const i4 = 4 * i;
-				data[ i4 + 0 ] = DataUtils.toHalfFloat( _color.r );
-				data[ i4 + 1 ] = DataUtils.toHalfFloat( _color.g );
-				data[ i4 + 2 ] = DataUtils.toHalfFloat( _color.b );
-				data[ i4 + 3 ] = DataUtils.toHalfFloat( 1.0 );
+				data[ i4 + 0 ] = ( _color.r );
+				data[ i4 + 1 ] = ( _color.g );
+				data[ i4 + 2 ] = ( _color.b );
+				data[ i4 + 3 ] = ( 1.0 );
 
 			}
 

package/src/textures/blueNoise/BlueNoiseGenerator.js

@@ -0,0 +1,115 @@
+import { shuffleArray, fillWithOnes } from './utils.js';
+import { BlueNoiseSamples } from './BlueNoiseSamples.js';
+
+export class BlueNoiseGenerator {
+
+	constructor() {
+
+		this.random = Math.random;
+		this.sigma = 1.5;
+		this.size = 64;
+		this.majorityPointsRatio = 0.1;
+
+		this.samples = new BlueNoiseSamples( 1 );
+		this.savedSamples = new BlueNoiseSamples( 1 );
+
+	}
+
+	generate() {
+
+		// http://cv.ulichney.com/papers/1993-void-cluster.pdf
+
+		const {
+			samples,
+			savedSamples,
+			sigma,
+			majorityPointsRatio,
+			size,
+		} = this;
+
+		samples.resize( size );
+		samples.setSigma( sigma );
+
+		// 1. Randomly place the minority points.
+		const pointCount = Math.floor( size * size * majorityPointsRatio );
+		const initialSamples = samples.binaryPattern;
+
+		fillWithOnes( initialSamples, pointCount );
+		shuffleArray( initialSamples, this.random );
+
+		for ( let i = 0, l = initialSamples.length; i < l; i ++ ) {
+
+			if ( initialSamples[ i ] === 1 ) {
+
+				samples.addPointIndex( i );
+
+			}
+
+		}
+
+		// 2. Remove minority point that is in densest cluster and place it in the largest void.
+		while ( true ) {
+
+			const clusterIndex = samples.findCluster();
+			samples.removePointIndex( clusterIndex );
+
+			const voidIndex = samples.findVoid();
+			if ( clusterIndex === voidIndex ) {
+
+				samples.addPointIndex( clusterIndex );
+				break;
+
+			}
+
+			samples.addPointIndex( voidIndex );
+
+		}
+
+		// 3. PHASE I: Assign a rank to each progressively less dense cluster point and put it
+		// in the dither array.
+		const ditherArray = new Uint32Array( size * size );
+		savedSamples.copy( samples );
+
+		let rank;
+		rank = samples.count - 1;
+		while ( rank >= 0 ) {
+
+			const clusterIndex = samples.findCluster();
+			samples.removePointIndex( clusterIndex );
+
+			ditherArray[ clusterIndex ] = rank;
+			rank --;
+
+		}
+
+		// 4. PHASE II: Do the same thing for the largest voids up to half of the total pixels using
+		// the initial binary pattern.
+		const totalSize = size * size;
+		rank = savedSamples.count;
+		while ( rank < totalSize / 2 ) {
+
+			const voidIndex = savedSamples.findVoid();
+			savedSamples.addPointIndex( voidIndex );
+			ditherArray[ voidIndex ] = rank;
+			rank ++;
+
+		}
+
+		// 5. PHASE III: Invert the pattern and finish out by assigning a rank to the remaining
+		// and iteratively removing them.
+		savedSamples.invert();
+
+		while ( rank < totalSize ) {
+
+			const clusterIndex = savedSamples.findCluster();
+			savedSamples.removePointIndex( clusterIndex );
+			ditherArray[ clusterIndex ] = rank;
+			rank ++;
+
+		}
+
+		return { data: ditherArray, maxValue: totalSize };
+
+	}
+
+}