three-gpu-pathtracer 0.0.16 → 0.0.18

package/src/shader/bsdf/bsdfSampling.glsl.js

@@ -80,7 +80,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 	${ iridescenceGLSL }
 
 	// diffuse
-	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// https://schuttejoe.github.io/post/disneybsdf/
 		float fl = schlickFresnel( wi.z, 0.0 );
@@ -94,15 +94,17 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		// TODO: subsurface approx?
 
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		color = ( 1.0 - F ) * transFactor * metalFactor * wi.z * surf.color * ( retro + lambert ) / PI;
+
 		return wi.z / PI;
 
 	}
 
 	vec3 diffuseDirection( vec3 wo, SurfaceRecord surf ) {
 
-		vec3 lightDirection = sampleSphere( sobol2( 11 ) );
+		vec3 lightDirection = sampleSphere( rand2( 11 ) );
 		lightDirection.z += 1.0;
 		lightDirection = normalize( lightDirection );
 
@@ -111,7 +113,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 	}
 
 	// specular
-	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// if roughness is set to 0 then D === NaN which results in black pixels
 		float metalness = surf.metalness;
@@ -147,7 +149,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 12 )
+			rand2( 12 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -158,7 +160,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	// transmission
 	/*
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
 
@@ -184,7 +186,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( filteredRoughness ),
-			sobol2( 13 )
+			rand2( 13 )
 		);
 
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
@@ -201,12 +203,13 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	// TODO: This is just using a basic cosine-weighted specular distribution with an
 	// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		color = surf.transmission * surf.color;
 
 		// PDF
-		float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 		if ( F >= 1.0 ) {
 
 			return 0.0;
@@ -221,7 +224,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		float roughness = surf.filteredRoughness;
 		float eta = surf.eta;
-		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
+		vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( rand2( 13 ) ) * roughness );
 		vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 		if ( surf.thinFilm ) {
@@ -262,7 +265,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 halfVector = ggxDirection(
 			wo,
 			vec2( roughness ),
-			sobol2( 14 )
+			rand2( 14 )
 		);
 
 		// apply to new ray by reflecting off the new normal
@@ -292,12 +295,13 @@ export const bsdfSamplingGLSL = /* glsl */`
 	// bsdf
 	void getLobeWeights(
 		vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRecord surf,
-		out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight
+		inout float diffuseWeight, inout float specularWeight, inout float transmissionWeight, inout float clearcoatWeight
 	) {
 
 		float metalness = surf.metalness;
 		float transmission = surf.transmission;
-		float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		// float fEstimate = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
+		float fEstimate = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
 
 		float transSpecularProb = mix( max( 0.25, fEstimate ), 1.0, metalness );
 		float diffSpecularProb = 0.5 + 0.5 * metalness;
@@ -316,7 +320,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	float bsdfEval(
 		vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRecord surf,
-		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, out float specularPdf, out vec3 color
+		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, inout float specularPdf, inout vec3 color
 	) {
 
 		float metalness = surf.metalness;
@@ -379,7 +383,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	}
 
-	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, out vec3 color ) {
+	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, inout vec3 color ) {
 
 		if ( surf.volumeParticle ) {
 
@@ -413,7 +417,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 			ScatterRecord sampleRec;
 			sampleRec.specularPdf = 0.0;
 			sampleRec.pdf = 1.0 / ( 4.0 * PI );
-			sampleRec.direction = sampleSphere( sobol2( 16 ) );
+			sampleRec.direction = sampleSphere( rand2( 16 ) );
 			sampleRec.color = surf.color / ( 4.0 * PI );
 			return sampleRec;
 
@@ -465,7 +469,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 		vec3 wi;
 		vec3 clearcoatWi;
 
-		float r = sobol( 15 );
+		float r = rand( 15 );
 		if ( r <= cdf[0] ) { // diffuse
 
 			wi = diffuseDirection( wo, surf );

package/src/shader/common/bvhAnyHit.glsl.js

@@ -1,10 +1,10 @@
 export const bvhAnyHitGLSL = /* glsl */`
 
 	bool bvhIntersectAnyHit(
-		BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+		vec3 rayOrigin, vec3 rayDirection,
 
 		// output variables
-		out float side, out float dist
+		inout float side, inout float dist
 	) {
 
 		uvec4 faceIndices;

package/src/shader/common/fresnel.glsl.js

@@ -69,30 +69,36 @@ export const fresnelGLSL = /* glsl */`
 
 	}
 
-	float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
+	// TODO: disney fresnel was removed and replaced with this fresnel function to better align with
+	// the glTF but is causing blown out pixels. Should be revisited
+	// float evaluateFresnelWeight( float cosTheta, float eta, float f0 ) {
 
-		if ( totalInternalReflection( cosTheta, eta ) ) {
+	// 	if ( totalInternalReflection( cosTheta, eta ) ) {
 
-			return 1.0;
+	// 		return 1.0;
 
-		}
+	// 	}
 
-		return schlickFresnel( cosTheta, f0 );
+	// 	return schlickFresnel( cosTheta, f0 );
 
-	}
+	// }
 
-	/*
 	// https://schuttejoe.github.io/post/disneybsdf/
 	float disneyFresnel( vec3 wo, vec3 wi, vec3 wh, float f0, float eta, float metalness ) {
 
 		float dotHV = dot( wo, wh );
-		float dotHL = dot( wi, wh );
+		if ( totalInternalReflection( dotHV, eta ) ) {
 
+			return 1.0;
+
+		}
+
+		float dotHL = dot( wi, wh );
 		float dielectricFresnel = dielectricFresnel( abs( dotHV ), eta );
 		float metallicFresnel = schlickFresnel( dotHL, f0 );
 
 		return mix( dielectricFresnel, metallicFresnel, metalness );
 
 	}
-	*/
+
 `;

package/src/shader/common/intersectShapes.glsl.js

@@ -3,7 +3,7 @@ export const intersectShapesGLSL = /* glsl */`
 	// 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/
-	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -34,7 +34,7 @@ export const intersectShapesGLSL = /* glsl */`
 
 	// 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 circle on that same plane. See above URL for a description of the plane intersection algorithm.
-	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
 

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

@@ -27,28 +27,28 @@ export const pcgGLSL = /* glsl */`
 	}
 
 	// returns [ 0, 1 ]
-	float rand() {
+	float pcgRand() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
 
 	}
 
-	vec2 rand2() {
+	vec2 pcgRand2() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
 
 	}
 
-	vec3 rand3() {
+	vec3 pcgRand3() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
 
 	}
 
-	vec4 rand4() {
+	vec4 pcgRand4() {
 
 		pcg4d( WHITE_NOISE_SEED );
 		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );

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

@@ -214,9 +214,9 @@ export const sobolSamplingGLSL = /* glsl */`
 
 	// Seeds
 	uniform sampler2D sobolTexture;
-	uint sobolPixelIndex;
-	uint sobolPathIndex;
-	uint sobolBounceIndex;
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
 
 	uint sobolGetSeed( uint bounce, uint effect ) {
 

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

@@ -0,0 +1,45 @@
+export const stratifiedTextureGLSL = /* glsl */`
+
+	uniform sampler2D stratifiedTexture;
+	uniform sampler2D stratifiedOffsetTexture;
+
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
+	vec4 pixelSeed = vec4( 0 );
+
+	vec4 rand4( int v ) {
+
+		ivec2 uv = ivec2( v, sobolBounceIndex );
+		vec4 stratifiedSample = texelFetch( stratifiedTexture, uv, 0 );
+		return fract( stratifiedSample + pixelSeed.r ); // blue noise + stratified samples
+
+	}
+
+	vec3 rand3( int v ) {
+
+		return rand4( v ).xyz;
+
+	}
+
+	vec2 rand2( int v ) {
+
+		return rand4( v ).xy;
+
+	}
+
+	float rand( int v ) {
+
+		return rand4( v ).x;
+
+	}
+
+	void rng_initialize( vec2 screenCoord, int frame ) {
+
+		// tile the small noise texture across the entire screen
+		ivec2 noiseSize = ivec2( textureSize( stratifiedOffsetTexture, 0 ) );
+		pixelSeed = texelFetch( stratifiedOffsetTexture, ivec2( screenCoord.xy ) % noiseSize, 0 );
+
+	}
+
+`;

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

@@ -24,14 +24,14 @@ export const equirectSamplingGLSL = /* glsl */`
 	}
 
 	// samples the color given env map with CDF and returns the pdf of the direction
-	float sampleEquirect( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
+	float sampleEquirect( vec3 direction, inout vec3 color ) {
 
 		vec2 uv = equirectDirectionToUv( direction );
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );
@@ -39,20 +39,20 @@ export const equirectSamplingGLSL = /* glsl */`
 	}
 
 	// samples a direction of the envmap with color and retrieves pdf
-	float sampleEquirectProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
+	float sampleEquirectProbability( vec2 r, inout vec3 color, inout 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;
+		float v = texture2D( envMapInfo.marginalWeights, vec2( r.x, 0.0 ) ).x;
+		float u = texture2D( envMapInfo.conditionalWeights, vec2( r.y, v ) ).x;
 		vec2 uv = vec2( u, v );
 
 		vec3 derivedDirection = equirectUvToDirection( uv );
 		direction = derivedDirection;
-		color = texture2D( info.map, uv ).rgb;
+		color = texture2D( envMapInfo.map, uv ).rgb;
 
-		float totalSum = info.totalSum;
+		float totalSum = envMapInfo.totalSum;
 		float lum = luminance( color );
-		ivec2 resolution = textureSize( info.map, 0 );
+		ivec2 resolution = textureSize( envMapInfo.map, 0 );
 		float pdf = lum / totalSum;
 
 		return float( resolution.x * resolution.y ) * pdf * equirectDirectionPdf( direction );

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

@@ -42,24 +42,17 @@ export const lightSamplingGLSL = /* glsl */`
 
 	};
 
-	bool lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection, out LightRecord lightRec ) {
+	bool intersectLightAtIndex( sampler2D lights, vec3 rayOrigin, vec3 rayDirection, uint l, inout LightRecord lightRec ) {
 
 		bool didHit = false;
-		uint l;
-		for ( l = 0u; l < lightCount; l ++ ) {
-
-			Light light = readLightInfo( lights, l );
-
-			vec3 u = light.u;
-			vec3 v = light.v;
-
-			// check for backface
-			vec3 normal = normalize( cross( u, v ) );
-			if ( dot( normal, rayDirection ) < 0.0 ) {
+		Light light = readLightInfo( lights, l );
 
-				continue;
+		vec3 u = light.u;
+		vec3 v = light.v;
 
-			}
+		// check for backface
+		vec3 normal = normalize( cross( u, v ) );
+		if ( dot( normal, rayDirection ) > 0.0 ) {
 
 			u *= 1.0 / dot( u, u );
 			v *= 1.0 / dot( v, v );
@@ -72,17 +65,13 @@ export const lightSamplingGLSL = /* glsl */`
 				( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
 			) {
 
-				if ( ! didHit || dist < lightRec.dist ) {
-
-					float cosTheta = dot( rayDirection, normal );
-					didHit = true;
-					lightRec.dist = dist;
-					lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-					lightRec.emission = light.color * light.intensity;
-					lightRec.direction = rayDirection;
-					lightRec.type = light.type;
-
-				}
+				float cosTheta = dot( rayDirection, normal );
+				didHit = true;
+				lightRec.dist = dist;
+				lightRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+				lightRec.emission = light.color * light.intensity;
+				lightRec.direction = rayDirection;
+				lightRec.type = light.type;
 
 			}
 
@@ -94,11 +83,6 @@ export const lightSamplingGLSL = /* glsl */`
 
 	LightRecord randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
 
-		LightRecord lightRec;
-		lightRec.type = light.type;
-
-		lightRec.emission = light.color * light.intensity;
-
 		vec3 randomPos;
 		if( light.type == RECT_AREA_LIGHT_TYPE ) {
 
@@ -119,12 +103,17 @@ export const lightSamplingGLSL = /* glsl */`
 
 		vec3 toLight = randomPos - rayOrigin;
 		float lightDistSq = dot( toLight, toLight );
-		lightRec.dist = sqrt( lightDistSq );
+		float dist = sqrt( lightDistSq );
+		vec3 direction = toLight / dist;
+		vec3 lightNormal = normalize( cross( light.u, light.v ) );
 
-		vec3 direction = toLight / lightRec.dist;
+		LightRecord lightRec;
+		lightRec.type = light.type;
+		lightRec.emission = light.color * light.intensity;
+		lightRec.dist = dist;
 		lightRec.direction = direction;
 
-		vec3 lightNormal = normalize( cross( light.u, light.v ) );
+		// TODO: the denominator is potentially zero
 		lightRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
 
 		return lightRec;
@@ -172,13 +161,15 @@ export const lightSamplingGLSL = /* glsl */`
 
 	LightRecord randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
 
+		LightRecord result;
+
 		// pick a random light
 		uint l = uint( ruv.x * float( lightCount ) );
 		Light light = readLightInfo( lights, l );
 
 		if ( light.type == SPOT_LIGHT_TYPE ) {
 
-			return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+			result = randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
 
 		} else if ( light.type == POINT_LIGHT_TYPE ) {
 
@@ -198,7 +189,7 @@ export const lightSamplingGLSL = /* glsl */`
 			rec.pdf = 1.0;
 			rec.emission = light.color * light.intensity * distanceFalloff;
 			rec.type = light.type;
-			return rec;
+			result = rec;
 
 		} else if ( light.type == DIR_LIGHT_TYPE ) {
 
@@ -209,15 +200,17 @@ export const lightSamplingGLSL = /* glsl */`
 			rec.emission = light.color * light.intensity;
 			rec.type = light.type;
 
-			return rec;
+			result = rec;
 
 		} else {
 
 			// sample the light
-			return randomAreaLightSample( light, rayOrigin, ruv.yz );
+			result = randomAreaLightSample( light, rayOrigin, ruv.yz );
 
 		}
 
+		return result;
+
 	}
 
 `;

package/src/shader/structs/fogMaterialBvh.glsl.js

@@ -15,9 +15,9 @@ bool isMaterialFogVolume( sampler2D materials, uint materialIndex ) {
 
 // returns true if we're within the first fog volume we hit
 bool bvhIntersectFogVolumeHit(
-	BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+	vec3 rayOrigin, vec3 rayDirection,
 	usampler2D materialIndexAttribute, sampler2D materials,
-	out Material material
+	inout Material material
 ) {
 
 	material.fogVolume = false;

package/src/shader/structs/lightsStruct.glsl.js

@@ -61,13 +61,22 @@ export const lightsStructGLSL = /* glsl */`
 			vec4 s4 = texelFetch1D( tex, i + 4u );
 			vec4 s5 = texelFetch1D( tex, i + 5u );
 			l.radius = s4.r;
-			l.near = s4.g;
-			l.decay = s4.b;
-			l.distance = s4.a;
+			l.decay = s4.g;
+			l.distance = s4.b;
+			l.coneCos = s4.a;
 
-			l.coneCos = s5.r;
-			l.penumbraCos = s5.g;
-			l.iesProfile = int( round ( s5.b ) );
+			l.penumbraCos = s5.r;
+			l.iesProfile = int( round( s5.g ) );
+
+		} else {
+
+			l.radius = 0.0;
+			l.decay = 0.0;
+			l.distance = 0.0;
+
+			l.coneCos = 0.0;
+			l.penumbraCos = 0.0;
+			l.iesProfile = - 1;
 
 		}
 

package/src/shader/structs/materialStruct.glsl.js

@@ -184,21 +184,22 @@ export const materialStructGLSL = /* glsl */ `
 
 		uint firstTextureTransformIdx = i + 15u;
 
-		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx );
-		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
-		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
-		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
-		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
-		m.normalMapTransform = m.normalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
-		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
-		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
-		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
-		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
-		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
-		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
-		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
-		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
-		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
+		// mat3( 1.0 ) is an identity matrix
+		m.mapTransform = m.map == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx );
+		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
+		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
+		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
+		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
+		m.normalMapTransform = m.normalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
+		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
+		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
+		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
+		m.sheenColorMapTransform = m.sheenColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 18u );
+		m.sheenRoughnessMapTransform = m.sheenRoughnessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 20u );
+		m.iridescenceMapTransform = m.iridescenceMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 22u );
+		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
+		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
+		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
 
 		return m;
 

package/src/textures/BlueNoiseTexture.js

@@ -0,0 +1,87 @@
+import { DataTexture, FloatType, NearestFilter, RGBAFormat, RGFormat, RedFormat } from 'three';
+import { BlueNoiseGenerator } from './blueNoise/BlueNoiseGenerator.js';
+
+function getStride( channels ) {
+
+	if ( channels >= 3 ) {
+
+		return 4;
+
+	} else {
+
+		return channels;
+
+	}
+
+}
+
+function getFormat( channels ) {
+
+	switch ( channels ) {
+
+	case 1:
+		return RedFormat;
+	case 2:
+		return RGFormat;
+	default:
+		return RGBAFormat;
+
+	}
+
+}
+
+export class BlueNoiseTexture extends DataTexture {
+
+	constructor( size = 64, channels = 1 ) {
+
+		super( new Float32Array( 4 ), 1, 1, RGBAFormat, FloatType );
+		this.minFilter = NearestFilter;
+		this.magFilter = NearestFilter;
+
+		this.size = size;
+		this.channels = channels;
+		this.update();
+
+	}
+
+	update() {
+
+		const channels = this.channels;
+		const size = this.size;
+		const generator = new BlueNoiseGenerator();
+		generator.channels = channels;
+		generator.size = size;
+
+		const stride = getStride( channels );
+		const format = getFormat( stride );
+		if ( this.image.width !== size || format !== this.format ) {
+
+			this.image.width = size;
+			this.image.height = size;
+			this.image.data = new Float32Array( ( size ** 2 ) * stride );
+			this.format = format;
+			this.dispose();
+
+		}
+
+		const data = this.image.data;
+		for ( let i = 0, l = channels; i < l; i ++ ) {
+
+			const result = generator.generate();
+			const bin = result.data;
+			const maxValue = result.maxValue;
+
+			for ( let j = 0, l2 = bin.length; j < l2; j ++ ) {
+
+				const value = bin[ j ] / maxValue;
+				data[ j * stride + i ] = value;
+
+			}
+
+		}
+
+		this.needsUpdate = true;
+
+	}
+
+}