755 lines
17 KiB
C#
755 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace CurvedUI
|
|
{
|
|
[AddComponentMenu("CurvedUI/CurvedUISettings")]
|
|
[RequireComponent(typeof(Canvas))]
|
|
public class CurvedUISettings : MonoBehaviour
|
|
{
|
|
public enum CurvedUIShape
|
|
{
|
|
CYLINDER = 0,
|
|
RING = 1,
|
|
SPHERE = 2,
|
|
CYLINDER_VERTICAL = 3
|
|
}
|
|
|
|
[SerializeField]
|
|
private CurvedUIShape shape;
|
|
|
|
[SerializeField]
|
|
private float quality = 1f;
|
|
|
|
[SerializeField]
|
|
private bool interactable = true;
|
|
|
|
[SerializeField]
|
|
private bool blocksRaycasts = true;
|
|
|
|
[SerializeField]
|
|
private bool raycastMyLayerOnly = true;
|
|
|
|
[SerializeField]
|
|
private bool forceUseBoxCollider;
|
|
|
|
[SerializeField]
|
|
private int angle = 90;
|
|
|
|
[SerializeField]
|
|
private bool preserveAspect = true;
|
|
|
|
[SerializeField]
|
|
private int vertAngle = 90;
|
|
|
|
[SerializeField]
|
|
private float ringFill = 0.5f;
|
|
|
|
[SerializeField]
|
|
private int ringExternalDiamater = 1000;
|
|
|
|
[SerializeField]
|
|
private bool ringFlipVertical;
|
|
|
|
private int baseCircleSegments = 16;
|
|
|
|
private Vector2 savedRectSize;
|
|
|
|
private float savedRadius;
|
|
|
|
private Canvas myCanvas;
|
|
|
|
private RectTransform m_rectTransform;
|
|
|
|
private RectTransform RectTransform
|
|
{
|
|
get
|
|
{
|
|
if (m_rectTransform == null)
|
|
{
|
|
m_rectTransform = base.transform as RectTransform;
|
|
}
|
|
return m_rectTransform;
|
|
}
|
|
}
|
|
|
|
public int BaseCircleSegments
|
|
{
|
|
get
|
|
{
|
|
return baseCircleSegments;
|
|
}
|
|
}
|
|
|
|
public int Angle
|
|
{
|
|
get
|
|
{
|
|
return angle;
|
|
}
|
|
set
|
|
{
|
|
if (angle != value)
|
|
{
|
|
SetUIAngle(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public float Quality
|
|
{
|
|
get
|
|
{
|
|
return quality;
|
|
}
|
|
set
|
|
{
|
|
if (quality != value)
|
|
{
|
|
quality = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public CurvedUIShape Shape
|
|
{
|
|
get
|
|
{
|
|
return shape;
|
|
}
|
|
set
|
|
{
|
|
if (shape != value)
|
|
{
|
|
shape = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int VerticalAngle
|
|
{
|
|
get
|
|
{
|
|
return vertAngle;
|
|
}
|
|
set
|
|
{
|
|
if (vertAngle != value)
|
|
{
|
|
vertAngle = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public float RingFill
|
|
{
|
|
get
|
|
{
|
|
return ringFill;
|
|
}
|
|
set
|
|
{
|
|
if (ringFill != value)
|
|
{
|
|
ringFill = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public float SavedRadius
|
|
{
|
|
get
|
|
{
|
|
if (savedRadius == 0f)
|
|
{
|
|
savedRadius = GetCyllinderRadiusInCanvasSpace();
|
|
}
|
|
return savedRadius;
|
|
}
|
|
}
|
|
|
|
public int RingExternalDiameter
|
|
{
|
|
get
|
|
{
|
|
return ringExternalDiamater;
|
|
}
|
|
set
|
|
{
|
|
if (ringExternalDiamater != value)
|
|
{
|
|
ringExternalDiamater = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool RingFlipVertical
|
|
{
|
|
get
|
|
{
|
|
return ringFlipVertical;
|
|
}
|
|
set
|
|
{
|
|
if (ringFlipVertical != value)
|
|
{
|
|
ringFlipVertical = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool PreserveAspect
|
|
{
|
|
get
|
|
{
|
|
return preserveAspect;
|
|
}
|
|
set
|
|
{
|
|
if (preserveAspect != value)
|
|
{
|
|
preserveAspect = value;
|
|
SetUIAngle(angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Interactable
|
|
{
|
|
get
|
|
{
|
|
return interactable;
|
|
}
|
|
set
|
|
{
|
|
interactable = value;
|
|
}
|
|
}
|
|
|
|
public bool ForceUseBoxCollider
|
|
{
|
|
get
|
|
{
|
|
return forceUseBoxCollider;
|
|
}
|
|
set
|
|
{
|
|
forceUseBoxCollider = value;
|
|
}
|
|
}
|
|
|
|
public bool BlocksRaycasts
|
|
{
|
|
get
|
|
{
|
|
return blocksRaycasts;
|
|
}
|
|
set
|
|
{
|
|
if (blocksRaycasts != value)
|
|
{
|
|
blocksRaycasts = value;
|
|
if (Application.isPlaying && GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
GetComponent<CurvedUIRaycaster>().RebuildCollider();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool RaycastMyLayerOnly
|
|
{
|
|
get
|
|
{
|
|
return raycastMyLayerOnly;
|
|
}
|
|
set
|
|
{
|
|
raycastMyLayerOnly = value;
|
|
}
|
|
}
|
|
|
|
public bool PointingAtCanvas
|
|
{
|
|
get
|
|
{
|
|
if (GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
return GetComponent<CurvedUIRaycaster>().PointingAtCanvas;
|
|
}
|
|
Debug.LogWarning("CURVEDUI: Can't check if user is pointing at this canvas - No CurvedUIRaycaster is added to this canvas.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public CurvedUIInputModule.CUIControlMethod ControlMethod
|
|
{
|
|
get
|
|
{
|
|
return CurvedUIInputModule.ControlMethod;
|
|
}
|
|
set
|
|
{
|
|
CurvedUIInputModule.ControlMethod = value;
|
|
}
|
|
}
|
|
|
|
public bool GazeUseTimedClick
|
|
{
|
|
get
|
|
{
|
|
return CurvedUIInputModule.Instance.GazeUseTimedClick;
|
|
}
|
|
set
|
|
{
|
|
CurvedUIInputModule.Instance.GazeUseTimedClick = value;
|
|
}
|
|
}
|
|
|
|
public float GazeClickTimer
|
|
{
|
|
get
|
|
{
|
|
return CurvedUIInputModule.Instance.GazeClickTimer;
|
|
}
|
|
set
|
|
{
|
|
CurvedUIInputModule.Instance.GazeClickTimer = value;
|
|
}
|
|
}
|
|
|
|
public float GazeClickTimerDelay
|
|
{
|
|
get
|
|
{
|
|
return CurvedUIInputModule.Instance.GazeClickTimerDelay;
|
|
}
|
|
set
|
|
{
|
|
CurvedUIInputModule.Instance.GazeClickTimerDelay = value;
|
|
}
|
|
}
|
|
|
|
public float GazeTimerProgress
|
|
{
|
|
get
|
|
{
|
|
return CurvedUIInputModule.Instance.GazeTimerProgress;
|
|
}
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (RaycastMyLayerOnly && base.gameObject.layer == 0)
|
|
{
|
|
base.gameObject.layer = 5;
|
|
}
|
|
savedRectSize = RectTransform.rect.size;
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
GraphicRaycaster component = GetComponent<GraphicRaycaster>();
|
|
if (component != null)
|
|
{
|
|
if (!(component is CurvedUIRaycaster))
|
|
{
|
|
UnityEngine.Object.Destroy(component);
|
|
base.gameObject.AddComponent<CurvedUIRaycaster>();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base.gameObject.AddComponent<CurvedUIRaycaster>();
|
|
}
|
|
}
|
|
if (myCanvas == null)
|
|
{
|
|
myCanvas = GetComponent<Canvas>();
|
|
}
|
|
savedRadius = GetCyllinderRadiusInCanvasSpace();
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
Graphic[] componentsInChildren = GetComponentsInChildren<Graphic>();
|
|
foreach (Graphic graphic in componentsInChildren)
|
|
{
|
|
graphic.SetAllDirty();
|
|
}
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
Graphic[] componentsInChildren = GetComponentsInChildren<Graphic>();
|
|
foreach (Graphic graphic in componentsInChildren)
|
|
{
|
|
graphic.SetAllDirty();
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (RectTransform.rect.size != savedRectSize)
|
|
{
|
|
savedRectSize = RectTransform.rect.size;
|
|
SetUIAngle(angle);
|
|
}
|
|
if (savedRectSize.x == 0f || savedRectSize.y == 0f)
|
|
{
|
|
Debug.LogError("CurvedUI: Your Canvas size must be bigger than 0!");
|
|
}
|
|
}
|
|
|
|
private void SetUIAngle(int newAngle)
|
|
{
|
|
if (myCanvas == null)
|
|
{
|
|
myCanvas = GetComponent<Canvas>();
|
|
}
|
|
if (newAngle == 0)
|
|
{
|
|
newAngle = 1;
|
|
}
|
|
angle = newAngle;
|
|
savedRadius = GetCyllinderRadiusInCanvasSpace();
|
|
CurvedUIVertexEffect[] componentsInChildren = GetComponentsInChildren<CurvedUIVertexEffect>();
|
|
foreach (CurvedUIVertexEffect curvedUIVertexEffect in componentsInChildren)
|
|
{
|
|
curvedUIVertexEffect.SetDirty();
|
|
}
|
|
Graphic[] componentsInChildren2 = GetComponentsInChildren<Graphic>();
|
|
foreach (Graphic graphic in componentsInChildren2)
|
|
{
|
|
graphic.SetAllDirty();
|
|
}
|
|
if (Application.isPlaying && GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
GetComponent<CurvedUIRaycaster>().RebuildCollider();
|
|
}
|
|
}
|
|
|
|
private Vector3 CanvasToCyllinder(Vector3 pos)
|
|
{
|
|
float f = pos.x / savedRectSize.x * (float)Angle * ((float)Math.PI / 180f);
|
|
pos.x = Mathf.Sin(f) * (SavedRadius + pos.z);
|
|
pos.z += Mathf.Cos(f) * (SavedRadius + pos.z) - (SavedRadius + pos.z);
|
|
return pos;
|
|
}
|
|
|
|
private Vector3 CanvasToCyllinderVertical(Vector3 pos)
|
|
{
|
|
float f = pos.y / savedRectSize.y * (float)Angle * ((float)Math.PI / 180f);
|
|
pos.y = Mathf.Sin(f) * (SavedRadius + pos.z);
|
|
pos.z += Mathf.Cos(f) * (SavedRadius + pos.z) - (SavedRadius + pos.z);
|
|
return pos;
|
|
}
|
|
|
|
private Vector3 CanvasToRing(Vector3 pos)
|
|
{
|
|
float num = pos.y.Remap(savedRectSize.y * 0.5f * (float)(RingFlipVertical ? 1 : (-1)), (0f - savedRectSize.y) * 0.5f * (float)(RingFlipVertical ? 1 : (-1)), (float)RingExternalDiameter * (1f - RingFill) * 0.5f, (float)RingExternalDiameter * 0.5f);
|
|
float f = (pos.x / savedRectSize.x).Remap(-0.5f, 0.5f, (float)Math.PI / 2f, (float)angle * ((float)Math.PI / 180f) + (float)Math.PI / 2f);
|
|
pos.x = num * Mathf.Cos(f);
|
|
pos.y = num * Mathf.Sin(f);
|
|
return pos;
|
|
}
|
|
|
|
private Vector3 CanvasToSphere(Vector3 pos)
|
|
{
|
|
float num = SavedRadius;
|
|
float num2 = VerticalAngle;
|
|
if (PreserveAspect)
|
|
{
|
|
num2 = (float)angle * (savedRectSize.y / savedRectSize.x);
|
|
num += ((Angle <= 0) ? pos.z : (0f - pos.z));
|
|
}
|
|
else
|
|
{
|
|
num = savedRectSize.x / 2f + pos.z;
|
|
if (num2 == 0f)
|
|
{
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
float num3 = (pos.x / savedRectSize.x).Remap(-0.5f, 0.5f, (float)(180 - angle) / 2f - 90f, 180f - (float)(180 - angle) / 2f - 90f);
|
|
num3 *= (float)Math.PI / 180f;
|
|
float num4 = (pos.y / savedRectSize.y).Remap(-0.5f, 0.5f, (180f - num2) / 2f, 180f - (180f - num2) / 2f);
|
|
num4 *= (float)Math.PI / 180f;
|
|
pos.z = Mathf.Sin(num4) * Mathf.Cos(num3) * num;
|
|
pos.y = (0f - num) * Mathf.Cos(num4);
|
|
pos.x = Mathf.Sin(num4) * Mathf.Sin(num3) * num;
|
|
if (PreserveAspect)
|
|
{
|
|
pos.z -= num;
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
public void AddEffectToChildren()
|
|
{
|
|
Graphic[] componentsInChildren = GetComponentsInChildren<Graphic>(true);
|
|
foreach (Graphic graphic in componentsInChildren)
|
|
{
|
|
if (graphic.GetComponent<CurvedUIVertexEffect>() == null)
|
|
{
|
|
graphic.gameObject.AddComponent<CurvedUIVertexEffect>();
|
|
graphic.SetAllDirty();
|
|
}
|
|
}
|
|
InputField[] componentsInChildren2 = GetComponentsInChildren<InputField>(true);
|
|
foreach (InputField inputField in componentsInChildren2)
|
|
{
|
|
if (inputField.GetComponent<CurvedUIInputFieldCaret>() == null)
|
|
{
|
|
inputField.gameObject.AddComponent<CurvedUIInputFieldCaret>();
|
|
}
|
|
}
|
|
}
|
|
|
|
public Vector3 VertexPositionToCurvedCanvas(Vector3 pos)
|
|
{
|
|
switch (Shape)
|
|
{
|
|
case CurvedUIShape.CYLINDER:
|
|
return CanvasToCyllinder(pos);
|
|
case CurvedUIShape.CYLINDER_VERTICAL:
|
|
return CanvasToCyllinderVertical(pos);
|
|
case CurvedUIShape.RING:
|
|
return CanvasToRing(pos);
|
|
case CurvedUIShape.SPHERE:
|
|
return CanvasToSphere(pos);
|
|
default:
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public Vector3 CanvasToCurvedCanvas(Vector3 pos)
|
|
{
|
|
pos = VertexPositionToCurvedCanvas(pos);
|
|
if (float.IsNaN(pos.x) || float.IsInfinity(pos.x))
|
|
{
|
|
return Vector3.zero;
|
|
}
|
|
return base.transform.localToWorldMatrix.MultiplyPoint3x4(pos);
|
|
}
|
|
|
|
public Vector3 CanvasToCurvedCanvasNormal(Vector3 pos)
|
|
{
|
|
pos = VertexPositionToCurvedCanvas(pos);
|
|
switch (Shape)
|
|
{
|
|
case CurvedUIShape.CYLINDER:
|
|
return base.transform.localToWorldMatrix.MultiplyVector((pos - new Vector3(0f, 0f, 0f - GetCyllinderRadiusInCanvasSpace())).ModifyY(0f)).normalized;
|
|
case CurvedUIShape.CYLINDER_VERTICAL:
|
|
return base.transform.localToWorldMatrix.MultiplyVector((pos - new Vector3(0f, 0f, 0f - GetCyllinderRadiusInCanvasSpace())).ModifyX(0f)).normalized;
|
|
case CurvedUIShape.RING:
|
|
return -base.transform.forward;
|
|
case CurvedUIShape.SPHERE:
|
|
{
|
|
Vector3 vector = ((!PreserveAspect) ? Vector3.zero : new Vector3(0f, 0f, 0f - GetCyllinderRadiusInCanvasSpace()));
|
|
return base.transform.localToWorldMatrix.MultiplyVector(pos - vector).normalized;
|
|
}
|
|
default:
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public bool RaycastToCanvasSpace(Ray ray, out Vector2 o_positionOnCanvas)
|
|
{
|
|
CurvedUIRaycaster component = GetComponent<CurvedUIRaycaster>();
|
|
o_positionOnCanvas = Vector2.zero;
|
|
switch (Shape)
|
|
{
|
|
case CurvedUIShape.CYLINDER:
|
|
return component.RaycastToCyllinderCanvas(ray, out o_positionOnCanvas, true);
|
|
case CurvedUIShape.CYLINDER_VERTICAL:
|
|
return component.RaycastToCyllinderVerticalCanvas(ray, out o_positionOnCanvas, true);
|
|
case CurvedUIShape.RING:
|
|
return component.RaycastToRingCanvas(ray, out o_positionOnCanvas, true);
|
|
case CurvedUIShape.SPHERE:
|
|
return component.RaycastToSphereCanvas(ray, out o_positionOnCanvas, true);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public float GetCyllinderRadiusInCanvasSpace()
|
|
{
|
|
float num = ((!PreserveAspect) ? (RectTransform.rect.size.x * 0.5f / Mathf.Sin(Mathf.Clamp(angle, -180f, 180f) * 0.5f * ((float)Math.PI / 180f))) : ((shape != CurvedUIShape.CYLINDER_VERTICAL) ? (RectTransform.rect.size.x / ((float)Math.PI * 2f * ((float)angle / 360f))) : (RectTransform.rect.size.y / ((float)Math.PI * 2f * ((float)angle / 360f)))));
|
|
return (angle != 0) ? num : 0f;
|
|
}
|
|
|
|
public Vector2 GetTesslationSize(bool modifiedByQuality = true)
|
|
{
|
|
Vector2 size = RectTransform.rect.size;
|
|
if (Angle != 0 || (!PreserveAspect && vertAngle != 0))
|
|
{
|
|
switch (shape)
|
|
{
|
|
case CurvedUIShape.CYLINDER:
|
|
case CurvedUIShape.RING:
|
|
case CurvedUIShape.CYLINDER_VERTICAL:
|
|
size /= GetSegmentsByAngle(angle);
|
|
break;
|
|
case CurvedUIShape.SPHERE:
|
|
size.x /= GetSegmentsByAngle(angle);
|
|
if (PreserveAspect)
|
|
{
|
|
size.y = size.x * RectTransform.rect.size.y / RectTransform.rect.size.x;
|
|
}
|
|
else
|
|
{
|
|
size.y /= GetSegmentsByAngle(VerticalAngle);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return size / ((!modifiedByQuality) ? 1f : Mathf.Clamp(Quality, 0.01f, 10f));
|
|
}
|
|
|
|
private float GetSegmentsByAngle(float angle)
|
|
{
|
|
if (angle.Abs() <= 1f)
|
|
{
|
|
return 1f;
|
|
}
|
|
if (angle.Abs() < 90f)
|
|
{
|
|
return (float)baseCircleSegments * Mathf.Abs(angle).Remap(0f, 90f, 0.01f, 0.5f);
|
|
}
|
|
return (float)baseCircleSegments * Mathf.Abs(angle).Remap(90f, 360f, 0.5f, 1f);
|
|
}
|
|
|
|
public void SetAllChildrenDirty(bool recalculateCurveOnly = false)
|
|
{
|
|
CurvedUIVertexEffect[] componentsInChildren = GetComponentsInChildren<CurvedUIVertexEffect>();
|
|
foreach (CurvedUIVertexEffect curvedUIVertexEffect in componentsInChildren)
|
|
{
|
|
if (recalculateCurveOnly)
|
|
{
|
|
curvedUIVertexEffect.SetDirty();
|
|
}
|
|
else
|
|
{
|
|
curvedUIVertexEffect.CurvingRequired = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Click()
|
|
{
|
|
if (GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
GetComponent<CurvedUIRaycaster>().Click();
|
|
}
|
|
}
|
|
|
|
public List<GameObject> GetObjectsUnderPointer()
|
|
{
|
|
if (GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
return GetComponent<CurvedUIRaycaster>().GetObjectsUnderPointer();
|
|
}
|
|
return new List<GameObject>();
|
|
}
|
|
|
|
public List<GameObject> GetObjectsUnderScreenPos(Vector2 pos, Camera eventCamera = null)
|
|
{
|
|
if (eventCamera == null)
|
|
{
|
|
eventCamera = myCanvas.worldCamera;
|
|
}
|
|
if (GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
return GetComponent<CurvedUIRaycaster>().GetObjectsUnderScreenPos(pos, eventCamera);
|
|
}
|
|
return new List<GameObject>();
|
|
}
|
|
|
|
public List<GameObject> GetObjectsHitByRay(Ray ray)
|
|
{
|
|
if (GetComponent<CurvedUIRaycaster>() != null)
|
|
{
|
|
return GetComponent<CurvedUIRaycaster>().GetObjectsHitByRay(ray);
|
|
}
|
|
return new List<GameObject>();
|
|
}
|
|
|
|
public void ActivateCurvedUIComponents(bool activate)
|
|
{
|
|
List<CurvedUITMP> list = new List<CurvedUITMP>();
|
|
list.AddRange(GetComponentsInChildren<CurvedUITMP>(true));
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
list[i].enabled = activate;
|
|
}
|
|
List<CurvedUITMPSubmesh> list2 = new List<CurvedUITMPSubmesh>();
|
|
list2.AddRange(GetComponentsInChildren<CurvedUITMPSubmesh>(true));
|
|
for (int j = 0; j < list2.Count; j++)
|
|
{
|
|
list2[j].enabled = activate;
|
|
}
|
|
List<CurvedUIVertexEffect> list3 = new List<CurvedUIVertexEffect>();
|
|
list3.AddRange(GetComponentsInChildren<CurvedUIVertexEffect>(true));
|
|
for (int k = 0; k < list3.Count; k++)
|
|
{
|
|
if (list3[k].GetComponent<Graphic>() != null)
|
|
{
|
|
list3[k].GetComponent<Graphic>().SetAllDirty();
|
|
}
|
|
list3[k].enabled = activate;
|
|
}
|
|
List<CurvedUIRaycaster> list4 = new List<CurvedUIRaycaster>();
|
|
list4.AddRange(GetComponents<CurvedUIRaycaster>());
|
|
for (int l = 0; l < list4.Count; l++)
|
|
{
|
|
list4[l].enabled = activate;
|
|
}
|
|
base.enabled = activate;
|
|
}
|
|
|
|
public void RemoveCurvedUIComponents()
|
|
{
|
|
List<CurvedUITMP> list = new List<CurvedUITMP>();
|
|
list.AddRange(GetComponentsInChildren<CurvedUITMP>(true));
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(list[i]);
|
|
}
|
|
List<CurvedUITMPSubmesh> list2 = new List<CurvedUITMPSubmesh>();
|
|
list2.AddRange(GetComponentsInChildren<CurvedUITMPSubmesh>(true));
|
|
for (int j = 0; j < list2.Count; j++)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(list2[j]);
|
|
}
|
|
List<CurvedUIVertexEffect> list3 = new List<CurvedUIVertexEffect>();
|
|
list3.AddRange(GetComponentsInChildren<CurvedUIVertexEffect>(true));
|
|
for (int k = 0; k < list3.Count; k++)
|
|
{
|
|
if (list3[k].GetComponent<Graphic>() != null)
|
|
{
|
|
list3[k].GetComponent<Graphic>().SetAllDirty();
|
|
}
|
|
UnityEngine.Object.DestroyImmediate(list3[k]);
|
|
}
|
|
List<CurvedUIRaycaster> list4 = new List<CurvedUIRaycaster>();
|
|
list4.AddRange(GetComponents<CurvedUIRaycaster>());
|
|
for (int l = 0; l < list4.Count; l++)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(list4[l]);
|
|
}
|
|
UnityEngine.Object.DestroyImmediate(this);
|
|
}
|
|
}
|
|
}
|