示例#1
0
        public override void UpdateLayout()
        {
            elementList.Clear();
            float sum = 0.0f;

            foreach (Transform child in transform)
            {
                LayoutElement3D element = child.GetComponent <LayoutElement3D>();
                if (!child.gameObject.activeSelf || element == null)
                {
                    continue;
                }
                elementList.Add(element);
                sum += element.size.y * element.transform.localScale.y;
            }
            float sum_withSpace = sum + spacing * (elementList.Count - 1);

            Vector3 c_size = new Vector3();

            c_size.x = size.x - padding.lower.x - padding.upper.x;
            c_size.y = size.y - padding.lower.y - padding.upper.y;
            c_size.z = size.z - padding.lower.z - padding.upper.z;

            Vector3 c_center = center;

            c_center.x += (padding.lower.x - padding.upper.x) * 0.5f;
            c_center.y += (padding.lower.y - padding.upper.y) * 0.5f;
            c_center.z += (padding.lower.z - padding.upper.z) * 0.5f;

            Vector3 direction = Vector3.zero;
            Vector3 offset    = Vector3.zero;

            direction.y = childDirection == Direction.LowerToUpper ? 1.0f : -1.0f;
            switch (childAlignmentY)
            {
            case AxisAlignment.Lower:
                offset.y = -c_size.y * 0.5f;
                if (childDirection == Direction.UpperToLower)
                {
                    offset.y += sum_withSpace;
                }
                break;

            case AxisAlignment.Middle:
                offset.y = -direction.y * sum_withSpace * 0.5f;
                break;

            case AxisAlignment.Upper:
                offset.y = c_size.y * 0.5f;
                if (childDirection == Direction.LowerToUpper)
                {
                    offset.y -= sum_withSpace;
                }
                break;
            }

            switch (childAlignmentX)
            {
            case AxisAlignment.Lower:
                direction.x = 1.0f;
                break;

            case AxisAlignment.Middle:
                direction.x = 0.0f;
                break;

            case AxisAlignment.Upper:
                direction.x = -1.0f;
                break;
            }
            offset.x = -direction.x * c_size.x * 0.5f;

            switch (childAlignmentZ)
            {
            case AxisAlignment.Lower:
                direction.z = 1.0f;
                break;

            case AxisAlignment.Middle:
                direction.z = 0.0f;
                break;

            case AxisAlignment.Upper:
                direction.z = -1.0f;
                break;
            }
            offset.z = -direction.z * c_size.z * 0.5f;

            float   c_spacing   = spacing;
            Vector3 scaleFactor = Vector3.zero;

            if (childForceExpand.y)
            {
                offset.y      = -direction.y * c_size.y * 0.5f;
                scaleFactor.y = (c_size.y - (c_spacing * (elementList.Count - 1))) / elementList.Count;
                if (!childControlSize.x && sum_withSpace < c_size.y)
                {
                    c_spacing = (c_size.y - sum) / (elementList.Count - 1);
                }
            }
            if (childForceExpand.x)
            {
                scaleFactor.x = c_size.x;
            }
            if (childForceExpand.z)
            {
                scaleFactor.z = c_size.z;
            }

            foreach (LayoutElement3D element in elementList)
            {
                Vector3 scale = element.transform.localScale;
                if (childControlSize.x)
                {
                    scale.x = scaleFactor.x / element.size.x;
                }
                if (childControlSize.y)
                {
                    scale.y = scaleFactor.y / element.size.y;
                }
                if (childControlSize.z)
                {
                    scale.z = scaleFactor.z / element.size.z;
                }
                element.transform.localScale = scale;

                Vector3 elementSize = Vector3.one;
                elementSize.x = element.size.x * scale.x;
                elementSize.y = element.size.y * scale.y;
                elementSize.z = element.size.z * scale.z;

                Vector3 elementOffset = Vector3.one;
                elementOffset.x = elementSize.x * 0.5f * direction.x - element.center.x * scale.x;
                elementOffset.y = elementSize.y * 0.5f * direction.y - element.center.y * scale.y;
                elementOffset.z = elementSize.z * 0.5f * direction.z - element.center.z * scale.z;

                element.transform.localPosition = c_center + offset + elementOffset;
                offset.y += (elementSize.y + c_spacing) * direction.y;
            }
            elementList.Clear();
        }
示例#2
0
        public override void UpdateLayout()
        {
            Check();
            elementList.Clear();
            foreach (Transform child in transform)
            {
                LayoutElement3D element = child.GetComponent <LayoutElement3D>();
                if (!child.gameObject.activeSelf || element == null)
                {
                    continue;
                }
                elementList.Add(element);
            }

            Vector3 c_size = new Vector3();

            c_size.x = size.x - padding.lower.x - padding.upper.x;
            c_size.y = size.y - padding.lower.y - padding.upper.y;
            c_size.z = size.z - padding.lower.z - padding.upper.z;

            Vector3 c_center = center;

            c_center.x += (padding.lower.x - padding.upper.x) * 0.5f;
            c_center.y += (padding.lower.y - padding.upper.y) * 0.5f;
            c_center.z += (padding.lower.z - padding.upper.z) * 0.5f;

            Int3 c_count_max = new Int3();

            c_count_max.x = constraintX.constraintType == ConstraintType.Flexible ?
                            Mathf.FloorToInt((c_size.x + spacing.x) / (cellSize.x + spacing.x)) : constraintX.constraintCount;
            c_count_max.y = constraintY.constraintType == ConstraintType.Flexible ?
                            Mathf.FloorToInt((c_size.y + spacing.y) / (cellSize.y + spacing.y)) : constraintY.constraintCount;
            c_count_max.z = constraintZ.constraintType == ConstraintType.Flexible ?
                            Mathf.FloorToInt((c_size.z + spacing.z) / (cellSize.z + spacing.z)) : constraintZ.constraintCount;

            Int3 c_count = new Int3();
            int  countUnit, countRow, countPlane;

            countUnit = elementList.Count;
            switch (axisOrder)
            {
            case AxisOrder.XYZ:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.x);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.x / c_count_max.y);
                c_count.x  = countUnit < c_count_max.x ? countUnit : c_count_max.x;
                c_count.y  = countRow < c_count_max.y ? countRow : c_count_max.y;
                c_count.z  = countPlane < c_count_max.z ? countPlane : c_count_max.z;
                constraintZ.constraintType = ConstraintType.Flexible;
                break;

            case AxisOrder.XZY:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.x);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.x / c_count_max.z);
                c_count.x  = countUnit < c_count_max.x ? countUnit : c_count_max.x;
                c_count.z  = countRow < c_count_max.z ? countRow : c_count_max.z;
                c_count.y  = countPlane < c_count_max.y ? countPlane : c_count_max.y;
                constraintY.constraintType = ConstraintType.Flexible;
                break;

            case AxisOrder.YXZ:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.y);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.y / c_count_max.x);
                c_count.y  = countUnit < c_count_max.y ? countUnit : c_count_max.y;
                c_count.x  = countRow < c_count_max.x ? countRow : c_count_max.x;
                c_count.z  = countPlane < c_count_max.z ? countPlane : c_count_max.z;
                constraintZ.constraintType = ConstraintType.Flexible;
                break;

            case AxisOrder.YZX:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.y);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.y / c_count_max.z);
                c_count.y  = countUnit < c_count_max.y ? countUnit : c_count_max.y;
                c_count.z  = countRow < c_count_max.z ? countRow : c_count_max.z;
                c_count.x  = countPlane < c_count_max.x ? countPlane : c_count_max.x;
                constraintX.constraintType = ConstraintType.Flexible;
                break;

            case AxisOrder.ZXY:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.z);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.z / c_count_max.x);
                c_count.z  = countUnit < c_count_max.z ? countUnit : c_count_max.z;
                c_count.x  = countRow < c_count_max.x ? countRow : c_count_max.x;
                c_count.y  = countPlane < c_count_max.y ? countPlane : c_count_max.y;
                constraintY.constraintType = ConstraintType.Flexible;
                break;

            case AxisOrder.ZYX:
                countRow   = Mathf.CeilToInt((float)elementList.Count / c_count_max.z);
                countPlane = Mathf.CeilToInt((float)elementList.Count / c_count_max.z / c_count_max.y);
                c_count.z  = countUnit < c_count_max.z ? countUnit : c_count_max.z;
                c_count.y  = countRow < c_count_max.y ? countRow : c_count_max.y;
                c_count.x  = countPlane < c_count_max.x ? countPlane : c_count_max.x;
                constraintX.constraintType = ConstraintType.Flexible;
                break;
            }

            Vector3 sum_withSpace = new Vector3();

            sum_withSpace.x = (cellSize.x + spacing.x) * c_count.x - spacing.x;
            sum_withSpace.y = (cellSize.y + spacing.y) * c_count.y - spacing.y;
            sum_withSpace.z = (cellSize.z + spacing.z) * c_count.z - spacing.z;

            Vector3 offset    = Vector3.zero;
            Vector3 direction = Vector3.zero;

            direction.x = childDirectionX == Direction.LowerToUpper ? 1.0f : -1.0f;
            direction.y = childDirectionY == Direction.LowerToUpper ? 1.0f : -1.0f;
            direction.z = childDirectionZ == Direction.LowerToUpper ? 1.0f : -1.0f;

            switch (childAlignmentX)
            {
            case AxisAlignment.Lower:
                offset.x = -c_size.x * 0.5f;
                if (childDirectionX == Direction.UpperToLower)
                {
                    offset.x += sum_withSpace.x;
                }
                break;

            case AxisAlignment.Middle:
                offset.x = -direction.x * sum_withSpace.x * 0.5f;
                break;

            case AxisAlignment.Upper:
                offset.x = c_size.x * 0.5f;
                if (childDirectionX == Direction.LowerToUpper)
                {
                    offset.x -= sum_withSpace.x;
                }
                break;
            }

            switch (childAlignmentY)
            {
            case AxisAlignment.Lower:
                offset.y = -c_size.y * 0.5f;
                if (childDirectionY == Direction.UpperToLower)
                {
                    offset.y += sum_withSpace.y;
                }
                break;

            case AxisAlignment.Middle:
                offset.y = -direction.y * sum_withSpace.y * 0.5f;
                break;

            case AxisAlignment.Upper:
                offset.y = c_size.y * 0.5f;
                if (childDirectionY == Direction.LowerToUpper)
                {
                    offset.y -= sum_withSpace.y;
                }
                break;
            }

            switch (childAlignmentZ)
            {
            case AxisAlignment.Lower:
                offset.z = -c_size.z * 0.5f;
                if (childDirectionZ == Direction.UpperToLower)
                {
                    offset.z += sum_withSpace.z;
                }
                break;

            case AxisAlignment.Middle:
                offset.z = -direction.z * sum_withSpace.z * 0.5f;
                break;

            case AxisAlignment.Upper:
                offset.z = c_size.z * 0.5f;
                if (childDirectionZ == Direction.LowerToUpper)
                {
                    offset.z -= sum_withSpace.z;
                }
                break;
            }

            Vector3 scaleFactor = Vector3.zero;

            if (childForceExpand.x)
            {
                scaleFactor.x = cellSize.x;
            }
            if (childForceExpand.y)
            {
                scaleFactor.y = cellSize.y;
            }
            if (childForceExpand.z)
            {
                scaleFactor.z = cellSize.z;
            }

            Vector3 offset_curr = offset;
            Int3    counter     = new Int3();

            foreach (LayoutElement3D element in elementList)
            {
                Vector3 scale = element.transform.localScale;
                if (childControlSize.x)
                {
                    scale.x = scaleFactor.x / element.size.x;
                }
                if (childControlSize.y)
                {
                    scale.y = scaleFactor.y / element.size.y;
                }
                if (childControlSize.z)
                {
                    scale.z = scaleFactor.z / element.size.z;
                }
                element.transform.localScale = scale;

                Vector3 elementOffset = Vector3.one;
                elementOffset.x = cellSize.x * 0.5f * direction.x - element.center.x * scale.x;
                elementOffset.y = cellSize.y * 0.5f * direction.y - element.center.y * scale.y;
                elementOffset.z = cellSize.z * 0.5f * direction.z - element.center.z * scale.z;

                element.transform.localPosition = c_center + offset_curr + elementOffset;

                switch (axisOrder)
                {
                case AxisOrder.XYZ:
                    counter.x++;
                    if (counter.x >= c_count.x)
                    {
                        counter.x     = 0;
                        offset_curr.x = offset.x;

                        counter.y++;
                        if (counter.y >= c_count.y)
                        {
                            counter.y     = 0;
                            offset_curr.y = offset.y;

                            counter.z++;
                            offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                        }
                        else
                        {
                            offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                        }
                    }
                    else
                    {
                        offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                    }
                    break;

                case AxisOrder.XZY:
                    counter.x++;
                    if (counter.x >= c_count.x)
                    {
                        counter.x     = 0;
                        offset_curr.x = offset.x;

                        counter.z++;
                        if (counter.z >= c_count.z)
                        {
                            counter.z     = 0;
                            offset_curr.z = offset.z;

                            counter.y++;
                            offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                        }
                        else
                        {
                            offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                        }
                    }
                    else
                    {
                        offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                    }
                    break;

                case AxisOrder.YXZ:
                    counter.y++;
                    if (counter.y >= c_count.y)
                    {
                        counter.y     = 0;
                        offset_curr.y = offset.y;

                        counter.x++;
                        if (counter.x >= c_count.x)
                        {
                            counter.x     = 0;
                            offset_curr.x = offset.x;

                            counter.z++;
                            offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                        }
                        else
                        {
                            offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                        }
                    }
                    else
                    {
                        offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                    }
                    break;

                case AxisOrder.YZX:
                    counter.y++;
                    if (counter.y >= c_count.y)
                    {
                        counter.y     = 0;
                        offset_curr.y = offset.y;

                        counter.z++;
                        if (counter.z >= c_count.z)
                        {
                            counter.z     = 0;
                            offset_curr.z = offset.z;

                            counter.x++;
                            offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                        }
                        else
                        {
                            offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                        }
                    }
                    else
                    {
                        offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                    }
                    break;

                case AxisOrder.ZXY:
                    counter.z++;
                    if (counter.z >= c_count.z)
                    {
                        counter.z     = 0;
                        offset_curr.z = offset.z;

                        counter.x++;
                        if (counter.x >= c_count.x)
                        {
                            counter.x     = 0;
                            offset_curr.x = offset.x;

                            counter.y++;
                            offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                        }
                        else
                        {
                            offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                        }
                    }
                    else
                    {
                        offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                    }
                    break;

                case AxisOrder.ZYX:
                    counter.z++;
                    if (counter.z >= c_count.z)
                    {
                        counter.z     = 0;
                        offset_curr.z = offset.z;

                        counter.y++;
                        if (counter.y >= c_count.y)
                        {
                            counter.y     = 0;
                            offset_curr.y = offset.y;

                            counter.x++;
                            offset_curr.x += (cellSize.x + spacing.x) * direction.x;
                        }
                        else
                        {
                            offset_curr.y += (cellSize.y + spacing.y) * direction.y;
                        }
                    }
                    else
                    {
                        offset_curr.z += (cellSize.z + spacing.z) * direction.z;
                    }
                    break;
                }
            }
            elementList.Clear();
        }