AlphaaeGameStudio/TEngine
1
0
Fork 0
mirror of https://github.com/Alex-Rachel/TEngine.git synced 2025-08-14 16:51:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

[+] UI循环列表拓展与示例

Browse Source 
[+] UI循环列表拓展与示例
This commit is contained in:
ALEXTANG
2023-08-10 23:25:43 +08:00
parent ea9447d0ea
commit 53f0ecb6c1
22 changed files with 4700 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: f0e67891bd0f0c7449b345c622ed6b0e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

84
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/ClickEventListener.cs Normal file
View File

@@ -0,0 +1,84 @@
using UnityEngine;
using UnityEngine.EventSystems;
namespace GameLogic
{
public class ClickEventListener : MonoBehaviour, IPointerClickHandler, IPointerDownHandler, IPointerUpHandler
{
public static ClickEventListener Get(GameObject obj)
{
ClickEventListener listener = obj.GetComponent<ClickEventListener>();
if (listener == null)
{
listener = obj.AddComponent<ClickEventListener>();
}
return listener;
}
private System.Action<GameObject> _clickedHandler = null;
private System.Action<GameObject> _doubleClickedHandler = null;
private System.Action<GameObject> _onPointerDownHandler = null;
private System.Action<GameObject> _onPointerUpHandler = null;
bool _isPressed = false;
public bool IsPressed => _isPressed;
public void OnPointerClick(PointerEventData eventData)
{
if (eventData.clickCount == 2)
{
if (_doubleClickedHandler != null)
{
_doubleClickedHandler(gameObject);
}
}
else
{
if (_clickedHandler != null)
{
_clickedHandler(gameObject);
}
}
}
public void SetClickEventHandler(System.Action<GameObject> handler)
{
_clickedHandler = handler;
}
public void SetDoubleClickEventHandler(System.Action<GameObject> handler)
{
_doubleClickedHandler = handler;
}
public void SetPointerDownHandler(System.Action<GameObject> handler)
{
_onPointerDownHandler = handler;
}
public void SetPointerUpHandler(System.Action<GameObject> handler)
{
_onPointerUpHandler = handler;
}
public void OnPointerDown(PointerEventData eventData)
{
_isPressed = true;
if (_onPointerDownHandler != null)
{
_onPointerDownHandler(gameObject);
}
}
public void OnPointerUp(PointerEventData eventData)
{
_isPressed = false;
if (_onPointerUpHandler != null)
{
_onPointerUpHandler(gameObject);
}
}
}
}

11
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/ClickEventListener.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: aa13a2165836fda459a6c28562ac101a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

326
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/ItemPosMgr.cs Normal file
View File

@@ -0,0 +1,326 @@
using System;
using System.Collections.Generic;
namespace GameLogic
{
public class ItemSizeGroup
{
public float[] ItemSizeArray = null;
public float[] ItemStartPosArray = null;
public int ItemCount = 0;
private int _dirtyBeginIndex = ItemPosMgr.ItemMaxCountPerGroup;
public float GroupSize = 0;
public float GroupStartPos = 0;
public float GroupEndPos = 0;
public int GroupIndex = 0;
public float ItemDefaultSize = 0;
public ItemSizeGroup(int index, float itemDefaultSize)
{
GroupIndex = index;
ItemDefaultSize = itemDefaultSize;
Init();
}
public void Init()
{
ItemSizeArray = new float[ItemPosMgr.ItemMaxCountPerGroup];
if (ItemDefaultSize != 0)
{
for (int i = 0; i < ItemSizeArray.Length; ++i)
{
ItemSizeArray[i] = ItemDefaultSize;
}
}
ItemStartPosArray = new float[ItemPosMgr.ItemMaxCountPerGroup];
ItemStartPosArray[0] = 0;
ItemCount = ItemPosMgr.ItemMaxCountPerGroup;
GroupSize = ItemDefaultSize * ItemSizeArray.Length;
if (ItemDefaultSize != 0)
{
_dirtyBeginIndex = 0;
}
else
{
_dirtyBeginIndex = ItemPosMgr.ItemMaxCountPerGroup;
}
}
public float GetItemStartPos(int index)
{
return GroupStartPos + ItemStartPosArray[index];
}
public bool IsDirty
{
get { return (_dirtyBeginIndex < ItemCount); }
}
public float SetItemSize(int index, float size)
{
float old = ItemSizeArray[index];
if (Math.Abs(old - size) < 0.001f)
{
return 0;
}
ItemSizeArray[index] = size;
if (index < _dirtyBeginIndex)
{
_dirtyBeginIndex = index;
}
float ds = size - old;
GroupSize = GroupSize + ds;
return ds;
}
public void SetItemCount(int count)
{
if (ItemCount == count)
{
return;
}
ItemCount = count;
RecalcGroupSize();
}
public void RecalcGroupSize()
{
GroupSize = 0;
for (int i = 0; i < ItemCount; ++i)
{
GroupSize += ItemSizeArray[i];
}
}
public int GetItemIndexByPos(float pos)
{
if (ItemCount == 0)
{
return -1;
}
int low = 0;
int high = ItemCount - 1;
while (low <= high)
{
int mid = (low + high) / 2;
float startPos = ItemStartPosArray[mid];
float endPos = startPos + ItemSizeArray[mid];
if (startPos <= pos && endPos >= pos)
{
return mid;
}
else if (pos > endPos)
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
return -1;
}
public void UpdateAllItemStartPos()
{
if (_dirtyBeginIndex >= ItemCount)
{
return;
}
int startIndex = (_dirtyBeginIndex < 1) ? 1 : _dirtyBeginIndex;
for (int i = startIndex; i < ItemCount; ++i)
{
ItemStartPosArray[i] = ItemStartPosArray[i - 1] + ItemSizeArray[i - 1];
}
_dirtyBeginIndex = ItemCount;
}
}
public class ItemPosMgr
{
public const int ItemMaxCountPerGroup = 100;
readonly List<ItemSizeGroup> _itemSizeGroupList = new List<ItemSizeGroup>();
public int _dirtyBeginIndex = int.MaxValue;
public float TotalSize = 0;
public float ItemDefaultSize = 20;
public ItemPosMgr(float itemDefaultSize)
{
ItemDefaultSize = itemDefaultSize;
}
public void SetItemMaxCount(int maxCount)
{
_dirtyBeginIndex = 0;
TotalSize = 0;
int st = maxCount % ItemMaxCountPerGroup;
int lastGroupItemCount = st;
int needMaxGroupCount = maxCount / ItemMaxCountPerGroup;
if (st > 0)
{
needMaxGroupCount++;
}
else
{
lastGroupItemCount = ItemMaxCountPerGroup;
}
int count = _itemSizeGroupList.Count;
if (count > needMaxGroupCount)
{
int d = count - needMaxGroupCount;
_itemSizeGroupList.RemoveRange(needMaxGroupCount, d);
}
else if (count < needMaxGroupCount)
{
int d = needMaxGroupCount - count;
for (int i = 0; i < d; ++i)
{
ItemSizeGroup tGroup = new ItemSizeGroup(count + i, ItemDefaultSize);
_itemSizeGroupList.Add(tGroup);
}
}
count = _itemSizeGroupList.Count;
if (count == 0)
{
return;
}
for (int i = 0; i < count - 1; ++i)
{
_itemSizeGroupList[i].SetItemCount(ItemMaxCountPerGroup);
}
_itemSizeGroupList[count - 1].SetItemCount(lastGroupItemCount);
for (int i = 0; i < count; ++i)
{
TotalSize = TotalSize + _itemSizeGroupList[i].GroupSize;
}
}
public void SetItemSize(int itemIndex, float size)
{
int groupIndex = itemIndex / ItemMaxCountPerGroup;
int indexInGroup = itemIndex % ItemMaxCountPerGroup;
ItemSizeGroup tGroup = _itemSizeGroupList[groupIndex];
float changedSize = tGroup.SetItemSize(indexInGroup, size);
if (changedSize != 0f)
{
if (groupIndex < _dirtyBeginIndex)
{
_dirtyBeginIndex = groupIndex;
}
}
TotalSize += changedSize;
}
public float GetItemPos(int itemIndex)
{
Update(true);
int groupIndex = itemIndex / ItemMaxCountPerGroup;
int indexInGroup = itemIndex % ItemMaxCountPerGroup;
return _itemSizeGroupList[groupIndex].GetItemStartPos(indexInGroup);
}
public void GetItemIndexAndPosAtGivenPos(float pos, ref int index, ref float itemPos)
{
Update(true);
index = 0;
itemPos = 0f;
int count = _itemSizeGroupList.Count;
if (count == 0)
{
return;
}
ItemSizeGroup hitGroup = null;
int low = 0;
int high = count - 1;
while (low <= high)
{
int mid = (low + high) / 2;
ItemSizeGroup tGroup = _itemSizeGroupList[mid];
if (tGroup.GroupStartPos <= pos && tGroup.GroupEndPos >= pos)
{
hitGroup = tGroup;
break;
}
else if (pos > tGroup.GroupEndPos)
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
int hitIndex = -1;
if (hitGroup != null)
{
hitIndex = hitGroup.GetItemIndexByPos(pos - hitGroup.GroupStartPos);
}
else
{
return;
}
if (hitIndex < 0)
{
return;
}
index = hitIndex + hitGroup.GroupIndex * ItemMaxCountPerGroup;
itemPos = hitGroup.GetItemStartPos(hitIndex);
}
public void Update(bool updateAll)
{
int count = _itemSizeGroupList.Count;
if (count == 0)
{
return;
}
if (_dirtyBeginIndex >= count)
{
return;
}
int loopCount = 0;
for (int i = _dirtyBeginIndex; i < count; ++i)
{
loopCount++;
ItemSizeGroup tGroup = _itemSizeGroupList[i];
_dirtyBeginIndex++;
tGroup.UpdateAllItemStartPos();
if (i == 0)
{
tGroup.GroupStartPos = 0;
tGroup.GroupEndPos = tGroup.GroupSize;
}
else
{
tGroup.GroupStartPos = _itemSizeGroupList[i - 1].GroupEndPos;
tGroup.GroupEndPos = tGroup.GroupStartPos + tGroup.GroupSize;
}
if (!updateAll && loopCount > 1)
{
return;
}
}
}
}
}

11
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/ItemPosMgr.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 61adb6a884bfbfc4292a5d39261a74f2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

3045
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/LoopListView.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/LoopListView.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: dd536d252034dd74b87b436507ec44f7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

216
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/LoopListViewItem.cs Normal file
View File

@@ -0,0 +1,216 @@
using UnityEngine;
namespace GameLogic
{
public class LoopListViewItem : MonoBehaviour
{
public float Padding;
private int _itemIndex = -1;
private int _itemId = -1;
private LoopListView _parentListView = null;
private bool _isInitHandlerCalled = false;
private string _itemPrefabName;
private RectTransform _cachedRectTransform;
private float _padding;
private float _distanceWithViewPortSnapCenter = 0;
private int _itemCreatedCheckFrameCount = 0;
private float _startPosOffset = 0;
private object _userObjectData = null;
private int _userIntData1 = 0;
private int _userIntData2 = 0;
private string _userStringData1 = null;
private string _userStringData2 = null;
private int _goId = 0;
public int GoId
{
set => _goId = value;
get => _goId;
}
public object UserObjectData
{
get => _userObjectData;
set => _userObjectData = value;
}
public int UserIntData1
{
get => _userIntData1;
set => _userIntData1 = value;
}
public int UserIntData2
{
get => _userIntData2;
set => _userIntData2 = value;
}
public string UserStringData1
{
get => _userStringData1;
set => _userStringData1 = value;
}
public string UserStringData2
{
get => _userStringData2;
set => _userStringData2 = value;
}
public float DistanceWithViewPortSnapCenter
{
get => _distanceWithViewPortSnapCenter;
set => _distanceWithViewPortSnapCenter = value;
}
public float StartPosOffset
{
get => _startPosOffset;
set => _startPosOffset = value;
}
public int ItemCreatedCheckFrameCount
{
get => _itemCreatedCheckFrameCount;
set => _itemCreatedCheckFrameCount = value;
}
public RectTransform CachedRectTransform
{
get
{
if (_cachedRectTransform == null)
{
_cachedRectTransform = gameObject.GetComponent<RectTransform>();
}
return _cachedRectTransform;
}
}
public string ItemPrefabName
{
get => _itemPrefabName;
set => _itemPrefabName = value;
}
public int ItemIndex
{
get => _itemIndex;
set => _itemIndex = value;
}
public int ItemId
{
get => _itemId;
set => _itemId = value;
}
public bool IsInitHandlerCalled
{
get => _isInitHandlerCalled;
set => _isInitHandlerCalled = value;
}
public LoopListView ParentListView
{
get => _parentListView;
set => _parentListView = value;
}
public float TopY
{
get
{
ListItemArrangeType arrageType = ParentListView.ArrangeType;
if (arrageType == ListItemArrangeType.TopToBottom)
{
return CachedRectTransform.localPosition.y;
}
else if (arrageType == ListItemArrangeType.BottomToTop)
{
return CachedRectTransform.localPosition.y + CachedRectTransform.rect.height;
}
return 0;
}
}
public float BottomY
{
get
{
ListItemArrangeType arrageType = ParentListView.ArrangeType;
if (arrageType == ListItemArrangeType.TopToBottom)
{
return CachedRectTransform.localPosition.y - CachedRectTransform.rect.height;
}
else if (arrageType == ListItemArrangeType.BottomToTop)
{
return CachedRectTransform.localPosition.y;
}
return 0;
}
}
public float LeftX
{
get
{
ListItemArrangeType arrageType = ParentListView.ArrangeType;
if (arrageType == ListItemArrangeType.LeftToRight)
{
return CachedRectTransform.localPosition.x;
}
else if (arrageType == ListItemArrangeType.RightToLeft)
{
return CachedRectTransform.localPosition.x - CachedRectTransform.rect.width;
}
return 0;
}
}
public float RightX
{
get
{
ListItemArrangeType arrageType = ParentListView.ArrangeType;
if (arrageType == ListItemArrangeType.LeftToRight)
{
return CachedRectTransform.localPosition.x + CachedRectTransform.rect.width;
}
else if (arrageType == ListItemArrangeType.RightToLeft)
{
return CachedRectTransform.localPosition.x;
}
return 0;
}
}
public float ItemSize
{
get
{
if (ParentListView.IsVertList)
{
return CachedRectTransform.rect.height;
}
else
{
return CachedRectTransform.rect.width;
}
}
}
public float ItemSizeWithPadding => ItemSize + _padding;
}
}

11
Assets/GameScripts/HotFix/GameLogic/UI/Common/SuperScrollView/Scripts/LoopListViewItem.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 29af6e9bda3402e4eba67bb72531e618
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: