메시 API를 사용하여 방사형 진행 표시기 만들기
버전: 2023.2+
이 예시는 메시 API를 사용하여 시각적 요소에 시각적 콘텐츠를 그리는 방법을 보여줍니다.
참고: 메시 API는 고급 사용자를 위한 툴입니다. 버전 2022.1 이상에서 단순 지오메트리만 생성하려면 벡터 API를 대신 사용하십시오. 자세한 내용은 벡터 API를 사용하여 방사형 진행 표시기 만들기를 참조하십시오.
개요 예시
이 예시에서는 로딩 표시줄 대신 진행률을 표시하는 커스텀 컨트롤을 생성합니다. 진행 표시기는 백분율을 표시하는 레이블 주위의 부분적으로 채워진 링에 진행률 값을 표시합니다. 0에서 100 사이의 값을 지원하며 이 값에 따라 링이 채워집니다.
이 예시에서 만든 완성된 파일은 이 GitHub 저장소에서 찾을 수 있습니다.
선행 조건
이 가이드는 Unity 에디터, UI 툴킷, C# 스크립팅에 익숙한 개발자를 위한 가이드입니다. 시작하기 전에 먼저 다음을 숙지하십시오.
방사형 진행 표시기와 커스텀 메시 만들기
C# 스크립트를 생성하여 RadialProgress 클래스를 정의하고 컨트롤을 UXML 및__ UI__(사용자 인터페이스) 사용자가 애플리케이션과 상호 작용하도록 해 줍니다. Unity는 현재 3개의 UI 시스템을 지원합니다. 자세한 정보
See in Glossary 빌더에 표시합니다.
- 임의의 템플릿을 사용하여 Unity 프로젝트를 생성합니다.
-
radial-progress라는 폴더를 만들어 파일을 저장합니다. -
radial-progress폴더에서 다음 내용을 포함하는RadialProgress.cs라는 이름의 C# 스크립트를 생성합니다.
using Unity.Collections;
using UnityEngine;
using UnityEngine.UIElements;
namespace MyUILibrary
{
/// <summary>
/// An element that displays progress inside a partially filled circle
/// </summary>
[UxmlElement]
public partial class RadialProgress : VisualElement
{
// These are USS class names for the control overall and the label.
public static readonly string ussClassName = "radial-progress";
public static readonly string ussLabelClassName = "radial-progress__label";
// These objects allow C# code to access custom USS properties.
static CustomStyleProperty<Color> s_TrackColor = new CustomStyleProperty<Color>("--track-color");
static CustomStyleProperty<Color> s_ProgressColor = new CustomStyleProperty<Color>("--progress-color");
// These are the meshes this control uses.
EllipseMesh m_TrackMesh;
EllipseMesh m_ProgressMesh;
// This is the label that displays the percentage.
Label m_Label;
// This is the number of outer vertices to generate the circle.
const int k_NumSteps = 200;
// This is the number that the Label displays as a percentage.
float m_Progress;
/// <summary>
/// A value between 0 and 100
/// </summary>
[UxmlAttribute]
public float progress
{
// The progress property is exposed in C#.
get => m_Progress;
set
{
// Whenever the progress property changes, MarkDirtyRepaint() is named. This causes a call to the
// generateVisualContents callback.
m_Progress = value;
m_Label.text = Mathf.Clamp(Mathf.Round(value), 0, 100) + "%";
MarkDirtyRepaint();
}
}
// This default constructor is RadialProgress's only constructor.
public RadialProgress()
{
// Create a Label, add a USS class name, and add it to this visual tree.
m_Label = new Label();
m_Label.AddToClassList(ussLabelClassName);
Add(m_Label);
// Create meshes for the track and the progress.
m_ProgressMesh = new EllipseMesh(k_NumSteps);
m_TrackMesh = new EllipseMesh(k_NumSteps);
// Add the USS class name for the overall control.
AddToClassList(ussClassName);
// Register a callback after custom style resolution.
RegisterCallback<CustomStyleResolvedEvent>(evt => CustomStylesResolved(evt));
// Register a callback to generate the visual content of the control.
generateVisualContent += context => GenerateVisualContent(context);
progress = 0.0f;
}
static void CustomStylesResolved(CustomStyleResolvedEvent evt)
{
RadialProgress element = (RadialProgress)evt.currentTarget;
element.UpdateCustomStyles();
}
// After the custom colors are resolved, this method uses them to color the meshes and (if necessary) repaint
// the control.
void UpdateCustomStyles()
{
if (customStyle.TryGetValue(s_ProgressColor, out var progressColor))
{
m_ProgressMesh.color = progressColor;
}
if (customStyle.TryGetValue(s_TrackColor, out var trackColor))
{
m_TrackMesh.color = trackColor;
}
if (m_ProgressMesh.isDirty || m_TrackMesh.isDirty)
MarkDirtyRepaint();
}
// The GenerateVisualContent() callback method calls DrawMeshes().
static void GenerateVisualContent(MeshGenerationContext context)
{
RadialProgress element = (RadialProgress)context.visualElement;
element.DrawMeshes(context);
}
// DrawMeshes() uses the EllipseMesh utility class to generate an array of vertices and indices, for both the
// "track" ring (in grey) and the progress ring (in green). It then passes the geometry to the MeshWriteData
// object, as returned by the MeshGenerationContext.Allocate() method. For the "progress", only a slice of
// the index arrays is used to progressively reveal parts of the mesh.
void DrawMeshes(MeshGenerationContext context)
{
float halfWidth = contentRect.width * 0.5f;
float halfHeight = contentRect.height * 0.5f;
if (halfWidth < 2.0f || halfHeight < 2.0f)
return;
m_ProgressMesh.width = halfWidth;
m_ProgressMesh.height = halfHeight;
m_ProgressMesh.borderSize = 10;
m_ProgressMesh.UpdateMesh();
m_TrackMesh.width = halfWidth;
m_TrackMesh.height = halfHeight;
m_TrackMesh.borderSize = 10;
m_TrackMesh.UpdateMesh();
// Draw track mesh first
var trackMeshWriteData = context.Allocate(m_TrackMesh.vertices.Length, m_TrackMesh.indices.Length);
trackMeshWriteData.SetAllVertices(m_TrackMesh.vertices);
trackMeshWriteData.SetAllIndices(m_TrackMesh.indices);
// Keep progress between 0 and 100
float clampedProgress = Mathf.Clamp(m_Progress, 0.0f, 100.0f);
// Determine how many triangle are used to depending on progress, to achieve a partially filled circle
int sliceSize = Mathf.FloorToInt((k_NumSteps * clampedProgress) / 100.0f);
if (sliceSize == 0)
return;
// Every step is 6 indices in the corresponding array
sliceSize *= 6;
var progressMeshWriteData = context.Allocate(m_ProgressMesh.vertices.Length, sliceSize);
progressMeshWriteData.SetAllVertices(m_ProgressMesh.vertices);
var tempIndicesArray = new NativeArray<ushort>(m_ProgressMesh.indices, Allocator.Temp);
progressMeshWriteData.SetAllIndices(tempIndicesArray.Slice(0, sliceSize));
tempIndicesArray.Dispose();
}
}
}
커스텀 메시 만들기
다음 내용을 포함하는 EllipseMesh.cs라는 이름의 C# 스크립트를 생성합니다.
using UnityEngine;
using UnityEngine.UIElements;
namespace MyUILibrary
{
public class EllipseMesh
{
int m_NumSteps;
float m_Width;
float m_Height;
Color m_Color;
float m_BorderSize;
bool m_IsDirty;
public Vertex[] vertices { get; private set; }
public ushort[] indices { get; private set; }
public EllipseMesh(int numSteps)
{
m_NumSteps = numSteps;
m_IsDirty = true;
}
public void UpdateMesh()
{
if (!m_IsDirty)
return;
int numVertices = numSteps * 2;
int numIndices = numVertices * 6;
if (vertices == null || vertices.Length != numVertices)
vertices = new Vertex[numVertices];
if (indices == null || indices.Length != numIndices)
indices = new ushort[numIndices];
float stepSize = 360.0f / (float)numSteps;
float angle = -180.0f;
for (int i = 0; i < numSteps; ++i)
{
angle -= stepSize;
float radians = Mathf.Deg2Rad * angle;
float outerX = Mathf.Sin(radians) * width;
float outerY = Mathf.Cos(radians) * height;
Vertex outerVertex = new Vertex();
outerVertex.position = new Vector3(width + outerX, height + outerY, Vertex.nearZ);
outerVertex.tint = color;
vertices[i * 2] = outerVertex;
float innerX = Mathf.Sin(radians) * (width - borderSize);
float innerY = Mathf.Cos(radians) * (height - borderSize);
Vertex innerVertex = new Vertex();
innerVertex.position = new Vector3(width + innerX, height + innerY, Vertex.nearZ);
innerVertex.tint = color;
vertices[i * 2 + 1] = innerVertex;
indices[i * 6] = (ushort)((i == 0) ? vertices.Length - 2 : (i - 1) * 2); // previous outer vertex
indices[i * 6 + 1] = (ushort)(i * 2); // current outer vertex
indices[i * 6 + 2] = (ushort)(i * 2 + 1); // current inner vertex
indices[i * 6 + 3] = (ushort)((i == 0) ? vertices.Length - 2 : (i - 1) * 2); // previous outer vertex
indices[i * 6 + 4] = (ushort)(i * 2 + 1); // current inner vertex
indices[i * 6 + 5] = (ushort)((i == 0) ? vertices.Length - 1 : (i - 1) * 2 + 1); // previous inner vertex
}
m_IsDirty = false;
}
public bool isDirty => m_IsDirty;
void CompareAndWrite(ref float field, float newValue)
{
if (Mathf.Abs(field - newValue) > float.Epsilon)
{
m_IsDirty = true;
field = newValue;
}
}
public int numSteps
{
get => m_NumSteps;
set
{
m_IsDirty = value != m_NumSteps;
m_NumSteps = value;
}
}
public float width
{
get => m_Width;
set => CompareAndWrite(ref m_Width, value);
}
public float height
{
get => m_Height;
set => CompareAndWrite(ref m_Height, value);
}
public Color color
{
get => m_Color;
set
{
m_IsDirty = value != m_Color;
m_Color = value;
}
}
public float borderSize
{
get => m_BorderSize;
set => CompareAndWrite(ref m_BorderSize, value);
}
}
}
커스텀 컨트롤 스타일 지정
다음 내용을 포함하는 RadialProgress.uss라는 이름의 USS 파일을 생성합니다.
.radial-progress {
min-width: 26px;
min-height: 20px;
--track-color: rgb(130, 130, 130);
--progress-color: rgb(46, 132, 24);
--percentage-color: white;
margin-left: 5px;
margin-right: 5px;
margin-top: 5px;
margin-bottom: 5px;
flex-direction: row;
justify-content: center;
width: 100px;
height: 100px;
}
.radial-progress__label {
-unity-text-align: middle-left;
color: var(--percentage-color);
}
UI 문서에서 커스텀 컨트롤 사용 및 테스트
UI 빌더를 사용하여 컨트롤을 추가하고 USS 스타일시트를 적용할 수 있습니다. 다른 Progress 값을 사용하여 컨트롤을 테스트하십시오.
-
RadialProgressExample.uxml라는 이름의 UI 문서를 생성합니다. - UI 빌더에서
RadialProgressExample.uxml을 더블 클릭하여 엽니다. - Library 창에서 Project > Custom Controls > MyUILibrary를 선택합니다.
- RadialProgress를 계층 창으로 드래그합니다.
- UI 빌더의 StyleSheets 섹션에서
RadialProgress.uss를 기존 USS로 추가합니다. - 계층 창에서 RadialProgress를 선택합니다.
- 인스펙터 창에서 Name 박스에
radial-progress를 입력합니다. - 인스펙터 창에서 Progress 상자에 다른 값을 입력합니다. 뷰포트의 백분율이 변경되고 녹색 진행 표시 링의 크기가 조절됩니다.
동적 값으로 진행률을 업데이트하기 위한 로직 생성
데모용으로 컨트롤의 Progress 프로퍼티를 동적 값으로 업데이트하는 C# MonoBehaviour 스크립트를 생성합니다. radial-progress 폴더에 다음 내용이 포함된 RadialProgressComponent.cs라는 C# MonoBehaviour를 생성합니다.
using MyUILibrary;
using UnityEngine;
using UnityEngine.UIElements;
[RequireComponent(typeof(UIDocument))]
public class RadialProgressComponent : MonoBehaviour
{
RadialProgress m_RadialProgress;
void Start()
{
var root = GetComponent<UIDocument>().rootVisualElement;
m_RadialProgress = new RadialProgress() {
style = {
position = Position.Absolute,
left = 20, top = 20, width = 200, height = 200
}
};
root.Add(m_RadialProgress);
}
void Update()
{
m_RadialProgress.progress = ((Mathf.Sin(Time.time) + 1.0f) / 2.0f) * 60.0f + 10.0f;
}
}
런타임에서 진행 표시기 테스트
- Unity에서 GameObject > UI Toolkit > UI Document를 선택합니다.
- 계층 창에서 UIDocument를 선택합니다.
- RadialProgressComponent.cs를 UIDocument 게임 오브젝트의 컴포넌트로 추가합니다.
- 플레이 모드를 시작합니다. 진행 표시기가 씬에 표시되고 진행 표시 링과 값이 동적으로 변경됩니다.