three-gpu-pathtracer 0.0.5 → 0.0.7

package/src/{core → 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/{core → 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

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

package/src/objects/ShapedAreaLight.js

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

package/src/shader/shaderEnvMapSampling.js

@@ -1,59 +1,59 @@
-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 envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
-
-	vec2 uv = equirectDirectionToUv( direction );
-	color = texture2D( info.map, uv ).rgb;
-
-	float totalSum = texture2D( info.totalSum, vec2( 0.0 ) ).r;
-	float lum = colorToLuminance( color );
-	ivec2 resolution = textureSize( info.map, 0 );
-	float pdf = lum / totalSum;
-
-	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
-
-}
-
-float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 direction ) {
-
-	// sample env map cdf
-	vec2 r = rand2();
-	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 = texture2D( info.totalSum, vec2( 0.0 ) ).r;
-	float lum = colorToLuminance( 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 envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
+
+	vec2 uv = equirectDirectionToUv( direction );
+	color = texture2D( info.map, uv ).rgb;
+
+	float totalSum = info.totalSumWhole + info.totalSumDecimal;
+	float lum = colorToLuminance( color );
+	ivec2 resolution = textureSize( info.map, 0 );
+	float pdf = lum / totalSum;
+
+	return float( resolution.x * resolution.y ) * pdf * envMapDirectionPdf( direction );
+
+}
+
+float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 direction ) {
+
+	// sample env map cdf
+	vec2 r = rand2();
+	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 = colorToLuminance( 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,108 +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, float roughnessX, float roughnessY, float random1, float random2 ) {
-
-	// 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( roughnessX * incidentDir.x, roughnessY * incidentDir.y, 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( random1 );
-	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
-	float P1 = r * cos( phi );
-	float P2 = r * sin( phi ) * ( ( random2 < 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( roughnessX * N.x, roughnessY * N.y, 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 (2) from reference [2]
-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 (2) from reference [2]
-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 ) );
-
-}
-
-float ggxDistribution( vec3 halfVector, float roughness ) {
-
-	// See equation (33) from reference [0]
-	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 (1) from reference [2]
-	// const { x, y, z } = halfVector;
-	// const a2 = roughness * roughness;
-	// const mult = x * x / a2 + y * y / a2 + z * z;
-	// const mult2 = mult * mult;
-
-	// return 1.0 / Math.PI * a2 * mult2;
-
-}
-
-// 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, float roughnessX, float roughnessY, float random1, float random2 ) {
+
+	// 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( roughnessX * incidentDir.x, roughnessY * incidentDir.y, 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( random1 );
+	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
+	float P1 = r * cos( phi );
+	float P2 = r * sin( phi ) * ( ( random2 < 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( roughnessX * N.x, roughnessY * N.y, 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;
+
+}
+`;

package/src/shader/shaderIridescenceFunctions.js

@@ -0,0 +1,130 @@
+export const shaderIridescenceFunctions = /* glsl */`
+
+// XYZ to sRGB color space
+const mat3 XYZ_TO_REC709 = mat3(
+	 3.2404542, -0.9692660,  0.0556434,
+	-1.5371385,  1.8760108, -0.2040259,
+	-0.4985314,  0.0415560,  1.0572252
+);
+
+vec3 fresnel0ToIor( vec3 fresnel0 ) {
+
+	vec3 sqrtF0 = sqrt( fresnel0 );
+	return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );
+
+}
+
+// Conversion FO/IOR
+vec3 iorToFresnel0( vec3 transmittedIor, float incidentIor ) {
+
+	return square( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );
+
+}
+
+// ior is a value between 1.0 and 3.0. 1.0 is air interface
+float iorToFresnel0( float transmittedIor, float incidentIor ) {
+
+	return square( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ) );
+
+}
+
+// Fresnel equations for dielectric/dielectric interfaces. See https://belcour.github.io/blog/research/2017/05/01/brdf-thin-film.html
+vec3 evalSensitivity( float OPD, vec3 shift ) {
+
+	float phase = 2.0 * PI * OPD * 1.0e-9;
+
+	vec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );
+	vec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );
+	vec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );
+
+	vec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - square( phase ) * var );
+	xyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * square( phase ) );
+	xyz /= 1.0685e-7;
+
+	vec3 srgb = XYZ_TO_REC709 * xyz;
+	return srgb;
+
+}
+
+// See Section 4. Analytic Spectral Integration, A Practical Extension to Microfacet Theory for the Modeling of Varying Iridescence, https://hal.archives-ouvertes.fr/hal-01518344/document
+vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {
+
+	vec3 I;
+
+	// Force iridescenceIor -> outsideIOR when thinFilmThickness -> 0.0
+	float iridescenceIor = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );
+
+	// Evaluate the cosTheta on the base layer (Snell law)
+	float sinTheta2Sq = square( outsideIOR / iridescenceIor ) * ( 1.0 - square( cosTheta1 ) );
+
+	// Handle TIR:
+	float cosTheta2Sq = 1.0 - sinTheta2Sq;
+	if ( cosTheta2Sq < 0.0 ) {
+
+		return vec3( 1.0 );
+
+	}
+
+	float cosTheta2 = sqrt( cosTheta2Sq );
+
+	// First interface
+	float R0 = iorToFresnel0( iridescenceIor, outsideIOR );
+	float R12 = schlickFresnel( cosTheta1, R0 );
+	float R21 = R12;
+	float T121 = 1.0 - R12;
+	float phi12 = 0.0;
+	if ( iridescenceIor < outsideIOR ) {
+
+		phi12 = PI;
+
+	}
+	float phi21 = PI - phi12;
+
+	// Second interface
+	vec3 baseIOR = fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) ); // guard against 1.0
+	vec3 R1 = iorToFresnel0( baseIOR, iridescenceIor );
+	vec3 R23 = schlickFresnel( cosTheta2, R1 );
+	vec3 phi23 = vec3( 0.0 );
+	if ( baseIOR[0] < iridescenceIor ) {
+
+		phi23[ 0 ] = PI;
+
+	}
+	if ( baseIOR[1] < iridescenceIor ) {
+
+		phi23[ 1 ] = PI;
+
+	}
+	if ( baseIOR[2] < iridescenceIor ) {
+
+		phi23[ 2 ] = PI;
+
+	}
+
+	// Phase shift
+	float OPD = 2.0 * iridescenceIor * thinFilmThickness * cosTheta2;
+	vec3 phi = vec3( phi21 ) + phi23;
+
+	// Compound terms
+	vec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );
+	vec3 r123 = sqrt( R123 );
+	vec3 Rs = square( T121 ) * R23 / ( vec3( 1.0 ) - R123 );
+
+	// Reflectance term for m = 0 (DC term amplitude)
+	vec3 C0 = R12 + Rs;
+	I = C0;
+
+	// Reflectance term for m > 0 (pairs of diracs)
+	vec3 Cm = Rs - T121;
+	for ( int m = 1; m <= 2; ++ m )
+	{
+		Cm *= r123;
+		vec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );
+		I += Cm * Sm;
+	}
+
+	// Since out of gamut colors might be produced, negative color values are clamped to 0.
+	return max( I, vec3( 0.0 ) );
+}
+
+`;