RectTransformExtensions.cs

Go to the documentation of this file.

/*
The MIT License (MIT)
 
Copyright (c) 2015 Christian 'ketura' McCarty
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
 
 
// Thanks Christian 'ketura' McCarty for your code, which I found extremely useful and a must-have.
 
 
namespace UnityEngine
{
  
  public static class RectTransformExtensions
  {
    public static Rect GetWorldRect(this RectTransform rt)
    {
      // Be aware: a standard Rect has the position as the upper-left corner,
      // and I think the Unity UI stuff somehow repurposes this to instead point to the
      // lower-left. I'm not 100% sure on this, but I've had some unexplained wierdnesses.
      Vector3[] corners = new Vector3[4];
      rt.GetWorldCorners(corners);
      Vector2 size = new Vector2(corners[2].x - corners[1].x, corners[1].y - corners[0].y);
      return new Rect(new Vector2(corners[1].x, -corners[1].y), size);
    }
    
    public static MinMax01 GetAnchors(this RectTransform rt)
    {
      return new MinMax01(rt.anchorMin, rt.anchorMax);
    }
 
    
    public static void SetAnchors(this RectTransform rt, MinMax01 anchors)
    {
      rt.anchorMin = anchors.min;
      rt.anchorMax = anchors.max;
    }
 
    public static RectTransform GetParent(this RectTransform rt)
    {
      return rt.parent as RectTransform;
    }
    
    public static float GetWidth(this RectTransform rt)
    {
      return rt.rect.width;
    }
    
    public static float GetHeight(this RectTransform rt)
    {
      return rt.rect.height;
    }
 
    public static Vector2 GetSize(this RectTransform rt)
    {
      return new Vector2(rt.GetWidth(), rt.GetHeight());
    }
 
    public static void SetWidth(this RectTransform rt, float width)
    {
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, width);
    }
 
    public static void SetHeight(this RectTransform rt, float height)
    {
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height);
    }
 
    public static void SetSize(this RectTransform rt, float width, float height)
    {
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, width);
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height);
    }
 
    public static void SetSize(this RectTransform rt, Vector2 size)
    {
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size.x);
      rt.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size.y);
    }
 
    public static Vector2 GetLeft(this RectTransform rt)
    {
      return new Vector2(rt.offsetMin.x, rt.anchoredPosition.y);
    }
    
    public static Vector2 GetRight(this RectTransform rt)
    {
      return new Vector2(rt.offsetMax.x, rt.anchoredPosition.y);
    }
 
    public static Vector2 GetTop(this RectTransform rt)
    {
      return new Vector2(rt.anchoredPosition.x, rt.offsetMax.y);
    }
 
    public static Vector2 GetBottom(this RectTransform rt)
    {
      return new Vector2(rt.anchoredPosition.x, rt.offsetMin.y);
    }
 
    
    // Set[edgeName](float) is similar to setting the "Left" etc variables in the inspector.  Unlike the inspector, these
    // can be used regardless of anchor position.  Be warned, there's a reason the functionality
    // is hidden in the editor, as the behavior is unintuitive when adjusting the parent's rect.
    // If you're calling these every frame or otherwise updating frequently, shouldn't be a problem, though.
    //
    //Keep in mind that these functions all use standard directions when determining positioning; this means 
    // that unlike the inspector, positive ALWAYS means to the right/top, and negative ALWAYS means to the left/
    // bottom.  If you want true inspector functionality, use Left() and so on, below.
    //
    //E.g., SetLeftEdge(-10) will turn
    /*
        .__________.
        |          |
        |          |
        |   [ ]    |
        |          |
        |__________|
    
            into
        .__________.
        |          |
        |          |
      [       ]    |
        |          |
        |__________|
 
      [ ] is the RectTransform, the bigger square is the parent
    */
    public static void SetLeft(this RectTransform rt, float distance)
    {
      float xmin = rt.GetParent().rect.xMin;
      float anchorFactor = rt.anchorMin.x * 2 - 1;
 
      rt.offsetMin = new Vector2(xmin + (xmin * anchorFactor) + distance, rt.offsetMin.y);
    }
    public static void SetRight(this RectTransform rt, float distance)
    {
      float xmax = rt.GetParent().rect.xMax;
      float anchorFactor = rt.anchorMax.x * 2 - 1;
 
      rt.offsetMax = new Vector2(xmax - (xmax * anchorFactor) + distance, rt.offsetMax.y);
    }
    public static void SetTop(this RectTransform rt, float top)
    {
      float ymax = rt.GetParent().rect.yMax;
      float anchorFactor = rt.anchorMax.y * 2 - 1;
 
      rt.offsetMax = new Vector2(rt.offsetMax.x, ymax - (ymax * anchorFactor) + top);
    }
    public static void SetBottom(this RectTransform rt, float distance)
    {
      float ymin = rt.GetParent().rect.yMin;
      float anchorFactor = rt.anchorMin.y * 2 - 1;
 
      rt.offsetMin = new Vector2(rt.offsetMin.x, ymin + (ymin * anchorFactor) + distance);
    }
 
    // Truly matches the functionality of the "Left" etc property in the inspector. This means that
    // Right(10) will actually move the right edge to 10 units from the LEFT of the parent's right edge.
    // In other words, all coordinates are "inside": they measure distance from the parent's edge to the inside of the parent.
    public static void Left(this RectTransform rt, float distance)
    {
      rt.SetLeft(distance);
    }
    public static void Right(this RectTransform rt, float distance)
    {
      rt.SetRight(-distance);
    }
    public static void Top(this RectTransform rt, float distance)
    {
      rt.SetTop(-distance);
    }
    public static void Bottom(this RectTransform rt, float distance)
    {
      rt.SetRight(distance);
    }
 
 
    public static void SetLeftFrom(this RectTransform rt, MinMax01 anchor, float distance)
    {
      Vector2 origin = rt.AnchorToParentSpace(anchor.min - rt.anchorMin);
 
      rt.offsetMin = new Vector2(origin.x + distance, rt.offsetMin.y);
    }
    public static void SetRightFrom(this RectTransform rt, MinMax01 anchor, float distance)
    {
      Vector2 origin = rt.AnchorToParentSpace(anchor.max - rt.anchorMax);
 
      rt.offsetMax = new Vector2(origin.x + distance, rt.offsetMax.y);
    }
    public static void SetTopFrom(this RectTransform rt, MinMax01 anchor, float distance)
    {
      Vector2 origin = rt.AnchorToParentSpace(anchor.max - rt.anchorMax);
 
      rt.offsetMax = new Vector2(rt.offsetMax.x, origin.y + distance);
    }
    public static void SetBottomFrom(this RectTransform rt, MinMax01 anchor, float distance)
    {
      Vector2 origin = rt.AnchorToParentSpace(anchor.min - rt.anchorMin);
 
      rt.offsetMin = new Vector2(rt.offsetMin.x, origin.y + distance);
    }
 
 
    
    public static void SetRelativeLeft(this RectTransform rt, float distance)
    {
      rt.offsetMin = new Vector2(rt.anchoredPosition.x + distance, rt.offsetMin.y);
    }
    public static void SetRelativeRight(this RectTransform rt, float distance)
    {
      rt.offsetMax = new Vector2(rt.anchoredPosition.x + distance, rt.offsetMax.y);
    }
    public static void SetRelativeTop(this RectTransform rt, float distance)
    {
      rt.offsetMax = new Vector2(rt.offsetMax.x, rt.anchoredPosition.y + distance);
    }
    public static void SetRelativeBottom(this RectTransform rt, float distance)
    {
      rt.offsetMin = new Vector2(rt.offsetMin.x, rt.anchoredPosition.y + distance);
    }
    
    
    
    //E.g., MoveLeft(0) will look like this:
    /*
        .__________.
        |          |
        |          |
       [|]         |
        |          |
        |__________|
    */
    public static void MoveLeft(this RectTransform rt, float left = 0)
    {
      float xmin = rt.GetParent().rect.xMin;
      float center = rt.anchorMax.x - rt.anchorMin.x;
      float anchorFactor = rt.anchorMax.x * 2 - 1;
      rt.anchoredPosition = new Vector2(xmin + (xmin * anchorFactor) + left - (center * xmin), rt.anchoredPosition.y);
    }
    public static void MoveRight(this RectTransform rt, float right = 0)
    {
      float xmax = rt.GetParent().rect.xMax;
      float center = rt.anchorMax.x - rt.anchorMin.x;
      float anchorFactor = rt.anchorMax.x * 2 - 1;
      rt.anchoredPosition = new Vector2(xmax - (xmax * anchorFactor) - right + (center * xmax), rt.anchoredPosition.y);
    }
    public static void MoveTop(this RectTransform rt, float top = 0)
    {
      float ymax = rt.GetParent().rect.yMax;
      float center = rt.anchorMax.y - rt.anchorMin.y;
      float anchorFactor = rt.anchorMax.y * 2 - 1;
      rt.anchoredPosition = new Vector2(rt.anchoredPosition.x, ymax - (ymax * anchorFactor) - top + (center * ymax));
    }
    public static void MoveBottom(this RectTransform rt, float bottom = 0)
    {
      float ymin = rt.GetParent().rect.yMin;
      float center = rt.anchorMax.y - rt.anchorMin.y;
      float anchorFactor = rt.anchorMax.y * 2 - 1;
      rt.anchoredPosition = new Vector2(rt.anchoredPosition.x, ymin + (ymin * anchorFactor) + bottom - (center * ymin));
    }
 
    
    
    //Moves the RectTransform to align the child left edge with the parent left edge, etc.  
    //E.g., MoveLeftInside(0) will look like this:
    /*
        .__________.
        |          |
        |          |
        [ ]        |
        |          |
        |__________|
    */
    public static void MoveLeftInside(this RectTransform rt, float distance = 0)
    {
      rt.MoveLeft(distance + rt.GetWidth() / 2);
    }
    public static void MoveRightInside(this RectTransform rt, float distance = 0)
    {
      rt.MoveRight(distance + rt.GetWidth() / 2);
    }
    public static void MoveTopInside(this RectTransform rt, float distance = 0)
    {
      rt.MoveTop(distance + rt.GetHeight() / 2);
    }
    public static void MoveBottomInside(this RectTransform rt, float distance = 0)
    {
      rt.MoveBottom(distance + rt.GetHeight() / 2);
    }
 
    
    //Moves the RectTransform to align the child right edge with the parent left edge, etc
    //E.g., MoveLeftOutside(0) will look like this:
    /*
        .__________.
        |          |
        |          |
      [ ]          |
        |          |
        |__________|
    */
    public static void MoveLeftOutside(this RectTransform rt, float distance = 0)
    {
      rt.MoveLeft(distance - rt.GetWidth() / 2);
    }
    public static void MoveRightOutside(this RectTransform rt, float distance = 0)
    {
      rt.MoveRight(distance - rt.GetWidth() / 2);
    }
    public static void MoveTopOutside(this RectTransform rt, float distance = 0)
    {
      rt.MoveTop(distance - rt.GetHeight() / 2);
    }
    public static void MoveBottomOutside(this RectTransform rt, float distance = 0)
    {
      rt.MoveBottom(distance - rt.GetHeight() / 2);
    }
 
    
    public static void Move(this RectTransform rt, float x, float y)
    {
      rt.MoveLeft(x);
      rt.MoveBottom(y);
    }
    public static void Move(this RectTransform rt, Vector2 point)
    {
      rt.MoveLeft(point.x);
      rt.MoveBottom(point.y);
    }
    
    
    public static void MoveInside(this RectTransform rt, float x, float y)
    {
      rt.MoveLeftInside(x);
      rt.MoveBottomInside(y);
    }
    public static void MoveInside(this RectTransform rt, Vector2 point)
    {
      rt.MoveLeftInside(point.x);
      rt.MoveBottomInside(point.y);
    }
    
    
    public static void MoveOutside(this RectTransform rt, float x, float y)
    {
      rt.MoveLeftOutside(x);
      rt.MoveBottomOutside(y);
    }
    public static void MoveOutside(this RectTransform rt, Vector2 point)
    {
      rt.MoveLeftOutside(point.x);
      rt.MoveBottomOutside(point.y);
    }
 
    
    public static void MoveFrom(this RectTransform rt, MinMax01 anchor, Vector2 point)
    {
      rt.MoveFrom(anchor, point.x, point.y);
    }
    public static void MoveFrom(this RectTransform rt, MinMax01 anchor, float x, float y)
    {
      Vector2 origin = rt.AnchorToParentSpace(AnchorOrigin(anchor) - rt.AnchorOrigin());
      rt.anchoredPosition = new Vector2(origin.x + x, origin.y + y);
    }
 
    
    public static Vector2 ParentToChildSpace(this RectTransform rt, Vector2 point)
    {
      return rt.ParentToChildSpace(point.x, point.y);
    }
    public static Vector2 ParentToChildSpace(this RectTransform rt, float x, float y)
    {
      float xmin = rt.GetParent().rect.xMin;
      float ymin = rt.GetParent().rect.yMin;
      float anchorFactorX = rt.anchorMin.x * 2 - 1;
      float anchorFactorY = rt.anchorMin.y * 2 - 1;
      return new Vector2(xmin + (xmin * anchorFactorX) + x, ymin + (ymin * anchorFactorY) + y);
    }
 
 
    public static Vector2 ChildToParentSpace(this RectTransform rt, float x, float y)
    {
      return rt.AnchorOriginParent() + new Vector2(x, y);
    }
    public static Vector2 ChildToParentSpace(this RectTransform rt, Vector2 point)
    {
      return rt.AnchorOriginParent() + point;
    }
 
 
    public static Vector2 ParentToAnchorSpace(this RectTransform rt, Vector2 point)
    {
      return rt.ParentToAnchorSpace(point.x, point.y);
    }
    public static Vector2 ParentToAnchorSpace(this RectTransform rt, float x, float y)
    {
      Rect parent = rt.GetParent().rect;
      if (parent.width != 0)
        x /= parent.width;
      else
        x = 0;
 
      if (parent.height != 0)
        y /= parent.height;
      else
        y = 0;
 
      return new Vector2(x, y);
    }
 
    
    public static Vector2 AnchorToParentSpace(this RectTransform rt, float x, float y)
    {
      return new Vector2(x * rt.GetParent().rect.width, y * rt.GetParent().rect.height);
    }
    public static Vector2 AnchorToParentSpace(this RectTransform rt, Vector2 point)
    {
      return new Vector2(point.x * rt.GetParent().rect.width, point.y * rt.GetParent().rect.height);
    }
 
 
   
    public static Vector2 AnchorOrigin(this RectTransform rt)
    {
      return AnchorOrigin(rt.GetAnchors());
    }
    public static Vector2 AnchorOrigin(MinMax01 anchor)
    {
      float x = anchor.min.x + (anchor.max.x - anchor.min.x) / 2;
      float y = anchor.min.y + (anchor.max.y - anchor.min.y) / 2;
 
      return new Vector2(x, y);
    }
 
    public static Vector2 AnchorOriginParent(this RectTransform rt)
    {
      return Vector2.Scale(rt.AnchorOrigin(), new Vector2(rt.GetParent().rect.width, rt.GetParent().rect.height));
    }
 
    public static Canvas GetRootCanvas(this RectTransform rt)
    {
      Canvas rootCanvas = rt.GetComponentInParent<Canvas>();
 
      while (!rootCanvas.isRootCanvas)
        rootCanvas = rootCanvas.transform.parent.GetComponentInParent<Canvas>();
 
      return rootCanvas;
    }
 
    public static void SetProperties(this RectTransform rectTrans, RectTransform properties)
    {
      rectTrans.SetProperties(properties.anchoredPosition, properties.anchoredPosition3D, properties.anchorMax,
        properties.anchorMin, properties.offsetMax, properties.offsetMin, properties.pivot, properties.sizeDelta, properties.transform);
    }
 
    public static void SetProperties(this RectTransform rectTrans, Vector2 anchoredPosition, Vector3 anchoredPosition3D,
      Vector2 anchorMax, Vector2 anchorMin, Vector2 offsetMax, Vector2 offsetMin, Vector2 pivot, Vector2 sizeDelta, Transform trans = null)
    {
      rectTrans.anchoredPosition = anchoredPosition;
      rectTrans.anchoredPosition3D = anchoredPosition3D;
      rectTrans.anchorMax = anchorMax;
      rectTrans.anchorMin = anchorMin;
      rectTrans.offsetMax = offsetMax;
      rectTrans.offsetMin = offsetMin;
      rectTrans.pivot = pivot;
      rectTrans.sizeDelta = sizeDelta;
      if (trans) rectTrans.transform.SetProperties(trans);
    }
 
    public static void SetLerp(this RectTransform self, RectTransform a, RectTransform b, float t)
    {
      self.SetProperties(
        Vector2.Lerp(a.anchoredPosition, b.anchoredPosition, t),
        Vector3.Lerp(a.anchoredPosition3D, b.anchoredPosition3D, t),
        Vector2.Lerp(a.anchorMax, b.anchorMax, t),
        Vector2.Lerp(a.anchorMin, b.anchorMin, t),
        Vector2.Lerp(a.offsetMax, b.offsetMax, t),
        Vector2.Lerp(a.offsetMin, b.offsetMin, t),
        Vector2.Lerp(a.pivot, b.pivot, t),
        Vector2.Lerp(a.sizeDelta, b.sizeDelta, t)
      );
      self.transform.SetLerp(a.transform, b.transform, t);
    }
 
  }
}