LiRuochen_WorkFlow/UIGraphRenderer
Archived
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/dev/cp_lrc_dev1'

Browse Source
This commit is contained in:
lrss3
2026-04-30 09:37:35 +08:00
parent c11f07aa19 7fa90cbd81
commit d938aa9929
20 changed files with 61 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Runtime/Pattern/UIAnyPatternRenderer.cs
+800
View File
@@ -0,0 +1,800 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
namespace XericLibrary.Runtime.UIGraph
{
/// <summary>
/// 任意图案渲染器
/// </summary>
[AddComponentMenu("Xeric Library/UI/UIAnyPatternRenderer", 15)]
public class UIAnyPatternRenderer : XericRendererComponent
{
public enum DistanceFieldMode
{
/// <summary>
/// 简单模式：仅使用中心点（适用于凸多边形）
/// </summary>
SimpleCenter,
/// <summary>
/// 高级模式：使用中轴变换（适用于任意多边形）
/// </summary>
MedialAxis,
/// <summary>
/// 网格采样模式：在网格上采样距离（最精确但最慢）
/// </summary>
GridSampling
}
[System.Serializable]
public class PatternGroup
{
[Tooltip("该组包含的顶点索引")]
public List<int> vertexIndices = new List<int>();
[Tooltip("该组的填充颜色")]
public Color32 fillColor = Color.white;
[Tooltip("该组的描边颜色")]
public Color32 strokeColor = Color.black;
[Tooltip("描边宽度（像素）")]
[Range(0f, 20f)]
public float strokeWidth = 2f;
[Tooltip("是否填充该组")]
public bool fillEnabled = true;
[Tooltip("是否显示描边")]
public bool strokeEnabled = true;
[Header("距离场设置")]
[Tooltip("距离场生成模式")]
public DistanceFieldMode distanceFieldMode = DistanceFieldMode.SimpleCenter;
[Tooltip("距离场分辨率（仅GridSampling模式使用）")]
[Range(16, 256)]
public int distanceFieldResolution = 64;
[Tooltip("是否在着色器中使用距离场（需要自定义着色器）")]
public bool useDistanceFieldInShader = false;
[Tooltip("距离场衰减系数")]
[Range(0.1f, 10f)]
public float distanceFalloff = 1f;
[HideInInspector]
public List<Vector2> cachedMedialAxisPoints = new List<Vector2>();
[HideInInspector]
public List<float> cachedDistances = new List<float>();
[HideInInspector]
public Texture2D distanceFieldTexture;
}
[Header("顶点设置")]
[Tooltip("所有顶点的列表（局部坐标）")]
public List<Vector2> vertices = new List<Vector2>();
[Header("图形分组")]
[Tooltip("定义哪些顶点构成一个图形")]
public List<PatternGroup> patternGroups = new List<PatternGroup>();
[Header("全局设置")]
[Tooltip("是否显示所有顶点的辅助标记")]
public bool showVertexMarkers = false;
[Tooltip("顶点标记大小")]
[Range(1f, 20f)]
public float vertexMarkerSize = 5f;
[Tooltip("顶点标记颜色")]
public Color vertexMarkerColor = Color.red;
[Header("调试设置")]
[Tooltip("显示中轴线")]
public bool showMedialAxis = false;
[Tooltip("中轴线颜色")]
public Color medialAxisColor = Color.yellow;
[Tooltip("显示距离场可视化")]
public bool visualizeDistanceField = false;
// 三角剖分和距离场缓存
private Dictionary<int, List<int>> triangulationCache = new Dictionary<int, List<int>>();
private Dictionary<int, Vector2[]> uvCache = new Dictionary<int, Vector2[]>();
private bool isDirty = true;
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
if (vertices == null || vertices.Count == 0 || patternGroups == null || patternGroups.Count == 0)
{
return;
}
// 为每个图形分组生成网格
foreach (var group in patternGroups)
{
if (group.vertexIndices == null || group.vertexIndices.Count < 3)
continue;
// 获取该组的顶点
List<Vector2> groupVertices = new List<Vector2>();
foreach (int index in group.vertexIndices)
{
if (index >= 0 && index < vertices.Count)
{
groupVertices.Add(vertices[index]);
}
}
if (groupVertices.Count < 3)
continue;
// 三角剖分
List<int> triangles;
int cacheKey = GetCacheKey(group.vertexIndices);
if (!triangulationCache.TryGetValue(cacheKey, out triangles) || isDirty)
{
triangles = TriangulatePolygon(groupVertices);
triangulationCache[cacheKey] = triangles;
}
// 生成UV（距离场）
Vector2[] uvs;
if (!uvCache.TryGetValue(cacheKey, out uvs) || isDirty)
{
uvs = GenerateDistanceFieldUVs(group, groupVertices, triangles);
uvCache[cacheKey] = uvs;
}
// 添加填充
if (group.fillEnabled && triangles != null && triangles.Count > 0)
{
AddFilledPolygon(vh, groupVertices, triangles, uvs, group.fillColor);
}
// 添加描边
if (group.strokeEnabled && group.strokeWidth > 0)
{
AddStroke(vh, groupVertices, group.strokeWidth, group.strokeColor);
}
// 显示中轴线
if (showMedialAxis && group.cachedMedialAxisPoints.Count > 0)
{
AddMedialAxis(vh, group.cachedMedialAxisPoints, medialAxisColor);
}
}
// 添加顶点标记
if (showVertexMarkers)
{
AddVertexMarkers(vh);
}
isDirty = false;
}
/// <summary>
/// 生成距离场UV坐标
/// </summary>
private Vector2[] GenerateDistanceFieldUVs(PatternGroup group, List<Vector2> vertices, List<int> triangles)
{
Vector2[] uvs = new Vector2[vertices.Count];
switch (group.distanceFieldMode)
{
case DistanceFieldMode.SimpleCenter:
uvs = GenerateSimpleCenterUVs(vertices);
break;
case DistanceFieldMode.MedialAxis:
uvs = GenerateMedialAxisUVs(group, vertices, triangles);
break;
case DistanceFieldMode.GridSampling:
uvs = GenerateGridSamplingUVs(group, vertices, triangles);
break;
}
return uvs;
}
/// <summary>
/// 简单中心模式：计算质心并生成线性距离
/// </summary>
private Vector2[] GenerateSimpleCenterUVs(List<Vector2> vertices)
{
Vector2[] uvs = new Vector2[vertices.Count];
// 计算质心
Vector2 centroid = CalculateCentroid(vertices);
// 计算最大距离（归一化用）
float maxDistance = 0;
foreach (var vertex in vertices)
{
float dist = Vector2.Distance(vertex, centroid);
if (dist > maxDistance) maxDistance = dist;
}
if (maxDistance < 0.001f) maxDistance = 1f;
// 生成UV：质心处为(0.5, 0.5)，边界处根据距离变化
for (int i = 0; i < vertices.Count; i++)
{
float dist = Vector2.Distance(vertices[i], centroid);
float normalizedDist = dist / maxDistance;
// UV的x分量表示距离（0-1），y分量可以用于其他用途
uvs[i] = new Vector2(normalizedDist, 0.5f);
}
return uvs;
}
/// <summary>
/// 中轴变换模式：计算多边形的中轴线
/// </summary>
private Vector2[] GenerateMedialAxisUVs(PatternGroup group, List<Vector2> vertices, List<int> triangles)
{
Vector2[] uvs = new Vector2[vertices.Count];
// 清空缓存
group.cachedMedialAxisPoints.Clear();
group.cachedDistances.Clear();
// 计算中轴线
List<Vector2> medialAxis = ComputeMedialAxis(vertices);
group.cachedMedialAxisPoints = medialAxis;
if (medialAxis.Count == 0)
{
// 如果中轴线计算失败，回退到简单中心模式
return GenerateSimpleCenterUVs(vertices);
}
// 计算每个顶点到最近的中轴线点的距离
float maxDistance = 0;
for (int i = 0; i < vertices.Count; i++)
{
float minDist = float.MaxValue;
foreach (var axisPoint in medialAxis)
{
float dist = Vector2.Distance(vertices[i], axisPoint);
if (dist < minDist) minDist = dist;
}
group.cachedDistances.Add(minDist);
if (minDist > maxDistance) maxDistance = minDist;
}
if (maxDistance < 0.001f) maxDistance = 1f;
// 生成UV
for (int i = 0; i < vertices.Count; i++)
{
float normalizedDist = group.cachedDistances[i] / maxDistance;
uvs[i] = new Vector2(normalizedDist, 0.5f);
}
return uvs;
}
/// <summary>
/// 计算多边形的中轴线（简化版）
/// 实际应用中可以使用更复杂的算法如Voronoi图或直线骨架算法
/// </summary>
private List<Vector2> ComputeMedialAxis(List<Vector2> vertices)
{
List<Vector2> medialAxis = new List<Vector2>();
// 方法1：使用Voronoi图的简化版本
// 对于每条边，计算其法线方向上的点
int n = vertices.Count;
// 添加质心作为起点
Vector2 centroid = CalculateCentroid(vertices);
medialAxis.Add(centroid);
// 对于每条边，计算中垂线与相邻边中垂线的交点
for (int i = 0; i < n; i++)
{
int prev = (i - 1 + n) % n;
int curr = i;
int next = (i + 1) % n;
// 计算三条边的中垂线
Vector2 edge1Mid = (vertices[prev] + vertices[curr]) * 0.5f;
Vector2 edge1Dir = vertices[curr] - vertices[prev];
Vector2 edge1Normal = new Vector2(-edge1Dir.y, edge1Dir.x).normalized;
Vector2 edge2Mid = (vertices[curr] + vertices[next]) * 0.5f;
Vector2 edge2Dir = vertices[next] - vertices[curr];
Vector2 edge2Normal = new Vector2(-edge2Dir.y, edge2Dir.x).normalized;
// 计算两条中垂线的交点
Vector2 intersection;
if (LineLineIntersection(edge1Mid, edge1Normal, edge2Mid, edge2Normal, out intersection))
{
// 检查交点是否在多边形内部
if (PointInPolygon(intersection, vertices))
{
medialAxis.Add(intersection);
}
}
}
// 去重
medialAxis = RemoveDuplicatePoints(medialAxis, 0.1f);
return medialAxis;
}
/// <summary>
/// 网格采样模式：在网格上采样距离场（最精确）
/// </summary>
private Vector2[] GenerateGridSamplingUVs(PatternGroup group, List<Vector2> vertices, List<int> triangles)
{
Vector2[] uvs = new Vector2[vertices.Count];
// 计算包围盒
Vector2 min = vertices[0];
Vector2 max = vertices[0];
foreach (var v in vertices)
{
min = Vector2.Min(min, v);
max = Vector2.Max(max, v);
}
float width = max.x - min.x;
float height = max.y - min.y;
// 创建距离场纹理
if (group.distanceFieldTexture == null ||
group.distanceFieldTexture.width != group.distanceFieldResolution)
{
group.distanceFieldTexture = new Texture2D(
group.distanceFieldResolution,
group.distanceFieldResolution,
TextureFormat.R8, false);
group.distanceFieldTexture.filterMode = FilterMode.Bilinear;
}
Color32[] pixels = new Color32[group.distanceFieldResolution * group.distanceFieldResolution];
// 对每个像素采样
for (int y = 0; y < group.distanceFieldResolution; y++)
{
for (int x = 0; x < group.distanceFieldResolution; x++)
{
// 计算世界坐标
float worldX = min.x + (x / (float)(group.distanceFieldResolution - 1)) * width;
float worldY = min.y + (y / (float)(group.distanceFieldResolution - 1)) * height;
Vector2 worldPos = new Vector2(worldX, worldY);
// 计算到边界的最小距离
float minDistance = float.MaxValue;
// 检查是否在多边形内部
bool inside = PointInPolygon(worldPos, vertices);
// 计算到每条边的距离
for (int i = 0; i < vertices.Count; i++)
{
int next = (i + 1) % vertices.Count;
float dist = DistancePointToSegment(worldPos, vertices[i], vertices[next]);
if (dist < minDistance)
minDistance = dist;
}
// 归一化距离
float normalizedDist = Mathf.Clamp01(minDistance / Mathf.Max(width, height));
// 如果在外部，距离为负
if (!inside)
normalizedDist = -normalizedDist;
// 存储到纹理
int pixelIndex = y * group.distanceFieldResolution + x;
byte distByte = (byte)(Mathf.Clamp01(Mathf.Abs(normalizedDist)) * 255);
pixels[pixelIndex] = new Color32(distByte, distByte, distByte, 255);
// 为顶点生成UV
if (visualizeDistanceField)
{
for (int i = 0; i < vertices.Count; i++)
{
if (Vector2.Distance(vertices[i], worldPos) < 1f)
{
uvs[i] = new Vector2(x / (float)group.distanceFieldResolution,
y / (float)group.distanceFieldResolution);
}
}
}
}
}
group.distanceFieldTexture.SetPixels32(pixels);
group.distanceFieldTexture.Apply();
// 如果不显示可视化，使用简单模式的UV
if (!visualizeDistanceField)
{
return GenerateSimpleCenterUVs(vertices);
}
return uvs;
}
/// <summary>
/// 计算多边形的质心
/// </summary>
private Vector2 CalculateCentroid(List<Vector2> vertices)
{
float signedArea = 0;
float centerX = 0;
float centerY = 0;
int n = vertices.Count;
for (int i = 0; i < n; i++)
{
int next = (i + 1) % n;
float temp = vertices[i].x * vertices[next].y - vertices[next].x * vertices[i].y;
signedArea += temp;
centerX += (vertices[i].x + vertices[next].x) * temp;
centerY += (vertices[i].y + vertices[next].y) * temp;
}
signedArea *= 0.5f;
if (Mathf.Abs(signedArea) < 0.001f)
return vertices.Count > 0 ? vertices[0] : Vector2.zero;
centerX /= (6 * signedArea);
centerY /= (6 * signedArea);
return new Vector2(centerX, centerY);
}
/// <summary>
/// 检查点是否在多边形内部
/// </summary>
private bool PointInPolygon(Vector2 point, List<Vector2> vertices)
{
int n = vertices.Count;
bool inside = false;
for (int i = 0, j = n - 1; i < n; j = i++)
{
if (((vertices[i].y > point.y) != (vertices[j].y > point.y)) &&
(point.x < (vertices[j].x - vertices[i].x) * (point.y - vertices[i].y) /
(vertices[j].y - vertices[i].y) + vertices[i].x))
{
inside = !inside;
}
}
return inside;
}
/// <summary>
/// 计算点到线段的最短距离
/// </summary>
private float DistancePointToSegment(Vector2 point, Vector2 a, Vector2 b)
{
Vector2 ab = b - a;
Vector2 ap = point - a;
float dot = Vector2.Dot(ap, ab);
float lenSq = ab.sqrMagnitude;
float t = dot / lenSq;
t = Mathf.Clamp01(t);
Vector2 projection = a + t * ab;
return Vector2.Distance(point, projection);
}
/// <summary>
/// 计算两条直线的交点
/// </summary>
private bool LineLineIntersection(Vector2 p1, Vector2 d1, Vector2 p2, Vector2 d2, out Vector2 intersection)
{
intersection = Vector2.zero;
float det = d1.x * d2.y - d1.y * d2.x;
if (Mathf.Abs(det) < 0.001f)
return false;
Vector2 diff = p2 - p1;
float t = (diff.x * d2.y - diff.y * d2.x) / det;
intersection = p1 + t * d1;
return true;
}
/// <summary>
/// 去除重复点
/// </summary>
private List<Vector2> RemoveDuplicatePoints(List<Vector2> points, float threshold)
{
List<Vector2> result = new List<Vector2>();
foreach (var p in points)
{
bool isDuplicate = false;
foreach (var r in result)
{
if (Vector2.Distance(p, r) < threshold)
{
isDuplicate = true;
break;
}
}
if (!isDuplicate)
result.Add(p);
}
return result;
}
// ========== 以下是原有代码的简化版本 ==========
/// <summary>
/// 生成缓存键（基于顶点索引列表）
/// </summary>
private int GetCacheKey(List<int> indices)
{
int hash = 17;
foreach (int index in indices)
{
hash = hash * 31 + index;
}
return hash;
}
/// <summary>
/// 耳切法三角剖分（简化版）
/// </summary>
private List<int> TriangulatePolygon(List<Vector2> polygonVertices)
{
// 这里使用简化版本，实际应用中可以使用更复杂的三角剖分算法
List<int> triangles = new List<int>();
if (polygonVertices.Count < 3)
return triangles;
// 简单的扇形三角剖分（仅适用于凸多边形）
for (int i = 1; i < polygonVertices.Count - 1; i++)
{
triangles.Add(0);
triangles.Add(i);
triangles.Add(i + 1);
}
return triangles;
}
/// <summary>
/// 添加填充多边形
/// </summary>
private void AddFilledPolygon(VertexHelper vh, List<Vector2> vertices, List<int> triangles, Vector2[] uvs, Color32 color)
{
int vertexStartIndex = vh.currentVertCount;
// 添加顶点
for (int i = 0; i < vertices.Count; i++)
{
Vector2 uv = uvs != null && i < uvs.Length ? uvs[i] : Vector2.zero;
vh.AddVert(vertices[i], color, uv);
}
// 添加三角形索引
for (int i = 0; i < triangles.Count; i += 3)
{
vh.AddTriangle(
vertexStartIndex + triangles[i],
vertexStartIndex + triangles[i + 1],
vertexStartIndex + triangles[i + 2]
);
}
}
/// <summary>
/// 添加描边
/// </summary>
private void AddStroke(VertexHelper vh, List<Vector2> vertices, float width, Color32 color)
{
if (vertices.Count < 2)
return;
float halfWidth = width * 0.5f;
// 为每条边生成两个三角形（形成矩形）
for (int i = 0; i < vertices.Count; i++)
{
int next = (i + 1) % vertices.Count;
Vector2 p1 = vertices[i];
Vector2 p2 = vertices[next];
// 计算边的法线
Vector2 edge = p2 - p1;
Vector2 normal = new Vector2(-edge.y, edge.x).normalized;
// 生成四个顶点（矩形）
Vector2 v1 = p1 + normal * halfWidth;
Vector2 v2 = p1 - normal * halfWidth;
Vector2 v3 = p2 - normal * halfWidth;
Vector2 v4 = p2 + normal * halfWidth;
int startIndex = vh.currentVertCount;
vh.AddVert(v1, color, Vector2.zero);
vh.AddVert(v2, color, Vector2.zero);
vh.AddVert(v3, color, Vector2.zero);
vh.AddVert(v4, color, Vector2.zero);
// 两个三角形
vh.AddTriangle(startIndex, startIndex + 1, startIndex + 2);
vh.AddTriangle(startIndex, startIndex + 2, startIndex + 3);
}
}
/// <summary>
/// 添加中轴线可视化
/// </summary>
private void AddMedialAxis(VertexHelper vh, List<Vector2> points, Color32 color)
{
if (points.Count < 2)
return;
// 绘制线段
for (int i = 0; i < points.Count - 1; i++)
{
Vector2 p1 = points[i];
Vector2 p2 = points[i + 1];
float lineWidth = 3f;
Vector2 edge = p2 - p1;
Vector2 normal = new Vector2(-edge.y, edge.x).normalized;
Vector2 v1 = p1 + normal * lineWidth * 0.5f;
Vector2 v2 = p1 - normal * lineWidth * 0.5f;
Vector2 v3 = p2 - normal * lineWidth * 0.5f;
Vector2 v4 = p2 + normal * lineWidth * 0.5f;
int startIndex = vh.currentVertCount;
vh.AddVert(v1, color, Vector2.zero);
vh.AddVert(v2, color, Vector2.zero);
vh.AddVert(v3, color, Vector2.zero);
vh.AddVert(v4, color, Vector2.zero);
vh.AddTriangle(startIndex, startIndex + 1, startIndex + 2);
vh.AddTriangle(startIndex, startIndex + 2, startIndex + 3);
}
}
/// <summary>
/// 添加顶点标记（小圆圈）
/// </summary>
private void AddVertexMarkers(VertexHelper vh)
{
int segments = 8;
foreach (var vertex in vertices)
{
List<Vector2> circleVertices = new List<Vector2>();
List<int> circleTriangles = new List<int>();
circleVertices.Add(vertex);
for (int i = 0; i <= segments; i++)
{
float angle = (i / (float)segments) * 2 * Mathf.PI;
Vector2 point = vertex + new Vector2(
Mathf.Cos(angle) * vertexMarkerSize,
Mathf.Sin(angle) * vertexMarkerSize
);
circleVertices.Add(point);
}
for (int i = 1; i <= segments; i++)
{
circleTriangles.Add(0);
circleTriangles.Add(i);
circleTriangles.Add(i + 1);
}
int startIndex = vh.currentVertCount;
foreach (var v in circleVertices)
{
vh.AddVert(v, vertexMarkerColor, Vector2.zero);
}
for (int i = 0; i < circleTriangles.Count; i += 3)
{
vh.AddTriangle(
startIndex + circleTriangles[i],
startIndex + circleTriangles[i + 1],
startIndex + circleTriangles[i + 2]
);
}
}
}
/// <summary>
/// 标记为需要重新生成网格
/// </summary>
public void SetVerticesDirty()
{
isDirty = true;
SetAllDirty();
}
/// <summary>
/// 设置顶点列表
/// </summary>
public void SetVertices(List<Vector2> newVertices)
{
vertices = newVertices ?? new List<Vector2>();
SetVerticesDirty();
}
/// <summary>
/// 设置图形分组
/// </summary>
public void SetPatternGroups(List<PatternGroup> newGroups)
{
patternGroups = newGroups ?? new List<PatternGroup>();
SetVerticesDirty();
}
/// <summary>
/// 添加一个新的图形分组
/// </summary>
public void AddPatternGroup(List<int> vertexIndices, Color fillColor, Color strokeColor, float strokeWidth = 2f)
{
PatternGroup group = new PatternGroup
{
vertexIndices = vertexIndices,
fillColor = fillColor,
strokeColor = strokeColor,
strokeWidth = strokeWidth,
fillEnabled = true,
strokeEnabled = true,
distanceFieldMode = DistanceFieldMode.SimpleCenter
};
if (patternGroups == null)
patternGroups = new List<PatternGroup>();
patternGroups.Add(group);
SetVerticesDirty();
}
#if UNITY_EDITOR
protected override void OnValidate()
{
base.OnValidate();
isDirty = true;
}
#endif
}
}
Runtime/Pattern/UIAnyPatternRenderer.cs.meta
+3
View File
@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e0096bca1b7b40bf90e0aa7ebbda48f0
timeCreated: 1775548842
Runtime/Pattern/UILineRenderer.cs
+142
View File
@@ -0,0 +1,142 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;
namespace XericLibrary.Runtime.UIGraph
{
/// <summary>
/// UI上线条绘制组件
/// 支持设置线条厚度、居中显示，并为线段之间添加斜角边缘
/// 继承自 MaskableGraphic，可与 UI 遮罩系统配合使用
/// </summary>
[AddComponentMenu("Xeric Library/UI/UILineRenderer", 15)]
public class UILineRenderer : XericRendererComponent
{
// todo 根据优弧劣弧绘制线段，这么说可能不太准确，但我需要在90度以内绘制漂亮的转角，大于90度则用中心圆代替
#region 字段属性
/// <summary>
/// 线条的顶点数组，至少需要 2 个点才能绘制线条
/// 点的坐标基于本地空间，中心点由 center 属性控制
/// </summary>
public List<Vector2> points = new List<Vector2>();
private Vector2[] _points;
public float thickness = 10f;
public bool center = true;
public bool cycleLoop = false;
/// <summary>
/// 是否启用倒角功能
/// </summary>
public bool useChamfer = false;
/// <summary>
/// 倒角细分数量，控制圆弧的平滑度
/// </summary>
public int chamferSegments = 4;
/// <summary>
/// 内圆弧半径，当大于0时启用内圆弧
/// </summary>
public float innerRadius = 0f;
#endregion
/// <summary>
/// 添加顶点
/// </summary>
/// <param name="point"></param>
/// <param name="mergingRadius">合并弧度，指定一个弧度，在添加顶点时，自动合并之前的顶点为直线</param>
public void AddPoint(Vector2 point, float mergingRadius = -1)
{
if (mergingRadius > 0 && points.Count >= 2)
{
var a = points[^1];
var b = Vector3.Dot((a - points[^2]).normalized, (a - point).normalized);
if (b < mergingRadius)
points[^1] = point;
return;
}
points.Add(point);
Refresh();
}
public void RemovePoint(int index)
{
points.RemoveAt(index);
Refresh();
}
public void CleanPoint(Vector2 point)
{
points.Clear();
Refresh();
}
/// <summary>
/// 生成线条网格
/// </summary>
/// <param name="vh">用于构建网格的 VertexHelper 对象</param>
protected override void OnPopulateMesh(VertexHelper vh)
{
// 清空现有的网格数据
vh.Clear();
var offset = XericRendererUtils.SwitchCenterOffset(center, rectTransform.sizeDelta);
_points = points.ToArray();
if (useChamfer)
{
vh.PopulateLineByPointsArray_CFAL(_points, thickness, cycleLoop, color, offset, chamferSegments, innerRadius);
}
else
{
vh.PopulateLineByPointsArray_DSL5(_points, thickness, cycleLoop, color, offset);
}
return;
// 至少需要 2 个点才能绘制线条
if (_points.Length < 2)
return;
// 计算线路总长度
float totalLength = _points.CalculateTotalLength();
float currentLength = 0f;
// 遍历所有点，创建线段并添加到网格中
for (int i = 0; i < _points.Length-1; i++)
{
// 使用静态工具方法创建当前点与下一个点之间的线段
// 传递当前累积长度和总长度用于UV坐标计算
vh.CreateLineSegment_CFAL(_points[i], _points[i+1],
i > 0 ? Mathf.Acos(Vector2.Dot((_points[i] - _points[i -1]).normalized, (_points[i + 1] - _points[i]).normalized)) * Mathf.Rad2Deg : 0,
i < _points.Length-2 ? Mathf.Acos(Vector2.Dot((_points[i] - _points[i + 1]).normalized, (_points[i + 1] - _points[i +2]).normalized)) * Mathf.Rad2Deg : 0,
thickness, center, rectTransform.sizeDelta, color, currentLength, totalLength);
// 更新累积长度
currentLength += Vector2.Distance(_points[i], _points[i+1]);
// 计算当前线段的顶点索引（每个线段包含 5 个顶点）
int index = i * 5;
// 添加线段的两个三角形（构成矩形线段）
vh.AddTriangle(index, index+1, index+3);
vh.AddTriangle(index+3, index+2, index);
// 为线段之间添加斜角边缘
// 使用上一个线段的终点和当前线段的起点创建过渡三角形
if (i != 0)
{
vh.AddTriangle(index, index-1, index-3);
vh.AddTriangle(index+1, index-1, index-2);
}
}
}
}
}
Runtime/Pattern/UILineRenderer.cs.meta
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5b33b2e663e78774c9f0c9af55018725
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Runtime/Pattern/UIPatternRenderer.cs
+320
View File
@@ -0,0 +1,320 @@
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Pool;
using UnityEngine.Serialization;
using UnityEngine.UI;
using XericLibrary.Runtime.Debuger;
using XericLibrary.Runtime.MacroLibrary;
#if ODIN_INSPECTOR
using Sirenix.OdinInspector;
#endif
namespace XericLibrary.Runtime.UIGraph
{
/// <summary>
/// UI多边形图形图案渲染组件（三角形，菱形，五边形...三十二边形）
/// 支持倒角
/// </summary>
[AddComponentMenu("Xeric Library/UI/UIPatternRenderer", 15)]
public class UIPatternRenderer : XericRendererComponent
{
#region 字段属性
public override string ShaderName => "XericLibrary/UILine/UIPattern";
[Header("多边形设置"), Range(3, 32)] public int sides = 6;
[SerializeField, Tooltip("多边形的大小 (相对于矩形区域的比例 0-1)")]
#if ODIN_INSPECTOR
[PropertyRange("ScaleMin", "GetMaxScale")]
#else
[Range(0f, 1f)]
#endif
private float scale = 1f;
[Tooltip("倒角尺寸")][Range(0f, 1f)] public float roundingSize = 0;
[Tooltip("倒角细分")][Range(2f, 32f)] public int roundingTime = 3;
[Tooltip("倒角形状")][Range(0f, 1f)] public float roundingPower = 1;
public AngleSelectMode angleMode;
#if ODIN_INSPECTOR
[ShowIf("angleMode", optionalValue: AngleSelectMode.Angle)]
#endif
[Tooltip("起始角度")] public float startAngle = 90f;
#if ODIN_INSPECTOR
[ShowIf("angleMode", optionalValue: AngleSelectMode.Multiples)]
#endif
[Tooltip("起始角度(倍数对齐)")] public float startAngleTime = 1;
[SerializeField, Tooltip("边框厚度")] [Range(0f, 1f)]
private float borderThickness = .1f;
[SerializeField, Tooltip("边框颜色")] private Color borderColor = Color.white;
[SerializeField, Tooltip("边框颜色渐变")] private Color borderColor2 = Color.white;
[SerializeField, Tooltip("填充颜色")] private Color fillColor = Color.gray;
/// <summary>
/// 获取最大缩放（一个参考值）
/// </summary>
public float GetMaxScale => 1 / Mathf.Cos(GetSideRadius);
private float ScaleMin => 0.01f;
/// <summary>
/// 获取多边形的旋转弧度
/// </summary>
public float GetSideRadius => Mathf.PI / sides;
private float sideAngle =>
angleMode switch
{
AngleSelectMode.Angle => startAngle,
AngleSelectMode.Multiples => Mathf.Rad2Deg * 2 * GetSideRadius * (startAngleTime - (sides % 2 == 0 ? 0 : 0.25f)),
_ => 1f
};
private static readonly int BorderColor1 = Shader.PropertyToID("_BorderColor");
private static readonly int BorderColor2 = Shader.PropertyToID("_BorderColor2");
private static readonly int FillColor1 = Shader.PropertyToID("_FillColor");
private static readonly int Thinkness = Shader.PropertyToID("_Thinkness");
/// <summary>
/// 边框厚度
/// </summary>
public float BorderThickness
{
get => borderThickness;
set
{
borderThickness = value;
m_Material.SetFloat(Thinkness, borderThickness);
}
}
/// <summary>
/// 边框颜色
/// </summary>
public Color BorderColor
{
get => borderColor;
set
{
borderColor = value;
m_Material.SetColor(BorderColor1, borderColor);
}
}
/// <summary>
/// 边框颜色渐变
/// </summary>
public Color BorderColorLinear
{
get => borderColor2;
set
{
borderColor2 = value;
m_Material.SetColor(BorderColor2, borderColor2);
}
}
/// <summary>
/// 填充颜色
/// </summary>
public Color FillColor
{
get => fillColor;
set
{
fillColor = value;
m_Material.SetColor(FillColor1, fillColor);
}
}
/// <summary>
/// 设置缩放
/// </summary>
/// <param name="scale"></param>
public void SetScale(float scale) => this.scale = scale;
// 缓存顶点列表以避免每帧分配内存
private readonly List<Vector3> verticesCache = new List<Vector3>();
#endregion
#region 类内类型
public enum AngleSelectMode
{
Angle,
Multiples,
}
#endregion
protected override void OnPopulatePrefabricateVertex(List<UIVertex> vertexList, List<int> indexList)
{
// 获取绘图区域的中心点和尺寸
Rect rect = GetPixelAdjustedRect();
Vector2 center = rect.center;
// 取宽高较小值的一半作为基准半径，确保图形不超出边界
float minSize = Mathf.Min(rect.width, rect.height);
float radius = (minSize / 2f) * scale;
// 计算多边形的顶点
verticesCache.Clear();
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (sides < 3)
{
sides = 3;
Debug.LogError("图元必须由至少3个顶点构成！");
}
// 半角 (弧度)
var halfAngleRad = Mathf.PI / sides;
// 限制最大倒角半径，防止图形自相交或消失
// 最大理论半径是内切圆半径，但为了安全，限制在边长的一半对应的切距内
// 边长 L = 2 * R * sin(pi/n)
// 最大切距 d_max = L / 2 = R * sin(pi/n)
// 对应最大圆角半径 r_max = d_max * tan(pi/n) = R * sin^2/cos ?
// 简单限制：r < radius * 0.4 (经验值) 或者精确计算
var maxRounding = radius * 0.4f;
var currentRounding = Mathf.Clamp(roundingSize, 0f, maxRounding);
// 此渲染组件的颜色和中心uv
Color32 color32 = this.color;
Vector2 uvCenter = new Vector4(0.5f, 0.5f, 0, 0);
// 没有倒角，使用常规流程
if (currentRounding <= 0f)
{
verticesCache.AddRange(OriginPatternVectorPoints(sides, radius, sideAngle, center));
// 添加中心点
vertexList.AddVert(center, uvCenter, color32);
float angleStep = 360f / sides;
// 添加外围点
for (int i = 0; i < verticesCache.Count; i++)
{
// 简单的映射UV，将世界坐标映射到 0-1 范围，或者根据需求自定义
// 这里简单地将多边形映射到整个纹理空间
XericRendererUtils.GetUVAtRect(verticesCache[i], rect, out var u, out var v);
GetNormalizedAngleByPos(angleStep, i, out var normalizedAngle);
var uv = new Vector4(u, v, 1, normalizedAngle);
vertexList.AddVert(verticesCache[i], uv, color32);
}
// 三角形顺序：中心点, 当前外点, 下一个外点
for (int i = 1; i < sides; i++)
indexList.AddTriangle(0, i, i + 1);
// 连接最后一个点和第一个点以闭合形状
indexList.AddTriangle(0, sides, 1);
}
// 启用倒角
else
{
verticesCache.AddRange(OriginPatternVectorPoints(sides, radius, sideAngle, center));
// 添加中心点
vertexList.AddVert(center, uvCenter, color32);
var maxVpCount = sides * roundingTime + 1;
var l = 2 * radius * Mathf.Sin(Mathf.PI / sides);
for (var i = 0; i < sides; i++)
{
Vector2 pCurr = verticesCache[i];
Vector2 pPrev = verticesCache[(i - 1 + sides) % sides];
Vector2 pNext = verticesCache[(i + 1) % sides];
Vector2 dirIn = (pPrev - pCurr).normalized;
Vector2 dirOut = (pNext - pCurr).normalized;
// 计算圆弧圆心
// 角平分线方向 (指向内部)
// dirIn 的反向是 -dirIn. dirOut 是 dirOut.
// 平分线 = normalize(-dirIn + dirOut)
Vector2 bisector = (-dirIn + dirOut).normalized;
// 圆心距离 pCurr 的距离: h = r / sin(alpha)
float distToCenter = currentRounding / Mathf.Sin(halfAngleRad);
Vector2 arcCenter = pCurr + bisector * distToCenter;
var halfL = l * 0.5f;
var power = halfL * roundingPower * roundingSize;
// 添加圆弧中心点
// GetUVByPos(arcCenter, rect, out var ac_u, out var ac_v);
// vh.AddVert(arcCenter, this.color, new Vector4(ac_u, ac_v, ));
// // 中心区域
// if (i > 0)
// vh.AddTriangle(0, 2 + (i - 1) * roundingTime, 2 + i * roundingTime);
var p0 = pCurr + dirIn * halfL * roundingSize;
var p1 = pCurr + dirIn * power;
var p2 = pCurr + dirOut * power;
var p3 = pCurr + dirOut * halfL * roundingSize;
for (var j = 0; j < roundingTime; j++)
{
var jTime = (float)j / (roundingTime - 1);
MacroCurve.BezierCurve3(p0, p1, p2, p3, jTime, out var pos);
pos.GetUVAtRect(rect, out var u, out var v);
var uv = new Vector4(u, v, 1, 1);
vertexList.AddVert(pos, uv, this.color);
var index = roundingTime * i + j + 1;
var next = index + 1;
if (next >= maxVpCount)
next = (next % maxVpCount) + 1;
indexList.AddTriangle(0, index, next);
}
}
}
}
/// <summary>
/// 图元基础外围图形顶点
/// </summary>
/// <param name="sideCount">边数（或者顶点数）</param>
/// <param name="radius">半径</param>
/// <param name="startAngle">图形起始角度</param>
/// <param name="center">中心偏移</param>
/// <returns></returns>
private static IEnumerable<Vector3> OriginPatternVectorPoints(int sideCount, float radius, float startAngle,
Vector2 center)
{
float angleStep = 360f / sideCount;
for (int i = 0; i < sideCount; i++)
{
float angleDeg = startAngle + i * angleStep;
float angle = angleDeg * Mathf.Deg2Rad;
float x = center.x + Mathf.Cos(angle) * radius;
float y = center.y + Mathf.Sin(angle) * radius;
yield return new Vector2(x, y);
// uv的y是角度，不过看起来不太需要这一步
// float normalizedDist = 1.0f;
// float normalizedAngle = (angleDeg + 90f) / 360f;
// if (normalizedAngle < 0) normalizedAngle += 1f;
// if (normalizedAngle > 1) normalizedAngle -= 1f;
//
// uvCache.Add(new Vector2(normalizedDist, normalizedAngle));
}
}
private void GetNormalizedAngleByPos(float angleStep, int count, out float normalizedAngle)
{
float angleDeg = startAngle + count * angleStep;
normalizedAngle = (angleDeg + 90f) / 360f;
if (normalizedAngle < 0) normalizedAngle += 1f;
if (normalizedAngle > 1) normalizedAngle -= 1f;
}
#if UNITY_EDITOR
protected override void OnValidate()
{
base.OnValidate();
if (sides < 3) sides = 3;
if (scale <= float.Epsilon) scale = float.Epsilon;
SetVerticesDirty();
BorderThickness = borderThickness;
BorderColor = borderColor;
BorderColorLinear = borderColor2;
FillColor = fillColor;
}
#endif
}
}
Runtime/Pattern/UIPatternRenderer.cs.meta
+3
View File
@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: eada6ed68c1a4d4f80a267cc56ee40d9
timeCreated: 1774341380
Runtime/Pattern/XericRendererComponent.cs
+175
View File
@@ -0,0 +1,175 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Pool;
using UnityEngine.UI;
namespace XericLibrary.Runtime.UIGraph
{
/// <summary>
/// 自定义渲染组件
/// </summary>
[RequireComponent(typeof(CanvasRenderer))]
public class XericRendererComponent : MaskableGraphic
{
public virtual string ShaderName => "Hidden/Texture2D";
#region 字段属性
// 原始数据
private readonly List<UIVertex> _vertexList = new List<UIVertex>();
private readonly List<int> _indexList = new List<int>();
// 阵列原点
private List<Vector4> _arrayTransformList = new List<Vector4>();
// 中间数据
private List<UIVertex> _temp_vertexList = new List<UIVertex>();
private List<int> _temp_indexList = new List<int>();
private bool _dirty;
#endregion
#if UNITY_EDITOR
protected override void OnValidate()
{
base.OnValidate();
if (m_Material == null)
material = new Material(Shader.Find(ShaderName));
}
#endif
#region 绘制
/// <summary>
/// 刷新
/// </summary>
public virtual void Refresh()
{
SetVerticesDirty();
}
/// <summary>
/// ui模型填充流程
/// </summary>
/// <param name="vh"></param>
protected override void OnPopulateMesh(VertexHelper vh)
{
if (vh == null) return;
vh.Clear();
ClearCache();
// 填充图元
OnPopulatePrefabricateVertex(_vertexList, _indexList);
// 阵列
ArrayVertexList(_arrayTransformList);
// 将顶点填充到mesh
vh.AddUIVertexStream(_temp_vertexList, _temp_indexList);
}
/// <summary>
/// 填充预制顶点
/// </summary>
/// <param name="vertexList">顶点列表</param>
/// <param name="indexList">三角面索引</param>
protected virtual void OnPopulatePrefabricateVertex(List<UIVertex> vertexList, List<int> indexList)
{
}
/// <summary>
/// 清除所有缓存
/// </summary>
protected void ClearCache()
{
_vertexList.Clear();
_indexList.Clear();
}
/// <summary>
/// 添加一个阵列节点
/// </summary>
/// <param name="offset">偏移</param>
/// <param name="angle">角度</param>
public int AddArrayModifier(Vector3 offset, float angle)
{
var index = _arrayTransformList.Count;
_arrayTransformList.Add(new Vector4(offset.x, offset.y, offset.z, angle));
Refresh();
return index;
}
/// <summary>
/// 清空阵列节点
/// </summary>
public void ClearArrayModifier()
{
_arrayTransformList.Clear();
Refresh();
}
public bool ModifyArrayModifier(int index, Vector3 offset, float angle)
{
if (index < 0 || index >= _arrayTransformList.Count)
return false;
_arrayTransformList[index] = new Vector4(offset.x, offset.y, offset.z, angle);
Refresh();
return true;
}
#endregion
#region 阵列
/// <summary>
/// 根据原点阵列
/// </summary>
/// <param name="vh"></param>
/// <param name="trans"></param>
protected void ArrayVertexList(List<Vector4> trans)
{
_temp_vertexList.Clear();
_temp_indexList.Clear();
if (trans == null || trans.Count == 0)
{
Copy();
return;
}
for (int i = 0; i < trans.Count; i++)
Copy2(i, trans[i]);
void Copy()
{
_temp_vertexList.AddRange(_vertexList.GetRange(0, _vertexList.Count));
_temp_indexList.AddRange(_indexList.GetRange(0, _indexList.Count));
}
void Copy2(int index, Vector4 transform)
{
_temp_vertexList.AddRange(_vertexList.Select(a =>
{
var newPos = a.position;
if (transform.w != 0)
{
var rot = Quaternion.Euler(0, 0, transform.w);
newPos = rot * newPos;
}
newPos += (Vector3)transform;
return new UIVertex()
{
position = newPos,
normal = a.normal,
tangent = a.tangent,
color = a.color,
uv0 = a.uv0,
uv1 = a.uv1,
uv2 = a.uv2,
uv3 = a.uv3,
};
}));
_temp_indexList.AddRange(_indexList.Select(a => index * _vertexList.Count + a));
}
}
#endregion
}
}
Runtime/Pattern/XericRendererComponent.cs.meta
+3
View File
@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 69b796bc59d34993b4b618c67db9c388
timeCreated: 1774340572