Is there a map of what DOTs can and can't do so far?

Ideally there would be a Radar graph (?Spider Chart?) covering game engine systems and how DOTS and OOP compare with some additional details on each area?

As someone who keeps leaving DOTS then coming back to check this would be a great help in knowing if DOTS has the features a project needs yet.

 

My DOTS map is this:

Jobs, check
Burst, check
Entities, check
Shader Graph compatibility, check
Unity LTS with DOTS, check

Rest is up do the developer.

 

What about:

• Animation
• Physics
• Particles
• Networking
• Occlusion
• Audio
• Input
• Navigation
• Terrain
• 2D
• 3D
  • SRP
  • URP
  • HRP

Which systems are best in OOP and which are in DOTS or better in DOTS, hence a rated graph?

Actually the community could make one based on a poll with 20 categories, pity the polls on this forum are binary with a scale 0-1f we could build a community radar/spider graph comparing DOTS and OOP.

 

Unity OOP navigation package can't do that right either, and we got https://forum.unity.com/threads/open-source-planar-navmesh-built-on-dots.1060805/ quickly becoming a complete replacement.

 

All these, maybe besides physics has iffy state.

Either incomplete, hard to tap on, inefficient for projects needs, or hard to modify source code.

As you already know, most of developers using DOTS, rewrite major of these systems, tailored for they needs. Or use OOP based solutions, while combining with DOTS.

 

Animation - Roughly equal feature parity, but way harder to use unless you use https://forum.unity.com/threads/sou...mation-system-to-get-started-quickly.1046975/ but also there's not much of a performance difference as the Hybrid Renderer's skinning solution is slow. I have a compute skinning prototype that beats it by quite a bit at scale.
Physics - If you need fully-authored rigid bodies, good feel, and performance over precision, then it works really well. If that's not your use case, you'll probably have pain. So depending on your project, it can either be significantly better or significantly worse than GO-PhysX.
Particles - They are Hybrid GameObjects in DOTS. If you dig through the forums, you'll find some VFX graph integrations which work better.
Networking - I don't have much experience, but the MLAPI has a lot of momentum right now compared to DOTS
Occlusion - DOTS occlusion is easier to use as it doesn't have a baking step. However, it seems to have worse runtime performance in my limited testing.
Audio - There's low-level support in DSPGraph, but nothing high level outside of Project Tiny. I ended up writing a custom high-level solution which I share publicly.
Input - There was a DOTS specific prototype, but I think most people just use InputSystem on the main thread from a system.
Navigation - There are a lot of community solutions to this both in GO and DOTS. Some are hybrid, and some are custom. Nothing official.
Terrain - There's a DOTS asset on the asset store, but otherwise GO pretty much wins here.
2D - GO wins here, although making custom 2D solutions in DOTS is viable and can be worth it since 2D is easy to reason about.
3D - Use URP and HDRP and things will go great. HDRP has better integration as lighting features just work.

 

If you were to rate the OOP systems and the DOTS systems on a 1 to 10 ratio how would you rate them?

• Animation
• Physics
• Particles
• Networking
• Occlusion
• Audio
• Input
• Navigation
• Terrain
• 2D
• 3D
  • SRP
  • URP
  • HRP

 

One thing I'd say regarding DOTS netcode is that even though it feels very WIP at the moment, it's one of the rare netcode solutions for Unity that has a proper workflow for handling prediction. It's the only solution that got me thinking "this is exactly what we've always needed"

As far as I can tell, neither UNET or MLAPI or PUN have ever supported prediction properly (although it's on MLAPI's roadmap for the future). And a lot of other asset store netcode solutions don't support it either. It's unfortunate, because prediction is the kind of thing that you need at the very start of your project. Critical portions of your code may have to depend on it, and trying to implement it later down the road is a recipe for disaster

For this reason, I think it's easier to begin a new online game project in DOTS Netcode than it is in any other netcode system for Unity at the moment, maybe with the exception of Photon Quantum

Spoiler: More about Photon Quantum....

Quantum is like an entire other game engine in itself and is rather expensive, but it works incredibly well and basically allows you to write esport-grade online games without a single line of netcode. It sounds very hard to believe when you read that on their website, but after working with it for nearly a year I can confirm it is indeed true

The key to all this magic is determinism. Quantum comes with its own ECS and deterministic Math, Physics, Navmesh, etc... and this is why I say it's like a whole new engine. But if Unity can pull off cross-platform float determinism in DOTS, then something as easy to use as Photon Quantum might become possible in DOTS as well

 

I have not looked to far into DOTS netcode but I got the feeling it was more interpolation and simple prediction rather then true full logic client side prediction.

Really to get good networking you need to do low level networking yourself in my opinion. DOTS networking out of the box could be good for some games but not for an game that tries to have best in class networking. Because of how closely tied networking is to game logic.

 

DOTS Netcode allows you to put any system you want in the "PredictionGroup", and it makes sure to automatically revert networked state to the past and re-simulate all systems in this group for every tick until present

With this, I was able to effortlessly create an online FPS demo in only a few days. I've used Clumsy to simulate network lag, and validated that my railgun shots were in fact properly lag-compensated. In this demo, the railguns, characters, and physics systems are all part of the prediction group

(Note that the character jitter is due to a known issue in Netcode 0.6, but can be fixed with a manual code change in the package)

 

So DOTS packages are still in a state where lazy devs can do nothing but it's still possible to make good stuff with them?

 

Maybe we need two spider charts one for features the other for ease of use.

 

It's still in preview so yes. However I someone that's used dots Since the initial announcement, I don't think that this was the design of the system nor will it ever get to a point where it will be just simple to implement. Object-oriented programming and game objects are not going anywhere anytime soon

 

Is there a list of games made with DOTS somewhere ?

 

There is a dots showcase thread.
https://forum.unity.com/threads/share-our-dots-showcases.1010215/