Merge pull request #8021 from Unity-Technologies/internal/master

Internal/master

Author: UnityAljosha

Packages/com.unity.render-pipelines.core/CHANGELOG.md

@@ -14,7 +14,11 @@
   * [RTHandle fundamentals](rthandle-system-fundamentals.md)
   * [Using the RTHandle system](rthandle-system-using.md)
 * [Custom Material Inspector](custom-material-inspector.md)
-* [Adding properties in the menu](adding-properties.md)
+* [Custom settings](settings.md)
+  * [Adding properties in the menu](adding-properties.md)
+  * [Add custom graphics settings](add-custom-graphics-settings.md)
+  * [Get custom graphics settings](get-custom-graphics-settings.md)
+  * [Include or excude a setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md)
 * [Synchronizing shader code and C#](generating-shader-includes.md)
 * [Look Dev](Look-Dev.md)
   * [Environment Library](Look-Dev-Environment-Library.md)

Packages/com.unity.render-pipelines.core/Documentation~/TableOfContents.md

@@ -0,0 +1,92 @@
+# Add custom graphics settings
+
+You can add custom graphics settings to the **Edit** > **Project Settings** > **Graphics** window, then use the values of the settings to customize your build.
+
+You can change the values of settings while you're editing your project. Unity makes the values static when it builds your project, so you can't change them at runtime.
+
+## Add a setting
+
+To add a setting, follow these steps:
+
+1. Create a class that implements the `IRenderPipelineGraphicsSettings` interface, and add a `[Serializable]` attribute. This becomes a new settings group in the **Graphics** settings window.
+2. To set which render pipeline the setting applies to, add a `[SupportedOnRenderPipeline]` attribute and pass in a `RenderPipelineAsset` type.
+3. Add a property. This becomes a setting.
+4. Implement the `version` field and set it to `0`. Unity doesn't currently use the `version` field, but you must implement it. 
+
+For example, the following script adds a setting called **My Value** in a settings group called **My Settings**, in the graphics settings for the Universal Render Pipeline (URP).
+
+```c#
+using UnityEngine;
+using UnityEngine.Rendering;
+using System;
+
+[Serializable]
+[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))] 
+
+// Create a new settings group by implementing the IRenderPipelineGraphicsSettings interface
+public class MySettings : IRenderPipelineGraphicsSettings
+{
+  // Implement the version field
+  public int version => 0;
+
+  // Create a new setting and set its default value to 100.
+  public int myValue = 100;
+}
+```
+
+## Add a reference property
+
+[Reference properties](https://docs.unity3d.com/2023.3/Documentation/Manual/EditingValueProperties.html#references) take compatible project assets or GameObjects in the scene as inputs.
+
+To add a reference property, follow these steps:
+
+1. Create a class that implements the `IRenderPipelineResources` interface. This becomes a new settings group in the Graphics Settings window.
+2. Add a property. This becomes a reference property.
+3. Implement the `version` field and set it to `0`. Unity doesn't currently use the `version` field, but you must implement it. 
+
+For example, the following script adds a reference property called **My Material** that references a material.
+
+```c#
+using UnityEngine;
+using UnityEngine.Rendering;
+using System;
+
+[Serializable]
+[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))] 
+
+// Create a new reference property group by implementing the IRenderPipelineResources interface
+public class MySettings: IRenderPipelineResources
+{
+  // Implement the version field
+  public int version => 0;
+
+  // Create a new reference property that references a material
+  [SerializeField] public Material myMaterial;
+}
+```
+
+To set a default asset, use a [`[ResourcePath]`](https://docs.unity3d.com/2023.3/Documentation/ScriptReference/Rendering.ResourcePathAttribute.html) attribute above the reference property. For example, in the example, add the following line above `public Material myMaterial`.
+
+```c#
+[ResourcePath('path-to-default-file')]
+```
+
+## Change the name and layout of a settings group
+
+To change the name of a settings group in the **Graphics** settings window, follow these steps:
+
+1. Add `using System.ComponentModel` to your script.
+2. Add a `[Category]` attribute to your script. For example, `[Category("My Category")]`.
+
+You can also use the [PropertyDrawer](https://docs.unity3d.com/ScriptReference/PropertyDrawer.html) API to further customize the layout of custom settings.
+
+## Set which render pipeline a setting applies to
+
+To set which render pipeline a setting applies to, use the `[SupportedOnRenderPipeline]` attribute and pass in a `RenderPipelineAsset` type.
+
+For example, if your project uses the Universal Rendering Pipeline (URP) and you want your setting to appear only in the **URP** tab of the **Graphics** settings window, use the following code:
+
+```c#
+[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))]
+```
+

Packages/com.unity.render-pipelines.core/Documentation~/add-custom-graphics-settings.md

@@ -0,0 +1,67 @@
+# Include or exclude a setting in your build
+
+By default, Unity doesn't include a setting ("strips" the setting) in your built project. For example, if you create a custom reference property where you set a shader asset, Unity doesn't include that property in your build.
+
+You can choose to include a setting in your build instead. You can then get the value of the setting at runtime. The value is read-only.
+
+## Include a setting in your build
+
+To include a setting in your build by default, set the `IsAvailableInPlayerBuild` property of your [settings class](add-custom-graphics-settings.md) to `true`. 
+
+For example, add the following line:
+
+```c#
+public bool IsAvailableInPlayerBuild => true;
+```
+
+## Create your own stripping code
+
+You can override the `IsAvailableInPlayerBuild` property by implementing the `IRenderPipelineGraphicsSettingsStripper` interface, and writing code that conditionally strips or keeps the setting.
+
+Follow these steps:
+
+1. Create a class that implements the `IRenderPipelineGraphicsSettingsStripper` interface, and pass in your [settings class](add-custom-graphics-settings.md).
+2. Implement the `active` property. If you set `active` to `false`, the code in the class doesn't run.
+3. Implement the `CanRemoveSettings` method with your own code that decides whether to include the setting.
+4. In your code, return either `true` or `false` to strip or keep the setting.
+
+For example, in the following code, the `CanRemoveSettings` method returns `true` and strips the setting if the value of the setting is larger than 100.
+
+```c#
+using UnityEngine;
+using UnityEngine.Rendering;
+
+// Implement the IRenderPipelineGraphicsSettingsStripper interface, and pass in our settings class
+class SettingsStripper : IRenderPipelineGraphicsSettingsStripper<MySettings>
+{
+
+  // Make this stripper active
+  public bool active => true;
+
+  // Implement the CanRemoveSettings method with our own code
+  public bool CanRemoveSettings(MySettings settings)
+  {
+    // Strip the setting (return true) if the value is larger than 100
+    return settings.myValue > 100;
+  }
+}
+```
+
+If you implement `IRenderPipelineGraphicsSettingsStripper` multiple times for one setting, Unity only strips the setting if they all return `true`.
+
+## Check if your build includes a setting
+
+You can check if a setting exists at runtime. A setting might not exist at runtime for one of the following reasons:
+
+- Unity didn't include the setting in your build.
+- The current pipeline doesn't support the setting.
+
+Use `TryGetRenderPipelineSettings` to check if the setting exists. `TryGetRenderPipelineSettings` puts the setting in an `out` variable if it exists. Otherwise it returns `false`.
+
+For example, the following code checks whether a settings group called `MySettings` exists at runtime:
+
+```c#
+if (GraphicsSettings.TryGetRenderPipelineSettings<MySettings>(out var mySetting)){
+  Debug.Log("The setting is in the build and its value is {mySetting.myValue}");
+}
+```

Packages/com.unity.render-pipelines.core/Documentation~/choose-whether-unity-includes-a-graphics-setting-in-your-build.md

@@ -0,0 +1,104 @@
+# Get custom graphics settings
+
+To get a custom setting and read its value, use the `GetRenderPipelineSettings` method.
+
+If you want to get a setting at runtime, you must [include the setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md).
+
+For example, the following script gets the `MySettings` settings class from the example in the [Add custom graphics settings](add-custom-graphics-settings.md) page, then logs the value of the `MyValue` setting:
+
+```c#
+using UnityEngine;
+using UnityEngine.Rendering;
+
+public class LogMySettingsValue : MonoBehaviour
+{
+    // Unity calls the Update method once per frame
+    void Update()
+    {
+        // Get the MySettings settings
+        var mySettings = GraphicsSettings.GetRenderPipelineSettings<MySettings>();  
+
+        // Log the value of the MyValue setting
+        Debug.Log(mySettings.myValue);
+    }
+}
+```
+
+## Detect when a setting changes
+
+You can configure a property so it notifies other scripts when its value changes. This only works while you're editing your project, not at runtime.
+
+You can use this to fetch the value only when it changes, instead of every frame in the `Update()` method.
+
+Follow these steps:
+
+1. Create a public getter and setter in your setting class.
+
+2. In the setter, set the value using the `SetValueAndNotify` method, so changing the setting value sends a notification to other scripts.
+
+    For example:
+
+    ```c#
+    using UnityEngine;
+    using UnityEngine.Rendering;
+    using System;
+
+    [Serializable]
+    [SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))] 
+
+    // Create a settings group by implementing the IRenderPipelineGraphicsSettings interface
+    public class MySettings : IRenderPipelineGraphicsSettings
+    {
+        // Implement the version field
+        public int version => 0;
+
+        // Create a MyValue setting and set its default value to 100
+        [SerializeField] private int MyValue = 100;
+
+        public int myValue
+        {
+            get => MyValue;
+            set => this.SetValueAndNotify(ref MyValue, value);
+        }
+    }
+    ```
+
+    If you use `SetValueAndModify' in a standalone application, Unity throws an exception.
+
+3. Use the `GraphicsSettings.Subscribe` method to subscribe to notifications from the setting, and call an `Action` when the setting changes.
+
+    For example:
+
+    ```c#
+    using System;
+    using UnityEngine;
+    using UnityEngine.Rendering;
+
+    public class DetectSettingsChange : MonoBehaviour
+    {
+        
+        // Unity calls the Awake method when it loads the script instance.
+        void Awake()
+        {
+
+            // Log the new value of the setting
+            Action<MySettings, string> onSettingChanged = (setting, name) =>
+            {
+                Debug.Log($"{name} changed to {setting.myValue}");
+            };
+
+            // Subscribe to notifications from the MySettings settings, and call the OnSettingsChanged Action when notified
+            GraphicsSettings.Subscribe<MySettings>(onSettingChanged);
+        }
+    }
+    ```
+
+### Unsubscribe from the notifications from a setting
+
+To stop calling a method when a setting changes, use the `GraphicsSettings.Unsubscribe` method. For example:
+
+```c#
+GraphicsSettings.Unsubscribe<MySettings>(onSettingChanged);
+```
+
+

Packages/com.unity.render-pipelines.core/Documentation~/get-custom-graphics-settings.md

@@ -0,0 +1,10 @@
+# Custom settings
+
+Add custom properties and settings to a Scriptable Render Pipeline.
+
+|Page|Description|
+|-|-|
+|[Adding properties in the menu](adding-properties.md)|Add properties in the **Core Render Pipeline** settings section.|
+|[Add custom graphics settings](add-custom-graphics-settings.md)|Add custom graphics settings to the **Edit** > **Project Settings** > **Graphics** window, then use the values of the settings to customize your build.|
+|[Get custom graphics settings](get-custom-graphics-settings.md)|Get a custom graphics setting and read its value, or detect when a setting changes.|
+|[Include or exclude a setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md)|Choose whether Unity includes or strips a graphics setting in your build, and check if a build includes a setting.|

Packages/com.unity.render-pipelines.core/Documentation~/settings.md

@@ -1,7 +1,8 @@
 #define RAYTRACING_BACKEND_COMPUTE
-#define GROUP_SIZE_X 16
+#define GROUP_SIZE_X 64
 #define GROUP_SIZE_Y 1
 #define RAYTRACING_GROUP_SIZE GROUP_SIZE_X*GROUP_SIZE_Y
+
 #include "DynamicGISkyOcclusion.hlsl"
 
 int g_DispatchWidth;

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/DynamicGI/DynamicGISkyOcclusion.compute

@@ -12,17 +12,17 @@ UNITY_DECLARE_RT_ACCEL_STRUCT(_AccelStruct);
 
 int _SampleCount;
 int _SampleId;
-int _ProbeOffset;
 int _MaxBounces;
 float _OffsetRay;
+float _AverageAlbedo;
+int _BackFaceCulling;
+int _BakeSkyShadingDirection;
+
 StructuredBuffer<float3> _ProbePositions;
 StructuredBuffer<float3> _SkyShadingPrecomputedDirection;
 RWStructuredBuffer<float4> _SkyOcclusionOut;
 RWStructuredBuffer<float3> _SkyShadingOut;
 RWStructuredBuffer<uint> _SkyShadingDirectionIndexOut;
-float _AverageAlbedo;
-int _BackFaceCulling;
-int _BakeSkyShadingDirection;
 
 
 uint LinearSearchClosestDirection(float3 direction)
@@ -49,7 +49,7 @@ void RayGenExecute(UnifiedRT::DispatchInfo dispatchInfo)
     const float kSHBasis0 = 0.28209479177387814347f;
     const float kSHBasis1 = 0.48860251190291992159f;
 
-    int probeId = _ProbeOffset + dispatchInfo.globalThreadIndex;
+    int probeId = dispatchInfo.globalThreadIndex;
 
     RngState rngState;
     rngState.Init(uint2((uint)probeId, 0), 1, _SampleId);

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/DynamicGI/DynamicGISkyOcclusion.hlsl

@@ -146,6 +146,7 @@ internal static bool PrepareBaking()
 
                 if (positions.Length == 0)
                 {
+                    Clear();
                     CleanBakeData();
                     return false;
                 }
@@ -702,8 +703,10 @@ public RayTracingContext context
                         var resources = ScriptableObject.CreateInstance<RayTracingResources>();
                         ResourceReloader.ReloadAllNullIn(resources, k_PackageLightTransport);
 
-                        m_Backend = RayTracingContext.IsBackendSupported(RayTracingBackend.Hardware) ? RayTracingBackend.Hardware : RayTracingBackend.Compute;
-                        m_Backend = RayTracingBackend.Compute; // hardcoded to compute as hardware is broken for now (UUM-56242)
+                        // Hardware backend is still inconsistent on yamato, using only compute backend for now.
+                        //m_Backend = RayTracingContext.IsBackendSupported(RayTracingBackend.Hardware) ? RayTracingBackend.Hardware : RayTracingBackend.Compute;
+                        m_Backend = RayTracingBackend.Compute;
+                        
                         m_Context = new RayTracingContext(m_Backend, resources);
                     }