three-gpu-pathtracer 0.0.11 → 0.0.12

package/src/shader/shaderUtils.js

@@ -1,361 +1,361 @@
-export const shaderUtils = /* glsl */`
-
-	// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md#attenuation
-	vec3 transmissionAttenuation( float dist, vec3 attColor, float attDist ) {
-
-		vec3 ot = - log( attColor ) / attDist;
-		return exp( - ot * dist );
-
-	}
-
-	// 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 );
-
-	}
-
-	vec3 schlickFresnel( float cosine, vec3 f0 ) {
-
-		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
-
-	}
-
-	float dielectricFresnel( float cosThetaI, float eta ) {
-
-		// https://schuttejoe.github.io/post/disneybsdf/
-		float ni = eta;
-		float nt = 1.0;
-
-		// Check for total internal reflection
-		float sinThetaISq = 1.0f - cosThetaI * cosThetaI;
-		float sinThetaTSq = eta * eta * sinThetaISq;
-		if( sinThetaTSq >= 1.0 ) {
-
-			return 1.0;
-
-		}
-
-		float sinThetaT = sqrt( sinThetaTSq );
-
-		float cosThetaT = sqrt( max( 0.0, 1.0f - sinThetaT * sinThetaT ) );
-		float rParallel = ( ( nt * cosThetaI ) - ( ni * cosThetaT ) ) / ( ( nt * cosThetaI ) + ( ni * cosThetaT ) );
-		float rPerpendicular = ( ( ni * cosThetaI ) - ( nt * cosThetaT ) ) / ( ( ni * cosThetaI ) + ( nt * cosThetaT ) );
-		return ( rParallel * rParallel + rPerpendicular * rPerpendicular ) / 2.0;
-
-	}
-
-	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
-	float iorRatioToF0( float eta ) {
-
-		return pow( ( 1.0 - eta ) / ( 1.0 + eta ), 2.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 wi, vec3 wo, float eta ) {
-
-		// get the half vector - assuming if the light incident vector is on the other side
-		// of the that it's transmissive.
-		vec3 h;
-		if ( wi.z > 0.0 ) {
-
-			h = normalize( wi + wo );
-
-		} else {
-
-			// Scale by the ior ratio to retrieve the appropriate half vector
-			// From Section 2.2 on computing the transmission half vector:
-			// https://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
-			h = normalize( wi + wo * eta );
-
-		}
-
-		h *= sign( h.z );
-		return h;
-
-	}
-
-	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;
-
-	}
-
-	vec2 sampleTriangle( vec2 a, vec2 b, vec2 c, vec2 r ) {
-
-		// get the edges of the triangle and the diagonal across the
-		// center of the parallelogram
-		vec2 e1 = a - b;
-		vec2 e2 = c - b;
-		vec2 diag = normalize( e1 + e2 );
-
-		// pick the point in the parallelogram
-		if ( r.x + r.y > 1.0 ) {
-
-			r = vec2( 1.0 ) - r;
-
-		}
-
-		return e1 * r.x + e2 * r.y;
-
-	}
-
-	vec2 sampleCircle( vec2 uv ) {
-
-		float angle = 2.0 * PI * uv.x;
-		float radius = sqrt( uv.y );
-		return vec2( cos( angle ), sin( angle ) ) * radius;
-
-	}
-
-	vec3 sampleSphere( vec2 uv ) {
-
-		float u = ( uv.x - 0.5 ) * 2.0;
-		float t = uv.y * PI * 2.0;
-		float f = sqrt( 1.0 - u * u );
-
-		return vec3( f * cos( t ), f * sin( t ), u );
-
-	}
-
-	vec2 sampleRegularNGon( int sides, vec3 uvw ) {
-
-		sides = max( sides, 3 );
-
-		vec3 r = uvw;
-		float anglePerSegment = 2.0 * PI / float( sides );
-		float segment = floor( float( sides ) * r.x );
-
-		float angle1 = anglePerSegment * segment;
-		float angle2 = angle1 + anglePerSegment;
-		vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
-		vec2 b = vec2( 0.0, 0.0 );
-		vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
-
-		return sampleTriangle( a, b, c, r.yz );
-
-	}
-
-	// samples an aperture shape with the given number of sides. 0 means circle
-	vec2 sampleAperture( int blades, vec3 uvw ) {
-
-		return blades == 0 ?
-			sampleCircle( uvw.xy ) :
-			sampleRegularNGon( blades, uvw );
-
-	}
-
-	// ray sampling x and z are swapped to align with expected background view
-	vec2 equirectDirectionToUv( vec3 direction ) {
-
-		// from Spherical.setFromCartesianCoords
-		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
-		uv /= vec2( 2.0 * PI, PI );
-
-		// apply adjustments to get values in range [0, 1] and y right side up
-		uv.x += 0.5;
-		uv.y = 1.0 - uv.y;
-		return uv;
-
-	}
-
-	vec3 equirectUvToDirection( vec2 uv ) {
-
-		// undo above adjustments
-		uv.x -= 0.5;
-		uv.y = 1.0 - uv.y;
-
-		// from Vector3.setFromSphericalCoords
-		float theta = uv.x * 2.0 * PI;
-		float phi = uv.y * PI;
-
-		float sinPhi = sin( phi );
-
-		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
-
-	}
-
-	// Fast arccos approximation used to remove banding artifacts caused by numerical errors in acos.
-	// This is a cubic Lagrange interpolating polynomial for x = [-1, -1/2, 0, 1/2, 1].
-	// For more information see: https://github.com/gkjohnson/three-gpu-pathtracer/pull/171#issuecomment-1152275248
-	float acosApprox( float x ) {
-
-		x = clamp( x, -1.0, 1.0 );
-		return ( - 0.69813170079773212 * x * x - 0.87266462599716477 ) * x + 1.5707963267948966;
-
-	}
-
-	// An acos with input values bound to the range [-1, 1].
-	float acosSafe( float x ) {
-
-		return acos( clamp( x, -1.0, 1.0 ) );
-
-	}
-
-	float saturateCos( float val ) {
-
-		return clamp( val, 0.001, 1.0 );
-
-	}
-
-	float square( float t ) {
-
-		return t * t;
-
-	}
-
-	vec2 square( vec2 t ) {
-
-		return t * t;
-
-	}
-
-	vec3 square( vec3 t ) {
-
-		return t * t;
-
-	}
-
-	vec4 square( vec4 t ) {
-
-		return t * t;
-
-	}
-
-	vec2 rotateVector( vec2 v, float t ) {
-
-		float ac = cos( t );
-		float as = sin( t );
-		return vec2(
-			v.x * ac - v.y * as,
-			v.x * as + v.y * ac
-		);
-
-	}
-
-	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
-	// falls in the bounds of the rectangle on that same plane.
-	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
-	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
-
-		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
-
-		if ( t > EPSILON ) {
-
-			vec3 p = rayOrigin + rayDirection * t;
-			vec3 vi = p - center;
-
-			// check if p falls inside the rectangle
-			float a1 = dot( u, vi );
-			if ( abs( a1 ) <= 0.5 ) {
-
-				float a2 = dot( v, vi );
-				if ( abs( a2 ) <= 0.5 ) {
-
-					dist = t;
-					return true;
-
-				}
-
-			}
-
-		}
-
-		return false;
-
-	}
-
-	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
-	// falls in the bounds of the circle on that same plane. See above URL for a description of the plane intersection algorithm.
-	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
-
-		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
-
-		if ( t > EPSILON ) {
-
-			vec3 hit = rayOrigin + rayDirection * t;
-			vec3 vi = hit - position;
-
-			float a1 = dot( u, vi );
-			float a2 = dot( v, vi );
-
-			if( length( vec2( a1, a2 ) ) <= 0.5 ) {
-
-				dist = t;
-				return true;
-
-			}
-
-		}
-
-		return false;
-
-	}
-
-	// power heuristic for multiple importance sampling
-	float misHeuristic( float a, float b ) {
-
-		float aa = a * a;
-		float bb = b * b;
-		return aa / ( aa + bb );
-
-	}
-
-	// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
-	// erichlof/THREE.js-PathTracing-Renderer/
-	float tentFilter( float x ) {
-
-		return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
-
-	}
-`;
+export const shaderUtils = /* glsl */`
+
+	// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md#attenuation
+	vec3 transmissionAttenuation( float dist, vec3 attColor, float attDist ) {
+
+		vec3 ot = - log( attColor ) / attDist;
+		return exp( - ot * dist );
+
+	}
+
+	// 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 );
+
+	}
+
+	vec3 schlickFresnel( float cosine, vec3 f0 ) {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+	float dielectricFresnel( float cosThetaI, float eta ) {
+
+		// https://schuttejoe.github.io/post/disneybsdf/
+		float ni = eta;
+		float nt = 1.0;
+
+		// Check for total internal reflection
+		float sinThetaISq = 1.0f - cosThetaI * cosThetaI;
+		float sinThetaTSq = eta * eta * sinThetaISq;
+		if( sinThetaTSq >= 1.0 ) {
+
+			return 1.0;
+
+		}
+
+		float sinThetaT = sqrt( sinThetaTSq );
+
+		float cosThetaT = sqrt( max( 0.0, 1.0f - sinThetaT * sinThetaT ) );
+		float rParallel = ( ( nt * cosThetaI ) - ( ni * cosThetaT ) ) / ( ( nt * cosThetaI ) + ( ni * cosThetaT ) );
+		float rPerpendicular = ( ( ni * cosThetaI ) - ( nt * cosThetaT ) ) / ( ( ni * cosThetaI ) + ( nt * cosThetaT ) );
+		return ( rParallel * rParallel + rPerpendicular * rPerpendicular ) / 2.0;
+
+	}
+
+	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
+	float iorRatioToF0( float eta ) {
+
+		return pow( ( 1.0 - eta ) / ( 1.0 + eta ), 2.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 wi, vec3 wo, float eta ) {
+
+		// get the half vector - assuming if the light incident vector is on the other side
+		// of the that it's transmissive.
+		vec3 h;
+		if ( wi.z > 0.0 ) {
+
+			h = normalize( wi + wo );
+
+		} else {
+
+			// Scale by the ior ratio to retrieve the appropriate half vector
+			// From Section 2.2 on computing the transmission half vector:
+			// https://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
+			h = normalize( wi + wo * eta );
+
+		}
+
+		h *= sign( h.z );
+		return h;
+
+	}
+
+	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;
+
+	}
+
+	vec2 sampleTriangle( vec2 a, vec2 b, vec2 c, vec2 r ) {
+
+		// get the edges of the triangle and the diagonal across the
+		// center of the parallelogram
+		vec2 e1 = a - b;
+		vec2 e2 = c - b;
+		vec2 diag = normalize( e1 + e2 );
+
+		// pick the point in the parallelogram
+		if ( r.x + r.y > 1.0 ) {
+
+			r = vec2( 1.0 ) - r;
+
+		}
+
+		return e1 * r.x + e2 * r.y;
+
+	}
+
+	vec2 sampleCircle( vec2 uv ) {
+
+		float angle = 2.0 * PI * uv.x;
+		float radius = sqrt( uv.y );
+		return vec2( cos( angle ), sin( angle ) ) * radius;
+
+	}
+
+	vec3 sampleSphere( vec2 uv ) {
+
+		float u = ( uv.x - 0.5 ) * 2.0;
+		float t = uv.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
+
+		return vec3( f * cos( t ), f * sin( t ), u );
+
+	}
+
+	vec2 sampleRegularNGon( int sides, vec3 uvw ) {
+
+		sides = max( sides, 3 );
+
+		vec3 r = uvw;
+		float anglePerSegment = 2.0 * PI / float( sides );
+		float segment = floor( float( sides ) * r.x );
+
+		float angle1 = anglePerSegment * segment;
+		float angle2 = angle1 + anglePerSegment;
+		vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
+		vec2 b = vec2( 0.0, 0.0 );
+		vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+
+		return sampleTriangle( a, b, c, r.yz );
+
+	}
+
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades, vec3 uvw ) {
+
+		return blades == 0 ?
+			sampleCircle( uvw.xy ) :
+			sampleRegularNGon( blades, uvw );
+
+	}
+
+	// ray sampling x and z are swapped to align with expected background view
+	vec2 equirectDirectionToUv( vec3 direction ) {
+
+		// from Spherical.setFromCartesianCoords
+		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
+		uv /= vec2( 2.0 * PI, PI );
+
+		// apply adjustments to get values in range [0, 1] and y right side up
+		uv.x += 0.5;
+		uv.y = 1.0 - uv.y;
+		return uv;
+
+	}
+
+	vec3 equirectUvToDirection( vec2 uv ) {
+
+		// undo above adjustments
+		uv.x -= 0.5;
+		uv.y = 1.0 - uv.y;
+
+		// from Vector3.setFromSphericalCoords
+		float theta = uv.x * 2.0 * PI;
+		float phi = uv.y * PI;
+
+		float sinPhi = sin( phi );
+
+		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+
+	}
+
+	// Fast arccos approximation used to remove banding artifacts caused by numerical errors in acos.
+	// This is a cubic Lagrange interpolating polynomial for x = [-1, -1/2, 0, 1/2, 1].
+	// For more information see: https://github.com/gkjohnson/three-gpu-pathtracer/pull/171#issuecomment-1152275248
+	float acosApprox( float x ) {
+
+		x = clamp( x, -1.0, 1.0 );
+		return ( - 0.69813170079773212 * x * x - 0.87266462599716477 ) * x + 1.5707963267948966;
+
+	}
+
+	// An acos with input values bound to the range [-1, 1].
+	float acosSafe( float x ) {
+
+		return acos( clamp( x, -1.0, 1.0 ) );
+
+	}
+
+	float saturateCos( float val ) {
+
+		return clamp( val, 0.001, 1.0 );
+
+	}
+
+	float square( float t ) {
+
+		return t * t;
+
+	}
+
+	vec2 square( vec2 t ) {
+
+		return t * t;
+
+	}
+
+	vec3 square( vec3 t ) {
+
+		return t * t;
+
+	}
+
+	vec4 square( vec4 t ) {
+
+		return t * t;
+
+	}
+
+	vec2 rotateVector( vec2 v, float t ) {
+
+		float ac = cos( t );
+		float as = sin( t );
+		return vec2(
+			v.x * ac - v.y * as,
+			v.x * as + v.y * ac
+		);
+
+	}
+
+	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
+	// falls in the bounds of the rectangle on that same plane.
+	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+
+		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
+
+		if ( t > EPSILON ) {
+
+			vec3 p = rayOrigin + rayDirection * t;
+			vec3 vi = p - center;
+
+			// check if p falls inside the rectangle
+			float a1 = dot( u, vi );
+			if ( abs( a1 ) <= 0.5 ) {
+
+				float a2 = dot( v, vi );
+				if ( abs( a2 ) <= 0.5 ) {
+
+					dist = t;
+					return true;
+
+				}
+
+			}
+
+		}
+
+		return false;
+
+	}
+
+	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
+	// falls in the bounds of the circle on that same plane. See above URL for a description of the plane intersection algorithm.
+	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+
+		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
+
+		if ( t > EPSILON ) {
+
+			vec3 hit = rayOrigin + rayDirection * t;
+			vec3 vi = hit - position;
+
+			float a1 = dot( u, vi );
+			float a2 = dot( v, vi );
+
+			if( length( vec2( a1, a2 ) ) <= 0.5 ) {
+
+				dist = t;
+				return true;
+
+			}
+
+		}
+
+		return false;
+
+	}
+
+	// power heuristic for multiple importance sampling
+	float misHeuristic( float a, float b ) {
+
+		float aa = a * a;
+		float bb = b * b;
+		return aa / ( aa + bb );
+
+	}
+
+	// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
+	// erichlof/THREE.js-PathTracing-Renderer/
+	float tentFilter( float x ) {
+
+		return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
+
+	}
+`;