Initial Unity project commit

2026-07-08 19:53:15 +08:00
commit 75f254212e
15657 changed files with 11633879 additions and 0 deletions
@@ -0,0 +1,168 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Michsky.MUIP
+{
+    [AddComponentMenu("Modern UI Pack/Layout Group/Radial Layout Group")]
+    public class RadialLayoutGroup : LayoutGroup
+    {
+        public enum Direction { Clockwise = 0, Counterclockwise = 1, Bidirectional = 2 }
+
+        public enum ConstraintMode { Interval = 0, Range = 1 }
+
+        [SerializeField] private Direction refLayoutDir;
+        public Direction layoutDir { get { return refLayoutDir; } set { SetProperty(ref refLayoutDir, value); } }
+
+        [SerializeField] private float refRadiusStart = 200;
+        public float radiusStart { get { return refRadiusStart; } set { SetProperty(ref refRadiusStart, value); } }
+
+        [SerializeField] private float refRadiusDelta;
+        public float radiusDelta { get { return refRadiusDelta; } set { SetProperty(ref refRadiusDelta, value); } }
+
+        [SerializeField] private float refRadiusRange;
+        public float radiusRange { get { return refRadiusRange; } set { SetProperty(ref refRadiusRange, value); } }
+
+        [SerializeField] private float refAngleDelta;
+        public float angleDelta { get { return refAngleDelta; } set { SetProperty(ref refAngleDelta, value); } }
+
+        [SerializeField] private float refAngleStart;
+        public float angleStart { get { return refAngleStart; } set { SetProperty(ref refAngleStart, value); } }
+
+        [SerializeField] private float refAngleCenter;
+        public float angleCenter { get { return refAngleCenter; } set { SetProperty(ref refAngleCenter, value); } }
+
+        [SerializeField] private float refAngleRange = 200;
+        public float angleRange { get { return refAngleRange; } set { SetProperty(ref refAngleRange, value); } }
+
+        [SerializeField] private bool refChildRotate = false;
+        public bool childRotate { get { return refChildRotate; } set { SetProperty(ref refChildRotate, value); } }
+
+        public override void CalculateLayoutInputVertical() { }
+        public override void CalculateLayoutInputHorizontal() { }
+        public override void SetLayoutHorizontal() { CalculateChildrenPositions(); }
+        public override void SetLayoutVertical() { CalculateChildrenPositions(); }
+
+        private List<RectTransform> childList = new List<RectTransform>();
+        private List<ILayoutIgnorer> ignoreList = new List<ILayoutIgnorer>();
+
+        private void CalculateChildrenPositions()
+        {
+            this.m_Tracker.Clear();
+            childList.Clear();
+
+            for (int i = 0; i < this.transform.childCount; ++i)
+            {
+                RectTransform rect = this.transform.GetChild(i) as RectTransform;
+
+                if (!rect.gameObject.activeSelf)
+                    continue;
+
+                ignoreList.Clear();
+                rect.GetComponents(ignoreList);
+
+                if (ignoreList.Count == 0)
+                {
+                    childList.Add(rect);
+                    continue;
+                }
+
+                for (int j = 0; j < ignoreList.Count; j++)
+                {
+                    if (!ignoreList[j].ignoreLayout)
+                    {
+                        childList.Add(rect);
+                        break;
+                    }
+                }
+
+                ignoreList.Clear();
+            }
+
+            EnsureParameters(childList.Count);
+
+            for (int i = 0; i < childList.Count; ++i)
+            {
+                var child = childList[i];
+                float delta = i * angleDelta;
+                float angle = layoutDir == Direction.Clockwise ? angleStart - delta : angleStart + delta;
+                ProcessOneChild(child, angle, radiusStart + (i * radiusDelta));
+            }
+
+            childList.Clear();
+        }
+
+        private void EnsureParameters(int childCount)
+        {
+            EnsureAngleParameters(childCount);
+            EnsureRadiusParameters(childCount);
+        }
+
+        private void EnsureAngleParameters(int childCount)
+        {
+            int intervalCount = childCount - 1;
+
+            switch (layoutDir)
+            {
+                case Direction.Clockwise:
+                    if (intervalCount > 0) { this.angleDelta = this.angleRange / intervalCount; }
+                    else { this.angleDelta = 0; }
+                    break;
+
+                case Direction.Counterclockwise:
+                    if (intervalCount > 0) { this.angleDelta = this.angleRange / intervalCount; }
+                    else { this.angleDelta = 0; }
+                    break;
+
+                case Direction.Bidirectional:
+                    if (intervalCount > 0) { this.angleDelta = this.angleRange / intervalCount; }
+                    else { this.angleDelta = 0; }
+                    this.angleStart = this.angleCenter - angleRange * 0.5f;
+                    break;
+            }
+        }
+
+
+        private void EnsureRadiusParameters(int childCount)
+        {
+            int intervalCount = childCount - 1;
+
+            switch (layoutDir)
+            {
+                case Direction.Clockwise:
+                    if (intervalCount > 0) { this.radiusDelta = radiusRange / intervalCount; }
+                    else { this.radiusDelta = 0; }
+                    break;
+
+                case Direction.Counterclockwise:
+
+                case Direction.Bidirectional:
+                    if (intervalCount > 0) { this.radiusDelta = radiusRange / intervalCount; }
+                    else { this.radiusDelta = 0; }
+                    break;
+            }
+        }
+
+        private static readonly Vector2 center = new Vector2(0.5f, 0.5f);
+
+        private void ProcessOneChild(RectTransform child, float angle, float radius)
+        {
+            Vector3 pos = new Vector3(
+                Mathf.Cos(angle * Mathf.Deg2Rad),
+                Mathf.Sin(angle * Mathf.Deg2Rad),
+                0.0f);
+            child.localPosition = pos * radius;
+
+            DrivenTransformProperties drivenProperties =
+                DrivenTransformProperties.Anchors | DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.Rotation | DrivenTransformProperties.Pivot;
+            m_Tracker.Add(this, child, drivenProperties);
+
+            child.anchorMin = center;
+            child.anchorMax = center;
+            child.pivot = center;
+
+            if (this.childRotate) { child.localEulerAngles = new Vector3(0, 0, angle); }
+            else { child.localEulerAngles = Vector3.zero; }
+        }
+    }
+}