Merge remote-tracking branch 'refs/remotes/origin/master' into Update-SSS-and-transmission

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/PSSL.hlsl

 #define INTRINSIC_MINMAX3
 #define Min3 min3
 #define Max3 max3
-//#define INTRINSIC_CUBEMAP_FACE_ID // Must investigate why AMD reference implementation is different than ours
+#define INTRINSIC_CUBEMAP_FACE_ID
 
 #define UNITY_UV_STARTS_AT_TOP 1
 #define UNITY_REVERSED_Z 1

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 #define CUBEMAPFACE_NEGATIVE_Z 5
 
 #ifndef INTRINSIC_CUBEMAP_FACE_ID
-// TODO: implement this. Is the reference implementation of cubemapID provide by AMD the reverse of our ?
-/*
-float CubemapFaceID(float3 dir)
+float CubeMapFaceID(float3 dir)
+
-        faceID = (dir.z < 0.0) ? 5.0 : 4.0;
+        faceID = (dir.z < 0.0) ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
-        faceID = (dir.y < 0.0) ? 3.0 : 2.0;
+        faceID = (dir.y < 0.0) ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
-        faceID = (dir.x < 0.0) ? 1.0 : 0.0;
+        faceID = (dir.x < 0.0) ? CUBEMAPFACE_NEGATIVE_X : CUBEMAPFACE_POSITIVE_X;
-    return faceID;
-}
-*/
-void GetCubeFaceID(float3 dir, out int faceIndex)
-{
-    // TODO: Use faceID intrinsic on console
-    float3 adir = abs(dir);
-
-    // +Z -Z
-    faceIndex = dir.z > 0.0 ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
-
-    // +X -X
-    if (adir.x > adir.y && adir.x > adir.z)
-    {
-        faceIndex = dir.x > 0.0 ? CUBEMAPFACE_NEGATIVE_X : CUBEMAPFACE_POSITIVE_X;
-    }
-    // +Y -Y
-    else if (adir.y > adir.x && adir.y > adir.z)
-    {
-        faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
-    }
+    return faceID;
-
 #endif // INTRINSIC_CUBEMAP_FACE_ID
 
 // ----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

 }
 
 // Ref: "Moving Frostbite to PBR", p. 69.
-real3 GetSpecularDominantDir(real3 N, real3 R, real roughness, real NdotV)
+real3 GetSpecularDominantDir(real3 N, real3 R, real perceptualRoughness, real NdotV)
-    real a = 1.0 - roughness;
+    real p = perceptualRoughness;
+    real a = 1.0 - p * p;
-    real lerpFactor = (s + roughness) * a;
+    real lerpFactor = (s + p * p) * a;
-    real lerpFactor = (s + roughness) * saturate(a * a + lerp(0.0, a, NdotV * NdotV));
+    real lerpFactor = (s + p * p) * saturate(a * a + lerp(0.0, a, NdotV * NdotV));
 #endif
 
     // The result is not normalized as we fetch in a cubemap
 // To simulate the streching of highlight at grazing angle for IBL we shrink the roughness
 // which allow to fake an anisotropic specular lobe.
 // Ref: http://www.frostbite.com/2015/08/stochastic-screen-space-reflections/ - slide 84
-real AnisotropicStrechAtGrazingAngle(real roughness, real perceptualRoughness, real NdotV)
+real AnisotropicStrechAtGrazingAngle(real perceptualRoughness, real NdotV)
-    return roughness * lerp(saturate(NdotV * 2.0), 1.0, perceptualRoughness);
+    real p = perceptualRoughness;
+    return p * lerp(saturate(NdotV * 2.0) * p, p, p);
 }
 
 // ----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 	return uint2( (posTC * sd.scaleOffset.xy + sd.scaleOffset.zw) * sd.textureSize.xy );
 }
 
-int EvalShadow_GetCubeFaceID( real3 dir )
+int EvalShadow_GetCubeFaceID( real3 sampleToLight )
-	// TODO: Use faceID intrinsic on console
+	real3 lightToSample = -sampleToLight; // TODO: pass the correct (flipped) direction
+
+#ifdef INTRINSIC_CUBEMAP_FACE_ID
+	return (int)CubeMapFaceID(lightToSample);
+#else
+	// TODO: use CubeMapFaceID() defined in Common.hlsl for all pipelines on all platforms.
+	real3 dir  = sampleToLight;
 	real3 adir = abs(dir);
 
 	// +Z -Z
 		faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
 	}
 	return faceIndex;
+#endif
 }
 
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     // 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));
-    float iblRoughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness);
-    preLightData.iblR = GetSpecularDominantDir(N, iblR, iblRoughness, NdotV);
+    preLightData.iblR = GetSpecularDominantDir(N, iblR, preLightData.iblPerceptualRoughness, NdotV);
 
 #ifdef LIT_USE_GGX_ENERGY_COMPENSATION
     // Ref: Practical multiple scattering compensation for microfacet models.