统一用户界面布局元素最大尺寸

Question

在统一ui中，LayoutElement具有最小，优先和灵活的大小。 但没有最大尺寸属性。 实施例 如果我有一个文本1和

layoutElement.flxibleWith = 1

layoutElement.minHeight = 19

的text1与一行TXT：

但是当我在text1中加载文本1继续 无限制地传播它的高度。

我做了一个脚本

using UnityEngine; 
using System.Collections; 
using UnityEngine.UI; 

[ExecuteInEditMode] 
[RequireComponent(typeof(LayoutElement))] 

public class LayoutElementMaxSize : MonoBehaviour 
{ 

private LayoutElement layoutElement; 
private ContentSizeFitter contentSizeFitter; 
private RectTransform rectransform; 

public bool controllWidth; 
public bool controllHeight; 

public float maxHight; 
public float maxWidth; 

void Start() 
{ 
    layoutElement = GetComponent<LayoutElement>(); 
    rectransform = GetComponent<RectTransform>(); 
} 

public void Update() 
{ 
    if(rectransform.hasChanged) 
    { 
     rectransform.hasChanged = false; 

     if (controllHeight) 
     { 
      layoutElement.preferredHeight = -1; 

      layoutElement.CalculateLayoutInputHorizontal(); 
      layoutElement.CalculateLayoutInputVertical(); 

      if (rectransform.rect.height >= maxHight) 
      { 
       layoutElement.preferredHeight = maxHight; 
      } 
     } 

     if (controllWidth) 
     { 
      if (rectransform.rect.height >= maxWidth) 
      { 
       layoutElement.preferredWidth = maxWidth; 
      } 
      else 
      { 
       layoutElement.preferredWidth = -1; 
      } 
     } 
    } 
}} 

但它不是完整的申请我的要求PLZ对其采取看看..

Answer 1

我知道这是一个老问题，但我正在寻找这样的东西，我最终重写你的课程，现在对我来说工作得很好。我不再只是制作另一个MonoBehaviour，而是重写LayoutElement，我还添加了一个自定义检查器，以便编辑它。希望我的解决方案能够帮助你或任何喜欢这样的事情的人。

using UnityEngine; 
using UnityEngine.UI; 

#if UNITY_EDITOR 
using UnityEditor; 
#endif 

[RequireComponent(typeof(RectTransform))] 
[System.Serializable] 
public class LayoutMaxSize : LayoutElement 
{ 
    public float maxHeight = -1; 
    public float maxWidth = -1; 

    public override void CalculateLayoutInputHorizontal() 
    { 
     base.CalculateLayoutInputHorizontal(); 
     UpdateMaxSizes(); 
    } 

    public override void CalculateLayoutInputVertical() 
    { 
     base.CalculateLayoutInputVertical(); 
     UpdateMaxSizes(); 
    } 

    protected override void OnRectTransformDimensionsChange() 
    { 
     base.OnRectTransformDimensionsChange(); 
     UpdateMaxSizes(); 
    } 

    protected override void OnValidate() 
    { 
     base.OnValidate(); 
     UpdateMaxSizes(); 
    } 

    private void UpdateMaxSizes() 
    { 
     if (maxHeight != -1) 
     { 
      if (preferredHeight == -1 && maxHeight < GetComponent<RectTransform>().sizeDelta.y) 
      { 
       preferredHeight = maxHeight; 
      } 
      else if (preferredHeight != -1 && transform.childCount > 0) 
      { 
       bool first = true; 
       float biggestY = 0; 
       float lowestY = 0; 
       for (int i = 0; i < transform.childCount; i++) 
       { 
        var childrenTransform = transform.GetChild(i).GetComponent<RectTransform>(); 
        if (childrenTransform == null) continue; 
        var childPos = childrenTransform.localPosition; 
        var childSize = childrenTransform.sizeDelta; 
        var childPivot = childrenTransform.pivot; 
        if(first) 
        { 
         biggestY = childPos.y + (childSize.y * (1f - childPivot.y)); 
         lowestY = childPos.y - (childSize.y * childPivot.y); 
        } 
        else 
        { 
         biggestY = Mathf.Max(biggestY, childPos.y + (childSize.y * (1f - childPivot.y))); 
         lowestY = Mathf.Min(lowestY, childPos.y - (childSize.y * childPivot.y)); 
        } 
        first = false; 
       } 
       if (first) return; 
       var childrenYSize = Mathf.Abs(biggestY - lowestY); 
       if(preferredHeight > childrenYSize) 
       { 
        preferredHeight = -1; 
       } 
      } 
     } 
     if (maxWidth != -1) 
     { 
      if (preferredWidth == -1 && maxWidth < GetComponent<RectTransform>().sizeDelta.x) 
      { 
       preferredWidth = maxWidth; 
      } 
      else if (preferredWidth != -1 && transform.childCount > 0) 
      { 
       bool first = true; 
       float biggestX = 0; 
       float lowestX = 0; 
       for (int i = 0; i < transform.childCount; i++) 
       { 
        var childrenTransform = transform.GetChild(i).GetComponent<RectTransform>(); 
        if (childrenTransform == null) continue; 
        var childPos = childrenTransform.localPosition; 
        var childSize = childrenTransform.sizeDelta; 
        var childPivot = childrenTransform.pivot; 
        if (first) 
        { 
         biggestX = childPos.x + (childSize.x * (1f - childPivot.x)); 
         lowestX = childPos.x - (childSize.x * childPivot.x); 
        } 
        else 
        { 
         biggestX = Mathf.Max(biggestX, childPos.x + (childSize.x * (1f - childPivot.x))); 
         lowestX = Mathf.Min(lowestX, childPos.x - (childSize.x * childPivot.x)); 
        } 
        first = false; 
       } 
       if (first) return; 
       var childrenXSize = Mathf.Abs(biggestX - lowestX); 
       if (preferredWidth > childrenXSize) 
       { 
        preferredWidth = -1; 
       } 
      } 
     } 
    } 
} 

#if UNITY_EDITOR 
[CustomEditor(typeof(LayoutMaxSize))] 
public class LayoutMaxSizeEditor : Editor 
{ 
    public override void OnInspectorGUI() 
    { 
     LayoutMaxSize layoutMax = target as LayoutMaxSize; 
     EditorGUILayout.BeginHorizontal(); 
     EditorGUILayout.PrefixLabel("Ignore Layout"); 
     layoutMax.ignoreLayout = EditorGUILayout.Toggle(layoutMax.ignoreLayout); 
     EditorGUILayout.EndHorizontal(); 
     if (!layoutMax.ignoreLayout) 
     { 
      EditorGUILayout.Space(); 
      EditorGUILayout.BeginHorizontal(); 
      EditorGUILayout.PrefixLabel("Min Width"); 
      var allowMinWidth = EditorGUILayout.Toggle(layoutMax.minWidth != -1); 
      if (allowMinWidth) 
      { 
       if (layoutMax.minWidth == -1) layoutMax.minWidth = 0; 
       layoutMax.minWidth = EditorGUILayout.FloatField(layoutMax.minWidth); 
      } 
      else if (layoutMax.minWidth != -1) 
      { 
       layoutMax.minWidth = -1; 
      } 
      EditorGUILayout.EndHorizontal(); 

      EditorGUILayout.BeginHorizontal(); 
      EditorGUILayout.PrefixLabel("Min Height"); 
      var allowMinHeight = EditorGUILayout.Toggle(layoutMax.minHeight != -1); 
      if (allowMinHeight) 
      { 
       if (layoutMax.minHeight == -1) layoutMax.minHeight = 0; 
       layoutMax.minHeight = EditorGUILayout.FloatField(layoutMax.minHeight); 
      } 
      else if (layoutMax.minHeight != -1) 
      { 
       layoutMax.minHeight = -1; 
      } 
      EditorGUILayout.EndHorizontal(); 

      EditorGUILayout.BeginHorizontal(); 
      EditorGUILayout.PrefixLabel("Max Width"); 
      var allowMaxWidth = EditorGUILayout.Toggle(layoutMax.maxWidth != -1); 
      if (allowMaxWidth) 
      { 
       if (layoutMax.maxWidth == -1) layoutMax.maxWidth = Mathf.Max(0, layoutMax.minWidth); 
       layoutMax.maxWidth = Mathf.Max(EditorGUILayout.FloatField(layoutMax.maxWidth), layoutMax.minWidth); 
      } 
      else if(layoutMax.maxWidth != -1) 
      { 
       layoutMax.maxWidth = -1; 
      } 
      EditorGUILayout.EndHorizontal(); 

      EditorGUILayout.BeginHorizontal(); 
      EditorGUILayout.PrefixLabel("Max Height"); 
      var allowMaxHeight = EditorGUILayout.Toggle(layoutMax.maxHeight != -1); 
      if (allowMaxHeight) 
      { 
       if (layoutMax.maxHeight == -1) layoutMax.maxHeight = Mathf.Max(0, layoutMax.minHeight); 
       layoutMax.maxHeight = Mathf.Max(EditorGUILayout.FloatField(layoutMax.maxHeight), layoutMax.minHeight); 
      } 
      else if (layoutMax.maxHeight != -1) 
      { 
       layoutMax.maxHeight = -1; 
      } 
      EditorGUILayout.EndHorizontal(); 
     } 
    } 
} 
#endif