5 years later - my unity tips

This is my collection of tips for programmers that use Unity.

It's a lot, but all well considered, and I've cut a lot that I actually intended to include when I started writing. Check out my twitter channel for more.

Kind regards, Fredrik Ludvigsen

Hold your breath, here we go:

Always use GIT, Asset Serialization: Force Text and Version Control: Visible Meta Files

• GIT is the most feature rich version control system that can be relied upon by large projects. Its layered architecture enables both convenient use and high power, while being incredibly stable at the same time. You need it for the code and text assets, at least.
• Force Text is super important, because this is the only way you can resolve conflicts in scene files, asset files and prefabs. The alternative is to loose your colleagues data when they need a merge. I don't do that.
• Visible Meta Files is important if you want to check whether something is being linked from scenes, asset files or prefabs.
  The 'guid' field in the meta file is the key here. It's the identifier for your script, prefab, asset or whatever it is that you have a question about.
  
  Find the guid, then do something like:
  

  git grep d10e8671756c9834b86e995999881a3f -- "*.unity"

  
  GIT returns a handy list of all the scenes that use that particular asset. No need to iterate through all your scenes from a script.

Store static configuration data (audio databases etc.) as many ScriptableObjects.

Here there is a lot of knowledge that comes together in a beautiful way.

• Scene files are typically too large and too frequently changed. Even when using Git, they are a challenge to the person who merges.
• If an object within a scene links to a ScriptableObject, it will automatically be loaded along with the scene. It doesn't matter if the same ScriptableObject is also linked from other scenes, it's handled automatically. It's also a lot more performant than using the Resources system.
• If you need to edit many of them at the same time (still, audio databases is my best example), you can actually create a folder inspector. It's a bit of a hack, but it's truly the thing you want when dealing with a large number of similar ScriptableObjects.
• ScriptableObjects supports generics properly, even if they are serialized. This means you can finally start write some truly useful code, using generics.
• ScriptableObjects can also be stored in scenes.
  It happens automatically if it's linked from a scene and not stored elsewhere.

Not convinced? Listen to this guy:

Enable alt-scroll to go through mesh renderers under the mouse cursor.

Here's a script that every Unity developer I know has fallen in love with. http://wiki.unity3d.com/index.php/SelectByMouseScroll

Don't rely on names of scenes.

Your colleagues are going to betray you. If they don't rename a scene, they're going to really, really tempt you to do it yourself.

Don't fight them, but refer directly scenes, like this. http://wiki.unity3d.com/index.php/SceneField

Don't use Time.deltaTime in Lerp

I'm talking about the following popular easing (don't do it):

pos = Vector3.Lerp(pos, target, Time.deltaTime / 50f);

The equation you're looking for is called exponential decay, and it's super nice. It works the same but is frame rate independent.

Details here.

ContextMenu is the quickest way to transform a set of ScriptableObjects.

Simply create your method, select the objects and select the context menu option.

Done.

Create your own async tasks

It's easier than you'd think.

Use lock free queues when working with threads

With a lock free queue, working with threads becomes a piece of cake.

Use one queue for input and one queue for output. Now your threads have an efficient way to fetch and deliver data, no more conflicts or race conditions.

A tidy lock free queue for Unity, here.

Make sure that all bugs that are spotted gets registered

This is easy to do with a plugin like Dungbeetle, and it's by far the best way to reduce the number of testing hours required for your game.

In my projects I actually rarely see a bug twice, and it's just because of how efficient the bug registration process and tracking is.

Follow my twitter channel

I write unity tips there. Infrequently, but with high quality. Worth scrolling through.