HDRP: Factor anisotropy code

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

     return normalize(lerp(N, grainNormal, anisotropy));
 }
 
+// For GGX aniso and IBL we have done an empirical (eye balled) approximation compare to the reference.
+// We use a single fetch, and we stretch the normal to use based on various criteria.
+// result are far away from the reference but better than nothing
+// Anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction) - positive use bitangentWS - negative use tangentWS
+// Note: returned iblPerceptualRoughness shouldn't be use for sampling FGD texture in a pre-integration
+void GetGGXAnisotropicModifiedNormalAndRoughness(real3 bitangentWS, real3 tangentWS, real3 N, real3 V, real anisotropy, real perceptualRoughness, out real3 iblN, out real iblPerceptualRoughness)
+{
+    // For positive anisotropy values: tangent = highlight stretch (anisotropy) direction, bitangent = grain (brush) direction.
+    float3 grainDirWS = (anisotropy >= 0.0) ? bitangentWS : tangentWS;
+    // Reduce stretching for (perceptualRoughness < 0.2).
+    float stretch = abs(anisotropy) * saturate(5.0 * perceptualRoughness);
+    // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV)
+    // However modified normal is just a hack. The goal is just to stretch a cubemap, no accuracy here. Let's save performance instead.
+    iblN = GetAnisotropicModifiedNormal(grainDirWS, N, V, stretch);
+    iblPerceptualRoughness = perceptualRoughness * saturate(1.2 - abs(anisotropy));
+}
+
 // Ref: "Moving Frostbite to PBR", p. 69.
 real3 GetSpecularDominantDir(real3 N, real3 R, real perceptualRoughness, real NdotV)
 {

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

         preLightData.coatIblF = F_Schlick(CLEAR_COAT_F0, NdotV) * bsdfData.coatMask;
     }
 
+    // Handle IBL + area light + multiscattering.
+    // Note: use the not modified by anisotropy iblPerceptualRoughness here.
+    float specularReflectivity;
+    GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, specularReflectivity);
+#ifdef USE_DIFFUSE_LAMBERT_BRDF
+    preLightData.diffuseFGD = 1.0;
+#endif
+
+#ifdef LIT_USE_GGX_ENERGY_COMPENSATION
+    // Ref: Practical multiple scattering compensation for microfacet models.
+    // We only apply the formulation for metals.
+    // For dielectrics, the change of reflectance is negligible.
+    // We deem the intensity difference of a couple of percent for high values of roughness
+    // to not be worth the cost of another precomputed table.
+    // Note: this formulation bakes the BSDF non-symmetric!
+    preLightData.energyCompensation = 1.0 / specularReflectivity - 1.0;
+#else
+    preLightData.energyCompensation = 0.0;
+#endif // LIT_USE_GGX_ENERGY_COMPENSATION
+
     float3 iblN;
 
     // We avoid divergent evaluation of the GGX, as that nearly doubles the cost.
 
         preLightData.partLambdaV = GetSmithJointGGXAnisoPartLambdaV(TdotV, BdotV, NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
 
-        // For GGX aniso and IBL we have done an empirical (eye balled) approximation compare to the reference.
-        // We use a single fetch, and we stretch the normal to use based on various criteria.
-        // result are far away from the reference but better than nothing
-        // For positive anisotropy values: tangent = highlight stretch (anisotropy) direction, bitangent = grain (brush) direction.
-        float3 grainDirWS = (bsdfData.anisotropy >= 0.0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
-        // Reduce stretching for (perceptualRoughness < 0.2).
-        float stretch = abs(bsdfData.anisotropy) * saturate(5 * preLightData.iblPerceptualRoughness);
-        // NOTE: If we follow the theory we should use the modified normal for the different calculation implying a normal (like NdotV) and use 'anisoIblNormalWS'
-        // into function like GetSpecularDominantDir(). However modified normal is just a hack. The goal is just to stretch a cubemap, no accuracy here.
-        // With this in mind and for performance reasons we chose to only use modified normal to calculate R.
-        iblN = GetAnisotropicModifiedNormal(grainDirWS, N, V, stretch);
+        // perceptualRoughness is use as input and output here
+        GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, bsdfData.anisotropy, preLightData.iblPerceptualRoughness, iblN, preLightData.iblPerceptualRoughness);
     }
     else
     {
 
-    // IBL
-
-    // Handle IBL +  multiscattering. Note FGD texture is also use for area light
-    float specularReflectivity;
-    GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, specularReflectivity);
-#ifdef USE_DIFFUSE_LAMBERT_BRDF
-    preLightData.diffuseFGD = 1.0;
-#endif
-
-    // This is a ad-hoc tweak to better match reference of anisotropic GGX.
-    // TODO: We need a better hack.
-    preLightData.iblPerceptualRoughness *= saturate(1.2 - abs(bsdfData.anisotropy));
-
-#ifdef LIT_USE_GGX_ENERGY_COMPENSATION
-    // Ref: Practical multiple scattering compensation for microfacet models.
-    // We only apply the formulation for metals.
-    // For dielectrics, the change of reflectance is negligible.
-    // We deem the intensity difference of a couple of percent for high values of roughness
-    // to not be worth the cost of another precomputed table.
-    // Note: this formulation bakes the BSDF non-symmetric!
-    preLightData.energyCompensation = 1.0 / specularReflectivity - 1.0;
-#else
-    preLightData.energyCompensation = 0.0;
-#endif // LIT_USE_GGX_ENERGY_COMPENSATION
 
     // Area light
     // UVs for sampling the LUTs

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.hlsl

         // Otherwise, the calculation of these is done for each light
         //
 
+        // Handle IBL + area light + multiscattering.
+        // Note: use the not modified by anisotropy iblPerceptualRoughness here.
+
+        // Here, we will fetch our actual FGD terms, see ComputeAdding for details: the F0 params
+        // will be replaced by our energy coefficients. Note that the way to do it depends on the
+        // formulation of ComputeAdding (with FGD fetches or only Fresnel terms).
+
+        // Also note that while the fetch directions for the light samples (IBL) are the ones
+        // at the top interface, for the FGD terms (in fact, for all angle dependent BSDF
+        // parametrization data), we need to use the actual interface angle a propagated direction
+        // would have. So, for the base layer, this is a refracted direction through the coat.
+        // Same for the top, but this is just NdotV.
+        // This is because we should really have fetched FGD with the tracked cti (cos theta incoming)
+        // at the bottom layer or top layer during ComputeAdding itself. We delayed the fetch after,
+        // because our ComputeAdding formulation is with "energy" coefficients calculated with a
+        // chain of Fresnel terms instead of a correct chain computed with the true FGD.
+
+        float baseLayerNdotV = PreLightData_GetBaseNdotVForFGD(bsdfData, preLightData, NdotV);
+
+
+        float diffuseFGDTmp; // unused, for coat layer FGD fetch
+
+        GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV[COAT_NORMAL_IDX],
+            preLightData.iblPerceptualRoughness[COAT_LOBE_IDX],
+            preLightData.vLayerEnergyCoeff[TOP_VLAYER_IDX],
+            preLightData.specularFGD[COAT_LOBE_IDX],
+            diffuseFGDTmp,
+            specularReflectivity[COAT_LOBE_IDX]);
+
+        GetPreIntegratedFGDGGXAndDisneyDiffuse(baseLayerNdotV,
+            preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX],
+            preLightData.vLayerEnergyCoeff[BOTTOM_VLAYER_IDX],
+            preLightData.specularFGD[BASE_LOBEA_IDX],
+            diffuseFGD[0],
+            specularReflectivity[BASE_LOBEA_IDX]);
+
+        GetPreIntegratedFGDGGXAndDisneyDiffuse(baseLayerNdotV,
+            preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX],
+            preLightData.vLayerEnergyCoeff[BOTTOM_VLAYER_IDX],
+            preLightData.specularFGD[BASE_LOBEB_IDX],
+            diffuseFGD[1],
+            specularReflectivity[BASE_LOBEB_IDX]);
+
         if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_STACK_LIT_ANISOTROPY))
         {
             // Note: there's no anisotropy possible on coat.
             preLightData.TdotV = TdotV;
             preLightData.BdotV = BdotV;
 #endif
-            // For GGX aniso and IBL we have done an empirical (eye balled) approximation compare to the reference.
-            // We use a single fetch, and we stretch the normal to use based on various criteria.
-            // result are far away from the reference but better than nothing
-            // For positive anisotropy values: tangent = highlight stretch (anisotropy) direction, bitangent = grain (brush) direction.
-            float3 grainDirWS[2];
-            //grainDirWS[0] = (bsdfData.anisotropy >= 0.0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
-            grainDirWS[0] = (preLightData.iblAnisotropy[0] >= 0.0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
-            grainDirWS[1] = (preLightData.iblAnisotropy[1] >= 0.0) ? bsdfData.bitangentWS : bsdfData.tangentWS;
-
-            // Reduce stretching for (perceptualRoughness < 0.2).
-            float stretch[2];
-            stretch[0] = abs(preLightData.iblAnisotropy[0]) * saturate(5 * preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX]);
-            stretch[1] = abs(preLightData.iblAnisotropy[1]) * saturate(5 * preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX]);
+ 
+            // perceptualRoughness is use as input and output here
+            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, preLightData.iblAnisotropy[0], preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX], iblN[BASE_LOBEA_IDX], preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX]);
+            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, preLightData.iblAnisotropy[1], preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX], iblN[BASE_LOBEB_IDX], preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX]);
-            iblN[BASE_LOBEA_IDX] = GetAnisotropicModifiedNormal(grainDirWS[0], N[BASE_NORMAL_IDX], V, stretch[0]);
-            iblN[BASE_LOBEB_IDX] = GetAnisotropicModifiedNormal(grainDirWS[1], N[BASE_NORMAL_IDX], V, stretch[1]);
-
         }
         else
         {
         // IBL
         // Handle IBL pre calculated data + GGX multiscattering energy loss compensation term
 
-        // Here, we will fetch our actual FGD terms, see ComputeAdding for details: the F0 params
-        // will be replaced by our energy coefficients. Note that the way to do it depends on the
-        // formulation of ComputeAdding (with FGD fetches or only Fresnel terms).
-
-        // Also note that while the fetch directions for the light samples (IBL) are the ones
-        // at the top interface, for the FGD terms (in fact, for all angle dependent BSDF
-        // parametrization data), we need to use the actual interface angle a propagated direction
-        // would have. So, for the base layer, this is a refracted direction through the coat.
-        // Same for the top, but this is just NdotV.
-        // This is because we should really have fetched FGD with the tracked cti (cos theta incoming)
-        // at the bottom layer or top layer during ComputeAdding itself. We delayed the fetch after,
-        // because our ComputeAdding formulation is with "energy" coefficients calculated with a
-        // chain of Fresnel terms instead of a correct chain computed with the true FGD.
-
-        float baseLayerNdotV = PreLightData_GetBaseNdotVForFGD(bsdfData, preLightData, NdotV);
-
-
-        float diffuseFGDTmp; // unused, for coat layer FGD fetch
-
-        GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV[COAT_NORMAL_IDX],
-                                               preLightData.iblPerceptualRoughness[COAT_LOBE_IDX],
-                                               preLightData.vLayerEnergyCoeff[TOP_VLAYER_IDX],
-                                               preLightData.specularFGD[COAT_LOBE_IDX],
-                                               diffuseFGDTmp,
-                                               specularReflectivity[COAT_LOBE_IDX]);
-
-        GetPreIntegratedFGDGGXAndDisneyDiffuse(baseLayerNdotV,
-                                               preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX],
-                                               preLightData.vLayerEnergyCoeff[BOTTOM_VLAYER_IDX],
-                                               preLightData.specularFGD[BASE_LOBEA_IDX],
-                                               diffuseFGD[0],
-                                               specularReflectivity[BASE_LOBEA_IDX]);
-
-        GetPreIntegratedFGDGGXAndDisneyDiffuse(baseLayerNdotV,
-                                               preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX],
-                                               preLightData.vLayerEnergyCoeff[BOTTOM_VLAYER_IDX],
-                                               preLightData.specularFGD[BASE_LOBEB_IDX],
-                                               diffuseFGD[1],
-                                               specularReflectivity[BASE_LOBEB_IDX]);
-
-        // This is a ad-hoc tweak to better match reference of anisotropic GGX.
-        // TODO: We need a better hack.
-        preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX] *= saturate(1.2 - abs(preLightData.iblAnisotropy[0]));
-        preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX] *= saturate(1.2 - abs(preLightData.iblAnisotropy[1]));
 
         // Correction of reflected direction for better handling of rough material