Mesh-Peeling

https://github.com/bunszr/Mesh-Peeling

#mesh #peel

Intro to DOTS animation

No, there is still no solution provided by Unity as part of DOTS.
The author shows how to use a hybrid animator approach, similar to one shown in DOTS character controller samples.
The video also shows the simplest example how to use 2 most popular animation assets from the asset store.

https://youtu.be/KvabbZKrUHk

#dots #animation

Dependency Injection on Unity

Another post why DI might be useful. But it also contains an implementation of a custom DI container, which is a great way to learn how containers work under the hood, especially how injections into MonoBehaviors work

Part 1: https://moderncsharpinunity.github.io/post/dependency-injection-on-unity/

Part 2: https://moderncsharpinunity.github.io/post/dependency-injection-on-unity-part2/

#di

Day Night Cycle using LUT in Fragment Shader of Materials

https://shahriyarshahrabi.medium.com/day-night-cycle-using-lut-in-fragment-shader-of-materials-80edaf26f655

Repo: https://github.com/IRCSS/Day-Night-LUT-Shader

#shader #lut

You can go a long way just by multiplying and adding simple textures in a creative way. ❄ Check out this frozen effect! Adding a few extra particles sells the illusion

https://twitter.com/unitygames/status/1536725196274642944

#vfx #frozen

Particle Effect For UGUI (UI Particle): This plugin provide a component to render particle effect for uGUI in Unity 2018.2 or later.
The particle rendering is maskable and sortable, without Camera, RenderTexture or Canvas.

It also correctly scales particles and provides better performance with mesh sharing feature.

https://github.com/mob-sakai/ParticleEffectForUGUI

#ui #particle

Moving faster

I find this very useful to help structure your development process. In the university I had the Personal Software Process (PSP) course that was also aimed to make each part of software development lifecycle more effecient. This post obviously does not cover what the whole course teaches you about, but it's a good place to start.
I also feel The Pragmatic Programmer vibes in this post. Some advice are directly from this book. So if you liked the post, you may take a look at the book too.

https://www.scattered-thoughts.net/writing/moving-faster/

#psp #productivity

Exarion

This tool makes a greyscale texture that tells each pixel when it should display itself. It helps create these types of textures easier.

https://botsop.itch.io/exarion

#vfx

Vertex Color Baker

An AssetPostprocessor for Unity that can bake ambient occlusion and curvature information into mesh vertex color channels, mainly intended for mid-poly workflows and procedural hard surface shaders.

https://github.com/Fewes/VertexColorBaker

#ao #vertexcolor

How to access worldwide your WebGL build from the local machine

https://medium.com/@wondrous_aqua_toad_341/how-to-access-worldwide-your-webgl-build-from-the-local-machine-b506c24a4dbd

#webgl

C# Journey into struct equality comparison, deep dive

A great post that dives into reasoning behind implementing IEquatable<>: where exactly allocations happen and that default ValueType Equals implementation uses structural comparison only for tightly packed structs, otherwise field-by-field comparison is used which utilizes reflection.
For us it means that we must implement IEquatable<> in our structs in case they are compared, which is common case when used in collections (dictionary, list, array, etc).

https://medium.com/@semuserable/c-journey-into-struct-equality-comparison-deep-dive-9693f74562f1

#performance #equals

Unity HDRP & ShaderGraph: Nodes that Bloat Shaders

It's nothing new that Shader Graph generates less-than-ideal code, but it's still interesting to examine in detail and see which more optimal solutions the author proposes.

https://justlukass.hashnode.dev/shadergraph-can-bloat-your-shaders-and-here-is-when

#performance #shader

Unity Assembly Definitions Explained: How to Organize and Control Your Code

This is definitely a good post that provides an overview of assembly definition settings and the benefits they bring. However, it's important to remember that any approach can backfire when taken to extremes. Having too many asm defs can significantly slow down your iterations. Even if compilation takes only seconds when your project is split into tiny assemblies, the domain reload would take much longer than compiling bigger assemblies, but in smaller quantities. Additionally, Rider needs to process all the assemblies, which also takes a lot of time, and this processing time seems to increase non-linearly as the number of assemblies grows.

Of course, the impact varies, and you should profile on your current hardware with your specific project. For me, 'too many assemblies' starts at around 500-600.

https://marcomignano.com/posts/unity-assembly-definitions-explained-how-to-organize-and-control-your-code

#asmdef

Estimating Early Access success

Analysis of steam reviews amount during early access.
Based on stats:
- if your game has less than 10 reviews in the first month of EA, then it's a miss.
- more than 200 it's a potential hit.

But in the end 200 is an arbitrary number the author has chosen, so don't make any targets or KPIs of reaching 200 reviews.

https://howtomarketagame.com/2023/08/21/estimating-early-access-success/

#marketing

niwatly/SectorLayoutGroup: Align children along the custom sector shape in Unity.

https://github.com/niwatly/SectorLayoutGroup

#layout

Volumetric grass shader

https://shahriyarshahrabi.medium.com/volumetric-grass-shader-28ebb9f6860b

#grass #shader

Migrating built-in shaders to the Universal Render Pipeline

Just in case you still have a built-in pipeline and decided to move to URP your whole project or some shaders this post must be helpful and should be added to the bookmarks.

https://blog.unity.com/engine-platform/migrating-built-in-shaders-to-the-universal-render-pipeline

#shader #urp

How to Make a Good 2D Camera

Here is a list of camera tricks and games where it's used. It's a good starting point for drawing inspiration for your game camera.

https://youtu.be/TdWFzpgnljs

#camera

Magic Tween

Extremely fast tween library implemented in Unity ECS

https://github.com/AnnulusGames/MagicTween

#tween #ecs

The reddit post with the recommendations list of Unity to Unreal tutorials

https://reddit.com/r/Unity3D/s/kPbZCC7Kdc

#unreal

The Weak Event pattern

Events in C# are a powerful mechanism for decoupling components and enabling a publisher/subscriber model. However, they have a significant drawback: the publisher holds a strong reference to the subscriber, and this can cause memory leaks. This article describes a pattern for implementing weak events in C#.

https://steven-giesel.com/blogPost/675b75fc-2c1b-43da-9ff8-42962ca8159b

#weakevent #observer