Example #1
0
    public static Vector2 GetPosition(this RectTransform source)
    {
        AnchorPresets allign = GetAnchor(source);

        switch (allign)
        {
        case AnchorPresets.TopLeft:
        case AnchorPresets.TopCenter:
        case AnchorPresets.TopRight:
        case AnchorPresets.MiddleLeft:
        case AnchorPresets.MiddleCenter:
        case AnchorPresets.MiddleRight:
        case AnchorPresets.BottomLeft:
        case AnchorPresets.BottonCenter:
        case AnchorPresets.BottomRight:
            break;

        case AnchorPresets.HorStretchTop:
        case AnchorPresets.HorStretchMiddle:
        case AnchorPresets.HorStretchBottom:
            return(new Vector2(source.anchoredPosition.x, -source.anchoredPosition.y));

        case AnchorPresets.VertStretchLeft:
        case AnchorPresets.VertStretchCenter:
        case AnchorPresets.VertStretchRight:
            break;

        case AnchorPresets.StretchAll:
            return(new Vector2(source.anchoredPosition.x, -source.anchoredPosition.y));
        }
        return(source.anchoredPosition);
    }
Example #2
0
    public static void SetPosition(this RectTransform source, float offsetx, float offsety)
    {
        AnchorPresets allign = GetAnchor(source);

        switch (allign)
        {
        case AnchorPresets.TopLeft:
        case AnchorPresets.TopCenter:
        case AnchorPresets.TopRight:
        case AnchorPresets.MiddleLeft:
        case AnchorPresets.MiddleCenter:
        case AnchorPresets.MiddleRight:
        case AnchorPresets.BottomLeft:
        case AnchorPresets.BottonCenter:
        case AnchorPresets.BottomRight:
            source.anchoredPosition = new Vector3(offsetx, offsety, 0f);
            break;

        case AnchorPresets.HorStretchTop:
        case AnchorPresets.HorStretchMiddle:
        case AnchorPresets.HorStretchBottom:
            source.anchoredPosition = new Vector3(offsetx, -offsety, 0f);
            break;

        case AnchorPresets.VertStretchLeft:
        case AnchorPresets.VertStretchCenter:
        case AnchorPresets.VertStretchRight:
            source.anchoredPosition = new Vector3(offsetx, offsety, 0f);
            break;

        case AnchorPresets.StretchAll:
            source.anchoredPosition = new Vector3(offsetx, -offsety, 0f);
            break;
        }
    }
Example #3
0
 public static void SetAnchors(this RectTransform rect, AnchorPresets align, Vector2 offsetMin, Vector2 offsetMax)
 {
     GetAnchors(align, out Vector2 anchorMin, out Vector2 anchorMax);
     rect.anchorMin = anchorMin;
     rect.anchorMax = anchorMax;
     rect.offsetMin = offsetMin;
     rect.offsetMax = offsetMax;
 }
Example #4
0
    void SetRectTransform(Vector2 rectSize, AnchorPresets anchor, PivotPresets pivot, AnchorPresets iconAnchor, PivotPresets iconPivot)
    {
        rectTransform.sizeDelta = rectSize;
        rectTransform.SetPivot(pivot);
        rectTransform.SetAnchor(anchor);

        iconTransform.SetAnchor(iconAnchor);
        iconTransform.SetPivot(iconPivot);
    }
Example #5
0
    public static bool SetAnchor(this RectTransform source, AnchorPresets allign)
    {
        if (__dic_anchor_1.ContainsKey(allign) == true)
        {
            Vector4 v4 = __dic_anchor_1[allign];

            source.anchorMin = new Vector2(v4.x, v4.y);
            source.anchorMax = new Vector2(v4.z, v4.w);
            return(true);
        }
        return(false);
    }
 private void UpdateDisplayableAnchor(string displayableName, AnchorPresets anchor)
 {
     if (displayableImages.ContainsKey(displayableName))
     {
         displayableImages[displayableName].imageRect.SetAnchor(anchor);
         StartCoroutine(DissolveIn(displayableImages[displayableName]));
     }
     else
     {
         Debug.LogWarning("Updapte Position Error: Can't find " + displayableName);
     }
 }
Example #7
0
 public static void UseAnchor(
     RectTransform rt,
     RectTransform anchor,
     Vector2 offset,
     AnchorPresets anchorPreset,
     PivotPresets pivotPreset)
 {
     if (rt == null || anchor == null)
     {
         return;
     }
     rt.SetParent(anchor, false);
     rt.SetAnchor(anchorPreset);
     rt.SetPivot(pivotPreset);
     rt.anchoredPosition = offset;
 }
Example #8
0
    public static void SetSize(this RectTransform source, float width, float height)
    {
        AnchorPresets allign = GetAnchor(source);

        switch (allign)
        {
        case AnchorPresets.TopLeft:
        case AnchorPresets.TopCenter:
        case AnchorPresets.TopRight:
        case AnchorPresets.MiddleLeft:
        case AnchorPresets.MiddleCenter:
        case AnchorPresets.MiddleRight:
        case AnchorPresets.BottomLeft:
        case AnchorPresets.BottonCenter:
        case AnchorPresets.BottomRight:
            source.sizeDelta = new Vector2(width, height);
            break;

        case AnchorPresets.HorStretchTop:
        case AnchorPresets.HorStretchMiddle:
        case AnchorPresets.HorStretchBottom:
        {
            RectTransform parent = source.parent.GetComponent <RectTransform>();
            Vector2       size   = parent.GetSize();
            source.sizeDelta = new Vector2(width - size.x, height);
        }
        break;

        case AnchorPresets.VertStretchLeft:
        case AnchorPresets.VertStretchCenter:
        case AnchorPresets.VertStretchRight:
        {
            RectTransform parent = source.parent.GetComponent <RectTransform>();
            Vector2       size   = parent.GetSize();
            source.sizeDelta = new Vector2(width, height - size.y);
        }
        break;

        case AnchorPresets.StretchAll:
        {
            RectTransform parent = source.parent.GetComponent <RectTransform>();
            Vector2       size   = parent.GetSize();
            source.sizeDelta = new Vector2(width - size.x, height - size.y);
        }
        break;
        }
    }
Example #9
0
    //private static AnchorPresets anchor;
    public static AnchorPresets GetAnchor(this RectTransform source)
    {
        if (source.anchorMin != source.anchorMax)
        {
            Debug.LogWarning($"Unhandled AnchorPreset, GetAnchor() returned default!");
            return(AnchorPresets.TopLeft);
        }

        VerticalAnchorPoint   verticalAnchorPoint   = (VerticalAnchorPoint)((int)source.anchorMin.y * 100f);
        HorizontalAnchorPoint horizontalAnchorPoint = (HorizontalAnchorPoint)((int)source.anchorMin.x * 100f);

        var currentAnchorString = verticalAnchorPoint.ToString() + horizontalAnchorPoint.ToString();

        AnchorPresets anchor = (AnchorPresets)System.Enum.Parse(typeof(AnchorPresets), currentAnchorString);

        return(anchor);
    }
        public static Image AddImage(string _name, Transform _parent, Vector2 _size, AnchorPresets _anchor, PivotPresets _pivot, Rect _offset, Color _color)
        {
            if (_parent == null)
            {
                return(null);
            }

            Image         _image     = null;
            RectTransform _transform = CreateRectTransformObject(_name, _parent, _size, _anchor, _pivot, _offset);

            if (_transform != null)
            {
                _transform.gameObject.AddComponent <CanvasRenderer>();
                _image       = _transform.gameObject.AddComponent <Image>();
                _image.color = _color;
            }

            return(_image);
        }
Example #11
0
        public static RectTransform Create(string name,
                                           Transform parent,
                                           AnchorPresets anchor,
                                           PivotPresets pivot,
                                           Vector2 size,
                                           Vector2 position)
        {
            var go = new GameObject(name);
            var t  = go.AddComponent <RectTransform>();

            t.SetParent(parent);
            t.localScale    = Vector3.one;
            t.localRotation = Quaternion.identity;
            t.SetAnchor(AnchorPresets.HorStretchTop);
            t.SetPivot(PivotPresets.TopCenter);
            t.sizeDelta        = size;
            t.anchoredPosition = position;
            return(t);
        }
        private static Vector2 ToSizeDelta(AnchorPresets preset, RectTransform rt)
        {
            switch (preset)
            {
            case AnchorPresets.StretchTop:
            case AnchorPresets.StretchMiddle:
            case AnchorPresets.StretchBottom:
                return(new Vector2(0.0f, rt.sizeDelta.y));

            case AnchorPresets.StretchLeft:
            case AnchorPresets.StretchCenter:
            case AnchorPresets.StretchRight:
                return(new Vector2(rt.sizeDelta.x, 0.0f));

            case AnchorPresets.StretchAll:
                return(Vector2.zero);
            }

            return(rt.sizeDelta);
        }
        private static Anchor ToAnchor(AnchorPresets preset)
        {
            switch (preset)
            {
            case AnchorPresets.TopLeft: return(AnchorMinMax(0.0f, 1.0f, 0.0f, 1.0f));

            case AnchorPresets.TopCenter: return(AnchorMinMax(0.5f, 1.0f, 0.5f, 1.0f));

            case AnchorPresets.TopRight: return(AnchorMinMax(1.0f, 1.0f, 1.0f, 1.0f));

            case AnchorPresets.MiddleLeft: return(AnchorMinMax(0.0f, 0.5f, 0.0f, 0.5f));

            case AnchorPresets.MiddleCenter: return(AnchorMinMax(0.5f, 0.5f, 0.5f, 0.5f));

            case AnchorPresets.MiddleRight: return(AnchorMinMax(1.0f, 0.5f, 1.0f, 0.5f));

            case AnchorPresets.BottomLeft: return(AnchorMinMax(0.0f, 0.0f, 0.0f, 0.0f));

            case AnchorPresets.BottomCenter: return(AnchorMinMax(0.5f, 0.0f, 0.5f, 0.0f));

            case AnchorPresets.BottomRight: return(AnchorMinMax(1.0f, 0.0f, 1.0f, 0.0f));

            case AnchorPresets.StretchTop: return(AnchorMinMax(0.0f, 1.0f, 1.0f, 1.0f));

            case AnchorPresets.StretchMiddle: return(AnchorMinMax(0.0f, 0.5f, 1.0f, 0.5f));

            case AnchorPresets.StretchBottom: return(AnchorMinMax(0.0f, 0.0f, 1.0f, 0.0f));

            case AnchorPresets.StretchLeft: return(AnchorMinMax(0.0f, 0.0f, 0.0f, 1.0f));

            case AnchorPresets.StretchCenter: return(AnchorMinMax(0.5f, 0.0f, 0.5f, 1.0f));

            case AnchorPresets.StretchRight: return(AnchorMinMax(1.0f, 0.0f, 1.0f, 1.0f));

            case AnchorPresets.StretchAll: return(AnchorMinMax(0.0f, 0.0f, 1.0f, 1.0f));
            }

            return(AnchorMinMax(0.5f, 0.5f, 0.5f, 0.5f));
        }
Example #14
0
    public GameObject addSprite(string name, Sprite sprite, Vector2 scale,
                                AnchorPresets anchorPreset = AnchorPresets.MiddleCenter,
                                Vector2Int pos             = new Vector2Int(),
                                PivotPresets pivotPreset   = PivotPresets.MiddleCenter)
    {
        GameObject gameObject = new GameObject();

        gameObject.transform.parent = canvas.transform;
        gameObject.name             = name;

        Image image = gameObject.AddComponent <Image>();

        image.sprite = sprite;

        RectTransform rectTransform = image.GetComponent <RectTransform>();

        RectTransformExtensions.SetAnchor(rectTransform, anchorPreset, pos.x, pos.y);
        RectTransformExtensions.SetPivot(rectTransform, pivotPreset);
        rectTransform.localScale = scale;

        return(gameObject);
    }
        private static Vector2 ToPivot(AnchorPresets presets)
        {
            switch (presets)
            {
            case AnchorPresets.TopLeft: return(new Vector2(0.0f, 1.0f));

            case AnchorPresets.TopCenter: return(new Vector2(0.5f, 1.0f));

            case AnchorPresets.TopRight: return(new Vector2(1.0f, 1.0f));

            case AnchorPresets.MiddleLeft: return(new Vector2(0.0f, 0.5f));

            case AnchorPresets.MiddleCenter: return(new Vector2(0.5f, 0.5f));

            case AnchorPresets.MiddleRight: return(new Vector2(1.0f, 0.5f));

            case AnchorPresets.BottomLeft: return(new Vector2(0.0f, 0.0f));

            case AnchorPresets.BottomCenter: return(new Vector2(0.5f, 0.0f));

            case AnchorPresets.BottomRight: return(new Vector2(1.0f, 0.0f));

            case AnchorPresets.StretchTop: return(new Vector2(0.5f, 1.0f));

            case AnchorPresets.StretchMiddle: return(new Vector2(0.5f, 0.5f));

            case AnchorPresets.StretchBottom: return(new Vector2(0.5f, 0.0f));

            case AnchorPresets.StretchLeft: return(new Vector2(0.0f, 0.5f));

            case AnchorPresets.StretchCenter: return(new Vector2(0.5f, 0.5f));

            case AnchorPresets.StretchRight: return(new Vector2(1.0f, 0.5f));

            case AnchorPresets.StretchAll: return(new Vector2(0.5f, 0.5f));
            }

            return(new Vector2(0.5f, 0.5f));
        }
        private static Vector2 ToAnchoredPosition(AnchorPresets preset, RectTransform rt)
        {
            switch (preset)
            {
            case AnchorPresets.TopLeft: return(new Vector2(rt.sizeDelta.x * rt.pivot.x, -rt.sizeDelta.y + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.TopCenter: return(new Vector2(rt.sizeDelta.x * (rt.pivot.x - 0.5f), -rt.sizeDelta.y + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.TopRight: return(new Vector2(-rt.sizeDelta.x + rt.pivot.x * rt.sizeDelta.x, -rt.sizeDelta.y + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.MiddleLeft: return(new Vector2(rt.sizeDelta.x * +rt.pivot.x, -rt.sizeDelta.y * 0.5f + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.MiddleCenter: return(new Vector2(rt.sizeDelta.x * (rt.pivot.x - 0.5f), -rt.sizeDelta.y * 0.5f + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.MiddleRight: return(new Vector2(-rt.sizeDelta.x + rt.pivot.x * rt.sizeDelta.x, -rt.sizeDelta.y * 0.5f + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.BottomLeft: return(new Vector2(rt.sizeDelta.x * +rt.pivot.x, rt.sizeDelta.y * rt.pivot.y));

            case AnchorPresets.BottomCenter: return(new Vector2(rt.sizeDelta.x * (rt.pivot.x - 0.5f), rt.sizeDelta.y * rt.pivot.y));

            case AnchorPresets.BottomRight: return(new Vector2(-rt.sizeDelta.x + rt.pivot.x * rt.sizeDelta.x, rt.sizeDelta.y * rt.pivot.y));

            case AnchorPresets.StretchTop: return(new Vector2(0.0f, rt.sizeDelta.y * -rt.sizeDelta.y + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.StretchMiddle: return(new Vector2(0.0f, -rt.sizeDelta.y * 0.5f + rt.pivot.y * rt.sizeDelta.y));

            case AnchorPresets.StretchBottom: return(new Vector2(0.0f, rt.sizeDelta.y * rt.pivot.y));

            case AnchorPresets.StretchLeft: return(new Vector2(rt.sizeDelta.x * rt.pivot.x, 0.0f));

            case AnchorPresets.StretchCenter: return(new Vector2(rt.sizeDelta.x * (rt.pivot.x - 0.5f), 0.0f));

            case AnchorPresets.StretchRight: return(new Vector2(-rt.sizeDelta.x + rt.pivot.x * rt.sizeDelta.x, 0.0f));

            case AnchorPresets.StretchAll: return(Vector2.zero);
            }

            return(Vector2.zero);
        }
        public static Text AddText(string _name, Transform _parent, Vector2 _size, AnchorPresets _anchor, PivotPresets _pivot, Rect _offset, Color _color, string _value)
        {
            if (_parent == null)
            {
                return(null);
            }

            Text          _text           = null;
            RectTransform _text_transform = CreateRectTransformObject(_name, _parent, _size, _anchor, _pivot, _offset);

            if (_text_transform != null)
            {
                _text_transform.gameObject.AddComponent <CanvasRenderer>();
                _text       = _text_transform.gameObject.AddComponent <Text>();
                _text.color = _color;
                _text.resizeTextForBestFit = true;
                _text.text      = _value;
                _text.alignment = TextAnchor.MiddleCenter;
            }

            return(_text);
        }
        public static void SetAnchorPreset(this RectTransform rectTransform, AnchorPresets preset, bool setPivot = false, bool setPos = false)
        {
            var anchor = ToAnchor(preset);

            rectTransform.anchorMin = anchor.min;
            rectTransform.anchorMax = anchor.max;

            if (setPivot)
            {
                rectTransform.pivot = ToPivot(preset);
            }

            if (setPos)
            {
                rectTransform.anchoredPosition = ToAnchoredPosition(preset, rectTransform);
                rectTransform.sizeDelta        = ToSizeDelta(preset, rectTransform);
            }

            if (setPivot && setPos)
            {
                rectTransform.anchoredPosition = Vector2.zero;
            }
        }
Example #19
0
 public void Settings(out Color panelColor, out Color textColor,
                      out HumanBodyBones placeBone, out Vector2 placeOffset, out Vector2 panelCollar,
                      out AnchorPresets anchor, out PivotPresets pivot, out QuoteStyle quoteStyle, out int listMax, out AlphaStyle _alphaStyle,
                      out float alphaChangingTime, out Vector3 moveDirection, out float movingTime,
                      out BackImage backImage, out int fontSize, out Font fonts)
 {
     panelColor        = PanelColor;
     textColor         = TextColor;
     placeBone         = PlaceBone;
     placeOffset       = PlaceOffset;
     panelCollar       = PanelCollar;
     anchor            = Anchor;
     pivot             = Pivot;
     quoteStyle        = QuoteStyle;
     listMax           = ListMax;
     _alphaStyle       = alphaStyle;
     alphaChangingTime = AlphaChangingTime;
     moveDirection     = MoveDirection;
     movingTime        = MovingTime;
     backImage         = BackImg;
     fontSize          = FontSize;
     fonts             = font;
 }
Example #20
0
    public GameObject addText(string name, string text, int fontSize, Vector2 scale,
                              AnchorPresets anchorPreset = AnchorPresets.MiddleCenter,
                              Vector2Int pos             = new Vector2Int(),
                              PivotPresets pivotPreset   = PivotPresets.MiddleCenter)
    {
        GameObject gameObject = new GameObject();

        gameObject.transform.parent = canvas.transform;
        gameObject.name             = name;

        Text textObject = gameObject.AddComponent <Text>();

        textObject.text     = text;
        textObject.font     = font;
        textObject.fontSize = fontSize;

        RectTransform rectTransform = textObject.GetComponent <RectTransform>();

        RectTransformExtensions.SetAnchor(rectTransform, anchorPreset, pos.x, pos.y);
        RectTransformExtensions.SetPivot(rectTransform, pivotPreset);
        rectTransform.localScale = scale;

        return(gameObject);
    }
        public static AnchorPresets GetAnchorPresets(this RectTransform source)
        {
            AnchorPresets result = AnchorPresets.UnKnown;

            if (source.anchorMin == new Vector2(0, 1) &&
                source.anchorMax == new Vector2(0, 1))
            {
                result = AnchorPresets.TopLeft;
            }

            if (source.anchorMin == new Vector2(0.5f, 1) &&
                source.anchorMax == new Vector2(0.5f, 1))
            {
                result = AnchorPresets.TopCenter;
            }

            if (source.anchorMin == new Vector2(1, 1) &&
                source.anchorMax == new Vector2(1, 1))
            {
                result = AnchorPresets.TopRight;
            }

            if (source.anchorMin == new Vector2(0, 0.5f) &&
                source.anchorMax == new Vector2(0, 0.5f))
            {
                result = AnchorPresets.MiddleLeft;
            }
            if (source.anchorMin == new Vector2(0.5f, 0.5f) &&
                source.anchorMax == new Vector2(0.5f, 0.5f))
            {
                result = AnchorPresets.MiddleCenter;
            }

            if (source.anchorMin == new Vector2(1, 0.5f) &&
                source.anchorMax == new Vector2(1, 0.5f))
            {
                result = AnchorPresets.MiddleRight;
            }

            if (source.anchorMin == new Vector2(0, 0) &&
                source.anchorMax == new Vector2(0, 0))
            {
                result = AnchorPresets.BottomLeft;
            }

            if (source.anchorMin == new Vector2(0.5f, 0) &&
                source.anchorMax == new Vector2(0.5f, 0))
            {
                result = AnchorPresets.BottonCenter;
            }

            if (source.anchorMin == new Vector2(1, 0) &&
                source.anchorMax == new Vector2(1, 0))
            {
                result = AnchorPresets.BottomRight;
            }

            if (source.anchorMin == new Vector2(0, 1) &&
                source.anchorMax == new Vector2(1, 1))
            {
                result = AnchorPresets.HorStretchTop;
            }

            if (source.anchorMin == new Vector2(0, 0.5f) &&
                source.anchorMax == new Vector2(1, 0.5f))
            {
                result = AnchorPresets.HorStretchMiddle;
            }

            if (source.anchorMin == new Vector2(0, 0) &&
                source.anchorMax == new Vector2(1, 0))
            {
                result = AnchorPresets.HorStretchBottom;
            }

            if (source.anchorMin == new Vector2(0, 0) &&
                source.anchorMax == new Vector2(0, 1))
            {
                result = AnchorPresets.VertStretchLeft;
            }

            if (source.anchorMin == new Vector2(0.5f, 0) &&
                source.anchorMax == new Vector2(0.5f, 1))
            {
                result = AnchorPresets.VertStretchCenter;
            }

            if (source.anchorMin == new Vector2(1, 0) &&
                source.anchorMax == new Vector2(1, 1))
            {
                result = AnchorPresets.VertStretchRight;
            }

            if (source.anchorMin == new Vector2(0, 0) &&
                source.anchorMax == new Vector2(1, 1))
            {
                result = AnchorPresets.StretchAll;
            }

            return(result);
        }
Example #22
0
 public AnchorPresetData(AnchorPresets preset, Vector2 min, Vector2 max)
 {
     Preset = preset;
     Min    = min;
     Max    = max;
 }
        public static void SetAnchor(this RectTransform _source, AnchorPresets _align, int _offset_x = 0, int _offset_y = 0)
        {
            _source.anchoredPosition3D = new Vector3(_offset_x, _offset_y, 0);

            switch (_align)
            {
            case (AnchorPresets.TopLeft):
            {
                _source.anchorMin = new Vector2(0, 1);
                _source.anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.TopCenter):
            {
                _source.anchorMin = new Vector2(0.5f, 1);
                _source.anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.TopRight):
            {
                _source.anchorMin = new Vector2(1, 1);
                _source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.MiddleLeft):
            {
                _source.anchorMin = new Vector2(0, 0.5f);
                _source.anchorMax = new Vector2(0, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleCenter):
            {
                _source.anchorMin = new Vector2(0.5f, 0.5f);
                _source.anchorMax = new Vector2(0.5f, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleRight):
            {
                _source.anchorMin = new Vector2(1, 0.5f);
                _source.anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.BottomLeft):
            {
                _source.anchorMin = new Vector2(0, 0);
                _source.anchorMax = new Vector2(0, 0);
                break;
            }

            case (AnchorPresets.BottonCenter):
            {
                _source.anchorMin = new Vector2(0.5f, 0);
                _source.anchorMax = new Vector2(0.5f, 0);
                break;
            }

            case (AnchorPresets.BottomRight):
            {
                _source.anchorMin = new Vector2(1, 0);
                _source.anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.HorStretchTop):
            {
                _source.anchorMin = new Vector2(0, 1);
                _source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.HorStretchMiddle):
            {
                _source.anchorMin = new Vector2(0, 0.5f);
                _source.anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.HorStretchBottom):
            {
                _source.anchorMin = new Vector2(0, 0);
                _source.anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.VertStretchLeft):
            {
                _source.anchorMin = new Vector2(0, 0);
                _source.anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.VertStretchCenter):
            {
                _source.anchorMin = new Vector2(0.5f, 0);
                _source.anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.VertStretchRight):
            {
                _source.anchorMin = new Vector2(1, 0);
                _source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.StretchAll):
            {
                _source.anchorMin = new Vector2(0, 0);
                _source.anchorMax = new Vector2(1, 1);
                break;
            }
            }
        }
Example #24
0
 public void SetRectTransform(AnchorPresets anchor, PivotPresets pivot)
 {
     rectTransform.SetAnchor(anchor);
     rectTransform.SetPivot(pivot);
 }
Example #25
0
 public static void SetAnchor(this RectTransform source, AnchorPresets align, float offsetX = 0, float offsetY = 0)
 {
     source.anchoredPosition = new Vector3(offsetX, offsetY, 0);
     source.SetAnchor(align);
 }
Example #26
0
    public static RectTransform SetAnchor(this RectTransform source, AnchorPresets align)
    {
        switch (align)
        {
        case (AnchorPresets.TopLeft):
        {
            source.anchorMin = new Vector2(0, 1);
            source.anchorMax = new Vector2(0, 1);
            break;
        }

        case (AnchorPresets.TopCenter):
        {
            source.anchorMin = new Vector2(0.5f, 1);
            source.anchorMax = new Vector2(0.5f, 1);
            break;
        }

        case (AnchorPresets.TopRight):
        {
            source.anchorMin = new Vector2(1, 1);
            source.anchorMax = new Vector2(1, 1);
            break;
        }

        case (AnchorPresets.MiddleLeft):
        {
            source.anchorMin = new Vector2(0, 0.5f);
            source.anchorMax = new Vector2(0, 0.5f);
            break;
        }

        case (AnchorPresets.MiddleCenter):
        {
            source.anchorMin = new Vector2(0.5f, 0.5f);
            source.anchorMax = new Vector2(0.5f, 0.5f);
            break;
        }

        case (AnchorPresets.MiddleRight):
        {
            source.anchorMin = new Vector2(1, 0.5f);
            source.anchorMax = new Vector2(1, 0.5f);
            break;
        }

        case (AnchorPresets.BottomLeft):
        {
            source.anchorMin = new Vector2(0, 0);
            source.anchorMax = new Vector2(0, 0);
            break;
        }

        case (AnchorPresets.BottonCenter):
        {
            source.anchorMin = new Vector2(0.5f, 0);
            source.anchorMax = new Vector2(0.5f, 0);
            break;
        }

        case (AnchorPresets.BottomRight):
        {
            source.anchorMin = new Vector2(1, 0);
            source.anchorMax = new Vector2(1, 0);
            break;
        }

        case (AnchorPresets.HorizontalStretchTop):
        {
            source.anchorMin = new Vector2(0, 1);
            source.anchorMax = new Vector2(1, 1);
            break;
        }

        case (AnchorPresets.HorizontalStretchMiddle):
        {
            source.anchorMin = new Vector2(0, 0.5f);
            source.anchorMax = new Vector2(1, 0.5f);
            break;
        }

        case (AnchorPresets.HorizontalStretchBottom):
        {
            source.anchorMin = new Vector2(0, 0);
            source.anchorMax = new Vector2(1, 0);
            break;
        }

        case (AnchorPresets.VerticalStretchLeft):
        {
            source.anchorMin = new Vector2(0, 0);
            source.anchorMax = new Vector2(0, 1);
            break;
        }

        case (AnchorPresets.VerticalStretchCenter):
        {
            source.anchorMin = new Vector2(0.5f, 0);
            source.anchorMax = new Vector2(0.5f, 1);
            break;
        }

        case (AnchorPresets.VerticalStretchRight):
        {
            source.anchorMin = new Vector2(1, 0);
            source.anchorMax = new Vector2(1, 1);
            break;
        }

        case (AnchorPresets.StretchAll):
        {
            source.anchorMin = new Vector2(0, 0);
            source.anchorMax = new Vector2(1, 1);
            break;
        }
        }

        return(source);
    }
Example #27
0
 public static void SetAnchors(this RectTransform rect, AnchorPresets align)
 {
     SetAnchors(rect, align, Vector2.zero, Vector2.zero);
 }
Example #28
0
        public static void GetAnchors(AnchorPresets align, out Vector2 anchorMin, out Vector2 anchorMax)
        {
            switch (align)
            {
            case (AnchorPresets.TopLeft):
            {
                anchorMin = new Vector2(0, 1);
                anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.TopCenter):
            {
                anchorMin = new Vector2(0.5f, 1);
                anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.TopRight):
            {
                anchorMin = new Vector2(1, 1);
                anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.MiddleLeft):
            {
                anchorMin = new Vector2(0, 0.5f);
                anchorMax = new Vector2(0, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleCenter):
            {
                anchorMin = new Vector2(0.5f, 0.5f);
                anchorMax = new Vector2(0.5f, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleRight):
            {
                anchorMin = new Vector2(1, 0.5f);
                anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.BottomLeft):
            {
                anchorMin = new Vector2(0, 0);
                anchorMax = new Vector2(0, 0);
                break;
            }

            case (AnchorPresets.BottomCenter):
            {
                anchorMin = new Vector2(0.5f, 0);
                anchorMax = new Vector2(0.5f, 0);
                break;
            }

            case (AnchorPresets.BottomRight):
            {
                anchorMin = new Vector2(1, 0);
                anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.HorizontalStretchTop):
            {
                anchorMin = new Vector2(0, 1);
                anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.HorizontalStretchMiddle):
            {
                anchorMin = new Vector2(0, 0.5f);
                anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.HorizontalStretchBottom):
            {
                anchorMin = new Vector2(0, 0);
                anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.VerticalStretchLeft):
            {
                anchorMin = new Vector2(0, 0);
                anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.VerticalStretchCenter):
            {
                anchorMin = new Vector2(0.5f, 0);
                anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.VerticalStretchRight):
            {
                anchorMin = new Vector2(1, 0);
                anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.StretchAll):
            {
                anchorMin = new Vector2(0, 0);
                anchorMax = new Vector2(1, 1);
                break;
            }

            default:
                anchorMin = Vector2.zero;
                anchorMax = Vector2.one;
                break;
            }
        }
Example #29
0
        public static void SetAnchor(this RectTransform source, AnchorPresets allign, int offsetX = 0, int offsetY = 0)
        {
            source.anchoredPosition = new Vector3(offsetX, offsetY, 0);

            switch (allign)
            {
            case (AnchorPresets.TopLeft):
            {
                source.anchorMin = new Vector2(0, 1);
                source.anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.TopCenter):
            {
                source.anchorMin = new Vector2(0.5f, 1);
                source.anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.TopRight):
            {
                source.anchorMin = new Vector2(1, 1);
                source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.MiddleLeft):
            {
                source.anchorMin = new Vector2(0, 0.5f);
                source.anchorMax = new Vector2(0, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleCenter):
            {
                source.anchorMin = new Vector2(0.5f, 0.5f);
                source.anchorMax = new Vector2(0.5f, 0.5f);
                break;
            }

            case (AnchorPresets.MiddleRight):
            {
                source.anchorMin = new Vector2(1, 0.5f);
                source.anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.BottomLeft):
            {
                source.anchorMin = new Vector2(0, 0);
                source.anchorMax = new Vector2(0, 0);
                break;
            }

            case (AnchorPresets.BottonCenter):
            {
                source.anchorMin = new Vector2(0.5f, 0);
                source.anchorMax = new Vector2(0.5f, 0);
                break;
            }

            case (AnchorPresets.BottomRight):
            {
                source.anchorMin = new Vector2(1, 0);
                source.anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.HorStretchTop):
            {
                source.anchorMin = new Vector2(0, 1);
                source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.HorStretchMiddle):
            {
                source.anchorMin = new Vector2(0, 0.5f);
                source.anchorMax = new Vector2(1, 0.5f);
                break;
            }

            case (AnchorPresets.HorStretchBottom):
            {
                source.anchorMin = new Vector2(0, 0);
                source.anchorMax = new Vector2(1, 0);
                break;
            }

            case (AnchorPresets.VertStretchLeft):
            {
                source.anchorMin = new Vector2(0, 0);
                source.anchorMax = new Vector2(0, 1);
                break;
            }

            case (AnchorPresets.VertStretchCenter):
            {
                source.anchorMin = new Vector2(0.5f, 0);
                source.anchorMax = new Vector2(0.5f, 1);
                break;
            }

            case (AnchorPresets.VertStretchRight):
            {
                source.anchorMin = new Vector2(1, 0);
                source.anchorMax = new Vector2(1, 1);
                break;
            }

            case (AnchorPresets.StretchAll):
            {
                source.anchorMin = new Vector2(0, 0);
                source.anchorMax = new Vector2(1, 1);
                break;
            }
            }
        }
Example #30
0
 void AssignRectTransform(Vector2 rectSize, AnchorPresets anchor, PivotPresets pivot)
 {
     rectTransform.sizeDelta = rectSize;
     rectTransform.SetPivot(pivot);
     rectTransform.SetAnchor(anchor);
 }