GUILayout to calculate the size of the drawn fields, calls the OnGUI method twice:

• In the first run with event.type == EventType.Layout draws nothing, it only collects data about all components to be drawn in order to calculate the size of the rectangle for each of them;
• During the second pass, all elements are drawn for real.

Do not forget about the overhead for calculating rectangles. Thus, the understandable reasons here are optimization .

Thanks to this logic, the developer is waiting for the brain-blowing artifacts of drawing and bugs, when in samopisnye editors (most often it refers to the heirs of EditorWindow), he mixes up the use of both GUILayout and GUI methods. For example, if GUILayoutUtility.GetLastRect() or GUILayoutUtility.GetRect () is used GUILayoutUtility.GetLastRect() and the result is stored in the field, or the logic is tied to delegates and callbacks.

Problems are well treated by checking in critical places:

 if (Event.current.type != EventType.Layout) { ... } 

The very first time I read the PropertyDrawer documentation , I was terrified of working with rectangles. They suggest doing it this way:

 // Calculate rects var amountRect = new Rect(position.x, position.y, 30, position.height); var unitRect = new Rect(position.x + 35, position.y, 50, position.height); var nameRect = new Rect(position.x + 90, position.y, position.width - 90, position.height); // Draw fields - passs GUIContent.none to each so they are drawn without labels EditorGUI.PropertyField(amountRect, property.FindPropertyRelative("amount"), GUIContent.none); EditorGUI.PropertyField(unitRect, property.FindPropertyRelative("unit"), GUIContent.none); EditorGUI.PropertyField(nameRect, property.FindPropertyRelative("name"), GUIContent.none); 

Often in tutorials they do this (I changed the code a bit to emphasize the particular approach to working with rectangles):

 // Draw first field position.width -=200; EditorGUI.PropertyField (position, property.FindPropertyRelative("level"), GUIContent.none); // Shift rect and draw second field position.x = position.width + 20; position.width = position.width - position.width - 10; EditorGUI.PropertyField (position, property.FindPropertyRelative("type"), GUIContent.none ); 

It should be noted that at that moment I did not know about the possibilities of GUILayout. Imagine my horror when I decided that this is the only way to draw a UI that Unity can offer?

Years passed, I wrote a lot of interfaces using both GUI and GUILayout, but I could not reconcile with this situation. In my next article, I'm going to tell you how I stopped worrying and started cutting rectangles correctly.

Probably every programmer encountered a problem: he added [SerializeField] , but nothing appeared in the inspector? All the magic is that the class of the field must have the attribute [Serializable] , which does not always come to mind.

 using System; using UnityEngine; [CreateAssetMenu] public class SimplePeopleDatabase : ScriptableObject { [SerializeField] private Human[] people; [Serializable] public class Human { [SerializeField] private string name; [SerializeField] private Gender gender; [SerializeField, Tooltip("  ")] private int earedness; } public enum Gender { Undefined = 0, Male = 1, Female = 2, } } 

 using System; using UnityEngine; #if UNITY_EDITOR using UnityEditor; #endif [CreateAssetMenu] public class SimplePeopleDatabaseWithCustomEditor : ScriptableObject { [SerializeField] private Human[] people; [Serializable] public class Human { [SerializeField] private string name; [SerializeField] private Gender gender; [SerializeField, Tooltip("  ")] private int earedness; } public enum Gender { Undefined = 0, Male = 1, Female = 2, } #if UNITY_EDITOR [CustomPropertyDrawer(typeof(Human))] public class HumanPropertyDrawer : PropertyDrawer { private const float space = 5; public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label) { int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; var firstLineRect = new Rect( x: rect.x, y: rect.y, width: rect.width, height: EditorGUIUtility.singleLineHeight ); DrawMainProperties(firstLineRect, property); EditorGUI.indentLevel = indent; } private void DrawMainProperties(Rect rect, SerializedProperty human){ rect.width = (rect.width - 2*space) / 3; DrawProperty(rect, human.FindPropertyRelative("name")); rect.x += rect.width + space; DrawProperty(rect, human.FindPropertyRelative("gender")); rect.x += rect.width + space; DrawProperty(rect, human.FindPropertyRelative("earedness")); } private void DrawProperty(Rect rect, SerializedProperty property){ EditorGUI.PropertyField(rect, property, GUIContent.none); } } #endif } 

 using System; using UnityEngine; #if UNITY_EDITOR using UnityEditor; #endif [CreateAssetMenu] public class PeopleDatabaseWithCustomEditor : ScriptableObject { [SerializeField] private Human[] people; [Serializable] public class Human { [SerializeField] private string name; [SerializeField] private Gender gender; [SerializeField, Tooltip("  ")] private int earedness; [SerializeField] private Pet[] pets; } public enum Gender { Undefined = 0, Male = 1, Female = 2, } [Serializable] public class Pet { [SerializeField] private PetType type; [SerializeField] private string name; [SerializeField, Tooltip("     ?")] private bool combat; } public enum PetType { Undefined = 0, Wolf = 1, Dragon = 2, Raven = 3, } #if UNITY_EDITOR [CustomPropertyDrawer(typeof(Human))] public class HumanPropertyDrawer : PropertyDrawer { private const float space = 5; public override float GetPropertyHeight(SerializedProperty property, GUIContent label){ return EditorGUIUtility.singleLineHeight + EditorGUI.GetPropertyHeight(property.FindPropertyRelative("pets"), null, true); } public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label) { int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; var firstLineRect = new Rect( x: rect.x, y: rect.y, width: rect.width, height: EditorGUIUtility.singleLineHeight ); DrawMainProperties(firstLineRect, property); var petsRect = new Rect( x: rect.x, y: rect.y + firstLineRect.height, height: rect.height - firstLineRect.height, width: rect.width ); DrawPets(petsRect, property.FindPropertyRelative("pets")); // Separator var lastLine = new Rect( x: rect.x, y: rect.y + rect.height - EditorGUIUtility.singleLineHeight / 2, width: rect.width, height: 1 ); EditorGUI.DrawRect(lastLine, Color.gray); EditorGUI.indentLevel = indent; } private void DrawMainProperties(Rect rect, SerializedProperty human){ rect.width = (rect.width - 2*space) / 3; DrawProperty(rect, human.FindPropertyRelative("name")); rect.x += rect.width + space; DrawProperty(rect, human.FindPropertyRelative("gender")); rect.x += rect.width + space; DrawProperty(rect, human.FindPropertyRelative("earedness")); } private void DrawProperty(Rect rect, SerializedProperty property){ EditorGUI.PropertyField(rect, property, GUIContent.none); } private void DrawPets(Rect rect, SerializedProperty petsArray){ var countRect = new Rect( x: rect.x, y: rect.y, height: EditorGUIUtility.singleLineHeight, width: rect.width ); var label = new GUIContent("Pets"); petsArray.arraySize = EditorGUI.IntField(countRect, label, petsArray.arraySize); var petsRect = new Rect( x: rect.x + EditorGUIUtility.labelWidth, y: rect.y, width: rect.width - EditorGUIUtility.labelWidth, height: 18 ); petsArray.isExpanded = true; for (int i = 0; i < petsArray.arraySize; i++){ petsRect.y += petsRect.height; EditorGUI.PropertyField(petsRect, petsArray.GetArrayElementAtIndex(i)); } petsArray.isExpanded = true; } } [CustomPropertyDrawer(typeof(Pet))] public class PetPropertyDrawer : PropertyDrawer { private const float space = 2; public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label) { int indent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; float combatFlagWidth = 20; rect.width = (rect.width - 2*space - combatFlagWidth) / 2; DrawProperty(rect, property.FindPropertyRelative("type")); rect.x += rect.width + space; DrawProperty(rect, property.FindPropertyRelative("name")); rect.x += rect.width + space; rect.width = combatFlagWidth; DrawProperty(rect, property.FindPropertyRelative("combat")); EditorGUI.indentLevel = indent; } private void DrawProperty(Rect rect, SerializedProperty property){ EditorGUI.PropertyField(rect, property, GUIContent.none); } } #endif } 

Although the result looks good, it is difficult to convey in words all the emotions regarding this code. And even worse to imagine what will happen next.

Add the attribute [OneLine] to draw in one line and [HideLabel] to hide the unnecessary in our case title, eating up a third of the length of the line.

 using System; using UnityEngine; using OneLine; [CreateAssetMenu] public class SimplePeopleDatabaseWithOneLine : ScriptableObject { [SerializeField, OneLine, HideLabel] private Human[] people; [Serializable] public class Human { [SerializeField] private string name; [SerializeField] private Gender gender; [SerializeField, Tooltip("  ")] private int earedness; } public enum Gender { Undefined = 0, Male = 1, Female = 2, } } 

Stretching margins in width in OneLine looks weird with dynamic arrays (and the list of pets is just that), so we rigidly set the width to all fields with the [Width] attribute. This time the picture is clickable.

 using System; using UnityEngine; using OneLine; [CreateAssetMenu] public class PeopleDatabaseWithOneLine : ScriptableObject { [SerializeField, OneLine, HideLabel] private Human[] people; [Serializable] public class Human { [SerializeField, Width(130)] private string name; [SerializeField, Width(75)] private Gender gender; [SerializeField, Tooltip("  "), Width(25)] private int earedness; [SerializeField] private Pet[] pets; } public enum Gender { Undefined = 0, Male = 1, Female = 2, } [Serializable] public class Pet { [SerializeField, Width(60)] private PetType type; [SerializeField, Width(100)] private string name; [SerializeField, Tooltip("     ?")] private bool combat; } public enum PetType { Undefined = 0, Wolf = 1, Dragon = 2, Raven = 3, } } 

It turns out quite widely, but when working with a database, it is quite possible to stretch it to the full screen. In future versions, I plan to give OneLine the ability to draw too large fields in a few lines.

When I wrote databases for artists, I constantly set up detailed field hints with [Tooltip] , replacing the documentation. With this attribute in the inspector it is enough to hover the mouse on the field, and a pop-up little cloud will tell you everything about it.

Problem: as I wrote earlier, a simple call to `EditorGUI.PropertyField (rect, property, content) does not draw hints. Interestingly, SerializedProperty contains the tootlip property (note the comprehensive documentation), but it always turned out to be empty when I was accessing it. Chyadt ?

Solution: we take the SerializedProperty.propertyPath and with reflexion in our hands we crawl along the path from the very beginning (pay attention to the arrays), when we crawl to the end, we can learn all the attributes of the field. I use this method of getting field attributes not only for working with prompts.

 public static T[] GetCustomAttributes<T>(this SerializedProperty property) where T : Attribute { string[] path = property.propertyPath.Split('.'); bool failed = false; var type = property.serializedObject.targetObject.GetType(); FieldInfo field = null; for (int i = 0; i < path.Length; i++) { field = type.GetField(path[i], BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.FlattenHierarchy | BindingFlags.Instance); type = field.FieldType; //    : .fieldName //    : .fieldName.Array.data[0] int next = i + 1; if (next < path.Length && path[next] == "Array") { i += 2; if (type.IsArray) { type = type.GetElementType(); } else { type = type.GetGenericArguments()[0]; } } } return field.GetCustomAttributes(typeof(T), false) .Cast<T>() .ToArray(); } 

In a large database, a long line containing many fields may look too "even", that is, the problem "there is nothing to catch on." I was faced with the task of providing a mechanism for highlighting particularly important fields in a line.
In accordance with the policy of the party, the selection of the field will produce an attribute [Highlight] .

The implementation is very simple:

• using the same tool as in the case of the hint, we find the [Highlight] attribute on the field;
• Before drawing the field, call EditorGUI.DrawRect(rect, color); and tint the rectangle with the desired color.

Problem: as a result of the known Unity bug (which is marked Won't fix ), the backlight appears and disappears.

Solution: described here . It looks easy. Interestingly, for what reason did Unity developers refuse to repair it?

The main feature of OneLine is that it should work out of the box: add one attribute and everything is drawn in one line. But life always suits us all sorts of pod. And one of them: decorators. These attributes are [Header] , [Space] (and any others that you can write yourself, extending DecoratorDrawer). It turned out that with the usual call of `EditorGUI.PropertyField (rect, property, content) all decorators are also drawn.

Problem:

Solution: At first I tried to find a workaround and even asked for Unity Answers , but with no result. Then I rummaged in UnityEditor.dll decompiled source code ( here ), and got the following solution:

 typeof(EditorGUI) .GetMethod("DefaultPropertyField", BindingFlags.NonPublic | BindingFlags.Static) .Invoke(null, new object[]{rect, property, GUIContent.none});