three-gpu-pathtracer 0.0.14 → 0.0.16

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

@@ -1,62 +1,62 @@
-export const intersectShapesGLSL = /* glsl */`
-
-	// 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;
-
-	}
-
-`;
+export const intersectShapesGLSL = /* glsl */`
+
+	// 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;
+
+	}
+
+`;

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

@@ -1,81 +1,81 @@
-export const mathGLSL = /* glsl */`
-
-	// 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
-		);
-
-	}
-
-	// 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 );
-
-	}
-
-`;
+export const mathGLSL = /* glsl */`
+
+	// 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
+		);
+
+	}
+
+	// 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 );
+
+	}
+
+`;

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

@@ -1,116 +1,116 @@
-export const utilsGLSL = /* glsl */`
-
-	// TODO: possibly this should be renamed something related to material or path tracing logic
-
-	#ifndef RAY_OFFSET
-	#define RAY_OFFSET 1e-4
-	#endif
-
-	// 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 stepRayOrigin( vec3 rayOrigin, vec3 rayDirection, vec3 offset, float dist ) {
-
-		vec3 point = rayOrigin + rayDirection * dist;
-		vec3 absPoint = abs( point );
-		float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-		return point + offset * ( maxPoint + 1.0 ) * RAY_OFFSET;
-
-	}
-
-	// 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 );
-
-	}
-
-	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;
-
-	}
-
-	// 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 ) );
-
-	}
-
-	// 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 utilsGLSL = /* glsl */`
+
+	// TODO: possibly this should be renamed something related to material or path tracing logic
+
+	#ifndef RAY_OFFSET
+	#define RAY_OFFSET 1e-4
+	#endif
+
+	// 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 stepRayOrigin( vec3 rayOrigin, vec3 rayDirection, vec3 offset, float dist ) {
+
+		vec3 point = rayOrigin + rayDirection * dist;
+		vec3 absPoint = abs( point );
+		float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+		return point + offset * ( maxPoint + 1.0 ) * RAY_OFFSET;
+
+	}
+
+	// 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 );
+
+	}
+
+	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;
+
+	}
+
+	// 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 ) );
+
+	}
+
+	// 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 ) );
+
+	}
+`;

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

@@ -1,57 +1,57 @@
-export const pcgGLSL = /* glsl */`
-
-	// https://www.shadertoy.com/view/wltcRS
-	uvec4 WHITE_NOISE_SEED;
-
-	void rng_initialize( vec2 p, int frame ) {
-
-		// white noise seed
-		WHITE_NOISE_SEED = 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;
-
-	}
-
-	// returns [ 0, 1 ]
-	float rand() {
-
-		pcg4d( WHITE_NOISE_SEED );
-		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
-
-	}
-
-	vec2 rand2() {
-
-		pcg4d( WHITE_NOISE_SEED );
-		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
-
-	}
-
-	vec3 rand3() {
-
-		pcg4d( WHITE_NOISE_SEED );
-		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
-
-	}
-
-	vec4 rand4() {
-
-		pcg4d( WHITE_NOISE_SEED );
-		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
-
-	}
-`;
+export const pcgGLSL = /* glsl */`
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 WHITE_NOISE_SEED;
+
+	void rng_initialize( vec2 p, int frame ) {
+
+		// white noise seed
+		WHITE_NOISE_SEED = 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;
+
+	}
+
+	// returns [ 0, 1 ]
+	float rand() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
+
+	}
+`;