three-gpu-pathtracer 0.0.24 → 0.0.26

package/src/webgpu/nodes/rand/bluedither.wgsl.js

@@ -0,0 +1,92 @@
+import { texture, vec4 } from 'three/tsl';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { rand4, rngInit, rngNextBounce } from './sobol.wgsl.js';
+import { BlueNoiseTexture } from '../../../textures/BlueNoiseTexture.js';
+
+// Based in part on the "stratified" random sample implement from the WebGLPathTracer which
+// is in turn based on "hoverinc/ray-tracing-renderer" sampling strategy.
+// This random sampling strategy uses the exact sample stratified sobol sequence for every
+// pixel on screen, with a fractional blue-noise offset applied. This means that pixels
+// along the blue noise stride sample the same directions leading to a blue noise pattern
+// emerging in screen space.
+//
+// References
+// - "Blue-Noise Dithered Sampling", Georgiev & Fajardo, SIGGRAPH 2016 Talks
+//   https://www.arnoldrenderer.com/research/dither_abstract.pdf
+// - Blue noise discussion:
+//   https://developer.nvidia.com/blog/rendering-in-real-time-with-spatiotemporal-blue-noise-textures-part-2/
+
+// constants
+const BN_SIZE = 64;
+
+// construct nodes
+const blueNoiseTex = new BlueNoiseTexture( BN_SIZE, 1 );
+const blueNoiseTexNode = texture( blueNoiseTex );
+const pixelSeed = vec4( 0 ).toVar( 'blueDitherSeed' );
+
+// When dithering, the sobol sampler is seeded with a constant pixel so every pixel
+// uses the same sequence, which is modified with the per-pixel blue noise sample.
+const blueDitherInitFunc = wgslTagFn/* wgsl */`
+	fn blueDitherInitialize( pixel: vec2u, pathIndex: u32, bounceIndex: u32 ) -> void {
+
+		let coord = vec2i( pixel % vec2u( ${ BN_SIZE }u ) );
+		${ pixelSeed } = textureLoad( ${ blueNoiseTexNode }, coord, 0 );
+		${ rngInit }( vec2u( 0 ), pathIndex, bounceIndex );
+
+	}
+`;
+
+const blueDitherNextBounceFunc = wgslTagFn/* wgsl */`
+	fn blueDitherNextBounce() -> void {
+
+		${ rngNextBounce }();
+
+	}
+`;
+
+// The per-pixel scalar is rotated by the golden ratio per dimension. Apply a per-dimension
+// offset to reduce the corelation of the sequence.
+const blueDitherRand4Func = wgslTagFn/* wgsl */`
+	fn blueDitherRand4( effect: u32 ) -> vec4f {
+
+		// Get the scrambled sobol stratified sample
+		let stratifiedSample = ${ rand4 }( effect );
+
+		// offset it by the blue noise seed and dimension rotation
+		return fract( stratifiedSample + ${ pixelSeed }.r );
+
+	}
+`;
+
+const blueDitherRand3Func = wgslTagFn/* wgsl */`
+	fn blueDitherRand3( effect: u32 ) -> vec3f {
+
+		return ${ blueDitherRand4Func }( effect ).xyz;
+
+	}
+`;
+
+const blueDitherRand2Func = wgslTagFn/* wgsl */`
+	fn blueDitherRand2( effect: u32 ) -> vec2f {
+
+		return ${ blueDitherRand4Func }( effect ).xy;
+
+	}
+`;
+
+const blueDitherRand1Func = wgslTagFn/* wgsl */`
+	fn blueDitherRand1( effect: u32 ) -> f32 {
+
+		return ${ blueDitherRand4Func }( effect ).x;
+
+	}
+`;
+
+export {
+	blueDitherNextBounceFunc as rngNextBounce,
+	blueDitherInitFunc as rngInit,
+	blueDitherRand1Func as rand1,
+	blueDitherRand2Func as rand2,
+	blueDitherRand3Func as rand3,
+	blueDitherRand4Func as rand4,
+};

package/src/webgpu/nodes/rand/pcg.wgsl.js

@@ -0,0 +1,81 @@
+import { wgsl, wgslFn } from 'three/tsl';
+
+const pcgStateStruct = wgsl( /* wgsl */`
+
+	struct PcgState {
+		s0: vec4u,
+		s1: vec4u,
+	};
+
+	var<private> g_state: PcgState;
+` );
+
+const pcgInitFunc = wgslFn( /* wgsl */`
+	fn pcgInitialize( pixel: vec2u, pathIndex: u32, bounceIndex: u32 ) -> void {
+
+		// white noise seed
+		g_state.s0 = vec4u( pixel | vec2( bounceIndex << 16 ), pathIndex, pixel.x + pixel.y);
+
+		// blue noise seed
+		g_state.s1 = vec4u( pathIndex, pathIndex * 15843, pathIndex * 31 + 4566, pathIndex * 2345 + 58585 );
+
+	}
+`, [ pcgStateStruct ] );
+
+const pcg4d = wgslFn( /* wgsl */ `
+	fn pcg4d( v: ptr<private, vec4u> ) -> void {
+
+		*v = *v * 1664525u + 1013904223u;
+		*v = *v + v.yzxy * v.wxyz;
+		*v = *v ^ ( *v >> vec4u( 16u ) );
+		*v = *v + v.yzxy * v.wxyz;
+	}
+` );
+
+const pcgRandFunc = wgslFn( /*wgsl*/`
+	fn pcgRand( _id: u32 ) -> f32 {
+
+		pcg4d( &g_state.s0 );
+		return abs( f32( g_state.s0.x ) / f32( 0xffffffffu ) );
+
+	}
+`, [ pcg4d, pcgStateStruct ] );
+
+const pcgRand2Func = wgslFn( /*wgsl*/`
+	fn pcgRand2( _id: u32 ) -> vec2f {
+
+		pcg4d( &g_state.s0 );
+		return abs( vec2f( g_state.s0.xy ) / f32( 0xffffffffu ) );
+
+	}
+`, [ pcg4d, pcgStateStruct ] );
+
+const pcgRand3Func = wgslFn( /*wgsl*/`
+	fn pcgRand3( _id: u32 ) -> vec3f {
+
+		pcg4d( &g_state.s0 );
+		return abs( vec3f( g_state.s0.xyz ) / f32( 0xffffffffu ) );
+
+	}
+`, [ pcg4d, pcgStateStruct ] );
+
+const pcgRand4Func = wgslFn( /*wgsl*/`
+	fn pcgRand4( _id: u32 ) -> vec4f {
+
+		pcg4d( &g_state.s0 );
+		return abs( vec4f( g_state.s0 ) / f32( 0xffffffffu ) );
+
+	}
+`, [ pcg4d, pcgStateStruct ] );
+
+const pcgNextBounceFunc = wgslFn( /* wgsl */ 'fn noop() -> void {}' );
+
+// PCG definitions
+export {
+	pcgInitFunc as rngInit,
+	pcgNextBounceFunc as rngNextBounce,
+	pcgRandFunc as rand1,
+	pcgRand2Func as rand2,
+	pcgRand3Func as rand3,
+	pcgRand4Func as rand4,
+};

package/src/webgpu/nodes/rand/sobol.wgsl.js

@@ -0,0 +1,287 @@
+import { uint, float, wgsl, wgslFn } from 'three/tsl';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+
+// References
+// - https://jcgt.org/published/0009/04/01/
+// - Code from https://www.shadertoy.com/view/WtGyDm
+// Ported from WebGL version at sobol.glsl.js
+
+const SOBOL_MAX_POINTS = uint( 256 * 256 );
+const SOBOL_FACTOR = float( 1.0 / 16777216.0 );
+
+const sobolConstants = wgsl( /* wgsl */ `
+
+	const SOBOL_DIRECTIONS_1 = array<u32, 32>(
+		0x80000000u, 0xc0000000u, 0xa0000000u, 0xf0000000u,
+		0x88000000u, 0xcc000000u, 0xaa000000u, 0xff000000u,
+		0x80800000u, 0xc0c00000u, 0xa0a00000u, 0xf0f00000u,
+		0x88880000u, 0xcccc0000u, 0xaaaa0000u, 0xffff0000u,
+		0x80008000u, 0xc000c000u, 0xa000a000u, 0xf000f000u,
+		0x88008800u, 0xcc00cc00u, 0xaa00aa00u, 0xff00ff00u,
+		0x80808080u, 0xc0c0c0c0u, 0xa0a0a0a0u, 0xf0f0f0f0u,
+		0x88888888u, 0xccccccccu, 0xaaaaaaaau, 0xffffffffu
+	);
+
+	const SOBOL_DIRECTIONS_2 = array<u32, 32>(
+		0x80000000u, 0xc0000000u, 0x60000000u, 0x90000000u,
+		0xe8000000u, 0x5c000000u, 0x8e000000u, 0xc5000000u,
+		0x68800000u, 0x9cc00000u, 0xee600000u, 0x55900000u,
+		0x80680000u, 0xc09c0000u, 0x60ee0000u, 0x90550000u,
+		0xe8808000u, 0x5cc0c000u, 0x8e606000u, 0xc5909000u,
+		0x6868e800u, 0x9c9c5c00u, 0xeeee8e00u, 0x5555c500u,
+		0x8000e880u, 0xc0005cc0u, 0x60008e60u, 0x9000c590u,
+		0xe8006868u, 0x5c009c9cu, 0x8e00eeeeu, 0xc5005555u
+	);
+
+	const SOBOL_DIRECTIONS_3 = array<u32, 32>(
+		0x80000000u, 0xc0000000u, 0x20000000u, 0x50000000u,
+		0xf8000000u, 0x74000000u, 0xa2000000u, 0x93000000u,
+		0xd8800000u, 0x25400000u, 0x59e00000u, 0xe6d00000u,
+		0x78080000u, 0xb40c0000u, 0x82020000u, 0xc3050000u,
+		0x208f8000u, 0x51474000u, 0xfbea2000u, 0x75d93000u,
+		0xa0858800u, 0x914e5400u, 0xdbe79e00u, 0x25db6d00u,
+		0x58800080u, 0xe54000c0u, 0x79e00020u, 0xb6d00050u,
+		0x800800f8u, 0xc00c0074u, 0x200200a2u, 0x50050093u
+	);
+
+	const SOBOL_DIRECTIONS_4 = array<u32, 32>(
+		0x80000000u, 0x40000000u, 0x20000000u, 0xb0000000u,
+		0xf8000000u, 0xdc000000u, 0x7a000000u, 0x9d000000u,
+		0x5a800000u, 0x2fc00000u, 0xa1600000u, 0xf0b00000u,
+		0xda880000u, 0x6fc40000u, 0x81620000u, 0x40bb0000u,
+		0x22878000u, 0xb3c9c000u, 0xfb65a000u, 0xddb2d000u,
+		0x78022800u, 0x9c0b3c00u, 0x5a0fb600u, 0x2d0ddb00u,
+		0xa2878080u, 0xf3c9c040u, 0xdb65a020u, 0x6db2d0b0u,
+		0x800228f8u, 0x400b3cdcu, 0x200fb67au, 0xb00ddb9du
+	);
+
+` );
+
+const sobolPixelIndex = uint( 0 ).toVar( 'sobolPixelIndex' );
+const sobolPathIndex = uint( 0 ).toVar( 'sobolPathIndex' );
+const sobolBounceIndex = uint( 0 ).toVar( 'sobolBounceIndex' );
+
+const getMaskedSobolFunc = wgslFn( /* wgsl */ `
+	fn getMaskedSobol( index: u32, directions: array<u32, 32> ) -> u32 {
+
+		var X = 0u;
+		for ( var bit = 0u; bit < 32u; bit ++ ) {
+
+			let mask = ( index >> bit ) & 1u;
+			X ^= mask * directions[ bit ];
+
+		}
+		return X;
+
+	}
+` );
+
+// functions to generate multi-dimensions variables of the same functions
+// to support 1, 2, 3, and 4 dimensional sobol sampling.
+const sobolScrambleNodesGenerator = ( dim = 1 ) => {
+
+	if ( dim <= 0 ) {
+
+		return;
+
+	}
+
+	const type = dim > 1 ? `vec${dim}u` : 'u32';
+
+	const sobolReverseBitsFunc = wgslFn( /* wgsl */ `
+		fn sobolReverseBits_${type}( in: ${type} ) -> ${type} {
+
+			var x = in;
+			x = ( ( ( x & ${type}( 0xaaaaaaaau ) ) >> ${type}( 1 ) ) | ( ( x & ${type}( 0x55555555u ) ) << ${type}( 1 ) ) );
+			x = ( ( ( x & ${type}( 0xccccccccu ) ) >> ${type}( 2 ) ) | ( ( x & ${type}( 0x33333333u ) ) << ${type}( 2 ) ) );
+			x = ( ( ( x & ${type}( 0xf0f0f0f0u ) ) >> ${type}( 4 ) ) | ( ( x & ${type}( 0x0f0f0f0fu ) ) << ${type}( 4 ) ) );
+			x = ( ( ( x & ${type}( 0xff00ff00u ) ) >> ${type}( 8 ) ) | ( ( x & ${type}( 0x00ff00ffu ) ) << ${type}( 8 ) ) );
+			return ( ( x >> ${type}( 16 ) ) | ( x << ${type}( 16 ) ) );
+
+		}
+	` );
+
+	const sobolHashCombineFunc = wgslFn( /* wgsl */ `
+		fn sobolHashCombine_${type}( seed: u32, v: ${type} ) -> ${type} {
+
+			return ${type}( seed ) ^ ( v + ${ type }( ( seed << 6 ) + ( seed >> 2 ) ) );
+
+		}
+	` );
+
+	const sobolLaineKarrasPermutationFunc = wgslFn( /* wgsl */ `
+		fn sobolLaineKarrasPermutation_${type}( in: ${type}, seed: ${type} ) -> ${type} {
+
+			var x = in;
+			x += seed;
+			x ^= x * 0x6c50b47cu;
+			x ^= x * 0xb82f1e52u;
+			x ^= x * 0xc7afe638u;
+			x ^= x * 0x8d22f6e6u;
+			return x;
+
+		}
+	` );
+
+	const nestedUniformScrambleBase2Func = wgslTagFn/* wgsl */ `
+		fn nestedUniformScrambleBase2_${type}( x: ${type}, seed: ${type} ) -> ${type} {
+
+			var res = ${ sobolLaineKarrasPermutationFunc }( x, seed );
+			res = ${ sobolReverseBitsFunc }( res );
+			return res;
+
+		}
+	`;
+
+	return {
+		reverseBits: sobolReverseBitsFunc,
+		hashCombine: sobolHashCombineFunc,
+		lkPermutation: sobolLaineKarrasPermutationFunc,
+		scramble: nestedUniformScrambleBase2Func,
+	};
+
+};
+
+// 0th node is intentionally empty to make access pattern more intuitive:
+// sobolNodes[ i ] are nodes that are needed to sample i-dimensional vectors
+// 1-dimensional vector = f32
+const sobolNodes = Array.from( { length: 5 }, ( _, i ) => sobolScrambleNodesGenerator( i ) );
+
+const generateSobolPointFunc = wgslTagFn/* wgsl */`
+  	${ [ sobolConstants ] }
+	fn generateSobolPoint( id: u32 ) -> vec4f {
+
+		var index = id;
+		if ( index >= ${ SOBOL_MAX_POINTS } ) {
+
+			index = index % ${ SOBOL_MAX_POINTS };
+			// return vec4( 0.0 );
+
+		}
+
+		// NOTE: this sobol "direction" is also available but we can't write out 5 components
+		// uint x = index & 0x00ffffffu;
+		let x = ${ sobolNodes[ 1 ].reverseBits }( ${ getMaskedSobolFunc }( index, SOBOL_DIRECTIONS_1 ) ) & 0x00ffffffu;
+		let y = ${ sobolNodes[ 1 ].reverseBits }( ${ getMaskedSobolFunc }( index, SOBOL_DIRECTIONS_2 ) ) & 0x00ffffffu;
+		let z = ${ sobolNodes[ 1 ].reverseBits }( ${ getMaskedSobolFunc }( index, SOBOL_DIRECTIONS_3 ) ) & 0x00ffffffu;
+		let w = ${ sobolNodes[ 1 ].reverseBits }( ${ getMaskedSobolFunc }( index, SOBOL_DIRECTIONS_4 ) ) & 0x00ffffffu;
+
+		return vec4( f32( x ), f32( y ), f32( z ), f32( w ) ) * ${ SOBOL_FACTOR };
+
+	}
+`;
+
+const sobolHashFunc = wgslFn( /* wgsl */ `
+	fn sobolHash( in: u32 ) -> u32 {
+
+		var x = in;
+		// finalizer from murmurhash3
+		x ^= x >> 16;
+		x *= 0x85ebca6bu;
+		x ^= x >> 13;
+		x *= 0xc2b2ae35u;
+		x ^= x >> 16;
+		return x;
+
+	}
+` );
+
+const sobolGetSeedFunc = wgslTagFn/* wgsl */`
+	fn sobolGetSeed( effect: u32 ) -> u32 {
+
+		return ${ sobolHashFunc }(
+			${ sobolNodes[ 1 ].hashCombine }(
+				${ sobolNodes[ 1 ].hashCombine }(
+					${ sobolHashFunc }( ${ sobolBounceIndex } ),
+					${ sobolPixelIndex }
+				),
+				effect
+			)
+		);
+
+	}
+`;
+
+const sobolGenerator = ( dim = 1, sobolPointFunc = generateSobolPointFunc ) => {
+
+	if ( dim <= 0 ) {
+
+		return;
+
+	}
+
+	const utype = dim > 1 ? `vec${ dim }u` : 'u32';
+	const ftype = dim > 1 ? `vec${ dim }f` : 'f32';
+
+	let components = '.r';
+	let combineValues = '1u';
+	if ( dim === 2 ) {
+
+		components = '.rg';
+		combineValues = 'vec2( 1u, 2u )';
+
+	} else if ( dim === 3 ) {
+
+		components = '.rgb';
+		combineValues = 'vec3( 1u, 2u, 3u )';
+
+	} else if ( dim === 4 ) {
+
+		components = '';
+		combineValues = 'vec4( 1u, 2u, 3u, 4u )';
+
+	}
+
+	return wgslTagFn/* wgsl */`
+		fn sobol${ dim }( effect: u32 ) -> ${ ftype } {
+
+			let seed = ${ sobolGetSeedFunc }( effect );
+			let index = ${ sobolPathIndex };
+
+			let shuffle_seed = ${ sobolNodes[ 1 ].hashCombine }( seed, 0u );
+			let shuffled_index = ${ sobolNodes[ 1 ].scramble }( ${ sobolNodes[ 1 ].reverseBits }( index ), shuffle_seed );
+			let sobol_pt = ${ sobolPointFunc }( shuffled_index )${ components };
+			var result = ${ utype }( sobol_pt * 16777216.0 );
+
+			let seed2 = ${ sobolNodes[ dim ].hashCombine }( seed, ${ combineValues } );
+			result = ${ sobolNodes[ dim ].scramble }( result, seed2 );
+
+			return ${ SOBOL_FACTOR } * ${ ftype }( result >> ${utype}( 8 ) );
+
+		}
+	`;
+
+};
+
+const sobolRand1Func = sobolGenerator( 1 );
+const sobolRand2Func = sobolGenerator( 2 );
+const sobolRand3Func = sobolGenerator( 3 );
+const sobolRand4Func = sobolGenerator( 4 );
+
+const sobolInitFunc = wgslTagFn/* wgsl */`
+	fn sobolInit( pixel: vec2u, pathIndex: u32, bounceIndex: u32 ) -> void {
+
+		${ sobolPixelIndex } = ( pixel.x << 16 ) | pixel.y;
+		${ sobolPathIndex } = pathIndex;
+		${ sobolBounceIndex } = bounceIndex;
+
+	}
+`;
+
+const sobolNextBounceFunc = wgslTagFn/* wgsl */`
+	fn sobolNextBounce() -> void {
+
+		${ sobolBounceIndex }++;
+
+	}
+`;
+
+// Sobol definitions
+export {
+	sobolInitFunc as rngInit,
+	sobolNextBounceFunc as rngNextBounce,
+	sobolRand1Func as rand1,
+	sobolRand2Func as rand2,
+	sobolRand3Func as rand3,
+	sobolRand4Func as rand4,
+};

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

@@ -0,0 +1,20 @@
+export const RNG_INDEX_RAY_JITTER = 0;
+export const RNG_INDEX_BACKGROUND_SAMPLE = 1;
+export const RNG_INDEX_SCATTER_TYPE = 2;
+export const RNG_INDEX_SCATTER_DIRECTION = 3;
+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_ALPHA_TEST = 50;
+import { contextProxyFn } from 'three-mesh-bvh/webgpu';
+import * as sobol from './rand/sobol.wgsl.js';
+
+// Wrap random functions in context-proxies that will retrieve the functions from
+// the build context if present otherwise fallback to sobol.
+export const rngInit = contextProxyFn( 'random.rngInit', sobol.rngInit );
+export const rngNextBounce = contextProxyFn( 'random.rngNextBounce', sobol.rngNextBounce );
+export const rand1 = contextProxyFn( 'random.rand1', sobol.rand1 );
+export const rand2 = contextProxyFn( 'random.rand2', sobol.rand2 );
+export const rand3 = contextProxyFn( 'random.rand3', sobol.rand3 );
+export const rand4 = contextProxyFn( 'random.rand4', sobol.rand4 );

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

@@ -0,0 +1,21 @@
+import { wgslFn } from 'three/tsl';
+
+export const resetResultFn = wgslFn( /* wgsl */ `
+
+	fn resetBuffers(
+		resultBuffer: ptr<storage, array<vec4f>, read_write>,
+		sample_count_buffer: ptr<storage, array<u32>, read_write>,
+		dimensions: vec2u,
+
+		globalId: vec2u,
+	) -> void {
+
+		let offset = globalId.x + globalId.y * dimensions.x;
+		sample_count_buffer[offset] = 0;
+		resultBuffer[offset] = vec4f(0.0);
+
+	}
+
+` );
+
+export default resetResultFn;

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

@@ -0,0 +1,193 @@
+import { wgslFn } from 'three/tsl';
+import { constants, lobeWeightsStruct } from './structs.wgsl.js';
+import { disneyFresnelFunc, iorToF0Func, schlickFresnelFunc } from './utils.wgsl.js';
+
+/*
+wi     : incident vector or light vector (pointing toward the light)
+wo     : outgoing vector or view vector (pointing towards the camera)
+wh     : computed half vector from wo and wi
+Vectors above are assumed to be in tangent space. i.e. +z is along macronormal of the surface
+eta    : Greek character used to denote the "ratio of ior"
+*/
+
+export const sampleSphereFunc = wgslFn( /* wgsl */ `
+
+	fn sampleSphere( uv: vec2f ) -> vec3f {
+
+		let u = ( uv.x - 0.5 ) * 2.0;
+		let t = uv.y * PI * 2.0;
+		let f = sqrt( 1.0 - u * u );
+
+		return vec3f( f * cos( t ), f * sin( t ), u );
+
+	}
+
+`, [ constants ] );
+
+// TODO: Investigate sampling directly in tagent space?
+// See 16.6.1 in https://www.realtimerendering.com/raytracinggems/unofficial_RayTracingGems_v1.9.pdf
+export const diffuseDirectionFunc = wgslFn( /* wgsl */ `
+
+	fn diffuseDirection( wo: vec3f, uv: vec2f ) -> vec3f {
+
+		var lightDirection = sampleSphere( uv );
+		lightDirection.z += 1.0;
+		lightDirection = normalize( lightDirection );
+
+		return lightDirection;
+
+	}
+
+`, [ sampleSphereFunc ] );
+
+export const getLobeWeightsFunc = wgslFn( /* wgsl */ `
+
+	fn getLobeWeights( wo: vec3f, wi: vec3f, woClearcoat: vec3f, wh: vec3f, clearcoatIor: f32, surf: SurfaceRecord ) -> LobeWeights {
+
+		var weights: LobeWeights;
+		var remaining = 1.0;
+
+		let clearcoatF0 = iorToF0( clearcoatIor );
+		let clearcoatFresnel = schlickFresnel( saturate( woClearcoat.z ), clearcoatF0 );
+		weights.clearcoat = surf.clearcoat * clearcoatFresnel;
+		remaining -= weights.clearcoat;
+
+		// this specular lobe only handles the opaque portion of the specular
+		let fEstimate = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
+		weights.specular = remaining * ( surf.metalness + ( 1.0 - surf.metalness ) * ( 1.0 - surf.transmission ) * fEstimate );
+		remaining -= weights.specular;
+
+		// the transmission lobe covers both the reflected and refracted halves of the transmissive portion
+		weights.transmission = remaining * surf.transmission;
+		remaining -= weights.transmission;
+
+		weights.diffuse = remaining;
+
+		return weights;
+
+	}
+
+`, [ disneyFresnelFunc, schlickFresnelFunc, iorToF0Func, lobeWeightsStruct, constants ] );
+
+export const equirectDirectionToUvFn = wgslFn( /* wgsl */`
+
+	fn equirectDirectionToUv(direction: vec3f) -> vec2f {
+
+		// from Spherical.setFromCartesianCoords
+		var uv = vec2f( atan2( direction.z, direction.x ), acos( direction.y ) );
+		uv /= vec2f( 2.0 * PI, PI );
+
+		// apply adjustments to get values in range [0, 1] and y right side up
+		uv.x += 0.5;
+		uv.y = 1.0 - uv.y;
+		return uv;
+
+	}
+
+` );
+
+export const sampleHemisphereFn = wgslFn( /* wgsl */ `
+
+	fn sampleHemisphere( n: vec3f, uv: vec2f ) -> vec3f {
+
+		// https://www.rorydriscoll.com/2009/01/07/better-sampling/
+		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf
+		let sign = select( sign( n.z ), 1.0, n.z == 0.0 );
+		let a = - 1.0 / ( sign + n.z );
+		let b = n.x * n.y * a;
+		let b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );
+		let b2 = vec3( b, sign + n.y * n.y * a, - n.y );
+
+		let r = sqrt( uv.x );
+		let theta = 2.0 * PI * uv.y;
+		let x = r * cos( theta );
+		let y = r * sin( theta );
+		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;
+
+	}
+
+`, [ 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 );
+
+	}
+
+` );
+
+export const luminanceFn = wgslFn( /* wgsl */ `
+
+	fn luminance( color: vec3f ) -> f32 {
+
+		return dot( color, vec3f( 0.2126, 0.7152, 0.0722 ) );
+
+	}
+
+` );
+
+// inverse of equirectDirectionToUv: map an equirect uv back to a direction
+export const equirectUvToDirectionFn = wgslFn( /* wgsl */ `
+
+	fn equirectUvToDirection( uvIn: vec2f ) -> vec3f {
+
+		// undo the adjustments applied in equirectDirectionToUv
+		var uv = uvIn;
+		uv.x -= 0.5;
+		uv.y = 1.0 - uv.y;
+
+		let theta = uv.x * 2.0 * PI;
+		let phi = uv.y * PI;
+		let sinPhi = sin( phi );
+
+		return vec3f( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+
+	}
+
+`, [ constants ] );
+
+// solid-angle pdf factor for the equirect parameterization ( accounts for pole compression )
+export const equirectDirectionPdfFn = wgslFn( /* wgsl */ `
+
+	fn equirectDirectionPdf( direction: vec3f ) -> f32 {
+
+		let uv = equirectDirectionToUv( direction );
+		let theta = uv.y * PI;
+		let sinTheta = sin( theta );
+		if ( sinTheta == 0.0 ) {
+
+			return 0.0;
+
+		}
+
+		return 1.0 / ( 2.0 * PI * PI * sinTheta );
+
+	}
+
+`, [ constants, equirectDirectionToUvFn ] );
+
+export const weightedAlphaBlendFn = wgslFn( /* wgsl */`
+
+	fn weightedAlphaBlend( prevColor: vec4f, newColor: vec4f, weight: f32 ) -> vec4f {
+
+		let invWeight = 1.0 - weight;
+		let totalAlpha = prevColor.a * invWeight + newColor.a * weight;
+		var blendedColor = vec4f( 0 );
+		if ( totalAlpha != 0.0 ) {
+
+			let prevContrib = prevColor.rgb * invWeight * prevColor.a / totalAlpha;
+			let resContrib = newColor.rgb * weight * newColor.a / totalAlpha;
+			blendedColor = vec4f( prevContrib + resContrib, totalAlpha );
+
+		}
+
+		return blendedColor;
+
+	}
+
+` );