three-gpu-pathtracer 0.0.27 → 0.0.28

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

@@ -0,0 +1,61 @@
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { scatterRecordStruct, surfaceRecordStruct } from './structs.wgsl.js';
+
+// The denoiser's auxiliary images, the first hit albedo and normal, accumulate in an "r32uint" array
+// texture, the one kind of storage texture core WebGPU can both read and write. Each layer packs two
+// halves: albedo.rg, then albedo.b and normal.z, then normal.xy. Normals are mapped to [0,1].
+export const AUX_LAYERS = 3;
+
+// the smooth metals the auxiliary images look past to what they reflect, as in mutracer
+const AUX_MIRROR_MAX_ROUGHNESS = 0.02;
+const AUX_MIRROR_MIN_METALNESS = 0.98;
+
+// whether a scatter shows its surface in the auxiliary images, rather than looking past it through a
+// transmission or a mirror
+export const isAuxSurfaceFn = wgslTagFn/* wgsl */`
+
+	fn isAuxSurface( surface: ${ surfaceRecordStruct }, scatterRec: ${ scatterRecordStruct } ) -> bool {
+
+		let isMirror = surface.roughness <= ${ AUX_MIRROR_MAX_ROUGHNESS } && surface.metalness >= ${ AUX_MIRROR_MIN_METALNESS };
+		return ! scatterRec.isTransmissive && ! isMirror;
+
+	}
+
+`;
+
+export const unpackAuxAlbedoFn = wgslTagFn/* wgsl */`
+
+	fn unpackAuxAlbedo( packed: vec3u ) -> vec3f {
+
+		return vec3f( unpack2x16float( packed.x ), unpack2x16float( packed.y ).x );
+
+	}
+
+`;
+
+export const unpackAuxNormalFn = wgslTagFn/* wgsl */`
+
+	fn unpackAuxNormal( packed: vec3u ) -> vec3f {
+
+		return vec3f( unpack2x16float( packed.z ), unpack2x16float( packed.y ).y );
+
+	}
+
+`;
+
+// blends a sample's albedo and normal into the packed running means
+export const blendAuxFn = wgslTagFn/* wgsl */`
+
+	fn blendAux( packed: vec3u, albedo: vec3f, normal: vec3f, weight: f32 ) -> vec3u {
+
+		let meanAlbedo = mix( ${ unpackAuxAlbedoFn }( packed ), albedo, weight );
+		let meanNormal = mix( ${ unpackAuxNormalFn }( packed ), normal * 0.5 + 0.5, weight );
+		return vec3u(
+			pack2x16float( meanAlbedo.rg ),
+			pack2x16float( vec2f( meanAlbedo.b, meanNormal.z ) ),
+			pack2x16float( meanNormal.xy ),
+		);
+
+	}
+
+`;

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

@@ -119,7 +119,7 @@ const eonLtcBasisFunc = wgslFn( /* wgsl */ `
 	fn eonLtcBasis( wo: vec3f ) -> mat3x3f {
 
 		let lenSqr = dot( wo.xy, wo.xy );
-		let invLen = inverseSqrt( max( lenSqr, 1e-7 ) );
+		let invLen = inverseSqrt( lenSqr );
 		let x = select(
 			vec3f( 1.0, 0.0, 0.0 ),
 			vec3f( wo.x, wo.y, 0.0 ) * invLen,

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

@@ -848,7 +848,8 @@ export const transmissionFresnelFunc = ( iridescentFresnel = iridescentFresnelFu
 		// Include the base-color tint in the transmission energy, as Cycles does when it
 		// computes the glass reflection probability from its two tinted coefficients.
 		let reflectEnergy = dot( reflectance, vec3f( 1.0 / 3.0 ) );
-		let transmitEnergy = dot( transmittance * surf.color, vec3f( 1.0 / 3.0 ) );
+		let transmissionTint = select( sqrt( surf.color ), surf.color, surf.thinWall );
+		let transmitEnergy = dot( transmittance * transmissionTint, vec3f( 1.0 / 3.0 ) );
 		let totalEnergy = reflectEnergy + transmitEnergy;
 		result.reflectProbability = select( 0.0, reflectEnergy / max( totalEnergy, EPSILON ), totalEnergy > EPSILON );
 

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

@@ -0,0 +1,165 @@
+import { StructTypeNode } from 'three/webgpu';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { LIGHT_FAR_DISTANCE } from './lights.wgsl.js';
+import { materialStruct } from './structs.wgsl.js';
+
+// Random walk subsurface scattering, following Cycles' subsurface_random_walk.h
+// https://github.com/blender/cycles/blob/a456b761034dda42c32eef9f4aae0fa5a5c9f604/src/kernel/integrator/subsurface_random_walk.h
+
+// the smallest attenuation color used to derive a medium's extinction, keeping the log finite
+const MEDIUM_MIN_ATTENUATION = 1e-6;
+
+// the throughput below which a walk stops, matching Cycles' VOLUME_THROUGHPUT_EPSILON
+export const MEDIUM_THROUGHPUT_EPSILON = 1e-6;
+
+// the largest phase anisotropy used, short of the +/- 1 delta phase function the scatter albedo
+// inversion and the Henyey-Greenstein pdf divide by zero at
+const MEDIUM_MAX_ANISOTROPY = 0.999;
+
+export const mediumStruct = new StructTypeNode( {
+	inside: 'bool',
+	object: 'uint',
+	extinction: 'vec3f',
+	albedo: 'vec3f',
+	anisotropy: 'float',
+}, 'Medium' );
+
+// a medium in a storage buffer, which can't hold bools, for walks that span passes
+export const mediumStateStruct = new StructTypeNode( {
+	extinction: 'vec3f',
+	object: 'uint',
+
+	albedo: 'vec3f',
+	anisotropy: 'float',
+
+	inside: 'uint',
+}, 'MediumState' );
+
+export const storeMediumFn = wgslTagFn/* wgsl */`
+
+	fn storeMedium( medium: ${ mediumStruct } ) -> ${ mediumStateStruct } {
+
+		var state: ${ mediumStateStruct };
+		state.extinction = medium.extinction;
+		state.object = medium.object;
+		state.albedo = medium.albedo;
+		state.anisotropy = medium.anisotropy;
+		state.inside = select( 0u, 1u, medium.inside );
+		return state;
+
+	}
+
+`;
+
+export const loadMediumFn = wgslTagFn/* wgsl */`
+
+	fn loadMedium( state: ${ mediumStateStruct } ) -> ${ mediumStruct } {
+
+		var medium: ${ mediumStruct };
+		medium.inside = state.inside != 0u;
+		medium.object = state.object;
+		medium.extinction = state.extinction;
+		medium.albedo = state.albedo;
+		medium.anisotropy = state.anisotropy;
+		return medium;
+
+	}
+
+`;
+
+// The single scatter albedo of a volume from its perceived multi scatter albedo and phase anisotropy, using the
+// inversion from "KHR_materials_scatter" (after Kulla and Conty 2017). A zero multi scatter albedo maps to exactly zero
+// https://github.com/KhronosGroup/glTF/pull/2579
+const singleScatterAlbedoFn = wgslTagFn/* wgsl */`
+
+	fn singleScatterAlbedo( multiscatterAlbedo: vec3f, anisotropy: f32 ) -> vec3f {
+
+		let a = multiscatterAlbedo;
+		let s = clamp( 4.09712 + 4.20863 * a - sqrt( 9.59217 + 41.6808 * a + 17.7126 * a * a ), vec3f( 0.0 ), vec3f( 1.0 ) );
+		let s2 = select( s * s, vec3f( 1.0 ), a <= vec3f( 0.0 ) );
+		return ( 1.0 - s2 ) / ( 1.0 - anisotropy * s2 );
+
+	}
+
+`;
+
+// The medium entered by refracting into a material, not "inside" if the material doesn't scatter
+export const enterMediumFn = wgslTagFn/* wgsl */`
+
+	fn enterMedium( material: ${ materialStruct }, object: u32 ) -> ${ mediumStruct } {
+
+		let anisotropy = clamp( material.scatterAnisotropy, - ${ MEDIUM_MAX_ANISOTROPY }, ${ MEDIUM_MAX_ANISOTROPY } );
+
+		var medium: ${ mediumStruct };
+		medium.extinction = - log( max( material.attenuationColor, vec3f( ${ MEDIUM_MIN_ATTENUATION } ) ) ) / material.attenuationDistance;
+		medium.albedo = ${ singleScatterAlbedoFn }( material.multiscatterColor * material.scatterStrength, anisotropy );
+		medium.inside = any( medium.albedo > vec3f( 0.0 ) ) && any( medium.extinction > vec3f( 0.0 ) );
+		medium.object = object;
+		medium.anisotropy = anisotropy;
+		return medium;
+
+	}
+
+`;
+
+// The probability of sampling each color channel's distance, in proportion to throughput times albedo
+// https://github.com/blender/cycles/blob/a456b761034dda42c32eef9f4aae0fa5a5c9f604/src/kernel/closure/volume.h#L157
+export const mediumChannelPdfFn = wgslTagFn/* wgsl */`
+
+	fn mediumChannelPdf( throughput: vec3f, albedo: vec3f ) -> vec3f {
+
+		let weights = abs( throughput * albedo );
+		let weightSum = weights.r + weights.g + weights.b;
+		if ( weightSum > 0.0 ) {
+
+			return weights / weightSum;
+
+		}
+
+		return vec3f( 1.0 / 3.0 );
+
+	}
+
+`;
+
+// Samples the distance to the next scatter event using one color channel's extinction
+export const sampleMediumDistanceFn = wgslTagFn/* wgsl */`
+
+	fn sampleMediumDistance( medium: ${ mediumStruct }, channelPdf: vec3f, u: vec2f ) -> f32 {
+
+		var channel = 2u;
+		if ( u.x < channelPdf.r ) {
+
+			channel = 0u;
+
+		} else if ( u.x < channelPdf.r + channelPdf.g ) {
+
+			channel = 1u;
+
+		}
+
+		// a channel with no extinction never scatters, and WGSL doesn't guarantee an infinite quotient
+		let extinction = medium.extinction[ channel ];
+		if ( extinction <= 0.0 ) {
+
+			return ${ LIGHT_FAR_DISTANCE };
+
+		}
+
+		return - log( 1.0 - u.y ) / extinction;
+
+	}
+
+`;
+
+// Per channel pdf of a segment: of scattering at "dist", or of passing it when it didn't scatter
+export const mediumDistancePdfFn = wgslTagFn/* wgsl */`
+
+	fn mediumDistancePdf( medium: ${ mediumStruct }, dist: f32, scattered: bool ) -> vec3f {
+
+		let transmittance = exp( - medium.extinction * dist );
+		return select( transmittance, medium.extinction * transmittance, scattered );
+
+	}
+
+`;

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

@@ -6,6 +6,8 @@ export const RNG_INDEX_APERTURE_SAMPLE = 4;
 export const RNG_INDEX_DIRECT_LIGHT_SAMPLE = 5;
 export const RNG_INDEX_RUSSIAN_ROULETTE = 6;
 export const RNG_INDEX_DISPERSION_WAVELENGTH = 7;
+export const RNG_INDEX_MEDIUM_DISTANCE = 8;
+export const RNG_INDEX_MEDIUM_DIRECTION = 9;
 export const RNG_INDEX_ALPHA_TEST = 50;
 import { contextProxyFn } from 'three-mesh-bvh/webgpu';
 import * as sobol from './rand/sobol.wgsl.js';

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

@@ -108,14 +108,55 @@ export const sampleHemisphereFn = wgslFn( /* wgsl */ `
 
 `, [ constants ] );
 
+// below this anisotropy the Henyey-Greenstein phase function is sampled as isotropic, avoiding the
+// division by zero in its inverted CDF
+const HG_ISOTROPIC_EPSILON = 1e-3;
+
+// Samples a new direction from the Henyey-Greenstein phase function around the propagation direction
+// "d". Positive "g" scatters forward. The sample is exact, so the phase function over its pdf is one.
+// https://github.com/blender/cycles/blob/a456b761034dda42c32eef9f4aae0fa5a5c9f604/src/kernel/closure/volume_util.h#L36
+export const sampleHenyeyGreensteinFn = wgslFn( /* wgsl */ `
+
+	fn sampleHenyeyGreenstein( d: vec3f, g: f32, uv: vec2f ) -> vec3f {
+
+		var cosTheta = 1.0 - 2.0 * uv.x;
+		if ( abs( g ) > ${ HG_ISOTROPIC_EPSILON } ) {
+
+			let sqrTerm = ( 1.0 - g * g ) / ( 1.0 - g + 2.0 * g * uv.x );
+			cosTheta = clamp( ( 1.0 + g * g - sqrTerm * sqrTerm ) / ( 2.0 * g ), - 1.0, 1.0 );
+
+		}
+
+		// orthonormal basis around "d", from https://graphics.pixar.com/library/OrthonormalB/paper.pdf
+		let sign = select( sign( d.z ), 1.0, d.z == 0.0 );
+		let a = - 1.0 / ( sign + d.z );
+		let b = d.x * d.y * a;
+		let b1 = vec3( 1.0 + sign * d.x * d.x * a, sign * b, - sign * d.x );
+		let b2 = vec3( b, sign + d.y * d.y * a, - d.y );
+
+		let sinTheta = sqrt( max( 0.0, 1.0 - cosTheta * cosTheta ) );
+		let phi = 2.0 * PI * uv.y;
+		return normalize( sinTheta * cos( phi ) * b1 + sinTheta * sin( phi ) * b2 + cosTheta * d );
+
+	}
+
+`, [ constants ] );
+
 // power heuristic for multiple importance sampling
 export const misHeuristicFn = wgslFn( /* wgsl */ `
 
 	fn misHeuristic( a: f32, b: f32 ) -> f32 {
 
-		let aa = a * a;
-		let bb = b * b;
-		return aa / ( aa + bb );
+		// computed as a ratio so squaring large pdfs can't overflow to Inf / Inf
+		if ( a >= b ) {
+
+			let r = b / a;
+			return 1.0 / ( 1.0 + r * r );
+
+		}
+
+		let r = a / b;
+		return r * r / ( 1.0 + r * r );
 
 	}
 

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

@@ -156,7 +156,13 @@ export const materialStruct = new StructTypeNode( {
 
 	// offset 264 floats
 	anisotropyMapTransform: 'mat3',
-	// total size = 276
+
+	// offset 276 floats
+	// the volume's scattering, from "KHR_materials_scatter"
+	multiscatterColor: 'vec3',
+	scatterStrength: 'float',
+	scatterAnisotropy: 'float',
+	// total size = 284
 }, 'Material' );
 
 export const surfaceRecordStruct = new StructTypeNode( {

package/src/webgpu/upscale/FSRUpscaler.js

@@ -1,5 +1,5 @@
-import { Vector2 } from 'three/webgpu';
 /** @import { Camera, Texture, WebGPURenderer } from 'three/webgpu' */
+import { Vector2 } from 'three/webgpu';
 
 const _size = /*@__PURE__*/ new Vector2();