Merge branch 'HDRP/staging' into Improve-bakeDiffuseLighting-code

com.unity.render-pipelines.high-definition/CHANGELOG.md

 - When LightLayers is enabled, the AmbientOclusion is store in the GBuffer in deferred path allowing to avoid double occlusion with SSAO. In forward the double occlusion is now always avoided.
 - Added the possibility to add an override transform on the camera for volume interpolation
 - Added desired lux intensity and auto multiplier for HDRI sky
+- Added an option to disable light by type in the debug menu
 - Added gradient sky
 - Split EmissiveColor and bakeDiffuseLighting in forward avoiding the emissiveColor to be affect by SSAO
 

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.cs

         {
             var list = new List<DebugUI.Widget>();
 
+            list.Add(new DebugUI.Foldout
+            {
+                displayName = "Show Light By Type",
+                children = {
+                    new DebugUI.BoolField { displayName = "Show Directional Lights", getter = () => lightingDebugSettings.showDirectionalLight, setter = value => lightingDebugSettings.showDirectionalLight = value },
+                    new DebugUI.BoolField { displayName = "Show Punctual Lights", getter = () => lightingDebugSettings.showPunctualLight, setter = value => lightingDebugSettings.showPunctualLight = value },
+                    new DebugUI.BoolField { displayName = "Show Area Lights", getter = () => lightingDebugSettings.showAreaLight, setter = value => lightingDebugSettings.showAreaLight = value },
+                    new DebugUI.BoolField { displayName = "Show Reflection Probe", getter = () => lightingDebugSettings.showReflectionProbe, setter = value => lightingDebugSettings.showReflectionProbe = value },
+                }
+            });
+
             list.Add(new DebugUI.EnumField
             {
                 displayName = "Shadow Debug Mode",

com.unity.render-pipelines.high-definition/HDRP/Debug/LightingDebug.cs

 
         public float                debugExposure = 0.0f;
 
+        public bool                 showPunctualLight = true;
+        public bool                 showDirectionalLight = true;
+        public bool                 showAreaLight = true;
+        public bool                 showReflectionProbe = true;
+
         public LightLoop.TileClusterDebug tileClusterDebug = LightLoop.TileClusterDebug.None;
         public LightLoop.TileClusterCategoryDebug tileClusterDebugByCategory = LightLoop.TileClusterCategoryDebug.Punctual;
     }

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightDefinition.cs

         // Disk,
     };
 
+    public static class GPULightTypeExtension
+    {
+        public static bool IsAreaLight(this GPULightType lightType)
+        {
+            return lightType == GPULightType.Rectangle || lightType == GPULightType.Line;
+        }
+        
+        public static bool IsSpot(this GPULightType lightType)
+        {
+            return lightType == GPULightType.Spot || lightType == GPULightType.ProjectorBox || lightType == GPULightType.ProjectorPyramid;
+        }
+    }
+
     // This is use to distinguish between reflection and refraction probe in LightLoop
     [GenerateHLSL]
     public enum GPUImageBasedLightingType

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightLoop/LightLoop.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
+
     class ShadowSetup : IDisposable
     {
         // shadow related stuff
             return true;
         }
 
-        public bool GetDirectionalLightData(CommandBuffer cmd, ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, HDAdditionalLightData additionalData, AdditionalShadowData additionalShadowData, int lightIndex)
+        public bool GetDirectionalLightData(CommandBuffer cmd, ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, HDAdditionalLightData additionalData, AdditionalShadowData additionalShadowData, int lightIndex, DebugDisplaySettings debugDisplaySettings)
         {
             var directionalLightData = new DirectionalLightData();
 
+                return false;
+            
+            // Discard light if disabled in debug display settings
+            if (!debugDisplaySettings.lightingDebugSettings.showDirectionalLight)
                 return false;
 
             directionalLightData.lightLayers = additionalData.GetLightLayers();
 
         public bool GetLightData(CommandBuffer cmd, ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType,
             VisibleLight light, HDAdditionalLightData additionalLightData, AdditionalShadowData additionalshadowData,
-            int lightIndex, ref Vector3 lightDimensions)
+            int lightIndex, ref Vector3 lightDimensions, DebugDisplaySettings debugDisplaySettings)
         {
             var lightData = new LightData();
 
 
             bool applyRangeAttenuation = additionalLightData.applyRangeAttenuation && (gpuLightType != GPULightType.ProjectorBox);
 
+            // Discard light if disabled in debug display settings
+            if (lightData.lightType.IsAreaLight())
+            {
+                if (!debugDisplaySettings.lightingDebugSettings.showAreaLight)
+                    return false;
+            }
+            else
+            {
+                if (!debugDisplaySettings.lightingDebugSettings.showPunctualLight)
+                    return false;
+            }
+
             // In the shader we do range remapping: (x - start) / (end - start) = (dist^2 * rangeAttenuationScale + rangeAttenuationBias)
             if (applyRangeAttenuation)
             {
             }
         }
 
-        public bool GetEnvLightData(CommandBuffer cmd, Camera camera, ProbeWrapper probe)
+        public bool GetEnvLightData(CommandBuffer cmd, Camera camera, ProbeWrapper probe, DebugDisplaySettings debugDisplaySettings)
+                return false;
+            
+            // Discard probe if disabled in debug menu
+            if (!debugDisplaySettings.lightingDebugSettings.showReflectionProbe)
                 return false;
 
             var capturePosition = Vector3.zero;
 
         // Return true if BakedShadowMask are enabled
         public bool PrepareLightsForGPU(CommandBuffer cmd, HDCamera hdCamera, ShadowSettings shadowSettings, CullResults cullResults,
-            ReflectionProbeCullResults reflectionProbeCullResults, DensityVolumeList densityVolumes)
+            ReflectionProbeCullResults reflectionProbeCullResults, DensityVolumeList densityVolumes, DebugDisplaySettings debugDisplaySettings)
         {
             using (new ProfilingSample(cmd, "Prepare Lights For GPU"))
             {
                         // Directional rendering side, it is separated as it is always visible so no volume to handle here
                         if (gpuLightType == GPULightType.Directional)
                         {
-                            if (GetDirectionalLightData(cmd, shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
+                            if (GetDirectionalLightData(cmd, shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex, debugDisplaySettings))
                             {
                                 directionalLightcount++;
 
                         Vector3 lightDimensions = new Vector3(); // X = length or width, Y = height, Z = range (depth)
 
                         // Punctual, area, projector lights - the rendering side.
-                        if (GetLightData(cmd, shadowSettings, camera, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex, ref lightDimensions))
+                        if (GetLightData(cmd, shadowSettings, camera, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex, ref lightDimensions, debugDisplaySettings))
                         {
                             switch (lightCategory)
                             {
 
                         var probeWrapper = ProbeWrapper.Wrap(probe, planarProbe);
 
-                        if (GetEnvLightData(cmd, camera, probeWrapper))
+                        if (GetEnvLightData(cmd, camera, probeWrapper, debugDisplaySettings))
                         {
                             GetEnvLightVolumeDataAndBound(probeWrapper, lightVolumeType, worldToView);
                             if (stereoEnabled)

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

                     bool enableBakeShadowMask;
                     using (new ProfilingSample(cmd, "TP_PrepareLightsForGPU", CustomSamplerId.TPPrepareLightsForGPU.GetSampler()))
                     {
-                        enableBakeShadowMask = m_LightLoop.PrepareLightsForGPU(cmd, hdCamera, m_ShadowSettings, m_CullResults, m_ReflectionProbeCullResults, densityVolumes);
+                        enableBakeShadowMask = m_LightLoop.PrepareLightsForGPU(cmd, hdCamera, m_ShadowSettings, m_CullResults, m_ReflectionProbeCullResults, densityVolumes, m_DebugDisplaySettings);
                     }
                     ConfigureForShadowMask(enableBakeShadowMask, cmd);
                     ConfigureForLightLayers(hdCamera.frameSettings.enableLightLayers, cmd);

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDUtils.cs

         public const RendererConfiguration k_RendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
         public const RendererConfiguration k_RendererConfigurationBakedLightingWithShadowMask = k_RendererConfigurationBakedLighting | RendererConfiguration.PerObjectOcclusionProbe | RendererConfiguration.PerObjectOcclusionProbeProxyVolume | RendererConfiguration.PerObjectShadowMask;
 
-        static public HDAdditionalReflectionData s_DefaultHDAdditionalReflectionData { get { return ComponentSingleton<HDAdditionalReflectionData>.instance; } }
+        static public HDAdditionalReflectionData s_DefaultHDAdditionalReflectionData { get { ComponentSingleton<HDAdditionalReflectionData>.instance.Awake(); return ComponentSingleton<HDAdditionalReflectionData>.instance} }
         static public HDAdditionalLightData s_DefaultHDAdditionalLightData { get { return ComponentSingleton<HDAdditionalLightData>.instance; } }
         static public HDAdditionalCameraData s_DefaultHDAdditionalCameraData { get { return ComponentSingleton<HDAdditionalCameraData>.instance; } }