Official SRP v12 beta is available now

Hi everyone,

As part of the Unity 2021.2 beta release, the v12 Scriptable Render Pipeline (SRP) packages are available now. This release is a continuation of our effort from 21.1 and is based on our 2021 goals shaped around Unity’s product commitments, announced in “The road to 2021” blogpost. Next to making further improvements in the quality, stability, and performance of SRPs, we have also added many new features to both URP and HDRP. For URP, the main focus has been around reducing the feature parity gap with the Built-in render pipeline. For HDRP, we have focused on performance improvements and artists’ tooling.

Read to learn about some important updates and features in this beta release.

Universal Render Pipeline (URP)

Deferred Renderer


Decals


Light Cookies


Reflection Probe Blending and Box Projection


2D Renderer improvements


SwapBuffers

In this release, Universal Renderer manages and operates on multiple camera color buffers in the backend. If you need to write effects that read from and write to the camera color buffer, you can use the new ScriptableRenderPass.Blit method in your Scriptable Renderer Feature. Using this new method, you can apply effects to the color buffer without managing and handling multiple camera color buffers yourself.

Built-in Converter Improvements


Visual Debugging Improvements
Improvements in this release bring Universal Rendering Pipeline’s (URP) Scene Debug View Modes closer to parity with the options available in Built-in Renderer. Similar to HDRP Render Pipeline Debug Window, URP Render Pipeline Debug Window is also included as a new debugging workflow for URP in this release.

Package Samples
This release includes the following samples: Camera Stacking - Mixed FOV, Camera Stacking - Split Screen, Renderer Features - Occluded Geometry, Renderer Features - Screen Space Ambient Occlusion(SSAO), Renderer Features - Glitch Effect.

Screen Space Ambient Occlusion(SSAO) Improvements
This release brings several improvements to SSAO: Support for the deferred renderer, support for normal maps in-depth/normal buffer, support for unlit surfaces, support for particles, performance improvements on mobile platforms.

Motion Vectors
Light Layers
Depth Pre-pass Support
Volume System Update Frequency

High Definition Render Pipeline (HDRP)

AMD FidelityFX Super Resolution Support


Nvidia DLSS support

(images from the PC game Lego Builder’s journey)

Volumetric clouds and cloud layers


Terrain details support


Local volumetric fog (ex-density volume) improvements


Decals improvements (UX, normal blending)
New Pathtracing features (stack lit, fabric & AxF shader support, Recorder integration, volumetric scattering, increased max samples
New Hair & Fur Shader for strand based rendering
Improved dynamic resolution support
RendererList API to improve CPU and GPU performance
AreaLight support for fabric and hair
Physical camera improvements (added focus distance, more animatable parameters)
Recorder improvements (accumulation motion blur)

SRP General

Enlighten Realtime GI Support: Learn more in the forum update.


Lens Flare URP and HDRP


SpeedTree 8 Support: This includes support for animated vegetation using the SpeedTree wind system, created with Shader Graph.

Light Anchor
This is a dedicated tool to manipulate lights around a pivot point instead of in world space for making lighting for cinematics easier and more efficient. Various presets allow lighting artists to quickly place lights around a character or any center of interest.

Crosspipeline Settings Workflow Improvements
A series of UI/UX improvements intended to improve workflows and consistency between the SRP render pipelines. For this iteration, the focus has been on aligning the light and camera components between URP and HDRP.

DirectX12 general performance and stability improvements

Shader Graph

Custom Interpolators


Preview Mode Control



Built-In Renderer Support
We have added a Target for the Built-in Render Pipeline, with Lit and Unlit Subtargets. This feature makes it possible for one Shader Graph to support all render pipelines simultaneously (some nodes are only available in specific render pipelines). The addition of Built-in support also provides a better basis to help our users migrate to SRPs in the future.

URP Uber Shader
You can now use Lit and Unlit Shader Graph shaders as uber shaders in your project. The new option "Allow Material Override" will let you override your Shader Graph material settings per Material instance, and as a result, allows you to create material variants based on a single Shader Graph asset.

Custom 2D Lighting
2D Light textures produced by the 2D Lights are now accessible as a node in Shader Graph. Some potential use cases are emissive light effects or animated caustics.

Shader keyword limits effectively removed
We have added a more efficient API to work with keywords and clearly separated global and local shader keywords in our shader system. Learn more in the forum discussion.

Blackboard Categories
Vertex ID, Instance ID, and EyeID Nodes
URP Surface Options
HDRP Tessellation support

Visual Effects Graph

URP high-end mobile support (compute capable devices only)


URP 2D renderer support (compute capable devices only)


In-editor Signed-distance field baker


HDRP ShaderGraph integration in VFXGraph


URP lit particles and various features and fixes (compute capable devices only)
Bounds and capacity helpers
Graphics/compute buffer support

Changelog details
If you are interested in the granular details of what has been fixed or changed, you can always refer to the latest changelogs:
URP What’s New, Changelog
HDRP What’s New, Changelog
Shader Graph Changelog
VFX Graph What’s New. Changelog

Getting started with Unity 2021.2 beta
A friendly reminder that before you take the beta for a spin, we encourage you to back up your project. This advice always applies when you are working with our beta and Pre-Release packages. Remember, the beta is not intended to be used for production – it’s for you to evaluate new features so that we can integrate your feedback. For projects in production, we recommend that you use verified packages and our most recent full release, Unity 2020.3.

As always, we value your feedback and would be happy to hear from you. Please use this thread if you have any comments or questions about this release. Alternatively, you can always use our Public roadmap page to provide feedback and make a new feature request.

Cheers!
The Unity Graphics team

EDIT: 19/09/21 - Added AMD FidelityFX Super Resolution Support

 

The main highlights are:

• New C# draw API for all pipelines. Cleaner and more consistent API for drawing objects from C#. This PR provides a set of Graphics.RenderX() functions to eventually replace a bunch of Graphics.DrawX() functions as users migrate to the new API (the old draw API will still be functional). Instead of passing various draw parameters as function arguments and having many function overloads, the parameters shared across RenderX() functions are passed as RenderParams struct. RenderMeshInstanced() is also more flexible now to allow custom per-instance data and custom layout. e.g., sort objects with custom data are accessible without the need to maintain parallel data structures. It also supports per-instance previousObjectToWorld for motion vector rendering and renderingLayerMask now.
  
  
• URP SwapBuffers API. In this release, Universal Renderer manages and operates on multiple camera color buffers in the backend. If you need to write effects that read from and write to the camera color buffer, you can use the new ScriptableRenderPass.Blit method in your Scriptable Renderer Feature. Using this new method, you can apply effects to the color buffer without managing and handling multiple camera color buffers yourself.
  
  
• Render pass Store actions control API in URP. You can use this API to discard contents of MSAA render targets, for example. You can do this in two ways.
  1) Configuring the pipeline asset on how aggressive URP controls store actions for internal passes. We have introduced a new setting in the pipeline asset and a new public API that enables control at runtime.
  2) Configuring the custom ScriptableRenderPass if a specific target doesn't need to be stored.
  The PR for API docs on this one hasn’t landed yet. But you can look at the API below if you are interested.
  ScriptableRenderPass.ConfigureColorStoreAction
  ScriptableRenderPass.ConfigureDepthStoreAction
  https://github.com/Unity-Technologi...time/Passes/ScriptableRenderPass.cs#L282-L296
  
  
• URP API to control depth priming (z pre-pass) has been introduced, which can be controlled by runtime API with this new public API
  
  
• HDRP RenderList API mentioned above
  

 

Since SRP moved to become part of Unity core (during 21.1 release), when something lands on our GitHub, it is not an official release yet. The changes will be included as part of the next editor release after SRP to core PR lands.

 

Yes, there is progress but it won't be part of the 21.x release cycle. As I mentioned in this forum thread we will share our plans for feedback after the 21.2 release. In the meantime, you can send your feedback here and here on our public roadmap page if you want to make sure your special use cases are considered.

I have a question however and I would like to get your feedback on it. What is more high priority to you; shader library API documentation or Surface Shaders capability?

 

Our goal in 2021 has been to make sure users of SRPs at the current state of the product are successful in their projects. If you are using URP or HDRP, we want to make sure the known gaps in quality, stability, and performance of existing features and workflows in using either URP or HDRP are addressed first. Secondary to that, we also planned to add new features prioritized, taking the feedback into account. Based on feedback we have received, for URP, the theme has been around getting closer to feature parity with the Built-in pipeline. For HDRP, it has been around improving artist workflow and features needed for high fidelity visuals and high-end platforms.

Although the demand is a lot lower, there are also cross-platform projects that have use cases for using both URP and HDRP in a single project to deliver the right level of visual fidelity from mobile devices all the way to high-end platforms such as new consoles. In 2021, we still do not officially support cross pipeline workflows (although some projects use the concept). However, we have started making improvements to allow for the co-existence of both URP and HDRP pipelines in the same Unity project. We have also looked at the existing UX and workflows and have started improving where they make sense. In some cases, for new features or workflows, we tried to deliver them across both pipelines. All these efforts have been minimal in 2021. We will continue exploring and planning for cross pipeline workflows in 2022. We can't share the concrete details for SRPs in 2022 as we are still in the 2021 shipping phase while planning for 2022. But we will expose them when Unity announces 22 release cycle plans, and we will make sure our public roadmaps are updated accordingly to reflect the details, including the crosspipeline items. In the meantime, I encourage you to give us feedback through our public roadmap page to make sure your priorities and feature/workflow request are taken into account (we actively triage, organize and discuss the feedback).

 

For up to date information on Raytracing support on next-gen consoles, if you are an approved console developer, there is information in the sticky threads in the relevant console specific forums.

 

Hi,

Indeed there is no work planned at the moment to support raytracing on Vulkan. All efforts on the platform side are focused on DX12 and consoles support. So definitely I will recommend DX12 in your case @Perun.

Performance and stability should be a lot improved in 21.2 according to our internal benchmarks (please test on the latest Betas as some improvements might have landed very recently). Overall we have seen performance gain whatever graphics API was used, and addressed some major performance issues which were causing, in some cases, DX12 to get worst performance the higher resolution was. DX12 is still slightly behind DX11 in terms of performance, but now, the higher the resolution, the smaller the delta is according to our tests. Vulkan is also always slightly a bit slower but in the same ball park.

Note that for URP, the same conclusions applyies.

It is worth noting that the first HDRP game with real-time raytracing as shipped in June: Lego Builder's Journey. A good first step towards production readiness!

With these improvements, NVidia DLSS, AMD FSR, and our own custom temporal upscaler all integrated in 21.2, and a burstification of the decals on the CPU, you should get various weapons to improve performance on all platforms supported by HDRP.

We will continue to focus our efforts on improving performance and quality on DX12 in the 22 cycle until we are confident to get it out of experimental.

We are very interested to get your feedback, get issues reported, and even performance benchmarks on your projects if you are willing to share with us (on this subject, note that DX12 performance benchmarks must be done in Player as they vary even more than on DX11 between Editor and Player - you can find a great example of benchmarking in our SpaceShip demo project).