[Unity] Linien zur Laufzeit erstellen (Verwendung von Bezier)
1. Ziele erreicht
Erstellen Sie im Handumdrehen eine Netzkurve, die mit Bezier-Methoden in Echtzeit bearbeitet werden kann.
2. Einführung in das Prinzip
2.1 Erstellung von Kurven
Um eine Netzkurve in Unity zu erstellen, können Sie auf die Implementierungsmethode des prozeduralen Netzes von Unity zurückgreifen . Hauptsächlich unterteilt in Eckpunkte, Dreiecke, UVs und Normalen. Der Autor hat einen ähnlichen Artikel: Pure Code Creation Method of Unity Cord Pipeline_ , in dem die Erstellungsmethode für Gitterlinien ausführlich erläutert wird. Der Unterschied besteht diesmal in der Methode zum Erstellen normaler Linien.
2.2 Festlegung von Bezier-Kurvenpunkten
Der Autor hat einen Artikel zur Erstellung einer Bezier-Kurve in Unity veröffentlicht, in dem die Erstellungsmethode von Bezier beschrieben wird.
3. Implementierungsprozess
3.1 So erstellen Sie Kurven
Prinzipien der Linienzusammensetzung
Eine Kurve besteht aus einem Querschnittskreis und einer Mittelachse. Die Normalrichtung des Querschnitts ist die Vektordifferenz zwischen den vorderen und hinteren Punkten. Die grüne Linie in der Abbildung unten ist die Mittelachse, Punkt A ist der Punkt des Querschnitts und die Normalrichtung des Querschnitts ist die Vektor AD ⃗ \vec{AD}ANZEIGE _Der Vektor CB ⃗ \vec{CB}CBDer Einheitsvektor von; die Normalenrichtung des Endpunkts und des Startpunkts ist der Vektor von sich selbst und dem vorherigen oder nächsten Punkt.
Code-Quellcode
3.1.1 Erstellung eines Querkreises
#region 横切圆创建
/// <summary>
/// 得到管线横切圆
/// </summary>
/// <param name="Count">段数</param>
/// <param name="R">半径</param>
/// <returns></returns>
Vector3[] CircularSection(int Count, float R)
{
Vector3[] vector3s = new Vector3[Count];
float angle = 360 / Count;
Vector3 vector3 = new Vector3(R, 0, 0);
for (int i = 0; i < Count; i++)
{
//根据角度得到圆的分布点
vector3s[i] = vector3.ToAngle(angle * i, Vector3.zero, Vector3.forward);
}
return vector3s;
}
#endregion
vector3-Rotationserweiterungsmethode
/// <summary>
/// 角度旋转
/// </summary>
/// <param name="vector3"></param>
/// <param name="angle">旋转角度</param>
/// <param name="center">旋转中心点</param>
/// <param name="direction">旋转轴</param>
/// <returns></returns>
public static Vector3 ToAngle(this Vector3 vector3, float angle, Vector3 center, Vector3 direction)
{
Vector3 pos = center;
Quaternion quaternion = Quaternion.AngleAxis(angle, direction);
Matrix4x4 matrix = new Matrix4x4();
matrix.SetTRS(pos, quaternion, Vector3.one);
vector3 = matrix.MultiplyPoint3x4(vector3);
return vector3;
}
3.1.2 Festlegung der Mittellinie
class LinePoint
{
Vector3 location;
Vector3 direction;
public Vector3 Location { get => location; set => location = value; }
public Vector3 Direction { get => direction; set => direction = value; }
}
/// <summary>
/// 中心线的确立
/// </summary>
/// <param name="createPoint">曲线点</param>
/// <returns></returns>
List<LinePoint> SetLinePoint(Vector3[] createPoint)
{
List<LinePoint> pipePoints = new List<LinePoint>();
int length = createPoint.Length;
for (int i = 0; i < length; i++)
{
if (i == 0)
{
Vector3 tangent = (createPoint[i + 1] - createPoint[i]).normalized;//法线
AddPipePoints(createPoint[i], tangent, ref pipePoints);
}
else if (i == length - 1)
{
Vector3 tangent = (createPoint[i] - createPoint[i - 1]).normalized;//法线
AddPipePoints(createPoint[i], tangent, ref pipePoints);
}
else
{
Vector3 tangent = (createPoint[i+1] - createPoint[i - 1]).normalized;//法线
AddPipePoints(createPoint[i], tangent, ref pipePoints);
}
}
return pipePoints;
}
/// <summary>
/// 增加中心轴线点
/// </summary>
/// <param name="location">位置</param>
/// <param name="direction">法线</param>
void AddPipePoints(Vector3 location, Vector3 direction, ref List<LinePoint> pipePoints)
{
LinePoint pipePoint = new LinePoint();
pipePoint.Location = location;
pipePoint.Direction = direction;
pipePoints.Add(pipePoint);
}
3.1.3 Rastererstellung
/// <summary>
/// 立体网格创建
/// </summary>
/// <param name="createPoint">创建的点数据</param>
/// <param name="circularCount">圆的段数</param>
/// <param name="circularR">圆的半径</param>
/// <returns></returns>
public Mesh CreateLine3D(Vector3[] createPoint, int circularCount, float circularR)
{
//截面圆
Vector3[] circul = CircularSection(circularCount, circularR);
//中心线
List<LinePoint> centreLine = SetLinePoint(createPoint);
//网格点数据
Vector3[] meshPoint = CreateMeshPoint(centreLine, circul);
float uvX = Vector3.Distance(circul[0], circul[1]);
//返回网格
return CreatMesh(centreLine, meshPoint, circul.Length, uvX);
}
/// <summary>
/// 创建网格点数据
/// </summary>
/// <param name="linePoint"></param>
/// <param name="circular"></param>
/// <returns></returns>
Vector3[] CreateMeshPoint(List<LinePoint> linePoint, Vector3[] circular)
{
int length = linePoint.Count;
int circularCount = circular.Length;
Vector3[] meshPoint = new Vector3[length * circularCount];
for (int i = 0; i < length; i++)
{
for (int j = 0; j < circularCount; j++)
{
meshPoint[(i * circularCount) + j] = circular[j].FromToMoveRotation(linePoint[i].Location, linePoint[i].Direction);
}
}
return meshPoint;
}
/// <summary>
/// 网格创建
/// </summary>
/// <param name="linePoints">线的轴心线组</param>
/// <param name="meshPoint">网格点</param>
/// <param name="count">段数</param>
/// <param name="uvX">uv宽度</param>
/// <returns></returns>
Mesh CreatMesh(List<LinePoint> linePoints, Vector3[] meshPoint, int count, float uvX)
{
Mesh mesh = new Mesh();
mesh.vertices = meshPoint;
mesh.triangles = GetTriangles(linePoints.Count, count);
mesh.uv = GetUV(linePoints, count, uvX);
mesh.RecalculateNormals();
mesh.RecalculateBounds();
return mesh;
}
/// <param name="length">线段段数</param>
/// <param name="count">横截面段数（也就是圆的段数）</param>
/// <returns></returns>
int[] GetTriangles(int length, int count)
{
int[] triangles = new int[(count * (length - 1)) * 6];
int k = 0;
if (count == 1)
{
for (int i = 0; i < length-1; i++)
{
int a = i * 2;
triangles[k] = a;
triangles[k + 1] = a + 1;
triangles[k + 2] = a + 3;
triangles[k + 3] = a;
triangles[k + 4] = a + 3;
triangles[k + 5] = a + 2;
k += 6;
}
}
else
{
for (int i = 0; i < length - 1; i++)
{
for (int j = 0; j < count; j++)
{
if (j == count - 1)
{
// Debug.Log("k=" + k);
triangles[k] = (i * count) + j;
triangles[k + 1] = (i * count) + 0;
triangles[k + 2] = ((i + 1) * count) + 0;
triangles[k + 3] = (i * count) + j;
triangles[k + 4] = ((i + 1) * count) + 0;
triangles[k + 5] = ((i + 1) * count) + j;
}
else
{
triangles[k] = (i * count) + j;
triangles[k + 1] = (i * count) + j + 1;
triangles[k + 2] = ((i + 1) * count) + j + 1;
triangles[k + 3] = (i * count) + j;
triangles[k + 4] = ((i + 1) * count) + j + 1;
triangles[k + 5] = ((i + 1) * count) + j;
}
k += 6;
}
}
}
return triangles;
}
/// <summary>
/// 创建uv
/// </summary>
/// <param name="linePoints"></param>
/// <param name="count"></param>
/// <param name="uvX"></param>
/// <returns></returns>
Vector2[] GetUV(List<LinePoint> linePoints,int count, float uvX)
{
int length = linePoints.Count;
if (count == 1) { count = 2; }
Vector2[] uvs = new Vector2[(count * length)];
float lineDis = 0;
int k = 0;
for (int i = 0; i < length; i ++)
{
if (i != 0)
{
lineDis += Vector3.Distance(linePoints[i].Location, linePoints[i - 1].Location);
}
for (int j = 0; j < count; j++)
{
Vector2 vector2;
if (j % 2 != 0)
{
vector2 = new Vector2(uvX, lineDis);
}
else
{
vector2 = new Vector2(0, lineDis);
}
uvs[k] = vector2;
k += 1;
}
}
return uvs;
}
3.2 Methode zur Erstellung der Bezier-Kurve
Quellcode
/// <summary>
/// 获取绘制点
/// </summary>
/// <param name="controlPoints"></param>
/// <param name="segmentsPerCurve"></param>
/// <returns></returns>
public List<Vector3> GetDrawingPoints(List<Vector3> controlPoints, int segmentsPerCurve)
{
List<Vector3> points = new List<Vector3>();
// 下一段的起始点和上段终点是一个，所以是 i+=3
for (int i = 0; i <= controlPoints.Count - 4; i += 3)
{
var p0 = controlPoints[i];
var p1 = controlPoints[i + 1];
var p2 = controlPoints[i + 2];
var p3 = controlPoints[i + 3];
float dis = Vector3.Distance(p0, p3);
int count = Mathf.CeilToInt(segmentsPerCurve * dis);
if (count < segmentsPerCurve)
{
count = segmentsPerCurve;
}
for (int j = 0; j <= count; j++)
{
var t = j / (float)count;
points.Add(CalculateBezierPoint(t, p0, p1, p2, p3));
}
}
return points;
}
// 三阶公式
Vector3 CalculateBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
{
Vector3 result;
Vector3 p0p1 = (1 - t) * p0 + t * p1;
Vector3 p1p2 = (1 - t) * p1 + t * p2;
Vector3 p2p3 = (1 - t) * p2 + t * p3;
Vector3 p0p1p2 = (1 - t) * p0p1 + t * p1p2;
Vector3 p1p2p3 = (1 - t) * p1p2 + t * p2p3;
result = (1 - t) * p0p1p2 + t * p1p2p3;
return result;
}
3.3 Anwendung der Bezier-Kurve
Basierend auf der obigen Methode werden die Funktionen zum Erstellen, Speichern, Lesen und Bearbeiten von Bezier implementiert.
Fall-Download-Adresse
Kurve erstellen
Kurve speichern
Es gibt zwei Speichermethoden: Langzeitspeicherung und Zwischenspeicherung. Beim Langzeitspeichern werden die gespeicherten Daten in eine lokale Datei geschrieben, die auch nach einem Neustart des Projekts gelesen werden kann; beim temporären Speichern werden die Daten während der Projektlaufzeit gespeichert und gehen nach dem Neustart verloren. Die Demo verwendet die temporäre Speichermethode
Lesen und bearbeiten
Nachdem Sie die Kurve gelesen haben, können Sie mit der Bearbeitung der aktuellen Kurve fortfahren.
Kurvendurchsuchen
