protected void CalcAlongGroupAxis(int axis, bool isVertical, LinearGroup group)
{
if (group == null)
{
return;
}
bool controlSize = (axis == 0 ? m_ChildControlWidth : m_ChildControlHeight);
bool useScale = (axis == 0 ? m_ChildScaleWidth : m_ChildScaleHeight);
bool childForceExpandSize = (axis == 0 ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
float totalMin = 0;
float totalPreferred = 0;
float totalFlexible = 0;
bool alongOtherAxis = (isVertical ^ (axis == 1));
for (int i = 0; i < group.RectChildren.Count; i++)
{
RectTransform child = group.RectChildren[i];
float min, preferred, flexible;
GetChildSizes(child, axis, controlSize, childForceExpandSize, out min, out preferred, out flexible);
if (useScale)
{
float scaleFactor = child.localScale[axis];
min *= scaleFactor;
preferred *= scaleFactor;
flexible *= scaleFactor;
}
if (alongOtherAxis)
{
totalMin = Mathf.Max(min, totalMin);
totalPreferred = Mathf.Max(preferred, 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);
group.SetLayoutInputForAxis(totalMin, totalPreferred, totalFlexible, axis);
}
protected new void SetChildrenAlongAxis(int axis, bool isVertical)
{
float size = rectTransform.rect.size[axis];
float innerSize = size - (axis == 0 ? padding.horizontal : padding.vertical);
bool alongOtherAxis = (isVertical ^ (axis == 1));
bool controlSize = (axis == 0 ? m_ChildControlWidth : m_ChildControlHeight);
bool childForceExpandSize = (axis == 0 ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
//Calculate initial position
float pos = (axis == 0 ? padding.left : padding.top);
float surplusSpace = size - GetTotalPreferredSize(axis);
if (surplusSpace > 0)
{
if (GetTotalFlexibleSize(axis) == 0)
{
if (!controlSize || !childForceExpandSize)
{
pos = GetStartOffset(axis, GetTotalPreferredSize(axis) - (axis == 0 ? padding.horizontal : padding.vertical));
}
}
}
for (int i = 0; i < _Groups.Count; i++)
{
LinearGroup group = _Groups[i];
var groupSize = group.size;
groupSize[axis] = alongOtherAxis ? Mathf.Max(group.GetTotalMinSize(axis), group.GetTotalPreferredSize(axis)) : innerSize;
group.size = groupSize;
var groupPosition = group.position;
groupPosition[axis] = pos;
group.position = groupPosition;
SetChildrenAlongGroupAxis(axis, isVertical, group);
if (alongOtherAxis)
{
pos += groupSize[axis] + spacingBetween;
}
}
}
protected new void CalcAlongAxis(int axis, bool isVertical)
{
float combinedPadding = (axis == 0 ? padding.horizontal : padding.vertical);
bool controlSize = (axis == 0 ? m_ChildControlWidth : m_ChildControlHeight);
bool useScale = (axis == 0 ? m_ChildScaleWidth : m_ChildScaleHeight);
bool childForceExpandSize = (axis == 0 ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
float totalMin = combinedPadding;
float totalPreferred = combinedPadding;
float totalFlexible = 0;
bool alongOtherAxis = (isVertical ^ (axis == 1));
var axisSpacing = alongOtherAxis ? spacingBetween : spacing;
for (int i = 0; i < _Groups.Count; i++)
{
LinearGroup group = _Groups[i];
CalcAlongGroupAxis(axis, isVertical, group);
float min = group.GetTotalMinSize(axis);
float preferred = group.GetTotalPreferredSize(axis);
float flexible = group.GetTotalFlexibleSize(axis);
totalMin += min + axisSpacing;
totalPreferred += preferred + axisSpacing;
// Increment flexible size with element's flexible size.
totalFlexible += flexible;
}
if (!alongOtherAxis && rectChildren.Count > 0)
{
totalMin -= axisSpacing;
totalPreferred -= axisSpacing;
}
totalPreferred = Mathf.Max(totalMin, totalPreferred);
SetLayoutInputForAxis(totalMin, totalPreferred, totalFlexible, axis);
}
protected void SetChildrenAlongGroupAxis(int axis, bool isVertical, LinearGroup group)
{
float size = group.size[axis];
bool controlSize = (axis == 0 ? m_ChildControlWidth : m_ChildControlHeight);
bool useScale = (axis == 0 ? m_ChildScaleWidth : m_ChildScaleHeight);
bool childForceExpandSize = (axis == 0 ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
float alignmentOnAxis = GetAlignmentOnAxis(axis);
bool alongOtherAxis = (isVertical ^ (axis == 1));
if (alongOtherAxis)
{
float pos = group.position[axis];
for (int i = 0; i < group.RectChildren.Count; i++)
{
RectTransform child = group.RectChildren[i];
float min, preferred, flexible;
GetChildSizes(child, axis, controlSize, childForceExpandSize, out min, out preferred, out flexible);
float scaleFactor = useScale ? child.localScale[axis] : 1f;
float requiredSpace = Mathf.Clamp(size, min, flexible > 0 ? size : preferred);
float startOffset = pos + group.GetStartOffset(axis, requiredSpace * scaleFactor, alignmentOnAxis);
if (controlSize)
{
SetChildAlongAxisWithScale(child, axis, startOffset, requiredSpace, scaleFactor);
}
else
{
float offsetInCell = (requiredSpace - child.sizeDelta[axis]) * alignmentOnAxis;
SetChildAlongAxisWithScale(child, axis, startOffset + offsetInCell, scaleFactor);
}
}
}
else
{
float pos = group.position[axis];
float itemFlexibleMultiplier = 0;
float surplusSpace = size - group.GetTotalPreferredSize(axis);
var useFlexibleSpacing = false;
if (surplusSpace > 0)
{
if (group.GetTotalFlexibleSize(axis) == 0)
{
if (!controlSize || !childForceExpandSize)
{
pos += group.GetStartOffset(axis, group.GetTotalPreferredSize(axis), alignmentOnAxis);
}
else
{
useFlexibleSpacing = true;
}
}
else if (group.GetTotalFlexibleSize(axis) > 0)
{
itemFlexibleMultiplier = surplusSpace / group.GetTotalFlexibleSize(axis);
}
}
float minMaxLerp = 0;
if (group.GetTotalMinSize(axis) != group.GetTotalPreferredSize(axis))
{
minMaxLerp = Mathf.Clamp01((size - group.GetTotalMinSize(axis)) / (group.GetTotalPreferredSize(axis) - group.GetTotalMinSize(axis)));
}
var currentSpacing = useFlexibleSpacing && group.RectChildren.Count - 1 > 0 ? Mathf.Max(spacing, surplusSpace / (group.RectChildren.Count - 1)) : spacing;
for (int i = 0; i < group.RectChildren.Count; i++)
{
RectTransform child = group.RectChildren[i];
float min, preferred, flexible;
GetChildSizes(child, axis, controlSize, childForceExpandSize, out min, out preferred, out flexible);
float scaleFactor = useScale ? child.localScale[axis] : 1f;
float childSize = Mathf.Lerp(min, preferred, minMaxLerp);
childSize += flexible * itemFlexibleMultiplier;
if (controlSize)
{
SetChildAlongAxisWithScale(child, axis, pos, childSize, scaleFactor);
}
else
{
float offsetInCell = (childSize - child.sizeDelta[axis]) * alignmentOnAxis;
SetChildAlongAxisWithScale(child, axis, pos + offsetInCell, scaleFactor);
}
pos += childSize * scaleFactor + currentSpacing;
}
}
}
protected virtual List <LinearGroup> BuildChildrenGroups(bool isVertical)
{
List <LinearGroup> rectChildrenPerGroup = new List <LinearGroup>();
int axis = isVertical ? 1 : 0;
float size = rectTransform.rect.size[axis];
float innerSize = size - (axis == 0 ? padding.horizontal : padding.vertical);
bool controlSize = (axis == 0 ? m_ChildControlWidth : m_ChildControlHeight);
bool useScale = (axis == 0 ? m_ChildScaleWidth : m_ChildScaleHeight);
bool childForceExpandSize = (axis == 0 ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
float alignmentOnAxis = GetAlignmentOnAxis(axis);
float startPos = (axis == 0 ? padding.left : padding.top);
float itemFlexibleMultiplier = 0;
//float surplusSpace = size - GetTotalPreferredSize(axis);
float pos = startPos;
LinearGroup currentGroup = new LinearGroup();
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
float min, preferred, flexible;
GetChildSizes(child, axis, controlSize, childForceExpandSize, out min, out preferred, out flexible);
float scaleFactor = useScale ? child.localScale[axis] : 1f;
float childSize = Mathf.Max(min, preferred);
childSize += flexible * itemFlexibleMultiplier;
//Fit in current group
if (pos + childSize <= innerSize)
{
currentGroup.RectChildren.Add(child);
pos += childSize * scaleFactor + spacing;
//Last iteraction so we must force add currentgroup to groups
if (i == rectChildren.Count - 1)
{
rectChildrenPerGroup.Add(currentGroup);
}
}
//Dont fit
else
{
//We finished this group, add it in groups list
rectChildrenPerGroup.Add(currentGroup);
//Create a new group
var newGroup = new LinearGroup();
pos = startPos;
//We cant skup this case, child must be added in this group if no other was added before
if (currentGroup.RectChildren.Count == 0)
{
currentGroup.RectChildren.Add(child);
}
else
{
newGroup.RectChildren.Add(child);
pos = childSize * scaleFactor + spacing;
}
currentGroup = newGroup;
//Last iteraction so we must force add currentgroup to groups
if (i == rectChildren.Count - 1 && newGroup.RectChildren.Count > 0)
{
rectChildrenPerGroup.Add(newGroup);
}
}
}
return(rectChildrenPerGroup);
}
