three-gpu-pathtracer 0.0.24 → 0.0.26

package/src/webgpu/nodes/debugBounds.wgsl.js

@@ -0,0 +1,228 @@
+import { Matrix4, StructTypeNode } from 'three/webgpu';
+import { uniform, uint, float } from 'three/tsl';
+import { wgslTagFn, ndcToCameraRay, rayStruct, bvhNodeBoundsStruct, bvhNodeStruct, intersectsTriangle } from 'three-mesh-bvh/webgpu';
+
+// blue -> cyan -> green -> yellow -> red heat ramp shared by the debug visualizations
+export const heatColorFn = wgslTagFn/* wgsl */`
+	fn debugHeatColor( t: f32 ) -> vec3f {
+
+		let r = clamp( 1.5 - abs( 4.0 * t - 3.0 ), 0.0, 1.0 );
+		let g = clamp( 1.5 - abs( 4.0 * t - 2.0 ), 0.0, 1.0 );
+		let b = clamp( 1.5 - abs( 4.0 * t - 1.0 ), 0.0, 1.0 );
+		return vec3f( r, g, b );
+
+	}
+`;
+
+// Result struct holding a running tally of the TLAS and BLAS bounding boxes the ray crosses
+const debugBoundsResultStruct = new StructTypeNode( {
+	tlasCount: 'uint',
+	blasCount: 'uint',
+	didHit: 'bool',
+	dist: 'float',
+}, 'DebugBoundsResult' );
+
+// Builds the full-screen "bvh bounds heatmap" fragment function for the given bvh data. The uniforms
+// driving it are attached as `.uniforms` so the caller can update them each frame.
+export function getDebugBoundsFunction( bvhData ) {
+
+	const { transforms, index, attributes, materials } = bvhData.storage;
+
+	// uniforms
+
+	// camera transforms used to build the ray
+	const cameraToModelMatrix = uniform( new Matrix4() );
+	const inverseProjectionMatrix = uniform( new Matrix4() );
+
+	// 1 / 0 flags toggling which bvh levels contribute to the count
+	const displayTLAS = uniform( 1 );
+	const displayBLAS = uniform( 1 );
+
+	// 1 / 0 flag, stop counting boxes past the nearest hit surface
+	const stopAtSurface = uniform( 0 );
+
+	// node count that saturates to full heat
+	const saturationCount = uniform( 64 );
+
+	// shared traversal state, mirroring the path tracer's raycast:
+	// - level: 0 while walking the TLAS, 1 while walking a BLAS ( picks which counter to bump )
+	// - rayScalar: factor converting a local-space hit distance back to world units
+	// - materialSide: side of the current object's material, for front / backface culling
+	const level = uint( 0 ).toVar( 'bvh_debugBoundsLevel' );
+	const rayScalar = float( 1.0 ).toVar( 'bvh_debugRayScalar' );
+	const materialSide = float( 0.0 ).toVar( 'bvh_debugMaterialSide' );
+
+	// front-to-back child ordering: descend the child the ray reaches first
+	const getBoundsOrder = wgslTagFn/* wgsl */`
+		fn debugGetBoundsOrder( ray: ${ rayStruct }, splitAxis: u32, node: ${ bvhNodeStruct } ) -> bool {
+
+			return ray.direction[ splitAxis ] >= 0.0;
+
+		}
+	`;
+
+	// bounds hook: tally the box (into the level's counter) and keep descending, unless it sits
+	// entirely behind the nearest hit surface found so far
+	const intersectsBounds = wgslTagFn/* wgsl */`
+		fn debugIntersectsBounds( ray: ${ rayStruct }, bounds: ${ bvhNodeBoundsStruct }, result: ptr<function, ${ debugBoundsResultStruct }> ) -> u32 {
+
+			let boundsMin = vec3( bounds.min[ 0 ], bounds.min[ 1 ], bounds.min[ 2 ] );
+			let boundsMax = vec3( bounds.max[ 0 ], bounds.max[ 1 ], bounds.max[ 2 ] );
+
+			let invDir = 1.0 / ray.direction;
+			let tMinPlane = ( boundsMin - ray.origin ) * invDir;
+			let tMaxPlane = ( boundsMax - ray.origin ) * invDir;
+
+			let tMinHit = min( tMinPlane, tMaxPlane );
+			let tMaxHit = max( tMinPlane, tMaxPlane );
+
+			let t0 = max( max( tMinHit.x, tMinHit.y ), tMinHit.z );
+			let t1 = min( min( tMaxHit.x, tMaxHit.y ), tMaxHit.z );
+
+			let dist = max( t0, 0.0 );
+			if ( t1 < dist ) {
+
+				return 0u;
+
+			} else if ( result.didHit && dist * ${ rayScalar } >= result.dist ) {
+
+				return 0u;
+
+			}
+
+			if ( ${ level } == 1u ) {
+
+				result.blasCount = result.blasCount + 1u;
+
+			} else {
+
+				result.tlasCount = result.tlasCount + 1u;
+
+			}
+
+			return 1u;
+
+		}
+	`;
+
+	// range hook: intersect the leaf triangles to track the nearest surface
+	const intersectRange = wgslTagFn/* wgsl */`
+		fn debugIntersectRange( ray: ${ rayStruct }, offset: u32, count: u32, result: ptr<function, ${ debugBoundsResultStruct }> ) -> bool {
+
+			var didHit = false;
+			if ( ${ stopAtSurface } > 0.5 ) {
+
+				for ( var ti = offset; ti < offset + count; ti = ti + 1u ) {
+
+					let i0 = ${ index }[ ti * 3u ];
+					let i1 = ${ index }[ ti * 3u + 1u ];
+					let i2 = ${ index }[ ti * 3u + 2u ];
+
+					let a = ${ attributes }[ i0 ].position.xyz;
+					let b = ${ attributes }[ i1 ].position.xyz;
+					let c = ${ attributes }[ i2 ].position.xyz;
+
+					var triResult = ${ intersectsTriangle }( ray, a, b, c );
+					triResult.dist *= ${ rayScalar };
+					if ( triResult.didHit && ( ! result.didHit || triResult.dist < result.dist ) ) {
+
+						// cull faces that don't match the material side
+						if ( ${ materialSide } != 0.0 && triResult.side != ${ materialSide } ) {
+
+							continue;
+
+						}
+
+						result.didHit = true;
+						result.dist = triResult.dist;
+						didHit = true;
+
+					}
+
+				}
+
+			}
+
+			return didHit;
+
+		}
+	`;
+
+	// transform hook: move the ray into object-local space ( normalizing the direction and storing
+	// the scale factor, exactly like the raycast ), record the material side, and mark that we are
+	// now descending a BLAS
+	const transformRay = wgslTagFn/* wgsl */`
+		fn debugTransformRay( ray: ptr<function, ${ rayStruct }>, objectIndex: u32 ) -> void {
+
+			let object = ${ transforms }[ objectIndex ];
+			let toLocal = object.inverseMatrixWorld;
+			ray.origin = ( toLocal * vec4f( ray.origin, 1.0 ) ).xyz;
+			ray.direction = ( toLocal * vec4f( ray.direction, 0.0 ) ).xyz;
+
+			let len = length( ray.direction );
+			ray.direction = ray.direction / len;
+			${ rayScalar } = 1.0 / len;
+
+			${ materialSide } = ${ materials }[ object.materialIndex ].side;
+			${ level } = 1u;
+
+		}
+	`;
+
+	// reset hook: back to the TLAS once a BLAS has been fully traversed
+	const resetLevel = wgslTagFn/* wgsl */`
+		fn debugResetLevel( objectIndex: u32 ) -> void {
+
+			${ rayScalar } = 1.0;
+			${ level } = 0u;
+
+		}
+	`;
+
+	// reuse the path tracer's traversal to count boxes across the TLAS and every BLAS it references
+	const countBounds = bvhData.getShapecastFn( {
+		name: 'debugBoundsCount',
+		shapeStruct: rayStruct,
+		resultStruct: debugBoundsResultStruct,
+
+		boundsOrderFn: getBoundsOrder,
+		intersectsBoundsFn: intersectsBounds,
+		intersectRangeFn: intersectRange,
+		transformShapeFn: transformRay,
+		resetShapeFn: resetLevel,
+	} );
+
+	const debugBounds = wgslTagFn/* wgsl */`
+		fn debugBounds( vUv: vec2f ) -> vec4f {
+
+			let ndc = vUv * 2.0 - vec2f( 1.0 );
+			var ray = ${ ndcToCameraRay }( ndc, ${ cameraToModelMatrix } * ${ inverseProjectionMatrix } );
+			ray.direction = normalize( ray.direction );
+
+			// count the boxes the ray crosses, pruning those behind the nearest hit surface
+			var result: ${ debugBoundsResultStruct };
+			${ countBounds }( ray, &result );
+
+			let tlas = select( 0u, result.tlasCount, ${ displayTLAS } > 0.5 );
+			let blas = select( 0u, result.blasCount, ${ displayBLAS } > 0.5 );
+			let count = tlas + blas;
+
+			let t = clamp( f32( count ) / max( ${ saturationCount }, 1.0 ), 0.0, 1.0 );
+
+			return vec4f( ${ heatColorFn }( t ), 1.0 );
+
+		}
+	`;
+
+	debugBounds.uniforms = {
+		cameraToModelMatrix,
+		inverseProjectionMatrix,
+		displayTLAS,
+		displayBLAS,
+		stopAtSurface,
+		saturationCount,
+	};
+
+	return debugBounds;
+
+}

package/src/webgpu/nodes/eon.wgsl.js

@@ -0,0 +1,262 @@
+import { wgslFn } from 'three/tsl';
+import { constants, surfaceRecordStruct } from './structs.wgsl.js';
+
+const eonDirectionalAlbedoFunc = wgslFn( /* wgsl */ `
+
+	fn eonDirectionalAlbedo( mu: f32, roughness: f32, A: f32 ) -> f32 {
+
+		let muComp = 1.0 - mu;
+		let gOverPi = muComp * (
+			0.0571085289 + muComp * (
+				0.491881867 + muComp * (
+					- 0.332181442 + muComp * 0.0714429953
+				)
+			)
+		);
+		return A * ( 1.0 + roughness * gOverPi );
+
+	}
+
+` );
+
+const fonSingleScatterFunc = wgslFn( /* wgsl */ `
+
+	fn fonSingleScatter( NdotV: f32, NdotL: f32, VdotH: f32, roughness: f32, A: f32, rho: vec3f ) -> vec3f {
+
+		let VdotL = 2.0 * VdotH * VdotH - 1.0;
+		let s = VdotL - NdotV * NdotL;
+		let sOverT = select( s, s / max( NdotV, NdotL ), s > 0.0 );
+
+		return ( rho / PI ) * A * ( 1.0 + roughness * sOverT );
+
+	}
+
+`, [ constants ] );
+
+// Fujii's improved Oren-Nayar single-scatter diffuse BRDF.
+// Based on: https://jcgt.org/published/0014/01/06/ (Section 2, Listing 1)
+export const fonBrdfFunc = wgslFn( /* wgsl */ `
+
+	fn fonBrdf( NdotV: f32, NdotL: f32, VdotH: f32, surf: SurfaceRecord ) -> vec3f {
+
+		let roughness = surf.diffuseRoughness;
+		if ( roughness < 1e-5 ) {
+
+			return surf.color / PI;
+
+		}
+
+		let rho = saturate( surf.color );
+		let A = 1.0 / ( 1.0 + ( 0.5 - 2.0 / ( 3.0 * PI ) ) * roughness );
+
+		return fonSingleScatter( NdotV, NdotL, VdotH, roughness, A, rho );
+
+	}
+
+`, [ constants, surfaceRecordStruct, fonSingleScatterFunc ] );
+
+// Energy-preserving Oren-Nayar diffuse BRDF (EON).
+// Based on: https://jcgt.org/published/0014/01/06/ (Section 3, Listing 2)
+export const eonBrdfFunc = wgslFn( /* wgsl */ `
+
+	fn eonBrdf( NdotV: f32, NdotL: f32, VdotH: f32, surf: SurfaceRecord ) -> vec3f {
+
+		let roughness = surf.diffuseRoughness;
+		if ( roughness < 1e-5 ) {
+
+			return surf.color / PI;
+
+		}
+
+		let rho = saturate( surf.color );
+		let A = 1.0 / ( 1.0 + ( 0.5 - 2.0 / ( 3.0 * PI ) ) * roughness );
+		let singleScatter = fonSingleScatter( NdotV, NdotL, VdotH, roughness, A, rho );
+
+		let averageDirectionalAlbedo = A * ( 1.0 + ( 2.0 / 3.0 - 28.0 / ( 15.0 * PI ) ) * roughness );
+		let directionalAlbedoV = eonDirectionalAlbedo( NdotV, roughness, A );
+		let directionalAlbedoL = eonDirectionalAlbedo( NdotL, roughness, A );
+
+		let rhoMultiScatter = rho * rho * averageDirectionalAlbedo /
+			max( vec3f( 1e-7 ), vec3f( 1.0 ) - rho * ( 1.0 - averageDirectionalAlbedo ) );
+		let multiScatter = ( rhoMultiScatter / PI ) *
+			max( 1e-7, 1.0 - directionalAlbedoV ) *
+			max( 1e-7, 1.0 - directionalAlbedoL ) /
+			max( 1e-7, 1.0 - averageDirectionalAlbedo );
+
+		return singleScatter + multiScatter;
+
+	}
+
+`, [ constants, surfaceRecordStruct, eonDirectionalAlbedoFunc, fonSingleScatterFunc ] );
+
+// EON importance sampling: a clipped linearly transformed cosine (CLTC) lobe
+// mixed with a uniform hemisphere lobe. Based on Listing 3 and Listing 4:
+// https://jcgt.org/published/0014/01/06/
+const eonLtcCoeffsFunc = wgslFn( /* wgsl */ `
+
+	fn eonLtcCoeffs( mu: f32, roughness: f32 ) -> vec4f {
+
+		let a = 1.0 + roughness * (
+			0.303392 + ( - 0.518982 + 0.111709 * mu ) * mu +
+			( - 0.276266 + 0.335918 * mu ) * roughness
+		);
+		let b = roughness * (
+			- 1.16407 + 1.15859 * mu + ( 0.150815 - 0.150105 * mu ) * roughness
+		) / ( mu * mu * mu - 1.43545 );
+		let c = 1.0 + roughness * ( 0.20013 + ( - 0.506373 + 0.261777 * mu ) * mu );
+		let d = roughness * (
+			0.540852 + ( - 1.01625 + 0.475392 * mu ) * mu
+		) / ( - 1.0743 + ( 0.0725628 + mu ) * mu );
+
+		return vec4f( a, b, c, d );
+
+	}
+
+` );
+
+const eonLtcBasisFunc = wgslFn( /* wgsl */ `
+
+	fn eonLtcBasis( wo: vec3f ) -> mat3x3f {
+
+		let lenSqr = dot( wo.xy, wo.xy );
+		let invLen = inverseSqrt( max( lenSqr, 1e-7 ) );
+		let x = select(
+			vec3f( 1.0, 0.0, 0.0 ),
+			vec3f( wo.x, wo.y, 0.0 ) * invLen,
+			lenSqr > 0.0,
+		);
+		let y = vec3f( - x.y, x.x, 0.0 );
+
+		return mat3x3f( x, y, vec3f( 0.0, 0.0, 1.0 ) );
+
+	}
+
+` );
+
+const eonCltcPdfFunc = wgslFn( /* wgsl */ `
+
+	fn eonCltcPdf( wo: vec3f, wi: vec3f, roughness: f32 ) -> f32 {
+
+		let toLtc = transpose( eonLtcBasis( wo ) );
+		let wiLtc = toLtc * wi;
+		let coeffs = eonLtcCoeffs( saturate( wo.z ), roughness );
+		let a = coeffs.x;
+		let b = coeffs.y;
+		let c = coeffs.z;
+		let d = coeffs.w;
+		let detM = c * ( a - b * d );
+		let wh = vec3f(
+			c * ( wiLtc.x - b * wiLtc.z ),
+			( a - b * d ) * wiLtc.y,
+			- c * ( d * wiLtc.x - a * wiLtc.z ),
+		);
+		let lenSqr = max( dot( wh, wh ), 1e-7 );
+		let vz = inverseSqrt( d * d + 1.0 );
+		let s = 0.5 * ( 1.0 + vz );
+		let jacobian = detM * detM / ( lenSqr * lenSqr );
+
+		return jacobian * max( wh.z, 0.0 ) / ( PI * s );
+
+	}
+
+`, [ constants, eonLtcCoeffsFunc, eonLtcBasisFunc ] );
+
+const eonCltcDirectionFunc = wgslFn( /* wgsl */ `
+
+	fn eonCltcDirection( wo: vec3f, roughness: f32, uv: vec2f ) -> vec3f {
+
+		let coeffs = eonLtcCoeffs( saturate( wo.z ), roughness );
+		let a = coeffs.x;
+		let b = coeffs.y;
+		let c = coeffs.z;
+		let d = coeffs.w;
+		let radius = sqrt( uv.x );
+		let phi = 2.0 * PI * uv.y;
+		let y = radius * sin( phi );
+		let vz = inverseSqrt( d * d + 1.0 );
+		let s = 0.5 * ( 1.0 + vz );
+		let x = - mix( sqrt( max( 1.0 - y * y, 0.0 ) ), radius * cos( phi ), s );
+		let wh = vec3f( x, y, sqrt( max( 1.0 - x * x - y * y, 0.0 ) ) );
+		let wiUnnormalized = vec3f(
+			a * wh.x + b * wh.z,
+			c * wh.y,
+			d * wh.x + wh.z,
+		);
+		let wi = normalize( eonLtcBasis( wo ) * wiUnnormalized );
+
+		return wi;
+
+	}
+
+`, [ constants, eonLtcCoeffsFunc, eonLtcBasisFunc ] );
+
+const eonUniformHemisphereSampleFunc = wgslFn( /* wgsl */ `
+
+	fn eonUniformHemisphereSample( uv: vec2f ) -> vec3f {
+
+		let sinTheta = sqrt( max( 1.0 - uv.x * uv.x, 0.0 ) );
+		let phi = 2.0 * PI * uv.y;
+		return vec3f( sinTheta * cos( phi ), sinTheta * sin( phi ), uv.x );
+
+	}
+
+`, [ constants ] );
+
+const eonUniformProbabilityFunc = wgslFn( /* wgsl */ `
+
+	fn eonUniformProbability( wo: vec3f, roughness: f32 ) -> f32 {
+
+		let mu = saturate( wo.z );
+		return clamp( pow( roughness, 0.1 ), 0.0, 1.0 ) * (
+			0.162925 + ( - 0.372058 + ( 0.538233 - 0.290822 * mu ) * mu ) * mu
+		);
+
+	}
+
+` );
+
+// EON's CLTC + uniform-hemisphere sampler. The PDF is evaluated separately by
+// eonPdf so direction sampling does not pay for a discarded Jacobian evaluation.
+export const eonDirectionFunc = wgslFn( /* wgsl */ `
+
+	fn eonDirection( wo: vec3f, roughness: f32, uv: vec2f ) -> vec3f {
+
+		let uniformProbability = eonUniformProbability( wo, roughness );
+		if ( uv.x <= uniformProbability && uniformProbability > 0.0 ) {
+
+			return eonUniformHemisphereSample( vec2f( uv.x / uniformProbability, uv.y ) );
+
+		}
+
+		let cltcProbability = 1.0 - uniformProbability;
+		let cltcUv = vec2f(
+			( uv.x - uniformProbability ) / max( cltcProbability, 1e-7 ),
+			uv.y,
+		);
+		return eonCltcDirection( wo, roughness, cltcUv );
+
+	}
+
+`, [ eonCltcDirectionFunc, eonUniformHemisphereSampleFunc, eonUniformProbabilityFunc ] );
+
+export const eonPDFFunc = wgslFn( /* wgsl */ `
+
+	fn eonPdf( wo: vec3f, wi: vec3f, roughness: f32 ) -> f32 {
+
+		// The EON proposal is defined over the positive hemisphere.
+		if ( wo.z <= 0.0 || wi.z <= 0.0 ) {
+
+			return 0.0;
+
+		}
+
+		let uniformProbability = eonUniformProbability( wo, roughness );
+		let cltcProbability = 1.0 - uniformProbability;
+		let uniformPdf = 1.0 / ( 2.0 * PI );
+
+		return uniformProbability * uniformPdf +
+			cltcProbability * eonCltcPdf( wo, wi, roughness );
+
+	}
+
+`, [ constants, eonCltcPdfFunc, eonUniformProbabilityFunc ] );

package/src/webgpu/nodes/ggx.wgsl.js

@@ -0,0 +1,190 @@
+import { wgslFn } from 'three/tsl';
+import { constants } from './structs.wgsl.js';
+
+// See sampling.wgsl for vector shorthand explanations
+// 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. Anisotropic surfaces are represented with a 2-dimensional alpha storing the
+// roughness along the tangent (x) and bitangent (y) in the TBN frame.
+
+// [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/
+// [5] https://seblagarde.wordpress.com/wp-content/uploads/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+// [6] https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_anisotropy/README.md
+// [7] https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
+
+// trowbridge-reitz === GGX === GTR
+export const ggxDirectionFunc = wgslFn( /* wgsl */ `
+
+	fn ggxDirection( incidentDir: vec3f, alpha: vec2f, uv: vec2f ) -> vec3f {
+
+		// Implementation from reference [1]
+		// stretch view
+		let V = normalize( vec3f( alpha * incidentDir.xy, incidentDir.z ) );
+
+		// orthonormal basis
+		var T1: vec3f;
+		if ( V.z < 0.9999 ) {
+
+			T1 = normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) );
+
+		} else {
+
+			T1 = vec3( 1.0, 0.0, 0.0 );
+
+		}
+
+		let T2 = cross( T1, V );
+
+		// sample point with polar coordinates (r, phi)
+		let a = 1.0 / ( 1.0 + V.z );
+		let r = sqrt( uv.x );
+		var phi: f32;
+		if ( uv.y < a ) {
+
+			phi = uv.y / a * PI;
+
+		} else {
+
+			phi = PI + ( uv.y - a ) / ( 1.0 - a ) * PI;
+
+		}
+
+		let P1 = r * cos( phi );
+		var P2 = r * sin( phi );
+		if ( uv.y >= a ) {
+
+			P2 *= V.z;
+
+		}
+
+		// compute normal
+		var N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );
+
+		// unstretch
+		N = normalize( vec3( alpha * N.xy, max( 0.0, N.z ) ) );
+
+		return N;
+
+	}
+
+`, [ constants ] );
+
+// Smith masking lambda for a single direction, used to build the G1 term for the pdf
+// See equation (34) from [0] and equation (43) from [7]
+export const ggxLambdaFunc = wgslFn( /* wgsl */ `
+
+	fn ggxLambda( V: vec3f, alpha: vec2f ) -> f32 {
+
+		let alphaT = alpha.x;
+		let alphaB = alpha.y;
+
+		// abs v.z to support transmitted rays
+		let NdotV = max( abs( V.z ), MIN_INCIDENT_COS );
+		let cos2 = NdotV * NdotV;
+		let t = ( alphaT * alphaT * V.x * V.x + alphaB * alphaB * V.y * V.y ) / cos2;
+		let numerator = - 1.0 + sqrt( 1.0 + t );
+		return numerator / 2.0;
+
+	}
+
+`, [ constants ] );
+
+// Based on equation (2) from reference [1]
+export const ggxShadowMaskG1Func = wgslFn( /* wgsl */ `
+
+	fn ggxShadowMaskG1( V: vec3f, alpha: vec2f ) -> f32 {
+
+		// TODO: this could be collapsed to a simpler form as an optimization
+		return 1.0 / ( 1.0 + ggxLambda( V, alpha ) );
+
+	}
+
+`, [ ggxLambdaFunc ] );
+
+// Smith height-correlated visibility term = G / ( 4 * NdotV * NdotL )
+// See (listing 16) in [7] and from [6]
+export const ggxSmithVisibilityFunc = wgslFn( /* wgsl */ `
+
+	fn ggxSmithVisibility( V: vec3f, L: vec3f, alpha: vec2f ) -> f32 {
+
+		let alphaT = alpha.x;
+		let alphaB = alpha.y;
+
+		let NdotV = max( V.z, MIN_INCIDENT_COS );
+		let NdotL = max( L.z, MIN_INCIDENT_COS );
+
+		let TdotV = V.x;
+		let TdotL = L.x;
+
+		let BdotV = V.y;
+		let BdotL = L.y;
+
+		let GGXV = NdotL * length( vec3f( alphaT * TdotV, alphaB * BdotV, NdotV ) );
+		let GGXL = NdotV * length( vec3f( alphaT * TdotL, alphaB * BdotL, NdotL ) );
+
+		return 0.5 / ( GGXV + GGXL );
+
+	}
+
+`, [ constants ] );
+
+// Trowbridge-Reitz ( GGX ) normal distribution
+// See (listing 15) in [7]
+export const ggxDistributionFunc = wgslFn( /* wgsl */ `
+
+	fn ggxDistribution( H: vec3f, alpha: vec2f ) -> f32 {
+
+		let alphaT = alpha.x;
+		let alphaB = alpha.y;
+
+		let NdotH = H.z;
+		let TdotH = H.x;
+		let BdotH = H.y;
+
+		let a2 = alphaT * alphaB;
+		let v = vec3f( alphaB * TdotH, alphaT * BdotH, a2 * NdotH );
+		let v2 = dot( v, v );
+		let w2 = a2 / v2;
+
+		return a2 * w2 * w2 / PI;
+
+	}
+
+`, [ constants ] );
+
+// ggxPDF, divided by the Jacobian of reflection operation
+// PDF: See equation (17) from reference [2]
+// Note: HdotV cancel out bc its guaranteed to be > 0
+export const ggxReflectionAdjustedPDFFunc = wgslFn( /* wgsl */ `
+
+	fn ggxReflectionAdjustedPDF( V: vec3f, H: vec3f, alpha: vec2f ) -> f32 {
+
+		let NdotV = max( V.z, MIN_INCIDENT_COS );
+		let D = ggxDistribution( H, alpha );
+		let G1 = ggxShadowMaskG1( V, alpha );
+
+		return D * G1 / ( 4 * NdotV );
+
+	}
+`, [ ggxDistributionFunc, ggxShadowMaskG1Func ] );
+
+// ggxPDF, divided by the Jacobian of refraction operation
+// See equation (3) from [2] for pdf and (17) from [0] for Jacobian
+export const ggxRefractionAdjustedPDFFunc = wgslFn( /* wgsl */ `
+
+	fn ggxRefractionAdjustedPDF( V: vec3f, L: vec3f, H: vec3f, alpha: vec2f, eta: f32 ) -> f32 {
+
+		let NdotV = max( V.z, MIN_INCIDENT_COS );
+		let HdotV = dot( V, H );
+		let HdotL = dot( L, H );
+		let D = ggxDistribution( H, alpha );
+		let G1 = ggxShadowMaskG1( V, alpha );
+
+		let denom = eta * HdotV + HdotL;
+		return D * G1 * abs( HdotV ) * abs( HdotL ) / ( NdotV * denom * denom );
+
+	}
+`, [ ggxDistributionFunc, ggxShadowMaskG1Func ] );