RectTransformUtility

源码

  1. using scm = System.ComponentModel;
  2. using uei = UnityEngine.Internal;
  3. using RequiredByNativeCodeAttribute = UnityEngine.Scripting.RequiredByNativeCodeAttribute;
  4. using UsedByNativeCodeAttribute = UnityEngine.Scripting.UsedByNativeCodeAttribute;
  6. using System;
  7. using UnityEngine;
  8. using Object = UnityEngine.Object;
  10. namespace UnityEngine
  11. {
  12.     public sealed partial class RectTransformUtility
  13.     {
  14.         private static Vector3[] s_Corners = new Vector3[4];
  16.         private RectTransformUtility() {}
  18.         public static bool RectangleContainsScreenPoint(RectTransform rect, Vector2 screenPoint)
  19.         {
  20.             return RectangleContainsScreenPoint(rect, screenPoint, null);
  21.         }
  23.         public static bool ScreenPointToWorldPointInRectangle(RectTransform rect, Vector2 screenPoint, Camera cam, out Vector3 worldPoint)
  24.         {
  25.             worldPoint = Vector2.zero;
  26.             Ray ray = ScreenPointToRay(cam, screenPoint);
  27.             var plane = new Plane(rect.rotation * Vector3.back, rect.position);
  29.             float dist;
  30.             if (!plane.Raycast(ray, out dist))
  31.                 return false;
  33.             worldPoint = ray.GetPoint(dist);
  34.             return true;
  35.         }
  37.         public static bool ScreenPointToLocalPointInRectangle(RectTransform rect, Vector2 screenPoint, Camera cam, out Vector2 localPoint)
  38.         {
  39.             localPoint = Vector2.zero;
  40.             Vector3 worldPoint;
  41.             if (ScreenPointToWorldPointInRectangle(rect, screenPoint, cam, out worldPoint))
  42.             {
  43.                 localPoint = rect.InverseTransformPoint(worldPoint);
  44.                 return true;
  45.             }
  46.             return false;
  47.         }
  49.         public static Ray ScreenPointToRay(Camera cam, Vector2 screenPos)
  50.         {
  51.             if (cam != null)
  52.                 return cam.ScreenPointToRay(screenPos);
  54.             Vector3 pos = screenPos;
  55.             pos.z -= 100f;
  56.             return new Ray(pos, Vector3.forward);
  57.         }
  59.         public static Vector2 WorldToScreenPoint(Camera cam, Vector3 worldPoint)
  60.         {
  61.             if (cam == null)
  62.                 return new Vector2(worldPoint.x, worldPoint.y);
  64.             return cam.WorldToScreenPoint(worldPoint);
  65.         }
  67.         public static Bounds CalculateRelativeRectTransformBounds(Transform root, Transform child)
  68.         {
  69.             RectTransform[] rects = child.GetComponentsInChildren<RectTransform>(false);
  71.             if (rects.Length > 0)
  72.             {
  73.                 Vector3 vMin = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
  74.                 Vector3 vMax = new Vector3(float.MinValue, float.MinValue, float.MinValue);
  76.                 Matrix4x4 toLocal = root.worldToLocalMatrix;
  78.                 for (int i = 0, imax = rects.Length; i < imax; i++)
  79.                 {
  80.                     rects[i].GetWorldCorners(s_Corners);
  81.                     for (int j = 0; j < 4; j++)
  82.                     {
  83.                         Vector3 v = toLocal.MultiplyPoint3x4(s_Corners[j]);
  84.                         vMin = Vector3.Min(v, vMin);
  85.                         vMax = Vector3.Max(v, vMax);
  86.                     }
  87.                 }
  89.                 Bounds b = new Bounds(vMin, Vector3.zero);
  90.                 b.Encapsulate(vMax);
  91.                 return b;
  92.             }
  93.             return new Bounds(Vector3.zero, Vector3.zero);
  94.         }
  96.         public static Bounds CalculateRelativeRectTransformBounds(Transform trans)
  97.         {
  98.             return CalculateRelativeRectTransformBounds(trans, trans);
  99.         }
  101.         public static void FlipLayoutOnAxis(RectTransform rect, int axis, bool keepPositioning, bool recursive)
  102.         {
  103.             if (rect == null)
  104.                 return;
  106.             if (recursive)
  107.             {
  108.                 for (int i = 0; i < rect.childCount; i++)
  109.                 {
  110.                     RectTransform childRect = rect.GetChild(i) as RectTransform;
  111.                     if (childRect != null)
  112.                         FlipLayoutOnAxis(childRect, axis, false, true);
  113.                 }
  114.             }
  116.             Vector2 pivot = rect.pivot;
  117.             pivot[axis] = 1.0f - pivot[axis];
  118.             rect.pivot = pivot;
  120.             if (keepPositioning)
  121.                 return;
  123.             Vector2 anchoredPosition = rect.anchoredPosition;
  124.             anchoredPosition[axis] = -anchoredPosition[axis];
  125.             rect.anchoredPosition = anchoredPosition;
  127.             Vector2 anchorMin = rect.anchorMin;
  128.             Vector2 anchorMax = rect.anchorMax;
  129.             float temp = anchorMin[axis];
  130.             anchorMin[axis] = 1 - anchorMax[axis];
  131.             anchorMax[axis] = 1 - temp;
  132.             rect.anchorMin = anchorMin;
  133.             rect.anchorMax = anchorMax;
  134.         }
  136.         public static void FlipLayoutAxes(RectTransform rect, bool keepPositioning, bool recursive)
  137.         {
  138.             if (rect == null)
  139.                 return;
  141.             if (recursive)
  142.             {
  143.                 for (int i = 0; i < rect.childCount; i++)
  144.                 {
  145.                     RectTransform childRect = rect.GetChild(i) as RectTransform;
  146.                     if (childRect != null)
  147.                         FlipLayoutAxes(childRect, false, true);
  148.                 }
  149.             }
  151.             rect.pivot = GetTransposed(rect.pivot);
  152.             rect.sizeDelta = GetTransposed(rect.sizeDelta);
  154.             if (keepPositioning)
  155.                 return;
  157.             rect.anchoredPosition = GetTransposed(rect.anchoredPosition);
  158.             rect.anchorMin = GetTransposed(rect.anchorMin);
  159.             rect.anchorMax = GetTransposed(rect.anchorMax);
  160.         }
  162.         private static Vector2 GetTransposed(Vector2 input)
  163.         {
  164.             return new Vector2(input.y, input.x);
  165.         }
  166.     }
  167. }

?