TransformAccessArrayDemo: This project demonstrates a few ways to implement moving 3d objects (casters) that project some decal on the ground below them.

Example how to use TAA API and how it is efficient to keep hierarchies flat.

https://github.com/Jura-Z/TransformAccessArrayDemo

#transformaccessarray #taa #optimization

Test Driven Indie Game Development

The author doesn't quite use TDD, but the point is still clear: automated tests increase initial development time, but save a lot more time to support code. Given that there are so many game-services now, support becomes 10 times more significant.

https://dbzer0.itch.io/hypnagonia/devlog/335569/test-driven-indie-game-development

#testing #automation #unittest

Expanded Math Functionality for Unity

- 2D Intersection tests
- Curves & Splines
- Trajectory math
- Triangle math
- Polygon math
- and more

https://github.com/FreyaHolmer/Mathfs

#math #lib

Drawing with SDFs in Unity

A simple drawer example with SDF shader

https://bronsonzgeb.com/index.php/2022/01/15/drawing-with-sdfs-in-unity/

#sdf

Best optimization tips by Unity engineers at Unite

Compilation of best Unity tips gathered at Unite conference. I spent a bunch of time rewatching those talks so you don’t have to.

https://gamedev.center/best-optimization-tips-by-unity-engineers-at-unite/

#unite #tips

Abusing For Loops In C# For Job Security

Found at r/shittyprogramming, indeed "helps" to become an irreplaceable developer. Still a fun read tho.

https://eddieabbondanz.io/post/c-sharp/abusing-for-loops-for-job-security/

Like Regular LINQ, but Faster and Without Allocations: Is It Possible?

Article got insights on how LINQ works. As a practical advice I don't find it really useful, because I am pretty sure you are not using LINQ in a hot path. And you gotta be a die-hard fan of it to carry an additional dependency just to use LINQ in critical sections

https://blog.devgenius.io/like-regular-linq-but-faster-and-without-allocations-is-it-possible-3d4724632e2a

#linq #enumerator #reflinq

Tech Art Toolbox - Erosion effects

A short and straight to the point video about different erosion effects done with shader graph.

https://twitter.com/matt_ostertag/status/1488489875766661122

#shadergraph #effect #erosion #shader

When to make LODs

Look in the wireframe view, when it starts to get close to solid, you need to swap to a lower LOD, which significantly reduces the density of the wireframe view.
In many cases, you’re better off with a single LOD and an imposter for the distance, or in some cases no LODs and just an imposter.

https://medium.com/@jasonbooth_86226/when-to-make-lods-c3109c35b802

#rendering #lod

Planar reflections probe component for Unity's Built-in Render Pipeline

Repo: https://github.com/eldskald/planar-reflections-unity

Video: https://youtu.be/w84-l3IEhXM

#reflection #vfx #reflectionprobe

How to make particles follow a path

https://youtu.be/hiyv9vZAOvA

#particles #vfx

Procedural Generation with Cellular Automata

A CPU-based approach to procedurally generate cave-like structures. Looks like it can be rewritten with compute shader as an improvement, but don't forget to profile tho if you end up using this or similar algorithm, CPU-based can be absolutely fine performance-wise in your case. And hell of a lot easier to debug.

https://bronsonzgeb.com/index.php/2022/01/30/procedural-generation-with-cellular-automata/

#pcg #generation #cellularautomata

Protobuf In C# .NET – Performance Comparisons

Series about protobuf. My latest blog post with talks from Unite contains the advice about using binary data serialization if native Unity formats are not suitable for your project. So in such cases you can consider protobuf.

https://dotnetcoretutorials.com/2022/01/18/protobuf-in-c-net-part-4-performance-comparisons/

#serialization #protobuf

DynamicResolutionSample: A simple, game usable noscript to drive Unity's dynamic resolution implementation.

Dynamic resolution is a technique for scaling render targets to reduce the number of pixels being processed to adapt to GPU performance concerns. It works by allocating the target resources at full resolution and then aliasing scaled versions over the same memory, which is very lightweight on the platforms/graphics APIs where it's supported. The final present target is unscaled so an upscale blit will always have to happen somewhere in the pipeline before that point.

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

#dynamicresolution #gpu #optimization

18 months of game programming interviews postmortem

One of the best posts in r/gamedev. Three-year old, but became even more relevant due to the global remote work trend, so more and more people got the chance to work in AAA companies.

https://www.reddit.com/r/gamedev/comments/9n847g/18_months_of_game_programming_interviews/

#interview #career

How bad are small triangles on GPU and why?

Small triangles are bad for performance. Kinda old post, but still holds true. Keep in mind the vertex density when creating LODs for your meshes, most likely you don't need a lot of different LODs wasting memory and reducing performance. And of course don't forget about imposters for distant objects.

https://www.g-truc.net/post-0662.html

#gpu #rendering #performance

An open source mesh slicer framework for Unity3D Game Engine. Written in C#.

Slice any convex Mesh using a Plane

https://github.com/DavidArayan/ezy-slice

#meshcutter #slicer

Impossible Geometry with Stencils in Unity URP

I have recently discovered a game called Moncage, that heavily uses this technique. For me it looked really interesting and innovative, but maybe I just play too little puzzles. Good breakdown of the effect anyway.

https://danielilett.com/2022-01-05-tut5-22-impossible-geom-stencils/

#stencil #rendering

Unity package to track a hand in realtime. 60 FPS hand detection. 3D Bones world detection

Requires an iPhone with Lidar support. Looks pretty awesome, not so long ago there was stuff like Leap Motion to detect hands and it had even lower accuracy, now it is available to a lot bigger audience.

https://github.com/ogoguel/realtimehand

#xr #ar #tracking

Profiler Extensibility.

Gives the ability to extend the Unity Profiler with custom data and visualisation in order to better measure the performance characteristics of your app. Profiler counters allow you to track the key metrics of an app and make them visible in the Unity Profiler or in other code. This is useful if you want to track performance changes in your application, and it speeds up the investigation of performance issues.
Looks like it could make automatic performance analysis easier with custom tools.

https://forum.unity.com/threads/profiler-extensibility.1119613/#post-7768908

#editortool #profiler

Breakdown of the impact frame effect

A high-level breakdown of the effect. Can be used as a starting point if you want to implement it in your game. Or if you learn shaders, it is a good task to figure out yourself given all the keywords to search step-by-step.

https://twitter.com/Raph_iuk/status/1490762063722995718

#vfx #shader #impactvfx