Official What is next for us at Unity with Scriptable Render Pipelines

Enlighten RT was just added back in 2021.1

 

Precisely.

Enlighten was "deprecated" for Enbrighten — which was released alongside with the new FRP — and is now also considered "deprecated" as well. Enbrighten will be "removed" in 2023 after of which it will make its "surprising" return in 2025 so that way Unity will never have to make the in-house RT GI they "promised".

Luckily, 2025 coincides with the same date that both the FRP and the BERP will be suddenly deprecated in favor of the new CRP (Complete Render Pipeline). Which I'm suuuuuure is just pure coincidence and not nefarious (or nefariously poor) planning on anyone's part.

In the meantime, I think I'm going to go back to pre-rendered cutscenes and crudely-drawn paper cutouts.
No one can deprecate my lighting model if I don't have one!

/s

 

So true!

 

Yeah, I was VERY skeptical when they initialy said they would do their own version of realtime GI like enlighten... I'm happy they got to renew their license instead of making an half baked implementation.

 

By all means depart for Nanite-land now if it's really a better fit for you in particular. Unfortunately Epic/Unreal completely dropped support for legacy mobile (non GPU compute capable) and WebGL. If that doesn't concern you, then it makes a lot of sense to go with Unreal's mid to high end platform only renderer. If that does matter to your use case(s), then Unity URP may be a better fit for many as it supports legacy mobile and WebGL. Or BRP if there's something it has that URP doesn't yet. Whereas Unity HDRP compares more closely to Unreal's only renderer.
Epic Unreal is a bit like Apple MacOS, they are quick to drop support for legacy / non state of the art platforms and maintain a focus and simplicity at the cost of compatibility.
Unity is / has become more like Microsoft Windows, they support legacy platforms for much much longer, at the cost of being more complex and fractured to support the full spectrum newest and oldest platforms and APIs.
There are pros and cons to each approach. Choose the one that works best for your projects and use case(s.)
Having said that, I do agree the development of URP, HDRP and other major recent developments at Unity have been in many ways unnecessarily splintered and rushed, work duplicated in isolation and UI / UX and APIs ended up wildly different for no reason other than perhaps lack of communication between teams and management plus unrealistic timelines, my best guess anyway.

 

What was a better fit for me was Unity when it was actually UNITED and retro-compatible.
All what the built-in render pipeline needed was single pass lighting and better batching. THAT'S IT.
What we got instead was LESS FEATURES, fragmentation and incompatibility with new render pipelines no one asked for.
And on top of that, URP isn't even faster than built-in!
What the hell Unity! Are you drunk??

 

Artist tooling is great idea.

 

There should be only one render pipeline with option to enable or disable some features. Shaders should be text based with option to use graphs for those who really need it.

The BIRP is (or maybe was) straighforward, well documented and easy to learn and it just needed to be upgraded.
At this point starting a new project is a hell - which pipeline should I use? BIRP - damn, it is not going to get any new features so it may be a waste of time learning it. URP - not finished, graph based (puke), limited - no multi render targets, no per object instance data, no RenderWithShader equivalent and so on. HDRP - too many options and setting (even Unreal does not have so many confusing settings). Maybe just SRP and write everything by my self - yeah I can do it, but why should I pay Unity if I have to reinvent the wheel?

You have destroyed this engine with those stupid ideas.

 

AMEN

 

I dont agree with you. They have to seperate platforms for performance. That is why unreal is not preferred for mobile platforms... Which pipeline you should use? It is not so hard task to answer I guess...

 

Unreal is not preferred for mobile platforms because more often than not having a full, modern, 3D engine based on C++ is overkill...

If you don't know anything about graphics and believe everything Unity says then sure its an easy choice. However if you know what you are doing the choice is still an utter mess between: works well but unsupported, hot mess number 1, hot mess number 2.

 

Unity is great on both mobile and desktop using the BIRP.
There is nothing on the new render pipelines that justifies the switch and the infinite hassle they impose.

 

How I see it, there wouldn't really be anything totally blocking Unity from doing single unified SRP instead of two - other than the convenience of having separate teams working on these as there's clearly different focus on HDPR and URP.

What we've seen already is that URP is shifting more towards HDRP way of things while Unity keeps working on unifying their SRPs. On my own personal testing I've seen URP getting heavier with recent additions and will expect it to get even more initial overhead the more functionality Unity adds to it. This isn't something I've properly benchmarked though, more of an observation from few projects I've tried on different URP versions.

I personally like that they do unify the SRPs but I also would expect there to be a point somewhere in the future where these two SRPs are unified enough they could merged together without having to redo everything. But at the same time, I actually don't expect that to happen but rather Unity to build yet another RP to replace both HDRP and URP in the future. How quickly this would happen probably depends a lot on what happens with DOTS (which Unity has kept under curtain for a year now). And when/if this happens, I totally expect userbase to rebel again because at that point they don't want yet another new RP and we see the cycle repeat.

 

This is incorrect in a number of ways. Unreal engine is actually a few engines, just seamlessly bound together. There's the forward renderer for mobile and VR, the deferred renderer used in most games, the DXR renderer and finally the new nanite renderer. These are all separate in the codebase, separate engines.

The only difference is that the developers absolutely had the experience of shipping a lot of games and engines long before Unity was even born.

You have to remember that URP was just an experiment, not even a product in Unity's eyes when it was being made. Just to test the SRP. What followed was a few years of making customers really pissed, me included.

Things are recovering and improving now but I really do hope Unity plans ahead in future. It's one thing to parrot the party line and another thing to live in the trenches with it.

 

I'm just going to point out right here that Unreals forward rendering code exists inside their c++ classes that handle specifically their deferred rendering. It's all merged together which looks like a hack job (which it probably was since they needed it quickly to make forward rendering path for Robo Recall). VR stuff is built on top like in every other engine.

 

I personally don't care how it's managed in UE.
My only concern is that Unity was a great engine until the new render pipelines came along and f*cked everything up just because the CTO was bored and wanted a change.

 

Actually they've steadily improved it. Even now there's more improvements on the roadmap. Point being isn't about them though it's about highlighting that Unity could have planned this a lot better instead of just pulling enlighten, adding it back, creating a spontaneous LWRP from a test, renaming it, leaving half of the API for dead and downgrading from built in.

What Unity shipped out of preview was nowhere near ready. Very few users respect being given a lot of problems on their plate.

Again, it's being addressed now but really Unity need to feel these reminders from their users to ensure it doesn't happen again.

 

The problem here is that over time it come hard to maintain. Due to the large number of platforms and compatibility with old devices, it becomes increasingly difficult and more complex to implement new functions.

 

mmmyeah, I'll believe it when it's actually done.
I'm sticking to BIRP for my game. Once I finish it, I'll have to try other engines. That is something I would have never done if Unity was actually UNITED...

 

My guess is that we are actually seeing the results of that.
They don't have to be positive though.

 

Which they are having to do all over again for URP. The platform compatibility matrix is blamed every time the sluggish pace at which URP gets "new" features is brought up.

 

Not for everything, in URP many features that are in HDRP are missing or have been implemented differently, which reduces the complexity of the two SRPs.
If one were to try to implement the new HDRP features into BIRP but with compatibility with old hardware like URP/BIRP, then different render branches would still have to be developed internally, depending on the available hardware. This then leads to a further abstraction and furter complexity, which costs performance, but also means that the settings also have to be reduced and you have far fewer setting options than are currently available in HDRP.

 

Not everything in URP must support every hardware. It already started: key features like deferred rendering and SSAO don't work in GLES 2.0.

Games that can scale up and down to run everywhere are the future. If you pick HDRP, you lock yourself out from profitable platforms like mobile and Switch (and maybe even PS4 and Xbox One depending on your game, due to HDRP's horrible CPU overhead), while if you pick URP you lose the ability of making your game look the best it can be on high-end platforms.

From the way things are going, URP will either eventually get all HDRP features and make it redundant, or Unity will eventually abstract things enough so projects can switch freely between URP and HDRP at build time. How many years it will take is anyone's guess.

 

A shader abstraction is still 2-3 years out, at least. If they copy the best parts of Better Shaders, it'll be pretty good. I think the most likely case is that Unity fixes some of the most glaring issues, and kind of lives with it until it does a new system for rendering in, say, 5-6 years, and hopefully doesn't make this mistake again. The thing is, while HDRP is modern in a lot of ways, it's still a renderer designed around last generation hardware. Modern renderers are moving more toward GPU centric rendering, cluster culling, bindless resource access, avoiding microtriangle issues, compute rasterization, etc, etc. This changes the entire pipeline substantially from what Unity has built with HDRP (and in some forms make them far less general). And for older platforms, they'll keep URP around in some form with an expanded feature set for a long time. I also expect to see a lot of stuff currently in HDRP moved back to URP, because there's not a lot of reasons URP couldn't do many of these features (ie: Motion vectors, which are badly needed for DLSS and temporal AA, the new sky system, AES light settings, etc).

 

5 years sounds about right, or the next console generation. But I think Unity is very cautious at this point, and DOTS has the focus.

 

Unity is already working on making it easier to switch between SRPs in a project. I think there are already games that use HDRP for desktop / consoles and URP for mobile.
In my opinion it should have been that way from the start, an abstraction on the editor / build level.

As far as I know, HDRP has a high CPU base load, but scales very well in large / complex scenes.

 

Spoiler

 

As far as I know, URP has more active features by default, which are automatically switched off for mobile with BIRP. E.g. Post process, BIRP does not have any post process by default, unless one installs it. Many benchmarks do not consider such things and test an unoptimized URP project. URP gives you the freedom to optimize the project yourself, which unfortunately too often is not used or only badly used.
Maybe Unity should think about creating a tool that gives suggestions for optimizing the scene for a specific target platform.

 

I always see people talking about the "tons" of features enabled by default by URP. So let's see what all these enormous amounts of features are and what's enabled by default. I created 2 projects and set them both to android, one with BIRP, one with URP 10. On both, the medium quality is used:

1. BIRP
- the medium quality is used by default
- with hard shadows, low res, distance = 20, no shadow cascades
- HDR disabled, box projection cubemap disabled
- Post-processing not added
- 1 pixel light allowed, the point lights will be per-vertex (4 max)
- MSAA disabled
- SRP Batcher non-existant



URP 10
- Medium quality is used by default,
- with hard shadows, 2048 res, distance = 50, no shadow cascades
- HDR disabled, box projection cubemap not yet implemented
- Post-processing is not enabled by default in a new scene
- 1 pixel light, the point lights will be per pixel (4 max)
- SRP Batcher enabled


So comparing these 2, they are quite close with the exception of the point light being per pixel in URP, but in most cases, nobody uses real-time point light on mobile. Yea, if post-processing is enabled in the scene, then it will make a huge difference. I will do some android tests to see how they compare with these settings.

 

What you cannot see in the benchmark of the video above is the exact settings of the individual RP, for me it also seems as if URP postprocessing is active here but not in BIRP. The settings of the shadow between BIRP and URP are a bit different, the render distance is more than twice as high in URP, and which resolution means "low"?

 

I wouldn't really draw huge conclusions from a benchmark made for single weak target device on mobile and desktop. I get this is what most have at their hands when they test their own things but it's not really covering the target audience of either space. To get better idea of the perf, one should test things with a lot wider range of devices as the performance of a renderer isn't just naive linear scale based on the target device.

One huge red flag on that video was that it really was tested on really old/weak hardware on both desktop and mobile.

As example I could make a comparison from HDRP running 3fps on integrated Intel GPU and then show how URP and built-in just destroy it at 30fps etc on same scene but that kind of comparison doesn't really mean HDRP is 10x slower on systems it's really targeted at (and it's not).

 

Where is the evidence of URP actually being faster? It seems there’s only evidence of it being slower and some passionate Unity fans trying to discredit them while failing to provide any actual evidence themselves.

 

Fair point, I have no idea what low means, I will try to eyeball it . I'm doing some tests right now.

 

I'm also not trying to discredit the benchmark above, just trying to say it's not really wide enough sample set to draw proper conclusions of URP performance. Pretty sure even Unity staff itself has mentioned that URP can be slower on older mobiles - which is totally in line with that videos findings.

 

And some comparisons. To have a fair-ish comparison, I made the following modifications. Now some of them are different of course, so it isn't a 1:1 comparison.

1. I set the pixel light to 0 in BIRP and set the Additional lights per vertex in URP.
2. For the shadow distance, I set them both to 20 and 1024 res in URP, it seems to match the Medium quality in BIRP. URP shadows seem to have PCF filtering on android
3. I also added 2 point lights at the same location with the same range. But in URP the falloff is different
4. For the scene I used my demo scene, the shaders both use PBR and have the same features.
5. Both GLES, both Linear
6. For the post-processing I used:
- ACES
- Vignette
- Color correction (contrast, saturation)
- Bloom (fast mode in BIRP)
7. Build time,
-167 seconds in BIRP, with or without post, 4 shaders used
-237 seconds in URP,

BIRP - No post

BIRP - Post-processing


URP - No post


URP with Post


So let's say it is quite close. What is don't understand is why spend 4 years or more, to get to the same level as BIRP, when you have BIRP that does all the S*** URP does, and beyond, and it works without issues from PC to mobile to VR. URP should not exist in my opinion, I just don't see the point of creating it. LWRP had a purpose, it was designed for low-range devices and it made sense.

As for HDRP, I like it. I wouldn't mind if they continue improving BIRP and use HDRP for next-gen rendering.

 

Noticing that the memory is almost double for URP (which used to be a killer constraint on mobile and I imagine still is).

Guessing this is to do with its batcher and general overheads. Yikes.

Also this is where the madness lies because built in trumps URP without PP. In this situation it doesn't feel like a daunting task to either buy or write your own PP to compensate but I can't say the same for URP.

 

The result is quite different in the output, BIRP has no specular reflection on the ground, URP does (and URP looks more natural). Is that also the case in the editor, or only on the device? Are you sure that both have the same shader/Material features?, or is Unity stripping something in BIRP?

About 65% more ram is not a little, but not twice as much.

 

Both have specular highlights, but in BIRP a level of 1 makes the highlight disappear
BIRP

URP


Now regarding how natural they look to comes down to my post settings being a bit different:

BIRP


URP

 

I was going to point out that instead of trying to match the settings 1:1, it might be better idea to try to match the visuals rather. I get that test didn't even try this in any level, hence the built-in looking totally garbage on that comparison.

Performance comparisons aside I personally prefer URP shading over built-in visually, even after tweaking.

 

It looks like garbage indeed But I wanted to add 2 point lights that would affect everything. And since in BIRP the falloff is linear, we have this christmas tree.

 

Can't you unify the falloff with baked lights? (which you'd typically use on mobile anyway)

 

I don't see any settings for that, maybe they are the same after baking.

 

I'm no fan of URP but it does have better performance from my many tests compared to built-in. I did a ton in a different thread some time ago, from small scenes to big scenes. Tested on scenes that reflect reality (games out on steam, graphics, etc) and URP won over built-in in each one. Although you can get pretty close to URP when you combine meshes using a cell based method so that culling/LODs still work in built-in. But URP wins by default, no need to combine meshes etc.

SRP batcher is a big help in many scenes that aren't simple from my testing. A proper test, URP would always win from my tests, everytime.

On my now really old laptop, using a laptop GTX 1070
i7-6700HQ CPU, 2.60GH

I can't say much about mobile as I don't use it.

edit: one of the tests: https://forum.unity.com/goto/post?id=7156825#post-7156825

 

SRP Batcher is most likely the winner here. With many materials, BIRP doesn't batch them, while in URP everything is batched by shader. Comparing the shaders, the code is more or less the same. I never check post processing and other aspects.

 

https://forum.unity.com/goto/post?id=7156825#post-7156825
This is one of the tests, although I did another one with a medieval scene but I think that one is lost to time.

But URP's development pace & quality of some features (e.g shadows) has been pretty disappointing.

 

I'm not saying BIRP or URP is faster, my point really is that after 4 years, with have URP = BIRP-ish + SRP Batcher, with more hassle, new workflows that are not documented, breaking changes with each release, and MARKETING, look we now support parallax cubemaps and enlighten!!

 

The URP batcher and the single pass lighting can be implemented in BIRP. There is just a lack of will to do so because "deprecated" and the sunk cost fallacy of having wasted time and money on the new render pipelines, so going back would be to acknowledge they f**ked up.

 

URP is pretty good with Vulkan, Quest spacewarp support (well it would be if it wasn't limited to a specific version) and I even make use of the pretty decent transparent shadow stuff. I liked that, would've been rough on builtin.

I think that URP could use some perf improvements and those should be seen as features.

 

https://forum.unity.com/threads/urp-vs-built-in-render-pipeline.1179325/
This thread shows different results for mobile... (I think I should perform some benchmark tests myself someday)