Added the texture filtering for normal maps + the roughness filtering. (DISABLED+UNTESTED)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs

             [SurfaceDataAttributes(new string[]{"Coat Normal", "Coat Normal View Space"}, true)]
             public Vector3 coatNormalWS;
 
+            [SurfaceDataAttributes("Average Normal Length A")]
+            public float averageNormalLengthA;
+
+            [SurfaceDataAttributes("Average Normal Length B")]
+            public float averageNormalLengthB;
+
             [SurfaceDataAttributes("Smoothness A")]
             public float perceptualSmoothnessA;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl

 #define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1308)
 #define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL (1309)
 #define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE (1310)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1311)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1312)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1313)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1314)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1315)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1316)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1317)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS (1318)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1319)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1320)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1321)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1322)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1323)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1324)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_AVERAGE_NORMAL_LENGTH_A (1311)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_AVERAGE_NORMAL_LENGTH_B (1312)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1313)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1314)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1315)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1316)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1317)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1318)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1319)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS (1320)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1321)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1322)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1323)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1324)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1325)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1326)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData:  static fields
     float3 normalWS;
     float3 geomNormalWS;
     float3 coatNormalWS;
+    float averageNormalLengthA;
+    float averageNormalLengthB;
     float perceptualSmoothnessA;
     float perceptualSmoothnessB;
     float lobeMix;
             break;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE:
             result = surfacedata.coatNormalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_AVERAGE_NORMAL_LENGTH_A:
+            result = surfacedata.averageNormalLengthA.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_AVERAGE_NORMAL_LENGTH_B:
+            result = surfacedata.averageNormalLengthB.xxx;
             break;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A:
             result = surfacedata.perceptualSmoothnessA.xxx;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.hlsl

 
     float variance = _SpecularAntiAliasingScreenSpaceVariance * (dot(deltaU, deltaU) + dot(deltaV, deltaV));
 
-    float squaredRoughness = saturate(r * r + min(2.0 * variance, _SpecularAntiAliasingThreshold));
+    return variance;
+}
-    return sqrt(squaredRoughness);
+// Based on The Order : 1886 SIGGRAPH course notes implementation.
+float AdjustRoughness(float avgNormalLength)
+{
+    if (avgNormalLength < 1.0)
+    {
+        float avgNormLen2 = avgNormalLength * avgNormalLength;
+        float kappa = (3 * avgNormalLength - avgNormalLength * avgNormLen2) / (1 - avgNormLen2);
+
+        return 1.0 / (2.0 * kappa);
+    }
+
+    return 0.0f;
+float FilterRoughness(float r, float3 geomNormalWS, float averageNormalLength)
+{
+    // Specular AA: NormalCurvatureToRoughness
+    r = lerp(r, max(NormalCurvatureToRoughness(geomNormalWS), r), _NormalCurvatureToRoughnessEnabled);
+
+    // Specular AA: Tokuyoshi Filtering + 1866 normal filtering.
+    float varianceGeom = FilterRoughness_TOKUYOSHI(geomNormalWS, r);
+    float varianceNorm = AdjustRoughness(averageNormalLength);
+    float filteredRoughness = sqrt(saturate(r * r + min(2.0 * (varianceGeom + varianceNorm), _SpecularAntiAliasingThreshold)));
+
+    return lerp(r, filteredRoughness, _SpecularAntiAliasingEnabled);
+}
 
 //-----------------------------------------------------------------------------
 // conversion function for forward
     bsdfData.perceptualRoughnessA = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothnessA);
     bsdfData.perceptualRoughnessB = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothnessB);
 
-    // Specular AA: NormalCurvatureToRoughness
-    float normalCurvatureToRoughnessA = max(NormalCurvatureToRoughness(bsdfData.normalWS), bsdfData.perceptualRoughnessA);
-    float normalCurvatureToRoughnessB = max(NormalCurvatureToRoughness(bsdfData.normalWS), bsdfData.perceptualRoughnessB);
-    bsdfData.perceptualRoughnessA = lerp(bsdfData.perceptualRoughnessA, normalCurvatureToRoughnessA, _NormalCurvatureToRoughnessEnabled);
-    bsdfData.perceptualRoughnessB = lerp(bsdfData.perceptualRoughnessB, normalCurvatureToRoughnessB, _NormalCurvatureToRoughnessEnabled);
-
-    // Specular AA: Tokuyoshi Filtering.
-    float filterRoughnessA = FilterRoughness_TOKUYOSHI(bsdfData.normalWS, bsdfData.perceptualRoughnessA);
-    float filterRoughnessB = FilterRoughness_TOKUYOSHI(bsdfData.normalWS, bsdfData.perceptualRoughnessB);
-    bsdfData.perceptualRoughnessA = lerp(bsdfData.perceptualRoughnessA, filterRoughnessA, _SpecularAntiAliasingEnabled);
-    bsdfData.perceptualRoughnessB = lerp(bsdfData.perceptualRoughnessB, filterRoughnessB, _SpecularAntiAliasingEnabled);
-
+    // Specular AA / Filtering.
+    bsdfData.perceptualRoughnessA = FilterRoughness(bsdfData.perceptualRoughnessA, bsdfData.geomNormalWS, surfaceData.averageNormalLengthA);
+    bsdfData.perceptualRoughnessB = FilterRoughness(bsdfData.perceptualRoughnessB, bsdfData.geomNormalWS, surfaceData.averageNormalLengthB);
+    
     bsdfData.lobeMix = surfaceData.lobeMix;
 
     // There is no metallic with SSS and specular color mode

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl

 #endif
 }
 
-float3 SampleTexture2DTriplanarNormalScaleBias(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, float textureNameObjSpace, TextureUVMapping uvMapping, float scale)
+float4 SampleTexture2DTriplanarNormalScaleBias(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, float textureNameObjSpace, TextureUVMapping uvMapping, float scale)
 {
     if (textureNameObjSpace)
     {
         // Decompress normal ourselve
         float3 normalOS = SampleTexture2DTriplanarScaleBias(TEXTURE2D_PARAM(textureName, samplerName), textureNameUV, textureNameUVLocal, textureNameST, uvMapping).xyz * 2.0 - 1.0;
         // no need to renormalize normalOS for SurfaceGradientFromPerturbedNormal
-        return SurfaceGradientFromPerturbedNormal(uvMapping.vertexNormalWS, TransformObjectToWorldDir(normalOS));
+        return float4(SurfaceGradientFromPerturbedNormal(uvMapping.vertexNormalWS, TransformObjectToWorldDir(normalOS)), 1.0);
     }
     else
     {
 
             // Assume derivXplane, derivYPlane and derivZPlane sampled using (z,y), (z,x) and (x,y) respectively.
             float3 volumeGrad = float3(derivZPlane.x + derivYPlane.y, derivZPlane.y + derivXplane.y, derivXplane.x + derivYPlane.x);
-            return SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad);
+            return float4(SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad), 1.0);
         }
 #endif
 
         {
-            return SurfaceGradientFromTBN(deriv, uvMapping.vertexTangentWS[textureNameUV], uvMapping.vertexBitangentWS[textureNameUV]);
+            return float4(SurfaceGradientFromTBN(deriv, uvMapping.vertexTangentWS[textureNameUV], uvMapping.vertexBitangentWS[textureNameUV]), 1.0);
         }
         else
         {
             else if (textureNameUV == TEXCOORD_INDEX_PLANAR_XY)
                 volumeGrad = float3(deriv.x, deriv.y, 0.0);
 
-            return SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad);
+            return float4(SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad), 1.0f);
         }
     }
 }
     // Standard
     surfaceData.baseColor = SAMPLE_TEXTURE2D_SCALE_BIAS(_BaseColorMap).rgb * _BaseColor.rgb;
 
-    float3 gradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_NormalMap, _NormalScale);
+    float4 gradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_NormalMap, _NormalScale);
     //TODO: bentNormalTS
 
     surfaceData.perceptualSmoothnessA = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_SmoothnessAMap), _SmoothnessAMapChannelMask);
 #endif
     surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
 
-    float3 coatGradient = float3(0.0, 0.0, 0.0);
+    float4 coatGradient = float4(0.0, 0.0, 0.0, 1.0f);
 #ifdef _MATERIAL_FEATURE_COAT
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_COAT;
     surfaceData.coatPerceptualSmoothness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_CoatSmoothnessMap), _CoatSmoothnessMapChannelMask);
 
     surfaceData.geomNormalWS = input.worldToTangent[2];
     // Convert back to world space normal
-    surfaceData.normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], gradient);
-    surfaceData.coatNormalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], coatGradient);
+    surfaceData.normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], gradient.xyz);
+    surfaceData.coatNormalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], coatGradient.xyz);
+
+    surfaceData.averageNormalLengthA = gradient.w;
+    surfaceData.averageNormalLengthB = coatGradient.w;
 
     // TODO: decal etc.
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/AssetPostProcessors.meta

+fileFormatVersion: 2
+guid: 3505be0d02e25a04f8932a6c2243015b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/AssetPostProcessors/NormalMapVarianceTexturePostprocessor.cs

+using System;
+using UnityEditor;
+using UnityEngine;
+
+public class NormalMapVarianceTexturePostprocessor : AssetPostprocessor
+{
+    void OnPreprocessTexture()
+    {
+        if (assetPath.IndexOf("_variance", StringComparison.InvariantCultureIgnoreCase) != -1)
+        {
+            // Make sure we don't convert as a normal map.
+            TextureImporter textureImporter = (TextureImporter)assetImporter;
+            textureImporter.convertToNormalmap = false;
+            textureImporter.textureCompression = TextureImporterCompression.CompressedHQ;
+
+            textureImporter.linearTexture = true; // Says deprecated but won't work without it.
+            textureImporter.sRGBTexture = false;  // But we're setting the new property just in case it changes later...
+        }
+    }
+
+    private static Color GetColor(Color[] source, int x, int y, int width, int height)
+    {
+        x = (x + width) % width;
+        y = (y + height) % height;
+
+        int index = y * width + x;
+        var c = source[index];
+
+        return c;
+    }
+
+    private static Vector3 GetNormal(Color[] source, int x, int y, int width, int height)
+    {
+        Vector3 n = (Vector4)GetColor(source, x, y, width, height);
+        n = 2.0f * n - Vector3.one;
+        n.Normalize();
+
+        return n;
+    }
+
+    private static Vector3 GetAverageNormal(Color[] source, int x, int y, int width, int height, int texelFootprint)
+    {
+        Vector3 averageNormal = new Vector3(0, 0, 0);
+
+        // Calculate the average color over the texel footprint.
+        for (int i = 0; i < texelFootprint; ++i)
+        {
+            for (int j = 0; j < texelFootprint; ++j)
+            {
+                averageNormal += GetNormal(source, x + i, y + j, width, height);
+            }
+        }
+
+        averageNormal /= (texelFootprint * texelFootprint);
+
+        return averageNormal;
+    }
+
+    void OnPostprocessTexture(Texture2D texture)
+    {
+        if (assetPath.IndexOf("_variance", StringComparison.InvariantCultureIgnoreCase) != -1)
+        {
+            // For mip 0, set the normal length to 1.
+            {
+                Color[] c = texture.GetPixels(0);
+                for (int i = 0; i < c.Length; i++)
+                {
+                    c[i].a = 1.0f;
+                }
+                texture.SetPixels(c, 0);
+            }
+
+            // Based on The Order : 1886 SIGGRAPH course notes implementation. Sample all normal map
+            // texels from the base mip level that are within the footprint of the current mipmap texel.
+            Color[] source = texture.GetPixels(0);
+            for (int m = 1; m < texture.mipmapCount; m++)
+            {
+                Color[] c = texture.GetPixels(m);
+
+                int mipWidth = Math.Max(1, texture.width >> m);
+                int mipHeight = Math.Max(1, texture.height >> m);
+
+                for (int x = 0; x < mipWidth; ++x)
+                {
+                    for (int y = 0; y < mipHeight; ++y)
+                    {
+                        int texelFootprint = 1 << m;
+                        Vector3 averageNormal = GetAverageNormal(source, x * texelFootprint, y * texelFootprint,
+                            texture.width, texture.height, texelFootprint);
+
+                        // Store the normal length for the average normal.
+                        int outputPosition = y * mipWidth + x;
+                        //c[outputPosition].a = averageNormal.magnitude;
+
+                        float normalLength = Math.Max(0.0f, Math.Min(1.0f, averageNormal.magnitude));
+                        c[outputPosition].a = normalLength;
+                    }
+                }
+
+                texture.SetPixels(c, m);
+            }
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/AssetPostProcessors/NormalMapVarianceTexturePostprocessor.cs.meta

+fileFormatVersion: 2
+guid: c7467d803a5cf8c479b64fbdac53aa41
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: