/// Credit Beka Westberg
/// Sourced from - https://bitbucket.org/UnityUIExtensions/unity-ui-extensions/pull-requests/28
/// Updated by SimonDarksideJ - Added some exception management and a SetNewItems to replace the content programmatically
using System.Collections;
using System.Collections.Generic;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using System;
namespace UnityEngine.UI.Extensions
{
[ExecuteInEditMode]
[RequireComponent(typeof(ScrollRect))]
[AddComponentMenu("UI/Extensions/ContentSnapScrollHorizontal")]
public class ContentScrollSnapHorizontal : MonoBehaviour, IBeginDragHandler, IEndDragHandler
{
[Serializable]
public class StartMovementEvent : UnityEvent { }
[Serializable]
public class CurrentItemChangeEvent : UnityEvent<int> { }
[Serializable]
public class FoundItemToSnapToEvent : UnityEvent<int> { }
[Serializable]
public class SnappedToItemEvent : UnityEvent<int> { }
public bool ignoreInactiveItems = true;
public MoveInfo startInfo = new MoveInfo(MoveInfo.IndexType.positionIndex, 0);
public GameObject prevButton;
public GameObject nextButton;
public GameObject pagination;
[Tooltip("The velocity below which the scroll rect will start to snap")]
public int snappingVelocityThreshold = 50;
[Header("Paging Info")]
[Tooltip("Should the pagination & buttons jump or lerp to the items")]
public bool jumpToItem = false;
[Tooltip("The time it will take for the pagination or buttons to move between items")]
public float lerpTime = .3f;
[Header("Events")]
[SerializeField]
[Tooltip("Event is triggered whenever the scroll rect starts to move, even when triggered programmatically")]
private StartMovementEvent m_StartMovementEvent = new StartMovementEvent();
public StartMovementEvent MovementStarted
{
get
{
return m_StartMovementEvent;
}
set
{
m_StartMovementEvent = value;
}
}
[SerializeField]
[Tooltip("Event is triggered whenever the closest item to the center of the scrollrect changes")]
private CurrentItemChangeEvent m_CurrentItemChangeEvent = new CurrentItemChangeEvent();
public CurrentItemChangeEvent CurrentItemChanged
{
get
{
return m_CurrentItemChangeEvent;
}
set
{
m_CurrentItemChangeEvent = value;
}
}
[SerializeField]
[Tooltip("Event is triggered when the ContentSnapScroll decides which item it is going to snap to. Returns the index of the closest position.")]
private FoundItemToSnapToEvent m_FoundItemToSnapToEvent = new FoundItemToSnapToEvent();
public FoundItemToSnapToEvent ItemFoundToSnap
{
get
{
return m_FoundItemToSnapToEvent;
}
set
{
m_FoundItemToSnapToEvent = value;
}
}
[SerializeField]
[Tooltip("Event is triggered when we finally settle on an element. Returns the index of the item's position.")]
private SnappedToItemEvent m_SnappedToItemEvent = new SnappedToItemEvent();
public SnappedToItemEvent ItemSnappedTo
{
get
{
return m_SnappedToItemEvent;
}
set
{
m_SnappedToItemEvent = value;
}
}
private ScrollRect scrollRect = null;
private RectTransform scrollRectTransform = null;
private RectTransform contentTransform = null;
private List<Vector3> contentPositions = new List<Vector3>();
private Vector3 lerpTarget = Vector3.zero;
private float totalScrollableWidth = 0;
private DrivenRectTransformTracker tracker ;
private float mLerpTime = 0;
private int _closestItem = 0;
private bool mSliding = false;
private bool mLerping = false;
private bool ContentIsHorizonalLayoutGroup
{
get
{
return contentTransform.GetComponent<HorizontalLayoutGroup>() != null;
}
}
#region Public Info
/// <summary>
/// Returns if the SnapScroll is moving
/// </summary>
public bool Moving
{
get
{
return Sliding || Lerping;
}
}
/// <summary>
/// Returns if the SnapScroll is moving because of a touch
/// </summary>
public bool Sliding
{
get
{
return mSliding;
}
}
/// <summary>
/// Returns if the SnapScroll is moving programmatically
/// </summary>
public bool Lerping
{
get
{
return mLerping;
}
}
/// <summary>
/// Returns the closest item's index
/// *Note this is zero based, and based on position not child order
/// </summary>
public int ClosestItemIndex
{
get
{
return contentPositions.IndexOf(FindClosestFrom(contentTransform.localPosition));
}
}
/// <summary>
/// Returns the lerpTarget's index
/// *Note this is zero-based, and based on position not child order
/// </summary>
public int LerpTargetIndex
{
get
{
return contentPositions.IndexOf(lerpTarget);
}
}
#endregion
#region Setup
private void Awake()
{
scrollRect = GetComponent<ScrollRect>();
scrollRectTransform = (RectTransform) scrollRect.transform;
contentTransform = scrollRect.content;
if (nextButton)
nextButton.GetComponent<Button>().onClick.AddListener(() => { NextItem(); });
if (prevButton)
prevButton.GetComponent<Button>().onClick.AddListener(() => { PreviousItem(); });
if (IsScrollRectAvailable)
{
SetupDrivenTransforms();
SetupSnapScroll();
scrollRect.horizontalNormalizedPosition = 0;
_closestItem = 0;
GoTo(startInfo);
}
}
public void SetNewItems(ref List<Transform> newItems)
{
if (scrollRect && contentTransform)
{
for (int i = scrollRect.content.childCount - 1; i >= 0; i--)
{
Transform child = contentTransform.GetChild(i);
child.SetParent(null);
GameObject.DestroyImmediate(child.gameObject);
}
foreach (Transform item in newItems)
{
GameObject newItem = item.gameObject;
if (newItem.IsPrefab())
{
newItem = Instantiate(item.gameObject, contentTransform);
}
else
{
newItem.transform.SetParent(contentTransform);
}
}
SetupDrivenTransforms();
SetupSnapScroll();
scrollRect.horizontalNormalizedPosition = 0;
_closestItem = 0;
GoTo(startInfo);
}
}
private bool IsScrollRectAvailable
{
get
{
if (scrollRect &&
contentTransform &&
contentTransform.childCount > 0)
{
return true;
}
return false;
}
}
private void OnDisable()
{
tracker.Clear();
}
private void SetupDrivenTransforms()
{
tracker = new DrivenRectTransformTracker();
tracker.Clear();
//So that we can calculate everything correctly
foreach (RectTransform child in contentTransform)
{
tracker.Add(this, child, DrivenTransformProperties.Anchors);
child.anchorMax = new Vector2(0, 1);
child.anchorMin = new Vector2(0, 1);
}
}
private void SetupSnapScroll()
{
if (ContentIsHorizonalLayoutGroup)
{
//because you can't get the anchored positions of UI elements
//when they are in a layout group (as far as I could tell)
SetupWithHorizontalLayoutGroup();
}
else
{
SetupWithCalculatedSpacing();
}
}
private void SetupWithHorizontalLayoutGroup()
{
HorizontalLayoutGroup horizLayoutGroup = contentTransform.GetComponent<HorizontalLayoutGroup>();
float childTotalWidths = 0;
int activeChildren = 0;
for (int i = 0; i < contentTransform.childCount; i++)
{
if (!ignoreInactiveItems || contentTransform.GetChild(i).gameObject.activeInHierarchy)
{
childTotalWidths += ((RectTransform)contentTransform.GetChild(i)).sizeDelta.x;
activeChildren++;
}
}
float spacingTotal = (activeChildren - 1) * horizLayoutGroup.spacing;
float totalWidth = childTotalWidths + spacingTotal + horizLayoutGroup.padding.left + horizLayoutGroup.padding.right;
contentTransform.sizeDelta = new Vector2(totalWidth, contentTransform.sizeDelta.y);
float scrollRectWidth = Mathf.Min(((RectTransform)contentTransform.GetChild(0)).sizeDelta.x, ((RectTransform)contentTransform.GetChild(contentTransform.childCount - 1)).sizeDelta.x);
/*---If the scroll view is set to stretch width this breaks stuff---*/
scrollRectTransform.sizeDelta = new Vector2(scrollRectWidth, scrollRectTransform.sizeDelta.y);
contentPositions = new List<Vector3>();
float widthOfScrollRect = scrollRectTransform.sizeDelta.x;
totalScrollableWidth = totalWidth - widthOfScrollRect;
float checkedChildrenTotalWidths = horizLayoutGroup.padding.left;
int activeChildrenBeforeSelf = 0;
for (int i = 0; i < contentTransform.childCount; i++)
{
if (!ignoreInactiveItems || contentTransform.GetChild(i).gameObject.activeInHierarchy)
{
float widthOfSelf = ((RectTransform)contentTransform.GetChild(i)).sizeDelta.x;
float offset = checkedChildrenTotalWidths + (horizLayoutGroup.spacing * activeChildrenBeforeSelf) + ((widthOfSelf - widthOfScrollRect) / 2);
scrollRect.horizontalNormalizedPosition = offset / totalScrollableWidth;
contentPositions.Add(contentTransform.localPosition);
checkedChildrenTotalWidths += widthOfSelf;
activeChildrenBeforeSelf++;
}
}
}
private void SetupWithCalculatedSpacing()
{
//we need them in order from left to right for pagination & buttons & our scrollRectWidth
List<RectTransform> childrenFromLeftToRight = new List<RectTransform>();
for (int i = 0; i < contentTransform.childCount; i++)
{
if (!ignoreInactiveItems || contentTransform.GetChild(i).gameObject.activeInHierarchy)
{
RectTransform childBeingSorted = ((RectTransform)contentTransform.GetChild(i));
int insertIndex = childrenFromLeftToRight.Count;
for (int j = 0; j < childrenFromLeftToRight.Count; j++)
{
if (DstFromTopLeftOfTransformToTopLeftOfParent(childBeingSorted).x < DstFromTopLeftOfTransformToTopLeftOfParent(childrenFromLeftToRight[j]).x)
{
insertIndex = j;
break;
}
}
childrenFromLeftToRight.Insert(insertIndex, childBeingSorted);
}
}
RectTransform childFurthestToTheRight = childrenFromLeftToRight[childrenFromLeftToRight.Count - 1];
float totalWidth = DstFromTopLeftOfTransformToTopLeftOfParent(childFurthestToTheRight).x + childFurthestToTheRight.sizeDelta.x;
contentTransform.sizeDelta = new Vector2(totalWidth, contentTransform.sizeDelta.y);
float scrollRectWidth = Mathf.Min(childrenFromLeftToRight[0].sizeDelta.x, childrenFromLeftToRight[childrenFromLeftToRight.Count - 1].sizeDelta.x);
// Note: sizeDelta will not be calculated properly if the scroll view is set to stretch width.
scrollRectTransform.sizeDelta = new Vector2(scrollRectWidth, scrollRectTransform.sizeDelta.y);
contentPositions = new List<Vector3>();
float widthOfScrollRect = scrollRectTransform.sizeDelta.x;
totalScrollableWidth = totalWidth - widthOfScrollRect;
for (int i = 0; i < childrenFromLeftToRight.Count; i++)
{
float offset = DstFromTopLeftOfTransformToTopLeftOfParent(childrenFromLeftToRight[i]).x + ((childrenFromLeftToRight[i].sizeDelta.x - widthOfScrollRect) / 2);
scrollRect.horizontalNormalizedPosition = offset / totalScrollableWidth;
contentPositions.Add(contentTransform.localPosition);
}
}
#endregion
#region Public Movement Functions
/// <summary>
/// Function for going to a specific screen.
/// *Note the index is based on a zero-starting index.
/// </summary>
/// <param name="info">All of the info about how you want it to move</param>
public void GoTo(MoveInfo info)
{
if (!Moving && info.index != ClosestItemIndex)
{
MovementStarted.Invoke();
}
if (info.indexType == MoveInfo.IndexType.childIndex)
{
mLerpTime = info.duration;
GoToChild(info.index, info.jump);
}
else if (info.indexType == MoveInfo.IndexType.positionIndex)
{
mLerpTime = info.duration;
GoToContentPos(info.index, info.jump);
}
}
private void GoToChild(int index, bool jump)
{
int clampedIndex = Mathf.Clamp(index, 0, contentPositions.Count - 1); //contentPositions amount == the amount of available children
if (ContentIsHorizonalLayoutGroup) //the contentPositions are in child order
{
lerpTarget = contentPositions[clampedIndex];
if (jump)
{
contentTransform.localPosition = lerpTarget;
}
else
{
StopMovement();
StartCoroutine("LerpToContent");
}
}
else //the contentPositions are in order from left -> right;
{
int availableChildIndex = 0; //an available child is one we can snap to
Vector3 previousContentTransformPos = contentTransform.localPosition;
for (int i = 0; i < contentTransform.childCount; i++)
{
if (!ignoreInactiveItems || contentTransform.GetChild(i).gameObject.activeInHierarchy)
{
if (availableChildIndex == clampedIndex)
{
RectTransform startChild = (RectTransform) contentTransform.GetChild(i);
float offset = DstFromTopLeftOfTransformToTopLeftOfParent(startChild).x + ((startChild.sizeDelta.x - scrollRectTransform.sizeDelta.x) / 2);
scrollRect.horizontalNormalizedPosition = offset / totalScrollableWidth;
lerpTarget = contentTransform.localPosition;
if (!jump)
{
contentTransform.localPosition = previousContentTransformPos;
StopMovement();
StartCoroutine("LerpToContent");
}
return;
}
availableChildIndex++;
}
}
}
}
private void GoToContentPos(int index, bool jump)
{
int clampedIndex = Mathf.Clamp(index, 0, contentPositions.Count - 1); //contentPositions amount == the amount of available children
//the content positions are all in order from left -> right
//which is what we want so there's no need to check
lerpTarget = contentPositions[clampedIndex];
if (jump)
{
contentTransform.localPosition = lerpTarget;
}
else
{
StopMovement();
StartCoroutine("LerpToContent");
}
}
/// <summary>
/// Function for going to the next item
/// *Note the next item is the item to the right of the current item, this is not based on child order
/// </summary>
public void NextItem()
{
int index;
if (Sliding)
{
index = ClosestItemIndex + 1;
}
else
{
index = LerpTargetIndex + 1;
}
MoveInfo info = new MoveInfo(MoveInfo.IndexType.positionIndex, index, jumpToItem, lerpTime);
GoTo(info);
}
/// <summary>
/// Function for going to the previous item
/// *Note the next item is the item to the left of the current item, this is not based on child order
/// </summary>
public void PreviousItem()
{
int index;
if (Sliding)
{
index = ClosestItemIndex - 1;
}
else
{
index = LerpTargetIndex - 1;
}
MoveInfo info = new MoveInfo(MoveInfo.IndexType.positionIndex, index, jumpToItem, lerpTime);
GoTo(info);
}
/// <summary>
/// Function for recalculating the size of the content & the snap positions, such as when you remove or add a child
/// </summary>
public void UpdateLayout()
{
SetupDrivenTransforms();
SetupSnapScroll();
}
/// <summary>
/// Recalculates the size of the content & snap positions, and moves to a new item afterwards.
/// </summary>
/// <param name="info">All of the info about how you want it to move</param>
public void UpdateLayoutAndMoveTo(MoveInfo info)
{
SetupDrivenTransforms();
SetupSnapScroll();
GoTo(info);
}
#endregion
#region Behind the Scenes Movement stuff
public void OnBeginDrag(PointerEventData ped)
{
if (contentPositions.Count < 2)
{
return;
}
StopMovement();
if (!Moving)
{
MovementStarted.Invoke();
}
}
public void OnEndDrag(PointerEventData ped)
{
if (contentPositions.Count <= 1)
{
return;
}
if (IsScrollRectAvailable)
{
StartCoroutine("SlideAndLerp");
}
}
private void Update()
{
if (IsScrollRectAvailable)
{
if (_closestItem != ClosestItemIndex)
{
CurrentItemChanged.Invoke(ClosestItemIndex);
ChangePaginationInfo(ClosestItemIndex);
_closestItem = ClosestItemIndex;
}
}
}
private IEnumerator SlideAndLerp()
{
mSliding = true;
while (Mathf.Abs(scrollRect.velocity.x) > snappingVelocityThreshold)
{
yield return null;
}
lerpTarget = FindClosestFrom(contentTransform.localPosition);
ItemFoundToSnap.Invoke(LerpTargetIndex);
while (Vector3.Distance(contentTransform.localPosition, lerpTarget) > 1)
{
contentTransform.localPosition = Vector3.Lerp(scrollRect.content.localPosition, lerpTarget, 7.5f * Time.deltaTime);
yield return null;
}
mSliding = false;
scrollRect.velocity = Vector2.zero;
contentTransform.localPosition = lerpTarget;
ItemSnappedTo.Invoke(LerpTargetIndex);
}
private IEnumerator LerpToContent()
{
ItemFoundToSnap.Invoke(LerpTargetIndex);
mLerping = true;
Vector3 originalContentPos = contentTransform.localPosition;
float elapsedTime = 0;
while (elapsedTime < mLerpTime)
{
elapsedTime += Time.deltaTime;
contentTransform.localPosition = Vector3.Lerp(originalContentPos, lerpTarget, (elapsedTime / mLerpTime));
yield return null;
}
ItemSnappedTo.Invoke(LerpTargetIndex);
mLerping = false;
}
#endregion
private void StopMovement()
{
scrollRect.velocity = Vector2.zero;
StopCoroutine("SlideAndLerp");
StopCoroutine("LerpToContent");
}
private void ChangePaginationInfo(int targetScreen)
{
if (pagination)
for (int i = 0; i < pagination.transform.childCount; i++)
{
pagination.transform.GetChild(i).GetComponent<Toggle>().isOn = (targetScreen == i);
}
}
private Vector2 DstFromTopLeftOfTransformToTopLeftOfParent(RectTransform rt)
{
//gets rid of any pivot weirdness
return new Vector2(rt.anchoredPosition.x - (rt.sizeDelta.x * rt.pivot.x), rt.anchoredPosition.y + (rt.sizeDelta.y * (1 - rt.pivot.y)));
}
private Vector3 FindClosestFrom(Vector3 start)
{
Vector3 closest = Vector3.zero;
float distance = Mathf.Infinity;
foreach (Vector3 position in contentPositions)
{
if (Vector3.Distance(start, position) < distance)
{
distance = Vector3.Distance(start, position);
closest = position;
}
}
return closest;
}
[System.Serializable]
public struct MoveInfo
{
public enum IndexType { childIndex, positionIndex }
[Tooltip("Child Index means the Index corresponds to the content item at that index in the hierarchy.\n" +
"Position Index means the Index corresponds to the content item in that snap position.\n" +
"A higher Position Index in a Horizontal Scroll Snap means it would be further to the right.")]
public IndexType indexType;
[Tooltip("Zero based")]
public int index;
[Tooltip("If this is true the snap scroll will jump to the index, otherwise it will lerp there.")]
public bool jump;
[Tooltip("If jump is false this is the time it will take to lerp to the index")]
public float duration;
/// <summary>
/// Creates a MoveInfo that jumps to the index
/// </summary>
/// <param name="_indexType">Whether you want to get the child at the index or the snap position at the index</param>
/// <param name="_index">Where you want it to jump</param>
public MoveInfo(IndexType _indexType, int _index)
{
indexType = _indexType;
index = _index;
jump = true;
duration = 0;
}
/// <summary>
/// Creates a MoveInfo
/// </summary>
/// <param name="_indexType">Whether you want to get the child at the index or the snap position at the index</param>
/// <param name="_index">Where you want it to jump</param>
/// <param name="_jump">Whether you want it to jump or lerp to the index</param>
/// <param name="_duration">How long it takes to lerp to the index</param>
public MoveInfo(IndexType _indexType, int _index, bool _jump, float _duration)
{
indexType = _indexType;
index = _index;
jump = _jump;
duration = _duration;
}
}
}
}