[6000.0] Fixed Custom URP Compile errors

.gitignore

@@ -38,7 +38,6 @@
 ShaderGraph/DebugOutput.meta
 ShaderGraph/DebugOutput/**
 ShaderGraph/Testing/IntegrationTests/.Failed
-TestProjects/*/ProjectSettings/ProjectVersion.txt
 TestProjects/VisualEffectGraph_HDRP/GraphViz/
 
 */manifest-updater.py

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

@@ -10,6 +10,66 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 Version Updated
 The version number for this package has increased due to a version update of a related graphics package.
 
+## [17.0.3] - 2025-02-13
+
+This version is compatible with Unity 6000.0.39f1.
+
+### Added
+- helper functions to Render Graph.
+
+### Changed
+- Improved the Native Render Pass CPU performance by implementing a Render Pass pooling system (URP RG).
+- Reworked the additional properties.
+- Improved Render Graph warning message in URP when missing RecordRenderGraph implementation.
+- Displayed subpass and attachment index on Render Graph Viewer.
+- Added a new icon and tooltip if there are multiple usage details for a resource block on Render Graph Viewer.
+- Fixed Render Graph Viewer being called before Render Graph execution and its resource deallocation.
+- Added What's New in Unity 6 to SRP Core Package.
+
+### Fixed
+- Added messaging to the Rendering Debugger UI to make it clearer that GPU Resident Drawer settings do not work if GPU Resident Drawer is not enabled. 
+- GPU Resident Drawer: Changed BatchRendererGroup variants was not reinitializing the system.
+- Improved the compiler logic that detects if the current render target is being used outside the current native render pass (e.g., when the pass is broken up by an unsafe pass), and determines the store action for this case. The fix now ensures that the `StoreAndResolve` action is used when the resource is read by an Unsafe Pass. 
+- Rendering Debugger - Keep the correct selected panel when entering and exiting from playmode.
+- Removed "depth only surface" warning message appearing when using Game View Gizmos in URP RG.
+- Render Graph Viewer: Fixed missing min height when resizing side panel vertical splitter.
+- Render Graph Viewer: Fixed possible NullReferenceException when opening the project.
+- Render Graph Viewer: Fixed side panel splitter state after returning from empty pass/resource filter.
+- Render Graph Viewer: Fixed long resource name clipping issues in side panel.
+- Render Graph Viewer: Fixed tooltip size bug and restructure tooltip messages.
+- Fixed memory usage regression causing up to 150MB higher memory usage in URP player builds.
+- Added missing user-facing text when inspecting volume profile when render pipeline has not been properly initialized yet.
+- Game view background turn yellow after enable render graph.
+- Fixed light.useViewFrustumForShadowCasterCull previously being ignored for shadow cascades. light.useViewFrustumForShadowCasterCull now works as expected.
+- Fixed an exception thrown when Render Graph pass was missing its renderFunc but tried to compute its hash value.
+- Fixed Render Graph Compiler logic bug where UnsafePass using MSAA texture could result in missing resolve surface errors.
+- Fixed incorrect default source texture name for Render Graph blit util function.
+- Fixed NullReferenceException when jumping to pass code from Render Graph Viewer.
+- Fixed _FOVEATED_RENDERING_NON_UNIFORM_RASTER shader compilation errors.
+- Fixed a null reference exception on the Graphics Settings stripper.
+- Avoid that the same volume can be registered more than 1 time in the VolumeManager.
+- Fixed crash caused by indirect argument buffer being one item too small.
+- [GLES3] Fixed an issue where Blitter.GetBlitMaterial(TextureDimension.Tex2DArray) returns null.
+- Fixed alignment of the columns on DebugUI.Foldouts.
+- Fixed BlitTexture(RenderTargetIdentifier) to be affected by PostProcessing.
+- Fixed errors that could happen when interacting with the Default Volume Profile context menu in Project Settings > Graphics.
+- Fixed a numerical error of ComputeEdgeFactor(V1, V2) when two vectors are colinear.
+- Fixed potential data corruption due to incorrect native render pass store action in NRP compiler.
+- Added stencil flag to read-only depth logic in NRP compiler to avoid unintentional usage of depth read and stencil write states on some APIs.
+- Added more error checking to `RenderGraph.ImportTexture` to prevent importing RenderTextures that have both color and depth.
+An exception will now be thrown in this case.
+- Fixed  an issue when using multiple AddBlitPass would binds the _BlitTexture wrongly.
+- Modified TextureDesc so it can now use GraphicsFormat to set the depthStencil format (TextureDesc.format). The TextureDesc.depthBufferBits and TextureDesc.colorFormat fields are now properties that call GraphicsFormatUtilities functions for backwards compatibility. The descriptor now unambiguously describes a single resource, either color or depth. Therefore, TextureHandle clearly represents a single resource.
+- Modified RTHandle allocators so they can now use GraphicsFormat to set the depthStencil format (TextureDesc.format). The allocators take a single format for either color or depth stencil to avoid incorrectly creating depth instead of color or vice versa.
+- Fixed a crash on DX12 due to invalid subpass flags passed by native render pass compiler.
+- Fixed an issue where Lens Flare was not rendering properly in OpenGLES3.
+- Fixed render graph incorrectly handling rendering to array slices and mipmaps other than 0 in some cases.
+- Render Graph Viewer - Improved UI lock when searching on side panels.
+- Render Graph Viewer - Padding corrected on burger menu on the side panels.
+- Fixed missing STP shaders & visual artifacts when targeting GLCore renderer
+- Rendering Debugger - Silent crash when selecting a Volume component with public RTHandles.
+- Fixed a crash on leaking streaming scratch buffer differently sized into the current pool.
+
 ## [17.0.2] - 2024-04-02
 
 This version is compatible with Unity 6000.0.0b15.

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

@@ -20,11 +20,13 @@
   * [RTHandle fundamentals](rthandle-system-fundamentals.md)
   * [Using the RTHandle system](rthandle-system-using.md)
 * [Custom Material Inspector](custom-material-inspector.md)
-* [Custom settings](settings.md)
+* [Custom graphics settings](settings.md)
   * [Adding properties in the menu](adding-properties.md)
-  * [Add custom graphics settings](add-custom-graphics-settings.md)
+  * [Add a settings group](add-custom-graphics-settings.md)
+  * [Add a setting](add-custom-graphics-setting.md)
+  * [Customize the UI of a setting](customize-ui-for-a-setting.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)
+  * [Include or exclude a setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md)
 * [Shaders](shaders.md)
   * [Use shader methods from the SRP Core shader library](built-in-shader-methods.md)
   * [Synchronizing shader code and C#](generating-shader-includes.md)

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

@@ -0,0 +1,60 @@
+# Add a setting
+
+Add a simple property or a reference property to a [custom graphics settings group](add-custom-graphics-settings.md). You can change the values of the setting in the Unity Editor while you're editing your project.
+
+Unity serializes the graphics settings you add. For more information, refer to [Script serialization](xref:um-script-serialization).
+
+**Note:** The value of a custom setting is static in a built project. You can't change the setting at runtime.
+
+## Add a simple property
+
+To add a simple property, add a field to your `IRenderPipelineGraphicsSettings` class using the `[SerializeField]` attribute. For example:
+
+```c#
+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+[Serializable]
+[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))] 
+
+// Create a new settings group by implementing the IRenderPipelineGraphicsSettings interface
+public class MySettings : IRenderPipelineGraphicsSettings
+{
+  // Add a private field for the version property
+  int internalVersion = 1;
+
+  // Implement the public version property
+  public int version => internalVersion;
+
+  // Add a float setting
+  [SerializeField]
+  private float mySetting = 1.0f;
+
+  // Add a Material reference property
+  [SerializeField]
+  public Material myMaterial;
+}
+```
+![](Images/customsettings-addsetting.png)<br/>
+The **Edit** > **Project Settings** > **Graphics** window with the new custom setting from the example script.
+
+## Set the default asset for a reference property
+
+To set a default asset for a [reference property](xref:um-editing-value-properties#references), for example a material, add a [`[ResourcePath]`](https://docs.unity3d.com/6000.1/Documentation/ScriptReference/Rendering.ResourcePathAttribute.html) attribute. For example:
+
+```c#
+public class MySettings: IRenderPipelineGraphicsSettings
+{
+  ...
+  [SerializeField]
+  [ResourcePath('path-to-default-file')]
+  public Material myMaterial;
+}
+```
+
+## Additional resources
+
+- [SerializeField](xref:UnityEngine.SerializeField)
+- [Reference properties](xref:EditingValueProperties#references)

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

@@ -1,92 +1,57 @@
-# Add custom graphics settings
+# Add a settings group
 
-You can add custom graphics settings to the **Edit** > **Project Settings** > **Graphics** window, then use the values of the settings to customize your build.
+To add a custom graphics settings group to a Scriptable Render Pipeline, implement the `IRenderPipelineGraphicsSettings` interface.
 
-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.
+Follow these steps:
 
-## Add a setting
+1. Create a class that implements the `IRenderPipelineGraphicsSettings` interface, then add a `[Serializable]` attribute.
 
-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).
+    **Note:** If you don't add a `[SupportedOnRenderPipeline]` attribute, the setting applies to any Scriptable Render Pipeline. However each Scriptable Render Pipeline stores its own value for the setting.
+
+3. Implement the `version` property. Unity doesn't currently use the `version` property, but you must implement it. 
+
+Unity adds the new settings group to the **Edit** > **Project Settings** > **Graphics** window.
+
+For example, the following script adds a settings group called **My Settings** in the **Graphics** settings window of the Universal Render Pipeline (URP).
 
 ```c#
+using System;
 using UnityEngine;
 using UnityEngine.Rendering;
-using System;
+using UnityEngine.Rendering.Universal;
 
 [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;
+  // Add a private field for the version property
+  int internalVersion = 1;
+
+  // Implement the public version property
+  public int version => internalVersion;
 
-  // 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.
+![](Images/customsettings-settingsgroup.png)<br/>
+The **Edit** > **Project Settings** > **Graphics** window with the new custom settings group from the example script.
 
-To add a reference property, follow these steps:
+## Change the display order of settings groups
 
-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.
+To change where a settings group appears, use the `[UnityEngine.Categorization.CategoryInfo]` attribute. For example, the following code gives the settings group the name **My Settings** and moves the group to the top of the graphics settings window.
 
 ```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
+[UnityEngine.Categorization.CategoryInfo(Name = "My Settings", Order = 0)]
+public class MySettings : IRenderPipelineGraphicsSettings
 {
-  // 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))]
-```
+## Additional resources
 
+- [Add a setting](add-custom-graphics-setting.md)

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

@@ -1,31 +1,35 @@
 # 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.
+By default, Unity doesn't include a setting ("strips" the setting) in your built project to optimize performance and reduce build size. For example, if you create a custom reference property that points to a shader asset, by default 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.
+You can choose to include a setting in your build instead. The value of the property is read-only at runtime.
 
 ## 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`. 
+To include a setting in your build by default, set the `IsAvailableInPlayerBuild` property of your [settings group class](add-custom-graphics-settings.md) to `true`. 
 
-For example, add the following line:
+For example:
 
 ```c#
-public bool IsAvailableInPlayerBuild => true;
+public class MySettings: IRenderPipelineGraphicsSettingsStripper
+{
+  ...
+  // Make settings in this class available in your build
+  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.
+To conditionally control whether Unity includes or excludes a setting in your build, override the `IsAvailableInPlayerBuild` property by implementing the `IRenderPipelineGraphicsSettingsStripper` interface.
 
 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.
+3. Implement the `CanRemoveSettings` method with your own code that decides whether to include the setting. Return `true` to strip the setting, or `false` to include 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.
+For example:
 
 ```c#
 using UnityEngine;
@@ -41,8 +45,8 @@ class SettingsStripper : IRenderPipelineGraphicsSettingsStripper<MySettings>
   // 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;
+    // Strip the setting (return true) if useMyFeature is false
+    return !settings.useMyFeature;
   }
 }
 ```
@@ -55,8 +59,9 @@ You can check if a setting exists at runtime. A setting might not exist at runti
 
 - Unity didn't include the setting in your build.
 - The current pipeline doesn't support the setting.
+- The setting is in an assembly that Unity doesn't include in your build. Refer to [Organizing scripts into assemblies](xref:um-script-compilation-assembly-definition-files) for more information.
 
-Use `TryGetRenderPipelineSettings` to check if the setting exists. `TryGetRenderPipelineSettings` puts the setting in an `out` variable if it exists. Otherwise it returns `false`.
+To check if the setting exists, use the `TryGetRenderPipelineSettings` API. `TryGetRenderPipelineSettings` puts the setting in an `out` variable if the setting exists. Otherwise it returns `false`.
 
 For example, the following code checks whether a settings group called `MySettings` exists at runtime:
 
@@ -65,3 +70,7 @@ if (GraphicsSettings.TryGetRenderPipelineSettings<MySettings>(out var mySetting)
   Debug.Log("The setting is in the build and its value is {mySetting.myValue}");
 }
 ```
+
+## Additional resources
+
+- [Organizing scripts into assemblies](xref:um-script-compilation-assembly-definition-files)