344 lines
14 KiB
C#
344 lines
14 KiB
C#
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using UnityEngine.UI;
|
||
|
||
namespace XericUI.Helper
|
||
{
|
||
public static class GridLayoutCalculator
|
||
{
|
||
public static Vector2 Grid;
|
||
|
||
public struct LayoutItem
|
||
{
|
||
public Vector2 position; // anchoredPosition
|
||
public Vector2 size;
|
||
public int indexInGrid;
|
||
public int rowIndex;
|
||
public int columnIndex;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算所有项目的布局
|
||
/// </summary>
|
||
/// <param name="childCount">子项数量</param>
|
||
/// <param name="containerSize">所需尺寸</param>
|
||
/// <param name="cellSize">单元尺寸</param>
|
||
/// <param name="spacing">单元空隙</param>
|
||
/// <param name="padding">外围空隙</param>
|
||
/// <param name="startCorner">起始角</param>
|
||
/// <param name="startAxis">起始轴</param>
|
||
/// <param name="constraint">容器尺寸</param>
|
||
/// <param name="constraintCount">需要的列数</param>
|
||
/// <param name="childAlignment">子项对齐</param>
|
||
/// <returns></returns>
|
||
public static List<LayoutItem> CalculateGridLayout(
|
||
ref List<LayoutItem> layoutItems,
|
||
int childCount,
|
||
Vector2 containerSize,
|
||
Vector2 cellSize,
|
||
Vector2 spacing,
|
||
RectOffset padding,
|
||
GridLayoutGroup.Corner startCorner,
|
||
GridLayoutGroup.Axis startAxis,
|
||
GridLayoutGroup.Constraint constraint,
|
||
int constraintCount,
|
||
TextAnchor childAlignment = TextAnchor.UpperLeft)
|
||
{
|
||
if (layoutItems == null)
|
||
layoutItems = new List<LayoutItem>();
|
||
else
|
||
layoutItems.Clear();
|
||
|
||
// 边界保护
|
||
constraintCount = Mathf.Max(1, constraintCount);
|
||
cellSize = new Vector2(Mathf.Max(0.1f, cellSize.x), Mathf.Max(0.1f, cellSize.y));
|
||
spacing = new Vector2(Mathf.Max(0f, spacing.x), Mathf.Max(0f, spacing.y));
|
||
|
||
// todo 这里的行列数限制了实际行列数，需要修改计算扩容
|
||
// 1. 计算行列数
|
||
int cellCountX, cellCountY;
|
||
CalculateGridDimensions(childCount, containerSize, cellSize, spacing, padding,
|
||
constraint, constraintCount, startAxis, out cellCountX, out cellCountY);
|
||
|
||
// 2. 计算实际使用的行列数
|
||
int actualCellCountX, actualCellCountY;
|
||
CalculateActualGridDimensions(childCount, cellCountX, cellCountY, constraint, constraintCount,
|
||
startAxis, out actualCellCountX, out actualCellCountY);
|
||
|
||
Grid = new Vector2(actualCellCountX, actualCellCountY);
|
||
|
||
// 3. 计算所需空间
|
||
Vector2 requiredSpace = new Vector2(
|
||
actualCellCountX * cellSize.x + Mathf.Max(0, actualCellCountX - 1) * spacing.x,
|
||
actualCellCountY * cellSize.y + Mathf.Max(0, actualCellCountY - 1) * spacing.y
|
||
);
|
||
|
||
// 4. 计算起始偏移（关键修复：根据startCorner调整基准点）
|
||
Vector2 startOffset = CalculateStartOffset(
|
||
requiredSpace, containerSize, padding, childAlignment, startCorner);
|
||
|
||
// 5. 处理特殊情况
|
||
|
||
int childrenToMove = CalculateChildrenToMove(childCount, cellCountX, cellCountY,
|
||
constraint, constraintCount, startAxis);
|
||
|
||
// 6. 计算每个子项的位置
|
||
int cornerX = (int)startCorner % 2; // 0=左, 1=右
|
||
int cornerY = (int)startCorner / 2; // 0=上, 1=下
|
||
|
||
for (int i = 0; i < childCount; i++)
|
||
{
|
||
int gridX, gridY;
|
||
CalculateItemGridPosition(i, childCount, cellCountX, cellCountY, startAxis,
|
||
constraint, constraintCount, childrenToMove,
|
||
actualCellCountX, actualCellCountY, out gridX, out gridY);
|
||
|
||
// 应用corner翻转（关键：这决定了索引0的位置）
|
||
if (cornerX == 1)
|
||
gridX = actualCellCountX - 1 - gridX;
|
||
if (cornerY == 1)
|
||
gridY = actualCellCountY - 1 - gridY;
|
||
|
||
// 计算最终位置（根据startCorner决定方向）
|
||
// 在Unity UI坐标系中：左下角是(0,0)，向右X增加，向上Y增加
|
||
// UpperLeft (0): 起点左上，向右(+)填充，向下(-)排列
|
||
// UpperRight (1): 起点右上，向左(-)填充，向下(-)排列
|
||
// LowerLeft (2): 起点左下，向右(+)填充，向上(+)排列
|
||
// LowerRight (3): 起点右下，向左(-)填充，向上(+)排列
|
||
float xDir = cornerX == 0 ? 1f : -1f; // 左边开始向右，右边开始向左
|
||
float yDir = cornerY == 0 ? -1f : 1f; // 上边开始向下，下边开始向上
|
||
|
||
Vector2 position = new Vector2(
|
||
startOffset.x + (cellSize.x + spacing.x) * gridX * xDir,
|
||
startOffset.y + (cellSize.y + spacing.y) * gridY * yDir
|
||
);
|
||
|
||
layoutItems.Add(new LayoutItem
|
||
{
|
||
position = position,
|
||
size = cellSize,
|
||
indexInGrid = i,
|
||
rowIndex = gridY,
|
||
columnIndex = gridX
|
||
});
|
||
}
|
||
|
||
return layoutItems;
|
||
}
|
||
|
||
// ===== 核心修复：根据startCorner计算起始偏移 =====
|
||
private static Vector2 CalculateStartOffset(
|
||
Vector2 requiredSpace,
|
||
Vector2 containerSize,
|
||
RectOffset padding,
|
||
TextAnchor childAlignment,
|
||
GridLayoutGroup.Corner startCorner)
|
||
{
|
||
// 计算每个轴的起始偏移
|
||
float startX = CalculateAxisStartOffset(
|
||
0, requiredSpace.x, containerSize.x, padding, childAlignment, startCorner);
|
||
float startY = CalculateAxisStartOffset(
|
||
1, requiredSpace.y, containerSize.y, padding, childAlignment, startCorner);
|
||
|
||
return new Vector2(startX, startY);
|
||
}
|
||
|
||
private static float CalculateAxisStartOffset(
|
||
int axis, // 0=X, 1=Y
|
||
float requiredSpace,
|
||
float availableSpace,
|
||
RectOffset padding,
|
||
TextAnchor childAlignment,
|
||
GridLayoutGroup.Corner startCorner)
|
||
{
|
||
// 计算包含padding的总需求空间
|
||
float requiredSpaceWithPadding = requiredSpace + (axis == 0 ? padding.horizontal : padding.vertical);
|
||
|
||
// 计算剩余空间
|
||
float surplusSpace = availableSpace - requiredSpaceWithPadding;
|
||
|
||
// 获取对齐值（0=左/上, 0.5=中, 1=右/下）
|
||
float alignmentValue = GetAlignmentOnAxis(axis, childAlignment);
|
||
|
||
// 关键：根据startCorner调整基准点
|
||
float baseOffset;
|
||
if (axis == 0) // X轴
|
||
{
|
||
// 如果startCorner在右侧，基准点应该是availableSpace - padding.right - requiredSpace
|
||
int cornerX = (int)startCorner % 2;
|
||
baseOffset = (cornerX == 0) ? padding.left : (availableSpace - padding.right - requiredSpace);
|
||
}
|
||
else // Y轴
|
||
{
|
||
// 如果startCorner在底部，基准点应该是availableSpace - padding.bottom - requiredSpace
|
||
int cornerY = (int)startCorner / 2;
|
||
baseOffset = (cornerY == 0) ? padding.top : (availableSpace - padding.bottom - requiredSpace);
|
||
}
|
||
|
||
// 应用对齐（在剩余空间内）
|
||
return baseOffset + surplusSpace * alignmentValue;
|
||
}
|
||
|
||
private static void CalculateItemGridPosition(
|
||
int index,
|
||
int childCount,
|
||
int cellCountX,
|
||
int cellCountY,
|
||
GridLayoutGroup.Axis startAxis,
|
||
GridLayoutGroup.Constraint constraint,
|
||
int constraintCount,
|
||
int childrenToMove,
|
||
int actualCellCountX,
|
||
int actualCellCountY,
|
||
out int gridX,
|
||
out int gridY)
|
||
{
|
||
// 计算基础位置（不考虑corner翻转）
|
||
if (startAxis == GridLayoutGroup.Axis.Horizontal)
|
||
{
|
||
if (constraint == GridLayoutGroup.Constraint.FixedRowCount &&
|
||
childrenToMove > 0 && childCount - index <= childrenToMove)
|
||
{
|
||
// 计算偏移量，确保gridY不会为负数
|
||
int offset = childCount - index - 1;
|
||
gridX = 0;
|
||
gridY = Mathf.Min(offset, constraintCount - 1);
|
||
}
|
||
else
|
||
{
|
||
gridX = index % cellCountX;
|
||
gridY = index / cellCountX;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (constraint == GridLayoutGroup.Constraint.FixedColumnCount &&
|
||
childrenToMove > 0 && childCount - index <= childrenToMove)
|
||
{
|
||
// 计算偏移量，确保gridX不会为负数
|
||
int offset = childCount - index - 1;
|
||
gridX = Mathf.Min(offset, constraintCount - 1);
|
||
gridY = 0;
|
||
}
|
||
else
|
||
{
|
||
gridX = index / cellCountY;
|
||
gridY = index % cellCountY;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static int CalculateChildrenToMove(
|
||
int childCount,
|
||
int cellCountX,
|
||
int cellCountY,
|
||
GridLayoutGroup.Constraint constraint,
|
||
int constraintCount,
|
||
GridLayoutGroup.Axis startAxis)
|
||
{
|
||
if (constraint == GridLayoutGroup.Constraint.Flexible || childCount <= constraintCount)
|
||
return 0;
|
||
|
||
int cellsPerMainAxis = startAxis == GridLayoutGroup.Axis.Horizontal ? cellCountX : cellCountY;
|
||
|
||
if (cellsPerMainAxis <= 0)
|
||
return 0;
|
||
|
||
float rowsNeeded = Mathf.CeilToInt((float)childCount / (float)cellsPerMainAxis);
|
||
if (rowsNeeded >= constraintCount)
|
||
return 0;
|
||
|
||
int childrenToMove = constraintCount - (int)rowsNeeded;
|
||
childrenToMove += Mathf.FloorToInt((float)childrenToMove / Mathf.Max(1f, (float)cellsPerMainAxis - 1));
|
||
|
||
if (childCount % cellsPerMainAxis == 1)
|
||
childrenToMove += 1;
|
||
|
||
return Mathf.Clamp(childrenToMove, 0, childCount);
|
||
}
|
||
|
||
private static void CalculateGridDimensions(
|
||
int childCount,
|
||
Vector2 containerSize,
|
||
Vector2 cellSize,
|
||
Vector2 spacing,
|
||
RectOffset padding,
|
||
GridLayoutGroup.Constraint constraint,
|
||
int constraintCount,
|
||
GridLayoutGroup.Axis startAxis,
|
||
out int cellCountX,
|
||
out int cellCountY)
|
||
{
|
||
cellCountX = 1;
|
||
cellCountY = 1;
|
||
|
||
switch (constraint)
|
||
{
|
||
case GridLayoutGroup.Constraint.FixedColumnCount:
|
||
cellCountX = constraintCount;
|
||
if (childCount > cellCountX)
|
||
cellCountY = childCount / cellCountX + (childCount % cellCountX > 0 ? 1 : 0);
|
||
break;
|
||
case GridLayoutGroup.Constraint.FixedRowCount:
|
||
cellCountY = constraintCount;
|
||
if (childCount > cellCountY)
|
||
cellCountX = childCount / cellCountY + (childCount % cellCountY > 0 ? 1 : 0);
|
||
break;
|
||
default:
|
||
float availableWidth = containerSize.x - padding.horizontal;
|
||
float availableHeight = containerSize.y - padding.vertical;
|
||
|
||
if (cellSize.x + spacing.x > 0)
|
||
cellCountX = Mathf.Max(1,
|
||
Mathf.FloorToInt((availableWidth + spacing.x + 0.001f) / (cellSize.x + spacing.x)));
|
||
else
|
||
cellCountX = int.MaxValue;
|
||
|
||
if (cellSize.y + spacing.y > 0)
|
||
cellCountY = Mathf.Max(1,
|
||
Mathf.FloorToInt((availableHeight + spacing.y + 0.001f) / (cellSize.y + spacing.y)));
|
||
else
|
||
cellCountY = int.MaxValue;
|
||
break;
|
||
}
|
||
}
|
||
|
||
private static void CalculateActualGridDimensions(
|
||
int childCount,
|
||
int cellCountX,
|
||
int cellCountY,
|
||
GridLayoutGroup.Constraint constraint,
|
||
int constraintCount,
|
||
GridLayoutGroup.Axis startAxis,
|
||
out int actualCellCountX,
|
||
out int actualCellCountY)
|
||
{
|
||
if (startAxis == GridLayoutGroup.Axis.Horizontal)
|
||
{
|
||
actualCellCountX = Mathf.Clamp(cellCountX, 1, childCount);
|
||
|
||
if (constraint == GridLayoutGroup.Constraint.FixedRowCount)
|
||
actualCellCountY = Mathf.Min(cellCountY, childCount);
|
||
else
|
||
actualCellCountY = Mathf.Clamp(cellCountY, 1, Mathf.CeilToInt(childCount / (float)cellCountX));
|
||
}
|
||
else
|
||
{
|
||
actualCellCountY = Mathf.Clamp(cellCountY, 1, childCount);
|
||
|
||
if (constraint == GridLayoutGroup.Constraint.FixedColumnCount)
|
||
actualCellCountX = Mathf.Min(cellCountX, childCount);
|
||
else
|
||
actualCellCountX = Mathf.Clamp(cellCountX, 1, Mathf.CeilToInt(childCount / (float)cellCountY));
|
||
}
|
||
}
|
||
|
||
private static float GetAlignmentOnAxis(int axis, TextAnchor childAlignment)
|
||
{
|
||
if (axis == 0)
|
||
return ((int)childAlignment % 3) * (1f / 3f); // 0, 0.333, 0.666
|
||
else
|
||
return ((int)childAlignment / 3) * 0.5f; // 0, 0.5, 1
|
||
}
|
||
}
|
||
} |