super-three 0.147.1 → 0.154.0

package/src/renderers/shaders/ShaderChunk/packing.glsl.js

@@ -42,21 +42,27 @@ vec2 unpackRGBATo2Half( vec4 v ) {
 	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
 }
 
-// NOTE: viewZ/eyeZ is < 0 when in front of the camera per OpenGL conventions
+// NOTE: viewZ, the z-coordinate in camera space, is negative for points in front of the camera
 
 float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
+	// -near maps to 0; -far maps to 1
 	return ( viewZ + near ) / ( near - far );
 }
-float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
-	return linearClipZ * ( near - far ) - near;
+
+float orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {
+	// maps orthographic depth in [ 0, 1 ] to viewZ
+	return depth * ( near - far ) - near;
 }
 
 // NOTE: https://twitter.com/gonnavis/status/1377183786949959682
 
 float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
+	// -near maps to 0; -far maps to 1
 	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
 }
-float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
-	return ( near * far ) / ( ( far - near ) * invClipZ - far );
+
+float perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {
+	// maps perspective depth in [ 0, 1 ] to viewZ
+	return ( near * far ) / ( ( far - near ) * depth - far );
 }
 `;

package/src/renderers/shaders/ShaderChunk/roughnessmap_fragment.glsl.js

@@ -3,7 +3,7 @@ float roughnessFactor = roughness;
 
 #ifdef USE_ROUGHNESSMAP
 
-	vec4 texelRoughness = texture2D( roughnessMap, vUv );
+	vec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );
 
 	// reads channel G, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
 	roughnessFactor *= texelRoughness.g;

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl.js

@@ -1,13 +1,13 @@
 export default /* glsl */`
 #if NUM_SPOT_LIGHT_COORDS > 0
 
-  varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
+	varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
 
 #endif
 
 #if NUM_SPOT_LIGHT_MAPS > 0
 
-  uniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];
+	uniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];
 
 #endif
 
@@ -110,15 +110,8 @@ export default /* glsl */`
 		shadowCoord.xyz /= shadowCoord.w;
 		shadowCoord.z += shadowBias;
 
-		// if ( something && something ) breaks ATI OpenGL shader compiler
-		// if ( all( something, something ) ) using this instead
-
-		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
-		bool inFrustum = all( inFrustumVec );
-
-		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
-
-		bool frustumTest = all( frustumTestVec );
+		bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;
+		bool frustumTest = inFrustum && shadowCoord.z <= 1.0;
 
 		if ( frustumTest ) {
 

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl.js

@@ -2,8 +2,8 @@ export default /* glsl */`
 
 #if NUM_SPOT_LIGHT_COORDS > 0
 
-  uniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];
-  varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
+	uniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];
+	varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
 
 #endif
 

package/src/renderers/shaders/ShaderChunk/shadowmap_vertex.glsl.js

@@ -1,53 +1,38 @@
 export default /* glsl */`
-#if defined( USE_SHADOWMAP ) || ( NUM_SPOT_LIGHT_COORDS > 0 )
 
-	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_COORDS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
+#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )
 
-		// Offsetting the position used for querying occlusion along the world normal can be used to reduce shadow acne.
-		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
-		vec4 shadowWorldPosition;
+	// Offsetting the position used for querying occlusion along the world normal can be used to reduce shadow acne.
+	vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
+	vec4 shadowWorldPosition;
 
-	#endif
-
-	#if NUM_DIR_LIGHT_SHADOWS > 0
-
-	#pragma unroll_loop_start
-	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
-
-		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
-		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
-
-	}
-	#pragma unroll_loop_end
+#endif
 
-	#endif
+#if defined( USE_SHADOWMAP )
 
-	#if NUM_SPOT_LIGHT_COORDS > 0
+	#if NUM_DIR_LIGHT_SHADOWS > 0
 
-	#pragma unroll_loop_start
-	for ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
 
-		shadowWorldPosition = worldPosition;
-		#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
-			shadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;
-		#endif
-		vSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;
+			shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
+			vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
 
-	}
-	#pragma unroll_loop_end
+		}
+		#pragma unroll_loop_end
 
 	#endif
 
 	#if NUM_POINT_LIGHT_SHADOWS > 0
 
-	#pragma unroll_loop_start
-	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
 
-		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
-		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
+			shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
+			vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
 
-	}
-	#pragma unroll_loop_end
+		}
+		#pragma unroll_loop_end
 
 	#endif
 
@@ -60,4 +45,24 @@ export default /* glsl */`
 	*/
 
 #endif
+
+// spot lights can be evaluated without active shadow mapping (when SpotLight.map is used)
+
+#if NUM_SPOT_LIGHT_COORDS > 0
+
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {
+
+		shadowWorldPosition = worldPosition;
+		#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+			shadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;
+		#endif
+		vSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;
+
+	}
+	#pragma unroll_loop_end
+
+#endif
+
+
 `;

package/src/renderers/shaders/ShaderChunk/specularmap_fragment.glsl.js

@@ -3,7 +3,7 @@ float specularStrength;
 
 #ifdef USE_SPECULARMAP
 
-	vec4 texelSpecular = texture2D( specularMap, vUv );
+	vec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );
 	specularStrength = texelSpecular.r;
 
 #else

package/src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl.js

@@ -9,7 +9,7 @@ uniform float toneMappingExposure;
 // exposure only
 vec3 LinearToneMapping( vec3 color ) {
 
-	return toneMappingExposure * color;
+	return saturate( toneMappingExposure * color );
 
 }
 

package/src/renderers/shaders/ShaderChunk/transmission_fragment.glsl.js

@@ -9,13 +9,13 @@ export default /* glsl */`
 
 	#ifdef USE_TRANSMISSIONMAP
 
-		material.transmission *= texture2D( transmissionMap, vUv ).r;
+		material.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;
 
 	#endif
 
 	#ifdef USE_THICKNESSMAP
 
-		material.thickness *= texture2D( thicknessMap, vUv ).g;
+		material.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;
 
 	#endif
 
@@ -23,14 +23,14 @@ export default /* glsl */`
 	vec3 v = normalize( cameraPosition - pos );
 	vec3 n = inverseTransformDirection( normal, viewMatrix );
 
-	vec4 transmission = getIBLVolumeRefraction(
+	vec4 transmitted = getIBLVolumeRefraction(
 		n, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
 		pos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,
 		material.attenuationColor, material.attenuationDistance );
 
-	material.transmissionAlpha = mix( material.transmissionAlpha, transmission.a, material.transmission );
+	material.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );
 
-	totalDiffuse = mix( totalDiffuse, transmission.rgb, material.transmission );
+	totalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );
 
 #endif
 `;

package/src/renderers/shaders/ShaderChunk/transmission_pars_fragment.glsl.js

@@ -29,6 +29,95 @@ export default /* glsl */`
 
 	varying vec3 vWorldPosition;
 
+	// Mipped Bicubic Texture Filtering by N8
+	// https://www.shadertoy.com/view/Dl2SDW
+
+	float w0( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );
+
+	}
+
+	float w1( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );
+
+	}
+
+	float w2( float a ){
+
+		return ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );
+
+	}
+
+	float w3( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a * a * a );
+
+	}
+
+	// g0 and g1 are the two amplitude functions
+	float g0( float a ) {
+
+		return w0( a ) + w1( a );
+
+	}
+
+	float g1( float a ) {
+
+		return w2( a ) + w3( a );
+
+	}
+
+	// h0 and h1 are the two offset functions
+	float h0( float a ) {
+
+		return - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );
+
+	}
+
+	float h1( float a ) {
+
+		return 1.0 + w3( a ) / ( w2( a ) + w3( a ) );
+
+	}
+
+	vec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {
+
+		uv = uv * texelSize.zw + 0.5;
+
+		vec2 iuv = floor( uv );
+		vec2 fuv = fract( uv );
+
+		float g0x = g0( fuv.x );
+		float g1x = g1( fuv.x );
+		float h0x = h0( fuv.x );
+		float h1x = h1( fuv.x );
+		float h0y = h0( fuv.y );
+		float h1y = h1( fuv.y );
+
+		vec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+		vec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+		vec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+		vec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+
+		return g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +
+			g1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );
+
+	}
+
+	vec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {
+
+		vec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );
+		vec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );
+		vec2 fLodSizeInv = 1.0 / fLodSize;
+		vec2 cLodSizeInv = 1.0 / cLodSize;
+		vec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );
+		vec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );
+		return mix( fSample, cSample, fract( lod ) );
+
+	}
+
 	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
 
 		// Direction of refracted light.
@@ -55,33 +144,24 @@ export default /* glsl */`
 
 	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
 
-		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
-
-		#ifdef texture2DLodEXT
-
-			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
-
-		#else
-
-			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
-
-		#endif
+		float lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
+		return textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );
 
 	}
 
-	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
+	vec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
 
 		if ( isinf( attenuationDistance ) ) {
 
 			// Attenuation distance is +∞, i.e. the transmitted color is not attenuated at all.
-			return radiance;
+			return vec3( 1.0 );
 
 		} else {
 
 			// Compute light attenuation using Beer's law.
 			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
 			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); // Beer's law
-			return transmittance * radiance;
+			return transmittance;
 
 		}
 
@@ -104,12 +184,17 @@ export default /* glsl */`
 		// Sample framebuffer to get pixel the refracted ray hits.
 		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
 
-		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
+		vec3 transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );
+		vec3 attenuatedColor = transmittance * transmittedLight.rgb;
 
 		// Get the specular component.
 		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
 
-		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
+		// As less light is transmitted, the opacity should be increased. This simple approximation does a decent job 
+		// of modulating a CSS background, and has no effect when the buffer is opaque, due to a solid object or clear color.
+		float transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;
+
+		return vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );
 
 	}
 #endif

package/src/renderers/shaders/ShaderChunk/uv_pars_fragment.glsl.js

@@ -1,7 +1,119 @@
 export default /* glsl */`
-#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
+#if defined( USE_UV ) || defined( USE_ANISOTROPY )
 
 	varying vec2 vUv;
 
+#endif
+#ifdef USE_MAP
+
+	varying vec2 vMapUv;
+
+#endif
+#ifdef USE_ALPHAMAP
+
+	varying vec2 vAlphaMapUv;
+
+#endif
+#ifdef USE_LIGHTMAP
+
+	varying vec2 vLightMapUv;
+
+#endif
+#ifdef USE_AOMAP
+
+	varying vec2 vAoMapUv;
+
+#endif
+#ifdef USE_BUMPMAP
+
+	varying vec2 vBumpMapUv;
+
+#endif
+#ifdef USE_NORMALMAP
+
+	varying vec2 vNormalMapUv;
+
+#endif
+#ifdef USE_EMISSIVEMAP
+
+	varying vec2 vEmissiveMapUv;
+
+#endif
+#ifdef USE_METALNESSMAP
+
+	varying vec2 vMetalnessMapUv;
+
+#endif
+#ifdef USE_ROUGHNESSMAP
+
+	varying vec2 vRoughnessMapUv;
+
+#endif
+#ifdef USE_ANISOTROPYMAP
+
+	varying vec2 vAnisotropyMapUv;
+
+#endif
+#ifdef USE_CLEARCOATMAP
+
+	varying vec2 vClearcoatMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	varying vec2 vClearcoatNormalMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	varying vec2 vClearcoatRoughnessMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCEMAP
+
+	varying vec2 vIridescenceMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+
+	varying vec2 vIridescenceThicknessMapUv;
+
+#endif
+#ifdef USE_SHEEN_COLORMAP
+
+	varying vec2 vSheenColorMapUv;
+
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+
+	varying vec2 vSheenRoughnessMapUv;
+
+#endif
+#ifdef USE_SPECULARMAP
+
+	varying vec2 vSpecularMapUv;
+
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+
+	varying vec2 vSpecularColorMapUv;
+
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+
+	varying vec2 vSpecularIntensityMapUv;
+
+#endif
+#ifdef USE_TRANSMISSIONMAP
+
+	uniform mat3 transmissionMapTransform;
+	varying vec2 vTransmissionMapUv;
+
+#endif
+#ifdef USE_THICKNESSMAP
+
+	uniform mat3 thicknessMapTransform;
+	varying vec2 vThicknessMapUv;
+
 #endif
 `;

package/src/renderers/shaders/ShaderChunk/uv_pars_vertex.glsl.js

@@ -1,17 +1,145 @@
 export default /* glsl */`
-#ifdef USE_UV
+#if defined( USE_UV ) || defined( USE_ANISOTROPY )
 
-	#ifdef UVS_VERTEX_ONLY
+	varying vec2 vUv;
 
-		vec2 vUv;
+#endif
+#ifdef USE_MAP
+
+	uniform mat3 mapTransform;
+	varying vec2 vMapUv;
+
+#endif
+#ifdef USE_ALPHAMAP
+
+	uniform mat3 alphaMapTransform;
+	varying vec2 vAlphaMapUv;
+
+#endif
+#ifdef USE_LIGHTMAP
+
+	uniform mat3 lightMapTransform;
+	varying vec2 vLightMapUv;
+
+#endif
+#ifdef USE_AOMAP
+
+	uniform mat3 aoMapTransform;
+	varying vec2 vAoMapUv;
+
+#endif
+#ifdef USE_BUMPMAP
+
+	uniform mat3 bumpMapTransform;
+	varying vec2 vBumpMapUv;
+
+#endif
+#ifdef USE_NORMALMAP
+
+	uniform mat3 normalMapTransform;
+	varying vec2 vNormalMapUv;
+
+#endif
+#ifdef USE_DISPLACEMENTMAP
+
+	uniform mat3 displacementMapTransform;
+	varying vec2 vDisplacementMapUv;
+
+#endif
+#ifdef USE_EMISSIVEMAP
+
+	uniform mat3 emissiveMapTransform;
+	varying vec2 vEmissiveMapUv;
+
+#endif
+#ifdef USE_METALNESSMAP
+
+	uniform mat3 metalnessMapTransform;
+	varying vec2 vMetalnessMapUv;
+
+#endif
+#ifdef USE_ROUGHNESSMAP
+
+	uniform mat3 roughnessMapTransform;
+	varying vec2 vRoughnessMapUv;
+
+#endif
+#ifdef USE_ANISOTROPYMAP
+
+	uniform mat3 anisotropyMapTransform;
+	varying vec2 vAnisotropyMapUv;
 
-	#else
+#endif
+#ifdef USE_CLEARCOATMAP
+
+	uniform mat3 clearcoatMapTransform;
+	varying vec2 vClearcoatMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	uniform mat3 clearcoatNormalMapTransform;
+	varying vec2 vClearcoatNormalMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	uniform mat3 clearcoatRoughnessMapTransform;
+	varying vec2 vClearcoatRoughnessMapUv;
+
+#endif
+#ifdef USE_SHEEN_COLORMAP
+
+	uniform mat3 sheenColorMapTransform;
+	varying vec2 vSheenColorMapUv;
+
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+
+	uniform mat3 sheenRoughnessMapTransform;
+	varying vec2 vSheenRoughnessMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCEMAP
 
-		varying vec2 vUv;
+	uniform mat3 iridescenceMapTransform;
+	varying vec2 vIridescenceMapUv;
 
-	#endif
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+
+	uniform mat3 iridescenceThicknessMapTransform;
+	varying vec2 vIridescenceThicknessMapUv;
+
+#endif
+#ifdef USE_SPECULARMAP
+
+	uniform mat3 specularMapTransform;
+	varying vec2 vSpecularMapUv;
+
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+
+	uniform mat3 specularColorMapTransform;
+	varying vec2 vSpecularColorMapUv;
+
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+
+	uniform mat3 specularIntensityMapTransform;
+	varying vec2 vSpecularIntensityMapUv;
+
+#endif
+#ifdef USE_TRANSMISSIONMAP
+
+	uniform mat3 transmissionMapTransform;
+	varying vec2 vTransmissionMapUv;
+
+#endif
+#ifdef USE_THICKNESSMAP
 
-	uniform mat3 uvTransform;
+	uniform mat3 thicknessMapTransform;
+	varying vec2 vThicknessMapUv;
 
 #endif
 `;