Merge remote-tracking branch 'origin/master' into hdrp-xr-lighting

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDAdditionalCameraData.cs

             Unlit  // Hard coded path
         };
 
+        public enum ClearColorMode
+        {
+            Sky,
+            BackgroundColor,
+            None
+        };
+
+        public ClearColorMode clearColorMode = ClearColorMode.Sky;
+        [ColorUsage(true, true)]
+        public Color backgroundColorHDR = new Color(0.025f, 0.07f, 0.19f, 0.0f);
+        public bool clearDepth = true;
+
         public RenderingPath    renderingPath;
         [Tooltip("Layer Mask used for the volume interpolation for this camera.")]
         public LayerMask        volumeLayerMask = -1;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

         // happen, but you never know...
         int m_LastFrameActive;
 
+        public bool clearDepth
+        {
+            get { return m_AdditionalCameraData != null ? m_AdditionalCameraData.clearDepth : camera.clearFlags != CameraClearFlags.Nothing; }
+        }
+
+        public HDAdditionalCameraData.ClearColorMode clearColorMode
+        {
+            get
+            {
+                if (m_AdditionalCameraData != null)
+                {
+                    return m_AdditionalCameraData.clearColorMode;
+                }
+
+                if (camera.clearFlags == CameraClearFlags.Skybox)
+                    return HDAdditionalCameraData.ClearColorMode.Sky;
+                else if (camera.clearFlags == CameraClearFlags.SolidColor)
+                    return HDAdditionalCameraData.ClearColorMode.BackgroundColor;
+                else // None
+                    return HDAdditionalCameraData.ClearColorMode.None;
+            }
+        }
+
+        public Color backgroundColorHDR
+        {
+            get
+            {
+                if (m_AdditionalCameraData != null)
+                {
+                    return m_AdditionalCameraData.backgroundColorHDR;
+                }
+
+                // The scene view has no additional data so this will correctly pick the editor preference backround color here.
+                return camera.backgroundColor.linear;
+            }
+        }        
+
         static Dictionary<Camera, HDCamera> s_Cameras = new Dictionary<Camera, HDCamera>();
         static List<Camera> s_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraUI.cs

         public static readonly CED.IDrawer[] Inspector = null;
 
         public static readonly CED.IDrawer SectionPrimarySettings = CED.Group(
-            CED.Action(Drawer_FieldBackgroundColor),
+            CED.Action(Drawer_FieldClearColorMode),
+            CED.Action(Drawer_FieldBackgroundColorHDR),
+            CED.Action(Drawer_FieldClearDepth),
             CED.Action(Drawer_FieldCullingMask),
             CED.Action(Drawer_FieldVolumeLayerMask),
             CED.space,
             frameSettingsUI.Update();
         }
 
-        static void Drawer_FieldBackgroundColor(HDCameraUI s, SerializedHDCamera p, Editor owner)
+        static void Drawer_FieldBackgroundColorHDR(HDCameraUI s, SerializedHDCamera p, Editor owner)
-            EditorGUILayout.PropertyField(p.backgroundColor, _.GetContent("Background Color|The Camera clears the screen to this color before rendering."));
+            EditorGUILayout.PropertyField(p.backgroundColorHDR, _.GetContent("Background Color|The BackgroundColor used to clear the screen when selecting BackgrounColor before rendering."));
         }
 
         static void Drawer_FieldVolumeLayerMask(HDCameraUI s, SerializedHDCamera p, Editor owner)
             EditorGUILayout.PropertyField(p.depth, _.GetContent("Depth"));
         }
 
+        static void Drawer_FieldClearColorMode(HDCameraUI s, SerializedHDCamera p, Editor owner)
+        {
+            EditorGUILayout.PropertyField(p.clearColorMode, _.GetContent("Clear Mode|The Camera clears the screen to selected mode."));
+        }
+
+        }
+
+        static void Drawer_FieldClearDepth(HDCameraUI s, SerializedHDCamera p, Editor owner)
+        {
+            EditorGUILayout.PropertyField(p.clearDepth, _.GetContent("ClearDepth|The Camera clears the depth buffer before rendering."));
         }
 
         static void Drawer_FieldRenderTarget(HDCameraUI s, SerializedHDCamera p, Editor owner)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/SerializedHDCamera.cs

         public SerializedObject serializedObject;
         public SerializedObject serializedAdditionalDataObject;
 
-        public SerializedProperty backgroundColor;
+        //public SerializedProperty backgroundColor;
         public SerializedProperty normalizedViewPortRect;
         public SerializedProperty fieldOfView;
         public SerializedProperty orthographic;
         public SerializedProperty targetDisplay;
 #endif
 
+        public SerializedProperty clearColorMode;
+        public SerializedProperty backgroundColorHDR;
+        public SerializedProperty clearDepth;
         public SerializedProperty volumeLayerMask;
         public SerializedFrameSettings frameSettings;
 
             hideFlags.intValue = (int)HideFlags.HideInInspector;
             serializedAdditionalDataObject.ApplyModifiedProperties();
 
-            backgroundColor = serializedObject.FindProperty("m_BackGroundColor");
+            //backgroundColor = serializedObject.FindProperty("m_BackGroundColor");
             normalizedViewPortRect = serializedObject.FindProperty("m_NormalizedViewPortRect");
             nearClippingPlane = serializedObject.FindProperty("near clip plane");
             farClippingPlane = serializedObject.FindProperty("far clip plane");
 
             targetEye = serializedObject.FindProperty("m_TargetEye");
 
+
+            clearColorMode = serializedAdditionalDataObject.Find((HDAdditionalCameraData d) => d.clearColorMode);
+            backgroundColorHDR = serializedAdditionalDataObject.Find((HDAdditionalCameraData d) => d.backgroundColorHDR);
+            clearDepth = serializedAdditionalDataObject.Find((HDAdditionalCameraData d) => d.clearDepth);
             volumeLayerMask = serializedAdditionalDataObject.Find((HDAdditionalCameraData d) => d.volumeLayerMask);
             frameSettings = new SerializedFrameSettings(serializedAdditionalDataObject.FindProperty("m_FrameSettings"));
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

                 // Clear depth/stencil and init buffers
                 using (new ProfilingSample(cmd, "Clear Depth/Stencil", CustomSamplerId.ClearDepthStencil.GetSampler()))
                 {
-                    HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer, ClearFlag.Depth);
+                    if (hdCamera.clearDepth)
+                    {
+                        HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer, ClearFlag.Depth);
+                    }
+                }
+
+                // Clear the HDR target
+                using (new ProfilingSample(cmd, "Clear HDR target", CustomSamplerId.ClearHDRTarget.GetSampler()))
+                {
+                    if (hdCamera.clearColorMode == HDAdditionalCameraData.ClearColorMode.BackgroundColor ||
+                        // If we want the sky but the sky don't exist, still clear with background color
+                        (hdCamera.clearColorMode == HDAdditionalCameraData.ClearColorMode.Sky && !m_SkyManager.IsSkyValid()) ||
+                        // Special handling for Preview we force to clear with background color (i.e black)
+                        // Note that the sky use in this case is the last one setup. If there is no scene or game, there is no sky use as reflection in the preview
+                        hdCamera.camera.cameraType == CameraType.Preview
+                        )
+                    {
+                        Color clearColor = hdCamera.backgroundColorHDR;
+                        HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer, ClearFlag.Color, clearColor);
+                    }
                 }
 
                 // Clear the diffuse SSS lighting target
                 }
 
                 // TODO: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
-
-                // Clear the HDR target
-                using (new ProfilingSample(cmd, "Clear HDR target", CustomSamplerId.ClearHDRTarget.GetSampler()))
-                {
-                    Color clearColor = hdCamera.camera.backgroundColor.linear; // Need it in linear because we clear a linear fp16 texture.
-                    HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer, ClearFlag.Color, clearColor);
-                }
 
                 // Clear GBuffers
                 if (!m_FrameSettings.enableForwardRenderingOnly)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyRenderingContext.cs

             return result;
         }
 
-        public void RenderSky(SkyUpdateContext skyContext, HDCamera camera, Light sunLight, RTHandle colorBuffer, RTHandle depthBuffer, CommandBuffer cmd)
+        public void RenderSky(SkyUpdateContext skyContext, HDCamera hdCamera, Light sunLight, RTHandle colorBuffer, RTHandle depthBuffer, CommandBuffer cmd)
-            if (skyContext.IsValid())
+            if (skyContext.IsValid() && hdCamera.clearColorMode == HDAdditionalCameraData.ClearColorMode.Sky)
-                    m_BuiltinParameters.pixelCoordToViewDirMatrix = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(camera.camera.fieldOfView * Mathf.Deg2Rad, camera.screenSize, camera.viewMatrix, false);
-                    m_BuiltinParameters.invViewProjMatrix = camera.viewProjMatrix.inverse;
-                    m_BuiltinParameters.screenSize = camera.screenSize;
-                    m_BuiltinParameters.cameraPosWS = camera.camera.transform.position;
+                    m_BuiltinParameters.pixelCoordToViewDirMatrix = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(hdCamera.camera.fieldOfView * Mathf.Deg2Rad, hdCamera.screenSize, hdCamera.viewMatrix, false);
+                    m_BuiltinParameters.invViewProjMatrix = hdCamera.viewProjMatrix.inverse;
+                    m_BuiltinParameters.screenSize = hdCamera.screenSize;
+                    m_BuiltinParameters.cameraPosWS = hdCamera.camera.transform.position;
-                    m_BuiltinParameters.hdCamera = camera;
+                    m_BuiltinParameters.hdCamera = hdCamera;
 
                     skyContext.renderer.SetRenderTargets(m_BuiltinParameters);
                     skyContext.renderer.RenderSky(m_BuiltinParameters, false);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightShaderGUI.cs

                 material.DisableKeyword("_ALPHABLEND_ON");
                 material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                 material.renderQueue = -1;
+                material.SetShaderPassEnabled("ShadowCaster", true);
                 break;
             case BlendMode.Cutout:
                 material.SetOverrideTag("RenderType", "TransparentCutout");
                 material.DisableKeyword("_ALPHABLEND_ON");
                 material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                 material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
+                material.SetShaderPassEnabled("ShadowCaster", true);
                 break;
             case BlendMode.Fade:
                 material.SetOverrideTag("RenderType", "Transparent");
                 material.EnableKeyword("_ALPHABLEND_ON");
                 material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
                 material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                material.SetShaderPassEnabled("ShadowCaster", false);
                 break;
             case BlendMode.Transparent:
                 material.SetOverrideTag("RenderType", "Transparent");
                 material.DisableKeyword("_ALPHABLEND_ON");
                 material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                 material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                material.SetShaderPassEnabled("ShadowCaster", false);
                 break;
         }
     }

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     return color;
 }
 
+// Used for Standard shader
+half4 LitPassFragmentNull(LightweightVertexOutput IN) : SV_Target
+{
+    LitPassFragment(IN);
+    return 0;
+}
+
 // Used for StandardSimpleLighting shader
 half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
 {
     half4 diffuseAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
     half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
 
-#ifdef _GLOSSINESS_FROM_BASE_ALPHA
-    half alpha = _Color.a;
-#else
-#endif
-
     AlphaDiscard(alpha, _Cutoff);
 
 #ifdef _NORMALMAP
 
     return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
 };
+
+
+// Used for StandardSimpleLighting shader
+half4 LitPassFragmentSimpleNull(LightweightVertexOutput IN) : SV_Target
+{
+    half4 result = LitPassFragmentSimple(IN);
+    return result.a;
+}
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassShadow.hlsl

 #ifndef LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 #define LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 
-#include "LWRP/ShaderLibrary/Core.hlsl"
+#include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
-struct VertexInput
-{
-    float4 position : POSITION;
-    float3 normal   : NORMAL;
-
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-float4 ShadowPassVertex(VertexInput v) : SV_POSITION
+LightweightVertexOutput ShadowPassVertex(LightweightVertexInput v)
-    UNITY_SETUP_INSTANCE_ID(v);
+    LightweightVertexOutput o = LitPassVertex(v);
-    float3 positionWS = TransformObjectToWorld(v.position.xyz);
-    float3 normalWS = TransformObjectToWorldDir(v.normal);
-
-    float invNdotL = 1.0 - saturate(dot(_LightDirection, normalWS));
+    float invNdotL = 1.0 - saturate(dot(_LightDirection, o.normal));
-    positionWS = normalWS * scale.xxx + positionWS;
-    float4 clipPos = TransformWorldToHClip(positionWS);
+    o.posWS = o.normal * scale.xxx + o.posWS;
+    float4 clipPos = TransformWorldToHClip(o.posWS);
 
     // _ShadowBias.x sign depens on if platform has reversed z buffer
     clipPos.z += _ShadowBias.x;
 #else
     clipPos.z = max(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE);
 #endif
-    return clipPos;
-}
-half4 ShadowPassFragment() : SV_TARGET
-{
-    return 0;
+    o.clipPos = clipPos;
+    return o;
-
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

         {
             Tags{"LightMode" = "ShadowCaster"}
 
-            ZWrite On ZTest LEqual
+            ZWrite On
+            ZTest LEqual
+            
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature _NORMALMAP
+            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature _EMISSION
+            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+            #pragma shader_feature _OCCLUSIONMAP
+
+            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
+            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
+            #pragma shader_feature _SPECULAR_SETUP
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment ShadowPassFragment
+            #pragma fragment LitPassFragmentNull
 
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            #pragma vertex vert
-            #pragma fragment frag
+            
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature _NORMALMAP
+            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature _EMISSION
+            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+            #pragma shader_feature _OCCLUSIONMAP
-            #include "LWRP/ShaderLibrary/Core.hlsl"
+            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
+            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
+            #pragma shader_feature _SPECULAR_SETUP
-            float4 vert(float4 pos : POSITION) : SV_POSITION
-            {
-                return TransformObjectToHClip(pos.xyz);
-            }
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
-            half4 frag() : SV_TARGET
-            {
-                return 0;
-            }
+            #pragma vertex LitPassVertex
+            #pragma fragment LitPassFragmentNull
+
+            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
             ENDHLSL
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

         {
             Tags{"Lightmode" = "ShadowCaster"}
 
-            ZWrite On ZTest LEqual
+            ZWrite On
+            ZTest LEqual
+            
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
+            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature _NORMALMAP
+            #pragma shader_feature _EMISSION
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment ShadowPassFragment
+            #pragma fragment LitPassFragmentSimpleNull
 
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            #pragma vertex vert
-            #pragma fragment frag
-            #include "LWRP/ShaderLibrary/Core.hlsl"
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
+            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature _NORMALMAP
+            #pragma shader_feature _EMISSION
-            float4 vert(float4 pos : POSITION) : SV_POSITION
-            {
-                return TransformObjectToHClip(pos.xyz);
-            }
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
-            half4 frag() : SV_TARGET
-            {
-                return 0;
-            }
+            #pragma vertex LitPassVertex
+            #pragma fragment LitPassFragmentSimpleNull
+        
+            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
             ENDHLSL
         }