Optimizing Texture Memory (VRAM) & Size

TL;DR
MEASURE TEXTURE VRAM USAGE AND DOWNLOAD SIZE using lox9973's Assetbundle Stat tool and Thry's VRAM estimator.
Reduce Resolution in the texture import settings! Not every texture needs to be 2k or 4k.
Don't disable mipmaps - Your materials will look and run better with them on!
Crunch doesn't change VRAM usage but can reduce download size. Not a magic bullet!
For Normal Maps, Use RG Compressed BC5 (From Platform overrides menu1). Normal Quality (DXT5nm) and High Quality (BC7) use the same VRAM but look worse.
For textures with Alpha, Use High Quality (BC7). Normal Quality (DXT5) uses the same VRAM but looks worse.
Don't use JPG (or other lossy formats) to store your source textures! Lower quality, with no benefit to VRAM/Download Size

https://www.poiyomi.com/blog/2022-10-17-texture-optimization

#optimization #vram

Performance tips and tricks from a Unity consultant

Amazing how fast recordings from Unite are available. Here is one of my favorite talks. Others I covered above and many more worth watching are all available now too.

https://youtu.be/CmD8MVGkDxQ?si=8JUVHTwHTqiRIT3l

#performance #optimization

Connecting the DOTS: Let’s make a game with Entities | Unite 2024

If you still haven't tried Entities, this talk gives you a good overview of what it is, how to work with it, and what drawbacks it has.

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

Repo: https://github.com/Unity-Technologies/Unite24ConnectingTheDOTS

The speaker, Daniel, is also a regular guest on the Hot Path Show, which I recommend watching if you already have any experience with Entities and would like to dive into the details.

#dots #entities

Architecture Behind Our Most Popular Games

The recording of my talk from May is finally available. It focuses on how multiple successful large-scale mobile games are developed and supported over an extended lifespan. I have already received feedback, and I realize I should have provided more detail on specific areas, such as the role of each component. If you'd like a post with a deeper dive into this architecture, drop a 🔥 reaction. Feel free to ask questions so I can cover them in that post.

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

#architecture #mvc #hmvc

Classic 3D videogame shadow techniques

https://30fps.net/pages/videogame-shadows/

I found this denoscription of shadow techniques very interesting. It's a good starting point for learning shadowing by trying to implement some of these techniques. For example, I learned a lot about shadow cascades by implementing it while following an excellent tutorial on a noscriptable render pipeline: https://news.1rj.ru/str/everydayUnity/2276.

Cascades are briefly mentioned in this post as a technique used in modern games. However, it does not cover the radiance cascade technique, which you can read more about here: https://news.1rj.ru/str/everydayUnity/2423.

#rendering #shadow

Unity 6 "empty" web build file sizes

How to reduce the size of web builds:

https://gist.github.com/aras-p/740c2d4f9977ce92b7de72b1394dd365

It’s worth noting that many of these recommendations are included in the updated Unity 6 documentation. However, it’s convenient to bookmark this post to have all the advice on one page.

https://docs.unity3d.com/Manual/web-optimization.html

https://docs.unity3d.com/Manual/web-optimization-mobile.html

#web #buildsize

Memory Mastery: Comparing Unity and .NET Garbage Collection

Another frequently raised question in interviews involves the differences between Unity and .NET garbage collection, and this post provides a clear answer without diving way too deep into the topic. Additionally, it offers general advice on avoiding excessive garbage generation, which can help reduce potential spikes caused by garbage collection.

https://medium.com/my-games-company/memory-mastery-comparing-unity-and-net-garbage-collection-4c23e693d3a5

#gc #interview

Optimize your game performance for mobile, XR, and the web in Unity (Unity 6 edition)

https://unity.com/resources/mobile-xr-web-game-performance-optimization-unity-6

A solid book with many performance tips — some are well-known, while others are new, especially those shared at the latest Unite conference regarding Unity 6. I'd like to point out the absence of the well-known tip about avoiding the animator's usage on the UI. It is claimed to have been fixed for quite some time already, even though it still has some performance implications (smaller tho): https://discussions.unity.com/t/animators-and-dirtying-ui/769821/16

#optimization #tips

Fake it ‘til You Make It: Faking Extended Draw Distance in Mobile Games

Developers of Block City Wars demonstrate a clever use of shaders and fog effects to fake distant objects, optimizing draw distance for better performance. In this game, players must be able to see the entire map from any position to avoid being at a disadvantage. Simply increasing the far clip plane isn’t feasible, as it raises the number of triangles passing through all culling stages. This means more objects undergo bounding box checks on the CPU and more fragments are processed on the GPU.

I encountered a similar issue while developing a car simulator set in an open city. We struggled because of the need to support multiple monitors, requiring separate cameras for forward, left, and right views, along with additional cameras for rearview mirrors.

Why not use a single camera with an ultra-wide FOV for forward, left, and right views? The answer is straightforward: to render 180 degrees, the FOV must be extremely high, resulting in unacceptable image quality due to severe distortions. This approach looked particularly bad on multiple monitors.

Instead, we opted for a combination of LODs, impostors, fog, and shorter draw distances for the left, right, and back cameras. Since players primarily focus on the forward view, this compromise worked well. And what was easier was that we didn’t need to render important objects all the time, as it was not needed for players to orient themselves using them.

https://www.gamedeveloper.com/production/fake-it-til-you-make-it-faking-extended-draw-distance-in-mobile-games

However, it’s unclear whether the solution includes LOD support for scaled-down meshes. If the distance is faked by scaling objects, then the high-poly version should be rendered, leading to high vertex density. This introduces performance challenges, as detailed in previous posts:
Vertex density
https://news.1rj.ru/str/everydayUnity/1634

Tips from the latest Unite https://news.1rj.ru/str/everydayUnity/2441

#rendering #culling

Unity’s TransformAccessArray — Internals and Best Practices

The TransformAccessArray in Unity is a specialized structure used for efficiently managing and accessing multiple Transform components, particularly in the context of jobs. It is designed to work with the Job System to allow parallel processing of Transform operations while minimizing overhead.
I tested this in my pet project a long time ago, and the difference was very noticeable, almost eliminating the cost of moving a large number of transforms every frame. While the API is pretty clean, working with jobs still adds cognitive load, so my advice is to always profile your code. Only if you see that transforms are the bottleneck should you switch from simple transform manipulations to using TransformAccessArray.

Tips from the Article:
- Use Burst.
- When a job only needs to read transforms (i.e., not write), use IJobParallelForTransform.ScheduleReadOnly.
- Break deep transform hierarchies into multiple transform roots whenever possible. This tip was also mentioned at Unite 2018 and in my post summarizing all performance tips from Unite.
- Review the desiredJobCount and innerloopBatchCount parameters. Aim for small enough values to keep all workers busy, but large enough to minimize the overhead of workers grabbing or stealing tasks too frequently.
- Prefer local space transform data like localPosition and GetLocalPositionAndRotation over world space data like position and localToWorldMatrix when possible.
- Reuse TransformAccessArray instances between frames; avoid recreating them unnecessarily.
- To remove a transform from the array, use TransformAccessArray.RemoveAtSwapBack instead of recreating the array. This is a general best practice for removing elements in hot paths.
- Avoid using transforms in a TransformAccessArray to store intermediary data between jobs. Transform access in jobs is slower compared to other alternatives.

https://medium.com/toca-boca-tech-blog/unitys-transformaccessarray-internals-and-best-practices-2923546e0b41

#optimization #performance #transform

UI Toolkit with Unity ECS - The Hot Path Show Ep. 3

In a free time I develop a pet project using Entities and
I've already mentioned The Hot Path Show here a few times promising to share my notes with insights from it. Even thought the videos are pretty long I find them very valuable as it always features the developer of Entities or the developer of a game made with DOTS and they share a lot of tips that might not be so obvious from the docs.

Here are my notes from the episode 3:
- ECB is slow, replaying the commands has a performance hit
- Dont use ECB all the time, default to use the main thread.
- If you see that parallelization is needed, then try to use native collections to gather entities and then perform the modification after the job
- Only if all the above is not working then use ECB
- Enableable components do not cause a not structural change
- EntityManager + EntityQuery is fast
- This is an example of fast entities destroying, since all of them in a one chunk

state.EntityManager.DestroyEntity(SystemAPI.QueryBuilder().WithAll<T>().Build());

- Dont use EntityQueryBuilder as its not burstable

I'd recommend you to check the show yourself, Since I am somewhat familiar with DOTS and Entities already, I might have missed some more basic advice. Would be great if anyone watching that shares the missed tips in the comments.
Drop a 🔥if you want more of similar recaps of videos and conference talks.

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

#ecs #dots

Twenty Five Slicer

A Unity package designed for more advanced sprite slicing, enabling a "25-slice" approach. It divides a sprite into a 5x5 grid, allowing precise scaling and manipulation of individual regions while preserving key areas.
9 slices: Non-stretchable areas.
6 slices: Stretch horizontally only.
6 slices: Stretch vertically only.
4 slices: Stretch in both directions.

This allows for far more detailed slicing. Where traditional 9-slice images often require stacking multiple image layers to achieve complex UI shapes (e.g., speech bubbles, boxes with icons or separators at the center), a 25-slice configuration can often handle these scenarios with just a single image.

https://github.com/kwan3854/TwentyFiveSlicer

#sprite #slicer

ArtificeToolkit: A Unity toolkit that allows easy editor customization with simple C# attributes.

A pretty new open-source package that can help replace Odin Inspector. Normally, extending Unity's editor requires specialized knowledge of IMGUI or UI Toolkit libraries and maintaining separate files for each extension. ArtificeToolkit simplifies this by letting you use custom attributes directly in the source code to alter property appearances in the editor.

It might not cover all of Odin's functionality, but based on the denoscription, it includes everything I used in my project, so it looks good to me. I haven't tested it personally, though.
It's implemented using Unity's new VisualElements framework.

Also not mentioned in the documentation, but you can create Editor Windows as if they were simple components by inheriting the ArtificeEditorWindow class and calling through a menu item the GetWindow

https://github.com/AbZorbaGames/artificetoolkit

#editor #inspector

Draw fewer tiles by using a dual-grid system.

How to create more rounded corners in a tilemap while using only 16 tiles instead of 47 to save runtime memory and reduce the effort of creating numerous tiles. This approach becomes especially crucial when working with animated tiles, as the tile count scales with each animation frame.

https://youtu.be/jEWFSv3ivTg

Demo: https://github.com/jess-hammer/dual-grid-tilemap-system-unity

The author also suggests a helpful tool for converting 15-piece sets to 47-piece sets: https://wareya.github.io/webtyler/

#tilemap #dualgrid

The Intelligent Mesh Combiner is a powerful Unity Editor tool designed to optimize your scenes by intelligently grouping and combining meshes based on their proximity and materials.

While I haven’t used this exact package yet, the underlying technique is highly effective for optimizing heavy scenes with numerous materials. I’ve had various experiences with this approach:
- Manually optimizing and combining 3D models in Blender.
- Using Asset Store solutions to automatically bake meshes in the editor.
- Developing a custom lightweight solution tailored to specific use cases.

This open-source package appears to offer a reasonable range of configuration options, making it a solid starting point if you don’t already have a tool for this functionality or have any issues with existing tool.

https://github.com/roundyyy/intelligent_mesh_combiner

#optimization #mesh

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