three-gpu-pathtracer 0.0.14 → 0.0.16

package/src/shader/rand/sobol.glsl.js

@@ -1,256 +1,256 @@
-// References
-// - https://jcgt.org/published/0009/04/01/
-// - Code from https://www.shadertoy.com/view/WtGyDm
-
-// functions to generate multi-dimensions variables of the same functions
-// to support 1, 2, 3, and 4 dimensional sobol sampling.
-function generateSobolFunctionVariants( dim = 1 ) {
-
-	let type = 'uint';
-	if ( dim > 1 ) {
-
-		type = 'uvec' + dim;
-
-	}
-
-	return /* glsl */`
-		${ type } sobolReverseBits( ${ type } x ) {
-
-			x = ( ( ( x & 0xaaaaaaaau ) >> 1 ) | ( ( x & 0x55555555u ) << 1 ) );
-			x = ( ( ( x & 0xccccccccu ) >> 2 ) | ( ( x & 0x33333333u ) << 2 ) );
-			x = ( ( ( x & 0xf0f0f0f0u ) >> 4 ) | ( ( x & 0x0f0f0f0fu ) << 4 ) );
-			x = ( ( ( x & 0xff00ff00u ) >> 8 ) | ( ( x & 0x00ff00ffu ) << 8 ) );
-			return ( ( x >> 16 ) | ( x << 16 ) );
-
-		}
-
-		${ type } sobolHashCombine( uint seed, ${ type } v ) {
-
-			return seed ^ ( v + ${ type }( ( seed << 6 ) + ( seed >> 2 ) ) );
-
-		}
-
-		${ type } sobolLaineKarrasPermutation( ${ type } x, ${ type } seed ) {
-
-			x += seed;
-			x ^= x * 0x6c50b47cu;
-			x ^= x * 0xb82f1e52u;
-			x ^= x * 0xc7afe638u;
-			x ^= x * 0x8d22f6e6u;
-			return x;
-
-		}
-
-		${ type } nestedUniformScrambleBase2( ${ type } x, ${ type } seed ) {
-
-			x = sobolLaineKarrasPermutation( x, seed );
-			x = sobolReverseBits( x );
-			return x;
-
-		}
-	`;
-
-}
-
-function generateSobolSampleFunctions( dim = 1 ) {
-
-	let utype = 'uint';
-	let vtype = 'float';
-	let num = '';
-	let components = '.r';
-	let combineValues = '1u';
-	if ( dim > 1 ) {
-
-		utype = 'uvec' + dim;
-		vtype = 'vec' + dim;
-		num = dim + '';
-		if ( dim === 2 ) {
-
-			components = '.rg';
-			combineValues = 'uvec2( 1u, 2u )';
-
-		} else if ( dim === 3 ) {
-
-			components = '.rgb';
-			combineValues = 'uvec3( 1u, 2u, 3u )';
-
-		} else {
-
-			components = '';
-			combineValues = 'uvec4( 1u, 2u, 3u, 4u )';
-
-		}
-
-	}
-
-	return /* glsl */`
-
-		${ vtype } sobol${ num }( int effect ) {
-
-			uint seed = sobolGetSeed( sobolBounceIndex, uint( effect ) );
-			uint index = sobolPathIndex;
-
-			uint shuffle_seed = sobolHashCombine( seed, 0u );
-			uint shuffled_index = nestedUniformScrambleBase2( sobolReverseBits( index ), shuffle_seed );
-			${ vtype } sobol_pt = sobolGetTexturePoint( shuffled_index )${ components };
-			${ utype } result = ${ utype }( sobol_pt * 16777216.0 );
-
-			${ utype } seed2 = sobolHashCombine( seed, ${ combineValues } );
-			result = nestedUniformScrambleBase2( result, seed2 );
-
-			return SOBOL_FACTOR * ${ vtype }( result >> 8 );
-
-		}
-	`;
-
-}
-
-export const sobolCommonGLSL = /* glsl */`
-
-	// Utils
-	const float SOBOL_FACTOR = 1.0 / 16777216.0;
-	const uint SOBOL_MAX_POINTS = 256u * 256u;
-
-	${ generateSobolFunctionVariants( 1 ) }
-	${ generateSobolFunctionVariants( 2 ) }
-	${ generateSobolFunctionVariants( 3 ) }
-	${ generateSobolFunctionVariants( 4 ) }
-
-	uint sobolHash( uint x ) {
-
-		// finalizer from murmurhash3
-		x ^= x >> 16;
-		x *= 0x85ebca6bu;
-		x ^= x >> 13;
-		x *= 0xc2b2ae35u;
-		x ^= x >> 16;
-		return x;
-
-	}
-
-`;
-
-export const sobolGenerationGLSL = /* glsl */`
-
-	const uint SOBOL_DIRECTIONS_1[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_2[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_3[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_4[ 32 ] = uint[ 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
-	);
-
-	uint getMaskedSobol( uint index, uint directions[ 32 ] ) {
-
-		uint X = 0u;
-		for ( int bit = 0; bit < 32; bit ++ ) {
-
-			uint mask = ( index >> bit ) & 1u;
-			X ^= mask * directions[ bit ];
-
-		}
-		return X;
-
-	}
-
-	vec4 generateSobolPoint( uint index ) {
-
-		if ( index >= SOBOL_MAX_POINTS ) {
-
-			return vec4( 0.0 );
-
-		}
-
-		// NOTEL this sobol "direction" is also available but we can't write out 5 components
-		// uint x = index & 0x00ffffffu;
-		uint x = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_1 ) ) & 0x00ffffffu;
-		uint y = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_2 ) ) & 0x00ffffffu;
-		uint z = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_3 ) ) & 0x00ffffffu;
-		uint w = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_4 ) ) & 0x00ffffffu;
-
-		return vec4( x, y, z, w ) * SOBOL_FACTOR;
-
-	}
-
-`;
-
-export const sobolSamplingGLSL = /* glsl */`
-
-	// Seeds
-	uniform sampler2D sobolTexture;
-	uint sobolPixelIndex;
-	uint sobolPathIndex;
-	uint sobolBounceIndex;
-
-	uint sobolGetSeed( uint bounce, uint effect ) {
-
-		return sobolHash(
-			sobolHashCombine(
-				sobolHashCombine(
-					sobolHash( bounce ),
-					sobolPixelIndex
-				),
-				effect
-			)
-		);
-
-	}
-
-	vec4 sobolGetTexturePoint( uint index ) {
-
-		if ( index >= SOBOL_MAX_POINTS ) {
-
-			index = index % SOBOL_MAX_POINTS;
-
-		}
-
-		uvec2 dim = uvec2( textureSize( sobolTexture, 0 ).xy );
-		uint y = index / dim.x;
-		uint x = index - y * dim.x;
-		vec2 uv = vec2( x, y ) / vec2( dim );
-		return texture( sobolTexture, uv );
-
-	}
-
-	${ generateSobolSampleFunctions( 1 ) }
-	${ generateSobolSampleFunctions( 2 ) }
-	${ generateSobolSampleFunctions( 3 ) }
-	${ generateSobolSampleFunctions( 4 ) }
-
-`;
+// References
+// - https://jcgt.org/published/0009/04/01/
+// - Code from https://www.shadertoy.com/view/WtGyDm
+
+// functions to generate multi-dimensions variables of the same functions
+// to support 1, 2, 3, and 4 dimensional sobol sampling.
+function generateSobolFunctionVariants( dim = 1 ) {
+
+	let type = 'uint';
+	if ( dim > 1 ) {
+
+		type = 'uvec' + dim;
+
+	}
+
+	return /* glsl */`
+		${ type } sobolReverseBits( ${ type } x ) {
+
+			x = ( ( ( x & 0xaaaaaaaau ) >> 1 ) | ( ( x & 0x55555555u ) << 1 ) );
+			x = ( ( ( x & 0xccccccccu ) >> 2 ) | ( ( x & 0x33333333u ) << 2 ) );
+			x = ( ( ( x & 0xf0f0f0f0u ) >> 4 ) | ( ( x & 0x0f0f0f0fu ) << 4 ) );
+			x = ( ( ( x & 0xff00ff00u ) >> 8 ) | ( ( x & 0x00ff00ffu ) << 8 ) );
+			return ( ( x >> 16 ) | ( x << 16 ) );
+
+		}
+
+		${ type } sobolHashCombine( uint seed, ${ type } v ) {
+
+			return seed ^ ( v + ${ type }( ( seed << 6 ) + ( seed >> 2 ) ) );
+
+		}
+
+		${ type } sobolLaineKarrasPermutation( ${ type } x, ${ type } seed ) {
+
+			x += seed;
+			x ^= x * 0x6c50b47cu;
+			x ^= x * 0xb82f1e52u;
+			x ^= x * 0xc7afe638u;
+			x ^= x * 0x8d22f6e6u;
+			return x;
+
+		}
+
+		${ type } nestedUniformScrambleBase2( ${ type } x, ${ type } seed ) {
+
+			x = sobolLaineKarrasPermutation( x, seed );
+			x = sobolReverseBits( x );
+			return x;
+
+		}
+	`;
+
+}
+
+function generateSobolSampleFunctions( dim = 1 ) {
+
+	let utype = 'uint';
+	let vtype = 'float';
+	let num = '';
+	let components = '.r';
+	let combineValues = '1u';
+	if ( dim > 1 ) {
+
+		utype = 'uvec' + dim;
+		vtype = 'vec' + dim;
+		num = dim + '';
+		if ( dim === 2 ) {
+
+			components = '.rg';
+			combineValues = 'uvec2( 1u, 2u )';
+
+		} else if ( dim === 3 ) {
+
+			components = '.rgb';
+			combineValues = 'uvec3( 1u, 2u, 3u )';
+
+		} else {
+
+			components = '';
+			combineValues = 'uvec4( 1u, 2u, 3u, 4u )';
+
+		}
+
+	}
+
+	return /* glsl */`
+
+		${ vtype } sobol${ num }( int effect ) {
+
+			uint seed = sobolGetSeed( sobolBounceIndex, uint( effect ) );
+			uint index = sobolPathIndex;
+
+			uint shuffle_seed = sobolHashCombine( seed, 0u );
+			uint shuffled_index = nestedUniformScrambleBase2( sobolReverseBits( index ), shuffle_seed );
+			${ vtype } sobol_pt = sobolGetTexturePoint( shuffled_index )${ components };
+			${ utype } result = ${ utype }( sobol_pt * 16777216.0 );
+
+			${ utype } seed2 = sobolHashCombine( seed, ${ combineValues } );
+			result = nestedUniformScrambleBase2( result, seed2 );
+
+			return SOBOL_FACTOR * ${ vtype }( result >> 8 );
+
+		}
+	`;
+
+}
+
+export const sobolCommonGLSL = /* glsl */`
+
+	// Utils
+	const float SOBOL_FACTOR = 1.0 / 16777216.0;
+	const uint SOBOL_MAX_POINTS = 256u * 256u;
+
+	${ generateSobolFunctionVariants( 1 ) }
+	${ generateSobolFunctionVariants( 2 ) }
+	${ generateSobolFunctionVariants( 3 ) }
+	${ generateSobolFunctionVariants( 4 ) }
+
+	uint sobolHash( uint x ) {
+
+		// finalizer from murmurhash3
+		x ^= x >> 16;
+		x *= 0x85ebca6bu;
+		x ^= x >> 13;
+		x *= 0xc2b2ae35u;
+		x ^= x >> 16;
+		return x;
+
+	}
+
+`;
+
+export const sobolGenerationGLSL = /* glsl */`
+
+	const uint SOBOL_DIRECTIONS_1[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_2[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_3[ 32 ] = uint[ 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 uint SOBOL_DIRECTIONS_4[ 32 ] = uint[ 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
+	);
+
+	uint getMaskedSobol( uint index, uint directions[ 32 ] ) {
+
+		uint X = 0u;
+		for ( int bit = 0; bit < 32; bit ++ ) {
+
+			uint mask = ( index >> bit ) & 1u;
+			X ^= mask * directions[ bit ];
+
+		}
+		return X;
+
+	}
+
+	vec4 generateSobolPoint( uint index ) {
+
+		if ( index >= SOBOL_MAX_POINTS ) {
+
+			return vec4( 0.0 );
+
+		}
+
+		// NOTEL this sobol "direction" is also available but we can't write out 5 components
+		// uint x = index & 0x00ffffffu;
+		uint x = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_1 ) ) & 0x00ffffffu;
+		uint y = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_2 ) ) & 0x00ffffffu;
+		uint z = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_3 ) ) & 0x00ffffffu;
+		uint w = sobolReverseBits( getMaskedSobol( index, SOBOL_DIRECTIONS_4 ) ) & 0x00ffffffu;
+
+		return vec4( x, y, z, w ) * SOBOL_FACTOR;
+
+	}
+
+`;
+
+export const sobolSamplingGLSL = /* glsl */`
+
+	// Seeds
+	uniform sampler2D sobolTexture;
+	uint sobolPixelIndex;
+	uint sobolPathIndex;
+	uint sobolBounceIndex;
+
+	uint sobolGetSeed( uint bounce, uint effect ) {
+
+		return sobolHash(
+			sobolHashCombine(
+				sobolHashCombine(
+					sobolHash( bounce ),
+					sobolPixelIndex
+				),
+				effect
+			)
+		);
+
+	}
+
+	vec4 sobolGetTexturePoint( uint index ) {
+
+		if ( index >= SOBOL_MAX_POINTS ) {
+
+			index = index % SOBOL_MAX_POINTS;
+
+		}
+
+		uvec2 dim = uvec2( textureSize( sobolTexture, 0 ).xy );
+		uint y = index / dim.x;
+		uint x = index - y * dim.x;
+		vec2 uv = vec2( x, y ) / vec2( dim );
+		return texture( sobolTexture, uv );
+
+	}
+
+	${ generateSobolSampleFunctions( 1 ) }
+	${ generateSobolSampleFunctions( 2 ) }
+	${ generateSobolSampleFunctions( 3 ) }
+	${ generateSobolSampleFunctions( 4 ) }
+
+`;

package/src/shader/sampling/equirectSampling.glsl.js

@@ -1,62 +1,62 @@
-export const equirectSamplingGLSL = /* glsl */`
-
-	// samples the the given environment map in the given direction
-	vec3 sampleEquirectColor( sampler2D envMap, vec3 direction ) {
-
-		return texture2D( envMap, equirectDirectionToUv( direction ) ).rgb;
-
-	}
-
-	// gets the pdf of the given direction to sample
-	float equirectDirectionPdf( 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 );
-
-	}
-
-	// samples the color given env map with CDF and returns the pdf of the direction
-	float sampleEquirect( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
-
-		vec2 uv = equirectDirectionToUv( direction );
-		color = texture2D( info.map, uv ).rgb;
-
-		float totalSum = info.totalSumWhole + info.totalSumDecimal;
-		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
-		float pdf = lum / totalSum;
-
-		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
-
-	}
-
-	// samples a direction of the envmap with color and retrieves pdf
-	float sampleEquirectProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
-
-		// sample env map cdf
-		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 = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
-		float pdf = lum / totalSum;
-
-		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
-
-	}
-
-`;
+export const equirectSamplingGLSL = /* glsl */`
+
+	// samples the the given environment map in the given direction
+	vec3 sampleEquirectColor( sampler2D envMap, vec3 direction ) {
+
+		return texture2D( envMap, equirectDirectionToUv( direction ) ).rgb;
+
+	}
+
+	// gets the pdf of the given direction to sample
+	float equirectDirectionPdf( 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 );
+
+	}
+
+	// samples the color given env map with CDF and returns the pdf of the direction
+	float sampleEquirect( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
+
+		vec2 uv = equirectDirectionToUv( direction );
+		color = texture2D( info.map, uv ).rgb;
+
+		float totalSum = info.totalSum;
+		float lum = luminance( color );
+		ivec2 resolution = textureSize( info.map, 0 );
+		float pdf = lum / totalSum;
+
+		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
+
+	}
+
+	// samples a direction of the envmap with color and retrieves pdf
+	float sampleEquirectProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
+
+		// sample env map cdf
+		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.totalSum;
+		float lum = luminance( color );
+		ivec2 resolution = textureSize( info.map, 0 );
+		float pdf = lum / totalSum;
+
+		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
+
+	}
+
+`;