初次提交

Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2e2efccd66845e74fa3968222446ebb9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/CustomMethodDrawerAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+
+namespace TModule.Editor
+{
+    [Conditional("UNITY_EDITOR")]
+    [AttributeUsage(AttributeTargets.Class,AllowMultiple =false)]
+    public class CustomMethodDrawerAttribute : Attribute
+    {
+        public Type AttributeType;
+
+        public CustomMethodDrawerAttribute(Type type)
+        {
+            AttributeType = type;
+        }
+    }
+}

Editor/CustomMethodDrawerAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4031c14cdf5db474f827255293f1c7c3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/ObjectInspector.cs

@@ -0,0 +1,879 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using System;
+using UnityEditor.SceneManagement;
+using System.Reflection;
+using UObject = UnityEngine.Object;
+using UnityEngine.UIElements;
+
+namespace TModule.Editor
+{
+    [CustomEditor(typeof(UObject),true)]
+    public class ObjectInspector : UnityEditor.Editor
+    {
+        BindingFlags flags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+        List<MethodDrawer> methodDrawers = new List<MethodDrawer>();
+        List<PropertyInfo> propertyInfos = new List<PropertyInfo>();
+        List<PropertyDrawer> propertyDrawers = new List<PropertyDrawer>();
+        Dictionary<Type,Type> methodDrawerTypes = new Dictionary<Type,Type>();
+        Dictionary<Type, Type> propertyDrawerTypes = new Dictionary<Type, Type>();
+
+        private void OnEnable()
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                foreach (var type in assembly.GetTypes())
+                {
+                    if (type.IsDefined(typeof(CustomMethodDrawerAttribute), true))
+                    {
+                        Type type1 = type.GetCustomAttribute<CustomMethodDrawerAttribute>().AttributeType;
+                        if (methodDrawerTypes.ContainsKey(type1))
+                            methodDrawerTypes[type1] = type;
+                        else
+                            methodDrawerTypes.Add(type1, type);
+                    }
+                    if (type.IsDefined(typeof(TCustomPropertyDrawerAttribute), true))
+                    {
+                        Type type1 = type.GetCustomAttribute<TCustomPropertyDrawerAttribute>().AttributeType;
+                        if (propertyDrawerTypes.ContainsKey(type1))
+                            propertyDrawerTypes[type1] = type;
+                        else
+                            propertyDrawerTypes.Add(type1, type);
+                    }
+                }
+            }
+            foreach (var method in target.GetType().GetMethods(flags))
+            {
+                if(method.IsDefined(typeof(MethodAttribute), true))
+                {
+                    MethodAttribute attribute = method.GetCustomAttribute<MethodAttribute>();
+                    if (!methodDrawerTypes.ContainsKey(attribute.GetType())) continue;
+                    MethodDrawer methodDrawer = Activator.CreateInstance(methodDrawerTypes[attribute.GetType()]) as MethodDrawer;
+                    if (methodDrawer != null)
+                    {
+                        methodDrawer.attribute = attribute;
+                        methodDrawer.methodInfo = method;
+                        methodDrawers.Add(methodDrawer);
+                    }
+                }
+            }
+            foreach (var property in target.GetType().GetProperties(flags))
+            {
+                if (property.IsDefined(typeof(PropertyAttribute), true))
+                {
+                    PropertyAttribute attribute = property.GetCustomAttribute<PropertyAttribute>();
+                    if (!propertyDrawerTypes.ContainsKey(attribute.GetType())) continue;
+                    PropertyDrawer propertyDrawer = Activator.CreateInstance(propertyDrawerTypes[attribute.GetType()]) as PropertyDrawer;
+                    if (propertyDrawer != null)
+                    {
+                        propertyDrawer.attribute = attribute;
+                        propertyDrawer.propertyInfo = property;
+                        propertyDrawers.Add(propertyDrawer);
+                    }
+                }
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            foreach (var property in propertyDrawers)
+            {
+                property.OnGUI(serializedObject);
+            }
+            foreach (var method in methodDrawers)
+            {
+                method.OnGUI(serializedObject);
+            }
+        }
+    }
+
+    public abstract class BaseAttributeDrawer : UnityEditor.PropertyDrawer
+    {
+        Rect copyRect = Rect.zero;
+        Rect pasteRect = Rect.zero;
+        public UObject target;
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            InspectorAttribute _attribute = (InspectorAttribute)attribute;
+            if (_attribute is BegingFoldAttribute && property.isExpanded)
+            {
+                if (_attribute.IsShow)
+                    return base.GetPropertyHeight(property, label);
+                else
+                    return 0;
+            }
+            else
+               return base.GetPropertyHeight(property, label);
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (property != null) target = property.serializedObject.targetObject;
+            
+            InspectorAttribute _attribute = (InspectorAttribute)attribute;
+            OnDarwBefore(position, property, label);
+            if (!_attribute.IsShow) return;
+            if (_attribute is BegingFoldAttribute && !property.isExpanded) return;
+
+            float _width = position.width;
+            _width -= (Convert.ToInt32(_attribute.IsEnableCopy) + Convert.ToInt32(_attribute.IsEnadlePaste)) * 43;
+            float _btnWidth = _width;
+            if (_attribute.IsEnableCopy)
+            {
+                _btnWidth += 23;
+                copyRect.Set(_btnWidth, position.y, 40, position.height);
+                if (GUI.Button(copyRect, "¸´ÖÆ"))
+                    Copy(property);
+                _btnWidth += 43;
+            }
+            if(_attribute.IsEnadlePaste)
+            {
+                pasteRect.Set(_btnWidth, position.y, 40, position.height);
+                if (GUI.Button(pasteRect, "Õ³Ìù"))
+                    Paste(property);
+            }
+            
+            position.width = _width;
+            switch (_attribute.DrawMode)
+            {
+                case DrawMode.EditModeAndRunTime:
+                    OnDarw(position, property, label);
+                    break;
+                case DrawMode.OnlyEditMode:
+                    if (!EditorApplication.isPlaying)
+                        OnDarwEditMode(position, property, label);
+                    break;
+                case DrawMode.OnlyRuntime:
+                    if (EditorApplication.isPlaying)
+                        OnDarwRuntime(position, property, label);
+                    break;
+                default:
+                    base.OnGUI(position, property, label);
+                    break;
+            }
+
+        }
+
+        public virtual void OnDarwBefore(Rect position, SerializedProperty property, GUIContent label)
+        {
+
+        }
+
+        public virtual void Paste(SerializedProperty property)
+        {
+            property.serializedObject.Update();
+            switch (property.propertyType)
+            {
+                case SerializedPropertyType.Generic:
+                    break;
+                case SerializedPropertyType.Integer:
+                    if (int.TryParse(EditorGUIUtility.systemCopyBuffer, out int v))
+                        property.intValue = v;
+                    break;
+                case SerializedPropertyType.Boolean:
+                    if (bool.TryParse(EditorGUIUtility.systemCopyBuffer, out bool b))
+                        property.boolValue = b;
+                    break;
+                case SerializedPropertyType.Float:
+                    string fstr = EditorGUIUtility.systemCopyBuffer.Replace("f", "");
+                    if (float.TryParse(fstr, out float f))
+                        property.floatValue = f;
+                    break;
+                case SerializedPropertyType.String:
+                    property.stringValue = EditorGUIUtility.systemCopyBuffer;
+                    break;
+                case SerializedPropertyType.Color:
+                    property.colorValue = JsonUtility.FromJson<Color>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.ObjectReference:
+                    property.objectReferenceValue = JsonUtility.FromJson<UnityEngine.Object>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.LayerMask:
+                    break;
+                case SerializedPropertyType.Enum:
+                    property.enumValueIndex = JsonUtility.FromJson<int>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Vector2:
+                    property.vector2Value = JsonUtility.FromJson<Vector2>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Vector3:
+                    property.vector3Value = JsonUtility.FromJson<Vector3>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Vector4:
+                    property.vector4Value = JsonUtility.FromJson<Vector4>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Rect:
+                    property.rectValue = JsonUtility.FromJson<Rect>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.ArraySize:
+                    property.arraySize = JsonUtility.FromJson<int>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Character:
+                    break;
+                case SerializedPropertyType.AnimationCurve:
+                    property.animationCurveValue = JsonUtility.FromJson<AnimationCurve>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Bounds:
+                    property.boundsValue = JsonUtility.FromJson<Bounds>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Gradient:
+                    break;
+                case SerializedPropertyType.Quaternion:
+                    property.quaternionValue = JsonUtility.FromJson<Quaternion>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.ExposedReference:
+                    property.exposedReferenceValue = JsonUtility.FromJson<UnityEngine.Object>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.FixedBufferSize:
+                    break;
+                case SerializedPropertyType.Vector2Int:
+                    property.vector2IntValue = JsonUtility.FromJson<Vector2Int>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Vector3Int:
+                    property.vector3IntValue = JsonUtility.FromJson<Vector3Int>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.RectInt:
+                    property.rectIntValue = JsonUtility.FromJson<RectInt>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.BoundsInt:
+                    property.boundsIntValue = JsonUtility.FromJson<BoundsInt>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.ManagedReference:
+                    property.managedReferenceValue = JsonUtility.FromJson<object>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                case SerializedPropertyType.Hash128:
+                    property.hash128Value = JsonUtility.FromJson<Hash128>(EditorGUIUtility.systemCopyBuffer);
+                    break;
+                default:
+                    break;
+            }
+            property.serializedObject.ApplyModifiedProperties();
+        }
+
+        public virtual void Copy(SerializedProperty property)
+        {
+            switch (property.propertyType)
+            {
+                case SerializedPropertyType.Generic:
+                    break;
+                case SerializedPropertyType.Integer:
+                    EditorGUIUtility.systemCopyBuffer=property.intValue.ToString();
+                    break;
+                case SerializedPropertyType.Boolean:
+                    EditorGUIUtility.systemCopyBuffer = property.boolValue.ToString();
+                    break;
+                case SerializedPropertyType.Float:
+                    EditorGUIUtility.systemCopyBuffer = property.floatValue + "f";
+                    break;
+                case SerializedPropertyType.String:
+                    EditorGUIUtility.systemCopyBuffer = property.stringValue;
+                    break;
+                case SerializedPropertyType.Color:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.colorValue);
+                    break;
+                case SerializedPropertyType.ObjectReference:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.objectReferenceValue);
+                    break;
+                case SerializedPropertyType.LayerMask:
+                    break;
+                case SerializedPropertyType.Enum:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.enumValueIndex);
+                    break;
+                case SerializedPropertyType.Vector2:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.vector2Value);
+                    break;
+                case SerializedPropertyType.Vector3:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.vector3Value);
+                    break;
+                case SerializedPropertyType.Vector4:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.vector4Value);
+                    break;
+                case SerializedPropertyType.Rect:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.rectValue);
+                    break;
+                case SerializedPropertyType.ArraySize:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.arraySize);
+                    break;
+                case SerializedPropertyType.Character:
+                    break;
+                case SerializedPropertyType.AnimationCurve:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.animationCurveValue);
+                    break;
+                case SerializedPropertyType.Bounds:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.boundsValue);
+                    break;
+                case SerializedPropertyType.Gradient:
+                    break;
+                case SerializedPropertyType.Quaternion:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.quaternionValue);
+                    break;
+                case SerializedPropertyType.ExposedReference:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.exposedReferenceValue);
+                    break;
+                case SerializedPropertyType.FixedBufferSize:
+                    break;
+                case SerializedPropertyType.Vector2Int:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.vector2IntValue);
+                    break;
+                case SerializedPropertyType.Vector3Int:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.vector3IntValue);
+                    break;
+                case SerializedPropertyType.RectInt:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.rectIntValue);
+                    break;
+                case SerializedPropertyType.BoundsInt:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.boundsIntValue);
+                    break;
+                case SerializedPropertyType.ManagedReference:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.managedReferenceValue);
+                    break;
+                case SerializedPropertyType.Hash128:
+                    EditorGUIUtility.systemCopyBuffer = JsonUtility.ToJson(property.hash128Value);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        public virtual void OnDarwRuntime(Rect position, SerializedProperty property, GUIContent label)
+        {
+            DrawUI(position, property, label);
+        }
+
+        public virtual void OnDarwEditMode(Rect position, SerializedProperty property, GUIContent label)
+        {
+            DrawUI(position, property, label);
+        }
+
+        public virtual void OnDarw(Rect position, SerializedProperty property, GUIContent label)
+        {
+            DrawUI(position, property, label);
+        }
+
+        public abstract void DrawUI(Rect position, SerializedProperty property, GUIContent label);
+
+        public void MarkerChange()
+        {
+            if (target == null) return;
+            EditorUtility.SetDirty(target);
+            if (EditorApplication.isPlaying) return;
+
+            Component component = target as Component;
+            if (component != null && component.gameObject.scene != null)
+            {
+                EditorSceneManager.MarkSceneDirty(component.gameObject.scene);
+            }
+        }
+    }
+
+    public abstract class MethodDrawer
+    {
+        public MethodInfo methodInfo;
+        public MethodAttribute attribute;
+
+        public virtual void OnGUI(SerializedObject serializedObject)
+        {
+
+        }
+    }
+
+    public abstract class PropertyDrawer
+    {
+        public PropertyInfo propertyInfo;
+        public PropertyAttribute attribute;
+        public UObject target;
+        public EventButtonAttribute buttonAttribute;
+        public GetTransFormValueAttribute formValueAttribute;
+        public string Name;
+
+        public virtual void OnGUI(SerializedObject serializedObject)
+        {
+            target = serializedObject.targetObject;
+            Name = string.IsNullOrEmpty(attribute.Lable) ? propertyInfo.Name : attribute.Lable;
+            buttonAttribute = target?.GetType().GetCustomAttribute<EventButtonAttribute>();
+            formValueAttribute = target?.GetType().GetCustomAttribute<GetTransFormValueAttribute>();
+            using(new EditorGUILayout.HorizontalScope())
+            {
+                switch (attribute.DrawMode)
+                {
+                    case DrawMode.EditModeAndRunTime:
+                        OnDarw(serializedObject);
+                        break;
+                    case DrawMode.OnlyEditMode:
+                        if (!EditorApplication.isPlaying)
+                            OnDarwEditMode(serializedObject);
+                        break;
+                    case DrawMode.OnlyRuntime:
+                        if (EditorApplication.isPlaying)
+                            OnDarwRuntime(serializedObject);
+                        break;
+                    default:
+                        DrawUI(serializedObject);
+                        break;
+                }
+                if (attribute.IsEnableCopy)
+                {
+                    if (GUILayout.Button("¸´ÖÆ",GUILayout.ExpandWidth(false)))
+                        Copy(serializedObject);
+                }
+                if (attribute.IsEnadlePaste)
+                {
+                    if (GUILayout.Button("Õ³Ìù", GUILayout.ExpandWidth(false)))
+                        Paste(serializedObject);
+                }
+                if(buttonAttribute!=null)
+                {
+                    if(GUILayout.Button(buttonAttribute.Lable, GUILayout.ExpandWidth(false)))
+                    {
+                        buttonAttribute.TypeValue.GetMethod(buttonAttribute.ActionName)?.Invoke(target,null);
+                    }
+                }
+                if(formValueAttribute!=null)
+                {
+                    if(GUILayout.Button(EditorGUIUtility.IconContent("Custom@2x").image, GUILayout.Width(30), GUILayout.Height(20)))
+                    {
+                        Vector3 value = (Vector3)propertyInfo.GetValue(target);
+                        if(Selection.activeTransform)
+                            switch (formValueAttribute.TranType)
+                            {
+                                case TranType.None:
+                                    break;
+                                case TranType.Position:
+                                    value = Selection.activeTransform.position;
+                                    break;
+                                case TranType.Rotation:
+                                    value = Selection.activeTransform.rotation.eulerAngles;
+                                    break;
+                                case TranType.Scale:
+                                    value = Selection.activeTransform.localScale;
+                                    break;
+                                default:
+                                    break;
+                            }
+                        propertyInfo.SetValue(target, value);
+                    }
+                }
+            }
+        }
+
+        public virtual void Paste(SerializedObject serializedObject)
+        {
+            try
+            {
+                propertyInfo.SetValue(target, EditorGUIUtility.systemCopyBuffer);
+                MarkerChange();
+            }
+            catch
+            {
+
+            }
+        }
+
+        public virtual void Copy(SerializedObject serializedObject)
+        {
+            EditorGUIUtility.systemCopyBuffer = propertyInfo.GetValue(target).ToString();
+        }
+
+        public virtual void OnDarwRuntime(SerializedObject serializedObject)
+        {
+            DrawUI(serializedObject);
+        }
+
+        public virtual void OnDarwEditMode(SerializedObject serializedObject)
+        {
+            DrawUI(serializedObject);
+        }
+
+        public virtual void OnDarw(SerializedObject serializedObject)
+        {
+            DrawUI(serializedObject);
+        }
+
+        public void MarkerChange()
+        {
+            if (target == null) return;
+            EditorUtility.SetDirty(target);
+            if (EditorApplication.isPlaying) return;
+
+            Component component = target as Component;
+            if (component != null && component.gameObject.scene != null)
+            {
+                EditorSceneManager.MarkSceneDirty(component.gameObject.scene);
+            }
+        }
+
+        public abstract void DrawUI(SerializedObject serializedObject);
+    }
+
+    [CustomPropertyDrawer(typeof(LabelAttribute),true)]
+    public class LabelAttributeDrawer:BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            LabelAttribute _attribute = (LabelAttribute)attribute;
+            label.text = _attribute.Text;
+            EditorGUI.PropertyField(position, property, label);
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(EventButtonAttribute), true)]
+    public class EventButtonAttributeDrawer : BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EventButtonAttribute _attribute = (EventButtonAttribute)attribute;
+            float width = position.width - 33;
+            width += 23;
+            if (GUI.Button(new Rect(width,position.y,30,position.height),_attribute.Lable))
+            {
+                _attribute.TypeValue.GetMethod(_attribute.ActionName).Invoke(target, null);
+            }
+            EditorGUI.PropertyField(new Rect(position.x,position.y,width-23,position.height), property, label);
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(DropdownAttribute),true)]
+    public class DropdownAttributeDrawer : BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            object value = fieldInfo.GetValue(property.serializedObject.targetObject);
+            DropdownAttribute dropdown = attribute as DropdownAttribute;
+            int selectIndex = dropdown.Values.IndexOf(value);
+            if (selectIndex < 0)
+            {
+                selectIndex = 0;
+                fieldInfo.SetValue(property.serializedObject.targetObject, dropdown.Values[selectIndex]);
+                MarkerChange();
+            }
+
+            EditorGUI.BeginChangeCheck();
+            int newIndex = EditorGUI.Popup(position,label.text, selectIndex, dropdown.DisplayOptions.ToArray());
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(target, "Dropdown");
+                fieldInfo.SetValue(target, dropdown.Values[newIndex]);
+                MarkerChange();
+            }
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(SceneAttribute))]
+    public class SceneAttributeDrawer : BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            object value = fieldInfo.GetValue(target);
+            EditorGUI.BeginChangeCheck();
+            SceneAsset scene = EditorGUI.ObjectField(position,label, AssetDatabase.LoadAssetAtPath<SceneAsset>((string)value), typeof(SceneAsset), false) as SceneAsset;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(target, "Scene");
+                fieldInfo.SetValue(target, AssetDatabase.GetAssetPath(scene));
+                MarkerChange();
+            }
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(RelevancyShowAttribute))]
+    public class RelevancyShowAttributeDrawer : BaseAttributeDrawer
+    {
+        BindingFlags flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Default | BindingFlags.Instance;
+
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.PropertyField(position, property, label);
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            RelevancyShowAttribute _attribute = attribute as RelevancyShowAttribute;
+            MemberInfo[] member = property.serializedObject.targetObject.GetType().GetMember(_attribute.FieldName, flags);
+            if (member != null && member.Length > 0)
+            {
+                if (member[0].MemberType == MemberTypes.Field)
+                    _attribute.IsShow = (member[0] as FieldInfo).GetValue(property.serializedObject.targetObject).Equals(_attribute.ShowValue);
+                else if (member[0].MemberType == MemberTypes.Property)
+                    _attribute.IsShow = (member[0] as PropertyInfo).GetValue(property.serializedObject.targetObject).Equals(_attribute.ShowValue);
+                else if (member[0].MemberType == MemberTypes.Method)
+                    _attribute.IsShow = (member[0] as MethodInfo).Invoke(property.serializedObject.targetObject, null).Equals(_attribute.ShowValue);
+            }
+            return base.GetPropertyHeight(property, label);
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(OnlyReadAttribute))]
+    public class OnlyReadAttributeDrawer : BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            GUI.enabled = false;
+            EditorGUI.PropertyField(position, property, label);
+            GUI.enabled = true;
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(BegingFoldAttribute))]
+    public class BegingFoldAttributeDrawer : BaseAttributeDrawer
+    {
+        int count = 0;
+        BindingFlags flags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+
+        public override void OnDarwBefore(Rect position, SerializedProperty property, GUIContent label)
+        {
+            BegingFoldAttribute _attribute = attribute as BegingFoldAttribute;
+            property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, _attribute.Label);
+        }
+
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            position.y += 23;
+            position.height = 20;
+            EditorGUI.PropertyField(position, property, label);
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            using (SerializedProperty iterator = property.serializedObject.GetIterator())
+            {
+                HashSet<string> fieldPaths = new HashSet<string>();
+                bool flags1 = false;
+                while (iterator.NextVisible(true))
+                {
+                    SerializedProperty _property = property.serializedObject.FindProperty(iterator.name);
+                    if (!flags1)
+                        flags1 = _property.propertyPath == property.propertyPath;
+                    if (_property != null && !fieldPaths.Contains(_property.propertyPath)&&flags1)
+                    {
+                        fieldPaths.Add(_property.propertyPath);
+                        FieldInfo fieldInfo = _property.serializedObject.targetObject.GetType().GetField(_property.name, flags);
+                        InspectorAttribute _attribute = fieldInfo.GetCustomAttribute<InspectorAttribute>();
+                        if(_attribute!=null)
+                        {
+                            if (fieldInfo.GetCustomAttribute<BegingFoldAttribute>() != null)
+                            {
+                                count++;
+                            }
+                            if(fieldInfo.GetCustomAttribute<EndFoldAttribute>() != null)
+                            {
+                                count--;
+                                if (count == 0)
+                                    break;
+                            }
+                        }
+                        _property.isExpanded = property.isExpanded;
+                    }
+                }
+            }
+
+            return base.GetPropertyHeight(property, label)+23;
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(GetTransFormValueAttribute))]
+    public class GetTransFormValueAttributeDrawer : BaseAttributeDrawer
+    {
+        public override void DrawUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            GetTransFormValueAttribute _attribute = (GetTransFormValueAttribute)attribute;
+            float width = position.width - 33;
+            width += 23;
+            if (GUI.Button(new Rect(width, position.y, 30, position.height), EditorGUIUtility.IconContent("Custom@2x").image))
+            {
+                Vector3 value = property.vector3Value;
+                if (Selection.activeTransform)
+                    switch (_attribute.TranType)
+                    {
+                        case TranType.None:
+                            break;
+                        case TranType.Position:
+                            value = Selection.activeTransform.position;
+                            break;
+                        case TranType.Rotation:
+                            value = Selection.activeTransform.rotation.eulerAngles;
+                            break;
+                        case TranType.Scale:
+                            value = Selection.activeTransform.localScale;
+                            break;
+                        default:
+                            break;
+                    }
+                property.vector3Value = value;
+            }
+            EditorGUI.PropertyField(new Rect(position.x, position.y, width-23, position.height), property, label);
+        }
+    }
+
+    [TCustomPropertyDrawer(typeof(PropertyAttribute))]
+    public class PropertyAttributeDrawer : PropertyDrawer
+    {
+        public override void DrawUI(SerializedObject serializedObject)
+        {
+            if (propertyInfo.CanWrite)
+            {
+                CanWritePainting();
+            }
+            else
+            {
+                ReadOnlyPainting();
+            }
+        }
+
+
+        private void CanWritePainting()
+        {
+            EditorGUI.BeginChangeCheck();
+            object value = propertyInfo.GetValue(target);
+            object newValue = value;
+            if (propertyInfo.PropertyType.IsEnum)
+            {
+                Enum realValue = EditorGUILayout.EnumPopup(Name, (Enum)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(string))
+            {
+                string realValue = EditorGUILayout.TextField(Name, (string)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(int))
+            {
+                int realValue = EditorGUILayout.IntField(Name, (int)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(float))
+            {
+                float realValue = EditorGUILayout.FloatField(Name, (float)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(bool))
+            {
+                bool realValue = EditorGUILayout.Toggle(Name, (bool)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(Vector2))
+            {
+                Vector2 realValue = EditorGUILayout.Vector2Field(Name, (Vector2)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(Vector3))
+            {
+                Vector3 realValue = EditorGUILayout.Vector3Field(Name, (Vector3)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType == typeof(Color))
+            {
+                Color realValue = EditorGUILayout.ColorField(Name, (Color)value);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else if (propertyInfo.PropertyType.IsSubclassOf(typeof(UObject)))
+            {
+                UObject realValue = EditorGUILayout.ObjectField(Name, value as UObject, propertyInfo.PropertyType, true);
+                if (EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+            else
+            {
+                string realValue = EditorGUILayout.TextField(Name, value != null ? value.ToString() : "null");
+                if(EditorGUI.EndChangeCheck()) newValue = realValue;
+            }
+
+            if (value != newValue)
+            {
+                Undo.RecordObject(target, "propertyInfo Changed");
+                propertyInfo.SetValue(target, newValue);
+                MarkerChange();
+            }
+        }
+
+        private void ReadOnlyPainting()
+        {
+            GUI.enabled = false;
+
+            object value = propertyInfo.GetValue(target);
+            if (propertyInfo.PropertyType.IsEnum)
+            {
+                EditorGUILayout.EnumPopup(Name, (Enum)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(string))
+            {
+                EditorGUILayout.TextField(Name, (string)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(int))
+            {
+                EditorGUILayout.IntField(Name, (int)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(float))
+            {
+                EditorGUILayout.FloatField(Name, (float)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(bool))
+            {
+                EditorGUILayout.Toggle(Name, (bool)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(Vector2))
+            {
+                EditorGUILayout.Vector2Field(Name, (Vector2)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(Vector3))
+            {
+                EditorGUILayout.Vector3Field(Name, (Vector3)value);
+            }
+            else if (propertyInfo.PropertyType == typeof(Color))
+            {
+                EditorGUILayout.ColorField(Name, (Color)value);
+            }
+            else if (propertyInfo.PropertyType.IsSubclassOf(typeof(UObject)))
+            {
+                EditorGUILayout.ObjectField(Name, value as UObject, propertyInfo.PropertyType, false);
+            }
+            else
+            {
+                EditorGUILayout.TextField(Name, value != null ? value.ToString() : "null");
+            }
+            GUI.enabled = true;
+        }
+    }
+
+    [CustomMethodDrawer(typeof(ButtonAttribute))]
+    public class ButtonAttributeDrawer : MethodDrawer
+    {
+        BindingFlags flags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Default; 
+        public bool IsActive = true;
+        public string Name;
+
+        public override void OnGUI(SerializedObject serializedObject)
+        {
+            ButtonAttribute _attribute = attribute as ButtonAttribute;
+            Name = string.IsNullOrEmpty(_attribute.Name) ? methodInfo.Name : _attribute.Name;
+            if (!string.IsNullOrEmpty(_attribute.CriteriaName))
+            {
+                MemberInfo[] member = serializedObject.targetObject.GetType().GetMember(_attribute.CriteriaName, flags);
+
+                if (member != null && member.Length > 0)
+                {
+                    if (member[0].MemberType == MemberTypes.Field)
+                        IsActive = (bool)(member[0] as FieldInfo).GetValue(serializedObject.targetObject);
+                    else if (member[0].MemberType == MemberTypes.Property)
+                        IsActive = (bool)(member[0] as PropertyInfo).GetValue(serializedObject.targetObject);
+                    else if (member[0].MemberType == MemberTypes.Method)
+                        IsActive = (bool)(member[0] as MethodInfo).Invoke(serializedObject.targetObject, null);
+                }
+
+                GUI.enabled = IsActive == _attribute.CriteriaVaule;
+            }
+            if (GUILayout.Button(Name))
+            {
+                if (methodInfo.IsStatic)
+                    methodInfo.Invoke(null, _attribute.Parameter);
+                else
+                    methodInfo.Invoke(serializedObject.targetObject, _attribute.Parameter);
+            }
+            GUI.enabled = true;
+        }
+    }
+
+}

Editor/ObjectInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 419eea9a0bdd5744caf4f6f8a9a642b3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/TCustomPropertyDrawer.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+using UnityEditor;
+
+namespace TModule.Editor
+{
+    [Conditional("UNITY_EDITOR")]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public class TCustomPropertyDrawerAttribute : Attribute
+    {
+        public Type AttributeType;
+        public TCustomPropertyDrawerAttribute(Type type)
+        {
+            AttributeType = type;
+        }
+    }
+}

Editor/TCustomPropertyDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 97008c2d1b3cdae42ba4cea9f1b2de14
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

InspectorAttribute.cs

@@ -0,0 +1,262 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+
+namespace TModule
+{
+    public enum DrawMode
+    {
+        EditModeAndRunTime,
+        OnlyEditMode,
+        OnlyRuntime
+    }
+
+    [Conditional("UNITY_EDITOR")]
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
+    public class InspectorAttribute : UnityEngine.PropertyAttribute
+    {
+        /// <summary>
+        /// 显示模式
+        /// </summary>
+        public DrawMode DrawMode = DrawMode.EditModeAndRunTime;
+
+        /// <summary>
+        /// 是否启用复制按钮
+        /// </summary>
+        public bool IsEnableCopy = false;
+
+        /// <summary>
+        /// 是否启用粘贴
+        /// </summary>
+        public bool IsEnadlePaste = false;
+
+        /// <summary>
+        /// 是否显示
+        /// </summary>
+        public bool IsShow = true;
+    }
+
+    /// <summary>
+    /// 标签
+    /// </summary>
+    public class LabelAttribute : InspectorAttribute
+    {
+        public string Text;
+
+        public LabelAttribute(string text)
+        {
+            Text = text;
+        }
+    }
+
+    /// <summary>
+    /// 下拉菜单
+    /// </summary>
+    public class DropdownAttribute : InspectorAttribute
+    {
+        public List<string> DisplayOptions { get; private set; } = new List<string>();
+
+        public List<object> Values { get; private set; } = new List<object>();
+
+        public DropdownAttribute(IEnumerable<string> displayOptions, IEnumerable<object> values)
+        {
+            DisplayOptions.AddRange(displayOptions);
+            Values.AddRange(values);
+        }
+
+        public DropdownAttribute() { }
+    }
+
+    /// <summary>
+    /// 将某个类型的子类做为下拉菜单
+    /// </summary>
+    public class TypeDropdownAttribute : DropdownAttribute
+    {
+        public Type ValueType;
+
+        public TypeDropdownAttribute(Type valueType)
+        {
+            Values.Add("None");
+            DisplayOptions.Add("None");
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                foreach (var type in assembly.GetTypes())
+                {
+                    if (type.IsSubclassOf(valueType) || (type.BaseType != null && type.BaseType.IsGenericType && type.BaseType.GetGenericTypeDefinition() == valueType))//判断type是否是其派生类
+                        if (type.IsClass && !type.IsAbstract && type.Name != valueType.Name)
+                        {
+                            Values.Add(type.FullName);
+                            DisplayOptions.Add(type.FullName);
+                        }
+                }
+            } 
+            
+        }
+    }
+
+    /// <summary>
+    /// 场景资源路径
+    /// </summary>
+    public class SceneAttribute : InspectorAttribute
+    {
+
+    }
+
+    public class MethodAttribute:Attribute
+    {
+
+    }
+
+    /// <summary>
+    /// 在字段后添加一个事件按钮
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true, Inherited = true)]
+    public class EventButtonAttribute : InspectorAttribute
+    {
+        public string Lable;
+        public string Style;
+        public string ActionName;
+        public string Tip;
+        public Texture Texture;
+        public Type TypeValue;
+
+        public EventButtonAttribute(string lable, string style, string actionName, Type type)
+        {
+            Lable = lable;
+            Style = style;
+            ActionName = actionName;
+            TypeValue = type;
+        }
+
+        public EventButtonAttribute(string lable, string tip, Texture texture, string actionName, Type type)
+        {
+            Lable = lable;
+            Tip = tip;
+            Texture = texture;
+            ActionName = actionName;
+            TypeValue = type;
+        }
+    }
+
+    /// <summary>
+    /// 方法按钮
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
+    public class ButtonAttribute : MethodAttribute
+    {
+        public string Name;
+        public string CriteriaName;
+        public bool CriteriaVaule;
+        public object[] Parameter;
+
+        public ButtonAttribute(params object[] parameter)
+        {
+            Parameter = parameter;
+        }
+
+        public ButtonAttribute(string buttonName, params object[] parameter)
+        {
+            Name = buttonName;
+            Parameter = parameter;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="buttonName">按钮显示文字</param>
+        /// <param name="criteraName">激活按钮条件名字 可是字段，属性，方法（必须有返回值且返回值为bool）</param>
+        /// <param name="criteriaValue">激活条件值</param>
+        /// <param name="parameter">参数</param>
+        public ButtonAttribute(string buttonName, string criteraName, bool criteriaValue = true, params object[] parameter)
+        {
+            Name = buttonName;
+            CriteriaName = criteraName;
+            CriteriaVaule = criteriaValue;
+            Parameter = parameter;
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+
+    public class GetTransFormValueAttribute : InspectorAttribute
+    {
+        public TranType TranType;
+
+        /// <summary>
+        /// 获取选中对象的Transform值
+        /// </summary>
+        /// <param name="tranType">要获取的Transform值TranType类型</param>
+        public GetTransFormValueAttribute(TranType tranType)
+        {
+            TranType = tranType;
+        }
+    }
+    public enum TranType
+    {
+        None,
+        Position,
+        Rotation,
+        Scale
+    }
+
+    /// <summary>
+    /// 属性
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
+    public class PropertyAttribute:InspectorAttribute
+    {
+        public string Lable;
+
+        public PropertyAttribute()
+        {
+            
+        }
+
+        public PropertyAttribute(string lable = "")
+        {
+            Lable = lable;
+        }
+    }
+
+    /// <summary>
+    /// 关联显示条件
+    /// </summary>
+    public class RelevancyShowAttribute : InspectorAttribute
+    {
+        public string FieldName;
+        public object ShowValue;
+
+        /// <summary>
+        /// 关联字段/属性显示条件
+        /// </summary>
+        /// <param name="fieldName">关联字段名字</param>
+        /// <param name="showValue">字段值为何值时显示</param>
+        public RelevancyShowAttribute(string fieldName, object showValue)
+        {
+            FieldName = fieldName;
+            ShowValue = showValue;
+        }
+    }
+
+    public class OnlyReadAttribute : InspectorAttribute
+    {
+
+    }
+
+    public class BegingFoldAttribute:InspectorAttribute
+    {
+        public string Label;
+
+        public BegingFoldAttribute(string label)
+        {
+            Label = label;
+        }
+    }
+
+    public class EndFoldAttribute : InspectorAttribute
+    {
+
+    }
+}

InspectorAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8491922d5ceafd54c92b55fb15c2e231
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: