10 minutes to review the quality of any Unity project

A good read, and I've never seen a post regarding this topic before. It doesn't seem to come in handy for most developers in terms of real reviews of many projects, but it's definitely helpful to establish your own rules and guidelines for your projects.

https://medium.com/@wondrous_aqua_toad_341/10-minutes-to-review-the-quality-of-any-unity-project-6f7ce78f26fd

#review

Premature Optimization

The main point which I also always repeat in my own blog posts: profile first. Optimization might not even be needed in the first place. And without the baseline you can't even tell whether changes improved the performance or not.

https://youtu.be/tKbV6BpH-C8

#optimization

Turning Sine Waves Into Game Water

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

#water #shader

In my blog post about the build size I used the build option Faster(smaller) builds to greatly reduce the size of code generation with IL2CPP.
In our company we had a chance to have a meeting with Unity engineers. At that time I asked what does this build option do under the hood and what drawbacks it has. But got no answer. Now the answer is in the docs:

When the “Faster (smaller) builds” setting is enabled only the single fully sharable version of generic code is compiled. This reduces the number of methods generated, reducing compile time and build size, but comes at the expense of runtime performance.

https://docs.unity3d.com/Manual/ScriptingRestrictions.html

#generic #genericsharing

Leveraging SerializeReference for Flexible Commands in Unity Game Development

There commands are bound via the inspector. In one of our previous projects, we employed a similar approach, but the commands were bound to events in the code within the composition root through a DI container.

https://medium.com/@gbrosgames/leveraging-serializereference-for-flexible-commands-in-unity-game-development-614e336b03b9

#command

YetAnotherHttpHandler: YetAnotherHttpHandler brings the power of HTTP/2 (and gRPC) to Unity and .NET Standard.

From the developers of UniTask

https://github.com/Cysharp/YetAnotherHttpHandler

#http #networking

BatchRendererGroup sample: Achieve high frame rate even on budget devices

I wrote my own post about BRG and creating a sample year and a half ago when the documentation page was still empty. It took quite a while to figure out how to work with BRG by experimenting with code.
After some time, they filled up the documentation, but I still found it insufficient to get started with BRG without much effort. It's great to see a better sample and a very detailed blog post about it, even with such a significant delay after the initial announcement of BRG.

You can also check my blog post if you haven't yet, but the new one by Unity is more relevant now with more details and a bigger sample.

https://blog.unity.com/engine-platform/batchrenderergroup-sample-high-frame-rate-on-budget-devices

Repo: https://github.com/Unity-Technologies/brg-shooter

My sample: https://github.com/AlexMerzlikin/Unity-BatchRendererGroup-Boids/

My post: https://gamedev.center/trying-out-new-unity-api-batchrenderergroup/

#brg #instancing

Is .NET 8 performant enough?

Comparison of .NET 8 and Burst performance

https://meetemq.com/2023/09/18/is-net-8-performant-enough/

#performance

Unity Rendering Paths: Forward vs. Deferred Rendering

This is a well-rounded comparison of rendering techniques, although Forward+ is missing from the equation which eliminates the light count restriction. So would be great to see a deeper comparison there.

https://researchandprogram.blogspot.com/2023/10/unity-rendering-paths-.html?m=1

#rendering

A simple example of using IEnableableComponent

It's a replacement for tag components. Since Unity ECS stores data in chunks based on their archetype, tag components are considered a lot less performant due to structural changes when they are removed or added.

https://coffeebraingames.wordpress.com/2023/08/21/a-simple-example-of-using-ienableablecomponent/

Read more about archetypes and how entities are located in memory: https://docs.unity3d.com/Packages/com.unity.entities@1.0/manual/concepts-archetypes.html

#dots #ecs

DialogueGraph: Open-source node-based tool for developing branching conversation trees

https://github.com/TeodorVecerdi/DialogueGraph

#dialogue

OutlineFx: Simplified Outline for Unity Urp with 2D support

The outline effect is achieved in the following way: selected objects are first rendered into a texture.
Then, the edges of objects on this texture are drawn over the main texture.
Optionally, the outline can be drawn in a separate texture and then used through a shader.

https://github.com/NullTale/OutlineFx

#outline #outline2d

UniversalInventorySystem: A Unity Package for creating easy to use and highly customizable inventories and inventory`s UI

https://github.com/Heymity/UniversalInventorySystem

#inventory

Porting Unity to CoreCLR | Unity Blog

I love this series where Unity engineers dive deep into details of the engine. The post slightly explains how memory allocation is managed by a garbage collector. Unity currently uses the Boehm GC, which is conservative and non-moving. In contrast, .NET CoreCLR employs a precise, moving garbage collector, which offers better performance. The Unity engine and editor code were initially developed based on the Boehm garbage collector's requirements. To use the CoreCLR GC, several modifications are required, including changes to custom marshaling tools used by Unity, such as the bindings generator and the proxy generator. Unity is gradually transitioning to the new representation of references to managed objects in the unmanaged code to ensure a GC-safety in the engine. This work will enable the use of the CoreCLR GC, which should improve performance and efficiency by minimizing the GC's involvement in native code. There are still no release dates tho

https://blog.unity.com/engine-platform/porting-unity-to-coreclr

#gc #coreclr

Introducing the new URP 3D Sample: The beta release of the new URP Sample Scene

I ran the first scene, and after it completely loaded I got a 2+ seconds freeze on my relatively powerful machine (i7 13th gen, 4070 Ti). But it's a beta, right?
Anyway looks pretty impressive for URP, and is definitely worth checking.

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

#urp #sample

Unit Testing Made Easy: How I Test My Game Made With Unity ECS

I haven't posted on my blog for a while, partly because I've been investing time in developing my game, which is still in its very early stages. Nonetheless, I wanted to share how I write unit tests for this game, built using Unity.Entities – an ECS implementation by Unity itself. It's not rocket science, but I did spend some time setting it up, so you don't have to invest your own if you plan to add automated tests to your ECS-based game.

What I find even more interesting is setting up performance tests for the same project and the benefits it brings. I'm planning to share this as the second post in this series soon, so stay tuned.

https://gamedev.center/unit-testing-made-easy-unity-ecs-best-practices/

A sample repo which will be extended with performance tests for the second post: https://github.com/AlexMerzlikin/UnityEntities-AutomatedTests-Sample

#ecs #dots #testing

How can I modify built-in packages?

I have recently faced a bug in a Unity package, so this was the fastest way to fix it and continue the work. Yeah obviously you lose new updates but there is a way to create some sort of a patch tool, that would update the local package and apply your changes. Of course, this is unnecessary if the issue is fixed in an update. If you already know a tool that does it, would be great if you shared it in the comments.

https://support.unity.com/hc/en-us/articles/9113460764052-How-can-I-modify-built-in-packages-

#package #upm

Why Cities: Skylines 2 performs poorly

An insightful article about performance issues in Cities: Skylines 2. It's mind-blowing that they created a game of this scale using DOTS, which was released relatively recently and is by no means production-ready even now. The author speculates on how DOTS has affected the game's performance, given the extensive rendering tasks the developers had to implement themselves, which may not perform optimally. However, I am more than amazed by developers, it's monumental work that only top-notch engineers can accomplish in such a short time

https://blog.paavo.me/cities-skylines-2-performance/

#rendering #dots #performance

Classes vs. Structs. How not to teach about performance!

I always love reading posts by Sergey Teplyakov. Even though they are sometimes overly technical and tough to go through (not a bad thing at all). This one is a great example of why you should always profile your code, especially critical parts on the hot path, and not believe tests on the web, as some authors try to mislead you for their reasons or just out of pure negligence or ignorance.

https://sergeyteplyakov.github.io/Blog/benchmarking/2023/11/02/Performance_Comparison_For_Classes_vs_Structs.html

#performance #benchmark

How I got streamers and YouTubers to play my demo

An author shares great tips and resources on how to find relevant people increasing chances of your game being noticed.

https://www.reddit.com/r/gamedev/s/kmF6RDmqni

#marketing