unityscrollview生成大量_unity3d-关于Unity ScrollRect / ScrollView优化/性能...

一：

.GetComponent<>()调用效率低下,尤其是在编辑器外部.避免在任何类型的Update()方法中使用它们.

二：

拖动ScrollView的每个帧都调用OnValueChanged().因此,从某种意义上讲,它等效于Update(),因此您应该避免在此方法中使用.GetComponent<>()调用.

三：

每当更改Canvas上的任何元素时,整个Canvas都必须重建其批次.此操作可能非常昂贵.因此,建议您将UI元素划分为至少两个Canvas,一个用于很少或永远不会更改的元素,而一个则是经常更改的元素.

每当ScrollView滚动整个画布时,都会弄脏它.因此,建议您将每个ScrollView放在单独的Canvas上.

四：

EventSystem.Update()处理场景中的输入检测,使用射线广播在层次结构中进行过滤,以便找到接受此输入的组件.因此,仅在与场景交互时才进行这些计算,例如在滚动ScrollView时.从图形和文本中删除不必要的RaycastTarget属性将缩短此处理时间.可能并没有太大的区别,但是如果您不注意足够的对象,则可以使输入处理时间真正加起来.

五：

使用任何种类的遮罩组件,甚至是RectMask2D,都可以批处理并渲染ScrollView中的所有对象.如果ScrollView中包含很多元素,建议您使用某种合并解决方案.在应用程序商店中有许多可用的方法.

但是,如果您的项目与此项目不兼容,需要持久性元素,则建议您隐藏屏幕外对象以减少性能开销. Transform.SetParent()和GameObject.SetActive()都是资源密集型方法,而是将CanvasGroup组件附加到每个元素并调整alpha值以实现相同的效果.

这是一个静态脚本,用于检测对象是否可见并相应地设置Alpha：

using UnityEngine;

using UnityEngine.UI;

public class ScrollHider : MonoBehaviour {

static public float contentTop;

static public float contentBottom;

static public bool HideObject(GameObject givenObject, CanvasGroup canvasGroup, float givenPosition, float givenHeight) {

if ((Mathf.Abs(givenPosition) + givenHeight > contentTop && Mathf.Abs(givenPosition) + givenHeight < contentBottom) || (Mathf.Abs(givenPosition) > contentTop && Mathf.Abs(givenPosition) < contentBottom)) {

if (canvasGroup.alpha != 1) {

canvasGroup.alpha = 1;

}

return true;

} else {

if (canvasGroup.alpha != 0) {

canvasGroup.alpha = 0;

}

return false;

}

}

static public void Setup(Scroll givenScroll) {

contentTop = (1 - givenScroll.verticalNormalizedPosition) * (givenScroll.content.rect.height - givenScroll.viewport.rect.height);

contentBottom = contentTop + givenScroll.viewport.rect.height;

}

}

六：

Unity的内置ScrollRect组件可实现广泛的模块化功能.但是,就性能而言,它可能比您自己编写的要慢得多.这是一个达到相同目的的Scroll脚本,但仅支持Unity的ScrollRect的vertical,clamped和惯性属性.

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.Events;

using UnityEngine.EventSystems;

public class Scroll : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IDragHandler, IScrollHandler {

private Camera mainCamera;

private RectTransform canvasRect;

public RectTransform viewport;

public RectTransform content;

private Rect viewportOld;

private Rect contentOld;

private List dragCoordinates = new List();

private List offsets = new List();

private int offsetsAveraged = 4;

private float offset;

private float velocity = 0;

private bool changesMade = false;

public float decelration = 0.135f;

public float scrollSensitivity;

public OnValueChanged onValueChanged;

[System.Serializable]

public class OnValueChanged : UnityEvent { }

[HideInInspector]

public float verticalNormalizedPosition

{

get

{

float sizeDelta = CaculateDeltaSize();

if (sizeDelta == 0) {

return 0;

} else {

return 1 - content.transform.localPosition.y / sizeDelta;

}

}

set

{

float o_verticalNormalizedPosition = verticalNormalizedPosition;

float m_verticalNormalizedPosition = Mathf.Max(0, Mathf.Min(1, value));

float maxY = CaculateDeltaSize();

content.transform.localPosition = new Vector3(content.transform.localPosition.x, Mathf.Max(0, (1 - m_verticalNormalizedPosition) * maxY), content.transform.localPosition.z);

float n_verticalNormalizedPosition = verticalNormalizedPosition;

if (o_verticalNormalizedPosition != n_verticalNormalizedPosition) {

onValueChanged.Invoke();

}

}

}

private float CaculateDeltaSize() {

return Mathf.Max(0, content.rect.height - viewport.rect.height); ;

}

private void Awake() {

mainCamera = GameObject.Find("Main Camera").GetComponent();

canvasRect = transform.root.GetComponent();

}

private Vector2 ConvertEventDataDrag(PointerEventData eventData) {

return new Vector2(eventData.position.x / mainCamera.pixelWidth * canvasRect.rect.width, eventData.position.y / mainCamera.pixelHeight * canvasRect.rect.height);

}

private Vector2 ConvertEventDataScroll(PointerEventData eventData) {

return new Vector2(eventData.scrollDelta.x / mainCamera.pixelWidth * canvasRect.rect.width, eventData.scrollDelta.y / mainCamera.pixelHeight * canvasRect.rect.height) * scrollSensitivity;

}

public void OnPointerDown(PointerEventData eventData) {

velocity = 0;

dragCoordinates.Clear();

offsets.Clear();

dragCoordinates.Add(ConvertEventDataDrag(eventData));

}

public void OnScroll(PointerEventData eventData) {

UpdateOffsetsScroll(ConvertEventDataScroll(eventData));

OffsetContent(offsets[offsets.Count - 1]);

}

public void OnDrag(PointerEventData eventData) {

dragCoordinates.Add(ConvertEventDataDrag(eventData));

UpdateOffsetsDrag();

OffsetContent(offsets[offsets.Count - 1]);

}

public void OnPointerUp(PointerEventData eventData) {

dragCoordinates.Add(ConvertEventDataDrag(eventData));

UpdateOffsetsDrag();

OffsetContent(offsets[offsets.Count - 1]);

float totalOffsets = 0;

foreach (float offset in offsets) {

totalOffsets += offset;

}

velocity = totalOffsets / offsetsAveraged;

dragCoordinates.Clear();

offsets.Clear();

}

private void OffsetContent(float givenOffset) {

float newY = Mathf.Max(0, Mathf.Min(CaculateDeltaSize(), content.transform.localPosition.y + givenOffset));

if (content.transform.localPosition.y != newY) {

content.transform.localPosition = new Vector3(content.transform.localPosition.x, newY, content.transform.localPosition.z);

}

onValueChanged.Invoke();

}

private void UpdateOffsetsDrag() {

offsets.Add(dragCoordinates[dragCoordinates.Count - 1].y - dragCoordinates[dragCoordinates.Count - 2].y);

if (offsets.Count > offsetsAveraged) {

offsets.RemoveAt(0);

}

}

private void UpdateOffsetsScroll(Vector2 givenScrollDelta) {

offsets.Add(givenScrollDelta.y);

if (offsets.Count > offsetsAveraged) {

offsets.RemoveAt(0);

}

}

private void LateUpdate() {

if (viewport.rect != viewportOld) {

changesMade = true;

viewportOld = new Rect(viewport.rect);

}

if (content.rect != contentOld) {

changesMade = true;

contentOld = new Rect(content.rect);

}

if (velocity != 0) {

changesMade = true;

velocity = (velocity / Mathf.Abs(velocity)) * Mathf.FloorToInt(Mathf.Abs(velocity) * (1 - decelration));

offset = velocity;

}

if (changesMade) {

OffsetContent(offset);

changesMade = false;

offset = 0;

}

}

}