Everyday Unity

When Your Game Is Bad But Your Optimisation Is Genius

3 simple optimisations that you can use to make your game run up to 10 times quicker.
Not a Unity video, but still can be easily applied to a Unity game. I have done similar optimizations to the terrain a long time ago in my own mobile game and got a significant boost.

https://www.youtube.com/watch?v=5zlfJW2VGLM

Repo: https://github.com/vercidium-patreon/glvertexid

#optimisation #terrain

.NET 9: Array vs Dictionary lookup performance in C#

I wanted to revisit my old post about the performance of lookup operations in dictionaries and arrays to see how all the performance improvements in newer .NET versions affect old benchmarks. TL;DR: The benchmark shows that dictionary lookups are around 2 times faster in .NET 9 compared to Framework 4.8. This means there is now less sense to use arrays to speed up lookups in small collections.

This does not apply to Unity yet, though they promise CoreCLR integration, so it might become useful someday

https://gamedev.center/net-9-array-vs-dictionary-lookup-performance-in-c/

#performance #lookup

ECS Programming Patterns from Official Packages

A list of advice how to perform common operations in unity.entities with examples from the entities package internals.
I also have personal notes with tips from the Hot Path Show that I found interesting, and they are pretty similar to what is shared in that post, e.g. tricks how to create new entities with the set of components without allocating a managed array of types and without adding components one by one which is very inefficient in the archetypes ECS implementation. This show is usually around 2 hours so it takes time to gather all these tips and sit through the whole video, so not everyone watches it completely. Put a 💯 reaction if you'd like me to publish it in a similar form to the post with top tips from Unite.

https://gametorrahod.com/ecs-patterns/

#dots #ecs

Introducing our new e-book: Unity’s Data-Oriented Technology Stack (DOTS) for advanced developers

Here's an overview of DOTS. Many people think DOTS is just ECS, but there are multiple packages and tools under this umbrella.

Of course, ECS is a big part of DOTS, which is why half of the book is about it, but you might be using DOTS without even knowing it, as some packages are jobified, and use burst/native collections under the hood.

https://blog.unity.com/engine-platform/new-ebook-understanding-unity-dots

#dots #book

CPU performance optimization guide - part 1 - CPU performance optimization guide

A great example of how to profile CPU performance at the lowest level. From my experience, you very rarely need to dive this deep in your daily work. However, if a method is on the hot path and invoked many times per frame, and all low-hanging fruit optimizations are done, then you definitely need this post bookmarked for future reference

https://gpuopen.com/learn/cpu-performance-guide/cpu-performance-guide-part1/

#profiling #cpu

Unity Shader Variants Optimisation and Troubleshooting

When using shaders from the asset store it might become challenging to control shader variants leading to increased build size and time to prewarm it. It's a good post to bookmark and get back to it during your project check ups.

https://dev.to/attiliohimeki/unity-shader-variants-optimisation-and-troubleshooting-28ci

#optimization #shader #shadervariants

10 Unity Audio Optimisation Tips

There are a few posts covering audio optimization available. While it's true that this topic is usually overlooked since assets, scripts, and rendering optimizations yield more significant performance gains, it's great to have such posts bookmarked, as they list a lot of high-quality tips. Moreover, now you know that sounds might also cripple performance.

https://gamedevbeginner.com/unity-audio-optimisation-tips/

#audio #optimization

List Add is way slower (almost 3 times) in net9.0 preview 3 than with net8.0
dotnet/runtime

This is an interesting discussion and investigation into why performance significantly drops on one of the platforms after optimization in net9.0. I always love reading how engineers solve complex problems. It's fascinating to see what changes under the hood can cause such big differences in performance and how they track down the issue.

https://github.com/dotnet/runtime/issues/101437

#performance

Chunk's Change Version

A detailed post on how .WithChangeFilter<T>() works in Entities

Then, there is a per-chunk number called ✏️ change version. How the chunk is considered "changed" in order to update this number is rather crude : Instantly when a query is executed related to that component and it has write permission. Then, chunks returned for that query will all get their ✏️ change version updated

It does not check whether system actually "change" the component's value with its work using the query. It just see the write dependency and thought the system "probably" changed that for all the matched chunks.

It is per chunk. There are other entities in the chunk that are not actually changed and still get iterated. Your logic must not be destructive to these entities. Try treating changed filter as optimization rather than branching logic, always imagine if the changed filter is removed, everything must still work like before but with worse performance

https://gametorrahod.com/change-version/

#dots #ecs

ECS Galaxy Sample: a project showing a large-scale simulation of several teams of spaceships fighting for the control of planets. This is a fully-automated simulation, but players can spectate using different camera modes. Players can also bring up a "Settings" menu during play to tweak some simulation parameters in realtime.

This sample aims to strike a balance between being simple and lightweight enough to be easy to learn from, and involving enough non-trivial ECS game code (AI, spatial queries, event-based logic, different unit/building types and roles, etc...) to make an interesting showcase.

https://github.com/Unity-Technologies/ECSGalaxySample

#ecs #dots #sample

Instantly Boost Unity Game Performance With IL2CPP_USE_SPARSEHASH

Finally, another post on my blog. This investigation was time-consuming, and while I won't say I enjoy digging through generated C++ code, the results were worth the effort. Hit the fire emoji if you like this type of content and want me to write more of it.

The metadata in IL2CPP generated for each type and used for tasks like virtual method invocation is barely covered online. Not even the Unity documentation provides sufficient information. More crucially, you won't find details online about how the metadata is stored in memory or the existence of the define IL2CPP_USE_SPARSEHASH. In this post, I dive into the internals available in the generated C++ code to learn more about it and how we can significantly boost the performance of some operations in our games using this knowledge.

Here is a lifehack to improve performance using a concrete example of dependency resolution at the app start for all DI enjoyers. Of course, this isn't free, but performance is always about compromise.

https://gamedev.center/instantly-boost-unity-game-performance-with-il2cpp_use_sparsehash/

I've also posted this on Reddit, so I would appreciate it if you upvote it for all the effort put into this: a reddit post

#il2cpp #performance #optimization #IL2CPP_USE_SPARSEHASH

[C#] Asynchronous processing and async/await

A great overview of how async/await works, from the differences between async and multithreading programming to explaining how async is compiled and operates under the hood. It's an excellent resource for interview preparation.

The content is in Japanese, but it's by the already legendary Annulus Games, and auto-translation does a good job.

https://annulusgames.com/blog/async-await/

#async #interview

An unusual post for this channel and a note on why I haven't posted in a while. I had the pleasure of giving a talk at Digital Dragons about "The Controllers Tree," the architectural framework developed by some of the top-tier engineers at our company.

I didn't expect the venue to be completely packed. I was pleasantly surprised to see so many people interested in the architecture at the event.

And of course, thanks to all the engineers who participated in developing the framework.
It helps us to build and grow multiple of the biggest mobile games.
We hope to release the Controllers Tree package as an open-source solution soon, so stay tuned. I also hope the video of the talk will be posted by the organizers on YouTube soon, so I can share it here. Drop a comment if you happened to attend this conference too.

Unity UI Toolkit documentation code examples

We are actively adopting UI Toolkit for our editor tools. And it turns out to be pretty convenient.
Still a lot of concerns regarding using it in the runtime tho. Do you have any experience with it for in-game UI? How is it going? Would you recommend it? Would be happy to discuss in the comments.

Editor UI examples
Get started with UI Toolkit
Relative and absolute positioning C# example
Create a Custom Inspector

Runtime UI examples
Get started with runtime UI
And many more other examples how to do different stuff with it. Check the full list in the repo.

https://github.com/Unity-Technologies/ui-toolkit-manual-code-examples

#uitoolkit #sample

Master Realtime VFX in Unity and Substance Designer! Learn How to Create a Fire AOE Orb!

I used this tutorial to create a fire orb for my game. It's 1 hour long, but covers everything in detail. If you are new to the shader graph, then I definitely recommend it.

https://www.youtube.com/watch?v=Cb3Zv9H1os4

#vfx #shadergraph

When, where, and why to put [BurstCompile], with mild under-the-hood explanation

A while ago, I was reviewing the burst inspector and noticed that only static methods were being bursted while others that I thought should qualify were not (no reference types, structs passed as ref args, etc.). After I had made these methods static, they were bursted right away. I was wondering why this was the case because I haven't seen that requirement in the docs (I probably just missed it). Anyway, I have recently found this thread which directly answers this question.

The first two things to know, from which all else flows, but seems a bit surprising at first:
1. Burst can only ever burst static methods, period, end of story. If you want this to happen outside of the special cases outlined below, just put [BurstCompile] on a static method and on its declaring type.* When you call this method, it will call the bursted version automatically, assuming burst compilation didn't fail.
2. Unless you try really hard, all C# called from bursted code is bursted.

https://forum.unity.com/threads/when-where-and-why-to-put-burstcompile-with-mild-under-the-hood-explanation.1344539/

#dots #ecs

The Strange Graphics Of LETHAL COMPANY

The case when it's so strange that it turns out to be genius.

https://www.youtube.com/watch?v=Z_-am00EXIc

#rendering