UI Toolkit: New and updated demos for programmers and artists

I’ve seen some Entities samples by Unity Technologies that use UI toolkit for in-game UI and not just for editor tools. It was interesting to play around a bit, but I have no real experience working with it in production yet. If anyone has used UI toolkit for in-game UI in production, I would be happy to hear about your feedback in the comments.

https://blog.unity.com/engine-platform/new-ui-toolkit-demos-for-programmers-artists

Quiz sample: https://assetstore.unity.com/packages/essentials/tutorial-projects/quizu-a-ui-toolkit-sample-268492

Dragon Crashes sample: https://assetstore.unity.com/packages/essentials/tutorial-projects/ui-toolkit-sample-dragon-crashers-231178

Video: https://www.youtube.com/watch?v=XtQist-I3Xo

#uitoolkit

Web runtime updates are here: Take your browser to the next level

A lot of new features for web builds: compute shaders, GPU skinning, SIMD, better exception handling and more

https://blog.unity.com/engine-platform/web-runtime-updates-enhance-browser-experience

#webgpu #web

PrimeTween

High-performance, allocation-free tween library for Unity. Create animations, delays, and sequences in one line of code. A lot faster than other tween libs according to author's benchmarks. It would be interesting to see comparison to Magic Tween too in the same benchmarks, because Magic Tween is claimed to be even faster than PrimeTween

https://github.com/KyryloKuzyk/PrimeTween

Performance comparison: https://github.com/KyryloKuzyk/PrimeTween/discussions/10

#tween

Soft Mask: a plugin that brings alpha-friendly masking to UI

It works almost like the standard Unity's mask, but supports alpha, which enables gradual and semi-transparent masks.

Repo: https://github.com/olegknyazev/SoftMask

Demo: https://olegknyazev.itch.io/softmask

#ui #mask

ParrelSync is a Unity editor extension that allows users to test multiplayer gameplay without building the project by opening another Unity editor window and mirroring changes from the original project.

Gonna come in handy especially given the new template release: small scale competitive multiplayer.

https://github.com/VeriorPies/ParrelSync/

Template: https://forum.unity.com/threads/small-scale-competitive-multiplayer-template-now-released.1520044/

#netcode #editortools

Unity Case Study: Vampire Survivors

This blog post is a good starting point for developers who are interested in learning more about architecture principles for Unity games and how to analyze other projects.

https://medium.com/@simon.nordon/unity-case-study-vampire-survivors-806eed11bebb

#review

Updated 2022 LTS Best Practice Guides for optimizing games | Unity Blog

Two new books featuring optimization tips and tricks for mobile, consoles, and PC have been released. I've skimmed through both materials; all the tips have already been published in various resources. However, it's great to have them compiled in one place with navigation via the contents page. I highly recommend bookmarking these books.

https://blog.unity.com/engine-platform/updated-2022-lts-best-practice-guides

#optimization #book

Managed memory reservation in Unity

Control heap growth in Unity using heap growth divisor to reserve memory before it is needed. The author provides a better way to do it compared to a large array allocation on the app start.

https://vbor.blog/posts/heap-realloc/

#memory #gc

Intro to Shader Graph in Unity 2022 (Your first graph, Textures & UVs, Transparency and Alpha)

For a long time, I was quite skeptical of Shader Graph due to the suboptimal performance of generated shaders. Consequently, I focused on learning HLSL. However, given the abundance of learning resources on Shader Graph, I decided to use it in my prototypes. It allows for the quick and easy addition of test shaders for my VFX. Now, I can confidently recommend trying it to save time during prototyping, especially if you are not highly proficient in HLSL. And as always, don't believe anyone about performance, profile yourself your particular game. Probably shader graph would be ok for you even in production.

https://danielilett.com/2023-09-26-tut7-3-intro-to-shader-graph/

https://danielilett.com/2023-12-04-tut7-4-intro-to-shader-graph-part-2/

https://danielilett.com/2023-12-11-tut7-5-intro-to-shader-graph-part-3/

#shadergraph

String Interning - To Use or Not to Use? A Performance Question

- String interning in non-native AOT is very slow and can drastically affect your application performance.
- If you call string.Intern in your code you probably should think if you really should.
- A very naive custom string cache based on ConcurrentDictionary<string, string> is drastically faster then the string interning cache and gives you an opportunity to clean-up the cache.
- If your app runs as a Native AOT app, then the performance is good, and the only drawback of the bulit-in string interning is an inability to clean it.

https://sergeyteplyakov.github.io/Blog/benchmarking/2023/12/10/Intern_or_Not_Intern.html

#interning

Use the GPU, Luke!

A highly detailed post about compute shaders, where the author delves into the intricacies of how GPUs work and provides a higher-level overview of the pipeline compared to Render Hell. I definitely recommend reading it, as well as Render Hell, if you are interested in more details on how GPUs operate.

https://arnaud-carre.github.io/2023-12-10-gpgpu/

#computeshader #rendering #gpgpu

How To Use Loops Inside Unity's Update Methods

An example of how not to use loops inside Update, along with a simple example of offloading calculations to a background thread using Awaitable, which is supported from 2023.1. However, it is not recommended for shorter-lived operations, such as parallelizing computationally-intensive algorithms. To maximize the use of multi-core CPUs and parallelize your algorithms, the C# Job System is recommended.

https://giannisakritidis.com/blog/Looping-Inside-Update/

Read more about Awaitable: https://docs.unity3d.com/2023.2/Documentation/Manual/AwaitSupport.html

#awaitable #async

BurstLinq: Extremely fast LINQ aggregation operations implementation optimized by Burst Compiler

I've run performance tests provided by the author and not in all cases BurstLinq was faster than regular for loop, but still in all cases a lot faster than Linq and in most cases faster than for. It was pretty interesting to check the source to see how these results were achieved.

https://github.com/AnnulusGames/BurstLinq

#burst #linq

Ultraviolet Lights & Invisible Ink Shader Graph

https://www.cyanilux.com/tutorials/ultraviolet-lights-invisible-ink/

#shadergraph #ultraviolet #ink

Arch: A high-performance C# based Archetype & Chunks Entity Component System (ECS) with optional multithreading

It's a type of repo that can be definitely recommended to read the source code and pick up some good practices. The ecs implementation is similar to Unity. Entities, but the codebase is easier to navigate and read in my opinion. It also contains source generation and can be used as a sample for your own implementation.

https://github.com/genaray/Arch

Source generation: https://github.com/genaray/Arch/tree/master/src/Arch.SourceGen

#ecs #sourcegen

Text-To-Material-Unity: Generate materials from text prompts in Unity

https://github.com/aniketrajnish/Text-To-Material-Unity

#aigen #material

Why am I not getting wishlists? A step by step solution

A great guide how to try triggering Steam algorithms. I love the advice about creating reddit posts with the noscript "I quit my job to make my dream game”, because lately, I've seen an influx of such posts, now we know why.

https://howtomarketagame.com/2023/12/05/why-am-i-not-getting-wishlists-a-step-by-step-solution/

#marketing #guide

CPU profiling for Unity

The Unity profiler is a powerful tool. It is useful when developing games, but requires the use of a development build. This type of build can introduce too much overhead in the app to obtain accurate performance data on the final game. For this reason, the Unity Profiler may not be suitable for precise CPU performance profiling of release builds. So this post explores other ways to profile release builds with minimal overhead

https://gpuopen.com/learn/unity-cpu-profiling-guide/

#profiling

Introducing Arm Frame Advisor

The previous post was about a low-overhead profiler, which allows detecting where issues are. After that it's time for a deep-dive profiler like Frame Advisor to investigate in detail what the root cause of the issue is.

https://community.arm.com/arm-community-blogs/b/graphics-gaming-and-vr-blog/posts/arm-mobile-studio-2023-5

#profiling