private void HandleSelfFittingAlongAxis(int axis)
{
//获取目标轴的适应类型
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
//添加Tracker的部分无法被修改
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
//根据类型选择适应的尺寸
if (fitting == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
private void SetCellsAlongAxis(int axis)
{
int columns = GetColumnCount();
int rows = GetRowCount();
int units = axis == 0 ? columns : rows;
float[] size = new float[units];
float[] pos = new float[units];
// Get origin
float space = axis == 0 ? rectTransform.rect.width : rectTransform.rect.height;
float extraSpace = space - LayoutUtility.GetPreferredSize(rectTransform, axis);
float origin = 0;
if (axis == 0)
{
origin = padding.left;
if (childAlignment == TextAnchor.UpperCenter || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.LowerCenter)
{
origin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.UpperRight || childAlignment == TextAnchor.MiddleRight || childAlignment == TextAnchor.LowerRight)
{
origin += extraSpace;
}
}
else
{
origin = padding.top;
if (childAlignment == TextAnchor.MiddleLeft || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.MiddleRight)
{
origin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.LowerLeft || childAlignment == TextAnchor.LowerCenter || childAlignment == TextAnchor.LowerRight)
{
origin += extraSpace;
}
}
pos [0] = origin;
size[0] = axis == 0 ? colPreferredWidths [0] : rowPreferredHeights [0];
if (units > 1)
{
for (int u = 1; u < units; u++)
{
pos [u] = pos [u - 1] + size [u - 1] + (axis == 0 ? spacing.x : spacing.y);
size[u] = axis == 0 ? colPreferredWidths [u] : rowPreferredHeights [u];
}
}
for (int i = 0; i < rectChildren.Count; i++)
{
int index = axis == 0 ? GetCellColumn(i, columns, rows) : GetCellRow(i, columns, rows);
SetChildAlongAxis(rectChildren [i], axis, pos[index], size[index]);
}
}
/// <summary>
///
/// <para>
/// Set the positions and sizes of the child layout elements for the given axis.
/// </para>
///
/// </summary>
/// <param name="axis">The axis to handle. 0 is horizontal and 1 is vertical.</param><param name="isVertical">Is this group a vertical group?</param>
protected void SetChildrenAlongAxis(int axis, bool isVertical)
{
float num1 = this.rectTransform.rect.size[axis];
if (isVertical ^ axis == 1)
{
float num2 = num1 - (axis != 0 ? (float)this.padding.vertical : (float)this.padding.horizontal);
for (int index = 0; index < this.rectChildren.Count; ++index)
{
RectTransform rect = this.rectChildren[index];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float a = LayoutUtility.GetFlexibleSize(rect, axis);
if ((axis != 0 ? (this.childForceExpandHeight ? 1 : 0) : (this.childForceExpandWidth ? 1 : 0)) != 0)
{
a = Mathf.Max(a, 1f);
}
float num3 = Mathf.Clamp(num2, minSize, (double)a <= 0.0 ? preferredSize : num1);
float startOffset = this.GetStartOffset(axis, num3);
this.SetChildAlongAxis(rect, axis, startOffset, num3);
}
}
else
{
float pos = axis != 0 ? (float)this.padding.top : (float)this.padding.left;
if ((double)this.GetTotalFlexibleSize(axis) == 0.0 && (double)this.GetTotalPreferredSize(axis) < (double)num1)
{
pos = this.GetStartOffset(axis, this.GetTotalPreferredSize(axis) - (axis != 0 ? (float)this.padding.vertical : (float)this.padding.horizontal));
}
float t = 0.0f;
if ((double)this.GetTotalMinSize(axis) != (double)this.GetTotalPreferredSize(axis))
{
t = Mathf.Clamp01((float)(((double)num1 - (double)this.GetTotalMinSize(axis)) / ((double)this.GetTotalPreferredSize(axis) - (double)this.GetTotalMinSize(axis))));
}
float num2 = 0.0f;
if ((double)num1 > (double)this.GetTotalPreferredSize(axis) && (double)this.GetTotalFlexibleSize(axis) > 0.0)
{
num2 = (num1 - this.GetTotalPreferredSize(axis)) / this.GetTotalFlexibleSize(axis);
}
for (int index = 0; index < this.rectChildren.Count; ++index)
{
RectTransform rect = this.rectChildren[index];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float a = LayoutUtility.GetFlexibleSize(rect, axis);
if ((axis != 0 ? (this.childForceExpandHeight ? 1 : 0) : (this.childForceExpandWidth ? 1 : 0)) != 0)
{
a = Mathf.Max(a, 1f);
}
float size = Mathf.Lerp(minSize, preferredSize, t) + a * num2;
this.SetChildAlongAxis(rect, axis, pos, size);
pos += size + this.spacing;
}
}
}
protected void SetChildrenAlongAxis(int axis, bool isVertical)
{
float num = base.rectTransform.rect.size[axis];
if (isVertical ^ (axis == 1))
{
float num2 = num - ((axis != 0) ? ((float)base.padding.vertical) : ((float)base.padding.horizontal));
for (int i = 0; i < base.rectChildren.Count; i++)
{
RectTransform rect = base.rectChildren[i];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float flexibleSize = LayoutUtility.GetFlexibleSize(rect, axis);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
flexibleSize = Mathf.Max(flexibleSize, 1f);
}
float requiredSpaceWithoutPadding = Mathf.Clamp(num2, minSize, (flexibleSize <= 0f) ? preferredSize : num);
float startOffset = base.GetStartOffset(axis, requiredSpaceWithoutPadding);
base.SetChildAlongAxis(rect, axis, startOffset, requiredSpaceWithoutPadding);
}
}
else
{
float pos = (axis != 0) ? ((float)base.padding.top) : ((float)base.padding.left);
if ((base.GetTotalFlexibleSize(axis) == 0f) && (base.GetTotalPreferredSize(axis) < num))
{
pos = base.GetStartOffset(axis, base.GetTotalPreferredSize(axis) - ((axis != 0) ? ((float)base.padding.vertical) : ((float)base.padding.horizontal)));
}
float t = 0f;
if (base.GetTotalMinSize(axis) != base.GetTotalPreferredSize(axis))
{
t = Mathf.Clamp01((num - base.GetTotalMinSize(axis)) / (base.GetTotalPreferredSize(axis) - base.GetTotalMinSize(axis)));
}
float num11 = 0f;
if ((num > base.GetTotalPreferredSize(axis)) && (base.GetTotalFlexibleSize(axis) > 0f))
{
num11 = (num - base.GetTotalPreferredSize(axis)) / base.GetTotalFlexibleSize(axis);
}
for (int j = 0; j < base.rectChildren.Count; j++)
{
RectTransform transform2 = base.rectChildren[j];
float a = LayoutUtility.GetMinSize(transform2, axis);
float b = LayoutUtility.GetPreferredSize(transform2, axis);
float num15 = LayoutUtility.GetFlexibleSize(transform2, axis);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
num15 = Mathf.Max(num15, 1f);
}
float size = Mathf.Lerp(a, b, t) + (num15 * num11);
base.SetChildAlongAxis(transform2, axis, pos, size);
pos += size + this.spacing;
}
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
if (fitting == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
float toBeSize = LayoutUtility.GetPreferredSize(m_Rect, axis);
var p = m_Rect.parent as RectTransform;
if (!ReferenceEquals(p, null))
{
if (axis == 0 && m_HorizontalConstrainToParentSize)
{
toBeSize = Mathf.Clamp(toBeSize, 0, p.rect.size.x);
}
if (axis == 1)
{
if (m_VerticalConstrainToParentSize)
{
toBeSize = Mathf.Clamp(toBeSize, 0, p.rect.size.y);
}
if (m_VerticalConstrainToCanvasSize)
{
float constrt = RootCanvasRectTransform.rect.size.y *
m_VerticalCanvasSizeFraction;
if (m_VerticalConstrainToConstant)
{
constrt += m_VerticalConstant;
}
toBeSize = Mathf.Clamp(toBeSize, 0, constrt);
}
}
}
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, toBeSize);
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTsfm, DrivenTransformProperties.None);
return;
}
DrivenTransformProperties flags = DrivenTransformProperties.ScaleX | DrivenTransformProperties.ScaleY;
if (horizontalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaX;
}
if (verticalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaY;
}
m_Tracker.Add(this, rectTsfm, flags);
// Set size to min or preferred size
float newSize = 0f;
if (fitting == FitMode.MinSize)
{
newSize = LayoutUtility.GetMinSize(m_Rect, axis);
newSize = axis == 0 ? Mathf.Max(newSize, m_fixedSize.x) : Mathf.Max(newSize, m_fixedSize.y);
}
else
{
newSize = LayoutUtility.GetPreferredSize(m_Rect, axis);
}
Vector2 newSizeV;
if (axis == 0)
{
newSizeV = new Vector2(Mathf.Max(newSize, m_fixedSize.x), m_Rect.sizeDelta.y);
}
else
{
newSizeV = new Vector2(m_Rect.sizeDelta.x, Mathf.Max(newSize, m_fixedSize.y));
}
m_Rect.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, newSize);
m_Rect.localScale = CalculateSizeScale(newSizeV, axis);
}
protected void CalcAlongAxisExtended(int axis, bool isVertical)
{
float padding = (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal);
float totalMin = padding;
float totalPreffered = padding;
float totalFlexible = 0f;
bool notOrderingAxis = isVertical ^ axis == 1;
for (int i = 0; i < base.rectChildren.Count; i++)
{
RectTransform rect = base.rectChildren[i];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float flexibleSize = LayoutUtility.GetFlexibleSize(rect, axis);
RectOffset margins = LayoutUtilityExtended.GetMargin(rect);
float margin = (float)((axis != 0) ? margins.vertical : margins.horizontal);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
flexibleSize = Mathf.Max(flexibleSize, 1f);
}
if (notOrderingAxis)
{
totalMin = Mathf.Max(minSize + padding + margin, totalMin);
totalPreffered = Mathf.Max(preferredSize + padding + margin, totalPreffered);
totalFlexible = Mathf.Max(flexibleSize, totalFlexible);
}
else
{
totalMin += minSize + this.spacing + margin;
totalPreffered += preferredSize + this.spacing + margin;
totalFlexible += flexibleSize;
}
}
if (!notOrderingAxis && base.rectChildren.Count > 0)
{
totalMin -= this.spacing;
totalPreffered -= this.spacing;
}
totalPreffered = Mathf.Max(totalMin, totalPreffered);
base.SetLayoutInputForAxis(totalMin, totalPreffered, totalFlexible, axis);
}
protected void CalcAlongAxis(int axis, bool isVertical)
{
float combinedPadding = (axis == 0 ? padding.horizontal : padding.vertical);
float totalMin = combinedPadding;
float totalPreferred = combinedPadding;
float totalFlexible = 0;
bool alongOtherAxis = (isVertical ^ (axis == 1));
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
float min = LayoutUtility.GetMinSize(child, axis);
float preferred = LayoutUtility.GetPreferredSize(child, axis);
float flexible = LayoutUtility.GetFlexibleSize(child, axis);
if ((axis == 0 ? childForceExpandWidth : childForceExpandHeight))
{
flexible = Mathf.Max(flexible, 1);
}
if (alongOtherAxis)
{
totalMin = Mathf.Max(min + combinedPadding, totalMin);
totalPreferred = Mathf.Max(preferred + combinedPadding, totalPreferred);
totalFlexible = Mathf.Max(flexible, totalFlexible);
}
else
{
totalMin += min + spacing;
totalPreferred += preferred + spacing;
// Increment flexible size with element's flexible size.
totalFlexible += flexible;
}
}
if (!alongOtherAxis && rectChildren.Count > 0)
{
totalMin -= spacing;
totalPreferred -= spacing;
}
totalPreferred = Mathf.Max(totalMin, totalPreferred);
SetLayoutInputForAxis(totalMin, totalPreferred, totalFlexible, axis);
}
private void GetChildSizes(RectTransform child, int axis, bool controlSize, bool childForceExpand, out float min, out float preferred, out float flexible)
{
if (!controlSize)
{
min = child.sizeDelta[axis];
preferred = min;
flexible = 0f;
}
else
{
min = LayoutUtility.GetMinSize(child, axis);
preferred = LayoutUtility.GetPreferredSize(child, axis);
flexible = LayoutUtility.GetFlexibleSize(child, axis);
}
if (childForceExpand)
{
flexible = Mathf.Max(flexible, 1f);
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitMode = (axis != 0) ? verticalFit : horizontalFit;
if (fitMode == FitMode.Unconstrained)
{
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
m_Tracker.Add(this, rectTransform, (axis != 0) ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
if (fitMode == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
return;
}
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
if (fitting == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
void CalculateLayoutInputForAxis(int axis)
{
// We need to reserve space for the padding.
float combinedPadding = (axis == 0 ? padding.horizontal : padding.vertical);
float totalmin = combinedPadding;
float totalpreferred = combinedPadding;
// And for the largest child.
float min = 0;
float preferred = 0;
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
min = Mathf.Max(min, LayoutUtility.GetMinSize(child, axis));
preferred = Mathf.Max(preferred, LayoutUtility.GetPreferredSize(child, axis));
}
totalmin += min;
totalpreferred += preferred;
// We ignore flexible size for now, I have not decided what to do with it yet.
SetLayoutInputForAxis(totalmin, totalpreferred, -1, axis);
}
/// <summary>
///
/// <para>
/// Calculate the layout element properties for this layout element along the given axis.
/// </para>
///
/// </summary>
/// <param name="axis">The axis to calculate for. 0 is horizontal and 1 is vertical.</param><param name="isVertical">Is this group a vertical group?</param>
protected void CalcAlongAxis(int axis, bool isVertical)
{
float num1 = axis != 0 ? (float)this.padding.vertical : (float)this.padding.horizontal;
float num2 = num1;
float b = num1;
float num3 = 0.0f;
bool flag = isVertical ^ axis == 1;
for (int index = 0; index < this.rectChildren.Count; ++index)
{
RectTransform rect = this.rectChildren[index];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float a = LayoutUtility.GetFlexibleSize(rect, axis);
if ((axis != 0 ? (this.childForceExpandHeight ? 1 : 0) : (this.childForceExpandWidth ? 1 : 0)) != 0)
{
a = Mathf.Max(a, 1f);
}
if (flag)
{
num2 = Mathf.Max(minSize + num1, num2);
b = Mathf.Max(preferredSize + num1, b);
num3 = Mathf.Max(a, num3);
}
else
{
num2 += minSize + this.spacing;
b += preferredSize + this.spacing;
num3 += a;
}
}
if (!flag && this.rectChildren.Count > 0)
{
num2 -= this.spacing;
b -= this.spacing;
}
float totalPreferred = Mathf.Max(num2, b);
this.SetLayoutInputForAxis(num2, totalPreferred, num3, axis);
}
protected void CalcAlongAxis(int axis, bool isVertical)
{
float num = (axis != 0) ? ((float)base.padding.vertical) : ((float)base.padding.horizontal);
float b = num;
float num3 = num;
float num4 = 0f;
bool flag = isVertical ^ (axis == 1);
for (int i = 0; i < base.rectChildren.Count; i++)
{
RectTransform rect = base.rectChildren[i];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float flexibleSize = LayoutUtility.GetFlexibleSize(rect, axis);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
flexibleSize = Mathf.Max(flexibleSize, 1f);
}
if (flag)
{
b = Mathf.Max(minSize + num, b);
num3 = Mathf.Max(preferredSize + num, num3);
num4 = Mathf.Max(flexibleSize, num4);
}
else
{
b += minSize + this.spacing;
num3 += preferredSize + this.spacing;
num4 += flexibleSize;
}
}
if (!flag && (base.rectChildren.Count > 0))
{
b -= this.spacing;
num3 -= this.spacing;
}
num3 = Mathf.Max(b, num3);
base.SetLayoutInputForAxis(b, num3, num4, axis);
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode mode = (axis != 0) ? this.verticalFit : this.horizontalFit;
if (mode != FitMode.Unconstrained)
{
this.m_Tracker.Add(this, this.rectTransform, (axis != 0) ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
if (mode == FitMode.MinSize)
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(this.m_Rect, axis));
}
else
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(this.m_Rect, axis));
}
}
}
//------------------------------------------------------------------------------------------------------
private void SetCellsAlongAxis(int axis)
{
// Get origin
float space = (axis == 0 ? rectTransform.rect.width : rectTransform.rect.height);
float extraSpace = space - LayoutUtility.GetPreferredSize(rectTransform, axis);
float gridOrigin = (axis == 0 ? padding.left : padding.top);
if (axis == 0)
{
if (childAlignment == TextAnchor.UpperCenter || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.LowerCenter)
{
gridOrigin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.UpperRight || childAlignment == TextAnchor.MiddleRight || childAlignment == TextAnchor.LowerRight)
{
gridOrigin += extraSpace;
}
}
else
{
if (childAlignment == TextAnchor.MiddleLeft || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.MiddleRight)
{
gridOrigin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.LowerLeft || childAlignment == TextAnchor.LowerCenter || childAlignment == TextAnchor.LowerRight)
{
gridOrigin += extraSpace;
}
}
// Expansion/alignment options
bool forceExpand = (axis == 0) ? childForceExpandWidth : childForceExpandHeight;
int alignment = 0;
if (axis == 0)
{
if (cellAlignment == TextAnchor.UpperLeft || cellAlignment == TextAnchor.MiddleLeft || cellAlignment == TextAnchor.LowerLeft)
{
alignment = -1;
}
if (cellAlignment == TextAnchor.UpperRight || cellAlignment == TextAnchor.MiddleRight || cellAlignment == TextAnchor.LowerRight)
{
alignment = 1;
}
}
else
{
if (cellAlignment == TextAnchor.UpperLeft || cellAlignment == TextAnchor.UpperCenter || cellAlignment == TextAnchor.UpperRight)
{
alignment = -1;
}
if (cellAlignment == TextAnchor.LowerLeft || cellAlignment == TextAnchor.LowerCenter || cellAlignment == TextAnchor.LowerRight)
{
alignment = 1;
}
}
// Set cells
for (int i = 0; i < rectChildren.Count; i++)
{
int colrow = (axis == 0 ? GetCellColumn(i) : GetCellRow(i));
// Column/row origin
float cellOrigin = gridOrigin + (axis == 0 ? GetColumnPositionWithinGrid(colrow) : GetRowPositionWithinGrid(colrow));
// Column/row size and space
float cellSpace = (axis == 0 ? GetColumnWidth(colrow) : GetRowHeight(colrow));
var child = rectChildren[i];
float cellSize = LayoutUtility.GetPreferredSize(child, axis);
float cellExtraSpace = cellSpace - cellSize;
// If cell should stretch, place there. If not, place within cell space according to cell alignment and its preferred size
bool cellForceExpand = forceExpand;
int thisCellAlignment = alignment;
var cellOptions = child.GetComponent <VariableGridCell> ();
if (cellOptions != null)
{
if (axis == 0 ? cellOptions.overrideForceExpandWidth : cellOptions.overrideForceExpandHeight)
{
cellForceExpand = (axis == 0 ? cellOptions.forceExpandWidth : cellOptions.forceExpandHeight);
}
if (cellOptions.overrideCellAlignment)
{
if (axis == 0)
{
if (cellOptions.cellAlignment == TextAnchor.UpperLeft || cellOptions.cellAlignment == TextAnchor.MiddleLeft || cellOptions.cellAlignment == TextAnchor.LowerLeft)
{
thisCellAlignment = -1;
}
else if (cellOptions.cellAlignment == TextAnchor.UpperCenter || cellOptions.cellAlignment == TextAnchor.MiddleCenter || cellOptions.cellAlignment == TextAnchor.LowerCenter)
{
thisCellAlignment = 0;
}
else
{
thisCellAlignment = 1;
}
}
else
{
if (cellOptions.cellAlignment == TextAnchor.UpperLeft || cellOptions.cellAlignment == TextAnchor.UpperCenter || cellOptions.cellAlignment == TextAnchor.UpperRight)
{
thisCellAlignment = -1;
}
else if (cellOptions.cellAlignment == TextAnchor.MiddleLeft || cellOptions.cellAlignment == TextAnchor.MiddleCenter || cellOptions.cellAlignment == TextAnchor.MiddleRight)
{
thisCellAlignment = 0;
}
else
{
thisCellAlignment = 1;
}
}
}
}
if (cellForceExpand)
{
cellSize = cellSpace;
}
else
{
if (thisCellAlignment == 0)
{
cellOrigin += cellExtraSpace / 2f;
}
if (thisCellAlignment == 1)
{
cellOrigin += cellExtraSpace;
}
}
SetChildAlongAxis(rectChildren [i], axis, cellOrigin, cellSize);
}
}
//------------------------------------------------------------------------------------------------------
private void SetCellsAlongAxis(int axis)
{
//源点
float space = (axis == 0 ? rectTransform.rect.width : rectTransform.rect.height);
float extraSpace = space - LayoutUtility.GetPreferredSize(rectTransform, axis);
float gridOrigin = (axis == 0 ? padding.left : padding.top);
if (axis == 0)
{
if (childAlignment == TextAnchor.UpperCenter || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.LowerCenter)
{
gridOrigin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.UpperRight || childAlignment == TextAnchor.MiddleRight || childAlignment == TextAnchor.LowerRight)
{
gridOrigin += extraSpace;
}
}
else
{
if (childAlignment == TextAnchor.MiddleLeft || childAlignment == TextAnchor.MiddleCenter || childAlignment == TextAnchor.MiddleRight)
{
gridOrigin += extraSpace / 2f;
}
else if (childAlignment == TextAnchor.LowerLeft || childAlignment == TextAnchor.LowerCenter || childAlignment == TextAnchor.LowerRight)
{
gridOrigin += extraSpace;
}
}
//物体偏好尺寸
float s = (rectTransform.rect.width - padding.horizontal - spacing.x * (columns - 1)) / columns / GetScaledSize.x;
//print(s);
//设置子物体位置
for (int i = 0; i < rectChildren.Count; i++)
{
//行列号
int colrow = (axis == 0 ? GetCellColumn(i) : GetCellRow(i));
// Column/row origin
float cellOrigin = gridOrigin + (axis == 0 ? GetColumnPositionWithinGrid(colrow) : GetRowPositionWithinGrid(colrow));
//子物体尺寸，间距
float cellSpace = (axis == 0 ? GetScaledSize.x : GetScaledSize.y);
//float cellSpace = (axis == 0 ? GetPreferredSize.x : GetPreferredSize.y);
float cellSize = GetSize(axis);
float cellExtraSpace = cellSpace - cellSize;
//cellExtraSpace =
// If cell should stretch, place there. If not, place within cell space according to cell alignment and its preferred size
int thisCellAlignment = 0;
if (thisCellAlignment == 0)
{
cellOrigin += cellExtraSpace / 2f;
}
if (thisCellAlignment == 1)
{
cellOrigin += cellExtraSpace;
}
SetChildAlongAxis(rectChildren[i], axis, cellOrigin, cellSize);
rectChildren[i].localScale = Vector3.one * scale;
}
}
protected void SetChildrenAlongAxisExtended(int axis, bool isVertical)
{
float axisSize = base.rectTransform.rect.size[axis];
bool notOrderingAxis = isVertical ^ axis == 1;
if (notOrderingAxis)
{
float axisSize2 = axisSize - (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal);
for (int i = 0; i < base.rectChildren.Count; i++)
{
RectTransform rect = base.rectChildren[i];
float minSize = LayoutUtility.GetMinSize(rect, axis);
float preferredSize = LayoutUtility.GetPreferredSize(rect, axis);
float flexibleSize = LayoutUtility.GetFlexibleSize(rect, axis);
RectOffset margin = LayoutUtilityExtended.GetMargin(rect);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
flexibleSize = Mathf.Max(flexibleSize, 1f);
}
float elementSize = Mathf.Clamp(axisSize2, minSize, (flexibleSize <= 0f) ? preferredSize : axisSize);
// Subtract margins
if (axis == 0 && this.m_SubtractMarginHorizontal)
{
elementSize -= margin.horizontal;
elementSize = Mathf.Clamp(elementSize, minSize, elementSize);
}
else if (axis != 0 && this.m_SubtractMarginVertical)
{
elementSize -= margin.vertical;
elementSize = Mathf.Clamp(elementSize, minSize, elementSize);
}
float startOffset = ((axis != 0) ? margin.top : margin.left) + base.GetStartOffset(axis, elementSize);
base.SetChildAlongAxis(rect, axis, startOffset, elementSize);
}
}
else
{
float offset = (float)((axis != 0) ? base.padding.top : base.padding.left);
if (base.GetTotalFlexibleSize(axis) == 0f && base.GetTotalPreferredSize(axis) < axisSize)
{
offset = base.GetStartOffset(axis, base.GetTotalPreferredSize(axis) - (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal));
}
float axisSize6 = 0f;
if (base.GetTotalMinSize(axis) != base.GetTotalPreferredSize(axis))
{
axisSize6 = Mathf.Clamp01((axisSize - base.GetTotalMinSize(axis)) / (base.GetTotalPreferredSize(axis) - base.GetTotalMinSize(axis)));
}
float axisSize7 = 0f;
if (axisSize > base.GetTotalPreferredSize(axis) && base.GetTotalFlexibleSize(axis) > 0f)
{
axisSize7 = (axisSize - base.GetTotalPreferredSize(axis)) / base.GetTotalFlexibleSize(axis);
}
for (int j = 0; j < base.rectChildren.Count; j++)
{
RectTransform rect2 = base.rectChildren[j];
float minSize2 = LayoutUtility.GetMinSize(rect2, axis);
float preferredSize2 = LayoutUtility.GetPreferredSize(rect2, axis);
float flexibleSize = LayoutUtility.GetFlexibleSize(rect2, axis);
RectOffset margin = LayoutUtilityExtended.GetMargin(rect2);
if ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth)
{
flexibleSize = Mathf.Max(flexibleSize, 1f);
}
float elementSize = Mathf.Lerp(minSize2, preferredSize2, axisSize6);
elementSize += flexibleSize * axisSize7;
offset += ((axis != 0) ? margin.top : margin.left);
base.SetChildAlongAxis(rect2, axis, offset, elementSize);
offset += elementSize + this.spacing + ((axis != 0) ? margin.bottom : margin.right);
}
}
}
/// <summary>
/// Main layout method
/// </summary>
/// <param name="width">Width to calculate the layout with</param>
/// <param name="axis">0 for horizontal axis, 1 for vertical</param>
/// <param name="layoutInput">If true, sets the layout input for the axis. If false, sets child position for axis</param>
public float SetLayout(float width, int axis, bool layoutInput)
{
var groupHeight = rectTransform.rect.height;
// Width that is available after padding is subtracted
var workingWidth = rectTransform.rect.width - padding.left - padding.right;
// Accumulates the total height of the rows, including spacing and padding.
var yOffset = IsLowerAlign ? (float)padding.bottom : (float)padding.top;
var currentRowWidth = 0f;
var currentRowHeight = 0f;
for (var i = 0; i < rectChildren.Count; i++)
{
// LowerAlign works from back to front
var index = IsLowerAlign ? rectChildren.Count - 1 - i : i;
var child = rectChildren[index];
var childWidth = LayoutUtility.GetPreferredSize(child, 0);
var childHeight = LayoutUtility.GetPreferredSize(child, 1);
// Max child width is layout group width - padding
childWidth = Mathf.Min(childWidth, workingWidth);
// If adding this element would exceed the bounds of the row,
// go to a new line after processing the current row
if (currentRowWidth + childWidth > workingWidth)
{
currentRowWidth -= SpacingX;
// Process current row elements positioning
if (!layoutInput)
{
var h = CalculateRowVerticalOffset(groupHeight, yOffset, currentRowHeight);
LayoutRow(_rowList, currentRowWidth, currentRowHeight, workingWidth, padding.left, h, axis);
}
// Clear existing row
_rowList.Clear();
// Add the current row height to total height accumulator, and reset to 0 for the next row
yOffset += currentRowHeight;
yOffset += SpacingY;
currentRowHeight = 0;
currentRowWidth = 0;
}
currentRowWidth += childWidth;
_rowList.Add(child);
// We need the largest element height to determine the starting position of the next line
if (childHeight > currentRowHeight)
{
currentRowHeight = childHeight;
}
// Don't do this for the last one
if (i < rectChildren.Count - 1)
{
currentRowWidth += SpacingX;
}
}
if (!layoutInput)
{
var h = CalculateRowVerticalOffset(groupHeight, yOffset, currentRowHeight);
currentRowWidth -= SpacingX;
// Layout the final row
LayoutRow(_rowList, currentRowWidth, currentRowHeight, workingWidth - (_rowList.Count > 1 ? SpacingX : 0), padding.left, h, axis);
}
_rowList.Clear();
// Add the last rows height to the height accumulator
yOffset += currentRowHeight;
yOffset += IsLowerAlign ? padding.top : padding.bottom;
if (layoutInput)
{
if (axis == 1)
{
SetLayoutInputForAxis(yOffset, yOffset, -1, axis);
}
}
return(yOffset);
}
protected void LayoutRow(IList <RectTransform> contents, float rowWidth, float rowHeight, float maxWidth, float xOffset, float yOffset, int axis)
{
var xPos = xOffset;
if (!ChildForceExpandWidth && IsCenterAlign)
{
xPos += (maxWidth - rowWidth) * 0.5f;
}
else if (!ChildForceExpandWidth && IsRightAlign)
{
xPos += (maxWidth - rowWidth);
}
var extraWidth = 0f;
var extraSpacing = 0f;
if (ChildForceExpandWidth)
{
extraWidth = (maxWidth - rowWidth) / _rowList.Count;
}
else if (ExpandHorizontalSpacing)
{
extraSpacing = (maxWidth - rowWidth) / (_rowList.Count - 1);
if (_rowList.Count > 1)
{
if (IsCenterAlign)
{
xPos -= extraSpacing * 0.5f * (_rowList.Count - 1);
}
else if (IsRightAlign)
{
xPos -= extraSpacing * (_rowList.Count - 1);
}
}
}
for (var j = 0; j < _rowList.Count; j++)
{
var index = IsLowerAlign ? _rowList.Count - 1 - j : j;
var rowChild = _rowList[index];
var rowChildWidth = LayoutUtility.GetPreferredSize(rowChild, 0) + extraWidth;
var rowChildHeight = LayoutUtility.GetPreferredSize(rowChild, 1);
if (ChildForceExpandHeight)
{
rowChildHeight = rowHeight;
}
rowChildWidth = Mathf.Min(rowChildWidth, maxWidth);
var yPos = yOffset;
if (IsMiddleAlign)
{
yPos += (rowHeight - rowChildHeight) * 0.5f;
}
else if (IsLowerAlign)
{
yPos += (rowHeight - rowChildHeight);
}
//
if (ExpandHorizontalSpacing && j > 0)
{
xPos += extraSpacing;
}
if (axis == 0)
{
SetChildAlongAxis(rowChild, 0, xPos, rowChildWidth);
}
else
{
SetChildAlongAxis(rowChild, 1, yPos, rowChildHeight);
}
// Don't do horizontal spacing for the last one
if (j < _rowList.Count - 1)
{
xPos += rowChildWidth + SpacingX;
}
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
ContentSizeFitter.FitMode fitMode = axis != 0 ? this.verticalFit : this.horizontalFit;
if (fitMode == ContentSizeFitter.FitMode.Unconstrained)
{
return;
}
this.m_Tracker.Add((UnityEngine.Object) this, this.rectTransform, axis != 0 ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
if (fitMode == ContentSizeFitter.FitMode.MinSize)
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(this.m_Rect, axis));
}
else
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(this.m_Rect, axis));
}
}
protected void SetChildrenAlongAxis(int axis, bool isVertical)
{
RectTransform rect = gameObject.GetComponent <RectTransform>();
rect.anchoredPosition = Vector2.zero;
bool isForceExpand = (isVertical ? childForceExpandHeight : childForceExpandWidth);
if (isForceExpand)
{
rect.anchorMin = Vector2.zero;
rect.anchorMax = Vector2.one;
rect.pivot = new Vector2(0.5f, 0.5f);
rect.sizeDelta = Vector2.zero;
}
float size = rectTransform.rect.size[axis];
bool alongOtherAxis = (isVertical ^ (axis == 1));
float wh = (axis == 0 ? padding.horizontal : padding.vertical);
float itemwh;
if (alongOtherAxis)
{
float innerSize = size - (axis == 0 ? padding.horizontal : padding.vertical);
itemwh = (axis == 1 ? itemWidth : itemHeight);
float itemsize = (axis == 0 ? itemWidth : itemHeight);
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
float requiredSpace = 0;
float min = LayoutUtility.GetMinSize(child, axis);
float preferred = LayoutUtility.GetPreferredSize(child, axis);
float flexible = LayoutUtility.GetFlexibleSize(child, axis);
if ((axis == 0 ? childForceExpandWidth : childForceExpandHeight))
{
flexible = Mathf.Max(flexible, 1);
}
requiredSpace = Mathf.Clamp(innerSize, min, flexible > 0 ? size : preferred);
wh += itemwh + spacing;
float startOffset = GetStartOffset(axis, requiredSpace);
if ((axis == 1 ? childForceExpandHeight : childForceExpandWidth))
{
SetChildAlongAxis(child, axis, startOffset, innerSize);
}
else
{
SetChildAlongAxis(child, axis, startOffset, itemsize);
}
}
}
else
{
itemwh = (axis == 0 ? itemWidth : itemHeight);
float pos = (axis == 0 ? padding.left : padding.top);
if (GetTotalFlexibleSize(axis) == 0 && GetTotalPreferredSize(axis) < size)
{
pos = GetStartOffset(axis, GetTotalPreferredSize(axis) - (axis == 0 ? padding.horizontal : padding.vertical));
}
float minMaxLerp = 0;
if (GetTotalMinSize(axis) != GetTotalPreferredSize(axis))
{
minMaxLerp = Mathf.Clamp01((size - GetTotalMinSize(axis)) / (GetTotalPreferredSize(axis) - GetTotalMinSize(axis)));
}
float itemFlexibleMultiplier = 0;
if (size > GetTotalPreferredSize(axis))
{
if (GetTotalFlexibleSize(axis) > 0)
{
itemFlexibleMultiplier = (size - GetTotalPreferredSize(axis)) / GetTotalFlexibleSize(axis);
}
}
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
float childSize = 0;
if ((axis == 1 ? childForceExpandHeight : childForceExpandWidth))
{
float min = LayoutUtility.GetMinSize(child, axis);
float preferred = LayoutUtility.GetPreferredSize(child, axis);
float flexible = LayoutUtility.GetFlexibleSize(child, axis);
flexible = Mathf.Max(flexible, 1);
childSize = Mathf.Lerp(min, preferred, minMaxLerp);
childSize += flexible * itemFlexibleMultiplier;
}
else
{
childSize += itemwh;
wh += childSize + spacing;
}
SetChildAlongAxis(child, axis, pos, childSize);
pos += childSize + spacing;
}
}
if (!isForceExpand)
{
if (!isVertical)
{
rect.pivot = new Vector2(0f, 0.5f);
rect.sizeDelta = new Vector2(wh, 0);
rect.anchorMin = new Vector2(0f, 0f);
rect.anchorMax = new Vector2(0f, 1.0f);
}
else
{
rect.pivot = new Vector2(0.5f, 1.0f);
rect.sizeDelta = new Vector2(0, wh);
rect.anchorMin = new Vector2(0, 1.0f);
rect.anchorMax = new Vector2(1.0f, 1.0f);
}
}
}
