private static void Init()
{
if (inspectorFieldParsers != null && inspectorTypeParsers != null)
{
return;
}
inspectorFieldParsers = new Dictionary <string, FieldInspectorParser>();
List <Type> parserTypes = AssemblyTool.FindTypesInCurrentDomainWhereExtend <FieldInspectorParser>();
foreach (var parserType in parserTypes)
{
var obj = ReflecTool.Instantiate(parserType);
Debug.Log(parserType.ToString() + " " + (obj == null));
FieldInspectorParser fieldInspectorParser = obj as FieldInspectorParser;
Debug.Log(parserType.ToString() + " " + (fieldInspectorParser == null));
inspectorFieldParsers.Add(fieldInspectorParser.Name, fieldInspectorParser);
}
inspectorTypeParsers = new Dictionary <Type, DefaultTypeInspector>();
parserTypes = AssemblyTool.FindTypesInCurrentDomainWhereExtend <DefaultTypeInspector>();
foreach (var parserType in parserTypes)
{
DefaultTypeInspector defaultTypeInspector = ReflecTool.Instantiate(parserType) as DefaultTypeInspector;
inspectorTypeParsers.Add(defaultTypeInspector.GetInspectorType(), defaultTypeInspector);
}
}
protected virtual List <ItemDetailPartInspector <T> > CreatePartInspector()
{
List <ItemDetailPartInspector <T> > partInspectors = new List <ItemDetailPartInspector <T> >();
List <Type> partInspectorTypeSet = AssemblyTool.FindTypesInCurrentDomainWhereExtend <ItemDetailPartInspector <T> >();
foreach (var partInspector in partInspectorTypeSet)
{
ItemDetailPartInspector <T> itemDetailPartInspector = ReflecTool.Instantiate(partInspector) as ItemDetailPartInspector <T>;
partInspectors.Add(itemDetailPartInspector);
}
return(partInspectors);
}
static FieldDrawerUtil()
{
fieldDrawers = new Dictionary <Type, FieldDrawer>();
List <Type> drawers = AssemblyTool.FindTypesInCurrentDomainWhereAttributeIs <CustomFieldDrawer>();
foreach (var item in drawers)
{
if (item.IsSubclassOf(typeof(FieldDrawer)))
{
CustomFieldDrawer att = item.GetAttribute <CustomFieldDrawer>();
fieldDrawers[att.m_type] = ReflecTool.Instantiate(item) as FieldDrawer;
}
}
}
private void Init()
{
if (inited == null)
{
List <Type> partInspectors = AssemblyTool.FindTypesInCurrentDomainWhereExtend <ItemDetailPartInspector <T> >();
foreach (var partInspector in partInspectors)
{
ItemDetailPartInspector <T> itemDetailPartInspector = ReflecTool.Instantiate(partInspector) as ItemDetailPartInspector <T>;
itemDetailPartInspectors.Add(itemDetailPartInspector);
}
itemDetailPartInspectors.Sort(
(l, r) =>
{ return(l.Order - r.Order); });
OnInit();
inited = new object();
}
}
public void Draw(
List <T> datas,
Func <T, string> getDataName,
Action <T> onSelect = null,
Action <T> onAdd = null)
{
if (datas == null)
{
return;
}
GUILayout.BeginVertical();
for (int i = 0; i < datas.Count; i++)
{
GUILayout.BeginHorizontal();
var data = datas[i];
var dataName = getDataName(data);
if (GUILayout.Button(dataName))
{
if (onSelect != null)
{
onSelect(data);
}
}
if (GUILayout.Button("X", GUILayout.Width(20)))
{
datas.RemoveAt(i);
i--;
}
GUILayout.EndHorizontal();
}
if (GUILayout.Button("Add"))
{
var instantiate = ReflecTool.Instantiate <T>();
if (onAdd != null)
{
onAdd(instantiate);
}
datas.Add(instantiate);
}
GUILayout.EndVertical();
}
public PluginImporterGroup Use(Type importType)
{
if (!this.importers.ContainsKey(importType))
{
this.importers.Add(importType, null);
var pluginImporter = ReflecTool.Instantiate(importType) as PluginImporter;
//引用导入插件的依赖插件
foreach (var dependency in pluginImporter.Dependencies)
{
this.Use(dependency);
}
this.importers[importType] = pluginImporter;
this.importerList.Add(pluginImporter);
}
return(this);
}
public void RefreshTreeData(SeanLibManager drawer)
{
var editorTypes = AssemblyTool.FindTypesInCurrentDomainWhereAttributeIs <CustomSeanLibEditor>();
editorTypes.RemoveAll(e => ReflecTool.GetAttribute <CustomSeanLibEditor>(e).IsDoc != isdoc);
editorTypes.Sort((l, r) =>
{
return(ReflecTool.GetAttribute <CustomSeanLibEditor>(l).order - ReflecTool.GetAttribute <CustomSeanLibEditor>(r).order);
});
editors = new List <SeanLibEditor>(editorTypes.Count);
foreach (var item in editorTypes)
{
SeanLibEditor editor = ReflecTool.Instantiate(item) as SeanLibEditor;
//editor.OnEnable(drawer);
editors.Add(editor);
}
Reload();
}
public static T GetLoader <T>(DownLoadAgent config) where T : UrlLoader
{
UrlLoader loader = null;
if (Loaders.TryGetValue(config.GUID, out loader))
{
if (loader is T)
{
return(loader as T);
}
else
{
DebugConsole.Warning("LoaderFactory", "GetLoader", "同一个资源文件被不同的类型请求");
return(null);
}
}
loader = ReflecTool.Instantiate <T>(new Type[] { typeof(DownLoadAgent) }, new object[] { config });
Loaders[config.GUID] = loader;
return(loader as T);
}
public static IList ListEditor(string prefix, IList list, Type listType)
{
if (list == null)
{
list = ReflecTool.Instantiate(listType) as IList;
}
var argType = listType.IsArray ? listType.GetElementType() : listType.GetGenericArguments()[0];
//register foldout
if (!registeredEditorFoldouts.ContainsKey(list))
{
registeredEditorFoldouts[list] = false;
}
GUILayout.BeginVertical();
var foldout = registeredEditorFoldouts[list];
foldout = EditorGUILayout.Foldout(foldout, prefix);
registeredEditorFoldouts[list] = foldout;
if (!foldout)
{
GUILayout.EndVertical();
return(list);
}
if (list.Equals(null))
{
GUILayout.Label("Null List");
GUILayout.EndVertical();
return(list);
}
GUILayout.BeginHorizontal();
GUILayout.Space(20);
GUILayout.BeginVertical();
if (GUILayout.Button("Add Element"))
{
if (listType.IsArray)
{
list = ResizeArray((Array)list, list.Count + 1);
registeredEditorFoldouts[list] = true;
}
else
{
object newElement = null;
if (argType.IsValueType)
{
newElement = Activator.CreateInstance(argType);
}
if (!argType.IsInterface && !argType.IsAbstract && AssemblyTool.FindTypesInCurrentDomainWhereExtend(argType).Count == 1)
{
try
{
newElement = Activator.CreateInstance(argType);
}
catch (Exception)
{
}
}
list.Add(newElement);
}
GUI.FocusControl("");
}
// EditorGUI.indentLevel++;
for (var i = 0; i < list.Count; i++)
{
GUILayout.BeginVertical(GUITool.GetAreaGUIStyle(new Color(Color.grey.r, Color.grey.g, Color.grey.b, 0.3f)));
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
ShowObject(list[i]);
GUILayout.EndVertical();
// list[i] = GenericField("Element " + i, list[i], argType, null, null, false);
if (GUILayout.Button("X", GUILayout.Width(18)))
{
if (listType.IsArray)
{
list = ResizeArray((Array)list, list.Count - 1);
registeredEditorFoldouts[list] = true;
}
else
{
list.RemoveAt(i);
}
GUI.FocusControl("");
}
GUILayout.EndHorizontal();
GUITool.Line(2);
GUILayout.EndVertical();
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
// EditorGUI.indentLevel--;
Separator();
GUILayout.EndVertical();
return(list);
}
public static object GenericField(
string name,
object value,
Type t,
FieldInfo fieldInfo,
object instance,
bool withName = true)
{
if (t == null)
{
return(value);
}
Init();
if (fieldInfo != null)
{
//检查是否有字段解析支持
InspectorStyle inspectorStyle = fieldInfo.GetAttribute <InspectorStyle>();
FieldInspectorParser parser = null;
if (inspectorStyle != null)
{
name = inspectorStyle.Name;
if (inspectorStyle.ParserName != null)
{
inspectorFieldParsers.TryGetValue(inspectorStyle.ParserName, out parser);
}
}
if (parser != null)
{
return(parser.ParserFiled(inspectorStyle, value, t, fieldInfo, instance, withName));
}
}
//检查是否有默认类型解析
if (inspectorTypeParsers.ContainsKey(t))
{
return(inspectorTypeParsers[t].Show(name, value, t, fieldInfo, instance, withName));
}
//默认显示
if (t == typeof(string))
{
if (withName)
{
return(EditorGUILayout.TextField(name, (string)value));
}
return(EditorGUILayout.TextField((string)value));
}
if (t == typeof(bool))
{
if (withName)
{
return(EditorGUILayout.Toggle(name, (bool)value));
}
return(EditorGUILayout.Toggle((bool)value));
}
if (t == typeof(int))
{
if (withName)
{
return(EditorGUILayout.IntField(name, (int)value));
}
return(EditorGUILayout.IntField((int)value));
}
if (t == typeof(uint))
{
if (withName)
{
return((uint)EditorGUILayout.IntField(name, Convert.ToInt32((uint)value)));
}
return((uint)EditorGUILayout.IntField(Convert.ToInt32((uint)value)));
}
if (t == typeof(float))
{
if (withName)
{
return(EditorGUILayout.FloatField(name, (float)value));
}
return(EditorGUILayout.FloatField((float)value));
}
if (t == typeof(Vector2))
{
if (withName)
{
return(EditorGUILayout.Vector2Field(name, (Vector2)value));
}
return(EditorGUILayout.Vector2Field("", (Vector2)value));
}
if (t == typeof(Vector3))
{
if (withName)
{
return(EditorGUILayout.Vector3Field(name, (Vector3)value));
}
return(EditorGUILayout.Vector3Field("", (Vector3)value));
}
if (t == typeof(Vector4))
{
if (withName)
{
return(EditorGUILayout.Vector4Field(name, (Vector4)value));
}
return(EditorGUILayout.Vector4Field("", (Vector4)value));
}
if (t == typeof(Quaternion))
{
var quat = (Quaternion)value;
var vec4 = new Vector4(quat.x, quat.y, quat.z, quat.w);
if (withName)
{
vec4 = EditorGUILayout.Vector4Field(name, vec4);
}
else
{
vec4 = EditorGUILayout.Vector4Field("", vec4);
}
return(new Quaternion(vec4.x, vec4.y, vec4.z, vec4.w));
}
if (t == typeof(Color))
{
if (withName)
{
return(EditorGUILayout.ColorField(name, (Color)value));
}
return(EditorGUILayout.ColorField((Color)value));
}
if (t == typeof(Rect))
{
if (withName)
{
return(EditorGUILayout.RectField(name, (Rect)value));
}
return(EditorGUILayout.RectField((Rect)value));
}
if (t == typeof(AnimationCurve))
{
if (withName)
{
return(EditorGUILayout.CurveField(name, (AnimationCurve)value));
}
return(EditorGUILayout.CurveField((AnimationCurve)value));
}
if (t == typeof(Bounds))
{
if (withName)
{
return(EditorGUILayout.BoundsField(name, (Bounds)value));
}
return(EditorGUILayout.BoundsField((Bounds)value));
}
if (typeof(IList).IsAssignableFrom(t))
{
return(ListEditor(name, (IList)value, t));
}
if (t.IsSubclassOf(typeof(System.Enum)))
{
bool hasAttribute = t.HasAttribute <FlagsAttribute>();
if (hasAttribute)
{
if (withName)
{
GUILayout.BeginHorizontal();
GUILayout.Label(name, GUILayout.Width(150));
FlagsEnumEditor(value, fieldInfo, instance);
GUILayout.EndHorizontal();
}
else
{
FlagsEnumEditor(value, fieldInfo, instance);
}
return(fieldInfo.GetValue(instance));
}
else
{
if (withName)
{
return(EditorGUILayout.EnumPopup(name, (System.Enum)value));
}
return(EditorGUILayout.EnumPopup((System.Enum)value));
}
}
if (typeof(UnityEngine.Object).IsAssignableFrom(t))
{
if (withName)
{
return(EditorGUILayout.ObjectField(name, (UnityEngine.Object)value, t, true));
}
return(EditorGUILayout.ObjectField((UnityEngine.Object)value, t, true));
}
if (value == null)
{
try
{
value = ReflecTool.Instantiate(fieldInfo.FieldType);
fieldInfo.SetValue(instance, value);
}
catch (Exception e)
{
// ignored
}
}
if (value != null)
{
GUILayout.BeginVertical();
if (withName)
{
GUILayout.Label(name);
}
GUILayout.BeginHorizontal();
GUILayout.Space(20);
GUILayout.BeginVertical();
ShowObject(value);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
return(value);
}
