Unity Editor Toolbox

ToolboxDrawers are categorized into 5 sub-types to handle different Inspector customization needs. Choosing the right type depends on whether you want to decorate, validate, or completely replace the rendering of a property.

Drawer Sub-types

1. ToolboxDecoratorDrawers: Used to create UI elements (icons, labels, controls) that appear before or after a serialized property. You can use multiple decorators on a single property.
2. ToolboxConditionDrawers: Used to validate a property's state. They determine if a property should be Disabled or hidden. Use only one per property.
3. ToolboxSelfPropertyDrawers: Used to customize the visual look of a specific property field. Use only one per property.
4. ToolboxListPropertyDrawers: Used to customize the appearance of list/array properties. Use only one per property.
5. ToolboxTargetTypeDrawers: Used to specify a custom look for all properties of a specific type (e.g., all int fields) regardless of attributes.

Implementation Workflow

To create a new drawer, follow these steps:

1. Decide which drawer sub-type fits your requirement.
2. Implement a dedicated ToolboxAttribute class (if the drawer is attribute-based).
3. Implement the corresponding ToolboxDrawer class.
4. Assign the newly created drawer in the Toolbox Settings file.
5. Apply the attribute to your target field in your scripts.

Use ToolboxListPropertyDrawer<T> to customize the rendering of lists or arrays. Inherit from ToolboxListPropertyAttribute to create the attribute.

• OnGuiSafe(property, label, attribute): Use this to define how the list header and its elements are drawn.

using UnityEngine;

public class StandardListAttribute : ToolboxListPropertyAttribute
{ }

using UnityEditor;
using Toolbox.Editor.Drawers;

public class StandardListAttributeDrawer : ToolboxListPropertyDrawer<StandardListAttribute>
{
	protected override void OnGuiSafe(SerializedProperty property, GUIContent label, StandardListAttribute attribute)
	{
		EditorGUILayout.LabelField("Custom list drawer example");
		EditorGUILayout.PropertyField(property, label, false);
		if (property.isExpanded)
		{
			EditorGUILayout.PropertyField(property.FindPropertyRelative("Array.size"));
			var size = property.arraySize;
			for (var i = 0; i < size; i++)
			{
				var element = property.GetArrayElementAtIndex(i);
				EditorGUILayout.PropertyField(element, element.isExpanded);
			}
		}
	}
}

You can add custom buttons and elements to the Unity main toolbar using ToolboxEditorToolbar.

Note: For Unity 6.3+, it is recommended to use the official Unity Toolbar API instead of this implementation, which relies on Reflection and overriding VisualElements.

To use it, subscribe to OnToolbarGuiLeft or OnToolbarGuiRight within an [InitializeOnLoad] class.

using Toolbox.Editor;

[UnityEditor.InitializeOnLoad]
public static class MyEditorUtility
{
	static MyEditorUtility()
	{
		ToolboxEditorToolbar.OnToolbarGuiLeft += OnToolbarGuiLeft;
		ToolboxEditorToolbar.OnToolbarGuiRight += OnToolbarGuiRight;
	}
	
	private static void OnToolbarGuiLeft()
	{
		GUILayout.FlexibleSpace();
		if (GUILayout.Button("1", Style.commandLeftStyle))
		{
			Debug.Log("1");
		}
		// ... other buttons
	}

	private static void OnToolbarGuiRight()
	{
		if (GUILayout.Button("1"))
		{
			Debug.Log("1");
		}
	}
}

You can enable/disable or show/hide properties using custom conditions. These work with boolean, int, string, UnityEngine.Object, and enum types, and they function correctly even with array/list properties. You can pass values from fields, properties, or methods.

Condition Types:

• Visibility: [ShowIf(nameof(member), value)], [HideIf(nameof(member), value)], [ShowDisabledIf(...)], and [HideDisabledIf(...)].
• Interactivity: [EnableIf(nameof(member), value)], [DisableIf(nameof(member), value, Comparison)], [DisableInPlayMode], and [DisableInEditMode].
• Warnings: [ShowWarningIf(nameof(member), value, "Message", DisableField)].
• Combined: [Disable, ReorderableList] can be used to apply multiple attributes.

public string StringValue => "Sho";
[ShowIf(nameof(StringValue), "show")]
public int var1;

[DisableIf(nameof(GetFloatValue), 2.0f, Comparison = UnityComparisonMethod.GreaterEqual)]
public int var2;

public float GetFloatValue()
{
	return 1.6f;
}