using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
using System;
|
using Cysharp.Threading.Tasks;
|
|
[ExecuteAlways]
|
public class AdaptiveLayout : MonoBehaviour
|
{
|
[SerializeField] HorizonOrVertical m_HorizonOrVerticle;
|
[SerializeField] CanvasGroup m_CanvasGroup;
|
[SerializeField] List<AdaptiveElement> m_AdapElements;
|
[SerializeField] bool m_AutoIncludeChild=false;
|
[SerializeField] float m_LeastHeight = 0f;
|
[SerializeField] float m_LeastWidth = 0f;
|
[SerializeField] float m_MaxHeight = 0f;
|
[SerializeField] float m_MaxWidth = 0f;
|
[NonSerialized] RectTransform m_Rect;
|
public RectTransform rectTransform
|
{
|
get
|
{
|
if (m_Rect == null)
|
{
|
m_Rect = GetComponent<RectTransform>();
|
}
|
return m_Rect;
|
}
|
}
|
public float Size
|
{
|
get
|
{
|
return m_HorizonOrVerticle == HorizonOrVertical.Horizon ? rectTransform.sizeDelta.x : rectTransform.sizeDelta.y;
|
}
|
}
|
|
public event Action adaptiveUpdateEvent;
|
|
private void OnEnable()
|
{
|
if (m_AdapElements == null)
|
{
|
enabled = false;
|
return;
|
}
|
if (m_CanvasGroup != null)
|
{
|
m_CanvasGroup.alpha = 0;
|
m_CanvasGroup.interactable = true;
|
Co_DelayShow();
|
}
|
}
|
|
private void TrackerRect(RectTransform _rect)
|
{
|
var _pivot = _rect.pivot;
|
var _anchorMax = _rect.anchorMax;
|
var _anchorMin = _rect.anchorMin;
|
if (m_HorizonOrVerticle == HorizonOrVertical.Horizon)
|
{
|
_pivot.x = 0; _pivot.y = 0.5f;
|
_anchorMax.x = 0; _anchorMax.y = 0.5f;
|
_anchorMin.x = 0; _anchorMin.y = 0.5f;
|
}
|
else
|
{
|
_pivot.x = 0.5f; _pivot.y = 1f;
|
_anchorMax.x = 0.5f; _anchorMax.y = 1;
|
_anchorMin.x = 0.5f; _anchorMin.y = 1;
|
}
|
if (_rect.pivot != _pivot || _rect.anchorMax != _anchorMax || _rect.anchorMin != _anchorMin)
|
{
|
_rect.pivot = _pivot;
|
_rect.anchorMax = _anchorMax;
|
_rect.anchorMin = _anchorMin;
|
}
|
}
|
|
private void CalculateLayout()
|
{
|
var _offset = 0.0f;
|
var _horizon = m_HorizonOrVerticle == HorizonOrVertical.Horizon;
|
for (int i = 0; i < m_AdapElements.Count; i++)
|
{
|
if (m_AdapElements[i].rect == null || !m_AdapElements[i].rect.gameObject.activeInHierarchy)
|
{
|
continue;
|
}
|
_offset += _horizon ? m_AdapElements[i].padding.left : m_AdapElements[i].padding.top;
|
var _pos = m_AdapElements[i].rect.localPosition;
|
if (_horizon)
|
{
|
_pos.x = _offset;
|
}
|
else
|
{
|
_pos.y = -_offset;
|
}
|
if (m_AdapElements[i].rect.localPosition != _pos)
|
{
|
m_AdapElements[i].rect.localPosition = _pos;
|
}
|
_offset += _horizon ? m_AdapElements[i].rect.sizeDelta.x : m_AdapElements[i].rect.sizeDelta.y;
|
_offset += _horizon ? m_AdapElements[i].padding.right : m_AdapElements[i].padding.bottom;
|
}
|
var _sizeDelta = rectTransform.sizeDelta;
|
if (_horizon)
|
{
|
if (m_LeastWidth > 1f)
|
{
|
_offset = Mathf.Max(_offset, m_LeastWidth);
|
}
|
if (m_MaxWidth > 1f)
|
{
|
_offset = Mathf.Min(_offset, m_MaxWidth);
|
}
|
_sizeDelta.x = _offset;
|
}
|
else
|
{
|
if (m_LeastHeight > 1f)
|
{
|
_offset = Mathf.Max(_offset, m_LeastHeight);
|
}
|
if (m_MaxHeight > 1f)
|
{
|
_offset = Mathf.Min(_offset, m_MaxHeight);
|
}
|
_sizeDelta.y = _offset;
|
}
|
if (rectTransform.sizeDelta != _sizeDelta)
|
{
|
rectTransform.sizeDelta = _sizeDelta;
|
if (adaptiveUpdateEvent != null)
|
{
|
adaptiveUpdateEvent();
|
}
|
}
|
}
|
|
private void LateUpdate()
|
{
|
if (m_AdapElements == null)
|
{
|
return;
|
}
|
TrackerRect(rectTransform);
|
for (int i = 0; i < m_AdapElements.Count; i++)
|
{
|
if (m_AdapElements[i].rect == null)
|
{
|
continue;
|
}
|
TrackerRect(m_AdapElements[i].rect);
|
}
|
CalculateLayout();
|
}
|
|
private void OnTransformChildrenChanged()
|
{
|
if (m_AutoIncludeChild)
|
{
|
AutoIncludeChild();
|
}
|
}
|
|
private void AutoIncludeChild()
|
{
|
var _index = 0;
|
foreach (Transform _child in transform)
|
{
|
if (m_AdapElements == null)
|
{
|
m_AdapElements = new List<AdaptiveElement>();
|
}
|
var _rect = m_AdapElements.Find((x) =>
|
{
|
return x.rect == _child;
|
});
|
var _rectOffset= _child.GetComponent<AdaptiveRectOffset>();
|
if (_rect == null)
|
{
|
m_AdapElements.Insert(_index, new AdaptiveElement(_child as RectTransform, _rectOffset));
|
}
|
_index++;
|
}
|
if (m_AdapElements != null)
|
{
|
m_AdapElements.RemoveAll((x) =>
|
{
|
return x.rect == null;
|
});
|
}
|
LateUpdate();
|
}
|
|
async UniTask Co_DelayShow()
|
{
|
await UniTask.Delay(100);
|
if (m_CanvasGroup != null)
|
{
|
m_CanvasGroup.alpha = 1;
|
}
|
}
|
|
public enum HorizonOrVertical
|
{
|
Horizon,
|
Vertical,
|
}
|
[Serializable]
|
public class AdaptiveElement
|
{
|
[SerializeField] RectTransform m_Rect;
|
public RectTransform rect
|
{
|
get
|
{
|
return m_Rect;
|
}
|
}
|
[SerializeField] RectOffset m_Padding;
|
public RectOffset padding
|
{
|
get
|
{
|
return m_Padding;
|
}
|
}
|
|
public AdaptiveElement(RectTransform _rect, AdaptiveRectOffset _offset)
|
{
|
m_Rect = _rect;
|
m_Padding = _offset == null ? new RectOffset() : _offset.rectOffset;
|
}
|
}
|
|
}
|
