three-gpu-pathtracer 0.0.3 → 0.0.6

package/src/shader/shaderMaterialSampling.js

@@ -1,4 +1,6 @@
 import { shaderGGXFunctions } from './shaderGGXFunctions.js';
+import { shaderSheenFunctions } from './shaderSheenFunctions.js';
+import { shaderIridescenceFunctions } from './shaderIridescenceFunctions.js';
 
 export const shaderMaterialSampling = /* glsl */`
 
@@ -13,15 +15,29 @@ struct SurfaceRec {
 	vec3 emission;
 	float transmission;
 	float ior;
+	float clearcoat;
+	float clearcoatRoughness;
+	float filteredClearcoatRoughness;
+	vec3 sheenColor;
+	float sheenRoughness;
+	float iridescence;
+	float iridescenceIor;
+	float iridescenceThickness;
+	vec3 specularColor;
+	float specularIntensity;
 };
 
 struct SampleRec {
+	float specularPdf;
 	float pdf;
 	vec3 direction;
+	vec3 clearcoatDirection;
 	vec3 color;
 };
 
 ${ shaderGGXFunctions }
+${ shaderSheenFunctions }
+${ shaderIridescenceFunctions }
 
 // diffuse
 float diffusePDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
@@ -56,10 +72,15 @@ vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 // specular
 float specularPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
-	// See equation (17) in http://jcgt.org/published/0003/02/03/
+	// See 14.1.1 Microfacet BxDFs in https://www.pbr-book.org/
 	float filteredRoughness = surf.filteredRoughness;
 	vec3 halfVector = getHalfVector( wi, wo );
-	return ggxPDF( wi, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+	float incidentTheta = acos( wo.z );
+	float D = ggxDistribution( halfVector, filteredRoughness );
+	float G1 = ggxShadowMaskG1( incidentTheta, filteredRoughness );
+	float ggxPdf = D * G1 * max( 0.0, abs( dot( wo, halfVector ) ) ) / abs ( wo.z );
+	return ggxPdf / ( 4.0 * dot( wo, halfVector ) );
 
 }
 
@@ -92,21 +113,25 @@ vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 	float iorRatio = frontFace ? 1.0 / ior : ior;
 	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
 	float D = ggxDistribution( halfVector, filteredRoughness );
+	vec3 F = vec3( schlickFresnelFromIor( dot( wi, halfVector ), iorRatio ) ) * surf.specularColor * surf.specularIntensity;
 
-	float F = schlickFresnelFromIor( dot( wi, halfVector ), iorRatio );
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
 	bool cannotRefract = iorRatio * sinTheta > 1.0;
 	if ( cannotRefract ) {
 
-		F = 1.0;
+		F = vec3( 1.0 );
 
 	}
 
+	float f0 = pow( ( iorRatio - 1.0 ) / ( iorRatio + 1.0 ), 2.0 );
+	vec3 iridescenceFresnel = evalIridescence( 1.0, surf.iridescenceIor, dot( wi, halfVector ), surf.iridescenceThickness, vec3( f0 ) );
+	F = mix( F, iridescenceFresnel, surf.iridescence );
+
 	vec3 color = mix( vec3( 1.0 ), surf.color, metalness );
 	color = mix( color, vec3( 1.0 ), F );
 	color *= G * D / ( 4.0 * abs( wi.z * wo.z ) );
-	color *= mix( F, 1.0, metalness );
+	color *= mix( F, vec3( 1.0 ), metalness );
 	color *= wi.z; // scale the light by the direction the light is coming in from
 
 	return color;
@@ -213,7 +238,119 @@ vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 }
 
-float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf ) {
+// clearcoat
+float clearcoatPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// See equation (27) in http://jcgt.org/published/0003/02/03/
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = getHalfVector( wi, wo );
+	return ggxPDF( wo, halfVector, filteredClearcoatRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+}
+
+vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
+
+	// sample ggx vndf distribution which gives a new normal
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = ggxDirection(
+		wo,
+		filteredClearcoatRoughness,
+		filteredClearcoatRoughness,
+		rand(),
+		rand()
+	);
+
+	// apply to new ray by reflecting off the new normal
+	return - reflect( wo, halfVector );
+
+}
+
+void clearcoatColor( inout vec3 color, vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = 1.5;
+	bool frontFace = surf.frontFace;
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+
+	vec3 halfVector = getHalfVector( wo, wi );
+	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float G = ggxShadowMaskG2( wi, wo, filteredClearcoatRoughness );
+	float D = ggxDistribution( halfVector, filteredClearcoatRoughness );
+
+	float F = schlickFresnelFromIor( dot( wi, halfVector ), ior );
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		F = 1.0;
+
+	}
+
+	float fClearcoat = F * D * G / ( 4.0 * abs( wi.z * wo.z ) );
+
+	color = color * ( 1.0 - surf.clearcoat * F ) + fClearcoat * surf.clearcoat * wi.z;
+
+}
+
+// sheen
+vec3 sheenColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	vec3 halfVector = getHalfVector( wo, wi );
+
+	float cosThetaO = saturateCos( wo.z );
+	float cosThetaI = saturateCos( wi.z );
+	float cosThetaH = halfVector.z;
+
+	float D = velvetD( cosThetaH, surf.sheenRoughness );
+	float G = velvetG( cosThetaO, cosThetaI, surf.sheenRoughness );
+
+	// See equation (1) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+	vec3 color = surf.sheenColor;
+	color *= D * G / ( 4.0 * abs( cosThetaO * cosThetaI ) );
+	color *= wi.z;
+
+	return color;
+
+}
+
+// bsdf
+void getLobeWeights( vec3 wo, vec3 clearcoatWo, SurfaceRec surf, out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	float transSpecularProb = mix( reflectance, 1.0, metalness );
+	float diffSpecularProb = 0.5 + 0.5 * metalness;
+
+	clearcoatWeight = surf.clearcoat * schlickFresnel( clearcoatWo.z, 0.04 );
+	diffuseWeight = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb ) * ( 1.0 - clearcoatWeight );
+	specularWeight = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb * ( 1.0 - clearcoatWeight );
+	transmissionWeight = transmission * ( 1.0 - transSpecularProb ) * ( 1.0 - clearcoatWeight );
+
+	float totalWeight = diffuseWeight + specularWeight + transmissionWeight + clearcoatWeight;
+	float invTotalWeight = 1.0 / totalWeight;
+
+	diffuseWeight *= invTotalWeight;
+	specularWeight *= invTotalWeight;
+	transmissionWeight *= invTotalWeight;
+	clearcoatWeight *= invTotalWeight;
+
+}
+
+float bsdfPdf( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out float specularPdf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
 
 	float ior = surf.ior;
 	float metalness = surf.metalness;
@@ -234,43 +371,85 @@ float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf ) {
 	float spdf = 0.0;
 	float dpdf = 0.0;
 	float tpdf = 0.0;
+	float cpdf = 0.0;
 
 	if ( wi.z < 0.0 ) {
 
-		tpdf = transmissionPDF( wo, wi, surf );
+		if( transmissionWeight > 0.0 ) {
+
+			tpdf = transmissionPDF( wo, wi, surf );
+
+		}
 
 	} else {
 
-		spdf = specularPDF( wo, wi, surf );
-		dpdf = diffusePDF( wo, wi, surf );
+		if( diffuseWeight > 0.0 ) {
+
+			dpdf = diffusePDF( wo, wi, surf );
+
+		}
+
+		if( specularWeight > 0.0 ) {
+
+			spdf = specularPDF( wo, wi, surf );
+
+		}
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		cpdf = clearcoatPDF( clearcoatWo, clearcoatWi, surf );
 
 	}
 
-	float transSpecularProb = mix( reflectance, 1.0, metalness );
-	float diffSpecularProb = 0.5 + 0.5 * metalness;
 	float pdf =
-		spdf * transmission * transSpecularProb
-		+ tpdf * transmission * ( 1.0 - transSpecularProb )
-		+ spdf * ( 1.0 - transmission ) * diffSpecularProb
-		+ dpdf * ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
+		  dpdf * diffuseWeight
+		+ spdf * specularWeight
+		+ tpdf * transmissionWeight
+		+ cpdf * clearcoatWeight;
+
+	// retrieve specular rays for the shadows flag
+	specularPdf = spdf * specularWeight + cpdf * clearcoatWeight;
 
 	return pdf;
 
 }
 
-vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+vec3 bsdfColor( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
 
 	vec3 color = vec3( 0.0 );
 	if ( wi.z < 0.0 ) {
 
-		color = transmissionColor( wo, wi, surf );
+		if( transmissionWeight > 0.0 ) {
+
+			color = transmissionColor( wo, wi, surf );
+
+		}
 
 	} else {
 
-		color = diffuseColor( wo, wi, surf );
-		color *= 1.0 - surf.transmission;
+		if( diffuseWeight > 0.0 ) {
+
+			color = diffuseColor( wo, wi, surf );
+			color *= 1.0 - surf.transmission;
 
-		color += specularColor( wo, wi, surf );
+		}
+
+		if( specularWeight > 0.0 ) {
+
+			color += specularColor( wo, wi, surf );
+
+		}
+
+		color *= sheenAlbedoScaling( wo, wi, surf );
+		color += sheenColor( wo, wi, surf );
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		clearcoatColor( color, clearcoatWo, clearcoatWi, surf );
 
 	}
 
@@ -278,62 +457,89 @@ vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 }
 
-float bsdfResult( vec3 wo, vec3 wi, SurfaceRec surf, out vec3 color ) {
+float bsdfResult( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out vec3 color ) {
 
-	color = bsdfColor( wo, wi, surf );
-	return bsdfPdf( wo, wi, surf );
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+
+	float specularPdf;
+	color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	return bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
 }
 
-SampleRec bsdfSample( vec3 wo, SurfaceRec surf ) {
+SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis, mat3 clearcoatNormalBasis, mat3 clearcoatInvBasis, SurfaceRec surf ) {
 
-	float ior = surf.ior;
-	float metalness = surf.metalness;
-	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
-	float ratio = frontFace ? 1.0 / ior : ior;
-	float cosTheta = min( wo.z, 1.0 );
-	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
-	if ( cannotRefract ) {
+	float pdf[4];
+	pdf[0] = diffuseWeight;
+	pdf[1] = specularWeight;
+	pdf[2] = transmissionWeight;
+	pdf[3] = clearcoatWeight;
 
-		reflectance = 1.0;
+	float cdf[4];
+	cdf[0] = pdf[0];
+	cdf[1] = pdf[1] + cdf[0];
+	cdf[2] = pdf[2] + cdf[1];
+	cdf[3] = pdf[3] + cdf[2];
 
-	}
+	if( cdf[3] != 0.0 ) {
 
-	SampleRec result;
-	if ( rand() < transmission ) {
+		float invMaxCdf = 1.0 / cdf[3];
+		cdf[0] *= invMaxCdf;
+		cdf[1] *= invMaxCdf;
+		cdf[2] *= invMaxCdf;
+		cdf[3] *= invMaxCdf;
 
-		float specularProb = mix( reflectance, 1.0, metalness );
-		if ( rand() < specularProb ) {
+	} else {
 
-			result.direction = specularDirection( wo, surf );
+		cdf[0] = 1.0;
+		cdf[1] = 0.0;
+		cdf[2] = 0.0;
+		cdf[3] = 0.0;
 
-		} else {
+	}
 
-			result.direction = transmissionDirection( wo, surf );
+	vec3 wi;
+	vec3 clearcoatWi;
 
-		}
+	float r = rand();
+	if ( r <= cdf[0] ) {
 
-	} else {
+		wi = diffuseDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-		float specularProb = 0.5 + 0.5 * metalness;
-		if ( rand() < specularProb ) {
+	} else if ( r <= cdf[1] ) {
 
-			result.direction = specularDirection( wo, surf );
+		wi = specularDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-		} else {
+	} else if ( r <= cdf[2] ) {
 
-			result.direction = diffuseDirection( wo, surf );
+		wi = transmissionDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-		}
+	} else if ( r <= cdf[3] ) {
+
+		clearcoatWi = clearcoatDirection( clearcoatWo, surf );
+		wi = normalize( invBasis * normalize( clearcoatNormalBasis * clearcoatWi ) );
 
 	}
 
-	result.pdf = bsdfPdf( wo, result.direction, surf );
-	result.color = bsdfColor( wo, result.direction, surf );
+	SampleRec result;
+	result.pdf = bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, result.specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.direction = wi;
+	result.clearcoatDirection = clearcoatWi;
+
 	return result;
 
 }

package/src/shader/shaderSheenFunctions.js

@@ -0,0 +1,98 @@
+export const shaderSheenFunctions = /* 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, SurfaceRec 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, SurfaceRec 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;
+
+}
+
+`;