com.amanotes.gdk 0.2.75 → 0.2.78

package/Runtime/UI/ScrollView/GDKScrollView.cs

@@ -0,0 +1,702 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+using UnityEngine.UI;
+
+
+namespace Amanotes.Core.Internal
+{
+    [RequireComponent(typeof(RectTransform))]
+    [DisallowMultipleComponent]
+    public class GDKScrollView : ScrollRect
+    {
+        public Vector2 defaultItemSize;
+        public RectTransform itemTemplate;
+        [SerializeField]
+        [FormerlySerializedAs("m_layoutType")]
+        protected ItemLayoutType layoutType = ItemLayoutType.Vertical;
+
+        private readonly List<ScrollItemWithRect> _managedItems = new List<ScrollItemWithRect>();
+        private readonly int[] _criticalItemIndex = new int[4];
+
+        private Action<int, RectTransform> _updateFunc;
+        private Func<int, Vector2> _itemSizeFunc;
+        private Func<int> _itemCountFunc;
+        private Func<int, RectTransform> _itemGetFunc;
+        private Action<RectTransform> _itemRecycleFunc;
+
+        private Rect _refRect;
+        private int _dataCount;
+        private bool _initialized;
+        private int _willUpdateData;
+
+        private readonly Vector3[] _viewWorldCorners = new Vector3[4];
+        private readonly Vector3[] _rectCorners = new Vector3[2];
+        private const int FLAG_SCROLL_DIRECTION = 1;
+
+        public enum ItemLayoutType
+        {
+            Vertical = 0b0001,                   // 0001
+            Horizontal = 0b0010,                 // 0010
+            VerticalThenHorizontal = 0b0100,     // 0100
+            HorizontalThenVertical = 0b0101,     // 0101
+        }
+
+        public virtual void SetUpdateFunc(Action<int, RectTransform> func)
+        {
+            _updateFunc = func;
+        }
+
+        public virtual void SetItemSizeFunc(Func<int, Vector2> func)
+        {
+            _itemSizeFunc = func;
+        }
+
+        public virtual void SetItemCountFunc(Func<int> func)
+        {
+            _itemCountFunc = func;
+        }
+
+        private void SetItemGetAndRecycleFunc(Func<int, RectTransform> getFunc, Action<RectTransform> recycleFunc)
+        {
+            if (getFunc != null && recycleFunc != null)
+            {
+                _itemGetFunc = getFunc;
+                _itemRecycleFunc = recycleFunc;
+            }
+            else
+            {
+                _itemGetFunc = null;
+                _itemRecycleFunc = null;
+            }
+        }
+
+        public void ResetAllDelegates()
+        {
+            SetUpdateFunc(null);
+            SetItemSizeFunc(null);
+            SetItemCountFunc(null);
+            SetItemGetAndRecycleFunc(null, null);
+        }
+
+        public void UpdateData(bool immediately = true)
+        {
+            if (immediately)
+            {
+                _willUpdateData |= 3; // 0011
+                InternalUpdateData();
+            }
+            else
+            {
+                if (_willUpdateData == 0 && IsActive())
+                {
+                    StartCoroutine(DelayUpdateData());
+                }
+
+                _willUpdateData |= 3;
+            }
+        }
+
+        public void UpdateDataIncrementally(bool immediately = true)
+        {
+            if (immediately)
+            {
+                _willUpdateData |= 1; // 0001
+                InternalUpdateData();
+            }
+            else
+            {
+                if (_willUpdateData == 0)
+                {
+                    StartCoroutine(DelayUpdateData());
+                }
+
+                _willUpdateData |= 1;
+            }
+        }
+
+        public void ScrollTo(int index)
+        {
+            InternalScrollTo(index);
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            if (_willUpdateData != 0)
+            {
+                StartCoroutine(DelayUpdateData());
+            }
+        }
+
+        protected virtual void InternalScrollTo(int index)
+        {
+            index = Mathf.Clamp(index, 0, _dataCount - 1);
+            EnsureItemRect(index);
+            Rect r = _managedItems[index].rect;
+            var dir = (int)layoutType & FLAG_SCROLL_DIRECTION;
+            if (dir == 1)
+            {
+                // vertical
+                var value = 1 - (-r.yMax / (content.sizeDelta.y - _refRect.height));
+                value = Mathf.Clamp01(value);
+                SetNormalizedPosition(value, 1);
+            }
+            else
+            {
+                // horizontal
+                var value = r.xMin / (content.sizeDelta.x - _refRect.width);
+                value = Mathf.Clamp01(value);
+                SetNormalizedPosition(value, 0);
+            }
+        }
+
+        protected override void SetContentAnchoredPosition(Vector2 position)
+        {
+            base.SetContentAnchoredPosition(position);
+
+            if (_willUpdateData != 0)
+            {
+                return;
+            }
+
+            UpdateCriticalItems();
+        }
+
+        protected override void SetNormalizedPosition(float value, int axis)
+        {
+            base.SetNormalizedPosition(value, axis);
+
+            if (_willUpdateData != 0)
+            {
+                return;
+            }
+
+            ResetCriticalItems();
+        }
+
+        private void EnsureItemRect(int index)
+        {
+            if (!_managedItems[index].rectDirty)
+            {
+                return;
+            }
+
+            var firstItem = _managedItems[0];
+            if (firstItem.rectDirty)
+            {
+                Vector2 firstSize = GetItemSize(0);
+                firstItem.rect = CreateWithLeftTopAndSize(Vector2.zero, firstSize);
+                firstItem.rectDirty = false;
+            }
+
+            var nearestClean = 0;
+            for (var i = index; i >= 0; --i)
+            {
+                if (_managedItems[i].rectDirty)
+                    continue;
+                nearestClean = i;
+                break;
+            }
+
+            Rect nearestCleanRect = _managedItems[nearestClean].rect;
+            Vector2 curPos = GetLeftTop(nearestCleanRect);
+            Vector2 size = nearestCleanRect.size;
+            MovePos(ref curPos, size);
+
+            for (var i = nearestClean + 1; i <= index; i++)
+            {
+                size = GetItemSize(i);
+                _managedItems[i].rect = CreateWithLeftTopAndSize(curPos, size);
+                _managedItems[i].rectDirty = false;
+                MovePos(ref curPos, size);
+            }
+
+            var range = new Vector2(Mathf.Abs(curPos.x), Mathf.Abs(curPos.y));
+            switch (layoutType)
+            {
+                case ItemLayoutType.VerticalThenHorizontal:
+                    range.x += size.x;
+                    range.y = _refRect.height;
+                    break;
+                case ItemLayoutType.HorizontalThenVertical:
+                    range.x = _refRect.width;
+                    if (curPos.x != 0)
+                    {
+                        range.y += size.y;
+                    }
+
+                    break;
+            }
+
+            content.sizeDelta = range;
+        }
+
+        protected override void OnDestroy()
+        {
+	        GDKPrefabPool.DestroyPooled(itemTemplate);
+        }
+
+        protected Rect GetItemLocalRect(int index)
+        {
+            if (index < 0 || index >= _dataCount)
+                return default;
+            EnsureItemRect(index);
+            return _managedItems[index].rect;
+
+        }
+
+#if UNITY_EDITOR
+        protected override void OnValidate()
+        {
+            var dir = (int)layoutType & FLAG_SCROLL_DIRECTION;
+            if (dir == 1)
+            {
+                // vertical
+                if (horizontalScrollbar != null)
+                {
+                    horizontalScrollbar.gameObject.SetActive(false);
+                    horizontalScrollbar = null;
+                }
+            }
+            else
+            {
+                // horizontal
+                if (verticalScrollbar != null)
+                {
+                    verticalScrollbar.gameObject.SetActive(false);
+                    verticalScrollbar = null;
+                }
+            }
+
+            base.OnValidate();
+        }
+#endif
+
+        private static Vector2 GetLeftTop(Rect rect)
+        {
+            Vector2 ret = rect.position;
+            ret.y += rect.size.y;
+            return ret;
+        }
+
+        private static Rect CreateWithLeftTopAndSize(Vector2 leftTop, Vector2 size)
+        {
+            Vector2 leftBottom = leftTop - new Vector2(0, size.y);
+            return new Rect(leftBottom, size);
+        }
+
+        private IEnumerator DelayUpdateData()
+        {
+            yield return new WaitForEndOfFrame();
+
+            InternalUpdateData();
+        }
+
+        private void InternalUpdateData()
+        {
+            if (!IsActive())
+            {
+                _willUpdateData |= 3;
+                return;
+            }
+
+            if (!_initialized)
+            {
+                InitScrollView();
+            }
+
+            CheckDataCountChange();
+
+            ResetCriticalItems();
+
+            _willUpdateData = 0;
+        }
+
+        protected virtual void CheckDataCountChange()
+        {
+            var newDataCount = 0;
+
+            if (_itemCountFunc != null)
+            {
+                newDataCount = _itemCountFunc();
+            }
+
+            var keepOldItems = (_willUpdateData & 2) == 0;
+
+            if (newDataCount != _managedItems.Count)
+            {
+                if (_managedItems.Count < newDataCount)
+                {
+                    if (!keepOldItems)
+                    {
+                        foreach (var itemWithRect in _managedItems)
+                        {
+                            itemWithRect.rectDirty = true;
+                        }
+                    }
+
+                    while (_managedItems.Count < newDataCount)
+                    {
+                        _managedItems.Add(new ScrollItemWithRect());
+                    }
+                }
+                else
+                {
+                    for (int i = 0, count = _managedItems.Count; i < count; ++i)
+                    {
+                        if (i < newDataCount)
+                        {
+                            if (!keepOldItems)
+                            {
+                                _managedItems[i].rectDirty = true;
+                            }
+
+                            if (i == newDataCount - 1)
+                            {
+                                _managedItems[i].rectDirty = true;
+                            }
+                        }
+
+                        if (i < newDataCount) continue;
+                        _managedItems[i].rectDirty = true;
+                        if (_managedItems[i].item == null) continue;
+                        RecycleOldItem(_managedItems[i].item);
+                        _managedItems[i].item = null;
+                    }
+                }
+            }
+            else
+            {
+                if (!keepOldItems)
+                {
+                    for (int i = 0, count = _managedItems.Count; i < count; ++i)
+                    {
+                        _managedItems[i].rectDirty = true;
+                    }
+                }
+            }
+
+            _dataCount = newDataCount;
+        }
+
+        private void ResetCriticalItems()
+        {
+            int firstIndex = -1, lastIndex = -1;
+
+            for (var i = 0; i < _dataCount; i++)
+            {
+                var hasItem = _managedItems[i].item != null;
+                var shouldShow = ShouldItemSeenAtIndex(i);
+
+                if (shouldShow)
+                {
+                    if (firstIndex == -1)
+                    {
+                        firstIndex = i;
+                    }
+
+                    lastIndex = i;
+                }
+
+                if (hasItem && shouldShow)
+                {
+                    SetDataForItemAtIndex(_managedItems[i].item, i);
+                    continue;
+                }
+
+                if (hasItem == shouldShow)
+                {
+                    continue;
+                }
+
+                if (hasItem)
+                {
+                    RecycleOldItem(_managedItems[i].item);
+                    _managedItems[i].item = null;
+                    continue;
+                }
+
+                RectTransform item = GetNewItem(i);
+                OnGetItemForDataIndex(item, i);
+                _managedItems[i].item = item;
+            }
+
+            _criticalItemIndex[CriticalItemType.UpToHide] = firstIndex;
+            _criticalItemIndex[CriticalItemType.DownToHide] = lastIndex;
+            _criticalItemIndex[CriticalItemType.UpToShow] = Mathf.Max(firstIndex - 1, 0);
+            _criticalItemIndex[CriticalItemType.DownToShow] = Mathf.Min(lastIndex + 1, _dataCount - 1);
+        }
+
+        private RectTransform GetCriticalItem(int type)
+        {
+            var index = _criticalItemIndex[type];
+            if (index >= 0 && index < _dataCount)
+            {
+                return _managedItems[index].item;
+            }
+
+            return null;
+        }
+
+        private void UpdateCriticalItems()
+        {
+            var dirty = true;
+
+            while (dirty)
+            {
+                dirty = false;
+
+                for (int i = CriticalItemType.UpToHide; i <= CriticalItemType.DownToShow; i++)
+                {
+                    if (i <= CriticalItemType.DownToHide)
+                    {
+                        dirty = dirty || CheckAndHideItem(i);
+                    }
+                    else
+                    {
+                        dirty = dirty || CheckAndShowItem(i);
+                    }
+                }
+            }
+        }
+
+        private bool CheckAndHideItem(int criticalItemType)
+        {
+            RectTransform item = GetCriticalItem(criticalItemType);
+            var criticalIndex = _criticalItemIndex[criticalItemType];
+            if (item == null || ShouldItemSeenAtIndex(criticalIndex)) return false;
+            RecycleOldItem(item);
+            _managedItems[criticalIndex].item = null;
+
+            if (criticalItemType == CriticalItemType.UpToHide)
+            {
+                _criticalItemIndex[criticalItemType + 2] = Mathf.Max(criticalIndex, _criticalItemIndex[criticalItemType + 2]);
+                _criticalItemIndex[criticalItemType]++;
+            }
+            else
+            {
+                _criticalItemIndex[criticalItemType + 2] = Mathf.Min(criticalIndex, _criticalItemIndex[criticalItemType + 2]);
+                _criticalItemIndex[criticalItemType]--;
+            }
+
+            _criticalItemIndex[criticalItemType] = Mathf.Clamp(_criticalItemIndex[criticalItemType], 0, _dataCount - 1);
+
+            if (_criticalItemIndex[CriticalItemType.UpToHide] <=
+                _criticalItemIndex[CriticalItemType.DownToHide]) return true;
+            ResetCriticalItems();
+            return false;
+
+        }
+
+        private bool CheckAndShowItem(int criticalItemType)
+        {
+            RectTransform item = GetCriticalItem(criticalItemType);
+            var criticalIndex = _criticalItemIndex[criticalItemType];
+
+            if (item != null || !ShouldItemSeenAtIndex(criticalIndex)) return false;
+            RectTransform newItem = GetNewItem(criticalIndex);
+            OnGetItemForDataIndex(newItem, criticalIndex);
+            _managedItems[criticalIndex].item = newItem;
+
+            if (criticalItemType == CriticalItemType.UpToShow)
+            {
+                _criticalItemIndex[criticalItemType - 2] = Mathf.Min(criticalIndex, _criticalItemIndex[criticalItemType - 2]);
+                _criticalItemIndex[criticalItemType]--;
+            }
+            else
+            {
+                _criticalItemIndex[criticalItemType - 2] = Mathf.Max(criticalIndex, _criticalItemIndex[criticalItemType - 2]);
+                _criticalItemIndex[criticalItemType]++;
+            }
+
+            _criticalItemIndex[criticalItemType] = Mathf.Clamp(_criticalItemIndex[criticalItemType], 0, _dataCount - 1);
+
+            if (_criticalItemIndex[CriticalItemType.UpToShow] <
+                _criticalItemIndex[CriticalItemType.DownToShow]) return true;
+            ResetCriticalItems();
+            return false;
+
+        }
+
+        private bool ShouldItemSeenAtIndex(int index)
+        {
+            if (index < 0 || index >= _dataCount)
+            {
+                return false;
+            }
+
+            EnsureItemRect(index);
+            return new Rect(_refRect.position - content.anchoredPosition, _refRect.size).Overlaps(_managedItems[index].rect);
+        }
+
+        private bool ShouldItemFullySeenAtIndex(int index)
+        {
+            if (index < 0 || index >= _dataCount)
+            {
+                return false;
+            }
+
+            EnsureItemRect(index);
+            return IsRectContains(new Rect(_refRect.position - content.anchoredPosition, _refRect.size), _managedItems[index].rect);
+        }
+
+        private bool IsRectContains(Rect outRect, Rect inRect, bool bothDimensions = false)
+        {
+            if (bothDimensions)
+            {
+                var xContains = (outRect.xMax >= inRect.xMax) && (outRect.xMin <= inRect.xMin);
+                var yContains = (outRect.yMax >= inRect.yMax) && (outRect.yMin <= inRect.yMin);
+                return xContains && yContains;
+            }
+            else
+            {
+                var dir = (int)layoutType & FLAG_SCROLL_DIRECTION;
+                if (dir == 1)
+                {
+                    return (outRect.yMax >= inRect.yMax) && (outRect.yMin <= inRect.yMin);
+                }
+                else
+                {
+                    return (outRect.xMax >= inRect.xMax) && (outRect.xMin <= inRect.xMin);
+                }
+            }
+        }
+        private void OnGetItemForDataIndex(RectTransform item, int index)
+        {
+            SetDataForItemAtIndex(item, index);
+            item.transform.SetParent(content, false);
+        }
+
+        private void SetDataForItemAtIndex(RectTransform item, int index)
+        {
+            if (_updateFunc != null)
+            {
+                _updateFunc(index, item);
+            }
+
+            SetPosForItemAtIndex(item, index);
+        }
+
+        private void SetPosForItemAtIndex(RectTransform item, int index)
+        {
+            EnsureItemRect(index);
+            Rect r = _managedItems[index].rect;
+            item.localPosition = r.position;
+            item.sizeDelta = r.size;
+        }
+
+        private Vector2 GetItemSize(int index)
+        {
+            if (index < 0 || index > _dataCount) return defaultItemSize;
+            return _itemSizeFunc?.Invoke(index) ?? defaultItemSize;
+        }
+
+        private RectTransform GetNewItem(int index)
+        {
+            var item = _itemGetFunc != null ? _itemGetFunc(index) : itemTemplate.Spawn();
+            item.anchorMin = Vector2.up;
+            item.anchorMax = Vector2.up;
+            item.pivot = Vector2.zero;
+            return item;
+        }
+
+        private void RecycleOldItem(RectTransform item)
+        {
+            if (_itemRecycleFunc != null)
+            {
+                _itemRecycleFunc(item);
+            }
+            else
+            {
+                item.Recycle();
+            }
+        }
+
+        private void InitScrollView()
+        {
+            _initialized = true;
+            var dir = (int)layoutType & FLAG_SCROLL_DIRECTION;
+            vertical = dir == 1;
+            horizontal = dir == 0;
+
+            content.pivot = Vector2.up;
+            content.anchorMin = Vector2.up;
+            content.anchorMax = Vector2.up;
+            content.anchoredPosition = Vector2.zero;
+
+            UpdateRefRect();
+        }
+
+        private void UpdateRefRect()
+        {
+            /*
+             *  WorldCorners
+             *
+             *    1 ------- 2
+             *    |         |
+             *    |         |
+             *    0 ------- 3
+             *
+             */
+
+            if (!CanvasUpdateRegistry.IsRebuildingLayout())
+            {
+                Canvas.ForceUpdateCanvases();
+            }
+
+            viewRect.GetWorldCorners(_viewWorldCorners);
+            _rectCorners[0] = content.transform.InverseTransformPoint(_viewWorldCorners[0]);
+            _rectCorners[1] = content.transform.InverseTransformPoint(_viewWorldCorners[2]);
+            _refRect = new Rect((Vector2)_rectCorners[0] - content.anchoredPosition, _rectCorners[1] - _rectCorners[0]);
+        }
+
+        private void MovePos(ref Vector2 pos, Vector2 size)
+        {
+            switch (layoutType)
+            {
+                case ItemLayoutType.Vertical:
+                    pos.y -= size.y;
+                    break;
+                case ItemLayoutType.Horizontal:
+                    pos.x += size.x;
+                    break;
+                case ItemLayoutType.VerticalThenHorizontal:
+                    pos.y -= size.y;
+                    if (pos.y - size.y < -_refRect.height)
+                    {
+                        pos.y = 0;
+                        pos.x += size.x;
+                    }
+
+                    break;
+                case ItemLayoutType.HorizontalThenVertical:
+
+                    pos.x += size.x;
+                    if (pos.x + size.x > _refRect.width)
+                    {
+                        pos.x = 0;
+                        pos.y -= size.y;
+                    }
+                    break;
+            }
+        }
+        
+        private static class CriticalItemType
+        {
+            public const byte UpToHide = 0;
+            public const byte DownToHide = 1;
+            public const byte UpToShow = 2;
+            public const byte DownToShow = 3;
+        }
+
+        private class ScrollItemWithRect
+        {
+            public RectTransform item;
+            public Rect rect;
+            public bool rectDirty = true;
+        }
+    }
+}

package/Runtime/UI/ScrollView/GDKScrollView.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2d355eec575560046ba27246695b84ad
+timeCreated: 1533042733
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: