(PR #2) Adds specular lighting based on the directionality of the baked lightmap lighting.

(PR #2) Derives the correct, but un-normalized light direction vector from the lightmap.
(PR #2) Adds extra debug functions, and remapping functions.
(PR #2) Decreases smoothness of materials in the non-directional light, to simulate specular scattering.
(PR #2) Add warning about extra texture fetch.

(PR #3) Fix up shadergraph lit shader to populate the lightmap direction vector.

Author: Kleptine

com.unity.render-pipelines.core/ShaderLibrary/Debug.hlsl

@@ -276,4 +276,104 @@ real3 GetColorCodeFunction(real value, real4 threshold)
     return outColor;
 }
 
+// Maps a value within the range to the range of colors in a heatmap.
+// 3 color bands: Red, Black, Green
+half4 HeatMapColorRedBlackGreen(half value, half minValue, half maxValue)
+{
+    #define HEATMAP_COLORS_COUNT 3
+    half4 colors[HEATMAP_COLORS_COUNT] =
+    {
+        // min value of the range
+        //half4(0.32, 0.00, 0.32, 1.00),
+        //half4(0.00, 0.00, 1.00, 1.00),
+        //half4(0.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 0.60, 0.00, 1.00),
+        //half4(1.00, 0.00, 0.00, 1.00),
+        half4(1, 0, 0, 1),
+        half4(0, 0, 0, 1),
+        half4(0, 1, 0, 1)
+        // max value of the range
+    };
+    half ratio=(HEATMAP_COLORS_COUNT-1.0)*saturate((value-minValue)/(maxValue-minValue));
+    half indexMin=floor(ratio);
+    half indexMax=min(indexMin+1,HEATMAP_COLORS_COUNT-1);
+
+    return lerp(colors[indexMin], colors[indexMax], ratio-indexMin);
+}
+
+// Maps a value within the range to the range of colors in a heatmap.
+// 3 color bands: Red, Black, White
+half4 HeatMapColorRedBlackWhite(half value, half minValue, half maxValue)
+{
+    #define HEATMAP_COLORS_COUNT 3
+    half4 colors[HEATMAP_COLORS_COUNT] =
+    {
+        // min value of the range
+        //half4(0.32, 0.00, 0.32, 1.00),
+        //half4(0.00, 0.00, 1.00, 1.00),
+        //half4(0.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 0.60, 0.00, 1.00),
+        //half4(1.00, 0.00, 0.00, 1.00),
+        half4(1, 0, 0, 1),
+        half4(0, 0, 0, 1),
+        half4(1, 1, 1, 1)
+        // max value of the range
+    };
+    half ratio=(HEATMAP_COLORS_COUNT-1.0)*saturate((value-minValue)/(maxValue-minValue));
+    half indexMin=floor(ratio);
+    half indexMax=min(indexMin+1,HEATMAP_COLORS_COUNT-1);
+
+    return lerp(colors[indexMin], colors[indexMax], ratio-indexMin);
+}
+
+// Maps a value within the range to the range of colors in a heatmap.
+// 2 color bands: Red, Black, White
+half4 HeatMapColorBlackWhite(half value, half minValue, half maxValue)
+{
+    #define HEATMAP_COLORS_COUNT 2
+    half4 colors[HEATMAP_COLORS_COUNT] =
+    {
+        // min value of the range
+        //half4(0.32, 0.00, 0.32, 1.00),
+        //half4(0.00, 0.00, 1.00, 1.00),
+        //half4(0.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 1.00, 0.00, 1.00),
+        //half4(1.00, 0.60, 0.00, 1.00),
+        //half4(1.00, 0.00, 0.00, 1.00),
+        half4(0, 0, 0, 1),
+        half4(1, 1, 1, 1)
+        // max value of the range
+    };
+    half ratio=(HEATMAP_COLORS_COUNT-1.0)*saturate((value-minValue)/(maxValue-minValue));
+    half indexMin=floor(ratio);
+    half indexMax=min(indexMin+1,HEATMAP_COLORS_COUNT-1);
+
+    return lerp(colors[indexMin], colors[indexMax], ratio-indexMin);
+}
+
+// Maps a value within the range to the range of colors in a heatmap.
+// 6 color bands
+half4 HeatMapColorMulticolor(half value, half minValue, half maxValue)
+{
+    #define HEATMAP_COLORS_COUNT 6
+    half4 colors[HEATMAP_COLORS_COUNT] =
+    {
+        // min value of the range
+        half4(0.32, 0.00, 0.32, 1.00),
+        half4(0.00, 0.00, 1.00, 1.00),
+        half4(0.00, 1.00, 0.00, 1.00),
+        half4(1.00, 1.00, 0.00, 1.00),
+        half4(1.00, 0.60, 0.00, 1.00),
+        half4(1.00, 0.00, 0.00, 1.00),
+        // max value of the range
+    };
+    half ratio=(HEATMAP_COLORS_COUNT-1.0)*saturate((value-minValue)/(maxValue-minValue));
+    half indexMin=floor(ratio);
+    half indexMax=min(indexMin+1,HEATMAP_COLORS_COUNT-1);
+
+    return lerp(colors[indexMin], colors[indexMax], ratio-indexMin);
+}
+
 #endif // UNITY_DEBUG_INCLUDED

com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/PBRForwardPass.hlsl

@@ -47,6 +47,22 @@ void BuildInputData(Varyings input, float3 normal, out InputData inputData)
     inputData.fogCoord = input.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.sh, inputData.normalWS);
+
+#ifdef LIGHTMAP_ON
+    half2 uv = input.lightmapUV;
+
+    // TODO(fixforship): This adds an *additional* unnecessary texture fetch to the shader. We're already sampling
+    // the directional lightmap in the SAMPLE_GI function, so we should sample it first, and feed it
+    // in, instead.
+    real4 direction_raw = SAMPLE_TEXTURE2D(unity_LightmapInd, samplerunity_Lightmap, uv);
+    half3 direction = (direction_raw.xyz - 0.5) * 2; // convert from [0,1] to [-1,1]
+    inputData.bakedGI_directionWS = direction;
+
+#else // LIGHTMAP_ON
+
+    inputData.bakedGI_directionWS = half3(0,0,0);
+
+#endif
 }
 
 PackedVaryings vert(Attributes input)

com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl

@@ -22,6 +22,7 @@ struct InputData
     half    fogCoord;
     half3   vertexLighting;
     half3   bakedGI;
+    half3   bakedGI_directionWS; // XYZ: Light direction, length is 'directionality'
 };
 
 ///////////////////////////////////////////////////////////////////////////////

com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl

@@ -510,15 +510,12 @@ half3 SubtractDirectMainLightFromLightmap(Light mainLight, half3 normalWS, half3
     return min(bakedGI, realtimeShadow);
 }
 
-half3 GlobalIllumination(BRDFData brdfData, half3 bakedGI, half occlusion, half3 normalWS, half3 viewDirectionWS)
+// (ASG) Calculates the GI by treating GI as simply another light source we pass into the DirectBRDF.
+// This gives us nice specular contribution from the baked lights! Very helpful in VR for making an object appear grounded.
+half3 GlobalIllumination(BRDFData brdfData, half3 bakedGI, half3 bakedGIDirectionWS, half occlusion, half3 normalWS, half3 viewDirectionWS)
 {
-    half3 reflectVector = reflect(-viewDirectionWS, normalWS);
-    half fresnelTerm = Pow4(1.0 - saturate(dot(normalWS, viewDirectionWS)));
-
     half3 indirectDiffuse = bakedGI * occlusion;
-    half3 indirectSpecular = GlossyEnvironmentReflection(reflectVector, brdfData.perceptualRoughness, occlusion);
-
-    return EnvironmentBRDF(brdfData, indirectDiffuse, indirectSpecular, fresnelTerm);
+    return DirectBDRF(brdfData, normalWS, bakedGIDirectionWS, viewDirectionWS) * indirectDiffuse;
 }
 
 void MixRealtimeAndBakedGI(inout Light light, half3 normalWS, inout half3 bakedGI, half4 shadowMask)
@@ -582,13 +579,28 @@ half3 VertexLighting(float3 positionWS, half3 normalWS)
 half4 UniversalFragmentPBR(InputData inputData, half3 albedo, half metallic, half3 specular,
     half smoothness, half occlusion, half3 emission, half alpha)
 {
+    // Decreases smoothness as the directionality of the light decreases. This approximates the specular highlight
+    // spreading and scattering, as the light becomes less directional. Without this, even shadowed areas look shiny.
+    // This is recommended by: https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/gdc2018-precomputedgiobalilluminationinfrostbite.pdf
+    // Although, here we do not apply the sqrt to the falloff. Instead we square it, which seems to produce a closer image to the blender groundtruth.
+    // The range remap makes sure that surfaces in perfectly direct light (directionality > .9) remain their true specular (directionality rarely reaches a perfect 1).
+    // See this Github discussion for more information: https://github.com/AStrangerGravity/Graphics/pull/2#discussion_r459731172
+
+    // Worth optimizing more if we become ALU bound. Just make sure to do a before/after.
+    // This smoothness falloff has been carefully tested to look good compared to the Blender render.
+    half physicalSmoothness = 1 - PerceptualSmoothnessToRoughness(smoothness);
+    half directionality_squared = dot(inputData.bakedGI_directionWS, inputData.bakedGI_directionWS); // The directionality is encoded as the length of the GI direction vector.
+    half adjustedSmoothness = physicalSmoothness * RangeRemap(0.0, .9 * .9, directionality_squared);
+    half perceptualAdjustedSmoothness = 1 - RoughnessToPerceptualRoughness(1 - adjustedSmoothness);
+
     BRDFData brdfData;
-    InitializeBRDFData(albedo, metallic, specular, smoothness, alpha, brdfData);
-    
+    InitializeBRDFData(albedo, metallic, specular, perceptualAdjustedSmoothness, alpha, brdfData);
+
     Light mainLight = GetMainLight(inputData.shadowCoord);
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
 
-    half3 color = GlobalIllumination(brdfData, inputData.bakedGI, occlusion, inputData.normalWS, inputData.viewDirectionWS);
+    half3 giDirectionWS = SafeNormalize(inputData.bakedGI_directionWS);
+    half3 color = GlobalIllumination(brdfData, inputData.bakedGI, giDirectionWS, occlusion, inputData.normalWS, inputData.viewDirectionWS);
     color += LightingPhysicallyBased(brdfData, mainLight, inputData.normalWS, inputData.viewDirectionWS);
 
 #ifdef _ADDITIONAL_LIGHTS

com.unity.render-pipelines.universal/Shaders/LitForwardPass.hlsl

@@ -74,7 +74,26 @@ void InitializeInputData(Varyings input, half3 normalTS, out InputData inputData
 
     inputData.fogCoord = input.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
+
     inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.vertexSH, inputData.normalWS);
+
+    // Get the direction of the lightmap lighting (scale is equal to the 'directionality')
+    #ifdef LIGHTMAP_ON
+
+    half2 uv = input.lightmapUV;
+
+    // TODO(fixforship): This adds an *additional* unnecessary texture fetch to the shader. We're already sampling
+    // the directional lightmap in the SAMPLE_GI function, so we should sample it first, and feed it
+    // in, instead.
+    real4 direction_raw = SAMPLE_TEXTURE2D(unity_LightmapInd, samplerunity_Lightmap, uv);
+    half3 direction = (direction_raw.xyz - 0.5) * 2; // convert from [0,1] to [-1,1]
+    inputData.bakedGI_directionWS = direction;
+
+    #else // LIGHTMAP_ON
+
+    inputData.bakedGI_directionWS = half3(0,0,0);
+
+    #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////

com.unity.render-pipelines.universal/Shaders/Nature/SpeedTree7CommonPasses.hlsl

@@ -86,6 +86,7 @@ void InitializeInputData(SpeedTreeVertexOutput input, half3 normalTS, out InputD
     inputData.fogCoord = input.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = half3(0, 0, 0); // No GI currently.
+    inputData.bakedGI_directionWS = half3(0,0,0);
 }
 
 half4 SpeedTree7Frag(SpeedTreeVertexOutput input) : SV_Target

com.unity.render-pipelines.universal/Shaders/Nature/SpeedTree8Passes.hlsl

@@ -295,6 +295,7 @@ void InitializeInputData(SpeedTreeFragmentInput input, half3 normalTS, out Input
     inputData.fogCoord = input.interpolated.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.interpolated.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = half3(0, 0, 0); // No GI currently.
+    inputData.bakedGI_directionWS = half3(0,0,0);
 }
 
 half4 SpeedTree8Frag(SpeedTreeFragmentInput input) : SV_Target

com.unity.render-pipelines.universal/Shaders/SimpleLitForwardPass.hlsl

@@ -69,6 +69,7 @@ void InitializeInputData(Varyings input, half3 normalTS, out InputData inputData
     inputData.fogCoord = input.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.vertexSH, inputData.normalWS);
+    inputData.bakedGI_directionWS = half3(0,0,0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

com.unity.render-pipelines.universal/Shaders/Terrain/WavingGrassPasses.hlsl

@@ -59,6 +59,7 @@ void InitializeInputData(GrassVertexOutput input, out InputData inputData)
     inputData.fogCoord = input.fogFactorAndVertexLight.x;
     inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.vertexSH, inputData.normalWS);
+    inputData.bakedGI_directionWS = half3(0,0,0);
 }
 
 void InitializeVertData(GrassVertexInput input, inout GrassVertexOutput vertData)