Merge HDRP staging [Skip CI]

com.unity.render-pipelines.core/Runtime/Common/ListBuffer.cs

@@ -0,0 +1,163 @@
+using System;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// A list that stores value on a provided memory buffer.
+    ///
+    /// Usually use this to have a list on stack allocated memory.
+    /// </summary>
+    /// <typeparam name="T">The type of the data stored in the list.</typeparam>
+    public unsafe struct ListBuffer<T>
+        where T: unmanaged
+    {
+        private T* m_BufferPtr;
+        private int m_Capacity;
+        private int* m_CountPtr;
+
+        /// <summary>
+        /// The pointer to the memory storage.
+        /// </summary>
+        internal T* BufferPtr => m_BufferPtr;
+
+        /// <summary>
+        /// The number of item in the list.
+        /// </summary>
+        public int Count => *m_CountPtr;
+
+        /// <summary>
+        /// The maximum number of item stored in this list.
+        /// </summary>
+        public int Capacity => m_Capacity;
+
+        /// <summary>
+        /// Instantiate a new list.
+        /// </summary>
+        /// <param name="bufferPtr">The address in memory to store the data.</param>
+        /// <param name="countPtr">The address in memory to store the number of item of this list..</param>
+        /// <param name="capacity">The number of <typeparamref name="T"/> that can be stored in the buffer.</param>
+        public ListBuffer(T* bufferPtr, int* countPtr, int capacity)
+        {
+            m_BufferPtr = bufferPtr;
+            m_Capacity = capacity;
+            m_CountPtr = countPtr;
+        }
+
+        /// <summary>
+        /// Get an item from the list.
+        /// </summary>
+        /// <param name="index">The index of the item to get.</param>
+        /// <returns>A reference to the item.</returns>
+        /// <exception cref="IndexOutOfRangeException">If the index is invalid.</exception>
+        public ref T this[in int index]
+        {
+            get
+            {
+                if (index < 0 || index >= Count)
+                    throw new IndexOutOfRangeException(
+                        $"Expected a value between 0 and {Count}, but received {index}.");
+                return ref m_BufferPtr[index];
+            }
+        }
+
+        /// <summary>
+        /// Get an item from the list.
+        ///
+        /// Safety: index must be inside the bounds of the list.
+        /// </summary>
+        /// <param name="index">The index of the item to get.</param>
+        /// <returns>A reference to the item.</returns>
+        public unsafe ref T GetUnchecked(in int index) => ref m_BufferPtr[index];
+
+        /// <summary>
+        /// Try to add a value in the list.
+        /// </summary>
+        /// <param name="value">A reference to the value to add.</param>
+        /// <returns>
+        ///   <code>true</code> when the value was added,
+        ///   <code>false</code> when the value was not added because the capacity was reached.
+        /// </returns>
+        public bool TryAdd(in T value)
+        {
+            if (Count >= m_Capacity)
+                return false;
+
+            m_BufferPtr[Count] = value;
+            ++*m_CountPtr;
+            return true;
+        }
+
+        /// <summary>
+        /// Copy the content of this list into another buffer in memory.
+        ///
+        /// Safety:
+        ///  * The destination must have enough memory to receive the copied data.
+        /// </summary>
+        /// <param name="dstBuffer">The destination buffer of the copy operation.</param>
+        /// <param name="startDstIndex">The index of the first element that will be copied in the destination buffer.</param>
+        /// <param name="copyCount">The number of item to copy.</param>
+        public unsafe void CopyTo(T* dstBuffer, int startDstIndex, int copyCount)
+        {
+            UnsafeUtility.MemCpy( dstBuffer + startDstIndex,  m_BufferPtr,
+                UnsafeUtility.SizeOf<T>() * copyCount);
+        }
+
+        /// <summary>
+        /// Try to copy the list into another list.
+        /// </summary>
+        /// <param name="other">The destination of the copy.</param>
+        /// <returns>
+        ///   * <code>true</code> when the copy was performed.
+        ///   * <code>false</code> when the copy was aborted because the destination have a capacity too small.
+        /// </returns>
+        public bool TryCopyTo(ListBuffer<T> other)
+        {
+            if (other.Count + Count >= other.m_Capacity)
+                return false;
+
+            UnsafeUtility.MemCpy( other.m_BufferPtr + other.Count, m_BufferPtr, UnsafeUtility.SizeOf<T>() * Count);
+            *other.m_CountPtr += Count;
+            return true;
+        }
+
+        /// <summary>
+        /// Try to copy the data from a buffer in this list.
+        /// </summary>
+        /// <param name="srcPtr">The pointer of the source memory to copy.</param>
+        /// <param name="count">The number of item to copy from the source buffer.</param>
+        /// <returns>
+        ///   * <code>true</code> when the copy was performed.
+        ///   * <code>false</code> when the copy was aborted because the capacity of this list is too small.
+        /// </returns>
+        public bool TryCopyFrom(T* srcPtr, int count)
+        {
+            if (count + Count > m_Capacity)
+                return false;
+
+            UnsafeUtility.MemCpy( m_BufferPtr + Count, srcPtr, UnsafeUtility.SizeOf<T>() * count);
+            *m_CountPtr += count;
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// Extensions for <see cref="ListBuffer{T}"/>.
+    /// </summary>
+    public static class ListBufferExtensions
+    {
+        /// <summary>
+        /// Perform a quick sort on a <see cref="ListBuffer{T}"/>.
+        /// </summary>
+        /// <param name="self">The list to sort.</param>
+        /// <typeparam name="T">The type of the element in the list.</typeparam>
+        public static void QuickSort<T>(this ListBuffer<T> self)
+            where T : unmanaged, IComparable<T>
+        {
+            unsafe
+            {
+                CoreUnsafeUtils.QuickSort<int>(self.Count, self.BufferPtr);
+            }
+        }
+    }
+}

com.unity.render-pipelines.core/Runtime/Textures/RTHandleSystem.cs

@@ -488,7 +488,7 @@ public RTHandle Alloc(
                     bindTextureMS = bindTextureMS,
                     useDynamicScale = m_HardwareDynamicResRequested && useDynamicScale,
                     memorylessMode = memoryless,
-                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, GraphicsFormatUtility.GetRenderTextureFormat(colorFormat), name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
+                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, colorFormat, name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
                 };
             }
 
@@ -744,7 +744,7 @@ string name
                     useDynamicScale = m_HardwareDynamicResRequested && useDynamicScale,
                     memorylessMode = memoryless,
                     stencilFormat = stencilFormat,
-                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, GraphicsFormatUtility.GetRenderTextureFormat(colorFormat), name, mips: useMipMap, enableMSAA: allocForMSAA, msaaSamples: m_ScaledRTCurrentMSAASamples)
+                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, colorFormat, name, mips: useMipMap, enableMSAA: allocForMSAA, msaaSamples: m_ScaledRTCurrentMSAASamples)
                 };
             }
             else
@@ -765,7 +765,7 @@ string name
                     bindTextureMS = bindTextureMS,
                     useDynamicScale = m_HardwareDynamicResRequested && useDynamicScale,
                     memorylessMode = memoryless,
-                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, GraphicsFormatUtility.GetRenderTextureFormat(colorFormat), name, mips: useMipMap, enableMSAA: allocForMSAA, msaaSamples: m_ScaledRTCurrentMSAASamples)
+                    name = CoreUtils.GetRenderTargetAutoName(width, height, slices, colorFormat, name, mips: useMipMap, enableMSAA: allocForMSAA, msaaSamples: m_ScaledRTCurrentMSAASamples)
                 };
             }
 

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

@@ -695,6 +695,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Fixed an issue where manipulating the color wheels in a volume component would reset the cursor every time.
 - Fixed an issue where static sky lighting would not be updated for a new scene until it's reloaded at least once.
 - Fixed culling for decals when used in prefabs and edited in context.
+- Force to rebake probe with missing baked texture. (1253367)
 
 ### Changed
 - Improve MIP selection for decals on Transparents
@@ -845,6 +846,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Changed the default exposure mode to "Automatic (Histogram)", along with "Limit Min" to -4 and "Limit Max" to 16.
 - Replaced the default scene system with the builtin Scene Template feature.
 - Changed extensions of shader CAS include files.
+- Making the planar probe atlas's format match the color buffer's format.
+- Removing the planarReflectionCacheCompressed setting from asset.
 
 ## [7.1.1] - 2019-09-05
 

com.unity.render-pipelines.high-definition/Documentation~/HDRP-Asset.md

@@ -36,6 +36,7 @@ When you create an HDRP Asset, open it in the Inspector to edit its properties.
 
 | **Property**                            | **Description**                                              |
 | --------------------------------------- | ------------------------------------------------------------ |
+| **Color Buffer Format**                 | The format of the color buffer that HDRP will use for rendering, using R16G16B16A16 instead of R11G11B10 will double the memory usage but help you to avoid banding. R16G16B16A16 is also required for [Alpha-Output](Alpha-Output.md).|
 | **Lit Shader Mode**                     | Use the drop-down to choose which mode HDRP uses for the [Lit Shader](Lit-Shader.html).<br />&#8226; **Forward Only**: forces HDRP to only use forward rendering for Lit Shaders.<br />&#8226; **Deferred Only**: forces HDRP to use deferred rendering for Lit Shaders (HDRP still renders advanced Materials using forward rendering).<br />&#8226; **Both**: allows the Camera to use deferred and forward rendering.<br /><br />Select **Both** to allow you to switch between forward and deferred rendering for Lit Shaders at runtime per Camera. Selecting a specific mode reduces build time and Shader memory because HDRP requires less Shader variants, but it is not possible to switch from one mode to the other at runtime. |
 | **- Multisample Anti-aliasing Quality** | Use the drop-down to set the number of samples HDRP uses for multisample anti-aliasing (MSAA). The larger the sample count, the better the quality. Select **None** to disable MSAA.<br />This property is only visible when **Lit Shader Mode** is set to **Forward Only** or **Both**. |
 | **Motion Vectors**                      | Enable the checkbox to make HDRP support motion vectors. HDRP uses motion vectors for effects like screen space reflection (SSR) and motion blur. When disabled, motion blur has no effect and HDRP calculates SSR with lower quality. |
@@ -123,7 +124,6 @@ Use the Reflection settings to configure the max number and resolution of the pr
 | **Compress Reflection Probe Cache**        | Enable the checkbox to compress the [Reflection Probe](Reflection-Probe.html) cache in order to save space on disk. |
 | **Reflection Cubemap Size**                | Use the drop-down to select the maximum resolution of individual Reflection Probe[ ](https://docs.unity3d.com/Manual/class-Cubemap.html)[cubemaps](https://docs.unity3d.com/Manual/class-Cubemap.html). |
 | **Probe Cache Size**                       | The maximum size of the Probe Cache. Defines how many Probe cube maps HDRP can save in cache. |
-| **Compress Planar Reflection Probe Cache** | Enable the checkbox to compress the [Planar Reflection Probe](Planar-Reflection-Probe.html) cache in order to save space on disk. |
 | **Planar Reflection Atlas Size**           | Use the drop-down to select the resolution of the planar probe atlas. It defines how many reflection probe you'll be able to render at once and at which resolution.  |
 | **Max Planar Reflection On Screen**        | The maximum number of planar reflections on screen at once. |
 | **Planar Probe Cache Size**                | The maximum size of the Planer Reflection Probe cache. Defines how many Probe textures HDRP can save in cache. |

com.unity.render-pipelines.high-definition/Documentation~/Planar-Reflection-Probe.md

@@ -6,6 +6,8 @@ The Planar Reflection Probe component is one of the types of [Reflection Probe](
 
 Planar Reflection Probes share many properties with the the [built-in render pipeline Reflection Probe](<https://docs.unity3d.com/Manual/class-ReflectionProbe.html>), and the [HDRP cubemap Reflection Probe](Reflection-Probe.html).
 
+Planar Reflection Probes use the same texture format than the one selected in [HDRP Asset](HDRP-Asset.md) for Color Buffer Format.
+
 ![](Images/PlanarReflectionProbe1.png)
 
 ### General Properties
@@ -83,4 +85,4 @@ You can use Scene view gizmos to visually customize specific properties.
 | ![](Images/ReflectionProbeGizmo1.png) | **Influence Volume bounds boundary** | Provides Scene view handles that allow you to move the boundaries of the [Influence Volume](#InfluenceVolume), which defines the area this Reflection Probe affects reflective Materials. Edits the **Box Size** or **Radius** value, depending on the **Shape** you select. |
 | ![](Images/ReflectionProbeGizmo2.png) | **Blend Distance boundary**           | Provides Scene view handles that allows you to alter the inward distance from the **Box Size** or **Radius** at which this Planar Reflection Probe blends with other Reflection Probes. Its behavior depends on the [workflow mode](#Workflows) you are using. It scales all sides equally in **Normal** mode, scales just the side with the handle you control in **Advanced** mode. |
 | ![](Images/ReflectionProbeGizmo4.png) | **Mirror Position**                   | Changes the behavior of the Move Tool so that it alters the **Mirror** **Position** property, rather than the **Position** of the **Transform**. |
-| ![](Images/ReflectionProbeGizmo5.png) | **Mirror Rotation**                   | Changes the behavior of the Rotate Tool so that it alters the **Mirror Rotation** property, rather than the **Rotation** of the **Transform**. |
+| ![](Images/ReflectionProbeGizmo5.png) | **Mirror Rotation**                   | Changes the behavior of the Rotate Tool so that it alters the **Mirror Rotation** property, rather than the **Rotation** of the **Transform**. |

com.unity.render-pipelines.high-definition/Documentation~/Upgrading-from-2020.1-to-2020.2.md

@@ -29,6 +29,8 @@ Select your [HDRP Asset](HDRP-Asset.md).
 In the Inspector, go to Lighting > Cookies.
 In the 2D Atlas Size drop-down, select a larger cookie resolution.
 
+From Unity 2020.2, the texture format of the color buffer selected in HDRP asset is apply to planar reflection probe. Previously planar reflection probe where always using float16 rendertarget.
+
 ## Shadows
 
 From Unity 2020.2, it is no longer necessary to change the [HDRP Config package](HDRP-Config-Package.md) to set the [shadow filtering quality](HDRP-Asset.md#FilteringQualities) for deferred rendering. Instead, you can now change the filtering quality directly on the [HDRP Asset](HDRP-Asset.md#FilteringQualities). Note if you previously had not set the shadow filtering quality to **Medium** on the HDRP Asset, the automatic project upgrade process changes the shadow quality which means you may need to manually change it back to its original value.

com.unity.render-pipelines.high-definition/Editor/Lighting/ProbeVolumeControllerEditor.cs

@@ -11,11 +11,14 @@ public override void OnInspectorGUI()
         {
             base.OnInspectorGUI();
 
-            if (!(GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset)
-                ?.currentPlatformRenderPipelineSettings.supportProbeVolume ?? false)
+            if (ShaderConfig.s_ProbeVolumesEvaluationMode != ProbeVolumesEvaluationModes.Disabled)
             {
-                EditorGUILayout.Space();
-                EditorGUILayout.HelpBox("The current HDRP Asset does not support Probe Volume Global Illumination.", MessageType.Error, wide: true);
+                if (!(GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset)
+                        ?.currentPlatformRenderPipelineSettings.supportProbeVolume ?? false)
+                {
+                    EditorGUILayout.Space();
+                    EditorGUILayout.HelpBox("The current HDRP Asset does not support Probe Volume Global Illumination.", MessageType.Error, wide: true);
+                }
             }
         }
     }