three-gpu-pathtracer 0.0.10 → 0.0.12

package/src/objects/EquirectCamera.js

@@ -1,13 +1,13 @@
-import { Camera } from 'three';
-
-export class EquirectCamera extends Camera {
-
-	constructor() {
-
-		super();
-
-		this.isEquirectCamera = true;
-
-	}
-
-}
+import { Camera } from 'three';
+
+export class EquirectCamera extends Camera {
+
+	constructor() {
+
+		super();
+
+		this.isEquirectCamera = true;
+
+	}
+
+}

package/src/objects/PhysicalCamera.js

@@ -1,28 +1,28 @@
-import { PerspectiveCamera } from 'three';
-
-export class PhysicalCamera extends PerspectiveCamera {
-
-	set bokehSize( size ) {
-
-		this.fStop = this.getFocalLength() / size;
-
-	}
-
-	get bokehSize() {
-
-		return this.getFocalLength() / this.fStop;
-
-	}
-
-	constructor( ...args ) {
-
-		super( ...args );
-		this.fStop = 1.4;
-		this.apertureBlades = 0;
-		this.apertureRotation = 0;
-		this.focusDistance = 25;
-		this.anamorphicRatio = 1;
-
-	}
-
-}
+import { PerspectiveCamera } from 'three';
+
+export class PhysicalCamera extends PerspectiveCamera {
+
+	set bokehSize( size ) {
+
+		this.fStop = this.getFocalLength() / size;
+
+	}
+
+	get bokehSize() {
+
+		return this.getFocalLength() / this.fStop;
+
+	}
+
+	constructor( ...args ) {
+
+		super( ...args );
+		this.fStop = 1.4;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 25;
+		this.anamorphicRatio = 1;
+
+	}
+
+}

package/src/objects/PhysicalSpotLight.js

@@ -1,14 +1,14 @@
-import { SpotLight } from 'three';
-
-export class PhysicalSpotLight extends SpotLight {
-
-	constructor( ...args ) {
-
-		super( ...args );
-
-		this.iesTexture = null;
-		this.radius = 0;
-
-	}
-
-}
+import { SpotLight } from 'three';
+
+export class PhysicalSpotLight extends SpotLight {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		this.iesTexture = null;
+		this.radius = 0;
+
+	}
+
+}

package/src/objects/ShapedAreaLight.js

@@ -1,12 +1,12 @@
-import { RectAreaLight } from 'three';
-
-export class ShapedAreaLight extends RectAreaLight {
-
-	constructor( ...args ) {
-
-		super( ...args );
-		this.isCircular = false;
-
-	}
-
-}
+import { RectAreaLight } from 'three';
+
+export class ShapedAreaLight extends RectAreaLight {
+
+	constructor( ...args ) {
+
+		super( ...args );
+		this.isCircular = false;
+
+	}
+
+}

package/src/shader/shaderBvhAnyHit.js

@@ -0,0 +1,76 @@
+export const shaderBvhAnyHit = /* glsl */`
+
+bool bvhIntersectAnyHit(
+	BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+
+	// output variables
+	out float side, out float dist
+) {
+
+	uvec4 faceIndices;
+	vec3 faceNormal;
+	vec3 barycoord;
+
+	// stack needs to be twice as long as the deepest tree we expect because
+	// we push both the left and right child onto the stack every traversal
+	int ptr = 0;
+	uint stack[ 60 ];
+	stack[ 0 ] = 0u;
+
+	float triangleDistance = 1e20;
+	while ( ptr > - 1 && ptr < 60 ) {
+
+		uint currNodeIndex = stack[ ptr ];
+		ptr --;
+
+		// check if we intersect the current bounds
+		float boundsHitDistance = intersectsBVHNodeBounds( rayOrigin, rayDirection, bvh, currNodeIndex );
+		if ( boundsHitDistance == INFINITY ) {
+
+			continue;
+
+		}
+
+		uvec2 boundsInfo = uTexelFetch1D( bvh.bvhContents, currNodeIndex ).xy;
+		bool isLeaf = bool( boundsInfo.x & 0xffff0000u );
+
+		if ( isLeaf ) {
+
+			uint count = boundsInfo.x & 0x0000ffffu;
+			uint offset = boundsInfo.y;
+
+			bool found = intersectTriangles(
+				bvh, rayOrigin, rayDirection, offset, count, triangleDistance,
+				faceIndices, faceNormal, barycoord, side, dist
+			);
+
+			if ( found ) {
+
+				return true;
+
+			}
+
+		} else {
+
+			uint leftIndex = currNodeIndex + 1u;
+			uint splitAxis = boundsInfo.x & 0x0000ffffu;
+			uint rightIndex = boundsInfo.y;
+
+			// set c2 in the stack so we traverse it later. We need to keep track of a pointer in
+			// the stack while we traverse. The second pointer added is the one that will be
+			// traversed first
+			ptr ++;
+			stack[ ptr ] = leftIndex;
+
+			ptr ++;
+			stack[ ptr ] = rightIndex;
+
+		}
+
+	}
+
+	return false;
+
+}
+
+`;

package/src/shader/shaderEnvMapSampling.js

@@ -1,58 +1,58 @@
-export const shaderEnvMapSampling = /* glsl */`
-
-vec3 sampleEquirectEnvMapColor( vec3 direction, sampler2D map ) {
-
-	return texture2D( map, equirectDirectionToUv( direction ) ).rgb;
-
-}
-
-float envMapDirectionPdf( vec3 direction ) {
-
-	vec2 uv = equirectDirectionToUv( direction );
-	float theta = uv.y * PI;
-	float sinTheta = sin( theta );
-	if ( sinTheta == 0.0 ) {
-
-		return 0.0;
-
-	}
-
-	return 1.0 / ( 2.0 * PI * PI * sinTheta );
-
-}
-
-float sampleEnvMap( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
-
-	vec2 uv = equirectDirectionToUv( direction );
-	color = texture2D( info.map, uv ).rgb;
-
-	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = luminance( color );
-	ivec2 resolution = textureSize( info.map, 0 );
-	float pdf = lum / totalSum;
-
-	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
-
-}
-
-float sampleEnvMapProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
-
-	// sample env map cdf
-	float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
-	float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
-	vec2 uv = vec2( u, v );
-
-	vec3 derivedDirection = equirectUvToDirection( uv );
-	direction = derivedDirection;
-	color = texture2D( info.map, uv ).rgb;
-
-	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = luminance( color );
-	ivec2 resolution = textureSize( info.map, 0 );
-	float pdf = lum / totalSum;
-
-	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
-
-}
-
-`;
+export const shaderEnvMapSampling = /* glsl */`
+
+vec3 sampleEquirectEnvMapColor( vec3 direction, sampler2D map ) {
+
+	return texture2D( map, equirectDirectionToUv( direction ) ).rgb;
+
+}
+
+float envMapDirectionPdf( vec3 direction ) {
+
+	vec2 uv = equirectDirectionToUv( direction );
+	float theta = uv.y * PI;
+	float sinTheta = sin( theta );
+	if ( sinTheta == 0.0 ) {
+
+		return 0.0;
+
+	}
+
+	return 1.0 / ( 2.0 * PI * PI * sinTheta );
+
+}
+
+float sampleEnvMap( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
+
+	vec2 uv = equirectDirectionToUv( direction );
+	color = texture2D( info.map, uv ).rgb;
+
+	float totalSum = info.totalSumWhole + info.totalSumDecimal;
+	float lum = luminance( color );
+	ivec2 resolution = textureSize( info.map, 0 );
+	float pdf = lum / totalSum;
+
+	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
+
+}
+
+float sampleEnvMapProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
+
+	// sample env map cdf
+	float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
+	float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
+	vec2 uv = vec2( u, v );
+
+	vec3 derivedDirection = equirectUvToDirection( uv );
+	direction = derivedDirection;
+	color = texture2D( info.map, uv ).rgb;
+
+	float totalSum = info.totalSumWhole + info.totalSumDecimal;
+	float lum = luminance( color );
+	ivec2 resolution = textureSize( info.map, 0 );
+	float pdf = lum / totalSum;
+
+	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
+
+}
+
+`;

package/src/shader/shaderGGXFunctions.js

@@ -1,100 +1,100 @@
-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, vec2 roughness, vec2 uv ) {
-
-	// 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( roughness * incidentDir.xy, 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( uv.x );
-	float phi = ( uv.y < a ) ? uv.y / a * PI : PI + ( uv.y - a ) / ( 1.0 - a ) * PI;
-	float P1 = r * cos( phi );
-	float P2 = r * sin( phi ) * ( ( uv.y < 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( roughness * N.xy, 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 (34) from reference [0]
-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 (34) from reference [0]
-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 ) );
-
-}
-
-// See equation (33) from reference [0]
-float ggxDistribution( vec3 halfVector, float roughness ) {
-
-	float a2 = roughness * roughness;
-	a2 = max( EPSILON, a2 );
-	float cosTheta = halfVector.z;
-	float cosTheta4 = pow( cosTheta, 4.0 );
-
-	if ( cosTheta == 0.0 ) return 0.0;
-
-	float theta = acosSafe( 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 (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;
-
-}
-`;
+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, vec2 roughness, vec2 uv ) {
+
+	// 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( roughness * incidentDir.xy, 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( uv.x );
+	float phi = ( uv.y < a ) ? uv.y / a * PI : PI + ( uv.y - a ) / ( 1.0 - a ) * PI;
+	float P1 = r * cos( phi );
+	float P2 = r * sin( phi ) * ( ( uv.y < 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( roughness * N.xy, 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 (34) from reference [0]
+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 (34) from reference [0]
+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 ) );
+
+}
+
+// See equation (33) from reference [0]
+float ggxDistribution( vec3 halfVector, float roughness ) {
+
+	float a2 = roughness * roughness;
+	a2 = max( EPSILON, a2 );
+	float cosTheta = halfVector.z;
+	float cosTheta4 = pow( cosTheta, 4.0 );
+
+	if ( cosTheta == 0.0 ) return 0.0;
+
+	float theta = acosSafe( 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 (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;
+
+}
+`;