AnnulusGames/Alchemy: Provides a rich set of editor extensions and serialization extensions for Unity

Another great package by Annulus Games - open source Odin alternative.

https://github.com/AnnulusGames/Alchemy

#inspector

LWGUI: A Lightweight, Flexible, Powerful Shader GUI System for Unity.

https://github.com/JasonMa0012/LWGUI

#inspector #shader

Modern Git Commands and Features You Should Be Using

Switch, restore, sparse checkout, worktree, bisect

https://martinheinz.dev/blog/109

#git

UnityDomainReloadHelper

A couple of attributes that help when Domain Reloading is disabled, which significantly decreases the time it takes for Unity to play a scene. By default, Unity provides the RuntimeInitializeOnLoadMethod attribute to assist, but it can be a little cumbersome.

I encourage you to write code in a way that allows you to turn off the domain reload upon entering play mode. It greatly speeds up the workflow even for my small pet projects. I have also worked on projects in production that have more than 1k assembly definitions, and reloading takes ages, so entering play mode was painfully slow and without this option turned off it was really hard to work.

https://github.com/joshcamas/unity-domain-reload-helper

#domainreload #attribute #editortools

How to implement multi-threaded frustum culling in Unity C#

Unity does this process under the hood already, but for some special cases with a custom renderer it might be needed.

https://www.pinwheelstud.io/post/frustum-culling-in-unity-csharp

#jobsystem #culling

How To Fix Deep Link/Push Notifications Crashes On Unity iOS after Apple Privacy Manifests update (and Why Software Design Matters)

A nasty crash appeared after the update from Unity 2021.3.31f1 to 2021.3.36f1, and the update was required due to the Apple privacy update and the introduction of Privacy manifest files since the support for it was added relatively recently. So you either have already encountered this crash or would encounter it soon if you publish your games to the App Store and use Facebook SDK and deep links as the deadline for this update is really close.
Strangely it was reproduced only on iOS 15 and 16, while iOS 17 was okay.
It turned out to be an interesting investigation, so I wanted to share the details with you.

It's funny how the regex to replace the generated UnityAppController.mm in FB SDK has been sitting there since 2015 and only now fired so badly causing a crash on a subset of devices. And it happened due to the UnityAppController.mm template being updated in one of the newer Unity versions.

And it's a perfect example of "Unknown Unknowns" discussed in "A Philosophy of Software Design" by John Ousterhout. Unknown unknowns increase the complexity of your system, but when it happens between 2 third parties it becomes multitudes times harder to track and resolve.
I definitely recommend the book.

According to the issue tracker, it also happens in 2022 and 2023, so now you know what to do if your app starts crashing on iOS after Unity update.

https://gamedev.center/how-to-fix-deep-link-push-notifications-crashes-on-unity-ios-and-why-software-design-matters/

#crash #ios

Noisy Nodes: Adds various noise generation nodes to Unity Shader Graph, including 3D noise nodes.

https://github.com/JimmyCushnie/Noisy-Nodes

#shadergraph #noise

mixandjam/balatro-feel: Recreating the basic Game Feel from Balatro

I've played Balatro a lot, and one of the reasons it's so satisfying is its animations and card behavior. Despite being pretty simple, the attention to detail is crazy. Once, I even caught myself staring at the card iteration animation, which is a plain white texture fade-out, but it blends so nicely with the overall flow.

https://github.com/mixandjam/balatro-feel

#feature #feel #balatro

Enableable Components Generated Code

How do enableable components work under the hood with the job system? There is actually the same code generated for both regular and enableable components, and multiple ifs decide how the components are processed.

https://gametorrahod.com/enableable-generated-code/

#ecs #dots

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

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

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

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

[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

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

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

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

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