Set the default anisotropy direction along the tangent

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/Lit.hlsl

         preLightData.TdotV = dot(bsdfData.tangentWS, V);
         preLightData.BdotV = dot(bsdfData.bitangentWS, V);
         preLightData.anisoGGXLambdaV = GetSmithJointGGXAnisoLambdaV(preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
-        iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.normalWS, bsdfData.tangentWS, V, bsdfData.anisotropy);
+        // Tangent = highlight stretch (anisotropy) direction. Bitangent = grain (brush) direction.
+        iblNormalWS = GetAnisotropicModifiedNormal(bsdfData.bitangentWS, bsdfData.normalWS, V, bsdfData.anisotropy);
         
         // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NDotV) and use iblNormalWS
         // into function like GetSpecularDominantDir(). However modified normal is just a hack. The goal is just to stretch a cubemap, no accuracy here.

Assets/ScriptableRenderLoop/ShaderLibrary/CommonMaterial.hlsl

 // Convert anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction) to roughness
 void ConvertAnisotropyToRoughness(float roughness, float anisotropy, out float roughnessT, out float roughnessB)
 {
+	// (0 <= anisotropy <= 1), therefore (0 <= anisoAspect <= 1)
+	// The 0.9 factor limits the aspect ratio to 10:1.
-    roughnessT = roughness * anisoAspect;
-    roughnessB = roughness / anisoAspect;
+
+    roughnessT = roughness / anisoAspect; // Distort along tangent (rougher)
+    roughnessB = roughness * anisoAspect; // Straighten along bitangent (smoother)
-// Fake anisotropic by distorting the normal as suggested by:
-// anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction)
-float3 GetAnisotropicModifiedNormal(float3 N, float3 T, float3 V, float anisotropy)
+// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to the normal.
+// The returned normal is NOT normalized.
+float3 ComputeGrainNormal(float3 grainDir, float3 V)
-    float3 anisoT = cross(-V, T);
-    float3 anisoN = cross(anisoT, T);
+	float3 B = cross(-V, grainDir);
+	return cross(B, grainDir);
+}
-    return normalize(lerp(N, anisoN, anisotropy));
+// Fake anisotropic by distorting the normal.
+// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to N.
+// Anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction)
+float3 GetAnisotropicModifiedNormal(float3 grainDir, float3 N, float3 V, float anisotropy)
+{
+	float3 grainNormal = ComputeGrainNormal(grainDir, V);
+	// TODO: test whether normalizing 'grainNormal' is worth it.
+	return normalize(lerp(N, grainNormal, anisotropy));
 }
 
 //-----------------------------------------------------------------------------