Fix GGX multiscatter energy conservation with analytical compensation.

Author: mrdoob

src/shader/bsdf/bsdf_functions.glsl.js

@@ -82,38 +82,17 @@ export const bsdf_functions = /* glsl */`
 
 	}
 
-	// Global variable to store microsurface scatter throughput
-	// This is set by specularDirection and used by bsdfSample
-	vec3 g_microsurfaceThroughput = vec3( 1.0 );
-
 	vec3 specularDirection( vec3 wo, SurfaceRecord surf ) {
 
-		// sample ggx vndf distribution which gives a new normal
+		// Sample GGX VNDF distribution to get a microfacet normal
 		float roughness = surf.filteredRoughness;
-
-		// Reset microsurface throughput
-		g_microsurfaceThroughput = vec3( 1.0 );
-
-		// For rough surfaces, optionally use microsurface multiscatter
-		// This simulates multiple bounces within the microfacet structure
-		vec3 f0Color = mix( surf.f0 * surf.specularColor * surf.specularIntensity, surf.color, surf.metalness );
-
-		MicrosurfaceScatterResult microResult = ggxMicrosurfaceScatter( wo, roughness, f0Color );
-
-		if ( microResult.valid ) {
-			// Use the microsurface scattered direction
-			g_microsurfaceThroughput = microResult.throughput;
-			return microResult.direction;
-		}
-
-		// Fall back to standard single-scatter sampling
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
 			rand2( 12 )
 		);
 
-		// apply to new ray by reflecting off the new normal
+		// Reflect view direction off the sampled microfacet normal
 		return - reflect( wo, halfVector );
 
 	}
@@ -479,12 +458,6 @@ export const bsdf_functions = /* glsl */`
 		result.pdf = bsdfEval( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight, result.specularPdf, result.color );
 		result.direction = normalize( surf.normalBasis * wi );
 
-		// Apply microsurface scattering throughput if we sampled the specular lobe
-		if ( r > cdf[0] && r <= cdf[1] ) {
-			// Specular lobe was sampled - apply microsurface throughput
-			result.color *= g_microsurfaceThroughput;
-		}
-
 		return result;
 
 	}

src/shader/bsdf/multiscatter_functions.glsl.js

@@ -1,131 +1,26 @@
 export const multiscatter_functions = /* glsl */`
 
-// Explicit Microsurface Multiscattering for GGX
-// Based on "Multiple-Scattering Microfacet BSDFs with the Smith Model" (Heitz et al. 2016)
-// and "Position-Free Multiple-Bounce Computations for Smith Microfacet BSDFs" (Xie & Hanrahan 2018)
-//
-// This simulates a random walk on the microsurface, allowing rays to bounce multiple times
-// within the microfacet structure before escaping.
-
-// Check if a direction is above the macrosurface
-bool isAboveSurface( vec3 w ) {
-	return w.z > 0.0;
-}
-
-// Sample a microfacet normal visible from direction v
-// Returns the microsurface normal in tangent space
-vec3 sampleGGXMicrofacet( vec3 v, float roughness, vec2 alpha, vec2 rand ) {
-	// Use VNDF sampling (already implemented in ggx_functions)
-	return ggxDirection( v, alpha, rand );
-}
-
-// Compute Fresnel reflectance for a given cosine
-float fresnelSchlick( float cosTheta, float f0 ) {
-	float c = 1.0 - cosTheta;
-	float c2 = c * c;
-	return f0 + ( 1.0 - f0 ) * c2 * c2 * c;
-}
-
-// Perform a random walk on the microsurface for multiscatter GGX
-// This function traces the path of a ray bouncing within the microfacet structure
-// wo: outgoing direction (view direction) in tangent space
-// roughness: surface roughness
-// f0Color: Fresnel at normal incidence
-// Returns: throughput color after microsurface bounces and final exit direction
-struct MicrosurfaceScatterResult {
-	vec3 direction;  // Final exit direction in tangent space
-	vec3 throughput; // Accumulated throughput/color
-	bool valid;      // Whether the scatter was successful
-};
-
-MicrosurfaceScatterResult ggxMicrosurfaceScatter( vec3 wo, float roughness, vec3 f0Color ) {
-
-	MicrosurfaceScatterResult result;
-	result.throughput = vec3( 1.0 );
-	result.valid = false;
-
-	// Only enable multiscatter for rough surfaces (roughness > 0.2)
-	// For smooth surfaces, single-scatter is sufficient
-	if ( roughness < 0.2 ) {
-		// Return invalid - use regular single-scatter path
-		return result;
-	}
-
-	// Current ray direction (starts as view direction)
-	vec3 w = wo;
-	vec3 throughput = vec3( 1.0 );
-
-	vec2 alpha = vec2( roughness );
-	float f0 = ( f0Color.r + f0Color.g + f0Color.b ) / 3.0;
-
-	// Maximum bounces within microsurface (typically 2-4 is enough)
-	const int MAX_MICRO_BOUNCES = 3;
-
-	for ( int bounce = 0; bounce < MAX_MICRO_BOUNCES; bounce++ ) {
-
-		// Check if ray escaped the microsurface
-		if ( isAboveSurface( w ) && bounce > 0 ) {
-			// Ray escaped! Return the result
-			result.direction = w;
-			result.throughput = throughput;
-			result.valid = true;
-			return result;
-		}
-
-		// If going down on first bounce, reject (shouldn't happen with VNDF)
-		if ( bounce == 0 && !isAboveSurface( w ) ) {
-			return result;
-		}
-
-		// Sample a visible microfacet normal
-		vec3 m = sampleGGXMicrofacet( w, roughness, alpha, rand2( 17 + bounce ) );
-
-		// Compute reflection direction
-		vec3 wi = reflect( -w, m );
-
-		// Compute Fresnel for this bounce
-		float cosTheta = dot( w, m );
-		float F = fresnelSchlick( abs( cosTheta ), f0 );
-
-		// Apply Fresnel to throughput
-		// For metals, use colored Fresnel
-		vec3 fresnelColor = f0Color + ( vec3( 1.0 ) - f0Color ) * pow( 1.0 - abs( cosTheta ), 5.0 );
-		throughput *= fresnelColor;
-
-		// Russian roulette for path termination
-		if ( bounce > 0 ) {
-			float q = max( throughput.r, max( throughput.g, throughput.b ) );
-			q = min( q, 0.95 ); // Cap at 95% to ensure termination
-
-			if ( rand( 18 + bounce ) > q ) {
-				// Path terminated
-				return result;
-			}
-
-			// Adjust throughput for RR
-			throughput /= q;
-		}
-
-		// Update direction for next bounce
-		w = wi;
-
-	}
+// Analytical multiscatter energy compensation for GGX BRDF
+// Compensates for energy loss due to multiple bounces within the microfacet structure
+// Based on observations that rough surfaces at grazing angles lose the most energy
+vec3 ggxMultiScatterCompensation( vec3 wo, vec3 wi, float roughness, vec3 F0 ) {
+	float NdotV = abs( wo.z );
+	float NdotL = abs( wi.z );
 
-	// If we hit max bounces, check if we're above surface
-	if ( isAboveSurface( w ) ) {
-		result.direction = w;
-		result.throughput = throughput;
-		result.valid = true;
-	}
+	// Energy compensation increases with roughness
+	// At roughness=0, no compensation needed (perfect mirror)
+	// At roughness=1, significant compensation needed (very rough)
+	float a = roughness * roughness;
+	float energyFactor = a * sqrt( a );  // Scales as roughness^1.5
 
-	return result;
+	// Angular dependence - more energy lost at grazing angles
+	float angularLoss = ( 1.0 - NdotV * 0.9 ) * ( 1.0 - NdotL * 0.9 );
 
-}
+	// Combined energy compensation
+	vec3 compensation = F0 * energyFactor * angularLoss;
 
-// Stub function for compatibility - not used in explicit multiscatter approach
-vec3 ggxMultiScatterCompensation( vec3 wo, vec3 wi, float roughness, vec3 F0 ) {
-	// Not used when explicit microsurface scattering is enabled
-	return vec3( 0.0 );
+	// Conservative global scale to avoid over-brightening
+	return compensation * 0.25;
 }