根据一个UI物体的位置摆放另一个UI物体

最近在遇到了一个需求，要点击某个道具UI之后，显示一个小的关于该道具的信息框。
大概是入下图这个样子的。

还好之前做过，于是乎直接修修补补腾过去。至于为什么要修补，是因为在之前的项目里虽然写了一些和RectTransform相关的一些utils，但都因为懒和菜，没有去维护。有重复的方法还有错误的方法，麻了。
这次说是修补，也稍微重写了一些和RectTransform相关的一些utils,也准备带进项目里看看有没有地方可以用的。

using UnityEngine;
using UnityEngine.UI;

namespace Temp
{
    public enum RectPositionType
    {
        Center = 0,

        Top = 1,
        Bottom = 2,
        Left = 3,
        Right = 4,

        TopLeft = 5,
        TopRight = 6,

        BottomLeft = 7,
        BottomRight = 8,
    }

    public class UIElementPositionSetter : MonoBehaviour
    {
        [Header("Target setting")]
        [SerializeField]
        private RectPositionType _targetRectPosition = RectPositionType.Center;
        [SerializeField]
        private Vector2 _targetPivot = Vector2.zero;
        [SerializeField]
        private Vector2 _extraOffset = Vector2.zero;
        [SerializeField]
        private RectOffset _adaptionOffset;
        [SerializeField]
        private bool _doScreenAdaption;

        [Header("Other setting")]
        [SerializeField]
        private RectTransform _defaultBoundsCanvasTransform;
        [SerializeField]
        private bool _adjustHorizontal = true;
        [SerializeField]
        private bool _adjustVertical = true;

        public void SetPosition(RectTransform target)
        {
            RectTransform self = transform as RectTransform;
            Vector3 spawnPos = GetLocalRectPosition(self, _targetRectPosition);
            spawnPos += new Vector3(_extraOffset.x, _extraOffset.y, 0f);
            spawnPos = self.localToWorldMatrix.MultiplyPoint(spawnPos);
            target.pivot = _targetPivot;
            target.position = spawnPos;
            if (_doScreenAdaption)
            {
                // HACK @Hiko force rebuild to make sure the size is correct
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
                DoAdaption(target);
            }
        }

        public void DoAdaption(RectTransform targetTransform)
        {
            if (_adjustHorizontal)
            {
                AdjustHorizontal(targetTransform, _defaultBoundsCanvasTransform);
            }
            if (_adjustVertical)
            {
                AdjustVertical(targetTransform, _defaultBoundsCanvasTransform);
            }
        }

        public void AdjustHorizontal(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
            Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
            bool leftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.right * targetSize.x + Vector2.right * _adaptionOffset.right);
            Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
            bool rightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

            if (leftOut && rightOut)
            {
                // outter bound is too small
                return;
            }

            if (leftOut)
            {
                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (rightOut)
            {
                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (leftOut || rightOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        public void AdjustVertical(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.right * targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
            Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
            bool topOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y + Vector2.right * targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
            Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
            bool bottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

            if (topOut && bottomOut)
            {
                // outter bound is too small
                return;
            }

            if (topOut)
            {
                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (bottomOut)
            {
                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (topOut || bottomOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        #region position util

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType)
        {
            return GetLocalRectPosition(target, offsetType, Vector2.zero);
        }

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType, Vector2 offset)
        {
            return GetLocalRectPosition(target.rect.size, target.pivot, offsetType, offset);
        }

        public static Vector2 GetLocalRectPosition(Vector2 targetSize, Vector2 targetPivot, RectPositionType offsetType, Vector2 offset)
        {
            Vector2 bottomLeft = Vector2.zero;
            bottomLeft.x -= targetPivot.x * targetSize.x;
            bottomLeft.y -= targetPivot.y * targetSize.y;
            Vector2 result = bottomLeft;
            switch (offsetType)
            {
                case RectPositionType.Top:
                    result += Vector2.right * 0.5f * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.Bottom:
                    result += Vector2.right * 0.5f * targetSize.x;
                    break;
                case RectPositionType.Left:
                    result += Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.Right:
                    result += Vector2.right * targetSize.x + Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.TopLeft:
                    result += Vector2.up * targetSize.y;
                    break;
                case RectPositionType.TopRight:
                    result += Vector2.right * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.BottomRight:
                    result += Vector2.right * targetSize.x;
                    break;
                case RectPositionType.BottomLeft:
                default:
                    break;
            }
            return result + offset;
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType)
        {
            return RectPositionToWorld(rect, offsetType, Vector2.zero);
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType, Vector2 offset)
        {
            var localPosition = GetLocalRectPosition(rect, offsetType, offset);
            return rect.TransformPoint(localPosition);
        }

        private Vector2 GetTargetRectPositionInLocalReference(RectPositionType offsetType)
        {
            RectTransform self = transform as RectTransform;
            Vector2 targetPivotPos = GetLocalRectPosition(self, _targetRectPosition, _extraOffset);
            Vector2 virtualCenterPos = targetPivotPos;
            virtualCenterPos += GetLocalRectPosition(_targetSize, _targetPivot, offsetType, Vector2.zero);
            return virtualCenterPos;
        }

        #endregion

#if UNITY_EDITOR

        [Header("Preview setting")]
        [SerializeField]
        private Vector2 _targetSize = Vector2.one * 128f;
        [SerializeField]
        private Color _previewColor = Color.white;
        [SerializeField]
        private bool _doDrawAdaptionOffsetRect = false;

        [System.Serializable]
        private struct TempCheckResult
        {
            public bool previewLeftOut;
            public bool previewRightOut;
            public bool previewTopOut;
            public bool previewBottomOut;
        }

        [SerializeField]
        private TempCheckResult _checkResult;

        private bool _previewLeftOut;
        private bool _previewRightOut;
        private bool _previewTopOut;
        private bool _previewBottomOut;

        private void OnDrawGizmosSelected()
        {
            // draw A box to show the position of target
            RectTransform self = transform as RectTransform;
            Vector2 localSpawnPos = GetLocalRectPosition(self, _targetRectPosition);
            localSpawnPos += _extraOffset;

            Vector2 pivot = _targetPivot;
            Vector2 topLeftPos = localSpawnPos;
            topLeftPos.x -= pivot.x * _targetSize.x;
            topLeftPos.y -= (pivot.y - 1f) * _targetSize.y;

            if (_doScreenAdaption)
            {
                // do adaption
                if (_defaultBoundsCanvasTransform != null) // if there is no bound, we can take the screen as the bound
                {
                    Matrix4x4 localToWorld = self.localToWorldMatrix;
                    RectTransform outterBoundRectTransform = _defaultBoundsCanvasTransform;
                    Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;

                    Vector3 checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
                    Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
                    _previewLeftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.right * _targetSize.x + Vector2.right * _adaptionOffset.right);
                    Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
                    _previewRightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.right * _targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
                    Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
                    _previewTopOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y + Vector2.right * _targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
                    Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
                    _previewBottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

                    if (_adjustHorizontal)
                    {
                        if (_previewLeftOut && _previewRightOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewLeftOut)
                            {
                                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewRightOut)
                            {
                                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }

                    if (_adjustVertical)
                    {
                        if (_previewTopOut && _previewBottomOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewTopOut)
                            {
                                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewBottomOut)
                            {
                                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }
                }
            }

            _checkResult.previewLeftOut = _previewLeftOut;
            _checkResult.previewRightOut = _previewRightOut;
            _checkResult.previewTopOut = _previewTopOut;
            _checkResult.previewBottomOut = _previewBottomOut;

            if (_doDrawAdaptionOffsetRect && _defaultBoundsCanvasTransform != null)
            {
                Vector2 innerBoundLeftPos = GetLocalRectPosition(_defaultBoundsCanvasTransform, RectPositionType.TopLeft, new Vector2(_adaptionOffset.left, -_adaptionOffset.top));
                Vector2 size = _defaultBoundsCanvasTransform.rect.size;
                size.x -= _adaptionOffset.horizontal;
                size.y -= _adaptionOffset.vertical;
                DrawBox(_defaultBoundsCanvasTransform, innerBoundLeftPos, size, Color.blue);
            }
            DrawBox(self, topLeftPos, _targetSize, _previewColor);
        }

        private void DrawBox(RectTransform reference, Vector2 topLeftPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.right * size.x));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.right * size.x), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.down * size.y), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.color = cachedColor;
        }

#endif

    }
}

还是像以前一样，先在debug draw里把功能完成再给移到实际的物体上。
但这次还是很可惜没有把功能很好抽出成比较单独的数学运算，而且感觉要用到的参数好多也没法拆分，最后留了一个多参的入口。