three-gpu-pathtracer 0.0.14 → 0.0.16

package/src/shader/bsdf/sheen.glsl.js

@@ -1,98 +1,98 @@
-export const sheenGLSL = /* glsl */`
-
-	// See equation (2) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
-	float velvetD( float cosThetaH, float roughness ) {
-
-		float alpha = max( roughness, 0.07 );
-		alpha = alpha * alpha;
-
-		float invAlpha = 1.0 / alpha;
-
-		float sqrCosThetaH = cosThetaH * cosThetaH;
-		float sinThetaH = max( 1.0 - sqrCosThetaH, 0.001 );
-
-		return ( 2.0 + invAlpha ) * pow( sinThetaH, 0.5 * invAlpha ) / ( 2.0 * PI );
-
-	}
-
-	float velvetParamsInterpolate( int i, float oneMinusAlphaSquared ) {
-
-		const float p0[5] = float[5]( 25.3245, 3.32435, 0.16801, -1.27393, -4.85967 );
-		const float p1[5] = float[5]( 21.5473, 3.82987, 0.19823, -1.97760, -4.32054 );
-
-		return mix( p1[i], p0[i], oneMinusAlphaSquared );
-
-	}
-
-	float velvetL( float x, float alpha ) {
-
-		float oneMinusAlpha = 1.0 - alpha;
-		float oneMinusAlphaSquared = oneMinusAlpha * oneMinusAlpha;
-
-		float a = velvetParamsInterpolate( 0, oneMinusAlphaSquared );
-		float b = velvetParamsInterpolate( 1, oneMinusAlphaSquared );
-		float c = velvetParamsInterpolate( 2, oneMinusAlphaSquared );
-		float d = velvetParamsInterpolate( 3, oneMinusAlphaSquared );
-		float e = velvetParamsInterpolate( 4, oneMinusAlphaSquared );
-
-		return a / ( 1.0 + b * pow( abs( x ), c ) ) + d * x + e;
-
-	}
-
-	// See equation (3) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
-	float velvetLambda( float cosTheta, float alpha ) {
-
-		return abs( cosTheta ) < 0.5 ? exp( velvetL( cosTheta, alpha ) ) : exp( 2.0 * velvetL( 0.5, alpha ) - velvetL( 1.0 - cosTheta, alpha ) );
-
-	}
-
-	// See Section 3, Shadowing Term, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
-	float velvetG( float cosThetaO, float cosThetaI, float roughness ) {
-
-		float alpha = max( roughness, 0.07 );
-		alpha = alpha * alpha;
-
-		return 1.0 / ( 1.0 + velvetLambda( cosThetaO, alpha ) + velvetLambda( cosThetaI, alpha ) );
-
-	}
-
-	float directionalAlbedoSheen( float cosTheta, float alpha ) {
-
-		cosTheta = saturate( cosTheta );
-
-		float c = 1.0 - cosTheta;
-		float c3 = c * c * c;
-
-		return 0.65584461 * c3 + 1.0 / ( 4.16526551 + exp( -7.97291361 * sqrt( alpha ) + 6.33516894 ) );
-
-	}
-
-	float sheenAlbedoScaling( vec3 wo, vec3 wi, SurfaceRecord surf ) {
-
-		float alpha = max( surf.sheenRoughness, 0.07 );
-		alpha = alpha * alpha;
-
-		float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
-
-		float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
-		float eWi = directionalAlbedoSheen( saturateCos( wi.z ), alpha );
-
-		return min( 1.0 - maxSheenColor * eWo, 1.0 - maxSheenColor * eWi );
-
-	}
-
-	// See Section 5, Layering, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
-	float sheenAlbedoScaling( vec3 wo, SurfaceRecord surf ) {
-
-		float alpha = max( surf.sheenRoughness, 0.07 );
-		alpha = alpha * alpha;
-
-		float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
-
-		float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
-
-		return 1.0 - maxSheenColor * eWo;
-
-	}
-
-`;
+export const sheenGLSL = /* glsl */`
+
+	// See equation (2) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	float velvetD( float cosThetaH, float roughness ) {
+
+		float alpha = max( roughness, 0.07 );
+		alpha = alpha * alpha;
+
+		float invAlpha = 1.0 / alpha;
+
+		float sqrCosThetaH = cosThetaH * cosThetaH;
+		float sinThetaH = max( 1.0 - sqrCosThetaH, 0.001 );
+
+		return ( 2.0 + invAlpha ) * pow( sinThetaH, 0.5 * invAlpha ) / ( 2.0 * PI );
+
+	}
+
+	float velvetParamsInterpolate( int i, float oneMinusAlphaSquared ) {
+
+		const float p0[5] = float[5]( 25.3245, 3.32435, 0.16801, -1.27393, -4.85967 );
+		const float p1[5] = float[5]( 21.5473, 3.82987, 0.19823, -1.97760, -4.32054 );
+
+		return mix( p1[i], p0[i], oneMinusAlphaSquared );
+
+	}
+
+	float velvetL( float x, float alpha ) {
+
+		float oneMinusAlpha = 1.0 - alpha;
+		float oneMinusAlphaSquared = oneMinusAlpha * oneMinusAlpha;
+
+		float a = velvetParamsInterpolate( 0, oneMinusAlphaSquared );
+		float b = velvetParamsInterpolate( 1, oneMinusAlphaSquared );
+		float c = velvetParamsInterpolate( 2, oneMinusAlphaSquared );
+		float d = velvetParamsInterpolate( 3, oneMinusAlphaSquared );
+		float e = velvetParamsInterpolate( 4, oneMinusAlphaSquared );
+
+		return a / ( 1.0 + b * pow( abs( x ), c ) ) + d * x + e;
+
+	}
+
+	// See equation (3) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	float velvetLambda( float cosTheta, float alpha ) {
+
+		return abs( cosTheta ) < 0.5 ? exp( velvetL( cosTheta, alpha ) ) : exp( 2.0 * velvetL( 0.5, alpha ) - velvetL( 1.0 - cosTheta, alpha ) );
+
+	}
+
+	// See Section 3, Shadowing Term, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	float velvetG( float cosThetaO, float cosThetaI, float roughness ) {
+
+		float alpha = max( roughness, 0.07 );
+		alpha = alpha * alpha;
+
+		return 1.0 / ( 1.0 + velvetLambda( cosThetaO, alpha ) + velvetLambda( cosThetaI, alpha ) );
+
+	}
+
+	float directionalAlbedoSheen( float cosTheta, float alpha ) {
+
+		cosTheta = saturate( cosTheta );
+
+		float c = 1.0 - cosTheta;
+		float c3 = c * c * c;
+
+		return 0.65584461 * c3 + 1.0 / ( 4.16526551 + exp( -7.97291361 * sqrt( alpha ) + 6.33516894 ) );
+
+	}
+
+	float sheenAlbedoScaling( vec3 wo, vec3 wi, SurfaceRecord surf ) {
+
+		float alpha = max( surf.sheenRoughness, 0.07 );
+		alpha = alpha * alpha;
+
+		float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
+
+		float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
+		float eWi = directionalAlbedoSheen( saturateCos( wi.z ), alpha );
+
+		return min( 1.0 - maxSheenColor * eWo, 1.0 - maxSheenColor * eWi );
+
+	}
+
+	// See Section 5, Layering, in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	float sheenAlbedoScaling( vec3 wo, SurfaceRecord surf ) {
+
+		float alpha = max( surf.sheenRoughness, 0.07 );
+		alpha = alpha * alpha;
+
+		float maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
+
+		float eWo = directionalAlbedoSheen( saturateCos( wo.z ), alpha );
+
+		return 1.0 - maxSheenColor * eWo;
+
+	}
+
+`;

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

@@ -1,25 +1,25 @@
-
-export const arraySamplerTexelFetchGLSL = /*glsl */`
-
-	// add texel fetch functions for texture arrays
-	vec4 texelFetch1D( sampler2DArray tex, int layer, uint index ) {
-
-		uint width = uint( textureSize( tex, 0 ).x );
-		uvec2 uv;
-		uv.x = index % width;
-		uv.y = index / width;
-
-		return texelFetch( tex, ivec3( uv, layer ), 0 );
-
-	}
-
-	vec4 textureSampleBarycoord( sampler2DArray tex, int layer, vec3 barycoord, uvec3 faceIndices ) {
-
-		return
-			barycoord.x * texelFetch1D( tex, layer, faceIndices.x ) +
-			barycoord.y * texelFetch1D( tex, layer, faceIndices.y ) +
-			barycoord.z * texelFetch1D( tex, layer, faceIndices.z );
-
-	}
-
-`;
+
+export const arraySamplerTexelFetchGLSL = /*glsl */`
+
+	// add texel fetch functions for texture arrays
+	vec4 texelFetch1D( sampler2DArray tex, int layer, uint index ) {
+
+		uint width = uint( textureSize( tex, 0 ).x );
+		uvec2 uv;
+		uv.x = index % width;
+		uv.y = index / width;
+
+		return texelFetch( tex, ivec3( uv, layer ), 0 );
+
+	}
+
+	vec4 textureSampleBarycoord( sampler2DArray tex, int layer, vec3 barycoord, uvec3 faceIndices ) {
+
+		return
+			barycoord.x * texelFetch1D( tex, layer, faceIndices.x ) +
+			barycoord.y * texelFetch1D( tex, layer, faceIndices.y ) +
+			barycoord.z * texelFetch1D( tex, layer, faceIndices.z );
+
+	}
+
+`;

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

@@ -1,76 +1,76 @@
-export const bvhAnyHitGLSL = /* 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;
-
-	}
-
-`;
+export const bvhAnyHitGLSL = /* 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/common/fresnel.glsl.js

@@ -1,98 +1,98 @@
-export const fresnelGLSL = /* glsl */`
-
-	bool totalInternalReflection( float cosTheta, float eta ) {
-
-		float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-		return eta * sinTheta > 1.0;
-
-	}
-
-	// 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 );
-
-	}
-
-	vec3 schlickFresnel( float cosine, vec3 f0, vec3 f90 ) {
-
-		return f0 + ( f90 - 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 );
-
-	}
-
-	vec3 evaluateFresnel( float cosTheta, float eta, vec3 f0, vec3 f90 ) {
-
-		if ( totalInternalReflection( cosTheta, eta ) ) {
-
-			return f90;
-
-		}
-
-		return schlickFresnel( cosTheta, f0, f90 );
-
-	}
-
-	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
-
-		if ( totalInternalReflection( cosTheta, eta ) ) {
-
-			return 1.0;
-
-		}
-
-		return schlickFresnel( cosTheta, f0 );
-
-	}
-
-	/*
-	// https://schuttejoe.github.io/post/disneybsdf/
-	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
-
-		float dotHV = dot( wo, wh );
-		float dotHL = dot( wi, wh );
-
-		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
-		float metallicFresnel = schlickFresnel( dotHL, f0 );
-
-		return mix( dielectricFresnel, metallicFresnel, metalness );
-
-	}
-	*/
-`;
+export const fresnelGLSL = /* glsl */`
+
+	bool totalInternalReflection( float cosTheta, float eta ) {
+
+		float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+		return eta * sinTheta > 1.0;
+
+	}
+
+	// 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 );
+
+	}
+
+	vec3 schlickFresnel( float cosine, vec3 f0, vec3 f90 ) {
+
+		return f0 + ( f90 - 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 );
+
+	}
+
+	vec3 evaluateFresnel( float cosTheta, float eta, vec3 f0, vec3 f90 ) {
+
+		if ( totalInternalReflection( cosTheta, eta ) ) {
+
+			return f90;
+
+		}
+
+		return schlickFresnel( cosTheta, f0, f90 );
+
+	}
+
+	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
+
+		if ( totalInternalReflection( cosTheta, eta ) ) {
+
+			return 1.0;
+
+		}
+
+		return schlickFresnel( cosTheta, f0 );
+
+	}
+
+	/*
+	// https://schuttejoe.github.io/post/disneybsdf/
+	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
+
+		float dotHV = dot( wo, wh );
+		float dotHL = dot( wi, wh );
+
+		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
+		float metallicFresnel = schlickFresnel( dotHL, f0 );
+
+		return mix( dielectricFresnel, metallicFresnel, metalness );
+
+	}
+	*/
+`;