more improvement on framesettings and asset

- Suppres support async compute
- Add dirty state to asset render pipeline for frame settings

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDAdditionalCameraData.cs

         // otherwise it is the serialized m_FrameSettings that are used
         // This is required so each camera have its own debug settings even if they all use the RenderingPath.Default path
         // and important at Runtime as Default Camera from Scene Preview doesn't exist
+        // assetFrameSettingsIsDirty is the current dirty frame settings state of HDRenderPipelineAsset
+        // if it is dirty and camera use RenderingPath.Default, we need to update it
-        public void UpdateDirtyFrameSettings(FrameSettings defaultFrameSettings)
+        public void UpdateDirtyFrameSettings(bool assetFrameSettingsIsDirty, FrameSettings defaultFrameSettings)
-            if (m_frameSettingsIsDirty)
+            if (m_frameSettingsIsDirty || assetFrameSettingsIsDirty)
             {
                 // We do a copy of the settings to those effectively used
                 if (renderingPath == RenderingPath.Default)
             {
                 // Note that we register m_FrameSettingsRuntime, so manipulating it in the Debug windows
                 // doesn't affect the serialized version
-                FrameSettings.RegisterDebug(m_camera.name, GetFrameSettings());
+                if (m_camera.cameraType != CameraType.Preview)
+                {
+                    FrameSettings.RegisterDebug(m_camera.name, GetFrameSettings());
+                }
                 m_CameraRegisterName = m_camera.name;
                 m_IsDebugRegistered = true;
             }
         {
             if (m_IsDebugRegistered)
             {
-                FrameSettings.UnRegisterDebug(m_CameraRegisterName);
+                if (m_camera.cameraType != CameraType.Preview)
+                {
+                    FrameSettings.UnRegisterDebug(m_CameraRegisterName);
+                }
                 m_IsDebugRegistered = false;
             }
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.Handlers.cs

             EditorUtility.CopySerialized(c.GetComponent<HDAdditionalCameraData>(), m_PreviewAdditionalCameraData);
             var layer = c.GetComponent<PostProcessLayer>() ?? ComponentSingleton<PostProcessLayer>.instance;
             EditorUtility.CopySerialized(layer, m_PreviewPostProcessLayer);
-            m_PreviewCamera.cameraType = CameraType.SceneView;
+            m_PreviewCamera.cameraType = CameraType.SceneView; // This is required else if we use Preview the image is flipped... (Unity...)
             m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());
 
             var previewTexture = GetPreviewTextureWithSize((int)previewSize.x, (int)previewSize.y);

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

             m_UIState.Reset(m_SerializedCamera, Repaint);
 
             m_PreviewCamera = EditorUtility.CreateGameObjectWithHideFlags("Preview Camera", HideFlags.HideAndDontSave, typeof(Camera)).GetComponent<Camera>();
+            m_PreviewCamera.enabled = false;
+            m_PreviewCamera.cameraType = CameraType.Preview; // Must be init before adding HDAdditionalCameraData
-            m_PreviewCamera.enabled = false;
             m_PreviewHDCamera = new HDCamera(m_PreviewCamera);
             m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/RenderPipelineSettingsUI.cs

         public RenderPipelineSettingsUI()
             : base(0)
         {
-            
+
         }
 
         public override void Reset(SerializedRenderPipelineSettings data, UnityAction repaint)
             EditorGUILayout.PropertyField(d.supportDBuffer, _.GetContent("Support Decal Buffer"));
             EditorGUILayout.PropertyField(d.supportMSAA, _.GetContent("Support MSAA"));
             EditorGUILayout.PropertyField(d.supportSubsurfaceScattering, _.GetContent("Support Subsurface Scattering"));
-            EditorGUILayout.PropertyField(d.supportAsyncCompute, _.GetContent("Support AsyncCompute"));
             --EditorGUI.indentLevel;
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedRenderPipelineSettings.cs

         public SerializedProperty supportDBuffer;
         public SerializedProperty supportMSAA;
         public SerializedProperty supportSubsurfaceScattering;
-        public SerializedProperty supportAsyncCompute;
 
         public SerializedGlobalLightLoopSettings lightLoopSettings;
         public SerializedShadowInitParameters shadowInitParams;
             supportDBuffer = root.Find((RenderPipelineSettings s) => s.supportDBuffer);
             supportMSAA = root.Find((RenderPipelineSettings s) => s.supportMSAA);
             supportSubsurfaceScattering = root.Find((RenderPipelineSettings s) => s.supportSubsurfaceScattering);
-            supportAsyncCompute = root.Find((RenderPipelineSettings s) => s.supportAsyncCompute);
 
             lightLoopSettings = new SerializedGlobalLightLoopSettings(root.Find((RenderPipelineSettings s) => s.lightLoopSettings));
             shadowInitParams = new SerializedShadowInitParameters(root.Find((RenderPipelineSettings s) => s.shadowInitParams));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

                 m_FrameCount = Time.frameCount;
             }
 
+            // We first update the state of asset frame settings as they can be use by various camera
+            // but we keep the dirty state to correctly reset other camera that use RenderingPath.Default.
+            bool assetFrameSettingsIsDirty = m_Asset.frameSettingsIsDirty;
+            m_Asset.UpdateDirtyFrameSettings();
+
             foreach (var camera in cameras)
             {
                 if (camera == null)
                 // Note: the SceneView camera will never have additionalCameraData
                 var additionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
 
-                // Get the effective frame settings for this camera (This is camera frame settings and debug settings)
+                // Init effective frame settings of each camera
+                // Each camera have its own debug frame settings control from the debug windows
+                // debug frame settings can't be aggregate with frame settings (i.e we can't aggregate forward only control for example)
+                // so debug settings (when use) are the effective frame settings
+                // To be able to have this behavior we init effective frame settings with serialized frame settings and copy
+                // debug settings change on top of it. Each time frame settings are change in the editor, we reset all debug settings
+                // to stay in sync. The loop below allow to update all frame settings correctly and is required because
+                // camera can rely on default frame settings from the HDRendeRPipelineAsset
-                    additionalCameraData.UpdateDirtyFrameSettings(m_Asset.GetFrameSettings());
+                    additionalCameraData.UpdateDirtyFrameSettings(assetFrameSettingsIsDirty, m_Asset.GetFrameSettings());
                     srcFrameSettings = additionalCameraData.GetFrameSettings();
                 }
                 else

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

         FrameSettings m_FrameSettings = new FrameSettings(); // This are the defaultFrameSettings for all the camera and apply to sceneView, public to be visible in the inspector
         // Not serialized, not visible, the settings effectively used
         FrameSettings m_FrameSettingsRuntime = new FrameSettings();
+
+        bool m_frameSettingsIsDirty = true;
+        public bool frameSettingsIsDirty
+        {
+            get { return m_frameSettingsIsDirty; }
+        }
+
+        }
+
+        // See comment in FrameSettings.UpdateDirtyFrameSettings()
+        // for detail about this function
+        public void UpdateDirtyFrameSettings()
+        {
+            if (m_frameSettingsIsDirty)
+            {
+                m_FrameSettings.CopyTo(m_FrameSettingsRuntime);
+
+                m_frameSettingsIsDirty = false;
+            }
         }
 
         // Store the various RenderPipelineSettings for each platform (for now only one)
 
         void ISerializationCallbackReceiver.OnAfterDeserialize()
         {
-            // Modification of defaultFrameSettings in the inspector will call OnValidate().
-            // We do a copy of the settings to those effectively used
-            m_FrameSettings.CopyTo(m_FrameSettingsRuntime);
+            // This is call on load or when this settings are change.
+            // When FrameSettings are manipulated we reset them to reflect the change, discarding all the Debug Windows change.
+            // Tag as dirty so frameSettings are correctly initialize at next HDRenderPipeline.Render() call
+            m_frameSettingsIsDirty = true;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

         public bool enablePostprocess = true;
 
         public bool enableStereo = true;
-        public bool enableAsyncCompute = false;
+        public bool enableAsyncCompute = true;
 
         public bool enableOpaqueObjects = true;
         public bool enableTransparentObjects = true;
             // Force forward if we request stereo. TODO: We should not enforce that, users should be able to chose deferred
             aggregate.enableForwardRenderingOnly = aggregate.enableForwardRenderingOnly || aggregate.enableStereo;
 
-            aggregate.enableAsyncCompute = srcFrameSettings.enableAsyncCompute && renderPipelineSettings.supportAsyncCompute;
+            aggregate.enableAsyncCompute = srcFrameSettings.enableAsyncCompute && SystemInfo.supportsAsyncCompute;
 
             aggregate.enableOpaqueObjects = srcFrameSettings.enableOpaqueObjects;
             aggregate.enableTransparentObjects = srcFrameSettings.enableTransparentObjects;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/RenderPipelineSettings.cs

         // Engine
         public bool supportDBuffer = false;
         public bool supportMSAA = false;
-        public bool supportAsyncCompute = false;
 
         public GlobalLightLoopSettings  lightLoopSettings = new GlobalLightLoopSettings();
         public ShadowInitParameters     shadowInitParams = new ShadowInitParameters();