1 files changed, 500 insertions, 0 deletions
diff --git a/Assets/Mountools/Tools/ToolObjectMethodInvoker.cs b/Assets/Mountools/Tools/ToolObjectMethodInvoker.cs
new file mode 100755
index 0000000..148f121
--- /dev/null
+++ b/Assets/Mountools/Tools/ToolObjectMethodInvoker.cs
@@ -0,0 +1,500 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mountools.Tools
+{
+    public class ToolObjectMethodInvoker : EditorWindow
+    {
+        private string _search = "";
+        
+        private Vector2 _scrollPositionRight = Vector2.zero;
+
+        private Dictionary<ParameterInfo, object> _parameterCache;
+        private Dictionary<MethodInfo, bool> _foldoutEnableMethod;
+
+        private bool _showGetter;
+        private bool _showSetter;
+        private bool _showPrivate;
+        private bool _showInherit;
+
+        private Component _debugComponent;
+
+        private void OnGUI()
+        {
+            EditorGUILayout.BeginVertical();
+            Draw();
+            EditorGUILayout.EndVertical();
+        }
+
+        private void Draw()
+        {
+            if (_parameterCache == null)
+                _parameterCache = new();
+            
+            if (_foldoutEnableMethod == null)
+                _foldoutEnableMethod = new();
+        
+            if (Selection.gameObjects == null || Selection.gameObjects.Length < 1)
+            {
+                return;
+            }
+        
+            GameObject debugObject = Selection.gameObjects[0];
+
+            var components = debugObject.GetComponents<Component>();
+
+            EditorGUILayout.BeginVertical();
+            {
+                EditorGUILayout.BeginVertical(GUILayout.Height(20));
+                {
+                    int select = 0;
+                    var i = 0;
+                    Component[] selections = components;
+                    List<string> names = new List<string>();
+                    foreach (var component in components)
+                    {
+                        names.Add(component.GetType().Name);
+                            
+                        if (component == _debugComponent)
+                            select = i;
+                        i++;
+                    }
+                    _debugComponent = selections[GUILayout.Toolbar(select, names.ToArray(), "toolbarbuttonRight")];
+
+                    
+                }
+                EditorGUILayout.EndVertical();
+            
+                EditorGUILayout.BeginHorizontal();
+                {
+                    _showSetter = GUILayout.Toggle(_showSetter, "Setter", "TE toolbarbutton", GUILayout.Width(45));
+                    _showGetter = GUILayout.Toggle(_showGetter, "Getter", "TE toolbarbutton", GUILayout.Width(45));
+                    _showInherit = GUILayout.Toggle(_showInherit, "Inherit", "TE toolbarbutton", GUILayout.Width(60));
+                    _showPrivate = GUILayout.Toggle(_showPrivate, "Private", "TE toolbarbutton", GUILayout.Width(60));
+                    _search = EditorGUILayout.TextField("", _search, "SearchTextField");
+                }
+                EditorGUILayout.EndHorizontal();
+                
+                _scrollPositionRight = EditorGUILayout.BeginScrollView(_scrollPositionRight, "OL box NoExpand");
+                {
+                    DrawComponentMethodInvokerView(_debugComponent);
+                }
+                EditorGUILayout.EndScrollView();
+            }
+            EditorGUILayout.EndVertical();
+        }
+
+        private void DrawComponentMethodInvokerView(Component component)
+        {
+            if (component == null)
+            {
+                return;
+            }
+
+            var style = new GUIStyle { fontSize = 12, fontStyle = FontStyle.Bold, normal = { textColor = GUI.contentColor } };
+            
+#if MT_L_CHINESE
+            var strMethod = "有参数方法列表";
+#endif
+#if MT_L_ENGLISH
+            var strMethod = "Method";
+#endif
+            EditorGUILayout.LabelField("   " + strMethod, style);
+            
+            EditorGUILayout.BeginVertical();
+            {
+                List<MethodInfo> noParameterMethodInfos = new List<MethodInfo>();
+                var methods = component.GetType().GetMethods();
+                var drawCount = 0;
+                foreach (var method in methods)
+                {
+                    if (method.Name.Contains("get_") && !_showGetter) continue;
+                    if (method.Name.Contains("set_") && !_showSetter) continue;
+                    if (method.IsPrivate && !_showPrivate) continue;
+                    if (method.DeclaringType != method.ReflectedType && !_showInherit) continue;
+                    if (_search.Trim() != "" && !method.Name.ToLower().Contains(_search.Trim().ToLower())) continue;
+
+                    if (!method.ContainsGenericParameters && !method.IsGenericMethod && !method.IsAbstract &&
+                        !method.IsConstructor && !method.IsAssembly)
+                    {
+                        ParameterInfo[] paremeters = method.GetParameters();
+                        if (paremeters.Length > 0)
+                        {
+                            DrawMethodInvoker(component, method, paremeters);
+                            drawCount ++;
+                        }
+                        else
+                        {
+                            noParameterMethodInfos.Add(method);
+                        }
+                    }
+                }
+#if MT_L_CHINESE
+                var strNone = "无";
+                var strNoParameter = "无参数方法列表";
+#endif
+#if MT_L_ENGLISH
+                var strNone = "None";
+                var strNoParameter = "No Parameter";
+#endif
+                if (drawCount == 0)
+                {
+                    EditorGUILayout.LabelField(strNone);
+                }
+
+                EditorGUILayout.Space();
+
+                EditorGUILayout.LabelField("   " + strNoParameter, style);
+
+                if (noParameterMethodInfos.Count < 1)
+                {
+                    EditorGUILayout.LabelField(strNone);
+                }
+                else
+                {
+                    foreach (var method in noParameterMethodInfos)
+                    {
+                        if (EditorGUILayout.LinkButton(method.Name + "();"))
+                        {
+                            PrintReturnValue(method, method.Invoke(component, null));
+                        }
+                    }
+                }
+            }
+            EditorGUILayout.EndVertical();
+        }
+        
+        private void DrawMethodInvoker(Component obj, MethodInfo methodInfo, ParameterInfo[] parameters)
+        {
+            string parameterNames = "";
+            foreach (var parameter in parameters)
+            {
+                parameterNames += parameter.ParameterType.Name + " " + parameter.Name + ", ";
+            }
+            
+            string n = (methodInfo.Name + " (" + parameterNames + ");")
+                .Replace("Single", "float")
+                .Replace("Int32", "int")
+                .Replace(", );", ");");
+            
+            SetFoldoutMethod(methodInfo, 
+                EditorGUILayout.BeginFoldoutHeaderGroup(GetFoldoutMethod(methodInfo), n, "FoldoutHeader"));
+            EditorGUILayout.EndFoldoutHeaderGroup();
+
+            EditorGUILayout.BeginHorizontal();
+            {
+                if (GetFoldoutMethod(methodInfo))
+                {
+                    EditorGUILayout.BeginVertical("OL box NoExpand");
+                    {
+                        bool canInvoke = true;
+
+                        foreach (var parameter in parameters)
+                        {
+                            if (!DrawParameterInputField(parameter))
+                                canInvoke = false;
+                        }
+
+#if MT_L_CHINESE
+                        var strInvoke = "调用方法";
+                        var strInvokeUnsafe = "调用方法 (非安全)";
+#endif
+#if MT_L_ENGLISH
+                        var strInvoke = "Invoke";
+                        var strInvokeUnsafe = "Invoke (Unsafe)";
+#endif
+
+                        bool click = canInvoke
+                            ? GUILayout.Button(strInvoke)
+                            : GUILayout.Button(strInvokeUnsafe);
+
+                        if (click)
+                        {
+                            List<object> param = new List<object>();
+                            foreach (var parameter in parameters)
+                            {
+                                param.Add(GetParameter(parameter));
+                            }
+
+                            PrintReturnValue(methodInfo, methodInfo.Invoke(obj, param.ToArray()));
+                        }
+                    }
+                    EditorGUILayout.EndVertical();
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private bool DrawParameterInputField(ParameterInfo parameterInfo)
+        {
+            var type = parameterInfo.ParameterType;
+            var parameterNameRaw = parameterInfo.Name;
+            var parameterName = "";
+            
+            // Name Formatter
+            var i = 0;
+            foreach (var nameChar in parameterNameRaw.Trim())
+            {
+                if (Char.IsUpper(nameChar))
+                {
+                    parameterName += " " + nameChar;
+                    continue;
+                }
+
+                parameterName += nameChar;
+            }
+
+            if (parameterName.Length > 1)
+                parameterName = parameterName.Substring(0, 1).ToUpper() + parameterName.Substring(1);
+            else
+                parameterName = parameterName.ToUpper();
+
+            if (type == typeof(int))
+            {
+                string t = parameterInfo.Name.ToLower();
+                if (t.Contains("mask") || t.Contains("layer"))
+                {
+                    SetParameter(parameterInfo, 
+                        EditorGUILayout.LayerField(parameterName, (int) GetParameter(parameterInfo, 0)));
+                    return true;
+                }
+                
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.IntField(parameterName, (int) GetParameter(parameterInfo, 0)));
+                return true;
+            }
+
+            if (type == typeof(float))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.FloatField(parameterName, (float) GetParameter(parameterInfo, 0f)));
+                return true;
+            }
+            
+            if (type == typeof(string))
+            {
+                string t = parameterName.ToLower();
+                if (t.Contains("password") || t.Contains("pswd") || t.Contains("passwd"))
+                {
+                    SetParameter(parameterInfo, 
+                        EditorGUILayout.PasswordField(parameterName, (string) GetParameter(parameterInfo, 0)));
+                    return true;
+                }
+                
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.TextField(parameterName, (string) GetParameter(parameterInfo, "")));
+                return true;
+            }
+            
+            if (type == typeof(bool))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.Toggle(parameterName, (bool) GetParameter(parameterInfo, false)));
+                return true;
+            }
+            
+            if (type == typeof(Quaternion))
+            {
+                Quaternion q = (Quaternion) GetParameter(parameterInfo, Quaternion.Euler(0, 0, 0));
+                Vector4 qv4 = new Vector4(q.x, q.y, q.z, q.w);
+                Vector4 v = EditorGUILayout.Vector4Field(parameterName, qv4);
+                SetParameter(parameterInfo, 
+                    new Quaternion(v.x, v.y, v.z, v.w));
+                return true;
+            }
+            
+            if (type == typeof(Vector4))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.Vector4Field(parameterName, (Vector4) GetParameter(parameterInfo, Vector4.zero)));
+                return true;
+            }
+            
+            if (type == typeof(Vector3))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.Vector3Field(parameterName, (Vector3) GetParameter(parameterInfo, Vector3.zero)));
+                return true;
+            }
+            
+            if (type == typeof(Vector2))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.Vector2Field(parameterName, (Vector2) GetParameter(parameterInfo, Vector2.zero)));
+                return true;
+            }
+            
+            if (type == typeof(Color))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.ColorField(parameterName, (Color) GetParameter(parameterInfo, Color.black)));
+                return true;
+            }
+            
+            if (type == typeof(Gradient))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.GradientField(parameterName, (Gradient) GetParameter(parameterInfo)));
+                return true;
+            }
+
+            if (type == typeof(Bounds))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.BoundsField(parameterName, (Bounds) GetParameter(parameterInfo)));
+                return true;
+            }
+            
+            if (type == typeof(AnimationCurve))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.CurveField(parameterName, (AnimationCurve) GetParameter(parameterInfo)));
+                return true;
+            }
+            
+            if (type == typeof(double))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.DoubleField(parameterName, (double) GetParameter(parameterInfo)));
+                return true;
+            }
+            
+            if (type == typeof(long))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.LongField(parameterName, (long) GetParameter(parameterInfo)));
+                return true;
+            }
+            
+            if (type == typeof(Rect))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.RectField(parameterName, (Rect) GetParameter(parameterInfo)));
+                return true;
+            }
+            
+            if (type == typeof(Transform))
+            {
+                SetParameter(parameterInfo, 
+                    EditorGUILayout.ObjectField(parameterName, (Transform) GetParameter(parameterInfo), typeof(Transform), true));
+                return true;
+            }
+            
+            GUILayout.Label(parameterName);
+            return false;
+        }
+
+        private void PrintReturnValue(MethodInfo methodInfo, object obj)
+        {
+            if (obj == null) return;
+
+            Type type = obj.GetType();
+
+            if (type == typeof(int) ||
+                type == typeof(float) ||
+                type == typeof(double) ||
+                type == typeof(string) ||
+                type == typeof(char) ||
+                type == typeof(long))
+            {
+                PrintReturnValueFormat(methodInfo, obj.ToString());
+                return;
+            }
+
+            if (type == typeof(Color))
+            {
+                Color v = (Color)obj;
+                PrintReturnValueFormat(methodInfo, $"argb:{v.a},{v.r},{v.g},{v.b}");
+                return;
+            }
+            
+            if (type == typeof(Vector2))
+            {
+                Vector2 v = (Vector2)obj;
+                PrintReturnValueFormat(methodInfo, $"xy:{v.x},{v.y}");
+                return;
+            }
+            
+            if (type == typeof(Vector3))
+            {
+                Vector3 v = (Vector3)obj;
+                PrintReturnValueFormat(methodInfo, $"xyz:{v.x},{v.y},{v.z}");
+                return;
+            }
+            
+            if (type == typeof(Vector4))
+            {
+                Vector4 v = (Vector4)obj;
+                PrintReturnValueFormat(methodInfo, $"xyzw:{v.x},{v.y},{v.z},{v.w}");
+                return;
+            }
+            
+            if (type == typeof(Quaternion))
+            {
+                Quaternion v = (Quaternion)obj;
+                Vector3 e = v.eulerAngles;
+                PrintReturnValueFormat(methodInfo, $"xyzw:{v.x},{v.y},{v.z},{v.w} euler:{e.x},{e.y},{e.z}");
+                return;
+            }
+        }
+
+        private void PrintReturnValueFormat(MethodInfo methodInfo, string value)
+        {
+            Debug.Log(methodInfo.Name + " Returned : ( " + methodInfo.ReturnType.Name + " ) " + value, _debugComponent);
+        }
+
+        private object GetParameter(ParameterInfo parameterInfo, object defaultValue = null)
+        {
+            if (_parameterCache.ContainsKey(parameterInfo))
+            {
+                if (_parameterCache[parameterInfo] == null && defaultValue != null)
+                {
+                    SetParameter(parameterInfo, defaultValue);
+                }
+                return _parameterCache[parameterInfo];
+            }
+
+            _parameterCache.Add(parameterInfo, defaultValue);
+            return defaultValue;
+        }
+        
+        private void SetParameter(ParameterInfo parameterInfo, object value)
+        {
+            if (_parameterCache.ContainsKey(parameterInfo))
+            {
+                _parameterCache[parameterInfo] = value;
+                return;
+            }
+
+            _parameterCache.Add(parameterInfo, value);
+        }
+
+        private bool GetFoldoutMethod(MethodInfo method)
+        {
+            if (_foldoutEnableMethod.ContainsKey(method))
+            {
+                return _foldoutEnableMethod[method];
+            }
+            
+            _foldoutEnableMethod.Add(method, false);
+            return false;
+        }
+        
+        private void SetFoldoutMethod(MethodInfo method, bool enable)
+        {
+            if (_foldoutEnableMethod.ContainsKey(method))
+            {
+                _foldoutEnableMethod[method] = enable;
+                return;
+            }
+            
+            _foldoutEnableMethod.Add(method, enable);
+        }
+    }
+}
+
+#endif
+\ No newline at end of file