three-gpu-pathtracer 0.0.8 → 0.0.10

package/src/shader/shaderSobolSampling.js

@@ -0,0 +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 shaderSobolCommon = /* 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 shaderSobolGeneration = /* 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 shaderSobolSampling = /* 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/shaderStructs.js

@@ -82,6 +82,7 @@ export const shaderMaterialStructs = /* glsl */ `
 		int sheenRoughnessMap;
 
 		bool vertexColors;
+		bool flatShading;
 		bool transparent;
 
 		mat3 mapTransform;
@@ -194,7 +195,8 @@ export const shaderMaterialStructs = /* glsl */ `
 
 		m.matte = bool( s14.r );
 		m.castShadow = ! bool( s14.g );
-		m.vertexColors = bool( s14.b );
+		m.vertexColors = bool( int( s14.b ) & 1 );
+		m.flatShading = bool( int( s14.b ) & 2 );
 		m.transparent = bool( s14.a );
 
 		uint firstTextureTransformIdx = i + 15u;
@@ -226,6 +228,8 @@ export const shaderLightStruct = /* glsl */ `
 	#define RECT_AREA_LIGHT_TYPE 0
 	#define CIRC_AREA_LIGHT_TYPE 1
 	#define SPOT_LIGHT_TYPE 2
+	#define DIR_LIGHT_TYPE 3
+	#define POINT_LIGHT_TYPE 4
 
 	struct LightsInfo {
 
@@ -277,7 +281,7 @@ export const shaderLightStruct = /* glsl */ `
 		l.v = s3.rgb;
 		l.area = s3.a;
 
-		if ( l.type == SPOT_LIGHT_TYPE ) {
+		if ( l.type == SPOT_LIGHT_TYPE || l.type == POINT_LIGHT_TYPE ) {
 
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );

package/src/shader/shaderUtils.js

@@ -131,74 +131,7 @@ export const shaderUtils = /* glsl */`
 
 	}
 
-	// https://www.shadertoy.com/view/wltcRS
-	uvec4 s0;
-
-	void rng_initialize(vec2 p, int frame) {
-
-		// white noise seed
-		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
-
-	}
-
-	// https://www.pcg-random.org/
-	void pcg4d( inout uvec4 v ) {
-
-		v = v * 1664525u + 1013904223u;
-		v.x += v.y * v.w;
-		v.y += v.z * v.x;
-		v.z += v.x * v.y;
-		v.w += v.y * v.z;
-		v = v ^ ( v >> 16u );
-		v.x += v.y*v.w;
-		v.y += v.z*v.x;
-		v.z += v.x*v.y;
-		v.w += v.y*v.z;
-
-	}
-
-	// returns [ 0, 1 ]
-	float rand() {
-
-		pcg4d(s0);
-		return float( s0.x ) / float( 0xffffffffu );
-
-	}
-
-	vec2 rand2() {
-
-		pcg4d( s0 );
-		return vec2( s0.xy ) / float(0xffffffffu);
-
-	}
-
-	vec3 rand3() {
-
-		pcg4d(s0);
-		return vec3( s0.xyz ) / float( 0xffffffffu );
-
-	}
-
-	vec4 rand4() {
-
-		pcg4d(s0);
-		return vec4(s0)/float(0xffffffffu);
-
-	}
-
-	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
-	vec3 randDirection() {
-
-		vec2 r = rand2();
-		float u = ( r.x - 0.5 ) * 2.0;
-		float t = r.y * PI * 2.0;
-		float f = sqrt( 1.0 - u * u );
-
-		return vec3( f * cos( t ), f * sin( t ), u );
-
-	}
-
-	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
+	vec2 sampleTriangle( vec2 a, vec2 b, vec2 c, vec2 r ) {
 
 		// get the edges of the triangle and the diagonal across the
 		// center of the parallelogram
@@ -206,8 +139,7 @@ export const shaderUtils = /* glsl */`
 		vec2 e2 = c - b;
 		vec2 diag = normalize( e1 + e2 );
 
-		// pick a random point in the parallelogram
-		vec2 r = rand2();
+		// pick the point in the parallelogram
 		if ( r.x + r.y > 1.0 ) {
 
 			r = vec2( 1.0 ) - r;
@@ -218,40 +150,48 @@ export const shaderUtils = /* glsl */`
 
 	}
 
-	// samples an aperture shape with the given number of sides. 0 means circle
-	vec2 sampleAperture( int blades ) {
+	vec2 sampleCircle( vec2 uv ) {
 
-		if ( blades == 0 ) {
+		float angle = 2.0 * PI * uv.x;
+		float radius = sqrt( uv.y );
+		return vec2( cos( angle ), sin( angle ) ) * radius;
 
-			vec2 r = rand2();
-			float angle = 2.0 * PI * r.x;
-			float radius = sqrt( rand() );
-			return vec2( cos( angle ), sin( angle ) ) * radius;
+	}
 
-		} else {
+	vec3 sampleSphere( vec2 uv ) {
 
-			blades = max( blades, 3 );
+		float u = ( uv.x - 0.5 ) * 2.0;
+		float t = uv.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
 
-			vec3 r = rand3();
-			float anglePerSegment = 2.0 * PI / float( blades );
-			float segment = floor( float( blades ) * r.x );
+		return vec3( f * cos( t ), f * sin( t ), u );
 
-			float angle1 = anglePerSegment * segment;
-			float angle2 = angle1 + anglePerSegment;
-			vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
-			vec2 b = vec2( 0.0, 0.0 );
-			vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+	}
 
-			return triangleSample( a, b, c );
+	vec2 sampleRegularNGon( int sides, vec3 uvw ) {
 
-		}
+		sides = max( sides, 3 );
+
+		vec3 r = uvw;
+		float anglePerSegment = 2.0 * PI / float( sides );
+		float segment = floor( float( sides ) * r.x );
+
+		float angle1 = anglePerSegment * segment;
+		float angle2 = angle1 + anglePerSegment;
+		vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
+		vec2 b = vec2( 0.0, 0.0 );
+		vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+
+		return sampleTriangle( a, b, c, r.yz );
 
 	}
 
-	float colorToLuminance( vec3 color ) {
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades, vec3 uvw ) {
 
-		// https://en.wikipedia.org/wiki/Relative_luminance
-		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+		return blades == 0 ?
+			sampleCircle( uvw.xy ) :
+			sampleRegularNGon( blades, uvw );
 
 	}
 
@@ -332,6 +272,17 @@ export const shaderUtils = /* glsl */`
 
 	}
 
+	vec2 rotateVector( vec2 v, float t ) {
+
+		float ac = cos( t );
+		float as = sin( t );
+		return vec2(
+			v.x * ac - v.y * as,
+			v.x * as + v.y * ac
+		);
+
+	}
+
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the rectangle on that same plane.
 	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
@@ -400,4 +351,11 @@ export const shaderUtils = /* glsl */`
 
 	}
 
+	// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
+	// erichlof/THREE.js-PathTracing-Renderer/
+	float tentFilter( float x ) {
+
+		return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
+
+	}
 `;

package/src/uniforms/EquirectHdrInfoUniform.js

@@ -3,12 +3,11 @@ import { DataTexture, FloatType, RedFormat, LinearFilter, DataUtils, HalfFloatTy
 function binarySearchFindClosestIndexOf( array, targetValue, offset = 0, count = array.length ) {
 
 	let lower = 0;
-	let upper = count;
+	let upper = count - 1;
 	while ( lower < upper ) {
 
 		const mid = ~ ~ ( 0.5 * upper + 0.5 * lower );
 
-
 		// check if the middle array value is above or below the target and shift
 		// which half of the array we're looking at
 		if ( array[ offset + mid ] < targetValue ) {
@@ -215,12 +214,13 @@ export class EquirectHdrInfoUniform {
 		const marginalDataArray = new Float32Array( height );
 		const conditionalDataArray = new Float32Array( width * height );
 
+		// we add a half texel offset so we're sampling the center of the pixel
 		for ( let i = 0; i < height; i ++ ) {
 
 			const dist = ( i + 1 ) / height;
 			const row = binarySearchFindClosestIndexOf( cdfMarginal, dist );
 
-			marginalDataArray[ i ] = row / height;
+			marginalDataArray[ i ] = ( row + 0.5 ) / height;
 
 		}
 
@@ -232,7 +232,7 @@ export class EquirectHdrInfoUniform {
 				const dist = ( x + 1 ) / width;
 				const col = binarySearchFindClosestIndexOf( cdfConditional, dist, y * width, width );
 
-				conditionalDataArray[ i ] = col / width;
+				conditionalDataArray[ i ] = ( col + 0.5 ) / width;
 
 			}
 

package/src/uniforms/LightsInfoUniformStruct.js

@@ -4,6 +4,8 @@ const LIGHT_PIXELS = 6;
 const RECT_AREA_LIGHT = 0;
 const CIRC_AREA_LIGHT = 1;
 const SPOT_LIGHT = 2;
+const DIR_LIGHT = 3;
+const POINT_LIGHT = 4;
 export class LightsInfoUniformStruct {
 
 	constructor() {
@@ -62,8 +64,24 @@ export class LightsInfoUniformStruct {
 
 			// type
 			let type = RECT_AREA_LIGHT;
-			if ( l.isRectAreaLight && l.isCircular ) type = CIRC_AREA_LIGHT;
-			else if ( l.isSpotLight ) type = SPOT_LIGHT;
+			if ( l.isRectAreaLight && l.isCircular ) {
+
+				type = CIRC_AREA_LIGHT;
+
+			} else if ( l.isSpotLight ) {
+
+				type = SPOT_LIGHT;
+
+			} else if ( l.isDirectionalLight ) {
+
+				type = DIR_LIGHT;
+
+			} else if ( l.isPointLight ) {
+
+				type = POINT_LIGHT;
+
+			}
+
 			floatArray[ baseIndex + ( index ++ ) ] = type;
 
 			// sample 2
@@ -150,6 +168,33 @@ export class LightsInfoUniformStruct {
 				// iesProfile
 				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
 
+			} else if ( l.isPointLight ) {
+
+				const worldPosition = l.getWorldPosition( u );
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.x;
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.y;
+				floatArray[ baseIndex + ( index ++ ) ] = worldPosition.z;
+				index ++;
+
+				// sample 4
+				index += 4;
+
+				// sample 5
+				index += 2;
+
+				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
+				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
+
+			} else if ( l.isDirectionalLight ) {
+
+				const worldPosition = l.getWorldPosition( u );
+				const targetPosition = l.target.getWorldPosition( v );
+
+				target.subVectors( worldPosition, targetPosition ).normalize();
+				floatArray[ baseIndex + ( index ++ ) ] = target.x;
+				floatArray[ baseIndex + ( index ++ ) ] = target.y;
+				floatArray[ baseIndex + ( index ++ ) ] = target.z;
+
 			}
 
 		}

package/src/uniforms/MaterialsTexture.js

@@ -1,5 +1,5 @@
 import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, FrontSide, BackSide, DoubleSide } from 'three';
-import { reduceTexturesToUniqueSources } from './utils.js';
+import { reduceTexturesToUniqueSources, getTextureHash } from './utils.js';
 
 const MATERIAL_PIXELS = 45;
 const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
@@ -61,8 +61,8 @@ export class MaterialsTexture extends DataTexture {
 
 			if ( key in material && material[ key ] ) {
 
-				const source = material[ key ].source;
-				return uniqueTextures.findIndex( tex => tex.source === source );
+				const hash = getTextureHash( material[ key ] );
+				return uniqueTextureLookup[ hash ];
 
 			} else {
 
@@ -152,6 +152,12 @@ export class MaterialsTexture extends DataTexture {
 
 		// get the list of textures with unique sources
 		const uniqueTextures = reduceTexturesToUniqueSources( textures );
+		const uniqueTextureLookup = {};
+		for ( let i = 0, l = uniqueTextures.length; i < l; i ++ ) {
+
+			uniqueTextureLookup[ getTextureHash( uniqueTextures[ i ] ) ] = i;
+
+		}
 
 		if ( image.width !== dimension ) {
 
@@ -183,9 +189,9 @@ export class MaterialsTexture extends DataTexture {
 			// sample 1
 			// metalness & roughness
 			floatArray[ index ++ ] = getField( m, 'metalness', 0.0 );
-			floatArray[ index ++ ] = uniqueTextures.indexOf( m.metalnessMap );
+			floatArray[ index ++ ] = getTexture( m, 'metalnessMap' );
 			floatArray[ index ++ ] = getField( m, 'roughness', 0.0 );
-			floatArray[ index ++ ] = uniqueTextures.indexOf( m.roughnessMap );
+			floatArray[ index ++ ] = getTexture( m, 'roughnessMap' );
 
 			// sample 2
 			// transmission & emissiveIntensity
@@ -363,7 +369,7 @@ export class MaterialsTexture extends DataTexture {
 			// sample 14
 			index ++; // matte
 			index ++; // shadow
-			floatArray[ index ++ ] = Number( m.vertexColors ); // vertexColors
+			floatArray[ index ++ ] = Number( m.vertexColors ) | ( Number( m.flatShading ) << 1 ); // vertexColors & flatShading
 			floatArray[ index ++ ] = Number( m.transparent ); // transparent
 
 			// map transform 15

package/src/uniforms/utils.js

@@ -1,3 +1,11 @@
+// we must hash the texture to determine uniqueness using the encoding, as well, because the
+// when rendering each texture to the texture array they must have a consistent color space.
+export function getTextureHash( t ) {
+
+	return `${ t.source.uuid }:${ t.encoding }`;
+
+}
+
 // reduce the set of textures to just those with a unique source while retaining
 // the order of the textures.
 export function reduceTexturesToUniqueSources( textures ) {
@@ -7,9 +15,10 @@ export function reduceTexturesToUniqueSources( textures ) {
 	for ( let i = 0, l = textures.length; i < l; i ++ ) {
 
 		const tex = textures[ i ];
-		if ( ! sourceSet.has( tex.source ) ) {
+		const hash = getTextureHash( tex );
+		if ( ! sourceSet.has( hash ) ) {
 
-			sourceSet.add( tex.source );
+			sourceSet.add( hash );
 			result.push( tex );
 
 		}