mirror of
https://github.com/DCFApixels/DragonECS-Unity.git
synced 2025-09-18 01:54:35 +08:00
598 lines
25 KiB
C#
598 lines
25 KiB
C#
#if UNITY_EDITOR
|
|
using DCFApixels.DragonECS.Unity.Internal;
|
|
using System;
|
|
using System.Reflection;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityObject = UnityEngine.Object;
|
|
using UnityComponent = UnityEngine.Component;
|
|
|
|
namespace DCFApixels.DragonECS.Unity.Editors
|
|
{
|
|
internal static class EcsGUI
|
|
{
|
|
#region Scores
|
|
public struct LabelWidthScore : IDisposable
|
|
{
|
|
private readonly float _value;
|
|
public LabelWidthScore(float value)
|
|
{
|
|
_value = EditorGUIUtility.labelWidth;
|
|
EditorGUIUtility.labelWidth = value;
|
|
}
|
|
public void Dispose()
|
|
{
|
|
EditorGUIUtility.labelWidth = _value;
|
|
}
|
|
}
|
|
public struct ColorScope : IDisposable
|
|
{
|
|
private readonly Color _value;
|
|
public ColorScope(float r, float g, float b, float a = 1f) : this(new Color(r, g, b, a)) { }
|
|
public ColorScope(Color value)
|
|
{
|
|
_value = GUI.color;
|
|
GUI.color = value;
|
|
}
|
|
public void Dispose()
|
|
{
|
|
GUI.color = _value;
|
|
}
|
|
}
|
|
public struct ContentColorScope : IDisposable
|
|
{
|
|
private readonly Color _value;
|
|
public ContentColorScope(float r, float g, float b, float a = 1f) : this(new Color(r, g, b, a)) { }
|
|
public ContentColorScope(Color value)
|
|
{
|
|
_value = GUI.contentColor;
|
|
GUI.contentColor = value;
|
|
}
|
|
public void Dispose()
|
|
{
|
|
GUI.contentColor = _value;
|
|
}
|
|
}
|
|
private static ContentColorScope SetContentColor(Color value) => new ContentColorScope(value);
|
|
private static ContentColorScope SetContentColor(float r, float g, float b, float a = 1f) => new ContentColorScope(r, g, b, a);
|
|
private static ColorScope SetColor(Color value) => new ColorScope(value);
|
|
private static ColorScope SetColor(float r, float g, float b, float a = 1f) => new ColorScope(r, g, b, a);
|
|
private static EditorGUI.DisabledScope Enable => new EditorGUI.DisabledScope(false);
|
|
private static EditorGUI.DisabledScope Disable => new EditorGUI.DisabledScope(true);
|
|
private static EditorGUI.DisabledScope SetEnable(bool value) => new EditorGUI.DisabledScope(!value);
|
|
#endregion
|
|
|
|
private static readonly BindingFlags fieldFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
|
|
|
|
internal readonly static Color GrayColor = new Color32(100, 100, 100, 255);
|
|
internal readonly static Color GreenColor = new Color32(75, 255, 0, 255);
|
|
internal readonly static Color RedColor = new Color32(255, 0, 75, 255);
|
|
|
|
private static readonly Rect RemoveButtonRect = new Rect(0f, 0f, 19f, 19f);
|
|
private static readonly Rect TooltipIconRect = new Rect(0f, 0f, 19f, 19f);
|
|
|
|
public static float EntityBarHeight => EditorGUIUtility.singleLineHeight + 3f;
|
|
|
|
#region Properties
|
|
private static ComponentColorMode AutoColorMode
|
|
{
|
|
get { return SettingsPrefs.instance.ComponentColorMode; }
|
|
set { SettingsPrefs.instance.ComponentColorMode = value; }
|
|
}
|
|
private static bool IsShowHidden
|
|
{
|
|
get { return SettingsPrefs.instance.IsShowHidden; }
|
|
set { SettingsPrefs.instance.IsShowHidden = value; }
|
|
}
|
|
private static bool IsShowRuntimeComponents
|
|
{
|
|
get { return SettingsPrefs.instance.IsShowRuntimeComponents; }
|
|
set { SettingsPrefs.instance.IsShowRuntimeComponents = value; }
|
|
}
|
|
#endregion
|
|
|
|
#region enums
|
|
public enum AddClearComponentButton : byte
|
|
{
|
|
None = 0,
|
|
AddComponent,
|
|
Clear,
|
|
}
|
|
[Flags]
|
|
public enum EntityStatus
|
|
{
|
|
NotAlive = 0,
|
|
Alive = 1 << 0,
|
|
Undefined = 1 << 1,
|
|
}
|
|
#endregion
|
|
|
|
#region HitTest
|
|
internal static bool HitTest(Rect rect)
|
|
{
|
|
return HitTest(rect, Event.current.mousePosition);
|
|
}
|
|
internal static bool HitTest(Rect rect, Event evt)
|
|
{
|
|
return HitTest(rect, evt.mousePosition);
|
|
}
|
|
internal static bool HitTest(Rect rect, Vector2 point)
|
|
{
|
|
int offset = 0;
|
|
return HitTest(rect, point, offset);
|
|
}
|
|
internal static bool HitTest(Rect rect, Vector2 point, int offset)
|
|
{
|
|
return point.x >= rect.xMin - (float)offset && point.x < rect.xMax + (float)offset && point.y >= rect.yMin - (float)offset && point.y < rect.yMax + (float)offset;
|
|
}
|
|
#endregion
|
|
|
|
#region small elems
|
|
public static void DrawIcon(Rect position, Texture icon, float iconPadding, string description)
|
|
{
|
|
using (SetColor(GUI.enabled ? GUI.color : GUI.color * new Color(1f, 1f, 1f, 0.4f)))
|
|
{
|
|
GUI.Label(position, UnityEditorUtility.GetLabel(string.Empty, description));
|
|
GUI.DrawTexture(RectUtility.AddPadding(position, iconPadding), icon);
|
|
}
|
|
}
|
|
public static (bool, bool) IconButtonGeneric(Rect position)
|
|
{
|
|
Color dc = GUI.color;
|
|
GUI.color = Color.clear; //Хак чтобы сделать реакцию от курсора мыши без лага
|
|
bool result = GUI.Button(position, "", EditorStyles.miniButtonMid);
|
|
GUI.color = dc;
|
|
|
|
var current = Event.current;
|
|
return (GUI.enabled && HitTest(position, current), result);
|
|
}
|
|
public static bool IconButton(Rect position, Texture icon, float iconPadding, string description)
|
|
{
|
|
bool result = GUI.Button(position, UnityEditorUtility.GetLabel(string.Empty));
|
|
DrawIcon(position, icon, iconPadding, description);
|
|
return result;
|
|
}
|
|
public static void DescriptionIcon(Rect position, string description)
|
|
{
|
|
using (new ColorScope(new Color(1f, 1f, 1f, 0.8f)))
|
|
{
|
|
DrawIcon(position, Icons.Instance.HelpIcon, 0, description);
|
|
}
|
|
}
|
|
public static bool CloseButton(Rect position)
|
|
{
|
|
using (new ColorScope(new Color(1f, 1f, 1f, 0.8f)))
|
|
{
|
|
var (hover, click) = IconButtonGeneric(position);
|
|
if (hover)
|
|
{
|
|
DrawIcon(position, Icons.Instance.CloseIconOn, -4f, null);
|
|
}
|
|
else
|
|
{
|
|
DrawIcon(position, Icons.Instance.CloseIcon, 0, null);
|
|
}
|
|
return click;
|
|
}
|
|
}
|
|
public static bool AutosetCascadeButton(Rect position)
|
|
{
|
|
return IconButton(position, Icons.Instance.AutosetCascadeIcon, 0f, "Autoset Cascade");
|
|
}
|
|
public static bool AutosetButton(Rect position)
|
|
{
|
|
return IconButton(position, Icons.Instance.AuotsetIcon, 1f, "Autoset");
|
|
}
|
|
public static bool UnlinkButton(Rect position)
|
|
{
|
|
return IconButton(position, Icons.Instance.UnlinkIcon, 1f, "Unlink Entity");
|
|
}
|
|
public static bool DelEntityButton(Rect position)
|
|
{
|
|
return IconButton(position, Icons.Instance.CloseIcon, 0f, "Delete Entity");
|
|
}
|
|
#endregion
|
|
|
|
#region entity bar
|
|
public static void EntityBarForAlive(Rect position, EntityStatus status, int id, short gen, short world)
|
|
{
|
|
EntityBar(position, status != EntityStatus.Alive, status, id, gen, world);
|
|
}
|
|
public static void EntityBar(Rect position, int id, short gen, short world)
|
|
{
|
|
EntityBar_Internal(position, false, id, gen, world);
|
|
}
|
|
public static void EntityBar(Rect position)
|
|
{
|
|
EntityBar_Internal(position, true);
|
|
}
|
|
public static void EntityBar(Rect position, bool isPlaceholder, EntityStatus status, int id = 0, short gen = 0, short world = 0)
|
|
{
|
|
using (new LabelWidthScore(0f))
|
|
{
|
|
var (entityInfoRect, statusRect) = RectUtility.VerticalSliceBottom(position, 3f);
|
|
|
|
Color statusColor;
|
|
switch (status)
|
|
{
|
|
case EntityStatus.NotAlive:
|
|
statusColor = EcsGUI.RedColor;
|
|
break;
|
|
case EntityStatus.Alive:
|
|
statusColor = EcsGUI.GreenColor;
|
|
break;
|
|
default:
|
|
statusColor = new Color32(200, 200, 200, 255);
|
|
break;
|
|
}
|
|
|
|
statusColor.a = 0.6f;
|
|
EditorGUI.DrawRect(statusRect, statusColor);
|
|
|
|
EntityBar_Internal(entityInfoRect, isPlaceholder, id, gen, world);
|
|
}
|
|
}
|
|
private static void EntityBar_Internal(Rect position, bool isPlaceHolder, int id = 0, short gen = 0, short world = 0)
|
|
{
|
|
using (new LabelWidthScore(0f))
|
|
{
|
|
Color w = Color.gray;
|
|
w.a = 0.6f;
|
|
Color b = Color.black;
|
|
b.a = 0.55f;
|
|
EditorGUI.DrawRect(position, w);
|
|
|
|
var (idRect, genWorldRect) = RectUtility.HorizontalSliceLerp(position, 0.4f);
|
|
var (genRect, worldRect) = RectUtility.HorizontalSliceLerp(genWorldRect, 0.5f);
|
|
|
|
idRect = RectUtility.AddPadding(idRect, 2, 1, 0, 0);
|
|
genRect = RectUtility.AddPadding(genRect, 1, 1, 0, 0);
|
|
worldRect = RectUtility.AddPadding(worldRect, 1, 2, 0, 0);
|
|
EditorGUI.DrawRect(idRect, b);
|
|
EditorGUI.DrawRect(genRect, b);
|
|
EditorGUI.DrawRect(worldRect, b);
|
|
|
|
GUIStyle style = UnityEditorUtility.GetInputFieldCenterAnhor();
|
|
|
|
if (isPlaceHolder)
|
|
{
|
|
using (new EditorGUI.DisabledScope(true))
|
|
{
|
|
GUI.Label(idRect, "Entity ID", style);
|
|
GUI.Label(genRect, "Generation", style);
|
|
GUI.Label(worldRect, "World ID", style);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUI.IntField(idRect, id, style);
|
|
EditorGUI.IntField(genRect, gen, style);
|
|
EditorGUI.IntField(worldRect, world, style);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
internal static int GetChildPropertiesCount(SerializedProperty property, Type type, out bool isEmpty)
|
|
{
|
|
int result = GetChildPropertiesCount(property);
|
|
isEmpty = result <= 0 && type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length <= 0;
|
|
return result;
|
|
}
|
|
internal static int GetChildPropertiesCount(SerializedProperty property)
|
|
{
|
|
var propsCounter = property.Copy();
|
|
int lastDepth = propsCounter.depth;
|
|
bool next = propsCounter.Next(true) && lastDepth < propsCounter.depth;
|
|
int result = next ? -1 : 0;
|
|
while (next)
|
|
{
|
|
result++;
|
|
next = propsCounter.Next(false);
|
|
}
|
|
return result;
|
|
}
|
|
public static Color SelectPanelColor(ITypeMeta meta, int index, int total)
|
|
{
|
|
var trueMeta = meta.Type.ToMeta();
|
|
if (trueMeta.IsCustomColor || meta.Color != trueMeta.Color)
|
|
{
|
|
return meta.Color.ToUnityColor();
|
|
}
|
|
else
|
|
{
|
|
switch (AutoColorMode)
|
|
{
|
|
case ComponentColorMode.Auto:
|
|
return meta.Color.ToUnityColor().Desaturate(0.48f) / 1.18f; //.Desaturate(0.48f) / 1.18f;
|
|
case ComponentColorMode.Rainbow:
|
|
int localTotal = Mathf.Max(total, EscEditorConsts.AUTO_COLOR_RAINBOW_MIN_RANGE);
|
|
Color hsv = Color.HSVToRGB(1f / localTotal * (index % localTotal), 1, 1);
|
|
return hsv.Desaturate(0.48f) / 1.18f;
|
|
default:
|
|
return index % 2 == 0 ? new Color(0.40f, 0.40f, 0.40f) : new Color(0.54f, 0.54f, 0.54f);
|
|
}
|
|
}
|
|
}
|
|
public static bool AddComponentButtons(Rect position)
|
|
{
|
|
position = RectUtility.AddPadding(position, 20f, 20f, 12f, 2f);
|
|
return GUI.Button(position, "Add Component");
|
|
}
|
|
public static AddClearComponentButton AddClearComponentButtons(Rect position)
|
|
{
|
|
position = RectUtility.AddPadding(position, 20f, 20f, 12f, 2f);
|
|
var (left, right) = RectUtility.HorizontalSliceLerp(position, 0.75f);
|
|
|
|
if (GUI.Button(left, "Add Component"))
|
|
{
|
|
return AddClearComponentButton.AddComponent;
|
|
}
|
|
if (GUI.Button(right, "Clear"))
|
|
{
|
|
return AddClearComponentButton.Clear;
|
|
}
|
|
return AddClearComponentButton.None;
|
|
}
|
|
|
|
public static void DrawEmptyComponentProperty(Rect position, SerializedProperty property, string name, bool isDisplayEmpty)
|
|
{
|
|
DrawEmptyComponentProperty(position, property, UnityEditorUtility.GetLabel(name), isDisplayEmpty);
|
|
}
|
|
public static void DrawEmptyComponentProperty(Rect position, SerializedProperty property, GUIContent label, bool isDisplayEmpty)
|
|
{
|
|
EditorGUI.LabelField(position, label);
|
|
if (isDisplayEmpty)
|
|
{
|
|
using (SetContentColor(1f, 1f, 1f, 0.4f))
|
|
{
|
|
GUI.Label(position.AddPadding(EditorGUIUtility.labelWidth, 0, 0, 0), "empty");
|
|
}
|
|
}
|
|
EditorGUI.BeginProperty(position, label, property);
|
|
EditorGUI.EndProperty();
|
|
}
|
|
|
|
public static class Layout
|
|
{
|
|
public static void DrawEmptyComponentProperty(SerializedProperty property, string name, bool isDisplayEmpty)
|
|
{
|
|
EcsGUI.DrawEmptyComponentProperty(GUILayoutUtility.GetRect(UnityEditorUtility.GetLabel(name), EditorStyles.label), property, name, isDisplayEmpty);
|
|
}
|
|
public static void DrawEmptyComponentProperty(SerializedProperty property, GUIContent label, bool isDisplayEmpty)
|
|
{
|
|
EcsGUI.DrawEmptyComponentProperty(GUILayoutUtility.GetRect(label, EditorStyles.label), property, label, isDisplayEmpty);
|
|
}
|
|
public static void DrawWorldBaseInfo(EcsWorld world)
|
|
{
|
|
bool isNull = world == null || world.IsDestroyed || world.id == 0;
|
|
int entitesCount = isNull ? 0 : world.Count;
|
|
int capacity = isNull ? 0 : world.Capacity;
|
|
int leakedEntitesCount = isNull ? 0 : world.CountLeakedEntitesDebug();
|
|
EditorGUILayout.IntField("Entities", entitesCount, EditorStyles.boldLabel);
|
|
EditorGUILayout.IntField("Capacity", capacity, EditorStyles.boldLabel);
|
|
Color color = leakedEntitesCount > 0 ? Color.yellow : GUI.contentColor;
|
|
using (new ContentColorScope(color))
|
|
{
|
|
EditorGUILayout.IntField("Leaked Entites", leakedEntitesCount, EditorStyles.boldLabel);
|
|
}
|
|
}
|
|
|
|
#region entity bar
|
|
public static void EntityBarForAlive(EntityStatus status, int id, short gen, short world)
|
|
{
|
|
float width = EditorGUIUtility.currentViewWidth;
|
|
float height = EntityBarHeight;
|
|
EcsGUI.EntityBarForAlive(GUILayoutUtility.GetRect(width, height), status, id, gen, world);
|
|
}
|
|
public static void EntityBar(EntityStatus status, bool isPlaceholder, int id, short gen, short world)
|
|
{
|
|
float width = EditorGUIUtility.currentViewWidth;
|
|
float height = EntityBarHeight;
|
|
EcsGUI.EntityBar(GUILayoutUtility.GetRect(width, height), isPlaceholder, status, id, gen, world);
|
|
}
|
|
public static void EntityBar(int id, short gen, short world)
|
|
{
|
|
float width = EditorGUIUtility.currentViewWidth;
|
|
float height = EntityBarHeight;
|
|
EcsGUI.EntityBar(GUILayoutUtility.GetRect(width, height), id, gen, world);
|
|
}
|
|
public static void EntityBar()
|
|
{
|
|
float width = EditorGUIUtility.currentViewWidth;
|
|
float height = EntityBarHeight;
|
|
EcsGUI.EntityBar(GUILayoutUtility.GetRect(width, height));
|
|
}
|
|
#endregion
|
|
|
|
public static bool AddComponentButtons()
|
|
{
|
|
return EcsGUI.AddComponentButtons(GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth, 36f));
|
|
}
|
|
public static AddClearComponentButton AddClearComponentButtons()
|
|
{
|
|
return EcsGUI.AddClearComponentButtons(GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth, 36f));
|
|
}
|
|
public static void DrawRuntimeComponents(entlong entity, bool isWithFoldout = true)
|
|
{
|
|
if (entity.TryUnpackForUnityEditor(out int entityID, out _, out _, out EcsWorld world))
|
|
{
|
|
DrawRuntimeComponents(entityID, world, isWithFoldout);
|
|
}
|
|
}
|
|
public static void DrawRuntimeComponents(int entityID, EcsWorld world, bool isWithFoldout = true)
|
|
{
|
|
var componentTypeIDs = world.GetComponentTypeIDsFor(entityID);
|
|
|
|
GUILayout.BeginVertical(UnityEditorUtility.GetStyle(Color.black, 0.2f));
|
|
|
|
if (isWithFoldout)
|
|
{
|
|
IsShowRuntimeComponents = EditorGUILayout.BeginFoldoutHeaderGroup(IsShowRuntimeComponents, "RUNTIME COMPONENTS", EditorStyles.foldout);
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
}
|
|
if (isWithFoldout == false || IsShowRuntimeComponents)
|
|
{
|
|
if (AddComponentButtons())
|
|
{
|
|
GenericMenu genericMenu = RuntimeComponentsUtility.GetAddComponentGenericMenu(world);
|
|
RuntimeComponentsUtility.CurrentEntityID = entityID;
|
|
genericMenu.ShowAsContext();
|
|
}
|
|
|
|
GUILayout.Box("", UnityEditorUtility.GetStyle(GUI.color, 0.16f), GUILayout.ExpandWidth(true));
|
|
IsShowHidden = EditorGUI.Toggle(GUILayoutUtility.GetLastRect(), "Show Hidden", IsShowHidden);
|
|
|
|
int i = 0;
|
|
foreach (var componentTypeID in componentTypeIDs)
|
|
{
|
|
var pool = world.GetPoolInstance(componentTypeID);
|
|
{
|
|
DrawRuntimeComponent(componentTypeIDs.Length, i++, entityID, pool);
|
|
}
|
|
}
|
|
}
|
|
GUILayout.EndVertical();
|
|
}
|
|
private static void DrawRuntimeComponent(int total, int index, int entityID, IEcsPool pool)
|
|
{
|
|
var meta = pool.ComponentType.ToMeta();
|
|
if (meta.IsHidden == false || IsShowHidden)
|
|
{
|
|
object data = pool.GetRaw(entityID);
|
|
|
|
Color panelColor = SelectPanelColor(meta, index, total).Desaturate(EscEditorConsts.COMPONENT_DRAWER_DESATURATE);
|
|
|
|
float padding = EditorGUIUtility.standardVerticalSpacing;
|
|
Rect removeButtonRect = GUILayoutUtility.GetLastRect();
|
|
|
|
GUILayout.BeginVertical(UnityEditorUtility.GetStyle(panelColor, EscEditorConsts.COMPONENT_DRAWER_ALPHA));
|
|
EditorGUI.BeginChangeCheck();
|
|
|
|
bool isRemoveComponent = false;
|
|
removeButtonRect.yMin = removeButtonRect.yMax;
|
|
removeButtonRect.yMax += RemoveButtonRect.height;
|
|
removeButtonRect.xMin = removeButtonRect.xMax - RemoveButtonRect.width;
|
|
removeButtonRect.center += Vector2.up * padding * 2f;
|
|
if (CloseButton(removeButtonRect))
|
|
{
|
|
isRemoveComponent = true;
|
|
}
|
|
|
|
Type componentType = pool.ComponentType;
|
|
ExpandMatrix expandMatrix = ExpandMatrix.Take(componentType);
|
|
bool changed = DrawRuntimeData(componentType, UnityEditorUtility.GetLabel(meta.Name), expandMatrix, data, out object resultData);
|
|
if (changed || isRemoveComponent)
|
|
{
|
|
if (isRemoveComponent)
|
|
{
|
|
pool.Del(entityID);
|
|
}
|
|
else
|
|
{
|
|
pool.SetRaw(entityID, resultData);
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(meta.Description.Text) == false)
|
|
{
|
|
Rect tooltipIconRect = TooltipIconRect;
|
|
tooltipIconRect.center = removeButtonRect.center;
|
|
tooltipIconRect.center -= Vector2.right * tooltipIconRect.width;
|
|
DescriptionIcon(tooltipIconRect, meta.Description.Text);
|
|
}
|
|
|
|
GUILayout.EndVertical();
|
|
}
|
|
}
|
|
|
|
private static bool DrawRuntimeData(Type fieldType, GUIContent label, ExpandMatrix expandMatrix, object data, out object outData)
|
|
{
|
|
outData = data;
|
|
Type type = data == null ? typeof(void) : data.GetType();
|
|
|
|
bool isUnityObject = typeof(UnityObject).IsAssignableFrom(fieldType);
|
|
|
|
if (isUnityObject == false && data == null)
|
|
{
|
|
EditorGUILayout.TextField(label, "Null");
|
|
return false;
|
|
}
|
|
ref bool isExpanded = ref expandMatrix.Down();
|
|
bool changed = false;
|
|
outData = data;
|
|
|
|
if (isUnityObject == false && (type.IsGenericType || !type.IsSerializable))
|
|
{
|
|
isExpanded = EditorGUILayout.BeginFoldoutHeaderGroup(isExpanded, label, EditorStyles.foldout);
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
|
|
if (isExpanded)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
foreach (var field in type.GetFields(fieldFlags))
|
|
{
|
|
GUIContent subLabel = UnityEditorUtility.GetLabel(UnityEditorUtility.TransformFieldName(field.Name));
|
|
if (DrawRuntimeData(field.FieldType, subLabel, expandMatrix, field.GetValue(data), out object fieldData))
|
|
{
|
|
field.SetValue(data, fieldData);
|
|
outData = data;
|
|
changed = true;
|
|
}
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isUnityObject)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
var uobj = (UnityObject)data;
|
|
|
|
bool isComponent = typeof(UnityComponent).IsAssignableFrom(fieldType);
|
|
if (isComponent)
|
|
{
|
|
uobj = EditorGUILayout.ObjectField(label, uobj, typeof(UnityObject), true);
|
|
}
|
|
else
|
|
{
|
|
uobj = EditorGUILayout.ObjectField(label, uobj, fieldType, true);
|
|
}
|
|
if (isComponent && uobj is GameObject go)
|
|
{
|
|
uobj = go.GetComponent(fieldType);
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
outData = uobj;
|
|
changed = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
WrapperBase w = RefEditorWrapper.Take(data);
|
|
|
|
w.IsExpanded = isExpanded;
|
|
EditorGUILayout.PropertyField(w.Property, label, true);
|
|
isExpanded = w.IsExpanded;
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
w.SO.ApplyModifiedProperties();
|
|
outData = w.Data;
|
|
changed = true;
|
|
}
|
|
w.Release();
|
|
}
|
|
}
|
|
|
|
expandMatrix.Up();
|
|
return changed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|