Unity中，實現物體的2D頂牌始終位於物體包圍盒中間下方邊緣，並自動計算頂牌中心點，避免頂牌遮擋物體

/*
 * 
 * 1.2D頂牌跟隨物體
 * 2.頂牌始終位於物體包圍盒中間下方邊緣位置
 * 3.自動計算頂牌中心點，避免頂牌遮擋物體
 * 
*/
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class TransformCard : MonoBehaviour
{
    public Canvas canvas;
    public RectTransform uiRectTrans;

    public void Update() 
    {
        UpdateUIRectTrans();
    }

    public void UpdateUIRectTrans()
    {
        var bounds = GetBounds(this.transform);//得到物體包圍盒
        var screenPoints = GetScreenPoints(bounds);//把包圍盒的頂點轉化成螢幕座標
        List<Vector2> convexHull = GetConvexHull(screenPoints);//得到最大凸多邊形
        var minX = float.MaxValue;
        var minY = float.MaxValue;
        var maxX = float.MinValue;
        var maxY = float.MinValue;

        foreach (var point in convexHull)
        {
            if (point.x > maxX) maxX = point.x;
            if (point.x < minX) minX = point.x;
            if (point.y > maxY) maxY = point.y;
            if (point.y < minY) minY = point.y;
        }

        var rayStart = new Vector2((minX + maxX) *0.5f, minY);//計算起點，中間最底部

        Vector2 p0, p1, interPoint;
        var hasIntersection = GetIntersection(rayStart, Vector2.up, convexHull, out interPoint, out p0, out p1);//得到與凸包的交點

        if (hasIntersection)
        {
            //根據相交的邊的方向, 計算UI中心點，始終保持UI邊緣貼著凸包邊緣，而不是重疊
            var interLineDirection = p0.y > p1.y ? p0 - p1 : p1 - p0;
            var angle = Vector2.SignedAngle(Vector2.up, interLineDirection);
            if (angle > 0f)
            {
                uiRectTrans.pivot = new Vector2(1f - angle / 90f * 0.5f, 1f);
            }
            else if (angle < 0f)
            {
                uiRectTrans.pivot = new Vector2(-angle / 90f * 0.5f, 1f);
            }
            else
            {
                uiRectTrans.pivot = new Vector2(0.5f, 1f);
            }

            //錨點在螢幕左下角
            uiRectTrans.anchorMin = Vector2.zero;
            uiRectTrans.anchorMax = Vector2.zero;

            uiRectTrans.anchoredPosition = interPoint;
        }
        ////Debug.Log("Convex Hull Points:");
        //for (int i = 0; i < convexHull.Count; i++)
        //{
        //    //Debug.LogError(convexHull[i]);
        //    Test2DImage("convex_" + i, convexHull[i]);
        //}
    }

    //把包圍盒的頂點轉化成螢幕座標
    public List<Vector2> GetScreenPoints(Bounds bounds) 
    {
        List<Vector3> boundsVertices = new List<Vector3>();
        List<Vector2> screenPoints = new List<Vector2>();
        var halfForward = this.transform.forward.normalized * bounds.size.z * 0.5f;
        var halfRight = this.transform.right.normalized * bounds.size.x * 0.5f;
        var center = bounds.center;
        var height = new Vector3(0f, bounds.size.y, 0f);
        boundsVertices.Add(center + halfForward + halfRight);
        boundsVertices.Add(center - halfForward + halfRight);
        boundsVertices.Add(center - halfForward - halfRight);
        boundsVertices.Add(center + halfForward - halfRight);
        boundsVertices.Add(boundsVertices[0] + height);
        boundsVertices.Add(boundsVertices[1] + height);
        boundsVertices.Add(boundsVertices[2] + height);
        boundsVertices.Add(boundsVertices[3] + height);
        for (int i = 0; i < boundsVertices.Count; i++)
        {
            var screenPoint = Camera.main.WorldToScreenPoint(boundsVertices[i]);
            screenPoints.Add(screenPoint);
            //Test3DSphere("Test3DSphere"+i, boundsVertices[i]);
        }
        return screenPoints;
    }

    //測試用，生成凸多邊形的頂點
    public void Test2DImage(string name, Vector3 pos)
    {
        var testObj = GameObject.Find(name);
        if (testObj == null)
        {
            testObj = new GameObject(name);
            testObj.name = name;
            testObj.AddComponent<Image>().color = Color.red;
        }
        testObj.transform.parent = canvas.transform;
        var rectTrans = testObj.transform as RectTransform;
        rectTrans.sizeDelta = new Vector2(10f, 10f);
        rectTrans.position = pos;
    }

    //測試用，生成包圍盒頂點
    static public void Test3DSphere(string name, Vector3 pos)
    {
        var testObj = GameObject.Find(name);
        if (testObj == null)
        {
            testObj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            testObj.name = name;
        }
        testObj.transform.localScale = Vector3.one * 0.1f;
        testObj.transform.position = pos;
    }

    //獲取包圍盒
    public static  Bounds GetBounds(Transform trans)
    {
        var b = trans.GetComponent<MeshFilter>().mesh.bounds;
        b.size = Vector3.Scale(b.size, trans.localScale);//mesh.bounds是本地座標,所以要同步大小
        var center = b.center + trans.position;//mesh.bounds是本地座標,所以要加上position
        center.y -= b.size.y / 2f;//把中心放在底部
        b.center = center;
        return b;
    }

    //計算凸包
    public static List<Vector2> GetConvexHull(List<Vector2> points)
    {
        // 步驟1：找出最低且最左的點
        Vector2 startPoint = points[0];
        foreach (Vector2 p in points)
        {
            if (p.y < startPoint.y || (p.y == startPoint.y && p.x < startPoint.x))
            {
                startPoint = p;
            }
        }

        // 步驟2：按照極角排序
        points.Sort((a, b) =>
        {
            float angleA = Mathf.Atan2(a.y - startPoint.y, a.x - startPoint.x);
            float angleB = Mathf.Atan2(b.y - startPoint.y, b.x - startPoint.x);
            if (angleA < angleB) return -1;
            if (angleA > angleB) return 1;
            return Vector2.Distance(startPoint, a).CompareTo(Vector2.Distance(startPoint, b));
        });

        // 步驟3：構建凸包
        List<Vector2> hull = new List<Vector2>();
        hull.Add(startPoint);

        for (int i = 1; i < points.Count; i++)
        {
            while (hull.Count > 1 && Cross(hull[hull.Count - 2], hull[hull.Count - 1], points[i]) <= 0)
            {
                hull.RemoveAt(hull.Count - 1);
            }
            hull.Add(points[i]);
        }

        return hull;
    }

    // 用於計算向量叉乘的幫助函式
    public static float Cross(Vector2 O, Vector2 A, Vector2 B)
    {
        return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
    }

    // 返回從點A出發，沿著方向B，與凸多邊形C的最近交點。
    public static bool GetIntersection(Vector2 A, Vector2 B, List<Vector2> convexPolygon, out Vector2 closestIntersection, out Vector2 C1, out Vector2 C2)
    {
        bool hasIntersection = false;
        float closestDistance = float.MaxValue;
        closestIntersection = C1 = C2 = Vector2.zero;
        // 遍歷凸多邊形的每條邊
        for (int i = 0; i < convexPolygon.Count; i++)
        {
            Vector2 T1 = convexPolygon[i];
            Vector2 T2 = convexPolygon[(i + 1) % convexPolygon.Count];

            // 計算與當前邊的交點
            Vector2? intersection = GetLineSegmentIntersection(A, B, T1, T2);

            if (intersection != null)
            {
                float distance = Vector2.Distance(A, intersection.Value);
                if (distance < closestDistance)
                {
                    closestDistance = distance;
                    closestIntersection = intersection.Value;
                    hasIntersection = true;
                    C1 = T1;
                    C2 = T2;
                }
            }
        }
        return hasIntersection;
    }

    // 計算從點A出發，沿著方向B，與線段C1-C2的交點
    public static Vector2? GetLineSegmentIntersection(Vector2 A, Vector2 B, Vector2 C1, Vector2 C2)
    {
        Vector2 dirAB = B.normalized;
        Vector2 dirC = C2 - C1;
        Vector2 normalC = new Vector2(-dirC.y, dirC.x);

        float denominator = Vector2.Dot(dirAB, normalC);
        if (Mathf.Abs(denominator) < 1e-6)
        {
            return null; // 平行或共線，無交點
        }

        float t = Vector2.Dot(C1 - A, normalC) / denominator;
        if (t < 0)
        {
            return null; // 交點在A的反方向
        }

        Vector2 P = A + t * dirAB;

        // 檢查P是否線上段C1-C2上
        float crossProduct = (P.x - C1.x) * (C2.y - C1.y) - (P.y - C1.y) * (C2.x - C1.x);
        if (Mathf.Abs(crossProduct) > 0.05f)
        {
            return null; // 不線上段上
        }

        float dotProduct = Vector2.Dot(P - C1, C2 - C1);
        if (dotProduct < 0 || dotProduct > Vector2.Dot(C2 - C1, C2 - C1))
        {
            return null; // 在延長線但不線上段上
        }

        return P;
    }
}