Merge remote-tracking branch 'refs/remotes/origin/master' into Update-material-features-performance-

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Color.hlsl

 // Gamma22
 real Gamma22ToLinear(real c)
 {
-    return pow(c, 2.2);
+    return PositivePow(c, 2.2);
-    return pow(c.rgb, real3(2.2, 2.2, 2.2));
+    return PositivePow(c.rgb, real3(2.2, 2.2, 2.2));
 }
 
 real4 Gamma22ToLinear(real4 c)
 
 real LinearToGamma22(real c)
 {
-    return pow(c, 0.454545454545455);
+    return PositivePow(c, 0.454545454545455);
-    return pow(c.rgb, real3(0.454545454545455, 0.454545454545455, 0.454545454545455));
+    return PositivePow(c.rgb, real3(0.454545454545455, 0.454545454545455, 0.454545454545455));
 }
 
 real4 LinearToGamma22(real4 c)
 real3 SRGBToLinear(real3 c)
 {
     real3 linearRGBLo  = c / 12.92;
-    real3 linearRGBHi  = pow((c + 0.055) / 1.055, real3(2.4, 2.4, 2.4));
+    real3 linearRGBHi  = PositivePow((c + 0.055) / 1.055, real3(2.4, 2.4, 2.4));
     real3 linearRGB    = (c <= 0.04045) ? linearRGBLo : linearRGBHi;
     return linearRGB;
 }
 real3 LinearToSRGB(real3 c)
 {
     real3 sRGBLo = c * 12.92;
-    real3 sRGBHi = (pow(c, real3(1.0/2.4, 1.0/2.4, 1.0/2.4)) * 1.055) - 0.055;
+    real3 sRGBHi = (PositivePow(c, real3(1.0/2.4, 1.0/2.4, 1.0/2.4)) * 1.055) - 0.055;
     real3 sRGB   = (c <= 0.0031308) ? sRGBLo : sRGBHi;
     return sRGB;
 }
 
 real3 FastLinearToSRGB(real3 c)
 {
-    return saturate(1.055 * pow(abs(c), 0.416666667) - 0.055);
+    return saturate(1.055 * PositivePow(c, 0.416666667) - 0.055);
 }
 
 real4 FastLinearToSRGB(real4 c)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 
 // Using pow often result to a warning like this
 // "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
-// PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
-TEMPLATE_2_REAL(PositivePow, base, power, return pow(max(abs(base), FLT_EPS), power))
+// PositivePow remove this warning when you know the value is positive or 0 and avoid inf/NAN.
+// Note: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509636(v=vs.85).aspx pow(0, >0) == 0
+TEMPLATE_2_REAL(PositivePow, base, power, return pow(abs(base), power))
 
 // Composes a floating point value with the magnitude of 'x' and the sign of 's'.
 // See the comment about FastSign() below.

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

     }
     return GetDebugMipColor(originalColor, tex, texelSize, uv);
 }
+
+// mipInfo :
+// x = quality setings minStreamingMipLevel
+// y = original mip count for texture
+// z = desired on screen mip level
+// w = 0
+float3 GetDebugMipReductionColor(Texture2D tex, float4 mipInfo)
+{
+    float3 outColor = float3(1.0, 0.0, 1.0); // Can't calculate without original mip count - return magenta
-float3 GetDebugMipReductionColor(Texture2D tex, float4 mipInfo)
-{
-        // mipInfo :
-        // x = quality setings minStreamingMipLevel
-        // y = original mip count for texture
-        // z = desired on screen mip level
-        // w = 0
-
-        return float3(0, mipCol, 0);
+        outColor = float3(0, mipCol, 0);
-    // Can't calculate without original mip count - return magenta
-    return float3(1.0, 0.0, 1.0);
+    return outColor;
 }
 
 // Convert an arbitrary range to color base on threshold provide to the function, threshold must be in growing order

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 
 float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
 {
+    float3 outColor = originalColor;
+
-        return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
+        outColor = GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
+        break;
-        return GetDebugMipCountColor(originalColor, tex);
+        outColor = GetDebugMipCountColor(originalColor, tex);
+        break;
-        return GetDebugMipReductionColor(tex, mipInfo);
+        outColor = GetDebugMipReductionColor(tex, mipInfo);
+        break;
-        return GetDebugStreamingMipColor(tex, mipInfo);
+        outColor = GetDebugStreamingMipColor(tex, mipInfo);
+        break;
-        return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
+        outColor = GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
+        break;
-    return originalColor;
+    return outColor;
 }
 
 // DebugFont code assume black and white font with texture size 256x128 with bloc of 16x16
 {
     const uint maxStringSize = 16;
 
-    int absIntValue = abs(intValue);
+    uint absIntValue = abs(intValue);
 
     // 1. Get size of the number of display
     int numEntries = min((intValue == 0 ? 0 : log10(absIntValue)) + (intValue < 0 ? 1 : 0), maxStringSize);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

 
                 // Load default renderPipelineResources / Material / Shader
                 string HDRenderPipelinePath = HDEditorUtils.GetHDRenderPipelinePath();
-                string PostProcessingPath = HDEditorUtils.GetPostProcessingPath();
                 string CorePath = HDEditorUtils.GetCorePath();
 
                 newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Handles.cs

 {
     partial class PlanarReflectionProbeUI
     {
+#if false
+#endif
         static readonly Color k_GizmoMirrorPlaneCamera = new Color(128f / 255f, 128f / 255f, 233f / 255f, 128f / 255f);
 
         public static void DrawHandles(PlanarReflectionProbeUI s, PlanarReflectionProbe d, Editor o)
             {
                 case EditBaseShape:
                     InfluenceVolumeUI.DrawGizmos(
-                        s.influenceVolume, 
-                        d.influenceVolume, 
-                        mat, 
-                        InfluenceVolumeUI.HandleType.Base, 
+                        s.influenceVolume,
+                        d.influenceVolume,
+                        mat,
+                        InfluenceVolumeUI.HandleType.Base,
-                        s.influenceVolume, 
-                        d.influenceVolume, 
+                        s.influenceVolume,
+                        d.influenceVolume,
-                        InfluenceVolumeUI.HandleType.Influence, 
+                        InfluenceVolumeUI.HandleType.Influence,
-                        s.influenceVolume, 
+                        s.influenceVolume,
-                        InfluenceVolumeUI.HandleType.InfluenceNormal, 
+                        InfluenceVolumeUI.HandleType.InfluenceNormal,
                         InfluenceVolumeUI.HandleType.All);
                     break;
                 default:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 float   _DirectionalShadowIndex;
 float3  _LightDirection;
 float4  _ScreenSpaceShadowsParameters;
-uint	_SampleCount;
+int     _SampleCount;
 CBUFFER_END
 
 #define _ContactShadowLength                _ScreenSpaceShadowsParameters.x

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoopDef.hlsl

     uint cacheType = index & 1;
     index = index >> 1;
 
+    float4 color = float4(0.0, 0.0, 0.0, 1.0);
+
     // This code will be inlined as lightLoopContext is hardcoded in the light loop
     if (lightLoopContext.sampleReflection == SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES)
     {
             ndc *= rcp(ndc.w);
             ndc.xy = ndc.xy * 0.5 + 0.5;
 
-            float4 color = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, 0);
-            color.a = any(ndc.xyz < 0) || any(ndc.xyz > 1) ? 0 : 1;
+            color.rgb = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, 0).rgb;
+            color.a = any(ndc.xyz < 0) || any(ndc.xyz > 1) ? 0.0 : 1.0;
-                return float4(ndc.xy, 0, color.a);
+                color = float4(ndc.xy, 0, color.a);
-            return color;
-            float4 color = SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_EnvCubemapTextures, s_trilinear_clamp_sampler, texCoord, index, lod);
-            color.a = 1;
+            color.rgb = SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(_EnvCubemapTextures, s_trilinear_clamp_sampler, texCoord, index, lod).rgb;
-                return float4(texCoord.xyz * 0.5 + 0.5, color.a);
+                color = float4(texCoord.xyz * 0.5 + 0.5, color.a);
-            return color;
-        return float4(0, 0, 0, 0);
-        return SampleSkyTexture(texCoord, lod);
+        color.rgb = SampleSkyTexture(texCoord, lod).rgb;
+
+    return color;
 }
 
 //-----------------------------------------------------------------------------

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

 
     if (overrideNormal)
     {
-        float overrideNormalValue = _DebugLightingNormal.yzw;
         surfaceData.normalWS = worldToTangent[2];
     }
 #endif