效果图：

使用的是UGUI和DOTween

当中比較关键的是循环滑动和层次排序：

1.循环滑动：这里先如果显示五张图片。分别标记为0,1,2,3,4，那么当向左滑动时，序列就变为1,2,3,4,0，这里先保存4的位置，然后从4開始，4的位置和大小向3渐变，3的位置和大小向2渐变。2的位置和大小向1渐变。1的位置和大小向0渐变。0的位置直接变为原来保存的4的位置。

也就是说，当向左滑动时，最左端的那张图片特殊处理，其余的向左推进。当向右滑动时，最右端的那张图片特殊处理，其余的向右推进。

2.层次排序：因为使用的是UGUI。UI的排序跟在Hierarchy的位置有关。假设图片缩放得越小，就觉得它越远离屏幕。因此就越靠前。会被后面的图片遮住。注意的是在缩放动画播放时，localScale是不确定的，因此要直接将当前位置的下一个位置的localScale传入，从而计算图片的"深度"。还有就是使用SetSiblingIndex时要全然确定好全部图片的排序。

using UnityEngine;

using System.Collections.Generic;

using DG.Tweening;

public class ScrollView : MonoBehaviour {

	public int xOffset = 1;//x轴偏移

    public int yOffset = 0;//y轴偏移

	public float scale = 0.8f;//缩放倍数

	public float time = 0.5f;//偏移与缩放动画的播放时间

    private int left;//最左端的编号

    private int right;//最右端的编号

	public int itemAmount = 5;//展示的图片数

	public Vector3 middlePos;//最中间的位置

	public GameObject itemPrefab;

    private GameObject canvas;

    private GameObject[] sortArray;

	private List<GameObject> list = new List<GameObject>();

	private void InstantiateItem(Vector3 pos,float scale)

	{

		GameObject go = Instantiate(itemPrefab) as GameObject;

        go.transform.SetParent(canvas.transform);

        go.transform.localPosition = pos;

		go.transform.localScale *= scale;

        InsertToSortArray(go, go.transform.localScale.x);

		list.Add(go);

	}

	public void Init()

	{

        left = 0;

        right = itemAmount - 1;

        canvas = GameObject.Find("Canvas");

        sortArray = new GameObject[itemAmount];

		int oneSideAmount = (itemAmount - 1) / 2;

		for(int i = oneSideAmount;i >= 1;i--)

		{

			Vector3 pos = middlePos + new Vector3(i * xOffset,i * yOffset,0) * -1;

			InstantiateItem(pos,Mathf.Pow(scale,i));

		}

		InstantiateItem(middlePos,1);

		for(int i = 1;i <= oneSideAmount;i++)

		{

			Vector3 pos = middlePos + new Vector3(i * xOffset,i * yOffset,0);

			InstantiateItem(pos,Mathf.Pow(scale,i));

		}

        Sort();

	}

    /// <summary>

    /// 依据缩放倍数计算深度

    /// </summary>

    /// <param name="scaleNum"></param>

    /// <returns></returns>

    private int CalculateDepth(float scaleNum)

    {

        float num = 0;

        int i = 0;

        while (true)

        {

            num = Mathf.Pow(scale, i);

            if (num != scaleNum) i++;

            else break;

        }

        return i;

    }

    /// <summary>

    /// 插入到排序数组中。数组序号越低。则越远离屏幕

    /// </summary>

    /// <param name="go"></param>

    /// <param name="localScaleX"></param>

    private void InsertToSortArray(GameObject go, float localScaleX)

    {

        int depth = CalculateDepth(localScaleX);

        depth = itemAmount / 2 - depth;

        if (depth == itemAmount / 2)

            sortArray[depth * 2] = go;

        else if (sortArray[depth] == null)

            sortArray[depth] = go;

        else

            sortArray[depth + itemAmount / 2] = go;

    }

	private void Sort()

	{

        for (int i = 0; i < itemAmount; i++)

        {

            sortArray[i].transform.SetSiblingIndex(i);

        }

        sortArray = new GameObject[itemAmount];

	}

	public void Move(int direction)

	{

		if(direction == -1)//向左滑动

		{

			int startIndex = left;

			int lastIndex = right;

            Vector3 lastPos = list[lastIndex].transform.position;

            InsertToSortArray(list[startIndex], list[startIndex].transform.localScale.x);

            for (int i = 0; i < itemAmount - 1;i++ )

            {

                int index = (lastIndex - i + itemAmount) % itemAmount;

                int preIndex = (index - 1 + itemAmount) % itemAmount;

                list[index].transform.DOMove(list[preIndex].transform.position,time);

                list[index].transform.DOScale(list[preIndex].transform.localScale,time);

                InsertToSortArray(list[index], list[preIndex].transform.localScale.x);

            }

			list[startIndex].transform.DOMove(lastPos,time);

            left = (left + 1) % itemAmount;

            right = (right + 1) % itemAmount;

		}

        else if (direction == 1)//向右滑动

		{

            int startIndex = right;

            int lastIndex = left;

            Vector3 lastPos = list[lastIndex].transform.position;

            InsertToSortArray(list[startIndex], list[startIndex].transform.localScale.x);

            for (int i = 0; i < itemAmount - 1; i++)

            {

                int index = (lastIndex + i + itemAmount) % itemAmount;

                int preIndex = (index + 1 + itemAmount) % itemAmount;

                list[index].transform.DOMove(list[preIndex].transform.position, time);

                list[index].transform.DOScale(list[preIndex].transform.localScale, time);

                InsertToSortArray(list[index], list[preIndex].transform.localScale.x);

            }

            list[startIndex].transform.DOMove(lastPos, time);

            left = (left - 1 + itemAmount) % itemAmount;

            right = (right - 1 + itemAmount) % itemAmount;

		}

		Sort();

	}

}

不足之处：

1.仅仅适用于展示图片数为奇数的场合

2.等等...