protected void DrawArrowCaps()
{
if (!(target is UObject))
{
return;
}
UObject t = (UObject)target;
var attr = GlobalReflectionCache.FindOrAdd(target.GetType()).GetCustomAttribute <DrawArrowCapAttribute>();
if (attr != null)
{
LokiSceneUtility.DrawArrowCap(t.transform);
}
}
private void DoRegister(IConsoleObject o)
{
Type type = o.GetType();
if (!mConsoleInfos.TryGetValue(type, out var consoleInfo))
{
consoleInfo = new List <IConsoleObject>();
mConsoleInfos.Add(type, consoleInfo);
}
consoleInfo.Union(o);
if (mSearchedType.Add(type))
{
var reflectTypeInfo = GlobalReflectionCache.FindOrAdd(type);
var methods = reflectTypeInfo.FindMethods <ConsoleMethodAttribute>();
foreach (var m in methods)
{
var attr = m.GetCustomAttribute <ConsoleMethodAttribute>();
MethodInfo validate = null;
if (!string.IsNullOrEmpty(attr.validate))
{
validate = type.GetMethod(attr.validate);
}
if (validate != null)
{
if (validate.IsStatic != m.IsStatic)
{
DebugUtility.LogError(LoggerTags.Console, "The Method [{0}] and the validate [{1}] must be the same modifier (ex. static)", m.Name, validate.Name);
continue;
}
if (validate.DeclaringType != typeof(bool))
{
DebugUtility.LogError(LoggerTags.Console, "The Validate [{0}] must return bool (true or false)", validate.Name);
continue;
}
}
string cmd = attr.aliasName;
if (string.IsNullOrEmpty(cmd))
{
cmd = string.Concat(type.FullName, ".", m.Name);
}
if (!mCommandInfos.TryGetValue(cmd, out var cmdGroup))
{
cmdGroup = new List <ConsoleCommand>();
mCommandInfos.Add(cmd, cmdGroup);
}
else
{
if (cmdGroup.FindIndex(command => command.owner == type) >= 0)
{
DebugUtility.LogError(LoggerTags.Engine, "The command is existed, it is not allowed : {0}", string.Concat(type.FullName, ".", m.Name));
continue;
}
}
ConsoleCommand entry;
entry.owner = type;
entry.attribute = attr;
entry.validate = validate;
entry.memberInfo = m;
entry.cmd = cmd;
cmdGroup.Add(entry);
}
var fieldsOrProperties = reflectTypeInfo.FindMembers <ConsoleMemberAttribute>();
foreach (var m in fieldsOrProperties)
{
var attr = m.GetCustomAttribute <ConsoleMemberAttribute>();
MethodInfo validate = null;
if (!string.IsNullOrEmpty(attr.validate))
{
validate = type.GetMethod(attr.validate);
}
if (validate != null)
{
bool memberIsStatic = false;
if (m.MemberType == MemberTypes.Field)
{
memberIsStatic = ((FieldInfo)m).IsStatic;
}
else if (m.MemberType == MemberTypes.Property)
{
memberIsStatic = ((PropertyInfo)m).IsStatic();
}
if (validate.IsStatic != memberIsStatic)
{
DebugUtility.LogError(LoggerTags.Console, "The Field [{0}] and the validate [{1}] must be the same modifier (ex. static)", m.Name, validate.Name);
continue;
}
if (validate.DeclaringType != typeof(bool))
{
DebugUtility.LogError(LoggerTags.Console, "The Validate [{0}] must return bool (true or false)", validate.Name);
continue;
}
}
string cmd = attr.aliasName;
if (string.IsNullOrEmpty(cmd))
{
cmd = string.Concat(type.FullName, ".", m.Name);
}
if (!mCommandInfos.TryGetValue(cmd, out var cmdGroup))
{
cmdGroup = new List <ConsoleCommand>();
mCommandInfos.Add(cmd, cmdGroup);
}
else
{
if (cmdGroup.FindIndex(command => command.owner == type) >= 0)
{
DebugUtility.LogError(LoggerTags.Engine, "The command is existed, it is not allowed : {0}", string.Concat(type.FullName, ".", m.Name));
continue;
}
}
ConsoleCommand entry;
entry.owner = type;
entry.attribute = attr;
entry.validate = validate;
entry.memberInfo = m;
entry.cmd = cmd;
cmdGroup.Add(entry);
}
}
}
protected virtual void OnDrawInspectorPreview()
{
if (target == null)
{
return;
}
Type targetType = target.GetType();
var memberInfos = GlobalReflectionCache.FindOrAdd(targetType).FindMembers <PreviewMemberBaseAttribute>();
if (memberInfos == null || memberInfos.Count <= 0)
{
return;
}
DrawLine();
foreach (var m in memberInfos)
{
PreviewMemberBaseAttribute attr = m.GetCustomAttribute <PreviewMemberBaseAttribute>(true);
TooltipAttribute ta = m.GetCustomAttribute <TooltipAttribute>(true);
Type drawType = null;
object value = null;
Action <object, object> setValue = null;
bool readonlyMember = false;
if (m is FieldInfo)
{
var field = (FieldInfo)m;
value = field.GetValue(target);
drawType = field.FieldType;
setValue = field.SetValue;
readonlyMember = field.IsInitOnly;
}
else if (m is PropertyInfo)
{
var property = (PropertyInfo)m;
value = property.GetValue(target);
drawType = property.PropertyType;
setValue = property.SetValue;
readonlyMember = !property.CanWrite;
}
else
{
continue;
}
string tooltip = ta != null ? ta.tooltip : string.Empty;
if (string.IsNullOrEmpty(tooltip))
{
var lta = m.GetCustomAttribute <LokiTooltipAttribute>(true);
tooltip = lta != null ? lta.tooltip : string.Empty;
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(m.Name, tooltip), WidthPercent(0.4f));
EditorGUI.BeginChangeCheck();
var lastGUIEnable = GUI.enabled;
GUI.enabled = !readonlyMember;
if (attr.useRange)
{
float rangeMin = 0.0f;
float rangeMax = 100000.0f;
if (attr is PreviewMemberAttribute)
{
PreviewMemberAttribute real = (PreviewMemberAttribute)attr;
rangeMin = real.rangeMin;
rangeMax = real.rangeMax;
}
else if (attr is PreviewMemberDynamicPropertyAttribute)
{
PreviewMemberDynamicPropertyAttribute real = (PreviewMemberDynamicPropertyAttribute)attr;
if (drawType == typeof(float) || drawType == typeof(int))
{
if (!string.IsNullOrEmpty(real.rangeMin))
{
rangeMin = (float)targetType.GetProperty(real.rangeMin).GetValue(target);
}
if (!string.IsNullOrEmpty(real.rangeMax))
{
rangeMax = (float)targetType.GetProperty(real.rangeMax).GetValue(target);
}
}
}
else if (attr is PreviewMemberDynamicFieldAttribute)
{
PreviewMemberDynamicFieldAttribute real = (PreviewMemberDynamicFieldAttribute)attr;
if (drawType == typeof(float) || drawType == typeof(int))
{
if (!string.IsNullOrEmpty(real.rangeMin))
{
rangeMin = (float)targetType.GetField(real.rangeMin).GetValue(target);
}
if (!string.IsNullOrEmpty(real.rangeMax))
{
rangeMax = (float)targetType.GetField(real.rangeMax).GetValue(target);
}
}
}
value = EditorGUILayoutObjectField(drawType, value, rangeMin, rangeMax);
}
else
{
value = EditorGUILayoutObjectField(drawType, value);
}
GUI.enabled = lastGUIEnable;
if (EditorGUI.EndChangeCheck())
{
setValue(target, value);
}
EditorGUILayout.EndHorizontal();
}
}
protected static void AutoSerializing(object t)
{
Type targetType = t.GetType();
UObject target = t as UObject;
if (target == null)
{
return;
}
var fieldsInfo = GlobalReflectionCache.FindOrAdd(targetType).FindSerializeFields();
if (fieldsInfo == null)
{
return;
}
foreach (var field in fieldsInfo)
{
bool fieldIsGameObject = (field.FieldType == typeof(GameObject));
bool fieldIsComponent = (field.FieldType.IsSubclassOf(typeof(Component)));
string fieldName = field.Name;
var attr = field.GetCustomAttribute <AutoSerializeFieldAttribute>(true);
if (attr != null)
{
if (!string.IsNullOrEmpty(attr.aliasName))
{
fieldName = attr.aliasName;
}
else
{
string autoRemovePrefix = attr.autoRemovePrefix;
if (!string.IsNullOrEmpty(autoRemovePrefix))
{
if (fieldName.Length > autoRemovePrefix.Length && fieldName.StartsWith(autoRemovePrefix))
{
fieldName = fieldName.Substring(autoRemovePrefix.Length);
}
}
}
}
if (fieldIsComponent || fieldIsGameObject)
{
Transform tr = target.transform.FindUnique(fieldName, StringComparison.OrdinalIgnoreCase);
if (tr == null)
{
if (fieldName.StartsWith("m"))
{
tr = target.transform.FindUnique(fieldName.Substring(1), StringComparison.OrdinalIgnoreCase);
}
}
if (tr != null)
{
if (fieldIsGameObject)
{
field.SetValue(target, tr.gameObject);
}
else if (fieldIsComponent)
{
var fieldComponent = tr.GetComponent(field.FieldType);
if (fieldComponent != null)
{
field.SetValue(target, fieldComponent);
}
}
else // todo
{
}
}
}
}
}