public void SetUp(BaseNode _nodeViewModel, CommandDispatcher _commandDispatcher, BaseGraphView _graphView)
{
Model = _nodeViewModel;
CommandDispatcher = _commandDispatcher;
Owner = _graphView;
// 绑定
BindingProperties();
InitializePorts();
RefreshPorts();
foreach (var fieldInfo in Model.GetNodeFieldInfos())
{
// 如果不是接口，跳过
if (!PortViews.TryGetValue(fieldInfo.Name, out NodePortView portView))
{
continue;
}
if (portView.direction != Direction.Input)
{
continue;
}
if (portView.orientation != Orientation.Horizontal)
{
continue;
}
var box = new VisualElement {
name = fieldInfo.Name
};
box.AddToClassList("port-input-element");
if (Utility_Attribute.TryGetFieldInfoAttribute(fieldInfo, out ShowAsDrawer showAsDrawer))
{
BindableElement fieldDrawer = UIElementsFactory.CreateField(String.Empty, fieldInfo.FieldType, Model.GetFieldInfoValue(fieldInfo), (newValue) =>
{
IBindableProperty property;
if (!string.IsNullOrEmpty(showAsDrawer.targetBindablePropertyName) && (property = Model.GetBindableProperty(showAsDrawer.targetBindablePropertyName)) != null)
{
property.ValueBoxed = newValue;
Owner.SetDirty();
}
});
if (fieldDrawer != null)
{
box.Add(fieldDrawer);
box.visible = !portView.Model.IsConnected;
portView.onConnected += () => { box.visible = false; };
portView.onDisconnected += () => { box.visible = !portView.connected; };
}
}
else
{
box.visible = false;
box.style.height = portView.style.height;
}
inputContainerElement.Add(box);
}
}
//public void Initialize(BaseGraphView _graphView, IEnumerable<Type> _nodeTypes, NodePort _port, Action<BaseNode> _onNodeCreated)
//{
// graphView = _graphView;
// port = _port;
// nodeTypes = _nodeTypes;
// tree = foreach (var item in GraphProcessorCache.PortCache)
// {
// foreach (var cachedPort in item.Value)
// {
// if (NodePort.IsCompatible(port, cachedPort))
// yield return item.Key;
// }
// }
// onNodeCreated = _onNodeCreated;
//}
private List <SearchTreeEntry> CreateSearchTree()
{
List <SearchTreeEntry> tempTree = new List <SearchTreeEntry>()
{
new SearchTreeGroupEntry(new GUIContent("Create Elements"))
};
foreach (Type type in nodeTypes)
{
if (Utility_Attribute.TryGetTypeAttribute(type, out NodeMenuItemAttribute attribute))
{
if (attribute.showInList)
{
if (attribute.titles.Length > 1)
{
SearchTreeGroupEntry groupTemp = null;
for (int i = 1; i < attribute.titles.Length; i++)
{
SearchTreeGroupEntry group = tempTree.Find(item =>
(item.content.text == attribute.titles[i - 1] && item.level == i)) as
SearchTreeGroupEntry;
if (group == null)
{
group = new SearchTreeGroupEntry(new GUIContent(attribute.titles[i - 1]), i);
int index = groupTemp == null ? 0 : tempTree.IndexOf(groupTemp);
tempTree.Insert(index + 1, group);
}
groupTemp = group;
}
tempTree.Insert(tempTree.IndexOf(groupTemp) + 1,
new SearchTreeEntry(new GUIContent(attribute.titles.Last()))
{
userData = type, level = attribute.titles.Length
});
}
else
{
tempTree.Add(new SearchTreeEntry(new GUIContent(attribute.titles.Last()))
{
userData = type, level = 1
});
}
}
}
else
{
GUIContent content = new GUIContent(GraphProcessorEditorUtility.GetNodeDisplayName(type));
tempTree.Add(new SearchTreeEntry(content)
{
userData = type, level = 1
});
}
}
return(tempTree);
}
void InitializeSettings()
{
foreach (var fieldInfo in Model.GetNodeFieldInfos())
{
if (Utility_Attribute.TryGetFieldInfoAttribute(fieldInfo, out ShowInSettingAttribute settingAttribute))
{
AddSettingField(fieldInfo);
}
}
}
public override TrackDrawOptions GetTrackOptions(TrackAsset track, Object binding)
{
TrackDrawOptions options = base.GetTrackOptions(track, binding);
if (Utility_Attribute.TryGetTypeAttribute(track.GetType(), out TLTrackMinHeightAttribute attribute))
{
options.minimumHeight = attribute.MinHeight;
}
return(options);
}
public override ClipDrawOptions GetClipOptions(TimelineClip clip)
{
ClipDrawOptions options = base.GetClipOptions(clip);
if (Utility_Attribute.TryGetTypeAttribute(clip.asset.GetType(), out TLClipTooltipAttribute attribute))
{
options.tooltip = attribute.Tooltip;
}
return(options);
}
public static string GetNodeDisplayName(Type _nodeType)
{
if (Utility_Attribute.TryGetTypeAttribute(_nodeType, out NodeMenuItemAttribute attri))
{
if (attri.titles != null && attri.titles.Length != 0)
{
return(attri.titles[attri.titles.Length - 1]);
}
}
return(_nodeType.Name);
}
protected void AddSettingField(FieldInfo _fieldInfo)
{
var label = Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out InspectorNameAttribute inspectorNameAttribute)
? inspectorNameAttribute.displayName : _fieldInfo.Name;
VisualElement fieldDrawer = CreateControlField(_fieldInfo, label);
if (fieldDrawer == null)
{
return;
}
settingsContainer.Add(fieldDrawer);
}
static void BuildCache()
{
ObjectEditorTypeCache = new Dictionary <Type, Type>();
foreach (var type in TypeCache.GetTypesDerivedFrom <ObjectEditor>())
{
if (Utility_Attribute.TryGetTypeAttribute(type, out CustomObjectEditorAttribute att))
{
ObjectEditorTypeCache[att.targetType] = type;
}
}
}
public static object DrawField(FieldInfo _fieldInfo, object _value)
{
GUIContent content = null;
if (Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out TooltipAttribute tooltipAtt))
{
content = EditorGUIExtension.GetGUIContent(ObjectNames.NicifyVariableName(_fieldInfo.Name), tooltipAtt.tooltip);
}
else
{
content = EditorGUIExtension.GetGUIContent(ObjectNames.NicifyVariableName(_fieldInfo.Name));
}
return(DrawField(content, _fieldInfo, _value));
}
public ConversationManager()
{
if (CommandResolverTypeCache == null)
{
CommandResolverTypeCache = new Dictionary <string, Type>();
foreach (var type in Utility_Reflection.GetChildrenTypes <IConversationCommand>())
{
if (Utility_Attribute.TryGetTypeAttribute(type, out CommandNameAttribute attribute))
{
CommandResolverTypeCache[attribute.commandText] = type;
}
}
}
}
public NodePort(FieldInfo _fieldInfo, PortAttribute _portAttribute)
{
fieldName = _fieldInfo.Name;
multiple = _portAttribute.IsMulti;
direction = _portAttribute.Direction;
typeConstraint = _portAttribute.TypeConstraint;
if (Utility_Attribute.TryGetFieldAttribute(_fieldInfo.DeclaringType, _fieldInfo.Name, out PortTypeAttribute typeAttribute))
{
typeQualifiedName = typeAttribute.portType.AssemblyQualifiedName;
}
else
{
typeQualifiedName = _fieldInfo.FieldType.AssemblyQualifiedName;
}
}
private void InitializeToolbox()
{
onIndicatorChanged += (i) => { SceneView.RepaintAll(); };
createTrackIcon = new GUIContent(EditorGUIUtility.FindTexture("CreateAddNew"), "创建轨道");
pingIcon = EditorGUIUtility.IconContent("d_SelectionListItem Icon");
pingIcon.tooltip = "PingAsset";
csIcon = new GUIContent(EditorGUIUtility.FindTexture("cs Script Icon"), "编辑Asset脚本");
selectIcon = EditorGUIUtility.IconContent("Selectable Icon");
selectIcon.tooltip = "选中Asset文件";
if (toolboxTreeViewState == null)
{
toolboxTreeViewState = new TreeViewState();
}
toolBoxTreeView = new ToolboxTreeView(toolboxTreeViewState);
BuildToolboxTreeView(toolBoxTreeView);
toolBoxTreeView.Reload();
List <KeyValuePair <string, Type> > menu = new List <KeyValuePair <string, Type> >();
foreach (Type trackType in TypeCache.GetTypesDerivedFrom(TimelineLiteTrackAssetType))
{
TLTrackAssetMenuItemAttribute attrib;
if (Utility_Attribute.TryGetTypeAttribute(trackType, out attrib))
{
if (!string.IsNullOrEmpty(attrib.defaultTrackName))
{
menu.Add(new KeyValuePair <string, Type>(attrib.defaultTrackName, trackType));
}
else
{
menu.Add(new KeyValuePair <string, Type>(trackType.Name, trackType));
}
}
}
menu = menu.OrderBy(a => a.Key).ToList();
trackTypeMenu = new GenericMenu();
foreach (var kv in menu)
{
trackTypeMenu.AddItem(new GUIContent(kv.Key), false, () =>
{
CreateTrack(kv.Value, kv.Key);
});
}
}
void InitializePorts()
{
foreach (var nodePort in Model.Ports)
{
Direction direction = nodePort.Value.Direction == PortDirection.Input ? Direction.Input : Direction.Output;
Orientation orientation =
Utility_Attribute.TryGetFieldAttribute(Model.GetType(), nodePort.Value.FieldName, out VerticalAttribute vertical) ?
Orientation.Vertical : Orientation.Horizontal;
NodePortView portView = CustomCreatePortView(orientation, direction, nodePort.Value);
if (portView == null)
{
portView = NodePortView.CreatePV(orientation, direction, nodePort.Value);
}
portView.SetUp(nodePort.Value, CommandDispatcher, Owner);
PortViews[nodePort.Key] = portView;
}
}
/// <summary> 根据节点类型返回对应节点视图类型 </summary>
/// <param name="_nodeType"> 节点类型 </param>
/// <returns> 节点视图类型 </returns>
public static Type GetNodeViewType(Type _nodeDataType)
{
if (NODE_VIEW_TYPE_CACHE == null)
{
NODE_VIEW_TYPE_CACHE = new Dictionary <Type, Type>();
foreach (var _nodeViewType in TypeCache.GetTypesWithAttribute <CustomNodeViewAttribute>())
{
if (Utility_Attribute.TryGetTypeAttribute(_nodeViewType, out CustomNodeViewAttribute attri))
{
NODE_VIEW_TYPE_CACHE[attri.nodeType] = _nodeViewType;
}
}
}
if (NODE_VIEW_TYPE_CACHE.TryGetValue(_nodeDataType, out Type nodeViewType))
{
return(nodeViewType);
}
return(null);
}
static void CachePorts(Type _nodeType)
{
List <FieldInfo> fieldInfos = Utility_Reflection.GetFieldInfos(_nodeType);
foreach (var fieldInfo in fieldInfos)
{
// 获取接口特性
if (!Utility_Attribute.TryGetFieldAttribute(_nodeType, fieldInfo.Name, out PortAttribute portAttribute))
{
continue;
}
if (!portCache.ContainsKey(_nodeType))
{
portCache.Add(_nodeType, new List <NodePort>());
}
portCache[_nodeType].Add(new NodePort(fieldInfo, portAttribute));
}
}
public override void InitializeBindableProperties()
{
SetBindableProperty(nameof(Title), new BindableProperty <string>());
SetBindableProperty(nameof(TitleColor), new BindableProperty <Color>(new Color(0.2f, 0.2f, 0.2f, 0.8f)));
SetBindableProperty(nameof(Icon), new BindableProperty <Texture>());
SetBindableProperty(nameof(IconSize), new BindableProperty <Vector2>(new Vector2(20, 20)));
SetBindableProperty(nameof(Tooltip), new BindableProperty <string>());
SetBindableProperty(nameof(Locked), new BindableProperty <bool>(locked, v => locked = v));
SetBindableProperty(nameof(Position), new BindableProperty <Vector2>(position, v => position = v));
SetBindableProperty(nameof(Expanded), new BindableProperty <bool>(true, v => expanded = v));
Type type = GetType();
if (Utility_Attribute.TryGetTypeAttribute(type, out NodeMenuItemAttribute displayName))
{
if (displayName.titles != null && displayName.titles.Length != 0)
{
Title = displayName.titles[displayName.titles.Length - 1];
}
}
else
{
Title = type.Name;
}
if (Utility_Attribute.TryGetTypeAttribute(type, out NodeTitleColorAttribute nodeTitleColor))
{
TitleColor = nodeTitleColor.color;
}
if (Utility_Attribute.TryGetTypeAttribute(type, out NodeIconAttribute iconAttribute))
{
IconSize = new Vector2(iconAttribute.width, iconAttribute.height);
Icon = Resources.Load <Texture2D>(iconAttribute.iconPath);
}
if (Utility_Attribute.TryGetTypeAttribute(type, out NodeTooltipAttribute tooltip))
{
Tooltip = tooltip.Tooltip;
}
}
/// <summary> 根据Graph类型返回对应窗口类型 </summary>
/// <param name="_graphType"> Graph类型 </param>
/// <returns> 窗口类型 </returns>
public static Type GetGraphWindowType(Type _graphType)
{
if (GRAPH_EDITOR_WINDOW_TYPE_CACHE == null)
{
GRAPH_EDITOR_WINDOW_TYPE_CACHE = new Dictionary <Type, Type>();
foreach (var type in TypeCache.GetTypesWithAttribute <CustomGraphWindowAttribute>())
{
if (Utility_Attribute.TryGetTypeAttribute(type, out CustomGraphWindowAttribute attribute))
{
GRAPH_EDITOR_WINDOW_TYPE_CACHE[attribute.graphType] = type;
}
}
}
if (GRAPH_EDITOR_WINDOW_TYPE_CACHE.TryGetValue(_graphType, out Type graphWindowType))
{
return(graphWindowType);
}
return(typeof(BaseGraphWindow));
}
/// <summary> 不是<see cref="private"/>、或者标记了<see cref="SerializeField"/>特性，并且没有标记<see cref="NonSerializedAttribute"/>特性，并且没有标记<see cref="HideInInspector"/>特性。 </summary>
/// <returns> 满足以上条件返回<see cref="true"/> </returns>
public static bool CanDraw(FieldInfo _fieldInfo)
{
return(((!_fieldInfo.IsPrivate && !_fieldInfo.IsFamily) || Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out SerializeField serAtt)) &&
!Utility_Attribute.TryGetTypeAttribute(_fieldInfo.DeclaringType, out NonSerializedAttribute nonAtt) &&
!Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out HideInInspector hideAtt));
}
private static object DrawSingleField(GUIContent _content, FieldInfo _fieldInfo, Type _fieldType, object _value)
{
if (Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out FieldAttribute att) ||
Utility_Attribute.TryGetTypeAttribute(_fieldType, out att))
{
FieldDrawer objectDrawer;
if ((objectDrawer = ObjectDrawerUtility.GetObjectDrawer(att)) != null)
{
objectDrawer.Value = _value;
objectDrawer.FieldInfo = _fieldInfo;
objectDrawer.OnGUI(_content);
return(_value);
}
}
if (_fieldType.Equals(typeof(int)))
{
return(EditorGUILayout.IntField(_content, _value == null ? 0 : (int)_value, EditorStylesExtension.NumberFieldStyle));
}
if (_fieldType.Equals(typeof(float)))
{
return(EditorGUILayout.FloatField(_content, _value == null ? 0 : (float)_value, EditorStylesExtension.NumberFieldStyle));
}
if (_fieldType.Equals(typeof(double)))
{
return(EditorGUILayout.DoubleField(_content, Convert.ToSingle(_value == null ? 0 : (double)_value), EditorStylesExtension.NumberFieldStyle));
}
if (_fieldType.Equals(typeof(long)))
{
return((long)EditorGUILayout.IntField(_content, Convert.ToInt32(_value == null ? 0 : (long)_value), EditorStylesExtension.NumberFieldStyle));
}
if (_fieldType.Equals(typeof(bool)))
{
return(EditorGUILayout.Toggle(_content, _value == null ? false : (bool)_value));
}
if (_fieldType.Equals(typeof(string)))
{
return(EditorGUILayout.TextField(_content, _value == null ? "" : (string)_value, EditorStylesExtension.TextFieldStyle));
}
if (_fieldType.Equals(typeof(byte)))
{
return(Convert.ToByte(EditorGUILayout.IntField(_content, Convert.ToInt32(_value == null ? 0 : (byte)_value))));
}
if (_fieldType.Equals(typeof(Vector2)))
{
return(EditorGUILayout.Vector2Field(_content, _value == null ? Vector2.zero : (Vector2)_value));
}
if (_fieldType.Equals(typeof(Vector2Int)))
{
return(EditorGUILayout.Vector2IntField(_content, _value == null ? Vector2Int.zero : (Vector2Int)_value));
}
if (_fieldType.Equals(typeof(Vector3)))
{
return(EditorGUILayout.Vector3Field(_content, _value == null ? Vector3.zero : (Vector3)_value));
}
if (_fieldType.Equals(typeof(Vector3Int)))
{
return(EditorGUILayout.Vector3IntField(_content, _value == null ? Vector3Int.zero : (Vector3Int)_value));
}
if (_fieldType.Equals(typeof(Vector4)))
{
return(EditorGUILayout.Vector4Field(_content.text, _value == null ? Vector4.zero : (Vector4)_value));
}
if (_fieldType.Equals(typeof(Quaternion)))
{
Quaternion quaternion = _value == null ? Quaternion.identity : (Quaternion)_value;
Vector4 vector = Vector4.zero;
vector.Set(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
vector = EditorGUILayout.Vector4Field(_content.text, vector);
quaternion.Set(vector.x, vector.y, vector.z, vector.w);
return(quaternion);
}
if (_fieldType.Equals(typeof(Color)))
{
return(EditorGUILayout.ColorField(_content, _value == null ? Color.black : (Color)_value));
}
if (_fieldType.Equals(typeof(Rect)))
{
return(EditorGUILayout.RectField(_content, _value == null ? Rect.zero : (Rect)_value));
}
if (_fieldType.Equals(typeof(Gradient)))
{
return(EditorGUILayout.GradientField(_content, _value == null ? new Gradient() : (Gradient)_value));
}
if (_fieldType.Equals(typeof(Matrix4x4)))
{
GUILayout.BeginVertical(new GUILayoutOption[0]);
if (EditorGUILayoutExtension.DrawFoldout(_content.text.GetHashCode(), _content))
{
EditorGUI.indentLevel++;
Matrix4x4 matrix4x = _value == null ? Matrix4x4.identity : (Matrix4x4)_value;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
EditorGUI.BeginChangeCheck();
matrix4x[i, j] = EditorGUILayout.FloatField("E" + i.ToString() + j.ToString(), matrix4x[i, j]);
if (EditorGUI.EndChangeCheck())
{
GUI.changed = true;
}
}
}
_value = matrix4x;
EditorGUI.indentLevel--;
}
GUILayout.EndVertical();
return(_value);
}
if (_fieldType.Equals(typeof(AnimationCurve)))
{
if (_value == null)
{
_value = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
GUI.changed = true;
}
return(EditorGUILayout.CurveField(_content, (AnimationCurve)_value));
}
if (_fieldType.Equals(typeof(LayerMask)))
{
return(EditorGUILayoutExtension.DrawLayerMask(_content, (LayerMask)_value));
}
if (typeof(UnityObject).IsAssignableFrom(_fieldType))
{
return(EditorGUILayout.ObjectField(_content, (UnityObject)_value, _fieldType, true));
}
if (_fieldType.IsEnum)
{
return(EditorGUILayout.EnumPopup(_content, (Enum)_value));
}
if (_fieldType.IsClass || (_fieldType.IsValueType && !_fieldType.IsPrimitive))
{
if (typeof(Delegate).IsAssignableFrom(_fieldType))
{
return(null);
}
if (typeof(object).IsAssignableFrom(_fieldType) && _value == null)
{
return(null);
}
int hashCode = _value.GetHashCode();
if (EditorGUILayoutExtension.drawnObjects.Contains(hashCode))
{
return(null);
}
try
{
EditorGUILayoutExtension.drawnObjects.Add(hashCode);
GUILayout.BeginVertical();
if (_value == null)
{
if (_fieldType.IsGenericType && _fieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
_fieldType = Nullable.GetUnderlyingType(_fieldType);
}
_value = Activator.CreateInstance(_fieldType, true);
}
if (EditorGUILayoutExtension.DrawFoldout(hashCode, _content))
{
EditorGUI.indentLevel++;
_value = EditorGUILayoutExtension.DrawFields(_value);
EditorGUI.indentLevel--;
}
EditorGUILayoutExtension.drawnObjects.Remove(hashCode);
GUILayout.EndVertical();
return(_value);
}
catch (Exception)
{
GUILayout.EndVertical();
EditorGUILayoutExtension.drawnObjects.Remove(hashCode);
return(null);
}
}
EditorGUILayout.LabelField("Unsupported Type: " + _fieldType);
return(null);
}
private static object DrawArrayField(GUIContent _content, FieldInfo _fieldInfo, Type _fieldType, object _value)
{
Type elementType;
if (_fieldType.IsArray)
{
elementType = _fieldType.GetElementType();
}
else
{
Type type2 = _fieldType;
while (!type2.IsGenericType)
{
type2 = type2.BaseType;
}
elementType = type2.GetGenericArguments()[0];
}
IList list;
if (_value == null)
{
if (_fieldType.IsGenericType || _fieldType.IsArray)
{
_value = list = (Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
elementType
}), true) as IList);
}
else
{
_value = list = (Activator.CreateInstance(_fieldType, true) as IList);
}
if (_fieldType.IsArray)
{
Array array = Array.CreateInstance(elementType, list.Count);
list.CopyTo(array, 0);
_value = list = array;
}
GUI.changed = true;
}
else
{
list = (IList)_value;
}
if (EditorGUILayoutExtension.DrawFoldout(_value.GetHashCode(), _content))
{
EditorGUI.indentLevel++;
bool flag = _value.GetHashCode() == EditorGUILayoutExtension.editingFieldHash;
int count = (!flag) ? list.Count : EditorGUILayoutExtension.savedArraySize;
int newCount = EditorGUILayout.IntField(EditorGUIExtension.GetGUIContent("Size"), count);
if (flag && EditorGUILayoutExtension.editingArray && (GUIUtility.keyboardControl != EditorGUILayoutExtension.currentKeyboardControl ||
(Event.current.keyCode == KeyCode.KeypadEnter || Event.current.keyCode == KeyCode.Return)))
{
if (newCount != list.Count)
{
int currentCount = list.Count;
if (newCount > currentCount)
{
if (_fieldType.IsArray)
{
Array array2 = Array.CreateInstance(elementType, newCount);
int num3 = -1;
for (int i = 0; i < newCount; i++)
{
if (i < list.Count)
{
num3 = i;
}
if (num3 == -1)
{
break;
}
}
}
else
{
Type type = list.Count > 0 ? list[list.Count - 1].GetType() : elementType;
if (!typeof(UnityObject).IsAssignableFrom(type))
{
for (int i = currentCount; i < newCount; i++)
{
list.Add(Activator.CreateInstance(type, true));
}
}
else
{
for (int i = currentCount; i < newCount; i++)
{
list.Add(null);
}
}
}
}
else
{
if (!_fieldType.IsArray)
{
while (list.Count > newCount)
{
list.RemoveAt(list.Count - 1);
}
}
}
}
EditorGUILayoutExtension.editingArray = false;
EditorGUILayoutExtension.savedArraySize = -1;
EditorGUILayoutExtension.editingFieldHash = -1;
GUI.changed = true;
}
else if (newCount != count)
{
if (!EditorGUILayoutExtension.editingArray)
{
EditorGUILayoutExtension.currentKeyboardControl = GUIUtility.keyboardControl;
EditorGUILayoutExtension.editingArray = true;
EditorGUILayoutExtension.editingFieldHash = _value.GetHashCode();
}
EditorGUILayoutExtension.savedArraySize = newCount;
}
if (_fieldInfo != null &&
(Utility_Attribute.TryGetFieldInfoAttribute(_fieldInfo, out FieldAttribute att) ||
Utility_Attribute.TryGetTypeAttribute(elementType, out att)))
{
for (int k = 0; k < list.Count; k++)
{
FieldDrawer objectDrawer;
if ((objectDrawer = ObjectDrawerUtility.GetObjectDrawer(att)) != null)
{
_content.text = "Element " + k;
objectDrawer.Value = list[k];
objectDrawer.OnGUI(_content);
if (objectDrawer.Value != list[k])
{
list[k] = objectDrawer.Value;
GUI.changed = true;
}
}
}
}
else
{
for (int k = 0; k < list.Count; k++)
{
_content.text = "Element " + k;
list[k] = EditorGUILayoutExtension.DrawField(_content, elementType, list[k]);
}
}
EditorGUI.indentLevel--;
}
return(list);
}
