Sometimes you need to load assets in the editor without the comfort of a direct reference. Assets are loaded using the AssetDatabase and it can be done by

• Path
• Label
• Name
• GUID
• Instance ID

Instance ID

The instance ID is visible at the top of the inspector when the inspector debug mode is active.

 

Beware, the instance ID  survives enter/exit play mode but will change every time the asset is unloaded. For example when Unity is closed.

GUID

The GUID of an asset can be found in its meta file.

 

The GUID will only change when the meta file is changed/deleted.

Load Specific Asset

I wouldn’t recommend using a specific asset path for loading. It can easily break when someone decides to move the asset. A more future-proof and reliable approach is to load assets based on their GUID.

#if UNITY_EDITOR
using UnityEditor;

public static class AssetLoader
{
	public static T LoadAsset<T>(string guid) where T : class
	{
		string assetPath = AssetDatabase.GUIDToAssetPath(guid);
		var asset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(T)) as T;
		return asset;
	}
}
#endif

Load Assets From Folder

If the assets you want to load are placed in a specific location, you can use AssetDatabase.FindAsset to get them. The function takes a list of folders and a search-string as parameters.  It’s a bit more involved than loading by GUID. But the search-string makes the function very versatile because you can use every input that you would type into the project window (search field) to locate assets.

#if UNITY_EDITOR
using UnityEditor;
using System.Collections.Generic;

public static class AssetLoader
{
	/// <summary>
	/// Loads all assets of type <typeparamref name="T"/> in the 
	/// <paramref name="folderPath"/> including subfolders.
	/// </summary>
	/// <typeparam name="T"> Type of the assets to load.</typeparam>
	/// <param name="folderPath"> Path starting at the asset folder.
	/// Example: Assets/Folder/Folder </param>
	/// <returns></returns>
	public static List<T> LoadAssetsFromFolder<T>(string folderPath) where T : class
	{
		List<T> loadedAssets = new List<T>();
		string searchString = $"t:{typeof(T)}";

		string[] assetGUIDs = AssetDatabase.FindAssets(searchString, new[] { folderPath });

		foreach (var assetGUID in assetGUIDs)
		{
			string assetPath = AssetDatabase.GUIDToAssetPath(assetGUID);
			T loadedAsset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(T)) as T;
			loadedAssets.Add(loadedAsset);
		}

		return loadedAssets;
	}
}
#endif

Load Assets with Label

This uses the same approach as the previous function. It just changes the search string for the AssetDatabase.FindAssets.

#if UNITY_EDITOR
using UnityEditor;
using System.Collections.Generic;

public static class AssetLoader
{
	/// <summary>
	/// Loads all labeled assets of type <typeparamref name="T"/> in the 
	/// <paramref name="folderPath"/> including subfolders.
	/// </summary>
	/// <typeparam name="T"> Type of the assets to load.</typeparam>
	/// <param name="folderPath"> Path starting at the asset folder.
	/// Example: Assets/Folder/Folder </param>
	/// <param name="label">Asset label</param>
	/// <returns></returns>
	public static List<T> LoadAssetsByLabel<T>(string folderPath, string label) where T : class
	{
		List<T> loadedAssets = new List<T>();
		string searchString = $"t:{typeof(T)} l:{label}";

		string[] assetGUIDs = AssetDatabase.FindAssets(searchString, new[] { folderPath });

		foreach (var assetGUID in assetGUIDs)
		{
			string assetPath = AssetDatabase.GUIDToAssetPath(assetGUID);
			T loadedAsset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(T)) as T;
			loadedAssets.Add(loadedAsset);
		}

		return loadedAssets;
	}
}
#endif

Improving the inspector in Unity can have significant benefits for game development efficiency and workflow.

An organized and easy-to-read inspector layout can provide quick access to game objects, components, and properties, making it simpler to identify and modify different elements of the game without having to navigate a cluttered and confusing interface.

In addition, input validation in the inspector can reduce the likelihood of errors and mistakes by preventing developers from accidentally entering invalid or out-of-range values.

While custom inspectors and editors can be used for this purpose, even simple improvements such as good naming and attributes can make a big difference in enhancing the inspector experience.

Example

To illustrate the concept, I will use the following example script to show how to enhance the inspector gradually.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
  /// <summary>
  /// Must be in the Range 1 - 10
  /// </summary>
  [SerializeField]
  private float movementRange = 5f; 

  [SerializeField]
  private float movementSpeed = 3f;

  [SerializeField]
  private Animator animator;

   [SerializeField]
   private float animationParameterA = 0.5f;

  [SerializeField]
  private float animationParameterB = 1f;

  [SerializeField]
  private Transform myTransform;

  [SerializeField]
  private Vector3 someMoveVectorInDegree = Vector3.zero;

  [SerializeField]
  private AudioClip stepSound;

  [SerializeField]
  private AnimationCurve animationCurve;
}

1. Context

Organize the properties by context into groups.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
  [SerializeField]
  private Transform myTransform;

  [SerializeField]
  private Vector3 someMoveVectorInDegree = Vector3.zero;

  /// <summary>
  /// Must be in the Range 1 - 10
  /// </summary>
  [SerializeField]
  private float movementRange = 5f; 

  [SerializeField]
  private float movementSpeed = 3f;

  [SerializeField]
  private Animator animator;

    [SerializeField]
    private float animationParameterA = 0.5f;

  [SerializeField]
  private float animationParameterB = 1f;

  [SerializeField]
  private AnimationCurve animationCurve;

  [SerializeField]
  private AudioClip stepSound;
}

 

2. Naming

To continue improving the inspector, create separation between the groups from the previous step by either adding space or adding headers with fitting names. Additionally, enhance the naming of variables by either removing excess detail or providing context for improved clarity. 

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
  [Header("Movement")]
  [SerializeField]
  private Transform movementTransform;

  [Space]
  [SerializeField]
  private Vector3 moveVector = Vector3.zero;


  [SerializeField]
  private float movementRange = 5f;

  [SerializeField]
  private float movementSpeed = 3f;

  [Header("Visuals")]
  [SerializeField]
  private Animator animator;

  [SerializeField]
  private float animationParameterA = 0.5f;

  [SerializeField]
  private float animationParameterB = 1f;

  [SerializeField]
  private AnimationCurve animationCurve;

  [Header("Audio")]
  [SerializeField]
  private AudioClip stepSound;
}

 

3. Tooltips

To regain the detail information that was lost in the previous step, consider adding it as a tooltip that can be easily viewed by hovering over the item in both the inspector and your IDE. It is worth noting that tooltips are the best place to include unit information, such as indicating whether an angle is in radians or degrees. This helps to avoid confusion when making adjustments to variables.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
  [Header("Movement")]
  [SerializeField]
  private Transform movementTransform;

  [Space]
  [Tooltip("In degrees")]
  [SerializeField]
  private Vector3 moveVector = Vector3.zero;

  [Tooltip("Must be in the range [1 - 10]")]
  [SerializeField]
  private float movementRange = 5f;

  [SerializeField]
  private float movementSpeed = 3f;

  [Header("Visuals")]
  [SerializeField]
  private Animator animator;

  [SerializeField]
  private float animationParameterA = 0.5f;

  [SerializeField]
  private float animationParameterB = 1f;

  [SerializeField]
  private AnimationCurve animationCurve;

  [Header("Audio")]
  [SerializeField]
  private AudioClip stepSound;
}

 

4. Attributes

Using attributes is an effective method for validating input values and preventing out-of-bounds errors. Some of the available attributes include those that clamp values within a specified range or define minimum values. If you require an attribute that is not built-in, you can find a wide variety of useful options on GitHub. Certain attributes only modify how a value is displayed in the inspector, making it easier to understand the impact of any adjustments.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
  [Header("Movement")]
  [SerializeField]
  private Transform movementTransform;

  [Space]
  [Tooltip("In degrees")]
  [SerializeField]
  private Vector3 moveVector = Vector3.zero;

  [Tooltip("Must be in the range [1 - 10]")]
  [Range(1f, 10f)]
  [SerializeField]
  private float movementRange = 5f;

  [Min(0.1f)]
  [SerializeField]
  private float movementSpeed = 3f;

  [Header("Visuals")]
  [SerializeField]
  private Animator animator;

  [Range(0f, 1f)]
  [SerializeField]
  private float animationParameterA = 0.5f;

  [Range(0f, 1f)]
  [SerializeField]
  private float animationParameterB = 1f;

  [SerializeField]
  private AnimationCurve animationCurve;

  [Header("Audio")]
  [SerializeField]
  private AudioClip stepSound;
}

 

Conclusion

After applying the steps outlined above, you can expect to see significant improvements in the layout and functionality of your inspector. By comparing the original inspector with the final enhanced version, you can easily visualize the benefits of organizing properties by context, enhancing variable naming, and adding tooltips and attributes for improved clarity and validation. With an optimized inspector, you can work more efficiently and effectively, allowing you to focus on developing your game and bringing your vision to life.

Problem

The CreateAssetMenu attribute is handy if you want a quick way to instantiate scriptable objects.  But it falls short when a dynamic name or the initialization of different properties is needed, for example, the generation of a custom ID.

Solution

The solution is to create the asset yourself. The CreateAssetMenu attribute is only a wrapper for the UnityEditor.MenuItem attribute. Use the magic string Assets/Create as itemName to place it in the create menu. You can extend the itemName in the same way as the menuName in the CreateAssetMenu to add subfolders.

A simple script to create a scriptable object with a custom name could look like this:

using UnityEngine;

public class CustomObject : ScriptableObject
{
	public int RandomNumber;
	public Texture2D Graphic;

#if UNITY_EDITOR
	[UnityEditor.MenuItem("Assets/Create/Custom/Object at Root (Menu Item)", priority = 10)]
	private static void CreateWithRandomName()
	{
		CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
		myObject.RandomNumber = Random.Range(0, 42);

		string directory = "Assets";
		string assetName = $"NewAssetName{myObject.RandomNumber}.asset";
		string path = System.IO.Path.Combine(directory, assetName);

		UnityEditor.AssetDatabase.CreateAsset(myObject, path);
	}
#endif
}

Create at Selection

You can change the path of the created object to spawn it wherever you want. If you would like to mirror the behaviour of the CreateAssetMenu attribute, place it at the position of the current selection. The selection can be accessed via the UnityEditor.Selection.activeObject. Be aware that the active object can be ba an asset or a folder. If the first is the case the asset name needs to be stipped from the path.

	[UnityEditor.MenuItem("Assets/Create/Custom/Object at Selection (Menu Item)", priority = 10)]
	private static void CreateAtSelection()
	{
		CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
		myObject.RandomNumber = Random.Range(0, 42);

		string directory = UnityEditor.AssetDatabase.GetAssetPath(UnityEditor.Selection.activeObject);
		if (System.IO.Path.HasExtension(directory))
			directory = System.IO.Path.GetDirectoryName(directory);

		string assetName = "NewAssetName.asset";
		string path = System.IO.Path.Combine(directory, assetName);

		UnityEditor.AssetDatabase.CreateAsset(myObject, path);
		UnityEditor.Selection.activeObject = myObject;
	}

Create from Selection

Now it’s only a short step to a neat asset integration workflow.
Search the selected assets for the objects you need and add the references to the object instance.

Real-life example

We use custom AudioEffect scriptable objects in our games to wrap audio clips to support randomisation and variants.

You just have to select the clips and use the create menu. The object pulls the clip references from the selection and generates the correct name based on the source clips names. It’s a reall time saver if you have 100+ sounds with variants in your game.

	[UnityEditor.MenuItem("Assets/Create/Custom/Object from Selection (Menu Item)", priority = 10)]
	private static void CreateFromSelection()
	{
		Texture2D[] graphics = UnityEditor.Selection.GetFiltered<Texture2D>(UnityEditor.SelectionMode.Assets);
		if (graphics != null && graphics.Length > 0)
		{
			CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
			myObject.RandomNumber = Random.Range(0, 42);
			myObject.Graphic = graphics[0];

			string directory = UnityEditor.AssetDatabase.GetAssetPath(UnityEditor.Selection.activeObject);
			if (System.IO.Path.HasExtension(directory))
				directory = System.IO.Path.GetDirectoryName(directory);

			string assetName = $"MyObject_{myObject.Graphic.name}.asset";
			string path = System.IO.Path.Combine(directory, assetName);

			UnityEditor.AssetDatabase.CreateAsset(myObject, path);
			UnityEditor.Selection.activeObject = myObject;
		}
		else
			Debug.LogError("Select a texture to create a CustomObject.");
	}

Following the complete script with all examples:

using UnityEngine;

[CreateAssetMenu(menuName = "Custom/Object (Create Asset Menu)")]
public class CustomObject : ScriptableObject
{
	public int RandomNumber;
	public Texture2D Graphic;

#if UNITY_EDITOR
	[UnityEditor.MenuItem("Assets/Create/Custom/Object at Root (Menu Item)", priority = 10)]
	private static void CreateWithRandomName()
	{
		CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
		myObject.RandomNumber = Random.Range(0, 42);

		string directory = "Assets";
		string assetName = $"NewAssetName{myObject.RandomNumber}.asset";
		string path = System.IO.Path.Combine(directory, assetName);

		UnityEditor.AssetDatabase.CreateAsset(myObject, path);
	}

	[UnityEditor.MenuItem("Assets/Create/Custom/Object at Selection (Menu Item)", priority = 10)]
	private static void CreateAtSelection()
	{
		CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
		myObject.RandomNumber = Random.Range(0, 42);

		string directory = UnityEditor.AssetDatabase.GetAssetPath(UnityEditor.Selection.activeObject);
		if (System.IO.Path.HasExtension(directory))
			directory = System.IO.Path.GetDirectoryName(directory);

		string assetName = "NewAssetName.asset";
		string path = System.IO.Path.Combine(directory, assetName);

		UnityEditor.AssetDatabase.CreateAsset(myObject, path);
		UnityEditor.Selection.activeObject = myObject;
	}

	[UnityEditor.MenuItem("Assets/Create/Custom/Object from Selection (Menu Item)", priority = 10)]
	private static void CreateFromSelection()
	{
		Texture2D[] graphics = UnityEditor.Selection.GetFiltered<Texture2D>(UnityEditor.SelectionMode.Assets);
		if (graphics != null && graphics.Length > 0)
		{
			CustomObject myObject = UnityEditor.ObjectFactory.CreateInstance<CustomObject>();
			myObject.RandomNumber = Random.Range(0, 42);
			myObject.Graphic = graphics[0];

			string directory = UnityEditor.AssetDatabase.GetAssetPath(UnityEditor.Selection.activeObject);
			if (System.IO.Path.HasExtension(directory))
				directory = System.IO.Path.GetDirectoryName(directory);

			string assetName = $"MyObject_{myObject.Graphic.name}.asset";
			string path = System.IO.Path.Combine(directory, assetName);

			UnityEditor.AssetDatabase.CreateAsset(myObject, path);
			UnityEditor.Selection.activeObject = myObject;
		}
		else
			Debug.LogError("Select a texture to create a CustomObject.");
	}
#endif
}

Problem

Do you ever think “The GameObject setup is so weird, it should be documented” but then don’t do it? Or are you forced to insert components in strange places because Unity just can’t do it any other way? Keyword: Unity’s UI rendering order is influenced by the hierarchy.

Most of the time it seems excessive to create documentation for a single component. But then a few weeks later you wonder why it’s there and everything breaks when you delete/move it? It would be handy if you could leave a comment on the GameObject. Something like ‘Do not delete/move! This is needed for the clickblocker’. Programmers comment their code, why not the GameObject setup in Unity too?

Solution

And that’s what the comment component is for. It’s a component with a text box which you can put next to weird GameObject setups. It is opened by double clicking on it and you can format it differently depending on the severity. You can choose between Information, Warning, Error.

It is especially useful when you work with several people (designers, programmers) on the same project. It keeps your colleagues from unknowingly breaking already implemented features.

It can be very frustrating when 3 people in a row delete an important component because they think it is unnecessary. Every week the same bug comes back from QA and every time it is the same component that is missing. Only the person who deleted it during a cleanup changed. This goes on until everyone on the team knows that this particular component has a purpose and needs to stay right there.

My colleague wrote the comment component and put up the source code on GitHub.

Unity’s default gizmos are essential for visual debugging but can only be drawn in world space. This restriction can be rather annoying if you try to debug custom UI or viewport-based camera movement. A simple line at a specific pixel coordinate would solve the problem most of the time. There are two solutions to this problem. 

Solution A

Add a canvas with a half-transparent image at the screen position. This is easy to do but comes with the following disadvantages:

• Must be created/deleted each time you want to debug
• Sets the canvas and scene dirty -> causes version control noise
• Not suitable if the screen position is not static

Solution B

Draw gizmos at the Camera.NearClipPlane. You can’t draw the gizmos exactly on the near clip plane because they would be invisible. Offset the gizmos a bit (0.001f) in the camera view direction. The gizmos will move with the camera and behave like screen space gizmos. Be aware that the canvas scale must be taken into account when dealing with pixel coordinates. If something is slightly off chances are high that the canvas.scaleFactor is missing in a calculation.

Below is an example implementation that works with all camera projections and canvas modes except world-space. In world-space just use the default gizmos.

Code at my GitHub: https://github.com/AuriMoogle/Unity-ScreenSpaceGizmos

// Author: Anja Haumann 2022 - MIT License
// Explanation and more content at my blog: https://anja-haumann.de

using UnityEngine;

public static class ScreenGizmos
{
  private const float offset = 0.001f;

  /// <summary>
  /// Draws a line in screen space between the 
  /// <paramref name="startPixelPos"/> and the 
  /// <paramref name="endPixelPos"/>. 
  /// </summary>
  public static void DrawLine(
    Canvas canvas, 
    Camera camera, 
    Vector3 startPixelPos, 
    Vector3 endPixelPos)
  {
    if (camera == null || canvas == null)
      return;

    Vector3 startWorld = PixelToCameraClipPlane(
      camera, 
      canvas, 
      startPixelPos);

    Vector3 endWorld = PixelToCameraClipPlane(
      camera, 
      canvas, 
      endPixelPos);

    Gizmos.DrawLine(startWorld, endWorld);
  }

  /// <summary>
  /// Converts the <paramref name="screenPos"/> to world space 
  /// near the <paramref name="camera"/> near clip plane. The 
  /// z component of the <paramref name="screenPos"/> 
  /// will be overriden.
  /// </summary>
  private static Vector3 PixelToCameraClipPlane(
    Camera camera, 
    Canvas canvas,
    Vector3 screenPos)
  {
    // The canvas scale factor affects the
    // screen position of all UI elements.
    screenPos *= canvas.scaleFactor;

    // The z-position defines the distance to the camera
    // when using Camera.ScreenToWorldPoint.
    screenPos.z = camera.nearClipPlane + offset;
    return camera.ScreenToWorldPoint(screenPos);
  }
}

If you build a game in Unity you will need a few UI screens to guide your player. The number of canvases will increase with the complexity and size of your project.

The canvases and the UI graphics will start to clutter your scene view because canvases are not moveable. This leads to a bad editing workflow and version control noise if you fall back to disable/enable the canvases that you want to edit.

This problem can be solved by parenting a new panel game object right beneath the canvas, set it to stretch and move it out of the way. This is the new parent game object for your UI graphics. 

Default Setup

Improved Setup

The panel positions need to be reset in the beginning to make them visible again. This can be done in a custom build process or in a simple script that resets the position in awake. The script must be placed on the offset game object.

Example

using UnityEngine;

/// <summary>
/// Used on RectTransform panels which are moved away from their default
/// position in the scene view to organize UI screens for editing.
/// At runtime, the anchored position is set back to zero.
/// </summary>
public class ResetRectTransform : MonoBehaviour
{
  private void Awake()
  {
    var rectTransform = (RectTransform)transform;
    rectTransform.offsetMin = Vector2.zero;
    rectTransform.offsetMax = Vector2.zero;
  }
}