Merge branch 'LW-Optimization'

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

         [SerializeField] private int m_MaxPixelLights = 4;
         [SerializeField] private bool m_SupportsVertexLight = false;
         [SerializeField] private bool m_RequireCameraDepthTexture = false;
+        [SerializeField] private bool m_SupportsHDR = false;
         [SerializeField] private MSAAQuality m_MSAA = MSAAQuality._4x;
         [SerializeField] private float m_RenderScale = 1.0f;
         [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
         public bool RequireCameraDepthTexture
         {
             get { return m_RequireCameraDepthTexture; }
+        }
+
+        public bool SupportsHDR
+        {
+            get { return m_SupportsHDR; }
         }
 
         public int MSAASampleCount

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightAssetEditor.cs

             public static GUIContent shadowCascadeSplit = new GUIContent("Cascades Split",
                     "Percentages to split shadow volume");
 
+            public static GUIContent hdrContent = new GUIContent("HDR", "Controls the global HDR settings.");
             public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing settings.");
 
             public static string[] shadowTypeOptions = {"No Shadows", "Hard Shadows", "Hard and Soft Shadows"};
         private SerializedProperty m_ShadowCascadesProp;
         private SerializedProperty m_ShadowCascade2SplitProp;
         private SerializedProperty m_ShadowCascade4SplitProp;
+        private SerializedProperty m_HDR;
         private SerializedProperty m_MSAA;
 
         void OnEnable()
             m_ShadowCascadesProp = serializedObject.FindProperty("m_ShadowCascades");
             m_ShadowCascade2SplitProp = serializedObject.FindProperty("m_Cascade2Split");
             m_ShadowCascade4SplitProp = serializedObject.FindProperty("m_Cascade4Split");
+            m_HDR = serializedObject.FindProperty("m_SupportsHDR");
             m_MSAA = serializedObject.FindProperty("m_MSAA");
         }
 
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_RequireCameraDepthTextureProp, Styles.requireCameraDepthTexture);
+            EditorGUILayout.PropertyField(m_HDR, Styles.hdrContent);
             EditorGUILayout.PropertyField(m_MSAA, Styles.msaaContent);
 
             EditorGUI.indentLevel--;

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightCameraEditor.cs

             EditorGUILayout.HelpBox(s_Styles.renderingPathInfo.text, MessageType.Info);
         }
 
+        private void DrawHDR()
+        {
+            settings.DrawHDR();
+            if (settings.HDR.boolValue && !lightweightPipeline.SupportsHDR)
+                EditorGUILayout.HelpBox("HDR rendering is disabled in Lightweight Pipeline asset.", MessageType.Warning);
+        }
+
         private void DrawTargetTexture()
         {
             EditorGUILayout.PropertyField(settings.targetTexture);
             DrawRenderingPath();
             DrawTargetTexture();
             settings.DrawOcclusionCulling();
-            settings.DrawHDR();
+            DrawHDR();
             DrawMSAA();
             settings.DrawVR();
             settings.DrawMultiDisplay();

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

             else
                 m_IntermediateTextureArray = false;
 
+            bool hdrEnabled = m_Asset.SupportsHDR && m_CurrCamera.allowHDR;
-                m_Asset.RenderScale < 1.0f || m_CurrCamera.allowHDR;
+                m_Asset.RenderScale < 1.0f || hdrEnabled;
-            m_ColorFormat = m_CurrCamera.allowHDR ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32;
+            m_ColorFormat = hdrEnabled ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
             m_RequiredDepth = false;
             m_CameraPostProcessLayer = m_CurrCamera.GetComponent<PostProcessLayer>();
 
                 bias = light.shadowBias * proj.m22 * 0.5f * sign;
 
                 // Currently only square POT cascades resolutions are used.
-                // We scale normalBias 
+                // We scale normalBias
                 double frustumWidth = 2.0 / (double)proj.m00;
                 double frustumHeight = 2.0 / (double)proj.m11;
                 float texelSizeX = (float)(frustumWidth / (double)cascadeResolution);
             CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SUBTRACTIVE", m_MixedLightingSetup == MixedLightingSetup.Subtractive);
             CoreUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_Asset.RequireCameraDepthTexture);
+
+            bool linearFogModeEnabled = false;
+            bool exponentialFogModeEnabled = false;
+            if (RenderSettings.fog)
+            {
+                if (RenderSettings.fogMode == FogMode.Linear)
+                    linearFogModeEnabled = true;
+                else
+                    exponentialFogModeEnabled = true;
+            }
+
+            CoreUtils.SetKeyword(cmd, "FOG_LINEAR", linearFogModeEnabled);
+            CoreUtils.SetKeyword(cmd, "FOG_EXP2", exponentialFogModeEnabled);
         }
 
         private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
             worldToShadow = cascadeAtlas * worldToShadow;
 
             m_ShadowSlices[cascadeIndex].atlasX = atlasX;
-            m_ShadowSlices[cascadeIndex].atlasY = atlasY; 
+            m_ShadowSlices[cascadeIndex].atlasY = atlasY;
             m_ShadowSlices[cascadeIndex].shadowResolution = shadowResolution;
             m_ShadowSlices[cascadeIndex].shadowTransform = worldToShadow;
         }
             {
                 // If PostProcessing is enabled, it is already blit to CameraTarget.
                 if (!LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.PostProcess))
-                    Blit(cmd, renderingConfig, BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
+                    Blit(cmd, renderingConfig, BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget, m_BlitMaterial);
             }
 
             SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
 
         private void Blit(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material material = null)
         {
+            cmd.SetGlobalTexture(m_BlitTexID, sourceRT);
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.DefaultViewport))
             {
                 cmd.Blit(sourceRT, destRT, material);
                 if (m_BlitQuad == null)
                     m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
 
-                cmd.SetGlobalTexture(m_BlitTexID, sourceRT);
-                cmd.DrawMesh(m_BlitQuad, Matrix4x4.identity, m_BlitMaterial);
+                cmd.DrawMesh(m_BlitQuad, Matrix4x4.identity, material);
             }
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightBlit.shader

         {
             Tags { "LightMode" = "LightweightForward"}
 
+            ZTest Always ZWrite Off
+
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightCopyDepth.shader

 
         Pass
         {
-            ColorMask 0
-            ZTest Always
-            ZWrite On
+            ZTest Always ZWrite Off ColorMask 0
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightShaderLibrary/Core.hlsl

     return normalize(mul(normalTangent, tangentToWorld));
 }
 
-float ComputeFogFactor(float z)
+half ComputeFogFactor(float z)
 {
     float clipZ_01 = UNITY_Z_0_FAR_FROM_CLIPSPACE(z);
 
     return half(fogFactor);
-#elif defined(FOG_EXP)
-    // factor = exp(-density*z)
-    float unityFogFactor = unity_FogParams.y * clipZ_01;
-    return half(saturate(exp2(-unityFogFactor)));
-    float unityFogFactor = unity_FogParams.x * clipZ_01;
-    return half(saturate(exp2(-unityFogFactor*unityFogFactor)));
+    // -density * z computed at vertex
+    return half(unity_FogParams.x * clipZ_01);
 #else
     return 0.0h;
 #endif
 {
-#if defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2)
+#if defined (FOG_LINEAR) || defined(FOG_EXP2)
+#if defined(FOG_EXP2)
+    // factor = exp(-(density*z)^2)
+    // fogFactor = density*z compute at vertex
+    fogFactor = saturate(exp2(-fogFactor*fogFactor));
+#endif
     color = lerp(fogColor, color, fogFactor);
 #endif
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
+            #pragma multi_compile _ FOG_LINEAR FOG_EXP2
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile_fog
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON
+
+            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
+            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
+            #ifdef DIRLIGHTMAP_COMBINED
+            #define LIGHTMAP_ON
+            #endif
 
             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragment

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT
             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
-            #pragma multi_compile _ _VERTEX_LIGHTS            
+            #pragma multi_compile _ _VERTEX_LIGHTS
+            #pragma multi_compile _ FOG_LINEAR FOG_EXP2
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile_fog
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON
+
+            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
+            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
+            #ifdef DIRLIGHTMAP_COMBINED
+            #define LIGHTMAP_ON
+            #endif
 
             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragmentSimple

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

             #pragma vertex SplatmapVert
             #pragma fragment SpatmapFragment
 
+            // -------------------------------------
+            // Lightweight Pipeline keywords
+            // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights
+            // Lightweight combines light classification and shadows keywords to reduce shader variants.
+            // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders
+            // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light)
+            // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE
-            #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile_fog
+            #pragma multi_compile _ FOG_LINEAR FOG_EXP2
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON
+
+            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
+            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
+            #ifdef DIRLIGHTMAP_COMBINED
+            #define LIGHTMAP_ON
+            #endif
 
             #include "LightweightShaderLibrary/Lighting.hlsl"