BS 0.2.0 UI控件同步 / EP Unity.1 Diagram版本下的附属增强提案

Convention/[Runtime]/Architecture.cs

@@ -264,12 +264,8 @@ namespace Convention
             }
         }
 
-        public static Registering Register(Type slot, object target, Action completer, params Type[] dependences)
+        public static Registering RegisterWithDuplicateAllow(Type slot, object target, Action completer, params Type[] dependences)
         {
-            if (RegisterHistory.Add(slot) == false)
-            {
-                throw new InvalidOperationException("Illegal duplicate registrations");
-            }
             Completer[slot] = completer;
             UncompleteTargets[slot] = target;
             Dependences[slot] = new DependenceModel(from dependence in dependences where dependence != slot select new TypeQuery(dependence));
@@ -278,9 +274,18 @@ namespace Convention
             return new Registering(slot);
         }
 
+        public static Registering Register(Type slot, object target, Action completer, params Type[] dependences)
+        {
+            if (RegisterHistory.Add(slot) == false)
+            {
+                throw new InvalidOperationException("Illegal duplicate registrations");
+            }
+            return RegisterWithDuplicateAllow(slot, target, completer, dependences);
+        }
+
         public static Registering Register<T>(T target, Action completer, params Type[] dependences) => Register(typeof(T), target!, completer, dependences);
 
-        public static bool Contains(Type type) => Childs.ContainsKey(type);
+        public static bool Contains(Type type) => Childs.TryGetValue(type, out var value) && value != null;
 
         public static bool Contains<T>() => Contains(typeof(T));
 

Convention/[Runtime]/Camera.meta

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

Convention/[Runtime]/Camera/CameraInitializer.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Convention
+{
+    [RequireComponent(typeof(Camera))]
+    public class CameraInitializer : MonoBehaviour
+    {
+        [Setting, SerializeField] private List<SO.CameraInitializerConfig> Configs = new();
+
+        public void InitializeImmediate()
+        {
+            var camera = GetComponent<Camera>();
+            foreach (var config in Configs)
+            {
+                config.Invoke(camera);
+            }
+            DestroyImmediate(this);
+        }
+
+        private void Awake()
+        {
+            InitializeImmediate();
+        }
+
+        public static void InitializeImmediate(GameObject target)
+        {
+            if (target.GetComponents<CameraInitializer>().Length != 0)
+            {
+                foreach(var initer in target.GetComponents<CameraInitializer>())
+                    initer.InitializeImmediate();
+            }
+        }
+    }
+
+    namespace SO
+    {
+        public abstract class CameraInitializerConfig : ScriptableObject
+        {
+            public abstract void Invoke(Camera camera);
+        }
+    }
+}

Convention/[Runtime]/Camera/CameraInitializer.cs.meta

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

Convention/[Runtime]/Config.cs

@@ -4,11 +4,15 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading;
+using Convention.WindowsUI;
 using Sirenix.Utilities;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Events;
+using UnityEngine.SceneManagement;
+using UnityEngine.UI;
 
 namespace UnityEditor
 {
@@ -990,15 +994,18 @@ namespace Convention
 
     public static partial class ConventionUtility
     {
+        public static event Action InitExtensionEnvCalls;
+
 #if UNITY_EDITOR
         [UnityEditor.MenuItem("Convention/InitExtensionEnv", priority = 100000)]
 #endif
         public static void InitExtensionEnv()
         {
             UnityEngine.Application.quitting += () => CoroutineStarter = null;
-            
-            GlobalConfig.InitExtensionEnv();
 
+            InitExtensionEnvCalls();
+            GlobalConfig.InitExtensionEnv();
+            UnityExtension.InitExtensionEnv();
             ES3Plugin.InitExtensionEnv();
         }
 
@@ -1080,10 +1087,7 @@ namespace Convention
                 steps.Clear();
             }
         }
-        /// <summary>
+
-        /// <20><>Ҫ<EFBFBD><D2AA><EFBFBD>շ<EFBFBD><D5B7><EFBFBD>ֵ, <20><><EFBFBD><EFBFBD><EFBFBD>ӳٵ<D3B3>Wrapper<65><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-        /// </summary>
-        /// <returns></returns>
         [return: ReturnNotSelf]
         public static ActionStepCoroutineWrapper CreateSteps() => new();
 
@@ -1355,4 +1359,748 @@ namespace Convention
             return result;
         }
     }
-}
+
+    public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
+    {
+
+        [Setting, Ignore] private static T m_instance;
+        public static T instance { get => m_instance; protected set => m_instance = value; }
+        public virtual bool IsDontDestroyOnLoad { get => false; }
+
+        protected virtual void Awake()
+        {
+            if (instance != null)
+            {
+                this.gameObject.SetActive(false);
+                return;
+            }
+            if (IsDontDestroyOnLoad && this.transform.parent == null)
+                DontDestroyOnLoad(this);
+            instance = (T)this;
+        }
+
+        public static bool IsAvailable()
+        {
+            return instance != null;
+        }
+    }
+}
+
+namespace Convention
+{
+    public static class UnityExtension
+    {
+        public static void InitExtensionEnv()
+        {
+            AsyncOperationExtension.InitExtensionEnv();
+            RectTransformExtension.InitExtensionEnv();
+        }
+    }
+
+    public static class AsyncOperationExtension
+    {
+        public static void InitExtensionEnv()
+        {
+            CompletedHelper.InitExtensionEnv();
+        }
+        public static void MarkCompleted(this AsyncOperation operation, [In] Action action)
+        {
+            operation.completed += new CompletedHelper(action).InternalCompleted;
+        }
+
+        private class CompletedHelper
+        {
+            static CompletedHelper() => helpers = new();
+            public static void InitExtensionEnv() => helpers.Clear();
+            private static readonly List<CompletedHelper> helpers = new();
+
+            readonly Action action;
+
+            public CompletedHelper([In] Action action)
+            {
+                helpers.Add(this);
+                this.action = action;
+            }
+            ~CompletedHelper()
+            {
+                helpers.Remove(this);
+            }
+
+            public void InternalCompleted(AsyncOperation obj)
+            {
+                if (obj.progress < 0.99f) return;
+                action.Invoke();
+                helpers.Remove(this);
+            }
+
+        }
+    }
+
+    public static partial class RectTransformExtension
+    {
+        private static bool IsDisableAdjustSizeToContainsChilds2DeferUpdates = false;
+
+
+        public static void InitExtensionEnv()
+        {
+            IsDisableAdjustSizeToContainsChilds2DeferUpdates = false;
+        }
+
+        public class AdjustSizeIgnore : MonoBehaviour { }
+#if UNITY_EDITOR
+        [UnityEditor.MenuItem("Convention/DisableAdjustSize", priority = 100000)]
+#endif
+        public static void DisableAdjustSizeToContainsChilds2DeferUpdates()
+        {
+            IsDisableAdjustSizeToContainsChilds2DeferUpdates = true;
+        }
+#if UNITY_EDITOR
+        [UnityEditor.MenuItem("Convention/EnableAdjustSize", priority = 100000)]
+#endif
+        public static void AppleAndEnableAdjustSizeToContainsChilds()
+        {
+            IsDisableAdjustSizeToContainsChilds2DeferUpdates = false;
+        }
+        public static void AdjustSizeToContainsChilds([In] RectTransform rectTransform, Vector2 min, Vector2 max, RectTransform.Axis? axis)
+        {
+            if (IsDisableAdjustSizeToContainsChilds2DeferUpdates)
+                return;
+            LayoutRebuilder.ForceRebuildLayoutImmediate(rectTransform);
+
+            bool stats = false;
+
+            List<RectTransform> currentList = new(), nextList = new();
+            var corners = new Vector3[4];
+            foreach (RectTransform item in rectTransform)
+            {
+                currentList.Add(item);
+            }
+            do
+            {
+                currentList.AddRange(nextList);
+                nextList.Clear();
+                foreach (RectTransform childTransform in currentList)
+                {
+                    if (childTransform.gameObject.activeInHierarchy == false)
+                        continue;
+                    if (childTransform.name.ToLower().Contains("<ignore rect>"))
+                        continue;
+                    if (childTransform.name.ToLower().Contains($"<ignore {nameof(AdjustSizeToContainsChilds)}>"))
+                        continue;
+                    if (childTransform.GetComponents<AdjustSizeIgnore>().Length != 0)
+                        continue;
+                    stats = true;
+                    foreach (RectTransform item in childTransform)
+                    {
+                        nextList.Add(item);
+                    }
+                    childTransform.GetWorldCorners(corners);
+                    foreach (var corner in corners)
+                    {
+                        Vector2 localCorner = rectTransform.InverseTransformPoint(corner);
+                        if (float.IsNaN(localCorner.x) || float.IsNaN(localCorner.y))
+                            break;
+                        min.x = Mathf.Min(min.x, localCorner.x);
+                        min.y = Mathf.Min(min.y, localCorner.y);
+                        max.x = Mathf.Max(max.x, localCorner.x);
+                        max.y = Mathf.Max(max.y, localCorner.y);
+                    }
+                }
+                currentList.Clear();
+            } while (nextList.Count > 0);
+            if (stats)
+            {
+                if ((axis.HasValue && axis.Value == RectTransform.Axis.Vertical) ||
+                    (rectTransform.anchorMin.x == 0 && rectTransform.anchorMax.x == 1 && rectTransform.anchorMin.y == rectTransform.anchorMax.y))
+                {
+                    rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, max.y - min.y);
+                }
+                else if ((axis.HasValue && axis.Value == RectTransform.Axis.Horizontal) ||
+                    (rectTransform.anchorMin.y == 0 && rectTransform.anchorMax.y == 1 && rectTransform.anchorMin.x == rectTransform.anchorMax.x))
+                {
+                    rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, max.x - min.x);
+                }
+                else
+                {
+                    rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, max.x - min.x);
+                    rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, max.y - min.y);
+                }
+            }
+        }
+        public static void AdjustSizeToContainsChilds([In] RectTransform rectTransform, RectTransform.Axis axis)
+        {
+            if (IsDisableAdjustSizeToContainsChilds2DeferUpdates)
+                return;
+            Vector2 min = new Vector2(float.MaxValue, float.MaxValue);
+            Vector2 max = new Vector2(float.MinValue, float.MinValue);
+
+            AdjustSizeToContainsChilds(rectTransform, min, max, axis);
+        }
+        public static void AdjustSizeToContainsChilds([In] RectTransform rectTransform)
+        {
+            if (IsDisableAdjustSizeToContainsChilds2DeferUpdates)
+                return;
+            Vector2 min = new Vector2(float.MaxValue, float.MaxValue);
+            Vector2 max = new Vector2(float.MinValue, float.MinValue);
+
+            AdjustSizeToContainsChilds(rectTransform, min, max, null);
+        }
+
+        internal static void SetParentAndResizeWithoutNotifyBaseWindowPlane([In] RectTransform parent, [In] RectTransform child, Rect rect, bool isAdjustSizeToContainsChilds)
+        {
+            child.SetParent(parent, false);
+            child.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Left, rect.x, rect.width);
+            child.SetInsetAndSizeFromParentEdge(RectTransform.Edge.Top, rect.y, rect.height);
+            if (isAdjustSizeToContainsChilds)
+                AdjustSizeToContainsChilds(parent);
+        }
+        internal static void SetParentAndResizeWithoutNotifyBaseWindowPlane(RectTransform parent, RectTransform child, bool isAdjustSizeToContainsChilds)
+        {
+            child.SetParent(parent, false);
+            if (isAdjustSizeToContainsChilds)
+                AdjustSizeToContainsChilds(parent);
+        }
+        public static void SetParentAndResize(RectTransform parent, RectTransform child, Rect rect, bool isAdjustSizeToContainsChilds)
+        {
+            if (parent.GetComponents<BaseWindowPlane>().Length != 0)
+            {
+                parent.GetComponents<BaseWindowPlane>()[0].AddChild(child, rect, isAdjustSizeToContainsChilds);
+            }
+            else
+            {
+                SetParentAndResizeWithoutNotifyBaseWindowPlane(parent, child, rect, isAdjustSizeToContainsChilds);
+            }
+        }
+        public static void SetParentAndResize(RectTransform parent, RectTransform child, bool isAdjustSizeToContainsChilds)
+        {
+            if (parent.GetComponents<BaseWindowPlane>().Length != 0)
+            {
+                parent.GetComponents<BaseWindowPlane>()[0].AddChild(child, isAdjustSizeToContainsChilds);
+            }
+            else
+            {
+                SetParentAndResizeWithoutNotifyBaseWindowPlane(parent, child, isAdjustSizeToContainsChilds);
+            }
+        }
+
+        public static bool IsVisible([In] RectTransform rectTransform, [In, Opt] Camera camera = null)
+        {
+            if (camera == null)
+                camera = Camera.main;
+            Transform camTransform = camera.transform;
+            Vector3[] corners = new Vector3[4];
+            rectTransform.GetWorldCorners(corners);
+            foreach (var worldPos in corners)
+            {
+                Vector2 viewPos = camera.WorldToViewportPoint(worldPos);
+                Vector3 dir = (worldPos - camTransform.position).normalized;
+                float dot = Vector3.Dot(camTransform.forward, dir);
+
+                if (dot <= 0 || viewPos.x < 0 || viewPos.x > 1 || viewPos.y < 0 || viewPos.y > 1)
+                    return false;
+            }
+            return true;
+        }
+    }
+
+    public static partial class SkyExtension
+    {
+        public static Material GetSky()
+        {
+            return RenderSettings.skybox;
+        }
+
+        public static void Load([In][Opt, When("If you sure")] Material skybox)
+        {
+            RenderSettings.skybox = skybox;
+        }
+
+        public static void Rotation(float angle)
+        {
+            RenderSettings.skybox.SetFloat("_Rotation", angle);
+        }
+    }
+
+    public static partial class SceneExtension
+    {
+        public static void Load(string name)
+        {
+            SceneManager.LoadScene(name, LoadSceneMode.Additive);
+        }
+        public static void Load(string name, out AsyncOperation async)
+        {
+            async = SceneManager.LoadSceneAsync(name, LoadSceneMode.Additive);
+        }
+        public static void Unload(string name)
+        {
+            SceneManager.UnloadSceneAsync(name);
+        }
+        public static Scene GetScene(string name)
+        {
+            return SceneManager.GetSceneByName(name);
+        }
+    }
+
+    public static class GameObjectExtension
+    {
+        /// <summary>
+        /// 递归设置GameObject及其所有子物体的Layer
+        /// </summary>
+        public static void SetLayerRecursively(GameObject gameObject, int layer)
+        {
+            gameObject.layer = layer;
+            foreach (Transform t in gameObject.transform)
+            {
+                SetLayerRecursively(t.gameObject, layer);
+            }
+        }
+
+        /// <summary>
+        /// 递归设置GameObject及其所有子物体的Tag
+        /// </summary>
+        public static void SetTagRecursively(GameObject gameObject, string tag)
+        {
+            gameObject.tag = tag;
+            foreach (Transform t in gameObject.transform)
+            {
+                SetTagRecursively(t.gameObject, tag);
+            }
+        }
+
+        /// <summary>
+        /// 递归启用/禁用所有Collider组件
+        /// </summary>
+        public static void SetCollisionRecursively(GameObject gameObject, bool enabled)
+        {
+            var colliders = gameObject.GetComponentsInChildren<Collider>();
+            foreach (var collider in colliders)
+            {
+                collider.enabled = enabled;
+            }
+        }
+
+        /// <summary>
+        /// 递归启用/禁用所有Renderer组件
+        /// </summary>
+        public static void SetVisualRecursively(GameObject gameObject, bool enabled)
+        {
+            var renderers = gameObject.GetComponentsInChildren<Renderer>();
+            foreach (var renderer in renderers)
+            {
+                renderer.enabled = enabled;
+            }
+        }
+
+        /// <summary>
+        /// 获取指定Tag的所有子组件
+        /// </summary>
+        public static T[] GetComponentsInChildrenWithTag<T>(GameObject gameObject, string tag) where T : Component
+        {
+            List<T> results = new List<T>();
+
+            if (gameObject.CompareTag(tag))
+            {
+                var component = gameObject.GetComponent<T>();
+                if (component != null)
+                    results.Add(component);
+            }
+
+            foreach (Transform t in gameObject.transform)
+            {
+                results.AddRange(GetComponentsInChildrenWithTag<T>(t.gameObject, tag));
+            }
+
+            return results.ToArray();
+        }
+
+        /// <summary>
+        /// 在父物体中查找组件
+        /// </summary>
+        public static T GetComponentInParents<T>(GameObject gameObject) where T : Component
+        {
+            for (Transform t = gameObject.transform; t != null; t = t.parent)
+            {
+                T result = t.GetComponent<T>();
+                if (result != null)
+                    return result;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 获取或添加组件
+        /// </summary>
+        public static T GetOrAddComponent<T>(GameObject gameObject) where T : Component
+        {
+            T component = gameObject.GetComponent<T>();
+            return component ?? gameObject.AddComponent<T>();
+        }
+    }
+
+    public static class TransformExtension
+    {
+        /// <summary>
+        /// 获取所有子物体
+        /// </summary>
+        public static List<Transform> GetAllChildren(this Transform transform)
+        {
+            List<Transform> children = new List<Transform>();
+            foreach (Transform child in transform)
+            {
+                children.Add(child);
+                children.AddRange(child.GetAllChildren());
+            }
+            return children;
+        }
+
+        /// <summary>
+        /// 销毁所有子物体
+        /// </summary>
+        public static void DestroyAllChildren(this Transform transform)
+        {
+            for (int i = transform.childCount - 1; i >= 0; i--)
+            {
+                UnityEngine.Object.Destroy(transform.GetChild(i).gameObject);
+            }
+        }
+
+        /// <summary>
+        /// 设置父物体并保持世界坐标
+        /// </summary>
+        public static void SetParentKeepWorldPosition(this Transform transform, Transform parent)
+        {
+            Vector3 worldPos = transform.position;
+            Quaternion worldRot = transform.rotation;
+            transform.SetParent(parent);
+            transform.position = worldPos;
+            transform.rotation = worldRot;
+        }
+    }
+
+    public static class CoroutineExtension
+    {
+        /// <summary>
+        /// 延迟执行
+        /// </summary>
+        public static IEnumerator Delay(float delay, Action action)
+        {
+            yield return new WaitForSeconds(delay);
+            action?.Invoke();
+        }
+
+        /// <summary>
+        /// 延迟执行并返回结果
+        /// </summary>
+        public static IEnumerator Delay<T>(float delay, Func<T> action, Action<T> callback)
+        {
+            yield return new WaitForSeconds(delay);
+            callback?.Invoke(action());
+        }
+
+        /// <summary>
+        /// 等待直到条件满足
+        /// </summary>
+        public static IEnumerator WaitUntil(Func<bool> condition, Action onComplete = null)
+        {
+            yield return new WaitUntil(condition);
+            onComplete?.Invoke();
+        }
+
+        /// <summary>
+        /// 等待直到条件满足，带超时
+        /// </summary>
+        public static IEnumerator WaitUntil(Func<bool> condition, float timeout, Action onComplete = null, Action onTimeout = null)
+        {
+            float elapsedTime = 0;
+            while (!condition() && elapsedTime < timeout)
+            {
+                elapsedTime += Time.deltaTime;
+                yield return null;
+            }
+
+            if (elapsedTime >= timeout)
+            {
+                onTimeout?.Invoke();
+            }
+            else
+            {
+                onComplete?.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// 执行动画曲线
+        /// </summary>
+        public static IEnumerator Animate(float duration, AnimationCurve curve, Action<float> onUpdate)
+        {
+            float elapsedTime = 0;
+            while (elapsedTime < duration)
+            {
+                elapsedTime += Time.deltaTime;
+                float normalizedTime = elapsedTime / duration;
+                float evaluatedValue = curve.Evaluate(normalizedTime);
+                onUpdate?.Invoke(evaluatedValue);
+                yield return null;
+            }
+            onUpdate?.Invoke(curve.Evaluate(1));
+        }
+
+        /// <summary>
+        /// 执行线性插值
+        /// </summary>
+        public static IEnumerator Lerp<T>(T start, T end, float duration, Action<T> onUpdate, Func<T, T, float, T> lerpFunction)
+        {
+            float elapsedTime = 0;
+            while (elapsedTime < duration)
+            {
+                elapsedTime += Time.deltaTime;
+                float normalizedTime = elapsedTime / duration;
+                T current = lerpFunction(start, end, normalizedTime);
+                onUpdate?.Invoke(current);
+                yield return null;
+            }
+            onUpdate?.Invoke(end);
+        }
+
+        /// <summary>
+        /// 执行Vector3插值
+        /// </summary>
+        public static IEnumerator LerpVector3(Vector3 start, Vector3 end, float duration, Action<Vector3> onUpdate)
+        {
+            yield return Lerp(start, end, duration, onUpdate, Vector3.Lerp);
+        }
+
+        /// <summary>
+        /// 执行Quaternion插值
+        /// </summary>
+        public static IEnumerator LerpQuaternion(Quaternion start, Quaternion end, float duration, Action<Quaternion> onUpdate)
+        {
+            yield return Lerp(start, end, duration, onUpdate, Quaternion.Lerp);
+        }
+
+        /// <summary>
+        /// 执行float插值
+        /// </summary>
+        public static IEnumerator LerpFloat(float start, float end, float duration, Action<float> onUpdate)
+        {
+            yield return Lerp(start, end, duration, onUpdate, Mathf.Lerp);
+        }
+    }
+
+    public static class ScriptingDefineUtility
+    {
+#if UNITY_EDITOR
+        public static void Add(string define, BuildTargetGroup target, bool log = false)
+        {
+            string definesString = PlayerSettings.GetScriptingDefineSymbolsForGroup(target);
+            if (definesString.Contains(define)) return;
+            string[] allDefines = definesString.Split(';');
+            ArrayUtility.Add(ref allDefines, define);
+            definesString = string.Join(";", allDefines);
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(target, definesString);
+            Debug.Log("Added \"" + define + "\" from " + EditorUserBuildSettings.selectedBuildTargetGroup + " Scripting define in Player Settings");
+        }
+
+        public static void Remove(string define, BuildTargetGroup target, bool log = false)
+        {
+            string definesString = PlayerSettings.GetScriptingDefineSymbolsForGroup(target);
+            if (!definesString.Contains(define)) return;
+            string[] allDefines = definesString.Split(';');
+            ArrayUtility.Remove(ref allDefines, define);
+            definesString = string.Join(";", allDefines);
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(target, definesString);
+            Debug.Log("Removed \"" + define + "\" from " + EditorUserBuildSettings.selectedBuildTargetGroup + " Scripting define in Player Settings");
+        }
+#endif
+    }
+}
+
+namespace Convention
+{
+    public static class StringExtension
+    {
+        public static void InitExtensionEnv()
+        {
+            CurrentStringTransformer = null;
+            MyLazyTransformer.Clear();
+        }
+
+        public static string LimitString([In] object data, int maxLength = 50)
+        {
+            return LimitString(data.ToString(), maxLength);
+        }
+        public static string LimitString([In] in string data, int maxLength = 50)
+        {
+            if (data.Length <= maxLength)
+                return data;
+            var insideStr = "\n...\n...\n";
+            int headLength = maxLength / 2;
+            int tailLength = maxLength - headLength - insideStr.Length;
+            return data[..headLength] + insideStr + data[^tailLength..];
+        }
+
+        public enum Side
+        {
+            Left,
+            Right,
+            Center
+        }
+        public static string FillString([In] object data, int maxLength = 50, char fillChar = ' ', Side side = Side.Right)
+        {
+            return FillString(data.ToString(), maxLength, fillChar, side);
+        }
+        public static string FillString([In] in string data, int maxLength = 50, char fillChar = ' ', Side side = Side.Right)
+        {
+            if (data.Length >= maxLength)
+                return data;
+            var fillStr = new string(fillChar, maxLength - data.Length);
+            switch (side)
+            {
+                case Side.Left:
+                    return fillStr + data;
+                case Side.Right:
+                    return data + fillStr;
+                case Side.Center:
+                    int leftLength = (maxLength - data.Length) / 2;
+                    int rightLength = maxLength - leftLength - data.Length;
+                    return new string(fillChar, leftLength) + data + new string(fillChar, rightLength);
+                default:
+                    return data;
+            }
+        }
+
+        public static List<string> BytesToStrings([In] IEnumerable<byte[]> bytes)
+        {
+            return BytesToStrings(bytes, Encoding.UTF8);
+        }
+        public static List<string> BytesToStrings([In] IEnumerable<byte[]> bytes, Encoding encoding)
+        {
+            return bytes.ToList().ConvertAll(x => encoding.GetString(x));
+        }
+
+        private static Dictionary<string, string> MyLazyTransformer = new();
+
+        public class StringTransformer
+        {
+            [Serializable, ArgPackage]
+            public class StringContentTree
+            {
+                public string leaf = null;
+                public Dictionary<string, StringContentTree> branch = null;
+            }
+
+            private StringContentTree contents;
+
+            public StringTransformer([In] string transformerFile)
+            {
+                var file = new ToolFile(transformerFile);
+                contents = file.LoadAsRawJson<StringContentTree>();
+            }
+
+            public string Transform([In] string stringName)
+            {
+                if (contents == null || contents.branch == null)
+                    return stringName;
+                var keys = stringName.Split('.');
+                StringContentTree current = contents;
+                foreach (var k in keys)
+                {
+                    if (current.branch != null && current.branch.TryGetValue(k, out var next))
+                    {
+                        current = next;
+                    }
+                    else
+                    {
+                        return stringName; // If any key is not found, return the original key
+                    }
+                }
+                return current.leaf ?? stringName; // Return leaf or original key if leaf is null
+            }
+        }
+
+        private static StringTransformer MyCurrentStringTransformer = null;
+        public static StringTransformer CurrentStringTransformer
+        {
+            get => MyCurrentStringTransformer;
+            set
+            {
+                if (MyCurrentStringTransformer != value)
+                {
+                    MyLazyTransformer.Clear();
+                    MyCurrentStringTransformer = value;
+                }
+            }
+        }
+
+        public static string Transform([In] string stringName)
+        {
+            if (MyLazyTransformer.TryGetValue(stringName, out var result))
+                return result;
+            return MyLazyTransformer[stringName] = CurrentStringTransformer != null
+                ? CurrentStringTransformer.Transform(stringName)
+                : stringName;
+        }
+    }
+}
+
+namespace Convention
+{
+    [ArgPackage]
+    public class ValueWrapper
+    {
+        private Func<object> getter;
+        private Action<object> setter;
+        public readonly Type type;
+
+        public ValueWrapper([In, Opt] Func<object> getter, [In, Opt] Action<object> setter, [In] Type type)
+        {
+            this.getter = getter;
+            this.setter = setter;
+            this.type = type;
+        }
+
+        public bool IsChangeAble => setter != null;
+        public bool IsObtainAble => getter != null;
+
+        public void SetValue(object value)
+        {
+            setter(value);
+        }
+        public object GetValue()
+        {
+            return getter();
+        }
+    }
+}
+
+namespace Convention
+{
+    public static class TextureExtenion
+    {
+        public static Texture2D CropTexture(this Texture texture, Rect source)
+        {
+            RenderTexture active = RenderTexture.active;
+            RenderTexture renderTexture = (RenderTexture.active = RenderTexture.GetTemporary(texture.width, texture.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default, 8));
+            bool sRGBWrite = GL.sRGBWrite;
+            GL.sRGBWrite = false;
+            GL.Clear(clearDepth: false, clearColor: true, new Color(1f, 1f, 1f, 0f));
+            Graphics.Blit(texture, renderTexture);
+            Texture2D texture2D = new Texture2D((int)source.width, (int)source.height, TextureFormat.ARGB32, mipChain: true, linear: false);
+            texture2D.filterMode = FilterMode.Point;
+            texture2D.ReadPixels(source, 0, 0);
+            texture2D.Apply();
+            GL.sRGBWrite = sRGBWrite;
+            RenderTexture.active = active;
+            RenderTexture.ReleaseTemporary(renderTexture);
+            return texture2D;
+        }
+        public static Texture2D CopyTexture(this Texture texture)
+        {
+            return CropTexture(texture, new(0, 0, texture.width, texture.height));
+        }
+        public static Sprite ToSprite(this Texture2D texture)
+        {
+            return Sprite.Create(texture, new(0, 0, texture.width, texture.height), new(0.5f, 0.5f));
+        }
+    }
+}

Convention/[Runtime]/File.cs

@@ -39,6 +39,11 @@ namespace Convention
     [Serializable]
     public sealed class ToolFile
     {
+        public static string[] TextFileExtensions = new string[] { "txt", "ini", "manifest" };
+        public static string[] AudioFileExtension = new string[] { "ogg", "mp2", "mp3", "mod", "wav", "it" };
+        public static string[] ImageFileExtension = new string[] { "png", "jpg", "jpeg", "bmp", "tif", "icon" };
+        public static string[] AssetBundleExtension = new string[] { "AssetBundle", "AssetBundle".ToLower(), "ab" };
+        public static string[] JsonExtension = new string[] { "json" };
         public static AudioType GetAudioType(string path)
         {
             return Path.GetExtension(path) switch
@@ -370,6 +375,21 @@ namespace Convention
             throw new InvalidOperationException();
         }
 
+        public bool ExtensionIs(params string[] extensions)
+        {
+            string el = GetExtension().ToLower();
+            string eln = el.Length > 1 ? el[1..] : null;
+            foreach (string extension in extensions)
+                if (el == extension || eln == extension)
+                    return true;
+            return false;
+        }
+        public bool IsText => this.ExtensionIs(TextFileExtensions);
+        public bool IsJson => this.ExtensionIs(JsonExtension);
+        public bool IsImage => this.ExtensionIs(ImageFileExtension);
+        public bool IsAudio => this.ExtensionIs(AudioFileExtension);
+        public bool IsAssetBundle => this.ExtensionIs(AssetBundleExtension);
+
         #endregion
 
         #region Size and Properties

Convention/[Runtime]/Plugins/Plugin.cs

@@ -20,6 +20,7 @@ namespace Convention
             var results = WindowsKit.SelectMultipleFiles(filter, title);
             if (results != null && results.Length > 0)
                 return results[0];
+            return null;
 #else           
             throw new NotImplementedException();
 #endif

Convention/[SO].meta

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

Convention/[SO]/ScriptableObject.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Convention
+{
+    [CreateAssetMenu(fileName = "new Convention", menuName = "Convention/Convention", order = -1)]
+    [Serializable, ArgPackage]
+    public class ScriptableObject : UnityEngine.ScriptableObject
+    {
+        [return: ReturnNotNull]
+        public string SymbolName()
+        {
+            return "Convention." + nameof(ScriptableObject);
+        }
+
+        public SerializedDictionary<string, UnityEngine.Object> uobjects = new();
+        public SerializedDictionary<string, string> symbols = new();
+        public SerializedDictionary<string, float> values = new();
+
+        public T FindItem<T>(string key, T defaultValue = default)
+        {
+            var typen = typeof(T);
+            if (typen.IsSubclassOf(typeof(UnityEngine.Object)))
+            {
+                if (uobjects.TryGetValue(key, out var uobj) && uobj is T uobj_r)
+                    return uobj_r;
+            }
+            else if (typen.IsSubclassOf(typeof(string)))
+            {
+                if (symbols.TryGetValue(key, out var str) && str is T str_r)
+                    return str_r;
+            }
+            else if (typen.IsSubclassOf(typeof(float)))
+            {
+                if (values.TryGetValue(key, out var fvalue) && fvalue is T fvalue_r)
+                    return fvalue_r;
+            }
+            else if (typen.IsSubclassOf(typeof(int)))
+            {
+                if (values.TryGetValue(key, out var ivalue) && ((int)ivalue) is T ivalue_r)
+                    return ivalue_r;
+            }
+            else if (typen.IsSubclassOf(typeof(bool)))
+            {
+                if (values.TryGetValue(key, out var bvalue) && (bvalue != 0) is T bvalue_r)
+                    return bvalue_r;
+            }
+            return defaultValue;
+        }
+
+        public virtual void Reset()
+        {
+            uobjects.Clear();
+            values.Clear();
+            symbols.Clear();
+        }
+    }
+}

Convention/[SO]/ScriptableObject.cs.meta

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

Convention/[Visual]/Operater/BehaviourContextManager.cs

@@ -0,0 +1,342 @@
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+
+namespace Convention.WindowsUI
+{
+    public interface IBehaviourOperator { }
+
+    /// <summary>
+    /// 禁止在Awake时刻使用BehaviourContext
+    /// </summary>
+    public class BehaviourContextManager : MonoBehaviour, ICanvasRaycastFilter
+    {
+        public static UnityEvent<PointerEventData> InitializeContextSingleEvent(UnityEvent<PointerEventData> Event, params UnityAction<PointerEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+            return Event;
+        }
+        public static UnityEvent<BaseEventData> InitializeContextSingleEvent(UnityEvent<BaseEventData> Event, params UnityAction<BaseEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+            return Event;
+        }
+        public static UnityEvent<AxisEventData> InitializeContextSingleEvent(UnityEvent<AxisEventData> Event, params UnityAction<AxisEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+            return Event;
+        }
+
+        public static void InitializeContextSingleEvent(ref UnityEvent<PointerEventData> Event, params UnityAction<PointerEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+        }
+        public static void InitializeContextSingleEvent(ref UnityEvent<BaseEventData> Event, params UnityAction<BaseEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+        }
+        public static void InitializeContextSingleEvent(ref UnityEvent<AxisEventData> Event, params UnityAction<AxisEventData>[] calls)
+        {
+            Event ??= new();
+            foreach (var call in calls)
+                Event.RemoveListener(call);
+            foreach (var call in calls)
+                Event.AddListener(call);
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnBeginDragEvent
+        {
+            get
+            {
+                if (!TryGetComponent<BaseBeginDragBehaviour>(out var cat)) return null;
+                return cat.OnBeginDragEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseBeginDragBehaviour>();
+                cat.OnBeginDragEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnDragEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseDragBehaviour>(out var cat)) return null;
+                return cat.OnDragEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseDragBehaviour>();
+                cat.OnDragEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnDropEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseDropBehaviour>(out var cat)) return null;
+                return cat.OnDropEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseDropBehaviour>();
+                cat.OnDropEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnEndDragEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseEndDragBehaviour>(out var cat)) return null;
+                return cat.OnEndDragEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseEndDragBehaviour>();
+                cat.OnEndDragEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnInitializePotentialDragEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseInitializePotentialDragBehaviour>(out var cat))
+                    return null;
+                return cat.OnInitializePotentialDragEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseInitializePotentialDragBehaviour>();
+                cat.OnInitializePotentialDragEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnPointerClickEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BasePointerClickBehaviour>(out var cat))
+                    return null;
+                return cat.OnPointerClickEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BasePointerClickBehaviour>();
+                cat.OnPointerClickEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnPointerDownEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BasePointerDownBehaviour>(out var cat))
+                    return null;
+                return cat.OnPointerDownEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BasePointerDownBehaviour>();
+                cat.OnPointerDownEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnPointerEnterEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BasePointerEnterBehaviour>(out var cat))
+                    return null;
+                return cat.OnPointerEnterEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BasePointerEnterBehaviour>();
+                cat.OnPointerEnterEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnPointerExitEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BasePointerExitBehaviour>(out var cat))
+                    return null;
+                return cat.OnPointerExitEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BasePointerExitBehaviour>();
+                cat.OnPointerExitEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnPointerUpEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BasePointerUpBehaviour>(out var cat))
+                    return null;
+                return cat.OnPointerUpEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BasePointerUpBehaviour>();
+                cat.OnPointerUpEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<PointerEventData> OnScrollEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseScrollBehaviour>(out var cat))
+                    return null;
+                return cat.OnScrollEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseScrollBehaviour>();
+                cat.OnScrollEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<BaseEventData> OnCancelEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseCancelBehaviour>(out var cat))
+                    return null;
+                return cat.OnCancelEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseCancelBehaviour>();
+                cat.OnCancelEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<BaseEventData> OnDeselectEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseDeselectBehaviour>(out var cat))
+                    return null;
+                return cat.OnDeselectEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseDeselectBehaviour>();
+                cat.OnDeselectEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<BaseEventData> OnSelectEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseSelectBehaviour>(out var cat))
+                    return null;
+                return cat.OnSelectEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseSelectBehaviour>();
+                cat.OnSelectEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<BaseEventData> OnSubmitEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseSubmitBehaviour>(out var cat))
+                    return null;
+                return cat.OnSubmitEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseSubmitBehaviour>();
+                cat.OnSubmitEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<BaseEventData> OnUpdateSelectedEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseUpdateSelectedBehaviour>(out var cat))
+                    return null;
+                return cat.OnUpdateSelectedEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseUpdateSelectedBehaviour>();
+                cat.OnUpdateSelectedEvent = value;
+            }
+        }
+        [Setting]
+        public UnityEvent<AxisEventData> OnMoveEvent
+        {
+            get
+            {
+                if (!this.TryGetComponent<BaseMoveBehaviour>(out var cat))
+                    return null;
+                return cat.OnMoveEvent;
+            }
+            set
+            {
+                var cat = this.GetOrAddComponent<BaseMoveBehaviour>();
+                cat.OnMoveEvent = value;
+            }
+        }
+
+        public delegate bool HowSetupRaycastLocationValid(Vector2 sp, Camera eventCamera);
+        [Ignore]public HowSetupRaycastLocationValid locationValid;
+
+        public bool IsRaycastLocationValid(Vector2 sp, Camera eventCamera)
+        {
+            return locationValid?.Invoke(sp, eventCamera) ?? true;
+        }
+
+        private void Awake()
+        {
+            foreach (var item in GetComponents<IBehaviourOperator>())
+            {
+                Destroy(item as MonoBehaviour);
+            }
+        }
+        private void OnDestroy()
+        {
+            foreach (var item in GetComponents<IBehaviourOperator>())
+            {
+                Destroy(item as MonoBehaviour);
+            }
+        }
+    }
+}
+

Convention/[Visual]/Operater/BehaviourContextManager.cs.meta

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

Convention/[Visual]/UIComponent/ModuleInterfaces.cs

@@ -58,17 +58,17 @@ namespace Convention.WindowsUI
         }
     }
 
-    public interface IText : IAnyClass
+    public interface IText 
     {
         string text { get; set; }
     }
 
-    public interface ITitle : IAnyClass
+    public interface ITitle 
     {
         string title { get; set; }
     }
 
-    public interface IInteractable : IAnyClass
+    public interface IInteractable
     {
         bool interactable { get; set; }
     }

Convention/[Visual]/UIComponent/SO.meta

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

Convention/[Visual]/UIComponent/SO/Windows.cs

@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Convention.WindowsUI;
+using UnityEngine;
+
+namespace Convention.SO
+{
+    [CreateAssetMenu(fileName = "new WindowsConfig", menuName = "Convention/WindowsConfig", order = 200)]
+    public class Windows : ScriptableObject
+    {
+        public static string GlobalWindowsConfig = "WindowConfig";
+        public static Windows GlobalInstance => Resources.Load<Windows>(GlobalWindowsConfig);
+
+        public static void InitExtensionEnv()
+        {
+            default_exist_names = GetDefaultNames();
+#if CONVENTION_DISABLE_WINDOWSO_GLOBAL_INIT
+            GlobalWindowsConfig = "WindowConfig";
+#endif
+        }
+        public static string[] GetDefaultNames()
+        {
+            List<string> names = new();
+            foreach (var item in Assembly.GetAssembly(typeof(Windows)).GetTypes())
+            {
+                if (item.IsSubclassOf(typeof(WindowsComponent)) ||
+                    (item.IsInterface == false && item.GetInterface(nameof(IWindowUIModule)) != null)
+                    )
+                {
+                    names.Add(item.Name);
+                }
+            }
+            names.Add(nameof(WindowManager));
+            names.Remove(nameof(WindowUIModule));
+            return names.ToArray();
+        }
+        private static string[] default_exist_names = GetDefaultNames();
+
+        private void OnEnable()
+        {
+            Reset();
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            foreach (string name in default_exist_names)
+            {
+                var resourcesArray = Resources.LoadAll(name);
+                foreach (var item in resourcesArray)
+                {
+                    if (item is not GameObject)
+                        continue;
+                    if((item as GameObject).GetComponents<MonoBehaviour>().Length == 0)
+                        continue;
+                    this.uobjects[name] = item;
+                    break;
+                }
+            }
+        }
+
+        [return: When("Datas's keys contains [In]name"), ReturnMayNull]
+        public WindowsComponent[] GetWindowsComponents([In] string name)
+        {
+            if (this.uobjects.TryGetValue(name, out var uobj))
+            {
+                var go = (uobj as GameObject);
+                return go.GetComponents<WindowsComponent>();
+            }
+            else return null;
+        }
+        [return: When("Datas's keys contains [In]name"), IsInstantiated(false), ReturnMayNull]
+        public WindowsComponent GetWindowsComponent([In] string name)
+        {
+            var wc = GetWindowsComponents(name);
+            if (wc.Length == 0)
+                return null;
+            return wc[0];
+        }
+        [return: When("Datas's keys contains [In]name and instance is T"), IsInstantiated(false)]
+        public T GetWindowsComponent<T>([In] string name) where T : WindowsComponent
+        {
+            return GetWindowsComponents(name).FirstOrDefault(P => (P as T) != null) as T;
+        }
+
+        [return: When("Datas's keys contains [In]name"), ReturnMayNull]
+        public IWindowUIModule[] GetWindowsUIs([In] string name)
+        {
+            if (this.uobjects.TryGetValue(name, out var value))
+                return (value as GameObject).GetComponents<IWindowUIModule>();
+            return null;
+        }
+        [return: When("Datas's keys contains [In]name"), IsInstantiated(false), ReturnMayNull]
+        public IWindowUIModule GetWindowsUI([In] string name)
+        {
+            var wm = GetWindowsUIs(name);
+            if (wm.Length == 0)
+                return null;
+            return wm[0];
+        }
+        [return: When("Datas's keys contains [In]name and instance is T"), IsInstantiated(false)]
+        public T GetWindowsUI<T>([In] string name) where T : class, IWindowUIModule
+        {
+            return GetWindowsUIs(name).FirstOrDefault(P => (P as T) != null) as T;
+        }
+    }
+}

Convention/[Visual]/UIComponent/SO/Windows.cs.meta

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

Convention/[Visual]/UIComponent/Variant/AssetsWindow/AssetsWindow.cs

@@ -15,11 +15,6 @@ namespace Convention.WindowsUI.Variant
         [Resources, OnlyNotNullMode, SerializeField, Tooltip("Path Text")] private Text m_PathTitle;
         [Content, OnlyPlayMode] public string CurrentTargetName;
         [Content, OnlyPlayMode, SerializeField] public List<string> pathContainer = new();
-        private RegisterWrapper<AssetsWindow> m_RegisterWrapper;
-        private void OnDestroy()
-        {
-            m_RegisterWrapper.Release();
-        }
 
         public PropertiesWindow MainPropertiesWindow => m_PropertiesWindow;
 
@@ -33,12 +28,11 @@ namespace Convention.WindowsUI.Variant
         {
             m_BackButton.onClick.AddListener(() => Pop(true));
             UpdatePathText();
-            m_RegisterWrapper = new(() => { });
+            Architecture.RegisterWithDuplicateAllow(typeof(AssetsWindow), this, () => { });
         }
 
         protected virtual void Reset()
         {
-            m_PropertiesWindow.m_PerformanceMode = PerformanceIndicator.PerformanceMode.L1;
             m_PropertiesWindow = GetComponent<PropertiesWindow>();
         }
 

Convention/[Visual]/UIComponent/Variant/AssetsWindow/FileSystemAssets.cs

@@ -9,7 +9,7 @@ namespace Convention.WindowsUI.Variant
         public static void InitLoadedRoots(ref List<string> LoadedInRoot)
         {
             LoadedInRoot = new List<string>();
-            if (PlatformIndicator.is_platform_windows)
+            if (PlatformIndicator.IsPlatformWindows)
             {
                 LoadedInRoot.Add(Application.persistentDataPath);
                 LoadedInRoot.Add(Application.streamingAssetsPath);

Convention/[Visual]/UIComponent/Variant/AssetsWindow/FileSystemAssetsItem.cs

@@ -7,7 +7,7 @@ using UnityEngine.UI;
 
 namespace Convention.WindowsUI.Variant
 {
-    public class FileSystemAssetsItem : MonoAnyBehaviour, AssetsItem.IAssetsItemInvoke
+    public class FileSystemAssetsItem : MonoBehaviour, AssetsItem.IAssetsItemInvoke
     {
         public static Dictionary<string, ToolFile> LoadedFiles = new();
         public static long LoadedFileAutoLoadMaxFileSize = 1024 * 50;
@@ -18,15 +18,6 @@ namespace Convention.WindowsUI.Variant
         [Content, OnlyNotNullMode, SerializeField, InspectorDraw(InspectorDrawType.Toggle), Ignore]
         private bool m_IsLoading = false;
 
-        private void OnDestroy()
-        {
-            if (m_File.data is AssetBundle)
-            {
-                return;
-            }
-            m_File.data = null;
-        }
-
         public void RebuildFileInfo([In] string path)
         {
             if (LoadedFiles.ContainsKey(path))
@@ -67,15 +58,15 @@ namespace Convention.WindowsUI.Variant
         private void OnAssetsItemFocusWithFileMode([In] AssetsItem item, [In] string name)
         {
             item.title = name;
-            FileSystemAssets.instance.CurrentSelectFilename.title = m_File.FullPath;
+            FileSystemAssets.instance.CurrentSelectFilename.title = m_File.GetFullPath();
-            if (m_File.IsExist == false)
+            if (m_File.Exists() == false)
                 return;
             else if (m_File.IsDir())
                 UpdateSprite(item, "folder");
-            else if (m_File.Extension.Length != 0 && m_Icons.uobjects.ContainsKey(m_File.Extension))
+            else if (m_File.GetExtension().Length != 0 && m_Icons.uobjects.ContainsKey(m_File.GetExtension()))
-                UpdateSprite(item, m_File.Extension);
+                UpdateSprite(item, m_File.GetExtension());
-            else if (m_File.Extension.Length != 0 && m_Icons.uobjects.ContainsKey(m_File.Extension[1..]))
+            else if (m_File.GetExtension().Length != 0 && m_Icons.uobjects.ContainsKey(m_File.GetExtension()[1..]))
-                UpdateSprite(item, m_File.Extension[1..]);
+                UpdateSprite(item, m_File.GetExtension()[1..]);
             else if (m_File.IsImage)
                 UpdateSprite(item, "image");
             else if (m_File.IsText)
@@ -101,8 +92,9 @@ namespace Convention.WindowsUI.Variant
         private class SkyItem : AssetBundleItem
         {
             [Resources, SerializeField] private Material SkyBox;
-            public class SkyItemInstanceWrapper : Singleton<SkyItemInstanceWrapper>
+            public class SkyItemInstanceWrapper
             {
+                public static SkyItemInstanceWrapper instance { get; protected set; }
                 public static void InitInstance()
                 {
                     if (instance == null)

Convention/[Visual]/UIComponent/Variant/ConversationWindow/ConversationWindow.cs

@@ -9,7 +9,6 @@ namespace Convention.WindowsUI.Variant
     {
         [Resources, OnlyNotNullMode] public WindowManager m_WindowManager;
         [Resources, SerializeField, OnlyNotNullMode] private PropertiesWindow m_PropertiesWindow;
-        private RegisterWrapper<ConversationWindow> m_RegisterWrapper;
 
         [Resources, Header("HeadLine"), OnlyNotNullMode] public Image HeadIcon;
         [Resources, OnlyNotNullMode] public ModernUIInputField HeadText = new();
@@ -36,15 +35,11 @@ namespace Convention.WindowsUI.Variant
 
         private void Start()
         {
-            m_RegisterWrapper = new(() =>
+            Architecture.RegisterWithDuplicateAllow(typeof(ConversationWindow), this, () =>
             {
 
             });
         }
-        private void OnDestroy()
-        {
-            m_RegisterWrapper.Release();
-        }
 
         public void SetHeadText(string text)
         {

Convention/[Visual]/UIComponent/Variant/HierarchyWindow/HierarchyLoadedIn.cs

@@ -7,11 +7,11 @@ namespace Convention
 {
     public interface ILoadedInHierarchy { }
     public interface IOnlyLoadedInHierarchy { }
-    public class HierarchyLoadedIn : MonoAnyBehaviour
+    public class HierarchyLoadedIn : MonoBehaviour
     {
         private void Update()
         {
-            if (!RegisterBaseWrapperExtension.Registers.ContainsKey(typeof(WindowsUI.Variant.HierarchyWindow)))
+            if (!Architecture.Contains<WindowsUI.Variant.HierarchyWindow>())
                 return;
             var onlys = GetComponents<IOnlyLoadedInHierarchy>();
             try

Convention/[Visual]/UIComponent/Variant/HierarchyWindow/HierarchyWindow.cs

@@ -9,14 +9,13 @@ namespace Convention.WindowsUI.Variant
     {
         [Resources] public WindowManager windowManager;
         [Resources, SerializeField] private PropertiesWindow m_PropertiesWindow;
-        private RegisterWrapper<HierarchyWindow> m_RegisterWrapper;
 
         private Dictionary<int, object> AllReferenceLinker = new();
         private Dictionary<object, int> AllReferenceLinker_R = new();
         private Dictionary<object, HierarchyItem> AllReferenceItemLinker = new();
 
         /// <summary>
-        /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD><EFBFBD>tab
+        /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>Ӧ<EFBFBD><D3A6>tab
         /// </summary>
         /// <param name="reference"></param>
         /// <param name="item"></param>
@@ -97,7 +96,7 @@ namespace Convention.WindowsUI.Variant
 
         private void Start()
         {
-            m_RegisterWrapper = new(() => { });
+            Architecture.RegisterWithDuplicateAllow(typeof(HierarchyWindow), this, () => { });
         }
 
         private void Reset()
@@ -106,10 +105,6 @@ namespace Convention.WindowsUI.Variant
             m_PropertiesWindow = GetComponent<PropertiesWindow>();
             AllReferenceLinker = new();
         }
-        private void OnDestroy()
-        {
-            m_RegisterWrapper.Release();
-        }
 
         public void RenameTabWhenItFocus()
         {

Convention/[Visual]/UIComponent/Variant/InspectorWindow/InspectorImage.cs

@@ -37,7 +37,7 @@ namespace Convention.WindowsUI.Variant
             if (path == null || path.Length == 0)
                 return;
             var file = new ToolFile(path);
-            if (file.IsExist == false)
+            if (file.Exists() == false)
                 return;
             Texture2D texture = file.LoadAsImage();
             SetImage(texture);

Convention/[Visual]/UIComponent/Variant/InspectorWindow/InspectorItem.cs

@@ -8,7 +8,7 @@ using static Convention.WindowsUI.Variant.PropertiesWindow;
 namespace Convention.WindowsUI.Variant
 {
     /// <summary>
-    /// enum&1==1<><31>Ϊ<EFBFBD><CEAA>̬<EFBFBD><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    /// enum&1==1<><31>Ϊ<EFBFBD><CEAA>̬<EFBFBD><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
     /// </summary>
     public enum InspectorDrawType
     {
@@ -400,9 +400,8 @@ namespace Convention.WindowsUI.Variant
 
 
     /// <summary>
-    /// ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ<EFBFBD>, <20><><EFBFBD><EFBFBD>GameObject<63><74>SetTarget<65><74>Inspector<6F><72>ʱֻչʾ<D5B9><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,
+    /// 
-    /// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>չʾComponentsҲ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD><To GameObject><3E><>ת<EFBFBD><D7AA>GameObject<63><74>Components<74>б<EFBFBD>,
+    /// <see cref="InspectorWindow.BuildWindow"/>
-    /// <20><><see cref="InspectorWindow.BuildWindow"/>
     /// </summary>
-    public interface IOnlyFocusThisOnInspector : IAnyClass { }
+    public interface IOnlyFocusThisOnInspector { }
 }

Convention/[Visual]/UIComponent/Variant/InspectorWindow/InspectorReference.cs

@@ -9,7 +9,7 @@ namespace Convention.WindowsUI.Variant
     {
         [Resources] public ModernUIInputField TextArea;
         [Resources] public Button RawButton;
-        public IAnyClass lastReference;
+        public object lastReference;
         [Content] public bool isEditing = false;
 
         private void OnCallback(string str)

Convention/[Visual]/UIComponent/Variant/InspectorWindow/InspectorWindow.cs

@@ -7,10 +7,9 @@ using UnityEngine;
 
 namespace Convention.WindowsUI.Variant
 {
-    public class InspectorWindow : WindowsComponent, ISingleton<InspectorWindow>
+    public class InspectorWindow : WindowsComponent
     {
         public static InspectorWindow instance { get; private set; }
-        private RegisterWrapper<InspectorWindow> m_RegisterWrapper;
         private object target;
 
         [Setting] public bool IsWorkWithHierarchyWindow = true;
@@ -32,11 +31,6 @@ namespace Convention.WindowsUI.Variant
                 m_PropertiesWindow = GetComponent<PropertiesWindow>();
         }
 
-        private void OnDestroy()
-        {
-            m_RegisterWrapper.Release();
-        }
-
         private void Start()
         {
             if (m_WindowManager == null)
@@ -44,7 +38,7 @@ namespace Convention.WindowsUI.Variant
             if (m_PropertiesWindow == null)
                 m_PropertiesWindow = GetComponent<PropertiesWindow>();
 
-            m_RegisterWrapper = new(() => { });
+            Architecture.RegisterWithDuplicateAllow(typeof(InspectorWindow), this, () => { });
             instance = this;
 
             if (IsWorkWithHierarchyWindow == true)
@@ -91,12 +85,12 @@ namespace Convention.WindowsUI.Variant
         }
 
         /// <summary>
-        /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>Ӧ<EFBFBD><D3A6>tab
+        /// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>Ӧ<EFBFBD><D3A6>tab
         /// </summary>
         /// <param name="target"></param>
         /// <param name="item"></param>
-        /// <returns><3E>Ƿ<EFBFBD><C7B7>봫<EFBFBD><EBB4AB><EFBFBD><EFBFBD>target<EFBFBD><EFBFBD>ͬ</returns>
+        /// <returns><3E>Ƿ<EFBFBD><C7B7>봫<EFBFBD><EBB4AB><EFBFBD>target<65><74>ͬ</returns>
-        [return: When("<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>target<EFBFBD>뱻<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊtarget<EFBFBD><EFBFBD>ʵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬ")]
+        [return: When("<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>target<65>뱻<EFBFBD><EBB1BB><EFBFBD><EFBFBD>Ϊtarget<65><74>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>ͬ")]
         public bool SetTarget([In] object target, [In, Opt] HierarchyItem item)
         {
             if (item != null && IsWorkWithHierarchyWindow)
@@ -159,7 +153,6 @@ namespace Convention.WindowsUI.Variant
             m_currentEntries.Clear();
         }
         private static readonly Type[] IgnoreCutOffType = new Type[] {
-                typeof(MonoAnyBehaviour),
                 typeof(GameObject),
                 typeof(MonoBehaviour),
                 typeof(UnityEngine.Object),

Convention/[Visual]/UIComponent/Variant/PropertiesWindow.cs

@@ -7,11 +7,13 @@ using UnityEngine.UI;
 
 namespace Convention.WindowsUI.Variant
 {
-    public class PropertiesWindow : MonoAnyBehaviour
+    public class PropertiesWindow : MonoBehaviour
     {
         [ArgPackage]
-        public class ItemEntry : LeftValueReference<WindowUIModule>
+        public class ItemEntry
         {
+            private WindowUIModule m_module;
+
             #region Tools
 
             private static bool IsSetupParentRectTransformAdjustSizeToContainsChilds = false;
@@ -118,8 +120,8 @@ namespace Convention.WindowsUI.Variant
             public static IActionInvoke MakeItemAsActionInvoke(
                 [In, Out] ItemEntry entry,
                 [In] string invokerName, [In] PropertiesWindow parent,
-                [In][Opt, When("If you sure not need a target")] IAnyClass target,
+                [In][Opt, When("If you sure not need a target")] object target,
-                params UnityAction<IAnyClass>[] actions)
+                params UnityAction<object>[] actions)
             {
                 entry.ref_value = InstantiateItemObject(invokerName, parent.m_WindowManager, parent.m_WindowsConfig);
                 var invoker = entry.ref_value as IActionInvoke;
@@ -132,8 +134,8 @@ namespace Convention.WindowsUI.Variant
             public static IButton MakeItemAsActionInvoke(
                 [In, Out] ItemEntry entry,
                 [In] string invokerName, [In] ItemEntry parent, [In] SO.Windows config,
-                [In][Opt, When("If you sure not need a target")] IAnyClass target,
+                [In][Opt, When("If you sure not need a target")] object target,
-                params UnityAction<IAnyClass>[] actions)
+                params UnityAction<object>[] actions)
             {
                 entry.ref_value = InstantiateItemObject(invokerName, parent.ref_value.GetComponent<RectTransform>(), config);
                 var invoker = entry.ref_value as IButton;
@@ -147,8 +149,8 @@ namespace Convention.WindowsUI.Variant
             public static IButton MakeItemAsButton(
                 [In, Out] ItemEntry entry,
                 [In] string buttonName, [In] PropertiesWindow parent,
-                [In][Opt, When("If you sure not need a target")] IAnyClass target,
+                [In][Opt, When("If you sure not need a target")] object target,
-                params UnityAction<IAnyClass>[] actions)
+                params UnityAction<object>[] actions)
             {
                 entry.ref_value = InstantiateItemObject(buttonName, parent.m_WindowManager, parent.m_WindowsConfig);
                 var button = entry.ref_value as IButton;
@@ -161,8 +163,8 @@ namespace Convention.WindowsUI.Variant
             public static IButton MakeItemAsButton(
                 [In, Out] ItemEntry entry,
                 [In] string buttonName, [In] ItemEntry parent, [In] SO.Windows config,
-                [In][Opt, When("If you sure not need a target")] IAnyClass target,
+                [In][Opt, When("If you sure not need a target")] object target,
-                params UnityAction<IAnyClass>[] actions)
+                params UnityAction<object>[] actions)
             {
                 entry.ref_value = InstantiateItemObject(buttonName, parent.ref_value.GetComponent<RectTransform>(), config);
                 var button = entry.ref_value as IButton;
@@ -219,18 +221,18 @@ namespace Convention.WindowsUI.Variant
 
             #endregion
 
-            public override WindowUIModule ref_value
+            public WindowUIModule ref_value
             {
-                get => base.ref_value;
+                get => m_module;
                 set
                 {
-                    if (base.ref_value != value)
+                    if (m_module != value)
                     {
-                        if (base.ref_value != null)
+                        if (m_module != null)
                         {
-                            base.ref_value.gameObject.SetActive(false);
+                            m_module.gameObject.SetActive(false);
                         }
-                        base.ref_value = value;
+                        m_module = value;
                         if (parentWindow != null)
                         {
                             parentWindow.m_WindowManager.SelectContextPlane(parentWindow.m_TargetWindowContent);
@@ -266,7 +268,7 @@ namespace Convention.WindowsUI.Variant
             public List<ItemEntry> GetChilds() => new(childs);
             public ItemEntry GetParent() => parentEntry;
 
-            public ItemEntry(PropertiesWindow parent) : base(null)
+            public ItemEntry(PropertiesWindow parent)
             {
                 childs = new();
                 this.parentWindow = parent;
@@ -274,7 +276,7 @@ namespace Convention.WindowsUI.Variant
                 parent.m_Entrys.Add(this);
                 layer = 0;
             }
-            public ItemEntry(ItemEntry parent) : base(null)
+            public ItemEntry(ItemEntry parent)
             {
                 childs = new();
                 this.parentEntry = parent;
@@ -401,7 +403,6 @@ namespace Convention.WindowsUI.Variant
         private RectTransform m_ContentPlaneWhenNoWindow;
         [Content, SerializeField, OnlyPlayMode] private List<ItemEntry> m_Entrys = new();
         [Resources, SerializeField, HopeNotNull] public WindowUIModule ItemPrefab;
-        [Setting, Tooltip("RUNTIME MODE")] public PerformanceIndicator.PerformanceMode m_PerformanceMode = PerformanceIndicator.PerformanceMode.Quality;
 
         public RectTransform TargetWindowContent => m_WindowManager == null ? m_ContentPlaneWhenNoWindow : m_WindowManager[m_TargetWindowContent];
 

Convention/[Visual]/UIComponent/Variant/SharedModule.cs

@@ -54,7 +54,7 @@ namespace Convention.WindowsUI.Variant
         }
 
         [ArgPackage]
-        public class CallbackData : AnyClass
+        public class CallbackData
         {
             public string name;
             public Action<Vector3> callback;
@@ -65,7 +65,7 @@ namespace Convention.WindowsUI.Variant
             }
         }
         /// <summary>
-        /// <EFBFBD>ص<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>root
+        /// 
         /// </summary>
         [return: ReturnNotNull, IsInstantiated(true)]
         public CustomMenu OpenCustomMenu([In] RectTransform root, params CallbackData[] actions)

Convention/[Visual]/UIComponent/WindowManager.cs.meta

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