JIRA: https://jira.unity3d.com/browse/GFXFEAT-381

This PR adds a toggle to the Lighting Window which, when enabled, will ensure that the scene has baked lighting data. If lighting data is missing, it will be baked upon opening the scene. We are primarily adding this due to requests from internal users and external asset developers/maintainers - they want to ship their sample scenes without baked lighting data, and have the bake happen on the users machine. They were using auto generate mode for this before, which no longer exists. 

This mode is much simpler than auto generate mode, in that it only kicks in in 1 scenario:
1. You are opening a scene.
2. The scene has no baked lighting data.
3. The scene has "Auto Initialize Lighting" enabled.

If all the above are true, bake the scene.

The new toggle is used as an upgrade path for auto generate mode. Scenes that were using auto before will have this flag enabled. By default it is disabled for new scenes.

![image](https://media.github.cds.internal.unity3d.com/user/2392/files/bfadec06-f973-45b1-a0cf-6e7370a7f40e)

Update UPM to 8.9.0. This version of UPM contains a fix for the EPERM errors that can happen on Windows when resolving packages. It also makes concurrent operations made on the same project from different processes (e.g. from the Editor and from MSBuild) more robust.

UPM source code diff: https://github.cds.internal.unity3d.com/unity/upm/compare/v8.7.0...v8.9.0
upm-core source code diff: https://github.cds.internal.unity3d.com/unity/upm-core/compare/v8.5.0...v9.0.0

Here's the changelog since UPM 8.8.0:

**Changed**
* [PAK-7761] The `[config:project:add-scoped-registry]` and `[config:project:update-scoped-registry]` IPC routes now take in an optional parameter `overrideBuiltIns` and `newOverrideBuiltIns`, respectively.
  * _This change has no impact on the Editor because the new property is not used._
* [PAK-5226] Improved concurrency handling to use a file-based mutex to synchronize concurrent operations from different UPM processes.

**Fixed**
* [PAK-7758] Re-enabled the in-memory metadata cache in CLI mode to fix the performance regression introduced by [PAK-7740] in 8.8.0.
  * _This regression never affected the Editor because UPM 8.8.0 was not deployed to it._
* [PAK-5250] Fixed an `EPERM` error that could occur on Windows during resolve by making resolved paths unique.
  * _The [EPERM bug](https://jira.unity3d.com/browse/PAK-5250) (user pain 24) was a regression introduced in UPM 8.0.0 which was deployed to trunk in version 2023.3.0a14._
* [PAK-7740] Fixed an issue where the `resolve` command appeared to hang for up to 30 seconds after printing its output to the console.
  * _The Editor was not affected by this issue because it only occurs when the `resolve` command is invoked from the command-line. The Editor uses UPM via IPC rather than CLI._

Jira: UUM-82338

Steps to reproduce:
1. Create a simple VFX Graph and open it
2. Hover the mouse on the Initialize Particle context's Bounds port

Actual results: 
No tooltip is shown

Expected results: 
The following tooltip should be shown:
>The culling bounds of this system.

![](https://jira.unity3d.com/secure/attachment/1539372/1539372_4B2LioyD1c.png)

This change removes the ifdef guards around the render graph global texture clearing logic which effectively enables it run by default.

JIRA: [UUM-68986](https://jira.unity3d.com/browse/UUM-68986)

Blit uses wrong texture source when using blit that sets texture using SetGlobalTexture right after a blit that sets texture using property block.
Based on the comments on the task, it looks like the expected behavior was that property blocks are cleared after each blit, but that wasn't happening. I added a clear after each blit that uses property block, so now they are indeed cleared after each blit and don't interfere with blits that use SetGlobalTexture

Some debug fields like the capacity in the Particle System Info were not updated unless the graph was saved. 

This PR is making the `VFXAnchoredProfilerUI ` implement the `IControlledElement ` to subscribe to the `OnControllerChanged` callback.

The purpose of this PR is to fix memory leaks in verified packages tests on DX12: https://jira.unity3d.com/browse/UUM-77895.

There were simply unreleased compute buffers, because some objects were not released.

Fixes an issue in HDRP where multiple selected lights with different ranges would have their range overridden if another property was changed.

…rFormat and depthBufferBits

Following the fixes of the TextureDesc https://github.cds.internal.unity3d.com/unity/unity/pull/53589
Now updating HDRP to using the new TextureDesc format field instead of colorFormat and depthBufferBits. To simplify reviewing, these changes were not included in the previous PR. 

But without them, the previous PR could potentially introduce a CPU main thread performance regression. The old fields are now properties that call a function to native land so these are more expensive than before. 

However, almost all references to these properties are the setting of the colorFormat, which is just a field set, so having little impact on performance. Most changes replace setting desc.colorFormat with desc.format, which is identical in behavior.

The few changes to the depthStencilFormat require more attention to review. (see commit https://github.cds.internal.unity3d.com/unity/unity/pull/54368/commits/3bd4c5332bdf7d719bbf8bfeb5f9b34d92a07cc8). These could introduce an unwanted change of format.

Also, by using the new desc format field, subtle bugs are avoided.

By default, when people use SRPs instead of built-in, there is very little difference when creating a new scene giving them the impression like the rendering is more or less the same. 

The idea is to give some love to those scene template so that there is something more satisfying by default when creating a new scene using a template. Since we already have a bunch of common x-pipeline assets in the common dependency folder of samples in the packages (Core, HDRP, URP), we can just easily import them and use them to create a super simple scene setup reflecting better the different capabilities of the pipelines. 

Before : 
![image](https://media.github.cds.internal.unity3d.com/user/1764/files/fd97878b-d9b4-402a-a482-ca1bf3d84d24)
After :
![image](https://media.github.cds.internal.unity3d.com/user/1764/files/bf15d481-5fe6-41b9-b662-14e43aa58854)

**Before**:
| URP  | HDRP |
| ------------- | ------------- |
| **Basic** ![_20240807_172410_B4 - URP - Basic](https://media.github.cds.internal.unity3d.com/user/1764/files/9d8cdc8a-aa82-4d19-8e96-c051c02b59e3) | **Indoors** ![_20240807_1722327_B4 - HDRP - Indoors](https://media.github.cds.internal.unity3d.com/user/1764/files/8e61abe1-92be-4b78-9236-c0428100927f) |
| **Standard** ![_20240807_1724421_B4 - URP - Standard](https://media.github.cds.internal.unity3d.com/user/1764/files/fd520097-e129-4c6b-a18c-1719ce5a5740) | **Outdoors** ![_20240807_1722535_B4 - HDRP - Outdoors](https://media.github.cds.internal.unity3d.com/user/1764/files/0a6c4045-0b82-4d43-861d-dc8eb1464d91) |

**After**:
| URP  | HDRP |
| ------------- | ------------- |
| **Basic**  ![Basic_20240807_1701336_URP - Basic](https://media.github.cds.internal.unity3d.com/user/1764/files/b08058cf-2244-4e23-96bd-eb680de9b179) | **Indoors** ![_20240819_1545720_HDRP - Indoors 2](https://media.github.cds.internal.unity3d.com/user/1764/files/94ba4992-8769-41ab-bf39-c38e464f8c56) |
| **Standard** ![_20240819_1545512_URP - Standard 2](https://media.github.cds.internal.unity3d.com/user/1764/files/4438a6aa-646e-46e5-b145-237b26f464f0) | **Outdoors** ![_20240819_154523_HDRP - Outdoors 2](https://media.github.cds.internal.unity3d.com/user/1764/files/4357134e-fccb-4522-bfd4-48ac53583ccf) |





What I did is just added materials / prefabs / models of the unity balls inside the common core samples folder so there's very little size change, the rest was already there.

In URP, the basic scene has been untouched. 
The standard test tries to match what happens in HDRP, with a little fog and the skybox baked (to have some ambient lighting at opening). Also, since realtime reflection probes are disabled by default in a new URP asset, I decided to put the reflection probe as baked and bake it into the levels data. Otherwise, you get a black Unity ball at opening which is not great :)

…any ranges that do not intersect the screen.

This PR fixes an issue in URP **Forward Plus** lighting where extra tiles were being incorrectly masked to be lit by spot lights that did not in fact affect them.

**Forward Plus** tiling job calculates ranges of screen space tiles per horizontal tile line. When both the start and the end points of the line were outside of the screen area it was incorrectly clamping them to screen boundary thus resulting in tiles along the edges of the screen to be classified as lit by that light. This change checks for this case and discards any tile ranges that do not overlap the screen extents.

Before fix:
![image](https://media.github.cds.internal.unity3d.com/user/760/files/c186cff3-4ec8-42e7-a912-fd477465d812)


After fix:
![image](https://media.github.cds.internal.unity3d.com/user/760/files/6e34fcc2-c68b-4b55-95c9-364bfdb26bb7)

This PR adds the necessary snippet in the unlit forward shader template in order to output the correct debug color.

…ering to backbuffer on iOS/macOS

For bandwidth optimisation purpose, when using Render Graph, URP3D and URP2D disable multisample when rendering resolved post processed result to the system backbuffer. To do so, they use the Screen API introduced in #15734. Unfortunately, this API has a one-frame delay on iOS and macOS platforms, resulting in the following confusing situation:

```
int a = Screen.msaaSamples; // a == 4
Screen.SetMSAASamples(1);
assert(a == Screen.msaaSamples); // a still equals 4 on ios and osx (!), 1 otherwise

// next frame

assert(a != Screen.msaaSamples); // a now equals 1
```

To counter this corner case, URP3D/URP2D implementations both introduced some specific logic respectively in `CreateRenderGraphCameraRenderTargets`/`GetImportResourceSummary`, but it doesn't work with camera stacking nor multiple base cameras where these functions are called multiple times for each frame, resulting in the infamous error message:

_Postprocessing Final Blit Pass/Screen Space UlToolkit/uGUI Pass - Overlay: Attachment 0 was created with 4 samples but 1 samples were requested._


Current PR proposes to fix the situation by introducing:
- two static internal properties `tryOptimizeScreenMSAASamples`/`startFrameScreenMSAASamples` in UniversalRenderPipeline class to:
  1. detect whether we can actually do this MSAA optimization, we decide to disable it with multiple base cameras as the optimization can be incorrect if one camera targets directly the backbuffer while the other one targets an intermediate texture.
  2. save the Screen MSAA samples value at the start of the frame, before looping through various cameras and renderers as iOS/macOS have the problematic one-frame delay.
- a new function `AdjustAndGetScreenMSAASamples()` at `ScriptableRenderer` level to:
  1. optimize Screen MSAA samples and handle iOS/macOS corner case
  3. unify specific logics between URP3D and URP2D, removing small already existing divergences between the two

Fix UUM-82513

Fix distortion in Unlit ShaderGraphs

…ng testing (UUM-82417)

* Fixes UUM-82417
* Makes sure URP shaders and ShaderGraph use the same code for pancaking
* Makes sure pancaking is only used with Directional lights
* Removes previous test scenes for this area and creates new ones
* Improved a test script in a URP Project

Shader Graph importer can throw exceptions during asset import, which result in an asset state that is more difficult for a user to correct. I'm suppressing exceptions around precision mismatch between node dependencies, as in most cases this situation is neither reachable nor user actionable nor is the behavior actually erroneous.

This PR fixes an issue that there is a case where some of the allocated NativeArrays do not get cleaned up properly when cleaning up a `ProbeRefenceVolume`. This can happen when recompiling scripts with APV running.

This PR also includes a minor fix for removing a GC allocation when sorting index defragmenting.

Jira: UUM-82505

Jira link: https://jira.unity3d.com/browse/UUM-78721
Before this change, APV had a mechanism to fix seams between multiple subdivision levels at bake time (introduced in this PR: https://github.cds.internal.unity3d.com/unity/unity/pull/46676). However, this did not work across different cells, which is addressed in this PR. 

Before change
<img width="313" alt="Screenshot 2024-09-17 at 2 31 24 PM" src="https://media.github.cds.internal.unity3d.com/user/3903/files/34c419a2-ef10-4422-b8ef-63693a63f730">
After change
<img width="313" alt="Screenshot 2024-09-17 at 2 32 11 PM" src="https://media.github.cds.internal.unity3d.com/user/3903/files/630680e3-c3ef-46f0-82a6-f760375846eb">

This PR fixes the artifact of non-physical DOF if it's used with TAA and dynamic resolution; The artifacts appear for a frame after the screen resolution changes.

Fixes UUM-75818.  A race condition existed where Shader Graph assets where being loaded before the required shader code files that were referenced by those assets. I fixed this by in-lining the required code in the custom code nodes of the Shader Graph assets instead of referencing external code files.

Following this recent PR : https://github.cds.internal.unity3d.com/unity/unity/pull/51061
A bad regression happened making the gameview always have focus blocking the user. 

The fix is now instead of looping through all the gameview (i.e visible cameras) it loops through all the cameras.

Only URP package sample scene script changes. No engine code changes.
Updated sample codes to use the new RenderGraph helper functions in [PackageSample](https://github.cds.internal.unity3d.com/unity/unity/tree/graphics/urp/rg-sample-usehelper/Packages/com.unity.render-pipelines.universal/Samples%7E/URPPackageSamples/RendererFeatures). Doc changes are done in separate PR: https://github.cds.internal.unity3d.com/unity/unity/pull/54526

https://jira.unity3d.com/browse/PLATGRAPH-3794 - URP Post Processing JIRA Task
https://jira.unity3d.com/browse/PLATGRAPH-3793 - URP Lighting JIRA Task

The purpose of this PR is to introduce Yamato jobs for webgpu for the URP Lighting and URP Post Processing test suites. With this change, we will be able to run the jobs off of trunk, and eventually get them into QV once we have 10 passing green tests. Currently, there are about ~3 tests left for post processing and 1 for lighting. These will be gated behind test filters for now, as the goal of this PR is to get the Yamato jobs running. They will be tracked in JIRA and removed from the test filter once fixed. 

Previous PR for the URP Foundation tests here: #53971

…n Core2D

As reported in JIRA, shader warnings "Sprite-Unlit-Default" are thrown after building 2D Platformer Microgame Template.
We can avoid the uninitialized variable warning by relocating the `return` statement outside of the `if` branch.

Small documentation fixes.

Jira tickets:
https://jira.unity3d.com/browse/DOCG-4491
https://jira.unity3d.com/browse/DOCG-4778
https://jira.unity3d.com/browse/DOCG-5403
https://jira.unity3d.com/browse/DOCG-5630
https://jira.unity3d.com/browse/DOCG-5672
https://jira.unity3d.com/browse/DOCG-5969
https://jira.unity3d.com/browse/DOCG-6082

…) and FinalPostBlit pass.

Jira: https://jira.unity3d.com/browse/GFXFOUND-753

This PR optimizes UberPass and FinalPostBlit pass performance for some XR platforms. The default foveation behavior for blit pass is to disable foveation. These two passes are handled as the special case for now.

Q&A
- Do you have a list of devices that this feature will be enable and which is not?
This feature will be enable on XR devices that support Unity uniform foveated rendering. For example, Quest2, Quest3, AndroidXR.
- What manual test have you done?
I haven't done any runtime testing yet on device. I tested on PC with mock to ensure no compiling errors.
- Which project you use to test?
I used a simple cube scene project from the URP foundation test.
- Is there any automated test to test this feature already?
Foveated rendering feature doesn't have automation coverage.

Fix UI overflow and stencil based effects not working in HDR

Fixed some shader warnings when building a player.

Post-migration step: remove the migrated URP docs files.

Solid Angle culling mode low level support was merged to trunk https://github.cds.internal.unity3d.com/unity/unity/pull/53762

This PR exposed the mode to Ray Tracing Settings volume override in HDRP.
![Unity_kTeSd6hhhb](https://media.github.cds.internal.unity3d.com/user/1325/files/3aaa3053-9005-4a87-8305-d3c68d529931)

Nice presentation that I made about culling modes: 
https://docs.google.com/presentation/d/1XegfK-9gZ0lW8OVJzQ8vXISK5hS08HxfkFx4oMHY5YU/edit?usp=sharing

This PR improves the HDRP Sample Water, it removes:
- WaterSurfaceBinder.cs: Use the VFXPropertyBinder for settings global texture is hacky
- EnableVFXAfter.cs: It was a simple hack to mitigate console error

The new approach avoids:
- Multiple calls and possible diverging SetGlobalTextures (there is a warning in component inspector in this case)
- Displaying a VFX before SetGlobalTextures (it disable component meanwhile)

Replace with an independent behavior: `WaterSurfaceBindVFX.cs`:
- Supposed to be allocated once per frame
- In charge of enabling children VFX once the SetGlobalTextures is applied
- Custom Inspector to help debug issue (like the water system being disabled)

Improve SampleWaterSurface.cs integration
- Add error feedback in case of disabled water system and/or missing SetGlobalBuffer (see functional testing status)

Fix Graphics Corruption on Silicon Device which can generates artifact in every single Unity rendering.

![image](https://media.github.cds.internal.unity3d.com/user/42/files/3d4b4fcb-aa19-48c7-bfdb-910439677f6f)

The problem was due to an unexpected call from `Graphics.DrawMeshNow` while *not* being within a Repaint event (see also this [OnSceneGUI documentation](https://docs.unity3d.com/ScriptReference/Editor.OnSceneGUI.html))

- Issue with while rendering mesh in wireframe with mesh module in ParticleSystem, initial repro 🔽 

https://media.github.cds.internal.unity3d.com/user/42/files/45a4c51e-b236-4c3a-907a-5610c5e7b55b

- Found a repro of the wrong DrawHull in HDRP (this is a theoretical repro, I tested on windows) 🔽 

https://media.github.cds.internal.unity3d.com/user/42/files/9057b6d4-c8b4-481e-9421-783e16cbbb6f

- Checked other usage of DrawMeshNow in VFX
   - With DrawCurve  ✅ 
![image](https://media.github.cds.internal.unity3d.com/user/42/files/e739a750-9615-463b-81c2-7fa40a96396c)
   - With Draw Context Border ✅ 
![image](https://media.github.cds.internal.unity3d.com/user/42/files/503aca84-4e6f-4c28-bc8d-b08ec66899ff)
   - With Gizmo rendering `Graphics.DrawMeshNow`, we can trust the `EventType.Repaint`
   
https://github.cds.internal.unity3d.com/unity/unity/blob/eaea05a25d195f7c6e58128434cc9a5130ef3b91/Packages/com.unity.visualeffectgraph/Editor/Gizmo/VFXGizmo.cs#L88

…to Android/Web when using Universal 3D Template

The GPU Driven feature officially doesn't support low graphics APIs, so it has been fixed to exclude Web and OpenGLES API for the problematic shaders.

Before fixing, there were several warnings happened:

```
Shader warning in 'InstanceDataBufferCopyKernels': Buffer count exceeding default GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS. Shader might not work on all hw. Consider combining separate buffers into one containing struct elements. at kernel MainCopyInstances (on gles3)
Shader warning in 'InstanceOcclusionCullingKernels': Buffer count exceeding default GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS. Shader might not work on all hw. Consider combining separate buffers into one containing struct elements. at kernel CullInstances (on gles3)
Shader warning in 'InstanceDataBufferUploadKernels': Buffer count exceeding default GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS. Shader might not work on all hw. Consider combining separate buffers into one containing struct elements. at kernel MainUploadScatterInstances (on gles3)
```

This change adds resource stripping logic to the STP RuntimeResources class. This prevents projects that don't use STP from including it in the build.

This change allows the empty URP template project to build successfully when targeting Windows from a Mac since STP's resources are now stripped and won't cause build failures. However, it doesn't actually allow STP to build for Windows on a Mac successfully. In order to fix that, we'll need native changes that strip out unsupported variants. That change will be handled by a different PR since it's not required to fix the HUP ticket associated with the template project.

Jira: [UUM-81586](https://jira.unity3d.com/browse/UUM-81586)

As reported in JIRA, some shader warnings are thrown after building HDRP 3d template. This PR fixes the following warnings.

```
1. Shader warning in 'HDRP/Lit': parameter 'pdf' is uninitialized when used here [-Wparameter-usage] at Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingBSDF.hlsl(74)
2. Shader warning in 'HDRP/Lit': expression result unused [-Wunused-value] (for raytracing shaders) at Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/VaryingMesh.hlsl(134)
3. Shader warning in 'HDRP/Unlit': expression result unused [-Wunused-value] (for raytracing shaders) at Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/VaryingMesh.hlsl(134)
4. Shader warning in 'Hidden/Core/ProbeVolumeOffsetDebug': use of potentially uninitialized variable (o) at Packages/com.unity.render-pipelines.core/Runtime/Debug/ProbeVolumeDebugBase.hlsl(272)
```

Following this recent PR https://github.cds.internal.unity3d.com/unity/unity/pull/51061
The ensure frame settings thingy has been added twice. 
This PR remove the first one. 

<img width="396" alt="Double" src="https://media.github.cds.internal.unity3d.com/user/1764/files/5a420507-db33-4c97-aef3-154c7fbd0f55">

Add option to compose hair before color pyramid but after clouds

This reverts commit 215ec324aec975b5a7f72aec432165ea586d8f8f. The changes were causing crashes on the DX12 backend due to the stencil flag being used on a DSV associated with a format with no stencil plane. This was leading to D3D12 runtime errors which cause device removal which results in a crash.

We should attempt to set this properly based on the format of the current pass depth attachment, but it requires some non-trivial changes to make the data available. In the meantime, we're reverting the original change to avoid the crash.

Cause:
The WorldLightManager.CollectWorldLights() function collects light information for the scene every frame so that it can be processed for render context.
During this process, it uses the FindObjectsByType<HDAdditionalReflectionData> function to update the reflection probe data.
This is a large part of the load.

Solution:
I decided to statically declare a HashSet on the HDAdditionalReflectionData itself to manage it.
Adding and removing from that HashSet was done by redefining the OnEnable and OnDisable functions to work.
The WorldLightManager just needs to use that HashSet data structure on every frame update.

URP RenderGraph [Jira](https://jira.unity3d.com/browse/URP-1297).
Update the rendergraph samples to the latest APIs and best practices.

Fix UUM-51358

`Bug`: https://jira.unity3d.com/browse/UUM-71240

When using `camera.Render()` with the `Test Runner` and URP + RenderGraph, we retrieve the `Color BackBuffer` here:
![image](https://media.github.cds.internal.unity3d.com/user/1911/files/18e269d4-ddef-48a3-984b-dcc94ceb3bd7)

It's fine when rendering in the `Scene View` and `GameView`, since both views set the right `Backbuffers` before retrieving them for the final rendering. In the context of the `Test Runner`, since it's not a real context or a real PlayerLoop, the `camera.Render` is executed at 'a random moment', so it can be while rendering the Console view, the Hierarchy view, etc. So we end up retrieving the wrong current BackBuffer (for the wrong editor view), which explains the dimensions mismatch.

The fix is simply to stop using `camera.Render`, since it's a nasty and complex bug to fix, so we decided to "hack it" for now. For the GPUDriven tests, we have to override `ProcessRenderRequests` as well to continue testing the `Culling` code in the way it was intended. Using `SubmitCameraRenderRequest` fixes the problem since we don't render in the BackBuffer anymore, but in a TargetTexture.

(Screenshot for my future me, in case I cause a regression. Here we can see all the view being rendered. The one with `IsGameView: 1` is the GameView. The mismatch bug happens when we render the scene (`camera.Render`) right after a non-GameView window (`isGameView: 0`) )

![image](https://media.github.cds.internal.unity3d.com/user/1911/files/05c877af-5279-484d-a494-f628a277e717)

There was a compile error when using the lighting debug views when APV and Shadowmask are active
https://jira.unity3d.com/browse/UUM-82976

Removed RGBM implementation from URP Bloom as it's not used currently while costs some shader variants and branching.

To reintroduce its usage we would have to make changes that would make RGBM Bloom pass twice slower than current SDR Bloom pass. The RGBM mode was targeting low-end devices in the first place, where such performance is not acceptable.

This PR disables instabilities in the XR automation

*[See [this document](https://docs.google.com/document/d/1IREfh8I-uX8NUfyB3H8qjnzRxXIAkZNrtu6g8n4JZIE/edit#heading=h.al4rvw6ezmw6) for details on what can land in 6000.1.]*

*[The PR comment commands commands and workflows to ready and land PR's can be found in the [pipeline documentation](https://internaldocs.unity.com/editor_and_runtime_development_guide/DevelopmentProcess/pr-process/evergreen-merge-queue/#rejoin-the-queue).]*

Add option to specify an alpha threshold when to write depth and movecs when compositing hq lines. This allows HQ Lines to not write depth when the alpha is deemed too low, mitigating problems from algorithms relying on screen space depth (like DOF).

Document Water functions: `GetCausticsBuffer()` `GetDeformationBuffer()` `GetFoamBuffer()`

Fix volumetric cloud shadow clipping issues when the camera is far from geometry.
Fix volumetric cloud clipping when the camera is aligned with the sun direction,  FoV is low and sun is at grazing angle.

This PR 
- removes redundant code, all allocators now use exactly the same RenderTexture creation path, leading to more robust and maintainable code
- uses the RenderTextureDescriptor constructor to create the RenderTexture as a micro optimization. This avoids 7 calls to C++ native land per RT allocation
- fixes a few small bugs and inconsistencies between the allocators now that they all use the same code path
- removes use of RT.format = shadowMap. Only uses explicit fields (graphicsFormat, depthStencilFormat, shadowSamplingMode), no "magic" fields (format=RenderTextureFormat, depthBufferBits)

Remove the disabled menu item that was really confusing for users.

This had to do with the fact that in URP render graph is not available if there is the compatibility mode enabled.

Removing that code and adding a better message. I've not added a new API to know why is not available as is two much work, the user should see the docs and try to enable the Render Graph support by their own.

![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/4f4f0696-60e5-46c7-9ada-02fde4c1df6e)

This change adds logic to URP's GPU occlusion culling code to prevent it from being enabled when running on Qualcomm GPUs. This should allow us to avoid the suspected driver issues for now while we get the real solution figured out.

Fixes: [UUM-74040](https://jira.unity3d.com/browse/UUM-74040)

If a material has a custom GUI powered by the core package's `MaterialEditorExtension.cs`, and if some properties are animated in the timeline, the UI doesn't update to reflect the animation. This change fixes this issue.

Fix https://jira.unity3d.com/browse/UUM-83481

Adopt the explicit depth stencil format property instead of setting depthBufferBits on RenderTextureDescriptor in URP 2D and 3D
This fixes a number of hard to find bugs. The source of these bugs:

renderTextureDesc1.depthBufferBits = renderTextureDesc2.depthBufferBits

does not always result in renderTextureDesc1.depthStencilFormat== renderTextureDesc2.depthStencilFormat being true.

depthBufferBits = 32 -> depending on platform, depthStencilFormat  == D32_S8

depthStencilFormat = D32 -> depthBufferBits == 32

etc. 

Also, 
renderTextureDesc1.depthBufferBits will call a native c++ method, so is more expensive than a field setter of the depthStencilFormat. So this is also a micro optimization.

This change updates the STP frame index calculation logic to use the same logic as the regular TAA code path. This ensures we always add the jitter frame count offset value and don't end up with inconsistent jitter calculations in different parts of the code.

In the previous code, we weren't actually including the jitter frame count offset in the frame index value used by STP's shader constant logic. This was causing the jitter offsets in the constants the jitter offsets used by the projection matrix to diverge in some cases which results in severely degraded visual quality.

Fantasy Kingdom Demo:

Before:
![image](https://media.github.cds.internal.unity3d.com/user/4435/files/176beb23-cccc-460f-b4d2-bb089700fbbf)

After:
![image](https://media.github.cds.internal.unity3d.com/user/4435/files/1b4e69bd-f820-4107-a8fb-dc3b450b9693)

Aside from the changes that affect STP, this PR also contains one additional commit (0cbd31e681c00095cf04c56b7f45b5a2e574979c) that corrects a similar issue in the very high quality TAA filter weight logic.

JIRA: https://jira.unity3d.com/browse/UUM-76255

Fixed an issue where a NullReferenceException was thrown when updating, undoing, and updating a legacy node.

Problem
* When Undoing, a new SGBlackboardField instance was created, but SGBlackboardField.SupplyDataToPropertyDrawer() was not called because the user's click and call to InspectorView.Update did not occur. As a result, m_InspectorUpdateDelegate is null, and subsequent calls to m_InspectorUpdateDelegte throw a NullReferenceException when onAfterVersionChange is called with node Update.

Solution
* perform initialization of all Inspectables (including SGBlackboardField) when Undo/Redo is performed, so that m_InspectorUpdateDelegate is set


In addition to the above issue, updating a node placed in the graph immediately upon opening the graph can also cause a NullReferenceException to be thrown, as the onAfterVersionChange of an SGBlackboardField that was never clicked is called and m_InspectorUpdateDelegate is called. I fixed it to avoid throwing a NullReferenceException with ?.Invoke(); when calling m_InspectorUpdateDelegate. I don't think there should be any other issues because the inspector update is done in the onAfterVersionChange callback of the newly added PropertyNodeView.

Add documentation for making APV compatible with AssetBundles and Addressables in URP and HDRP.

Jira ticket: https://jira.unity3d.com/browse/DOCG-6049

List new physically based sky custom material environment samples.

Document Fix fog scattering in HDRP.

…tation

Following a customer request for that, we realized it wasn't as straightforward to sync multiple water surface on the same scene. 
This addresses how to do it in the documentation. 

![waves](https://media.github.cds.internal.unity3d.com/user/1764/files/7552fc7e-204e-4f49-864f-e8a83c2f66e6)

JIRA: https://jira.unity3d.com/browse/GFXFOUND-567 and https://jira.unity3d.com/browse/GFXFOUND-566

The renderGraph currently uses HDRP's implementation with the OpenGLES and OpenGLCore graphics APIs. This PR makes it possible to use the newer renderGraph compiler

The main error with OpenGL + rendergraph was coming from MSAA missing a resolve texture. The error was that the check for resolve texture was done as if there was no autoresolve so it threw when it didn't find the resolve texture. In OpenGL, autoresolve is handled at the graphics API level so it's normal that there is no resolve texture at the end of the pass. The fix is to skip the check if the platform we are using supports autoresolve

Update SG heatmap default values.

This PR removes the depth bias that was previously being applied to objects during motion vector rendering.
The bias was causing objects to render out of order (in terms of depth) in the motion vector pass which led to
ghosting artifacts when temporal effects (like TAA or STP) use the inaccurate motion vector data.

After some analysis, it seems that the bias was necessary before because of two things:
1. The depth format used by the motion vector pass didn't always match the format used to generate the depth buffer. This was causing precision issues due to format conversions. This PR corrects the issue by ensuring the same format is always used.
2. The camera motion vectors shader was unintentionally sampling depth via a RelaxedPrecision qualified sampler type. On some platforms (Samsung S21 Android+VK), this was allowing the device to quantize the sampled depth data from its original format during sampling. This effectively meant we got 24/32 bit depth converted to 16-bit during sampling, and then tried to store out 24/32 bit depth after. This led to shadow-acne-like artifacts on CI. Normally, a hack in the hlslcc compiler is supposed to prevent depth texture sampling from using RelaxedPrecision, but the sampler was renamed at some point so this no longer appears to happen. This PR works around the issue by loading the depth data via image load rather than using a sampler which solves the issue on the S21. In the future, we should go back and find a better way to ensure depth samples don't end up qualified with RelaxedPrecision, but for now this approach solves a pressing issue for us and is still technically correct.

…Resources definition

jira: https://jira.unity3d.com/browse/UUM-82247

Since the class UniversalRenderPipelineRuntimeXRResources is wrapped in the #if ENABLE_VR && ENABLE_XR_MODULE preprocessor, it will not compile on platforms where ENABLE_VR is not defined.

This is why on platforms like tvOS, where ENABLE_VR is not defined, a warnning is shown that no matching type found for the UniversalRenderPipelineRuntimeXRResources data added to Assets/Settings/UniversalRenderPipelineGlobalSettings.asset.

The UniversalRenderPipelineRuntimeXRResources class definition should compile regardless of platform, so I removed the #if ENABLE_VR && ENABLE_XR_MODULE preprocessor.



### Before:
<img width="872" alt="image" src="https://media.github.cds.internal.unity3d.com/user/6374/files/1886efc7-b93e-4bbe-8ab2-4471f56c50b5">

Warning shows up when open the URP template project on tvOS platform.

### After:
No warning shows up.

* Add volumetric fog samples' descriptions from `VolumetricSamplesDescriptions.json`
* Refactor task to use samples

Add the documentation for Custom Render Texture shader graph that is missing for more than 2 years now 😱 

See the doc page here:
https://github.cds.internal.unity3d.com/unity/unity/blob/graphics/sg/fix-custom-render-texture-documentation/Packages/com.unity.shadergraph/Documentation~/Custom-Render-Texture.md

https://jira.unity3d.com/browse/UUM-78839
The thing is that this validation should not show the fix button, hide buttons of validations without a fixer

https://jira.unity3d.com/browse/UUM-77499
Simplify it to a single line.

Improve the UI:

Version shown on the window title:

![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/7568d8a3-a649-4632-b4b9-d0b188265dc7)

Package manager and show on start are always visible in the toolbar.

![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/567b330d-145d-4e9f-a27b-d9db96a5e62f)

Helpboxes with button instead of custom helpboxes

![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/4ee1ed7a-31ef-4406-b395-7e17ff91bb8b)

Splitting sections HDRP, VR and DXR. As other windows an inspectors are doing.
![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/af543313-dacd-4dd4-a4fb-fdce4e3c6962)

Also, each section has a shortcut to it's documentation:
![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/1b3dfdfb-394a-4988-980f-75aea71eaa1d)

Having a general settings section.
![imagen](https://media.github.cds.internal.unity3d.com/user/3279/files/66140161-4fcc-4dcb-ab88-48ceb787203b)

…eaming enabled

UUM-73635

When creating CellInstancedDebugProbes.probeBuffers, some of the CellData.probePositions vector components are irregularly NaN or very large.

The ProcessDiskStreamingRequest API reads streaming data asynchronously. The reason for the errors is that debug rendering is called while the asynchronous work is not finished.

Modified to call debug rendering when streaming is not in progress.

…lay Mode without saving changes

This PR fixes the reported bug and add a unit test.

Why the bug occurs: If a SG window (a `MaterialGraphEditWindow`) is open and its `m_GraphObject` field is null, then it reverts to the last saved state. `m_GraphObject` becomes null in `MaterialGraphEditWindow.OnDisable()`, which is called as a result of Domain Reload.

Fix: Release `m_GraphObject` only in `OnDestroy()`

Another issue: When a SG window is closed, `MaterialGraphEditWindow.OnDestroy()` is supposed to release `m_GraphObject` and its revelant resources. But `OnDisable()` makes only `m_GraphObject` null therefore the cleanup in `OnDestroy()` does not run. Same goes for `m_GraphEditorView`.

Jira: [UUM-71157](https://jira.unity3d.com/browse/UUM-71157)

As reported in JIRA, the 4th layer does not work on LayeredLit material when it is copied asset. This is also reproducible if we set the last layer's material to `None` because when the material is copied, the `GUIDArray` is trimmed. By setting the layersGUID size to 4(`kMaxLayerCount`), we can guarantee that the size of the layers to 4 as it is initialized before.

| Before | After |
| -- | -- |
|![image](https://media.github.cds.internal.unity3d.com/user/3842/files/a42c0064-3754-4f13-a446-0ba8e6712349)|![image](https://media.github.cds.internal.unity3d.com/user/3842/files/d56a263b-f6f0-4da1-84a6-90dd9e3fb1ce)|

Fix some minor points in the STP documentation pages

Fix camera stack issues relating to render scale. Clamps alpha to 1 as alpha is expected to be transparency. Fixes a NaN issue with Lens Distortion.

This PR fixes UUM-77168, which was a regression from UUM-62522. The main issue is that the "current render pipeline" can be empty string when no render pipeline is selected (which is a valid case). UUM-62522 added a fix to just check the currently supported subshaders by the current render pipeline, but did not handle the empty string case.

While investigating this fix, there was also a warning caused by including `Core2D.hlsl`. That has been fixed, along with some minor updates to generate better Metal shader code.

On Mac, it was not possible to edit the parameters of unsupported upsampling algorithms like DLSS and FSR2. This PR allows to change the settings, note that the algo still doesn't work on these platforms and the user is informed with a help box:
![image](https://media.github.cds.internal.unity3d.com/user/745/files/c8c5bcf1-6317-4f9d-bea9-114f0c77fe9a)

Fix UUM-77828
The render graph compiler was not correctly handling sub-resources as attachments both in c# and c++. This could cause rendering to slice x and y to be merged into a single render pass that rendered only to slice x. This is fixed by comparing not only the resource but also the array slice and mip index.

Also fixes the following minor issues discovered during investigation of this bug:
- Add Slice/Mip data to the render graph debugger which made it difficult to debug this
- Add some extra validation to the descriptor to avoid silently failing when creating invalid texture descriptors
- Renderpass C++ api validation was broken and considered some valid setups to be invalid since it was not comparing the aray slice and mip when testing attachments for equality.

This PR fixes a bug found by a client when it was trying to use two partial textures in a custom material at UI Pass, even as they were marked as global, as no other Pass was using it later they was reused by other passes, what throws wrong results in the expected render.

When a render pass can run arbitrary materials from users, then it needs to declare it uses All Globals in the pass, in any other case, the resources could be discarded and reused by other passes.

With the change made in this PR, the UI Pass will enable the UseAllGlobals to avoid this error with custom UI shaders.

Even the use of `AllGlobals` can affect performance, we need this change for correctness.

Downgrade UPM from 8.9.0 to 8.7.0.

A change included in UPM 8.8.0 (never deployed individually in trunk) introduced a HUP issue in the Rider IDE's Unity support because the Rider code used hard-coded assumptions about the location of packages on disk rather than relying on outputs from Unity's package manager. 

While this was reported to JetBrains as a Rider bug, they reached out to us [over Slack](https://unity.slack.com/archives/CP9UVU6MB/p1728388524010679). Since this directly affects Unity user workflows, [we decided to downgrade UPM](https://unity.enterprise.slack.com/archives/C07S55ENJTA) to the version just before the one that introduced the package path change to give JetBrains some time to roll out a pre-emptive fix by using the file `Library/PackageManager/projectResolution.json` instead of reading input files and reimplementing the UPM logic for resolved path building. 

The following describe this upgrade PR as if we were redoing the UPM upgrade from 8.6.0 to 8.7.0 instead of 8.9.0:

UPM source code diff: https://github.cds.internal.unity3d.com/unity/upm/compare/v8.6.0...v8.7.0
upm-core source code diff: https://github.cds.internal.unity3d.com/unity/upm-core/compare/v8.4.1...v8.5.0

UPM 8.7.0 changelog entry:
* **Added** [PAK-5270] Introduced a new `overrideBuiltIns` property to scoped registry configuration that will allow resolving packages from a registry even when they are built-in.
  * _This ties into the `Removed / PAK-5270` entry below._
* **Changed** [PAK-5226] Operations that require exclusive access to a resource no longer fail if the resource is busy. Instead, they wait for the resource to become available.
  * _QoL improvement._
* **Removed** [PAK-5270] Removed the fix introduced in [PAK-4540] allowing built-in packages to be overridden by registry source.
  * _This fixed a workflow issue when the project manifest referenced another version than the built-in version (this could happen when importing a .unitypackage referencing one of the core packages if the Unity version of the .unitypackage was newer than the current editor version). However, we found examples of people relying on this behaviour who "forked" core packages and published them on their custom scoped registries, which is why the `overrideBuiltIns` property was also added to the scoped registry configuration (no UI)._ 
* **Security** Updated the list of well-known certificates to the _2024-07-02_ revision.
  * _Regular maintenance update._

@relmgmt: This PR is based on a revert of  https://github.cds.internal.unity3d.com/unity/unity/pull/53876. I'm including the retroactive release notes as if we had instead upgraded from 8.6.0 to 8.7.0. Once Rider has this fix, we will revert this PR to upgrade again to 8.9.0, and update the release notes to provide only the entries relevant to the 8.7.0...8.9.0 change.

Fix shader errors when building the URP 3D Template on Metal.

Foveated Rendering related .hlsl files should be included in this order:
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl"

A motion vector pass generated by Shader Graph includes headers in this order:
    #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
    ...
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl"

Here Lighting.hlsl includes RealtimeLights.hlsl includes Clustering.hlsl, and Clustering.hlsl includes only FoveatedRendering.hlsl. Therefore definitions in FoveatedRenderingKeywords.hlsl are not included in the final generated code, causing shader compilation errors.

My PR simply reorder includes so that Lighting.hlsl comes after.

This PR adds a new option for cross-fade dithering type, which achieves dithering by stencil test instead of alpha testing. By enabling this option, the shader keyword LOD_FADE_CROSSFADE is stripped in forward/deferred pass and in depth-normal prepass (Limitation: it is not stripped if GPU instancing is enabled or if render graph is disabled). Stencil override is incompatible with this option in the above passes because 2 stencil bits (4 and 8) and the comparison function are overridden to render cross-fading objects.

The cross-fade has 4 transition steps. The following image shows a mesh cross-fading with different transition amounts.
![image](https://jira.unity3d.com/secure/attachment/1467810/image-2024-06-14-15-30-58-888.png)

4 transition steps correspond to 4 stencil values. Fade-in and fade-out complement each other, and it is done by using complementing comparison functions.

There is a warning message if stencil override is used along with this option.

![image](https://media.github.cds.internal.unity3d.com/user/7232/files/38193843-e691-4603-8232-4fde87606e7c)

…n (APV)

This PR fixes the issue of using unmatched APV cell data with the temporary baking set.

When an existing baking set asset is removed from itself or outside of the editor, the Adaptive Probe Volumes light tab creates a new temporary baking set. However, cached data wasn't removed clearly in ProbeReferenceVolume.

So it has been fixed to remove the loaded data by calling AddPendingSceneRemoval when a temporary baking set is created.

This PR aims to fix the issue of the Overlay UI not being displayed on screen, when using RG + HDR Output + FSR/FXAA.
The bug was caused by the missing Shader Keyword HDROverlay in finalPostPass, as the method SetupHDROutput would only set the keyword for the uberPass shader.
When FSR/FXAA are enable on RenderGraph more render passes are created and the rendering UI overlay happens in FinalPost, so now we set the keyword based on the material given.

Fix sanitize issue introduced at https://github.cds.internal.unity3d.com/unity/unity/pull/25236 (merged in 2023.3.0a7)
The random setting wasn't migrated.
It would have caused an unlink and change of behaviour in the graph if a block meets these two condition:
- Use former Set Custom Attribute Block
- Random is different than "Off"

Fixes [UUM-82679](https://jira.unity3d.com/browse/UUM-82679).

The relevant HDRP passes look as follows:

```
Render Opaques - write Depth
RenderSky - test Depth
PreRefractionDepthPrepass - write pre-refraction transparents to Depth
DuplicateDepth - copy Depth to PreRefractionDepth
TransparentDepthPrepass - write post-refraction transparents to Depth
RenderClouds - test Depth
```

HDRP has the ability for transparent objects to show up in the refractions of other transparent objects. For this feature, transparent draws are split into two passes:
1. Pre-refraction transparents are rendered first. These are transparents that have their Rendering Pass set to "Before refraction".
2. Post-refraction transparents are rendered afterwards. These are materials with a refractive material on them.

The depth buffer is copied between these two passes.

Before, the final depth buffer was used to test while rendering clouds, which is why they did not show up behind refractive objects. This PR changes the `RenderClouds` call to test against the pre-refraction depth buffer, and hence clouds do show up behind refractive materials.

![image](https://media.github.cds.internal.unity3d.com/user/2726/files/39d61641-e3b0-4ffa-83a1-3586a0d952a6)
_Before: The refractive yellow cube incorrectly masks out the green cloud layer. The blue cube is pre-refraction, and does correctly show up behind the yellow cube._


![image](https://media.github.cds.internal.unity3d.com/user/2726/files/0cb11761-856b-48d5-a18b-cc68b0dbaab1)
_After: The green cloud layer is rendered correctly behind the yellow refractive cube._

This PR also modifies the cloud layer test to check for transparent materials.
![image](https://media.github.cds.internal.unity3d.com/user/2726/files/a6820343-8e72-42f1-92d4-71b651f893f9)

This PR allow horizontal deformation with HDRP water system.
Please note that this option is disabled by default thus won't cause any change unless specifically checked by users. 
This was something that was discussed and tested many months ago during multiple hackweeks and was asked by multiple users (forums and via customer support : https://unity.slack.com/archives/C02EZE47X0T/p1726521015570729)

This allows the SG deformers to output a vector3 instead of a single float for deformation. This is split in two to allow for more flexibility in authoring and scalability: 
![image](https://media.github.cds.internal.unity3d.com/user/1764/files/14e40b0e-47c1-424a-bb43-5485f511459f)

This enables behavior like this:

https://media.github.cds.internal.unity3d.com/user/1764/files/1970fc0c-0082-4923-b7f8-b8151b37bf07

Since the increase in memory cost is not insignificant this is disabled by default in an HDRP setting under Water section
![image](https://media.github.cds.internal.unity3d.com/user/1764/files/ef4ca279-9260-4ddd-9755-98b399a6bc51)

Documentation needs to include some limitation of this when it's enabled, this can be done later since water decals is still not properly documented. (Compability with underwater or CPU simulation)
Jira link for documentation : https://jira.unity3d.com/browse/DOCG-6165

…DOCATT-1045

*[This PR is intended to fix broken links and formatting issues in the Shader Graph documentation for the following JIRA tickets:

- DOCATT-589
- DOCATT-1045 ]*

The failing CI jobs has been slowing developer velocity, as they could not rely on the test result status for easy verification. The point of this PR is to unblock said devs. 

In effect, this PR updates the test refs of those who needed to be updated and updates the UniversalGraphicsTest_Terrain test project to U6. It also disables some tests on specific platforms where more investigation is required (see [ENV-5648](https://jira.unity3d.com/browse/ENV-5648)).

This is an additional fix to 77050 that addresses SRP-Batcher incompatibility for Shaders created with ShaderGraph for 2D Renderers.

SRP-Batcher for 2D goes through a Custom Path and does not support TexelSize (_TexelSize) and Offset (_ST). 
However ShaderGraph enforces use of TexelSize whenever Textures are sampled due to initializing TexelSize when constructing UnityTexture2D.
This PR makes it optional just like Offset.

Fixes some small bugs:
* https://jira.unity3d.com/browse/UUM-83561
* https://jira.unity3d.com/browse/UUM-83578
* https://jira.unity3d.com/browse/UUM-84509

Fix shader warnings in VFX graphs in URP 3D Sample:
> use of potentially uninitialized variable (BuildVaryings) at /Repos/com.unity.template.urp-sample/Library/PackageCache/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl(73) (on d3d11)

```
Varyings SomeFunction()
{
    Varyings output = (Varyings)0;
    if (some) return output; // here
    output.field0 = ...;
    output.field1 = ...;
    return output;
}
```

FXC thinks returning 'output' in the midst of a function may cause it to be not fully initialized, when it's already zero-initialized. I rearranged the source code to remove intermediate return statements.

allow render graph passes with reflection

Fix two issues reproducible with the Sample Water Surface node in HDRP.

The first one is simply about a delayed field attribute missing, it prevents recompilation of the graph while editing settings:

https://media.github.cds.internal.unity3d.com/user/42/files/05b1db56-78db-472c-8d57-888a598869fa

The second one was more problematic, it displayed an error `Expression graph was marked as dirty after compiling context for UI` but simply due to an incorrect `Equals` implementation.

https://media.github.cds.internal.unity3d.com/user/42/files/70854649-a86a-45b4-8ab2-8c65aa1033ef

…ocess is disabled.

This PR ensures custom post-process effects in the `HDRenderPipeline` are disabled when post-processing is disabled.

Fixes UUM-72639 by ignoring material variants when converting, and logging an informative message to the console for awareness:
![image](https://media.github.cds.internal.unity3d.com/user/696/files/4ae2bcd6-e62e-480b-8f83-59164578bbd2)

…rnels.

This PR fixes an issue where the `PROCEDURAL_INSTANCING_ON` keyword is incorrectly applied to the compute-kernels generated using the `VertexSetup.template`, leading to instancing-related errors at compile-time (since `UNITY_INSTANCING_PROCEDURAL_FUNC` is undefined for compute-shaders).

The solution presented here isn't ideal, but since shadergraph has minimal compute-shader generation support (i.e. there are no good mechanism to include/exclude keywords for kernels generated by shadergraph), this should be good-enough for now.

Fix for UUM-84033 by adding a missing documentation link for the `Lens Flare Data (SRP)` asset on [URP](https://docs.unity3d.com/6000.0/Documentation/Manual/urp/shared/lens-flare/lens-flare-asset.html) and [HDRP](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@latest/index.html?subfolder=/manual/shared/lens-flare/lens-flare-asset.html).