What renderer to use ? URP vs Built-In + Some DOTS discussion

You are correct. Some of my statements are not incorrect, though:

HDRP is not supported on Switch:
https://forum.unity.com/threads/hdrp-switch-support.835051/

Low-level documentation is non-existent and is hurting asset authors:
https://forum.unity.com/threads/can...er-system-this-is-absurd.834742/#post-5541067

 

Yep but the point here is not to attack you but to just ensure this website is free from misinformation. The worst kind is usually when a repeats something b said, not realising a might not have a clue.

Thanks for being good about it and seeing where I'm coming from though. It's a hard job to keep things clear without random stuff when there's so many users of different technical capability.

 

Sorry for being kinda abrasive too.

 

Thanks for the links. I knew about the documentation causing headaches because outdated docs have been a problem for a while now, but none of my searches turned up anything regarding the Switch and HDRP support.

By the way if you had included links from the beginning your post would have been better received. Generalzations and a lack of sources in addition to a couple incorrect statements tends to make people believe everything is incorrect resulting in negative responses.

 

I'm using URP for a big project right now. I would absolutely not advise it if you're planning to ship your game within the next 18 months. It is very far from ready - not in terms of features or performance but in terms of bugs and breaking changes - and it's a real shame that Unity is telling people that it should be their default choice.

 

Maybe it would be a good idea to start "minesweeper" threads on new features, to try and collect all findings and gotchas in one place. Personally I'm not digging into SRP or DOTS yet but I'm making a somewhat complex project with UIElements runtime and would be glad to contribute of someone is interested.

 

So no issues for you personally?

 

That would be great but for that to happen we need people to state what their actual problems were rather than just say it's not ready.

 

Which version of Unity are you currently having problem with URP? Is your game 2D or 3D? What types of problems are you seeing? Have you submitted bug reports to Unity already?

 

I bet that the heretic was made in a custom unity version with a custom HDRP version like all the stuff we have seen from the Blacksmith to Adam and to this day.

 

I don't see a problem with unity showing a custom version of their tech provided the intention is to show where the product is going (as per The Heretic) and it will later be available in stock unity.

I would like them to release full source and asset access to these demo's though. Custom tools could then be included and we could learn from those too even if they are very project specific.

 

Well that is the porblem because they will not give you acces to that custom version of unity, that being said you can't do what they do in the demos .

 

Completely depends on the effect. Anything requiring source changes are outside the reach of people who don't have access to the source code, but everything else is within the reach of a developer assuming they have the skills necessary to make the appropriate modifications to the pipelines.

 

I think it's become rather confusing now to know what to start with. Things like the fact you can upgrade from the built in to HDRP or from the built in to URP, but not from one to the other seems to me to make it hard to select! (Unless this has changed?) Almost seems safer to start with built in as it's robust and can go either way. As usual people are very determined to convince themselves they've made the right choice of renderer. "I chose it so it must be the best option". I guess because we all commit so much effort and time to game making, it hurts if we think made the "wrong" choice. Unity has become less unified I think and that does impact on the ability to find the right documentation, help and tutorials. My experiments with the earlier LWRP were not positive (no faster on mobile, missing features, didn't look as good as built in initially), but by now perhaps URP is a completely better/different beast? I too would like to see some direct comparisons on real devices.

 

I've been using URP for months and it breaks compatibility with a ton of great asset store plugins without offering much in return. I'm considering switching back to built-in.

 

SRPs are fast and have new nice features but at the same time they lack the most important thing game developers need - stability and flexibility. The last thing you want while making a game is to spend hours/days/weeks to update your tools, and with SRPs you have to every time you update your project to a new, major unity release.

The next problem is that new SRPs aren't very flexible. They allow for way better performance than old built in, but only If you dare to use them as they were designed to, in my case, neither one is good and actual built in offers better performance.
HDRP provides nice graphics with good performance, but only in case you want to have AAA graphic. If you have other ideas and want to only use few features It provides, you will also have to enjoy worse performance.
URP is really much faster than built in but It doesn't have deffered renderer so If you want to combine real time shadows and huge, open scenes, It's going to end badly for you and your game.

Then, the next problem. You have to make a good choice first time, because by only trying to switch between them you are at risk of getting neurosis. The bigger your project is, the worse It will get.

Built in renderer is supported by the community, is well documented and allows for making games faster. I think It should be called "Indie render pipeline" since It is the best choice for a small team/alone developer. Only when you really in need of a new RP, should start thinking about moving. I recommend doing so once your game is closer to public release.

 

Package Manager.

 

Thinking to start with URP on 2020.1.2f1
My target is mobile devices and its a racing game so stop me if URP is not still a good choice with this version because you know it painful to switch projects back to built-in and I am on URP because I need ShaderGraph and on 2020.1.2f1 as DARK MODE is FREE now...

 

This is nuts!
I'm out of the Unity loop for about a year then I come back to start on a new project and straight away I'm forced to choose between something that I have no idea about and the 'old way'. I even need to check the forums to be able to choose which type of renderer to choose?!?!?

This is one of the reason I went away in the first place; because Unity keeps moving forward but clinging on to all its old bloated baggage. I agree choice is a good thing to have but not when it just leads to complete confusion at stage 1 of the project.

The reason I started using Unity 12(!?) years ago was because of its simplicity of use to get excellent results. What happened?!?

So, which renderer should I use? New or old?

 

Removing the old pipeline isn't doable until there are projects no longer dependent on it and it has achieved feature parity.

Check out the features of the new pipeline compared to the old, check out any assets that you're dependent on to see if they are compatible with the new pipelines, and then decide if you want to use it or not based on that.

 

If you have to ask: Old pipeline

Because srp is so new its not finished yet.
There should be a sign on srp it saying: wet paint, don't touch!

Wait for the paint to dry and then consider switching

 

Thanks for the clarification. I wish they'd have just stuck that little phrase in the new project dialogue.

 

at the moment the choice is complicated so here is results of my tests, you can spreadsheet your decision:

1. VFX graph works in built in
2. URP is 20% faster in gpu
3. URP eats up slightly more cpu
4. in URP lightprobes don't break batching
5. shader development is more difficult due to lack of surface shader : shader graph is essentially hlsl with nodes so just get ASE
6. URP devs reply rarely
7. URP shadows are uglier
8. v10 SSAO is slow and uglier than builtin's and the unity URP PP under performs
9. if you need fast PP regardless of RP get rufat's.
10. many good quality advanced github projects are URP only
11. you can turn off pieces of URP since you have the full code (for extra fps)
12. no deferred in URP so multilight isn't great
13. render layer in URP so there is no need to eat up physics layer anymore... oh but these can't be used because cameras don't cull on them (!)
14. going back and forth between RP is just a few clicks but only at the start of the project. events like OnPreCull etc.. won't work
15. shader graph break between URP versions
16. hlsl shaders will break between URP version
17. shader graph format changes so if you upgrade and find out it's broken you're stuck, version control a lot when using URP.
18. no LPPV, but these suck so no real loss.
19. progressive light mapper sucks in URP, get Bakery which also has a much better replacement for LPPV called volume light
20. SRP batcher is so good that you don't need to merge geometry anymore, nor do you need to atlas textures! A huge gain in productivity.

 

I'm currently using built-in (Unity 2019 LTS). Should I transition to URP?

 

If Built-in fulfills all of a projects requirements, why switch? unless one thinks
a future need will become a problem without URP.

 

If you plan to move beyond 2020 LTS you need to move since they will depricate builtin. I really hope HDRP is performing like builtin by then.

 

In build? it should eat up less every time unless you're doing apples to oranges somewhere.

URP Shadergraph needs work. The shadergraph manages to be far behind Amplify in some areas (especially technically).

 

You can still use the old default renderer... I use it right now

 

Even if they were equal in all features, I'd still use Amplify just because of the awful Shader Graph ux

 

Any official word on when they will deprecate built in? I'm hoping they keep the LTS versions going each year until there is complete feature parity with URP and there are basically _zero_ use-cases that still work better in Built In ... meaning, only once the question of what to use becomes a dumb question.

Also, I'm seeing people saying that because URP has no deferred rendering it doesnt handle multiple lights well.

Is that really still true? How on earth will URP replace BI if any game which uses multiple lights wont perform as well as BI? Isn't that a regression, not progress?

 

They are not deprecating built in. @MDADigital was incorrect

 

I think the thought behind URP and HDRP seemed good.
HDRP is a very realistic high-end take on real lighting & cameras (maybe too much so on camera side), but there is much experimentation in there with some very slow effects (like the real time ray traced stuff).
URP seems like a rethink of built-in to make a faster pipeline from mobile upwards, but many normal features like AO have only just been coming in.

The way they have been built as completely separate packages that add elements on top of the built-in code is harder to work with as the documentation is broken up, as well as the constantly changing render code and shader code (which may be why we have un-finished shader graphs to hide the core hlsl).
It is hard to set material settings in code because until recently there was no documentation on that and even now you can't really expect anything to be fixed in stone.

A lot of the new Unity features need more time in hidden beta (maybe ?) because with URP,HDRP,DOTS,UIElements etc we have many features that have been years in the making but still seem not ready

 

In my experience HDRPs performance is worse than built in especially when using real time shadows and/or forward rendering. My indoor scene in HDRP has about 18 lights. On a i7 10700k @4.7GHz CPU it takes ~11.7ms cpu time looking from a worst case viewing point for rendering a frame at 1920x1080. 2332 batches, 2.7M vertices, 464 SetPass calls (SRP batcher enabled) 2600 (not sure if thats a lot or not) shadow casters.
Same scene without volumetric lighting but more point lights which are even shadow casters takes 7.7ms using built in renderer. Batches 2700, 3.8M verts, 1000 setpass calls (nor srp batcher obviously, and the scene is even not optimized for material batching) 3500 shadow casters. Of course shadow maps and overall lighting look worse with built in but the performance difference is just too big in my opinion. GPU times is on both about 4-5ms. Both use deferred rendering. With built in renderer i can also use forward rendering and up to 4x MSAA which will increase the cpu time to 8.6ms while on HDRP this will cause the time to raise to 16.2ms.

Im not sure why but for example 1 directional light is much more costlier in HDRP with shadow maps active on it. Its about 1.3ms cpu time for that light only. If I disable that directional light, batches decrease to 1518, verts to 1.4M, setpass calls to 364 and shadow casters to 1237 still 10.4 ms CPU time. Disabling all lights CPU time is still at 7ms, PP still active. I also tried to change light updates to "on demand" and made every renderer to a static shadow caster but that did not help much -0.3ms.Tested this with different Unity and HDRP versions from 2019 - 2021 and its always the same behaviour. It looks like there is a much bigger overall overhead to HDRP and also a bigger per light / shadow map overhead than wih the built in renderer.

 

Anyone here know if the Universal RP version 11 will be released for Unity 2020.3? So far its only available in 2021.1+, but I'm really hoping to have point light shadows in 2020/
One other URP related issue I haven’t been able to solve, anyone able to get Speedtree shaders to work with Vegetation Studio (using instance indirect and shadows)?

 

the devs said urp 11 is only for 2021 and not for 2020

 

A lot of mentioning features arrived at URP 12 (Unity 2021.2 alpha)

• Shader graph support vertex id, instance id, eye id and custom interporators.
• Deferred renderer
• Enlighten realtime GI support

SRP will be replaced the black box build-in pipeline for sure. You can even make custom pipeline if you want or just modify the current one.(HDRP/URP)

I saw on github that Unity has branch for x-pipeline too. This might be the end goal which will combine two separated pipeline together. At this point, I think SRP is the way to go. No matter which one you use HDRP/URP/Custom, it will be this way. No more black box pipeline.

A little bit off-topic but speaking of full source access. If you ever try another U engine, you will know that even you see a code. You cannot just modified and expose it to runtime without considering that it might break EULA. There are some structure that you really need for runtime but it stay on editor code. All you can do is to dealing with it indirect way such as modify that data via the buffer which is available at runtime. You cannot just copy their editor code and place it in runtime code. Even if you can, the pipeline is very frustrated. Yes, you can change whatever you want but I think if you even have to modified their pipeline. Maybe just make your own engine is better because it not as easy as injecting code in Unity.

Unity is opposite to that. They allow you to do everything flexible to the point that you break optimization on your own. So Unity try to fix that by adding some restrictions and people start crying because it''s not a flexible as it is. That's why it break into two separated graphics pipeline as you see now. Both pipelines are not finished if you compare to build-in. But I can see their vision in it. URP started as LWRP with restrict number of lights. This is the fundamental that you need to know when develop for low end devices. Even then they fix it and allow more lights. See? Unity can't be both flexible and optimized + automate engine in a short time. They need more time to complete the engine.

In the meantime, another U is just make everything automatic and take the flexibility out of sight so you can only do their way or hard way.

 

I thought enlighten realtime GI was on way out?
But deferred renderer... URP is just becoming a bit of everything and the main event, clearly a replacement for built-in pipeline with HDRP a high-end realistic pipeline, almost on the side.

 

They re-enabled it:

• https://forum.unity.com/threads/update-on-global-illumination-2021.1067015/

 

It is not a black box pipeline, as shader code for built-in is available under MIT license. It is messy, and relies on a specific rendering process, but it is available.

 

Let's wait for a real production to break its teeth on this before getting too excited
@Ruberta how are deferred perfoormance ("oo" -- damn g14 keyboard again!)
I don't get the logic of reviving the enlighten corpse, unless the new version is amazing there weren't many productions using it (any?)

 

The enlighten "revival" was primarily a way for Unity to buy time to create the in-house Realtime Global Illumination solution (and to also reach URP "feature parity" with built-in).
As far as I am aware they didn't do it for any other reasons.

 

Well yes I'm not so excited, just looking where it's going! Was surprised to see deferred coming in, not sure why.
Personally only used HDRP (which keeps changing in places) or builtin/legacy

 

Disclaimer: I mostly target XR & Mobile platforms.

I have been using URP since it was the preview LWRP package Iand am very familiar with Shader Graph, VFX Graph (and made the mistake of completing a large project utilizing DOTS in preview before it was called DOTS). I recently started a new project using the built-in renderer and it's like a ton of bricks was just lifted from my shoulders. Things just work again with far fewer limiting factors (like lighting), and I'm not seeing a significant loss in performance (yet).

Don't get me wrong, I love Shader Graph & VFX Graph, but for me the gain is minimal when compared to how much time I've spent navigating the update inconsistencies, inconsistent documentation, imported asset conversion (most of which are incompatible), etc.

Even the larger, well funded third-party vendors like Microsoft (MRTK) and Facebook (Oculus SDK) are having trouble scrambling to keep their packages in a working state to make them compatible with URP's rapidly-changing feature support, or lack-thereof. You can tell they're also frustrated with the ongoing struggle supporting three pipelines - and only one of them is consistently stable and production-ready.

Another gain from going back to built-in is how much better my scenes look by default. I feel like with URP I have to spend hours from the get go just to get my scene to look anything but dull using the URP/Lit shader when I start a new project, while the built-in pipeline has a much higher quality baseline to start from. I'm sure HDRP looks great, but I target platforms that Unity explicitly states should not be utilizing HDRP.

I think I'll just get Amplify (and Bakery) to bridge the feature difference for now. I feel like the pipeline mess has caused developers and asset creators enough grief now that it's hurting more than it has helped anyone. It's almost like they should just now be released in a preview state. Don't get me started on DOTS... I have to re-learn the entire workflow if I want to use it, but that might be another waste of time.

 

The above mirrors my experiences and sentiments.

I reverted a project to Builtin from LWRP - URP - Builtin, about 12 months ago... and have just spent the last couple of weeks assessing if I should go back to URP... if it's more ready.

It isn't, because I've since learnt some of the ways to optimise Builtin, which has been eye opening. Am really only at the beginning of that journey in understanding the immense customisability of Builtin, and already getting big gains over what was running reasonably well, to more headroom for more visual effects, stylisations, etc.

All of which are easier to do in Builtin, because they're paths well travelled and there's some online materials from past journeyman through some more advanced (than me) customisations, optimisations and experimentations.

Some complain that Builtin is a blackbox... that's what I found URP to be. It's all uncharted and undocumented, and more blocked off and limiting than I ever imagined, especially now that I'm seeing how freely Builtin can be twisted and mangled to do all sorts of weird things.

Can you tell me more about this? Where it is, how to access it?

and... What brand of coffee helps in understanding it?

 

To the original question:

What renderer to use: URP or Built-In ?

If you're asking this question, the answer is Built-In

 

The eye opening ways to optimize and build on Builtin sound very charming. What do you have in mind exactly? Care to share any resources or give examples?

 

My project is a little weird, so I got a lot of cheap, easy, huge gains, that aren't immediately apparent, until you do all the following (and despite all being common sense once you know to do them all, nobody seems to teach and preach this stuff for a very light, fast, 2.5D or 2D game with Builtin.

This makes Builtin a genuinely lightweight renderer:

0. No lights, everything baked
1. Turn off all things to do with 3D lights and shadows on every single object and in every setting. There's a myriad of these settings throughout Unity, and the real gains come when you finally figure out how to turn ALL of this off. All of a sudden entering Play Mode is way faster and your game will run much faster.
2. Use old legacy shaders for particles AND geometry that can get away with it
2. a) Use the Standard Unlit Particle shader for everything else not able to be opaque (sprite shader)
3. Try culling in screen space manually, and setting draw orders to benefit and use tags to turn on and off stuff that you don't need really quick, and cull manually, and set sort to camera's z to realise this potential. Truly abuse sort order and passes to get the looks of what you want, the way you want, as it's way more powerful than I ever thought it was.
4. Use stripped shaders honed by people who've done or are doing what you're trying to do
5. Play with shaders that only do vertex rendering for 3D shapes as backgrounds and big/low detail stuff rather than spending too much time fussing with tilemaps etc.
6. Use MatCaps for everything that needs a bit of funkiness, or...
7. Use this AMAZING shader: https://docs.unity3d.com/Manual/shader-ReflectiveBumpedUnlit.html
-- There really should be a special lore around the above shader. It's incredible for 2D and 2.5D games
8. Master Material Property Block Instancing as this is the greatest single boon to working in Builtin
9. Understand & use Animation Legacy Component's huge performance advantages for transforming transforms - it's faster, lighter and way more powerful than using tweens
9 a) NEVER use coroutines. Never use Delegates, Never use Events, Never use Actions
10. Figure out how to manually batch/build as one all your geometry (and use a lot of geometry, as "Sprites", to cut down on fillrate.
11. Forget about Unity's 2D texture/sprite packing. It sucks. Do it manually, yourself.
12. Most times don't use alpha blending, just use black and additive so the black is faded out, wherever you can, i.f you must, use geometry to absolutely minimise the amount of alpha blending, as this is a bit of fillrate/fragment shader time hog

Make your object hierarchies as flat as possible

NEVER use Animator Controllers or any other part of Mecanim. Don't be tempted by Timeline, either. Also avoid Playables.

Turn off all 3D physics and remove it from your project entirely, and make sure you NEVER allow a 3D physics body to get into your scene.

Make sure you learn how to get particles wholly and completely and properly instanced and rendered on the GPU, this really boosts what you can do with them.

Strip out everything from the Package Manager other than Sprites, Cinemachine and TextMeshPro

Abuse TextMeshPro, it's VERY good. Way more powerful than people think it is.

 

All that really sounds like "use unity 3".

 

Yes:

I call it "Use Unity 2019.LTS as though it's Unity 5, minus Mecanim"

Stability, Sanity and Performance are the wins.

 

I use a 4 texture splat vertex lit shader with lightmapping support and it surprisingly worked in HDRP and URP. Couldn't tell if it was a bug or just a simple enough shader but it worked on all render pipelines.