Data-Oriented Damage System - The Hot Path Show Ep. 4

Continuing the series of sharing my notes from The Hot Path Show for everyone who uses DOTS and/or wants to learn more about it. Here are the notes for the video on implementing the damage system in ECS. Of course, it is not the one and only way to design and implement such a system, but it is a good starting point to learn how experienced developers use ECS.

- How to use the dynamic buffer buffer with the example of DamageElementBuffer to store multiple damage sources in one frame.

- 01:00:00 - You should create the entity and pass needed components instead of adding them in a separate method, because it leads to the entity being placed in one archetype and immediately moved to another.

- 01:01:00 - Since v1.2 you can use:
state.EntityManager.CreateEntity(stackalloc ComponentType[] { ComponentType.ReadOnly<T>(), ... })
This code is burstable. The old approach with using typeof(T) in CreateEntity was not burstable.

- 01:16:00 - Use [WriteGroup] to override groups with other systems.

- 01:18:00 - If you create your own ECB, use state.WorldUpdateAllocator instead of Temp or any other because this one is rewindable—it’s preallocated and clears every two frames.

- 01:38:00 - Example of ECB usage when you need to add a component not every frame and only in small quantities. ECB has a cost when doing a lot of operations.

Watch the episode: https://www.youtube.com/watch?v=SWXYpWtJZ5k

The sample project: https://github.com/TheHotPathShow/Episode-4

#ecs #dots

🌊 Uber Stylized Water

A highly customizable open-source stylized water shader for Unity 6.
URP
Rendering Path: Forward, Forward+, Deferred

I love that the author even provided documentation on how to use it, as well as multiple templates with various water styles.
I checked it myself, and it has tons of options to tune and adjust for your visual style. Definitely recommend checking it out.

https://github.com/MatrixRex/Uber-Stylized-Water

#water #shader #urp

imkoi/sparse-inject: DI Container forged for game development 

The fastest DI container developed by a friend of mine. I like his engineering approach and the overall high quality of the solution, which you can verify even by checking the benchmarks in the repo, as these are one of the most thorough benches for unity DI containers available online. They are conducted with a deep understanding of how a DI container is used in real games and how to measure performance correctly.

For example, benchmarks that prewarm the code in JIT-compiled environments don’t reflect real use cases, as in your game the registering stage is executed only once—unlike benchmarks where the building stage is run multiple times before measurements are taken. 

Moreover, the results vary significantly between Mono and IL2CPP. I recommend checking the benchmarks and results to remind yourself how crucial it is to profile your code and not blindly trust every claim made online (yes, I’m looking at you, benchmarks in Reflex and VContainer repos). 

Of course, the same applies to the benchmarks by the Sparse Inject author—if you're considering replacing your current DI container with this one, profile your code on the target platform with your existing DI container first. Then, after converting to Sparse Inject, compare the results. Ideally, test on multiple devices—the minimum supported, an average one, and a top-tier one—as performance gains may vary. 

I’ve started porting my pet project from VContainer to Sparse Inject. While I love the minimal API of Sparse Inject, it also means that everything VContainer provided for Unity integration needs to be redone manually. On one hand, VContainer’s Unity integration allows you to kick-start a project quickly, but on the other, it makes switching to another DI container more difficult later as you must redo all of that.
A minimal API of sparse inject requires additional steps now to implement integration features of VContainer I used, but in the future it also makes porting to another DI much easier since you gain complete control and understanding.

Nevertheless, I’ve shared my notes with the author so he can create a migration and quick-start guides. I believe that, sooner or later, a repository with add-ons for quicker Unity integration will be created — avoiding repetitive tasks while maintaining a clean API by keeping these additions separate from the main repo. 

https://github.com/imkoi/sparse-inject 

#di #container #dod

With Android 15, Google introduced support for 16 KB memory page sizes in the OS. It is expected that device manufacturers will start bringing out devices with these capabilities to the market. Google’s testing suggests that there are noticeable performance gains in apps and games launching on 16 KB-capable devices, with up to a 10% improvement.

Support for 16 KB sizes is now available in the following Unity versions:

- Unity 6000.1.0b5 (expected release: February 9, 2025)
- Unity 6000.0.38f1 (expected release: February 14, 2025)
- Unity 2022.3.56f1 (released: January 15, 2025)
- Unity 2021.3.48f1 (released: January 22, 2025)

All native libraries in your project must be 16 KB compatible. Currently, the page size is 4 KB, and larger pages bring the following benefits:

- Lower app launch times under memory pressure: 3.16% lower on average, with more significant improvements (up to 30%) for some apps tested by Google.
- Theoretically reduced page table overhead: Since there are fewer pages to manage.
- Improved I/O performance: Larger pages require fewer read and write operations for data spanning multiple pages.
- Cache efficiency: Larger pages can lead to better cache usage, reducing the number of cache misses if your app has good data locality.

https://discussions.unity.com/t/info-unity-engine-support-for-16-kb-memory-page-sizes-android-15/1589588

#native #pagesize

Misconceptions about DOTS and Entities

Not every Unity developer has had a chance to work with the Entities package. So this is a good read to clear misconceptions surrounding DOTS. You should not be surprisied that you can use DOTS even without the Entities package in your project.

https://docs.google.com/document/d/18hFIQipNxTsKsWk9eRroRwkGgswWs6m40X8N4Kkjhy4/edit

#dots #ecs

Use Multiplayer Play Mode to test multiplayer functionality within the Unity Editor.

It was released almost a year ago, but I missed the announcement back then. Now that I've decided to work on a small co-op prototype, I find this tool amazing—it saves a lot of time. I remember how inconvenient it was to test a multiplayer game when I was working on my first multiplayer project around the time UNet was still relevant (8–9 years ago, if I'm not mistaken). To test it, I had to build a standalone version first, which took some time. Now, running multiple windows in Play Mode makes the process much faster.

Unreal Engine has had this functionality out of the box for a while, and I really liked it when I was creating another prototype to get acquainted with Unreal some time ago. So I'm very happy that Unity now offers the same functionality. Definitely recommend it if you're working on a multiplayer game.

https://docs-multiplayer.unity3d.com/mppm/current/about/

#netcode #multiplayer

And by the way, you can also set up the layout in the virtual player window, which allows you to debug more easily by having access to the console, scene view, and hierarchy.

Sampling vs. Instrumentation Profilers in Unity: When to Use Each for Better Performance

New Blog Post Alert!
It’s been a while since the last post on my website gamedev.center — lately, I’ve been deep into working on my pet project instead of writing. But finally, a new post is up!

I keep seeing Superluminal mentioned more and more—so is it time to take another look? 🤔

In this post, I break down sampling vs. instrumentation profilers, when to use each, and why a hybrid approach gives the best results. Plus, I share real-world profiling strategies that helped optimize Unity projects.

https://gamedev.center/sampling-vs-instrumentation-profilers-in-unity-when-to-use-each-for-better-performance/

#profiling #sampling

Easy Text Effects for Unity

An open-source Unity package for animating TextMeshPro text with customizable effects. Includes ready-to-use samples, real-time previews, and per-vertex animation capabilities.

https://github.com/LeiQiaoZhi/Easy-Text-Effects-for-Unity

#text #vfx

GitHub - ruccho/WaterRW: WaterRW is 2D interactive water system for Unity.

https://github.com/ruccho/WaterRW

#water

Performance checklist provided by Unity in their ECS samples repo covers both regular projects and DOTS.

It gives you a clear plan of what to check after identifying slow parts of your game through profiling. While the list may seem trivial to developers experienced in optimization, it's beneficial to have it formalized and written down somewhere to optimize your optimization workflow. And of course it’s very helpful for less experienced devs.

https://docs.google.com/document/d/1QQZz6xzmWpe6NMdL3t2o7RXmya6UFyl_Xgo3KPfGxzQ/

#performance #profiling

Stencil Debugger for Unity's Universal URP
Stencil Debugger is a utility for visualizing the stencil buffer in Unity URP. This is especially useful for debugging rendering effects that rely on the stencil buffer.

It's been a while since I last debugged a shader, and it was far from trivial—I had to write shader code just to render the debug info into a texture. So this tool is incredibly helpful, as it eliminates the need for custom debug code at least for the stencil buffer.

https://github.com/alexanderameye/stencil-debugger

#stencil #debug

Reveal-By-Progress-Shader-For-Unity: A custom shader for Unity that reveals an object based on a progress value.

This effect is based on an old tutorial by Alan Zucconi. It's great to see a complete implementation that can be easily used for prototyping. Currently, it supports only the Built-in Render Pipeline.

I have seen this revealing effect in a lot of hyper casual games. Moreover, it can be modified for other purposes—for example, cutting off dark vertices entirely to imitate a 3D printing mechanic.

https://github.com/AnhPham/Reveal-By-Progress-Shader-For-Unity

#shader #reveal #builtin