@needle-tools/three 0.146.10 → 0.153.0

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

@@ -13,20 +13,20 @@ material.roughness = min( material.roughness, 1.0 );
 
 	material.ior = ior;
 
-	#ifdef SPECULAR
+	#ifdef USE_SPECULAR
 
 		float specularIntensityFactor = specularIntensity;
 		vec3 specularColorFactor = specularColor;
 
-		#ifdef USE_SPECULARINTENSITYMAP
+		#ifdef USE_SPECULAR_COLORMAP
 
-			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
+			specularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;
 
 		#endif
 
-		#ifdef USE_SPECULARCOLORMAP
+		#ifdef USE_SPECULAR_INTENSITYMAP
 
-			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
+			specularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;
 
 		#endif
 
@@ -58,13 +58,13 @@ material.roughness = min( material.roughness, 1.0 );
 
 	#ifdef USE_CLEARCOATMAP
 
-		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
+		material.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;
 
 	#endif
 
 	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
 
-		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
+		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;
 
 	#endif
 
@@ -82,13 +82,13 @@ material.roughness = min( material.roughness, 1.0 );
 
 	#ifdef USE_IRIDESCENCEMAP
 
-		material.iridescence *= texture2D( iridescenceMap, vUv ).r;
+		material.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;
 
 	#endif
 
 	#ifdef USE_IRIDESCENCE_THICKNESSMAP
 
-		material.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vUv ).g + iridescenceThicknessMinimum;
+		material.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;
 
 	#else
 
@@ -102,19 +102,45 @@ material.roughness = min( material.roughness, 1.0 );
 
 	material.sheenColor = sheenColor;
 
-	#ifdef USE_SHEENCOLORMAP
+	#ifdef USE_SHEEN_COLORMAP
 
-		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
+		material.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;
 
 	#endif
 
 	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
 
-	#ifdef USE_SHEENROUGHNESSMAP
+	#ifdef USE_SHEEN_ROUGHNESSMAP
 
-		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
+		material.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;
 
 	#endif
 
+#endif
+
+#ifdef USE_ANISOTROPY
+
+	#ifdef USE_ANISOTROPYMAP
+
+		mat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );
+		vec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;
+		vec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;
+
+	#else
+
+		vec2 anisotropyV = anisotropyVector;
+
+	#endif
+
+	material.anisotropy = length( anisotropyV );
+	anisotropyV /= material.anisotropy;
+	material.anisotropy = saturate( material.anisotropy );
+
+	// Roughness along the anisotropy bitangent is the material roughness, while the tangent roughness increases with anisotropy.
+	material.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );
+
+	material.anisotropyT = tbn[ 0 ] * anisotropyV.x - tbn[ 1 ] * anisotropyV.y;
+	material.anisotropyB = tbn[ 1 ] * anisotropyV.x + tbn[ 0 ] * anisotropyV.y;
+
 #endif
 `;

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

@@ -1,4 +1,5 @@
 export default /* glsl */`
+
 struct PhysicalMaterial {
 
 	vec3 diffuseColor;
@@ -38,12 +39,315 @@ struct PhysicalMaterial {
 		vec3 attenuationColor;
 	#endif
 
+	#ifdef USE_ANISOTROPY
+		float anisotropy;
+		float alphaT;
+		vec3 anisotropyT;
+		vec3 anisotropyB;
+	#endif
+
 };
 
 // temporary
 vec3 clearcoatSpecular = vec3( 0.0 );
 vec3 sheenSpecular = vec3( 0.0 );
 
+vec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {
+    float x = clamp( 1.0 - dotVH, 0.0, 1.0 );
+    float x2 = x * x;
+    float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );
+
+    return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );
+}
+
+// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
+// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
+
+	float a2 = pow2( alpha );
+
+	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
+	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
+
+	return 0.5 / max( gv + gl, EPSILON );
+
+}
+
+// Microfacet Models for Refraction through Rough Surfaces - equation (33)
+// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+// alpha is "roughness squared" in Disney’s reparameterization
+float D_GGX( const in float alpha, const in float dotNH ) {
+
+	float a2 = pow2( alpha );
+
+	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0; // avoid alpha = 0 with dotNH = 1
+
+	return RECIPROCAL_PI * a2 / pow2( denom );
+
+}
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
+#ifdef USE_ANISOTROPY
+
+	float V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {
+
+		float gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );
+		float gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );
+		float v = 0.5 / ( gv + gl );
+
+		return saturate(v);
+
+	}
+
+	float D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {
+
+		float a2 = alphaT * alphaB;
+		highp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );
+		highp float v2 = dot( v, v );
+		float w2 = a2 / v2;
+
+		return RECIPROCAL_PI * a2 * pow2 ( w2 );
+
+	}
+
+#endif
+
+#ifdef USE_CLEARCOAT
+
+	// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
+	vec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {
+
+		vec3 f0 = material.clearcoatF0;
+		float f90 = material.clearcoatF90;
+		float roughness = material.clearcoatRoughness;
+
+		float alpha = pow2( roughness ); // UE4's roughness
+
+		vec3 halfDir = normalize( lightDir + viewDir );
+
+		float dotNL = saturate( dot( normal, lightDir ) );
+		float dotNV = saturate( dot( normal, viewDir ) );
+		float dotNH = saturate( dot( normal, halfDir ) );
+		float dotVH = saturate( dot( viewDir, halfDir ) );
+
+		vec3 F = F_Schlick( f0, f90, dotVH );
+
+		float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+
+		float D = D_GGX( alpha, dotNH );
+
+		return F * ( V * D );
+
+	}
+
+#endif
+
+vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {
+
+	vec3 f0 = material.specularColor;
+	float f90 = material.specularF90;
+	float roughness = material.roughness;
+
+	float alpha = pow2( roughness ); // UE4's roughness
+
+	vec3 halfDir = normalize( lightDir + viewDir );
+
+	float dotNL = saturate( dot( normal, lightDir ) );
+	float dotNV = saturate( dot( normal, viewDir ) );
+	float dotNH = saturate( dot( normal, halfDir ) );
+	float dotVH = saturate( dot( viewDir, halfDir ) );
+
+	vec3 F = F_Schlick( f0, f90, dotVH );
+
+	#ifdef USE_IRIDESCENCE
+
+		F = mix( F, material.iridescenceFresnel, material.iridescence );
+
+	#endif
+
+	#ifdef USE_ANISOTROPY
+
+		float dotTL = dot( material.anisotropyT, lightDir );
+		float dotTV = dot( material.anisotropyT, viewDir );
+		float dotTH = dot( material.anisotropyT, halfDir );
+		float dotBL = dot( material.anisotropyB, lightDir );
+		float dotBV = dot( material.anisotropyB, viewDir );
+		float dotBH = dot( material.anisotropyB, halfDir );
+
+		float V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
+
+		float D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );
+
+	#else
+
+		float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+
+		float D = D_GGX( alpha, dotNH );
+
+	#endif
+
+	return F * ( V * D );
+
+}
+
+// Rect Area Light
+
+// Real-Time Polygonal-Light Shading with Linearly Transformed Cosines
+// by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
+// code: https://github.com/selfshadow/ltc_code/
+
+vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
+
+	const float LUT_SIZE = 64.0;
+	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
+	const float LUT_BIAS = 0.5 / LUT_SIZE;
+
+	float dotNV = saturate( dot( N, V ) );
+
+	// texture parameterized by sqrt( GGX alpha ) and sqrt( 1 - cos( theta ) )
+	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
+
+	uv = uv * LUT_SCALE + LUT_BIAS;
+
+	return uv;
+
+}
+
+float LTC_ClippedSphereFormFactor( const in vec3 f ) {
+
+	// Real-Time Area Lighting: a Journey from Research to Production (p.102)
+	// An approximation of the form factor of a horizon-clipped rectangle.
+
+	float l = length( f );
+
+	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
+
+}
+
+vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
+
+	float x = dot( v1, v2 );
+
+	float y = abs( x );
+
+	// rational polynomial approximation to theta / sin( theta ) / 2PI
+	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
+	float b = 3.4175940 + ( 4.1616724 + y ) * y;
+	float v = a / b;
+
+	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
+
+	return cross( v1, v2 ) * theta_sintheta;
+
+}
+
+vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
+
+	// bail if point is on back side of plane of light
+	// assumes ccw winding order of light vertices
+	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
+	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
+	vec3 lightNormal = cross( v1, v2 );
+
+	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
+
+	// construct orthonormal basis around N
+	vec3 T1, T2;
+	T1 = normalize( V - N * dot( V, N ) );
+	T2 = - cross( N, T1 ); // negated from paper; possibly due to a different handedness of world coordinate system
+
+	// compute transform
+	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
+
+	// transform rect
+	vec3 coords[ 4 ];
+	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
+	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
+	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
+	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
+
+	// project rect onto sphere
+	coords[ 0 ] = normalize( coords[ 0 ] );
+	coords[ 1 ] = normalize( coords[ 1 ] );
+	coords[ 2 ] = normalize( coords[ 2 ] );
+	coords[ 3 ] = normalize( coords[ 3 ] );
+
+	// calculate vector form factor
+	vec3 vectorFormFactor = vec3( 0.0 );
+	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
+	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
+	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
+	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
+
+	// adjust for horizon clipping
+	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
+
+/*
+	// alternate method of adjusting for horizon clipping (see referece)
+	// refactoring required
+	float len = length( vectorFormFactor );
+	float z = vectorFormFactor.z / len;
+
+	const float LUT_SIZE = 64.0;
+	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
+	const float LUT_BIAS = 0.5 / LUT_SIZE;
+
+	// tabulated horizon-clipped sphere, apparently...
+	vec2 uv = vec2( z * 0.5 + 0.5, len );
+	uv = uv * LUT_SCALE + LUT_BIAS;
+
+	float scale = texture2D( ltc_2, uv ).w;
+
+	float result = len * scale;
+*/
+
+	return vec3( result );
+
+}
+
+// End Rect Area Light
+
+#if defined( USE_SHEEN )
+
+// https://github.com/google/filament/blob/master/shaders/src/brdf.fs
+float D_Charlie( float roughness, float dotNH ) {
+
+	float alpha = pow2( roughness );
+
+	// Estevez and Kulla 2017, "Production Friendly Microfacet Sheen BRDF"
+	float invAlpha = 1.0 / alpha;
+	float cos2h = dotNH * dotNH;
+	float sin2h = max( 1.0 - cos2h, 0.0078125 ); // 2^(-14/2), so sin2h^2 > 0 in fp16
+
+	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
+
+}
+
+// https://github.com/google/filament/blob/master/shaders/src/brdf.fs
+float V_Neubelt( float dotNV, float dotNL ) {
+
+	// Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
+	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
+
+}
+
+vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
+
+	vec3 halfDir = normalize( lightDir + viewDir );
+
+	float dotNL = saturate( dot( normal, lightDir ) );
+	float dotNV = saturate( dot( normal, viewDir ) );
+	float dotNH = saturate( dot( normal, halfDir ) );
+
+	float D = D_Charlie( sheenRoughness, dotNH );
+	float V = V_Neubelt( dotNV, dotNL );
+
+	return sheenColor * ( D * V );
+
+}
+
+#endif
+
 // This is a curve-fit approxmation to the "Charlie sheen" BRDF integrated over the hemisphere from 
 // Estevez and Kulla 2017, "Production Friendly Microfacet Sheen BRDF". The analysis can be found
 // in the Sheen section of https://drive.google.com/file/d/1T0D1VSyR4AllqIJTQAraEIzjlb5h4FKH/view?usp=sharing
@@ -181,7 +485,7 @@ void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricC
 
 		vec3 ccIrradiance = dotNLcc * directLight.color;
 
-		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
+		clearcoatSpecular += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material );
 
 	#endif
 
@@ -191,15 +495,7 @@ void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricC
 
 	#endif
 
-	#ifdef USE_IRIDESCENCE
-
-		reflectedLight.directSpecular += irradiance * BRDF_GGX_Iridescence( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness );
-
-	#else
-
-		reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
-
-	#endif
+	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material );
 
 	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
 }

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

@@ -2,19 +2,11 @@ export default /* glsl */`
 #ifdef USE_MAP
 
 #ifdef USE_MIPMAP_BIAS
-        vec4 sampledDiffuseColor = texture2D( map, vUv, mipmapBias );
+    vec4 sampledDiffuseColor = texture2D( map, vMapUv, mipmapBias );
 #else
-		vec4 sampledDiffuseColor = texture2D( map, vUv, -0.5 );
+	vec4 sampledDiffuseColor = texture2D( map, vMapUv );
 #endif
 
-	#ifdef DECODE_VIDEO_TEXTURE
-
-		// inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved)
-
-		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
-
-	#endif
-
 	diffuseColor *= sampledDiffuseColor;
 
 #endif

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

@@ -1,7 +1,15 @@
 export default /* glsl */`
 #if defined( USE_MAP ) || defined( USE_ALPHAMAP )
 
-	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
+	#if defined( USE_POINTS_UV )
+
+		vec2 uv = vUv;
+
+	#else
+
+		vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
+
+	#endif
 
 #endif
 

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

@@ -1,7 +1,15 @@
 export default /* glsl */`
-#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+#if defined( USE_POINTS_UV )
 
-	uniform mat3 uvTransform;
+	varying vec2 vUv;
+
+#else
+
+	#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+
+		uniform mat3 uvTransform;
+
+	#endif
 
 #endif
 

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

@@ -3,7 +3,7 @@ float metalnessFactor = metalness;
 
 #ifdef USE_METALNESSMAP
 
-	vec4 texelMetalness = texture2D( metalnessMap, vUv );
+	vec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );
 
 	// reads channel B, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
 	metalnessFactor *= texelMetalness.b;

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

@@ -13,27 +13,49 @@ float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
 
 	#ifdef DOUBLE_SIDED
 
-		normal = normal * faceDirection;
+		normal *= faceDirection;
 
 	#endif
 
+#endif
+
+#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )
+
 	#ifdef USE_TANGENT
 
-		vec3 tangent = normalize( vTangent );
-		vec3 bitangent = normalize( vBitangent );
+		mat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
 
-		#ifdef DOUBLE_SIDED
+	#else
 
-			tangent = tangent * faceDirection;
-			bitangent = bitangent * faceDirection;
+		mat3 tbn = getTangentFrame( - vViewPosition, normal, vNormalMapUv );
+
+	#endif
 
-		#endif
+	#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
 
-		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
+		tbn[0] *= faceDirection;
+		tbn[1] *= faceDirection;
+
+	#endif
+
+#endif
+
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	#ifdef USE_TANGENT
+
+		mat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
+
+	#else
+
+		mat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );
+
+	#endif
 
-			mat3 vTBN = mat3( tangent, bitangent, normal );
+	#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
 
-		#endif
+		tbn2[0] *= faceDirection;
+		tbn2[1] *= faceDirection;
 
 	#endif
 

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

@@ -1,8 +1,8 @@
 export default /* glsl */`
 
-#ifdef OBJECTSPACE_NORMALMAP
+#ifdef USE_NORMALMAP_OBJECTSPACE
 
-	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0; // overrides both flatShading and attribute normals
+	normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0; // overrides both flatShading and attribute normals
 
 	#ifdef FLIP_SIDED
 
@@ -18,20 +18,12 @@ export default /* glsl */`
 
 	normal = normalize( normalMatrix * normal );
 
-#elif defined( TANGENTSPACE_NORMALMAP )
+#elif defined( USE_NORMALMAP_TANGENTSPACE )
 
-	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
+	vec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;
 	mapN.xy *= normalScale;
 
-	#ifdef USE_TANGENT
-
-		normal = normalize( vTBN * mapN );
-
-	#else
-
-		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
-
-	#endif
+	normal = normalize( tbn * mapN );
 
 #elif defined( USE_BUMPMAP )
 

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

@@ -6,23 +6,23 @@ export default /* glsl */`
 
 #endif
 
-#ifdef OBJECTSPACE_NORMALMAP
+#ifdef USE_NORMALMAP_OBJECTSPACE
 
 	uniform mat3 normalMatrix;
 
 #endif
 
-#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
+#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )
 
 	// Normal Mapping Without Precomputed Tangents
 	// http://www.thetenthplanet.de/archives/1180
 
-	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
+	mat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {
 
 		vec3 q0 = dFdx( eye_pos.xyz );
 		vec3 q1 = dFdy( eye_pos.xyz );
-		vec2 st0 = dFdx( vUv.st );
-		vec2 st1 = dFdy( vUv.st );
+		vec2 st0 = dFdx( uv.st );
+		vec2 st1 = dFdy( uv.st );
 
 		vec3 N = surf_norm; // normalized
 
@@ -33,9 +33,9 @@ export default /* glsl */`
 		vec3 B = q1perp * st0.y + q0perp * st1.y;
 
 		float det = max( dot( T, T ), dot( B, B ) );
-		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
+		float scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );
 
-		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
+		return mat3( T * scale, B * scale, N );
 
 	}
 

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

@@ -3,9 +3,8 @@ export default /* glsl */`
 diffuseColor.a = 1.0;
 #endif
 
-// https://github.com/mrdoob/three.js/pull/22425
 #ifdef USE_TRANSMISSION
-diffuseColor.a *= material.transmissionAlpha + 0.1;
+diffuseColor.a *= material.transmissionAlpha;
 #endif
 
 gl_FragColor = vec4( outgoingLight, diffuseColor.a );