three-gpu-pathtracer 0.0.14 → 0.0.16

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

@@ -1,223 +1,223 @@
-export const lightSamplingGLSL = /* glsl */`
-
-	float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
-
-		return smoothstep( coneCosine, penumbraCosine, angleCosine );
-
-	}
-
-	float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
-
-		// based upon Frostbite 3 Moving to Physically-based Rendering
-		// page 32, equation 26: E[window1]
-		// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
-		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), EPSILON );
-
-		if ( cutoffDistance > 0.0 ) {
-
-			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
-
-		}
-
-		return distanceFalloff;
-
-	}
-
-	float getPhotometricAttenuation( sampler2DArray iesProfiles, int iesProfile, vec3 posToLight, vec3 lightDir, vec3 u, vec3 v ) {
-
-		float cosTheta = dot( posToLight, lightDir );
-		float angle = acos( cosTheta ) * ( 1.0 / PI );
-
-		return texture2D( iesProfiles, vec3( 0.0, angle, iesProfile ) ).r;
-
-	}
-
-	struct LightSampleRecord {
-
-		float dist;
-		vec3 direction;
-		float pdf;
-		vec3 emission;
-		int type;
-
-	};
-
-	bool lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection, out LightSampleRecord lightSampleRec ) {
-
-		bool didHit = false;
-		uint l;
-		for ( l = 0u; l < lightCount; l ++ ) {
-
-			Light light = readLightInfo( lights, l );
-
-			vec3 u = light.u;
-			vec3 v = light.v;
-
-			// check for backface
-			vec3 normal = normalize( cross( u, v ) );
-			if ( dot( normal, rayDirection ) < 0.0 ) {
-
-				continue;
-
-			}
-
-			u *= 1.0 / dot( u, u );
-			v *= 1.0 / dot( v, v );
-
-			float dist;
-
-			// MIS / light intersection is not supported for punctual lights.
-			if(
-				( light.type == RECT_AREA_LIGHT_TYPE && intersectsRectangle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) ) ||
-				( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
-			) {
-
-				if ( ! didHit || dist < lightSampleRec.dist ) {
-
-					float cosTheta = dot( rayDirection, normal );
-					didHit = true;
-					lightSampleRec.dist = dist;
-					lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-					lightSampleRec.emission = light.color * light.intensity;
-					lightSampleRec.direction = rayDirection;
-					lightSampleRec.type = light.type;
-
-				}
-
-			}
-
-		}
-
-		return didHit;
-
-	}
-
-	LightSampleRecord randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
-
-		LightSampleRecord lightSampleRec;
-		lightSampleRec.type = light.type;
-
-		lightSampleRec.emission = light.color * light.intensity;
-
-		vec3 randomPos;
-		if( light.type == RECT_AREA_LIGHT_TYPE ) {
-
-			// rectangular area light
-			randomPos = light.position + light.u * ( ruv.x - 0.5 ) + light.v * ( ruv.y - 0.5 );
-
-		} else if( light.type == CIRC_AREA_LIGHT_TYPE ) {
-
-			// circular area light
-			float r = 0.5 * sqrt( ruv.x );
-			float theta = ruv.y * 2.0 * PI;
-			float x = r * cos( theta );
-			float y = r * sin( theta );
-
-			randomPos = light.position + light.u * x + light.v * y;
-
-		}
-
-		vec3 toLight = randomPos - rayOrigin;
-		float lightDistSq = dot( toLight, toLight );
-		lightSampleRec.dist = sqrt( lightDistSq );
-
-		vec3 direction = toLight / lightSampleRec.dist;
-		lightSampleRec.direction = direction;
-
-		vec3 lightNormal = normalize( cross( light.u, light.v ) );
-		lightSampleRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
-
-		return lightSampleRec;
-
-	}
-
-	LightSampleRecord randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin, vec2 ruv ) {
-
-		float radius = light.radius * sqrt( ruv.x );
-		float theta = ruv.y * 2.0 * PI;
-		float x = radius * cos( theta );
-		float y = radius * sin( theta );
-
-		vec3 u = light.u;
-		vec3 v = light.v;
-		vec3 normal = normalize( cross( u, v ) );
-
-		float angle = acos( light.coneCos );
-		float angleTan = tan( angle );
-		float startDistance = light.radius / max( angleTan, EPSILON );
-
-		vec3 randomPos = light.position - normal * startDistance + u * x + v * y;
-		vec3 toLight = randomPos - rayOrigin;
-		float lightDistSq = dot( toLight, toLight );
-		float dist = sqrt( lightDistSq );
-
-		vec3 direction = toLight / max( dist, EPSILON );
-		float cosTheta = dot( direction, normal );
-
-		float spotAttenuation = light.iesProfile != - 1 ?
-			getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v ) :
-			getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
-
-		float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
-		LightSampleRecord lightSampleRec;
-		lightSampleRec.type = light.type;
-		lightSampleRec.dist = dist;
-		lightSampleRec.direction = direction;
-		lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
-		lightSampleRec.pdf = 1.0;
-
-		return lightSampleRec;
-
-	}
-
-	LightSampleRecord randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
-
-		// pick a random light
-		uint l = uint( ruv.x * float( lightCount ) );
-		Light light = readLightInfo( lights, l );
-
-		if ( light.type == SPOT_LIGHT_TYPE ) {
-
-			return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
-
-		} else if ( light.type == POINT_LIGHT_TYPE ) {
-
-			vec3 lightRay = light.u - rayOrigin;
-			float lightDist = length( lightRay );
-			float cutoffDistance = light.distance;
-			float distanceFalloff = 1.0 / max( pow( lightDist, light.decay ), 0.01 );
-			if ( cutoffDistance > 0.0 ) {
-
-				distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDist / cutoffDistance ) ) );
-
-			}
-
-			LightSampleRecord rec;
-			rec.direction = normalize( lightRay );
-			rec.dist = length( lightRay );
-			rec.pdf = 1.0;
-			rec.emission = light.color * light.intensity * distanceFalloff;
-			rec.type = light.type;
-			return rec;
-
-		} else if ( light.type == DIR_LIGHT_TYPE ) {
-
-			LightSampleRecord rec;
-			rec.dist = 1e10;
-			rec.direction = light.u;
-			rec.pdf = 1.0;
-			rec.emission = light.color * light.intensity;
-			rec.type = light.type;
-
-			return rec;
-
-		} else {
-
-			// sample the light
-			return randomAreaLightSample( light, rayOrigin, ruv.yz );
-
-		}
-
-	}
-
-`;
+export const lightSamplingGLSL = /* glsl */`
+
+	float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
+
+		return smoothstep( coneCosine, penumbraCosine, angleCosine );
+
+	}
+
+	float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
+
+		// based upon Frostbite 3 Moving to Physically-based Rendering
+		// page 32, equation 26: E[window1]
+		// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), EPSILON );
+
+		if ( cutoffDistance > 0.0 ) {
+
+			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
+
+		}
+
+		return distanceFalloff;
+
+	}
+
+	float getPhotometricAttenuation( sampler2DArray iesProfiles, int iesProfile, vec3 posToLight, vec3 lightDir, vec3 u, vec3 v ) {
+
+		float cosTheta = dot( posToLight, lightDir );
+		float angle = acos( cosTheta ) * ( 1.0 / PI );
+
+		return texture2D( iesProfiles, vec3( 0.0, angle, iesProfile ) ).r;
+
+	}
+
+	struct LightRecord {
+
+		float dist;
+		vec3 direction;
+		float pdf;
+		vec3 emission;
+		int type;
+
+	};
+
+	bool lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection, out LightRecord lightRec ) {
+
+		bool didHit = false;
+		uint l;
+		for ( l = 0u; l < lightCount; l ++ ) {
+
+			Light light = readLightInfo( lights, l );
+
+			vec3 u = light.u;
+			vec3 v = light.v;
+
+			// check for backface
+			vec3 normal = normalize( cross( u, v ) );
+			if ( dot( normal, rayDirection ) < 0.0 ) {
+
+				continue;
+
+			}
+
+			u *= 1.0 / dot( u, u );
+			v *= 1.0 / dot( v, v );
+
+			float dist;
+
+			// MIS / light intersection is not supported for punctual lights.
+			if(
+				( light.type == RECT_AREA_LIGHT_TYPE && intersectsRectangle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) ) ||
+				( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
+			) {
+
+				if ( ! didHit || dist < lightRec.dist ) {
+
+					float cosTheta = dot( rayDirection, normal );
+					didHit = true;
+					lightRec.dist = dist;
+					lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+					lightRec.emission = light.color * light.intensity;
+					lightRec.direction = rayDirection;
+					lightRec.type = light.type;
+
+				}
+
+			}
+
+		}
+
+		return didHit;
+
+	}
+
+	LightRecord randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
+
+		LightRecord lightRec;
+		lightRec.type = light.type;
+
+		lightRec.emission = light.color * light.intensity;
+
+		vec3 randomPos;
+		if( light.type == RECT_AREA_LIGHT_TYPE ) {
+
+			// rectangular area light
+			randomPos = light.position + light.u * ( ruv.x - 0.5 ) + light.v * ( ruv.y - 0.5 );
+
+		} else if( light.type == CIRC_AREA_LIGHT_TYPE ) {
+
+			// circular area light
+			float r = 0.5 * sqrt( ruv.x );
+			float theta = ruv.y * 2.0 * PI;
+			float x = r * cos( theta );
+			float y = r * sin( theta );
+
+			randomPos = light.position + light.u * x + light.v * y;
+
+		}
+
+		vec3 toLight = randomPos - rayOrigin;
+		float lightDistSq = dot( toLight, toLight );
+		lightRec.dist = sqrt( lightDistSq );
+
+		vec3 direction = toLight / lightRec.dist;
+		lightRec.direction = direction;
+
+		vec3 lightNormal = normalize( cross( light.u, light.v ) );
+		lightRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
+
+		return lightRec;
+
+	}
+
+	LightRecord randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin, vec2 ruv ) {
+
+		float radius = light.radius * sqrt( ruv.x );
+		float theta = ruv.y * 2.0 * PI;
+		float x = radius * cos( theta );
+		float y = radius * sin( theta );
+
+		vec3 u = light.u;
+		vec3 v = light.v;
+		vec3 normal = normalize( cross( u, v ) );
+
+		float angle = acos( light.coneCos );
+		float angleTan = tan( angle );
+		float startDistance = light.radius / max( angleTan, EPSILON );
+
+		vec3 randomPos = light.position - normal * startDistance + u * x + v * y;
+		vec3 toLight = randomPos - rayOrigin;
+		float lightDistSq = dot( toLight, toLight );
+		float dist = sqrt( lightDistSq );
+
+		vec3 direction = toLight / max( dist, EPSILON );
+		float cosTheta = dot( direction, normal );
+
+		float spotAttenuation = light.iesProfile != - 1 ?
+			getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v ) :
+			getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
+
+		float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
+		LightRecord lightRec;
+		lightRec.type = light.type;
+		lightRec.dist = dist;
+		lightRec.direction = direction;
+		lightRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
+		lightRec.pdf = 1.0;
+
+		return lightRec;
+
+	}
+
+	LightRecord randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
+
+		// pick a random light
+		uint l = uint( ruv.x * float( lightCount ) );
+		Light light = readLightInfo( lights, l );
+
+		if ( light.type == SPOT_LIGHT_TYPE ) {
+
+			return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+
+		} else if ( light.type == POINT_LIGHT_TYPE ) {
+
+			vec3 lightRay = light.u - rayOrigin;
+			float lightDist = length( lightRay );
+			float cutoffDistance = light.distance;
+			float distanceFalloff = 1.0 / max( pow( lightDist, light.decay ), 0.01 );
+			if ( cutoffDistance > 0.0 ) {
+
+				distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDist / cutoffDistance ) ) );
+
+			}
+
+			LightRecord rec;
+			rec.direction = normalize( lightRay );
+			rec.dist = length( lightRay );
+			rec.pdf = 1.0;
+			rec.emission = light.color * light.intensity * distanceFalloff;
+			rec.type = light.type;
+			return rec;
+
+		} else if ( light.type == DIR_LIGHT_TYPE ) {
+
+			LightRecord rec;
+			rec.dist = 1e10;
+			rec.direction = light.u;
+			rec.pdf = 1.0;
+			rec.emission = light.color * light.intensity;
+			rec.type = light.type;
+
+			return rec;
+
+		} else {
+
+			// sample the light
+			return randomAreaLightSample( light, rayOrigin, ruv.yz );
+
+		}
+
+	}
+
+`;

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

@@ -1,86 +1,86 @@
-export const shapeSamplingGLSL = /* glsl */`
-
-	vec3 sampleHemisphere( 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 sampleRegularPolygon( 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 ) :
-			sampleRegularPolygon( blades, uvw );
-
-	}
-
-
-`;
+export const shapeSamplingGLSL = /* glsl */`
+
+	vec3 sampleHemisphere( 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 sampleRegularPolygon( 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 ) :
+			sampleRegularPolygon( blades, uvw );
+
+	}
+
+
+`;

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

@@ -1,13 +1,13 @@
-export const cameraStructGLSL = /* glsl */`
-
-	struct PhysicalCamera {
-
-		float focusDistance;
-		float anamorphicRatio;
-		float bokehSize;
-		int apertureBlades;
-		float apertureRotation;
-
-	};
-
-`;
+export const cameraStructGLSL = /* glsl */`
+
+	struct PhysicalCamera {
+
+		float focusDistance;
+		float anamorphicRatio;
+		float bokehSize;
+		int apertureBlades;
+		float apertureRotation;
+
+	};
+
+`;

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

@@ -1,14 +1,13 @@
-export const equirectStructGLSL = /* glsl */`
-
-	struct EquirectHdrInfo {
-
-		sampler2D marginalWeights;
-		sampler2D conditionalWeights;
-		sampler2D map;
-
-		float totalSumWhole;
-		float totalSumDecimal;
-
-	};
-
-`;
+export const equirectStructGLSL = /* glsl */`
+
+	struct EquirectHdrInfo {
+
+		sampler2D marginalWeights;
+		sampler2D conditionalWeights;
+		sampler2D map;
+
+		float totalSum;
+
+	};
+
+`;