three-gpu-pathtracer 0.0.1

package/src/materials/PhysicalPathTracingMaterial.js

@@ -0,0 +1,370 @@
+import { Matrix4, Matrix3, Color } from 'three';
+import { MaterialBase } from './MaterialBase.js';
+import {
+	MeshBVHUniformStruct, FloatVertexAttributeTexture, UIntVertexAttributeTexture,
+	shaderStructs, shaderIntersectFunction,
+} from 'three-mesh-bvh';
+import { shaderMaterialStructs } from '../shader/shaderStructs.js';
+import { MaterialStructArrayUniform } from '../uniforms/MaterialStructArrayUniform.js';
+import { RenderTarget2DArray } from '../uniforms/RenderTarget2DArray.js';
+import { shaderMaterialSampling } from '../shader/shaderMaterialSampling.js';
+import { shaderUtils } from '../shader/shaderUtils.js';
+
+export class PhysicalPathTracingMaterial extends MaterialBase {
+
+	// three.js relies on this field to add env map functions and defines
+	get envMap() {
+
+		return this.environmentMap;
+
+	}
+
+	constructor( parameters ) {
+
+		super( {
+
+			transparent: true,
+			depthWrite: false,
+
+			defines: {
+				BOUNCES: 3,
+				TRANSPARENT_TRAVERSALS: 5,
+				MATERIAL_LENGTH: 0,
+				GRADIENT_BG: 0,
+			},
+
+			uniforms: {
+				bvh: { value: new MeshBVHUniformStruct() },
+				normalAttribute: { value: new FloatVertexAttributeTexture() },
+				tangentAttribute: { value: new FloatVertexAttributeTexture() },
+				uvAttribute: { value: new FloatVertexAttributeTexture() },
+				materialIndexAttribute: { value: new UIntVertexAttributeTexture() },
+				materials: { value: new MaterialStructArrayUniform() },
+				textures: { value: new RenderTarget2DArray().texture },
+				cameraWorldMatrix: { value: new Matrix4() },
+				invProjectionMatrix: { value: new Matrix4() },
+				environmentBlur: { value: 0.2 },
+				environmentIntensity: { value: 2.0 },
+				environmentMap: { value: null },
+				environmentRotation: { value: new Matrix3() },
+				seed: { value: 0 },
+				opacity: { value: 1 },
+				filterGlossyFactor: { value: 0.0 },
+
+				gradientTop: { value: new Color( 0xbfd8ff ) },
+				gradientBottom: { value: new Color( 0xffffff ) },
+
+				bgGradientTop: { value: new Color( 0x111111 ) },
+				bgGradientBottom: { value: new Color( 0x000000 ) },
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec2 vUv;
+				void main() {
+
+					vec4 mvPosition = vec4( position, 1.0 );
+					mvPosition = modelViewMatrix * mvPosition;
+					gl_Position = projectionMatrix * mvPosition;
+
+					vUv = uv;
+
+				}
+
+			`,
+
+			fragmentShader: /* glsl */`
+				#define RAY_OFFSET 1e-5
+
+				precision highp isampler2D;
+				precision highp usampler2D;
+				precision highp sampler2DArray;
+				vec4 envMapTexelToLinear( vec4 a ) { return a; }
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${ shaderStructs }
+				${ shaderIntersectFunction }
+				${ shaderMaterialStructs }
+
+				${ shaderUtils }
+				${ shaderMaterialSampling }
+
+				#ifdef USE_ENVMAP
+
+				uniform float environmentBlur;
+				uniform sampler2D environmentMap;
+				uniform mat3 environmentRotation;
+
+				#else
+
+				uniform vec3 gradientTop;
+				uniform vec3 gradientBottom;
+
+				#endif
+
+				#if GRADIENT_BG
+
+				uniform vec3 bgGradientTop;
+				uniform vec3 bgGradientBottom;
+
+				#endif
+
+				uniform mat4 cameraWorldMatrix;
+				uniform mat4 invProjectionMatrix;
+				uniform sampler2D normalAttribute;
+				uniform sampler2D tangentAttribute;
+				uniform sampler2D uvAttribute;
+				uniform usampler2D materialIndexAttribute;
+				uniform BVH bvh;
+				uniform float environmentIntensity;
+				uniform float filterGlossyFactor;
+				uniform int seed;
+				uniform float opacity;
+				uniform Material materials[ MATERIAL_LENGTH ];
+				uniform sampler2DArray textures;
+				varying vec2 vUv;
+
+				void main() {
+
+					rng_initialize( gl_FragCoord.xy, seed );
+
+					// get [-1, 1] normalized device coordinates
+					vec2 ndc = 2.0 * vUv - vec2( 1.0 );
+					vec3 rayOrigin, rayDirection;
+					ndcToCameraRay( ndc, cameraWorldMatrix, invProjectionMatrix, rayOrigin, rayDirection );
+
+					// Lambertian render
+					gl_FragColor = vec4( 0.0 );
+
+					vec3 throughputColor = vec3( 1.0 );
+
+					// hit results
+					uvec4 faceIndices = uvec4( 0u );
+					vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
+					vec3 barycoord = vec3( 0.0 );
+					float side = 1.0;
+					float dist = 0.0;
+					float accumulatedRoughness = 0.0;
+					int i;
+					int transparentTraversals = TRANSPARENT_TRAVERSALS;
+					for ( i = 0; i < BOUNCES; i ++ ) {
+
+						if ( ! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
+
+							#if GRADIENT_BG
+
+							if ( i == 0 ) {
+
+								rayDirection = normalize( rayDirection + randDirection() * 0.05 );
+								float value = ( rayDirection.y + 1.0 ) / 2.0;
+
+								value = pow( value, 2.0 );
+
+								gl_FragColor = vec4( mix( bgGradientBottom, bgGradientTop, value ), 1.0 );
+								break;
+
+							}
+
+							#endif
+
+							#ifdef USE_ENVMAP
+
+                            vec3 skyColor = textureCubeUV( environmentMap, environmentRotation * rayDirection, environmentBlur ).rgb;
+
+							#else
+
+							rayDirection = normalize( rayDirection );
+							float value = ( rayDirection.y + 1.0 ) / 2.0;
+							vec3 skyColor = mix( gradientBottom, gradientTop, value );
+
+							#endif
+
+							gl_FragColor += vec4( skyColor * throughputColor * environmentIntensity, 1.0 );
+
+							break;
+
+						}
+
+						uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
+						Material material = materials[ materialIndex ];
+
+						vec2 uv = textureSampleBarycoord( uvAttribute, barycoord, faceIndices.xyz ).xy;
+
+						// albedo
+						vec4 albedo = vec4( material.color, material.opacity );
+						if ( material.map != - 1 ) {
+
+							albedo *= texture2D( textures, vec3( uv, material.map ) );
+
+						}
+
+						// possibly skip this sample if it's transparent or alpha test is enabled
+						// alpha test is disabled when it === 0
+						float alphaTest = material.alphaTest;
+						bool useAlphaTest = alphaTest != 0.0;
+						if (
+							useAlphaTest && albedo.a < alphaTest
+							|| ! useAlphaTest && albedo.a < rand()
+						) {
+
+							vec3 point = rayOrigin + rayDirection * dist;
+							rayOrigin += rayDirection * dist - faceNormal * RAY_OFFSET;
+
+							// only allow a limited number of transparency discards otherwise we could
+							// crash the context with too long a loop.
+							i -= sign( transparentTraversals );
+							transparentTraversals -= sign( transparentTraversals );
+							continue;
+
+						}
+
+						// fetch the interpolated smooth normal
+						vec3 normal = normalize( textureSampleBarycoord(
+							normalAttribute,
+							barycoord,
+							faceIndices.xyz
+						).xyz );
+
+						// roughness
+						float roughness = material.roughness;
+						if ( material.roughnessMap != - 1 ) {
+
+							roughness *= texture2D( textures, vec3( uv, material.roughnessMap ) ).g;
+
+						}
+
+						// metalness
+						float metalness = material.metalness;
+						if ( material.metalnessMap != - 1 ) {
+
+							metalness *= texture2D( textures, vec3( uv, material.metalnessMap ) ).b;
+
+						}
+
+						// emission
+						vec3 emission = material.emissiveIntensity * material.emissive;
+						if ( material.emissiveMap != - 1 ) {
+
+							emission *= texture2D( textures, vec3( uv, material.emissiveMap ) ).xyz;
+
+						}
+
+						// transmission
+						float transmission = material.transmission;
+						if ( material.transmissionMap != - 1 ) {
+
+							transmission *= texture2D( textures, vec3( uv, material.transmissionMap ) ).r;
+
+						}
+
+						// normal
+						if ( material.normalMap != - 1 ) {
+
+							vec4 tangentSample = textureSampleBarycoord(
+								tangentAttribute,
+								barycoord,
+								faceIndices.xyz
+							);
+
+							// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate
+							// resulting in NaNs and slow path tracing.
+							if ( length( tangentSample.xyz ) > 0.0 ) {
+
+								vec3 tangent = normalize( tangentSample.xyz );
+								vec3 bitangent = normalize( cross( normal, tangent ) * tangentSample.w );
+								mat3 vTBN = mat3( tangent, bitangent, normal );
+
+								vec3 texNormal = texture2D( textures, vec3( uv, material.normalMap ) ).xyz * 2.0 - 1.0;
+								texNormal.xy *= material.normalScale;
+								normal = vTBN * texNormal;
+
+							}
+
+						}
+
+						normal *= side;
+
+						SurfaceRec surfaceRec;
+						surfaceRec.normal = normal;
+						surfaceRec.faceNormal = faceNormal;
+						surfaceRec.frontFace = side == 1.0;
+						surfaceRec.transmission = transmission;
+						surfaceRec.ior = material.ior;
+						surfaceRec.emission = emission;
+						surfaceRec.metalness = metalness;
+						surfaceRec.color = albedo.rgb;
+						surfaceRec.roughness = roughness;
+
+						// Compute the filtered roughness value to use during specular reflection computations. A minimum
+						// value of 1e-6 is needed because the GGX functions do not work with a roughness value of 0 and
+						// the accumulated roughness value is scaled by a user setting and a "magic value" of 5.0.
+						// If we're exiting something transmissive then scale the factor down significantly so we can retain
+						// sharp internal reflections
+						surfaceRec.filteredRoughness = clamp(
+							max( surfaceRec.roughness, accumulatedRoughness * filterGlossyFactor * 5.0 ),
+							1e-3,
+							1.0
+						);
+
+						mat3 normalBasis = getBasisFromNormal( surfaceRec.normal );
+						mat3 invBasis = inverse( normalBasis );
+
+						vec3 outgoing = - normalize( invBasis * rayDirection );
+						SampleRec sampleRec = bsdfSample( outgoing, surfaceRec );
+
+						// adjust the hit point by the surface normal by a factor of some offset and the
+						// maximum component-wise value of the current point to accommodate floating point
+						// error as values increase.
+						vec3 point = rayOrigin + rayDirection * dist;
+						vec3 absPoint = abs( point );
+						float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+						rayDirection = normalize( normalBasis * sampleRec.direction );
+
+						bool isBelowSurface = dot( rayDirection, faceNormal ) < 0.0;
+						rayOrigin = point + faceNormal * ( maxPoint + 1.0 ) * ( isBelowSurface ? - RAY_OFFSET : RAY_OFFSET );
+
+						// accumulate a roughness value to offset diffuse, specular, diffuse rays that have high contribution
+						// to a single pixel resulting in fireflies
+						if ( ! isBelowSurface ) {
+
+							// determine if this is a rough normal or not by checking how far off straight up it is
+							vec3 halfVector = normalize( outgoing + sampleRec.direction );
+							accumulatedRoughness += sin( acos( halfVector.z ) );
+
+						}
+
+						// accumulate color
+						gl_FragColor.rgb += ( emission * throughputColor );
+
+						// skip the sample if our PDF or ray is impossible
+						if ( sampleRec.pdf <= 0.0 || ! isDirectionValid( rayDirection, normal, faceNormal) ) {
+
+							break;
+
+						}
+
+						throughputColor *= sampleRec.color / sampleRec.pdf;
+
+						// discard the sample if there are any NaNs
+						if ( any( isnan( throughputColor ) ) || any( isinf( throughputColor ) ) ) {
+
+							break;
+
+						}
+
+					}
+
+					gl_FragColor.a = opacity;
+
+				}
+
+			`
+
+		} );
+
+		this.setValues( parameters );
+
+	}
+
+}

package/src/shader/shaderGGXFunctions.js

@@ -0,0 +1,107 @@
+export const shaderGGXFunctions = /* glsl */`
+// The GGX functions provide sampling and distribution information for normals as output so
+// in order to get probability of scatter direction the half vector must be computed and provided.
+// [0] https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
+// [1] https://hal.archives-ouvertes.fr/hal-01509746/document
+// [2] http://jcgt.org/published/0007/04/01/
+// [4] http://jcgt.org/published/0003/02/03/
+
+// trowbridge-reitz === GGX === GTR
+
+vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float random1, float random2 ) {
+
+	// TODO: try GGXVNDF implementation from reference [2], here. Needs to update ggxDistribution
+	// function below, as well
+
+	// Implementation from reference [1]
+	// stretch view
+	vec3 V = normalize( vec3( roughnessX * incidentDir.x, roughnessY * incidentDir.y, incidentDir.z ) );
+
+	// orthonormal basis
+	vec3 T1 = ( V.z < 0.9999 ) ? normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) ) : vec3( 1.0, 0.0, 0.0 );
+	vec3 T2 = cross( T1, V );
+
+	// sample point with polar coordinates (r, phi)
+	float a = 1.0 / ( 1.0 + V.z );
+	float r = sqrt( random1 );
+	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
+	float P1 = r * cos( phi );
+	float P2 = r * sin( phi ) * ( ( random2 < a ) ? 1.0 : V.z );
+
+	// compute normal
+	vec3 N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );
+
+	// unstretch
+	N = normalize( vec3( roughnessX * N.x, roughnessY * N.y, max( 0.0, N.z ) ) );
+
+	return N;
+
+}
+
+// Below are PDF and related functions for use in a Monte Carlo path tracer
+// as specified in Appendix B of the following paper
+// See equation (2) from reference [2]
+float ggxLamda( float theta, float roughness ) {
+
+	float tanTheta = tan( theta );
+	float tanTheta2 = tanTheta * tanTheta;
+	float alpha2 = roughness * roughness;
+
+	float numerator = - 1.0 + sqrt( 1.0 + alpha2 * tanTheta2 );
+	return numerator / 2.0;
+
+}
+
+// See equation (2) from reference [2]
+float ggxShadowMaskG1( float theta, float roughness ) {
+
+	return 1.0 / ( 1.0 + ggxLamda( theta, roughness ) );
+
+}
+
+// See equation (125) from reference [4]
+float ggxShadowMaskG2( vec3 wi, vec3 wo, float roughness ) {
+
+	float incidentTheta = acos( wi.z );
+	float scatterTheta = acos( wo.z );
+	return 1.0 / ( 1.0 + ggxLamda( incidentTheta, roughness ) + ggxLamda( scatterTheta, roughness ) );
+
+}
+
+float ggxDistribution( vec3 halfVector, float roughness ) {
+
+	// See equation (33) from reference [0]
+	float a2 = roughness * roughness;
+	float cosTheta = halfVector.z;
+	float cosTheta4 = pow( cosTheta, 4.0 );
+
+	if ( cosTheta == 0.0 ) return 0.0;
+
+	float theta = acos( halfVector.z );
+	float tanTheta = tan( theta );
+	float tanTheta2 = pow( tanTheta, 2.0 );
+
+	float denom = PI * cosTheta4 * pow( a2 + tanTheta2, 2.0 );
+	return a2 / denom;
+
+	// See equation (1) from reference [2]
+	// const { x, y, z } = halfVector;
+	// const a2 = roughness * roughness;
+	// const mult = x * x / a2 + y * y / a2 + z * z;
+	// const mult2 = mult * mult;
+
+	// return 1.0 / Math.PI * a2 * mult2;
+
+}
+
+// See equation (3) from reference [2]
+float ggxPDF( vec3 wi, vec3 halfVector, float roughness ) {
+
+	float incidentTheta = acos( wi.z );
+	float D = ggxDistribution( halfVector, roughness );
+	float G1 = ggxShadowMaskG1( incidentTheta, roughness );
+
+	return D * G1 * max( 0.0, dot( wi, halfVector ) ) / wi.z;
+
+}
+`;