public void SetPolymorphicElementDrawCallback(StratusOdinSerializedProperty serializedProperty)
{
this.drawElementCallback =
(Rect rect, int index, bool isActive, bool isFocused) =>
{
if (!serializedProperty.isExpanded)
{
//EditorGUI.LabelField(rect, elementType.Name, elementLabelStyle);
//GUI.enabled = index == count;
return;
}
// Get the drawer for the element type
var element = serializedProperty.GetArrayElementAtIndex(index);
Type elementType = element.GetType();
SerializedSystemObject.ObjectDrawer drawer = SerializedSystemObject.GetObjectDrawer(elementType);
// Draw the element
Rect position = new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight);
if (drawElementTypeLabel)
{
EditorGUI.LabelField(position, elementType.Name, elementLabelStyle);
position.y += StratusEditorUtility.lineHeight;
}
drawer.DrawEditorGUI(position, element);
};
}
//------------------------------------------------------------------------/
// Messages
//------------------------------------------------------------------------/
protected override void OnSelectionChanged()
{
base.OnSelectionChanged();
eventObject = (Stratus.StratusEvent)Utilities.Reflection.Instantiate(selectedClass);
serializedEvent = new SerializedSystemObject(selectedClass, eventObject);
//serializedEvent.Deserialize(eventDataProperty);
}
public StratusOdinSerializedProperty(FieldInfo field, object target)
{
this.field = field;
this.type = this.field.FieldType;
this.propertyType = SerializedSystemObject.DeducePropertyType(this.field);
this.displayName = ObjectNames.NicifyVariableName(this.field.Name);
this.target = target;
// Enum
if (this.propertyType == SerializedPropertyType.Enum)
{
this.enumDisplayNames = StratusSearchableEnum.GetEnumDisplayNames(this.type);
}
// Array
this.isArray = typeof(IList).IsAssignableFrom(this.type);
if (this.isArray)
{
this.list = this.field.GetValue(target) as IList;
this.listElementType = Utilities.Reflection.GetIndexedType(list);
}
// Set the drawer
this.drawer = SerializedSystemObject.GetObjectDrawer(this.isArray ? this.listElementType : this.type);
}
void UpdateEventObject()
{
if (!triggerable.hasType)
{
return;
}
eventObject = (Stratus.Event)Utilities.Reflection.Instantiate(type);
serializedEvent = new SerializedSystemObject(type, eventObject);
serializedEvent.Deserialize(eventDataProperty);
}
//------------------------------------------------------------------------/
// Methods
//------------------------------------------------------------------------/
/// <summary>
/// Draws a list of elements deriving from a base class
/// </summary>
/// <returns>True if the height of the list changed, which signals a repaint event</returns>
public static bool DrawPolymorphicList <T>(List <T> list, string title, bool useTypeLabel = true)
{
// We need to remember this list since the height is variable depending on the
// amount of fields being drawn
int hashCode = list.GetHashCode();
if (!abstractListHeights.ContainsKey(hashCode))
{
abstractListHeights.Add(hashCode, 0);
}
IntegerRef maxCount = 0;
ReorderableListGUI.Title(title);
ReorderableListGUI.ListField(list, (Rect position, T value) =>
{
// Get the drawer
Type type = value.GetType();
SerializedSystemObject.ObjectDrawer drawer = SerializedSystemObject.GetObjectDrawer(type);
// We draw one line at a time
position.height = lineHeight;
// Calculate height for this type
int count = drawer.fieldCount;
if (useTypeLabel)
{
EditorGUI.LabelField(position, type.Name, EditorStyles.centeredGreyMiniLabel);
position.y += lineHeight;
count++;
}
if (count > maxCount)
{
maxCount = count;
}
// Draw
drawer.DrawEditorGUI(position, value);
return(value);
}, abstractListHeights[hashCode], ReorderableListFlags.HideAddButton);
float currentHeight = maxCount * lineHeight;
if (abstractListHeights[hashCode] != currentHeight)
{
abstractListHeights[hashCode] = currentHeight;
return(true);
}
return(false);
}
//------------------------------------------------------------------------/
// CTOR
//------------------------------------------------------------------------/
public FieldDrawer(FieldInfo field)
{
this.field = field;
this.type = this.field.FieldType;
this.name = ObjectNames.NicifyVariableName(field.Name);
this.attributesByName.AddRange(this.field.GetCustomAttributes(attributeType), (Attribute attribute) => attribute.GetType());
this.propertyType = SerializedSystemObject.DeducePropertyType(field);
this.isPrimitive = OdinSerializer.FormatterUtilities.IsPrimitiveType(this.type);
this.isArray = typeof(IList).IsAssignableFrom(this.type);
// Drawable unless its meant to be hidden
this.isDrawable = !this.attributesByName.ContainsKey(hideInInspectorAttribute);
// All currently fields are eventually of a single line
this.height = StratusEditorUtility.lineHeight;
}
public void SetPolymorphicElementHeightCallback(StratusOdinSerializedProperty serializedProperty)
{
elementHeightCallback = (int indexer) =>
{
if (!serializedProperty.isExpanded)
{
return(0);
//return SerializedSystemObject.ObjectDrawer.lineHeight;
}
else
{
SerializedSystemObject.ObjectDrawer drawer = SerializedSystemObject.GetObjectDrawer(serializedProperty.GetArrayElementAtIndex(indexer));
float height = drawer.height;
// We add an additional line of height since we are drawing a label for polymorphic list
if (drawElementTypeLabel)
{
height += SerializedSystemObject.DefaultObjectDrawer.lineHeight;
}
return(height);
}
};
}
/// <summary>
/// Draws a list of elements deriving from a base class
/// </summary>
/// <returns>True if the height of the list changed, which signals a repaint event</returns>
public static bool DrawPolymorphicList(FieldInfo field, object target, string title, bool useTypeLabel = true)
{
// We need to remember this list since the height is variable depending on the
// amount of fields being drawn
var fieldValue = field.GetValue(target);
IList list = fieldValue as IList;
//EditorGUILayout.BeginVertical(ReorderableListStyles.Container);
// Draw the header
EditorGUILayout.BeginHorizontal(ReorderableListStyles.Title);
EditorGUILayout.PrefixLabel(title);
if (GUILayout.Button("Add", polymorphicListLayoutOptions))
{
Type baseType = Utilities.Reflection.GetIndexedType(list); // list.GetType().GetElementType();
var menu = new GenericMenu();
string[] typeNames = Utilities.Reflection.GetSubclassNames(baseType);
menu.AddItems(typeNames, (int index) =>
{
list.Add(Utilities.Reflection.Instantiate(Utilities.Reflection.GetSubclass(baseType)[index]));
});
menu.ShowAsContext();
}
// Clear
if (GUILayout.Button("Clear", polymorphicListLayoutOptions))
{
list.Clear();
}
EditorGUILayout.EndHorizontal();
if (list.Count == 0)
{
return(false);
}
// Draw the elements
bool changed = false;
EditorGUILayout.BeginVertical(ReorderableListStyles.Container2);
foreach (var element in list)
{
EditorGUILayout.Space();
// Get the drawer for the type
Type elementType = element.GetType();
SerializedSystemObject.ObjectDrawer drawer = SerializedSystemObject.GetObjectDrawer(elementType);
EditorGUILayout.BeginVertical(ReorderableListStyles.Container);
{
EditorGUILayout.LabelField(elementType.Name, EditorStyles.centeredGreyMiniLabel);
//if (!drawer.isDrawable)
// EditorGUILayout.LabelField($"There are no serialized fields for {elementType.Name}");
//else
changed |= drawer.DrawEditorGUILayout(element);
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
//EditorGUILayout.EndVertical();
return(changed);
}
/// <summary>
/// Draws a field using EditorGUILayout based on its members,
/// (without using SerializedProperty)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="field"></param>
/// <returns>True if the field was changed</returns>
public static bool DrawField(FieldInfo field, object target)
{
return(SerializedSystemObject.GetFieldDrawer(field).DrawEditorGUILayout(target));
}
/// <summary>
/// Draws a field using EditorGUILayout based on its members,
/// (without using SerializedProperty)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="field"></param>
/// <returns>True if the field was changed</returns>
public static bool DrawField <T>(T field)
{
Type type = field.GetType();
return(SerializedSystemObject.GetObjectDrawer(type).DrawEditorGUILayout(field));
}
public static void DrawGUI(Rect position, FieldInfo field, object target)
{
SerializedPropertyType propertyType = SerializedSystemObject.DeducePropertyType(field);
string name = ObjectNames.NicifyVariableName(field.Name);
object value = null;
switch (propertyType)
{
case SerializedPropertyType.ObjectReference:
value = EditorGUI.ObjectField(position, name, (UnityEngine.Object)field.GetValue(target), field.FieldType, true);
break;
case SerializedPropertyType.Integer:
value = EditorGUI.IntField(position, field.GetValue <int>(target));
break;
case SerializedPropertyType.Boolean:
value = EditorGUI.Toggle(position, name, field.GetValue <bool>(target));
break;
case SerializedPropertyType.Float:
value = EditorGUI.FloatField(position, field.GetValue <float>(target));
break;
case SerializedPropertyType.String:
value = EditorGUI.TextField(position, name, field.GetValue <string>(target));
break;
case SerializedPropertyType.Color:
value = EditorGUI.ColorField(position, name, field.GetValue <Color>(target));
break;
case SerializedPropertyType.LayerMask:
value = EditorGUI.LayerField(position, name, field.GetValue <LayerMask>(target));
break;
case SerializedPropertyType.Enum:
StratusSearchableEnum.EnumPopup(position, name, field.GetValue <Enum>(target), (Enum selected) => field.SetValue(target, selected));
break;
case SerializedPropertyType.Vector2:
value = EditorGUI.Vector2Field(position, name, field.GetValue <Vector2>(target));
break;
case SerializedPropertyType.Vector3:
value = EditorGUI.Vector3Field(position, name, field.GetValue <Vector3>(target));
break;
case SerializedPropertyType.Vector4:
value = EditorGUI.Vector4Field(position, name, field.GetValue <Vector4>(target));
break;
case SerializedPropertyType.Rect:
value = EditorGUI.RectField(position, name, field.GetValue <Rect>(target));
break;
default:
EditorGUI.LabelField(position, $"No supported drawer for type {field.FieldType.Name}!");
break;
}
}