three-gpu-pathtracer 0.0.1

package/src/shader/shaderMaterialSampling.js

@@ -0,0 +1,333 @@
+import { shaderGGXFunctions } from './shaderGGXFunctions.js';
+
+export const shaderMaterialSampling = /* glsl */`
+
+struct SurfaceRec {
+	vec3 normal;
+	vec3 faceNormal;
+	bool frontFace;
+	float roughness;
+	float filteredRoughness;
+	float metalness;
+	vec3 color;
+	vec3 emission;
+	float transmission;
+	float ior;
+};
+
+struct SampleRec {
+	float pdf;
+	vec3 direction;
+	vec3 color;
+};
+
+${ shaderGGXFunctions }
+
+// diffuse
+float diffusePDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
+	float cosValue = wi.z;
+	return cosValue / PI;
+
+}
+
+vec3 diffuseDirection( vec3 wo, SurfaceRec surf ) {
+
+	vec3 lightDirection = randDirection();
+	lightDirection.z += 1.0;
+	lightDirection = normalize( lightDirection );
+
+	return lightDirection;
+
+}
+
+vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// TODO: scale by 1 - F here
+	// note on division by PI
+	// https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
+	float metalFactor = ( 1.0 - surf.metalness ) * wi.z / ( PI * PI );
+	float transmissionFactor = 1.0 - surf.transmission;
+	return surf.color * metalFactor * transmissionFactor;
+
+}
+
+// specular
+float specularPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// See equation (17) in http://jcgt.org/published/0003/02/03/
+	float filteredRoughness = surf.filteredRoughness;
+	vec3 halfVector = getHalfVector( wi, wo );
+	return ggxPDF( wi, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+}
+
+vec3 specularDirection( vec3 wo, SurfaceRec surf ) {
+
+	// sample ggx vndf distribution which gives a new normal
+	float filteredRoughness = surf.filteredRoughness;
+	vec3 halfVector = ggxDirection(
+		wo,
+		filteredRoughness,
+		filteredRoughness,
+		rand(),
+		rand()
+	);
+
+	// apply to new ray by reflecting off the new normal
+	return - reflect( wo, halfVector );
+
+}
+
+vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// if roughness is set to 0 then D === NaN which results in black pixels
+	float metalness = surf.metalness;
+	float ior = surf.ior;
+	bool frontFace = surf.frontFace;
+	float filteredRoughness = surf.filteredRoughness;
+
+	vec3 halfVector = getHalfVector( wo, wi );
+	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
+	float D = ggxDistribution( halfVector, filteredRoughness );
+
+	float F = schlickFresnelFromIor( dot( wi, halfVector ), iorRatio );
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		F = 1.0;
+
+	}
+
+	vec3 color = mix( vec3( 1.0 ), surf.color, metalness );
+	color = mix( color, vec3( 1.0 ), F );
+	color *= G * D / ( 4.0 * abs( wi.z * wo.z ) );
+	color *= mix( F, 1.0, metalness );
+	color *= wi.z; // scale the light by the direction the light is coming in from
+
+	return color;
+
+}
+
+/*
+// transmission
+function transmissionPDF( wo, wi, material, surf ) {
+
+	// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
+
+	const { roughness, ior } = material;
+	const { frontFace } = hit;
+	const ratio = frontFace ? ior : 1 / ior;
+	const minRoughness = Math.max( roughness, MIN_ROUGHNESS );
+
+	halfVector.set( 0, 0, 0 ).addScaledVector( wi, ratio ).addScaledVector( wo, 1.0 ).normalize().multiplyScalar( - 1 );
+
+	const denom = Math.pow( ratio * halfVector.dot( wi ) + 1.0 * halfVector.dot( wo ), 2.0 );
+	return ggxPDF( wo, halfVector, minRoughness ) / denom;
+
+}
+
+function transmissionDirection( wo, hit, material, lightDirection ) {
+
+	const { roughness, ior } = material;
+	const { frontFace } = hit;
+	const ratio = frontFace ? 1 / ior : ior;
+	const minRoughness = Math.max( roughness, MIN_ROUGHNESS );
+
+	// sample ggx vndf distribution which gives a new normal
+	ggxDirection(
+		wo,
+		minRoughness,
+		minRoughness,
+		Math.random(),
+		Math.random(),
+		halfVector,
+	);
+
+	// apply to new ray by reflecting off the new normal
+	tempDir.copy( wo ).multiplyScalar( - 1 );
+	refract( tempDir, halfVector, ratio, lightDirection );
+
+}
+
+function transmissionColor( wo, wi, material, hit, colorTarget ) {
+
+	const { metalness, transmission } = material;
+	colorTarget
+		.copy( material.color )
+		.multiplyScalar( ( 1.0 - metalness ) * wo.z )
+		.multiplyScalar( transmission );
+
+}
+*/
+
+// TODO: This is just using a basic cosine-weighted specular distribution with an
+// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
+float transmissionPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = surf.ior;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		return 0.0;
+
+	}
+
+	return 1.0 / ( 1.0 - reflectance );
+
+}
+
+vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
+
+	float roughness = surf.roughness;
+	float ior = surf.ior;
+	bool frontFace = surf.frontFace;
+	float ratio = frontFace ? 1.0 / ior : ior;
+
+	vec3 lightDirection = refract( - wo, vec3( 0.0, 0.0, 1.0 ), ratio );
+	lightDirection += randDirection() * roughness;
+	return normalize( lightDirection );
+
+}
+
+vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+
+	vec3 color = surf.color;
+	color *= ( 1.0 - metalness );
+	color *= transmission;
+
+	return color;
+
+}
+
+float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	float spdf = 0.0;
+	float dpdf = 0.0;
+	float tpdf = 0.0;
+
+	if ( wi.z < 0.0 ) {
+
+		tpdf = transmissionPDF( wo, wi, surf );
+
+	} else {
+
+		spdf = specularPDF( wo, wi, surf );
+		dpdf = diffusePDF( wo, wi, surf );
+
+	}
+
+	float transSpecularProb = mix( reflectance, 1.0, metalness );
+	float diffSpecularProb = 0.5 + 0.5 * metalness;
+	float pdf =
+		spdf * transmission * transSpecularProb
+		+ tpdf * transmission * ( 1.0 - transSpecularProb )
+		+ spdf * ( 1.0 - transmission ) * diffSpecularProb
+		+ dpdf * ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
+
+	return pdf;
+
+}
+
+vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	vec3 color = vec3( 0.0 );
+	if ( wi.z < 0.0 ) {
+
+		color = transmissionColor( wo, wi, surf );
+
+	} else {
+
+		color = diffuseColor( wo, wi, surf );
+		color *= 1.0 - surf.transmission;
+
+		color += specularColor( wo, wi, surf );
+
+	}
+
+	return color;
+
+}
+
+SampleRec bsdfSample( vec3 wo, SurfaceRec surf ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	SampleRec result;
+	if ( rand() < transmission ) {
+
+		float specularProb = mix( reflectance, 1.0, metalness );
+		if ( rand() < specularProb ) {
+
+			result.direction = specularDirection( wo, surf );
+
+		} else {
+
+			result.direction = transmissionDirection( wo, surf );
+
+		}
+
+	} else {
+
+		float specularProb = 0.5 + 0.5 * metalness;
+		if ( rand() < specularProb ) {
+
+			result.direction = specularDirection( wo, surf );
+
+		} else {
+
+			result.direction = diffuseDirection( wo, surf );
+
+		}
+
+	}
+
+	result.pdf = bsdfPdf( wo, result.direction, surf );
+	result.color = bsdfColor( wo, result.direction, surf );
+	return result;
+
+}
+`;

package/src/shader/shaderStructs.js

@@ -0,0 +1,30 @@
+export const shaderMaterialStructs = /* glsl */ `
+
+	struct Material {
+
+		vec3 color;
+		int map;
+
+		float metalness;
+		int metalnessMap;
+
+		float roughness;
+		int roughnessMap;
+
+		float ior;
+		float transmission;
+		int transmissionMap;
+
+		vec3 emissive;
+		float emissiveIntensity;
+		int emissiveMap;
+
+		int normalMap;
+		vec2 normalScale;
+
+		float opacity;
+		float alphaTest;
+
+	};
+
+`;

package/src/shader/shaderUtils.js

@@ -0,0 +1,140 @@
+export const shaderUtils = /* glsl */`
+
+	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
+	float schlickFresnel( float cosine, float f0 ) {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
+	float schlickFresnelFromIor( float cosine, float iorRatio ) {
+
+		// Schlick approximation
+		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
+		return schlickFresnel( cosine, r_0 );
+
+	}
+
+	// forms a basis with the normal vector as Z
+	mat3 getBasisFromNormal( vec3 normal ) {
+
+		vec3 other;
+		if ( abs( normal.x ) > 0.5 ) {
+
+			other = vec3( 0.0, 1.0, 0.0 );
+
+		} else {
+
+			other = vec3( 1.0, 0.0, 0.0 );
+
+		}
+
+		vec3 ortho = normalize( cross( normal, other ) );
+		vec3 ortho2 = normalize( cross( normal, ortho ) );
+		return mat3( ortho2, ortho, normal );
+
+	}
+
+	vec3 getHalfVector( vec3 a, vec3 b ) {
+
+		return normalize( a + b );
+
+	}
+
+	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray
+	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If
+	// we find a ray like that we ignore it to avoid artifacts.
+	// This function returns if the direction is on the same side of both planes.
+	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {
+
+		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;
+		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;
+		return aboveSurfaceNormal == aboveGeometryNormal;
+
+	}
+
+	vec3 getHemisphereSample( vec3 n, vec2 uv ) {
+
+		// https://www.rorydriscoll.com/2009/01/07/better-sampling/
+		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf
+		float sign = n.z == 0.0 ? 1.0 : sign( n.z );
+		float a = - 1.0 / ( sign + n.z );
+		float b = n.x * n.y * a;
+		vec3 b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );
+		vec3 b2 = vec3( b, sign + n.y * n.y * a, - n.y );
+
+		float r = sqrt( uv.x );
+		float theta = 2.0 * PI * uv.y;
+		float x = r * cos( theta );
+		float y = r * sin( theta );
+		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;
+
+	}
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 s0;
+
+	void rng_initialize(vec2 p, int frame) {
+
+		// white noise seed
+		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
+
+	}
+
+	// https://www.pcg-random.org/
+	void pcg4d( inout uvec4 v ) {
+
+		v = v * 1664525u + 1013904223u;
+		v.x += v.y * v.w;
+		v.y += v.z * v.x;
+		v.z += v.x * v.y;
+		v.w += v.y * v.z;
+		v = v ^ ( v >> 16u );
+		v.x += v.y*v.w;
+		v.y += v.z*v.x;
+		v.z += v.x*v.y;
+		v.w += v.y*v.z;
+
+	}
+
+	float rand() {
+
+		pcg4d(s0);
+		return float( s0.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( s0 );
+		return vec2( s0.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d(s0);
+		return vec3( s0.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d(s0);
+		return vec4(s0)/float(0xffffffffu);
+
+	}
+
+	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
+	vec3 randDirection() {
+
+		vec2 r = rand2();
+		float u = ( r.x - 0.5 ) * 2.0;
+		float t = r.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
+
+		return vec3( f * cos( t ), f * sin( t ), u );
+
+	}
+`;

package/src/uniforms/EquirectPdfUniform.js

@@ -0,0 +1,132 @@
+import { Color, DataTexture, FloatType, RGFormat, LinearFilter } from 'three';
+
+function RGBEToLinear( r, g, b, e, target ) {
+
+	const exp = e * 255.0 - 128.0;
+	target.set( r, g, b ).multiplyScalar( Math.pow( exp ) );
+	return target;
+
+}
+
+export class EquirectPdfUniform {
+
+	constructor() {
+
+		const marginalData = new DataTexture();
+		marginalData.type = FloatType;
+		marginalData.format = RGFormat;
+		marginalData.minFilter = LinearFilter;
+		marginalData.maxFilter = LinearFilter;
+		marginalData.generateMipmaps = false;
+
+		const conditionalData = new DataTexture();
+		conditionalData.type = FloatType;
+		conditionalData.format = RGFormat;
+		conditionalData.minFilter = LinearFilter;
+		conditionalData.maxFilter = LinearFilter;
+		conditionalData.generateMipmaps = false;
+
+		this.marginalData = marginalData;
+		this.conditionalData = conditionalData;
+
+	}
+
+	updateFrom( hdr ) {
+
+		// TODO: another reference implementation with a different approach:
+		// https://github.com/nvpro-samples/vk_mini_samples/blob/main/hdr_sampling/src/hdr_env.cpp#L243
+
+		// https://github.com/knightcrawler25/GLSL-PathTracer/blob/master/src/loaders/hdrloader.cpp
+		const { width, height, data } = hdr.image;
+		const color = new Color();
+		const hsl = {};
+
+		// track the importance of any given pixel in the image by tracking its weight relative to other pixels in the image
+		const pdfConditional = new Float32Array( width * height );
+		const cdfConditional = new Float32Array( width * height );
+
+		const pdfMarginal = new Float32Array( height );
+		const cdfMarginal = new Float32Array( height );
+
+		let cumulativeWeightMarginal = 0.0;
+		for ( let y = 0; y < height; y ++ ) {
+
+			let cumulativeWeight = 0.0;
+			for ( let x = 0; x < width; x ++ ) {
+
+				const i = y * width + x;
+				const r = data[ 4 * i + 0 ];
+				const g = data[ 4 * i + 1 ];
+				const b = data[ 4 * i + 2 ];
+				const e = data[ 4 * i + 3 ];
+
+				// the probability of the pixel being selected in this row is the
+				// scale of the luminance relative to the rest of the pixels.
+				// TODO: this should also account for the solid angle of the pixel when sampling
+				const weight = RGBEToLinear( r, g, b, e, color ).getHSL( hsl ).l;
+				cumulativeWeight += weight;
+
+				pdfConditional[ i ] = weight;
+				cdfConditional[ i ] = cumulativeWeight;
+
+			}
+
+			// scale the pdf and cdf to [0.0, 1.0]
+			for ( let i = 0, l = pdfConditional.length; i < l; i ++ ) {
+
+				pdfConditional[ i ] /= cumulativeWeight;
+				cdfConditional[ i ] /= cumulativeWeight;
+
+			}
+
+			cumulativeWeightMarginal += cumulativeWeight;
+
+			// compute the marginal pdf and cdf along the height of the map.
+			pdfMarginal[ y ] = cumulativeWeight;
+			cdfMarginal[ y ] = cumulativeWeightMarginal;
+
+		}
+
+		// scale the marginal pdf and cdf to [0.0, 1.0]
+		for ( let i = 0, l = pdfMarginal.length; i < l; i ++ ) {
+
+			pdfMarginal[ i ] /= cumulativeWeightMarginal;
+			cdfMarginal[ i ] /= cumulativeWeightMarginal;
+
+		}
+
+		// compute a sorted index of distributions and the probabilities along them for both
+		// the marginal and conditional data. These will be used to sample with a random number
+		// to retrieve a uv value to sample in the environment map.
+		const marginalDataArray = new Float32Array( height * 2 );
+		const conditionalDataArray = new Float32Array( width * height * 2 );
+
+		for ( let i = 0; i < height; i ++ ) {
+
+			//const dist = ( i + 1 ) / height;
+			const row = 0; // TODO: find the row that lies at the given cumulative distribution value above
+			marginalDataArray[ 2 * i + 0 ] = row / height;
+			marginalDataArray[ 2 * i + 1 ] = pdfMarginal[ i ];
+
+		}
+
+		for ( let y = 0; y < height; y ++ ) {
+
+			for ( let x = 0; x < width; x ++ ) {
+
+				const i = y * width + x;
+				//const dist = ( x + 1 ) / width;
+				const col = 0; // TODO: find the column in the given row that lies at the cumulative dist value above
+				conditionalDataArray[ 2 * i + 0 ] = col / width;
+				conditionalDataArray[ 2 * i + 1 ] = pdfConditional[ i ];
+
+			}
+
+		}
+
+		this.marginalData.image = { width, height, data: marginalDataArray };
+		this.conditionalData.image = { width, height, data: conditionalDataArray };
+
+	}
+
+}

package/src/uniforms/MaterialStructArrayUniform.js

@@ -0,0 +1,18 @@
+import { MaterialStructUniform } from './MaterialStructUniform.js';
+
+export class MaterialStructArrayUniform extends Array {
+
+	updateFrom( materials, textures ) {
+
+		while ( this.length > materials.length ) this.pop();
+		while ( this.length < materials.length ) this.push( new MaterialStructUniform() );
+
+		for ( let i = 0, l = this.length; i < l; i ++ ) {
+
+			this[ i ].updateFrom( materials[ i ], textures );
+
+		}
+
+	}
+
+}