🍣 🤘🏽 🕶️ एकता: प्रक्रियात्मक जाल संपादन 🧓🏾 💑 🕡

फ्लाई पर मॉडल को बदलना विकृतियों के भौतिकी के साथ-साथ गतिशील रूप से उत्पन्न और परिवर्तनीय सामग्री वाले खेलों में अनुकरण करने के लिए एक आम बात है। ऐसे मामलों में, प्रक्रियात्मक संपादन और ज्यामिति बनाने के तरीकों को लागू करना सुविधाजनक है। उत्तरार्द्ध अक्सर नेटवर्क से डाउनलोड किए गए डेटा को संचारित करते समय पोषित बाइट को बचाने की अनुमति देता है। इसके अलावा, यह मजेदार है!

लेख का उद्देश्य एकता में मेषों के प्रक्रियात्मक प्रसंस्करण के कौशल को पंप करना है। हम एक जाल के हिस्सों को बदलने और उत्पन्न करने के संचालन के बारे में बात करेंगे।

3 डी मॉडल के प्रक्रियात्मक संपादन के लिए हमारी सज्जनतापूर्ण किट में तीन बुनियादी संचालन शामिल हैं: त्रिकोणासन, बिंदुओं की गति, बाहर निकालना। हम पिछले दो के बारे में विस्तार से बात करेंगे। सबसे पहले, सबसे सरल गति के संचालन पर विचार करें - चलती कोने, घूर्णन और स्केलिंग किनारों और त्रिकोण। फिर हम नई ज्यामिति पैदा करने के लिए एक तरीके से निपटेंगे - एक्सट्रूड ऑपरेशन।

पिछले प्रकाशन में, हमने 3D मॉडल के डेटा के साथ सुविधाजनक कार्य के लिए हमारी संरचना का वर्णन किया था।

संरचना कोड

public static class CustomMeshPool { private static List<CustomMesh> Pool; private static int pointer; public static CustomMesh GetMesh(int id) { return Pool[id]; } public static int Push(CustomMesh customMesh) { if (Pool == null) Pool = new List<CustomMesh>(); pointer = GetAvailableIndex(); if (pointer < Pool.Count) Pool[pointer] = customMesh; else Pool.Add(customMesh); return pointer; } public static bool Remove(int index) { if (Pool == null) return false; var b = Pool[index] == null; Pool[index] = null; return b; } public static int GetAvailableIndex() { if (Pool == null) return 0; var availableIndex = Pool.FindIndex(mesh => mesh == null); return availableIndex != -1 ? availableIndex : Pool.Count; } public static void Flush() { if (Pool != null) Pool.Clear(); } } public class CustomMesh { public int Id; public Triangle[] Triangles; public Vector3[] vertices; public Vector3[] normals; public Vector2[] uv0, uv2; public Color[] colors; public CustomMesh(Vector3[] vertices, int[] triangles, Vector3[] normals, Vector2[] uv0, Vector2[] uv2, Color[] colors) { this.vertices = vertices; this.normals = normals; if (normals != null) for (var i = 0; i < this.normals.Length; i++) { this.normals[i] = this.normals[i].normalized; } this.uv0 = uv0; this.uv2 = uv2; this.colors = colors; var ptr = CustomMeshPool.GetAvailableIndex(); CustomMeshPool.Push(this); Id = ptr; Triangles = new Triangle[triangles.Length / 3]; Triangles = Triangles .AsParallel() .Select((t, i) => new Triangle(ptr, i, triangles[i * 3], triangles[i * 3 + 1], triangles[i * 3 + 2])) .ToArray(); } } public struct Triangle { private int _index; public int Index { get { return _index; } set { _index = value; if (_edges != null) { _edges[0].TriangleIndex = value; _edges[1].TriangleIndex = value; _edges[2].TriangleIndex = value; } } } private int _meshId; public int MeshId { get { return _meshId; } internal set { _meshId = value; } } private Edge[] _edges; public Edge[] Edges { get { return _edges; } set { if (value.Length == 3) { _edges = value; for (var i = 0; i < 3; i++) { _edges[i].TriangleIndex = _index; } } else throw new IndexOutOfRangeException(); } } public Vertex V0 { get { return Edges[0].v0; } set { if (value.MeshId != MeshId) throw new Exception("Not the same mesh"); Edges[0].v0 = value; Edges[2].v1 = value; } } public Vertex V1 { get { return Edges[1].v0; } set { if (value.MeshId != MeshId) throw new Exception("Not the same mesh"); Edges[1].v0 = value; Edges[0].v1 = value; } } public Vertex V2 { get { return Edges[2].v0; } set { if (value.MeshId != MeshId) throw new Exception("Not the same mesh"); Edges[2].v0 = value; Edges[1].v1 = value; } } public Triangle(int meshId, int index, int v0, int v1, int v2) { _index = index; _meshId = meshId; var edges = new Edge[3]; edges[0] = new Edge(meshId, index, v0, v1); edges[1] = new Edge(meshId, index, v1, v2); edges[2] = new Edge(meshId, index, v2, v0); _edges = edges; } } public struct Edge { public Vertex v0; public Vertex v1; private int _meshId; public int MeshId { get { return _meshId; } internal set { _meshId = value; } } private int _triangleIndex; public int TriangleIndex { get { return _triangleIndex; } internal set { _triangleIndex = value; } } public Edge(int meshId, int triangleIndex, int v0Index, int v1Index) { _meshId = meshId; _triangleIndex = triangleIndex; v0 = new Vertex() { MeshId = meshId, Index = v0Index }; v1 = new Vertex() { MeshId = meshId, Index = v1Index }; } } public struct Vertex { public int Index; private int _meshId; public int MeshId { get { return _meshId; } internal set { _meshId = value; } } public Vector3 position { get { return CustomMeshPool.GetMesh(_meshId).vertices[Index]; } set { CustomMeshPool.GetMesh(_meshId).vertices[Index] = value; } } public Vector3 normal { get { return CustomMeshPool.GetMesh(_meshId).normals[Index]; } set { CustomMeshPool.GetMesh(_meshId).normals[Index] = value; } } public Vector2 uv0 { get { return CustomMeshPool.GetMesh(_meshId).uv0[Index]; } set { CustomMeshPool.GetMesh(_meshId).uv0[Index] = value; } } public Vector2 uv2 { get { return CustomMeshPool.GetMesh(_meshId).uv2[Index]; } set { CustomMeshPool.GetMesh(_meshId).uv2[Index] = value; } } public Color color { get { return CustomMeshPool.GetMesh(_meshId).colors[Index]; } set { CustomMeshPool.GetMesh(_meshId).colors[Index] = value; } } }

जैसा कि आप देख सकते हैं, यहां PLINQ का उपयोग किया जाता है। ऐसा इसलिए है क्योंकि कम्प्यूटेशनल ज्यामिति एल्गोरिदम को अक्सर मल्टीथ्रेडिंग के माध्यम से अनुकूलित किया जा सकता है।
बेशक, LINQ कंस्ट्रक्शंस के निष्पादन के दौरान अधिक LINQ कंस्ट्रक्शन बनाए जाते हैं, जब "मैनुअल" कोड निष्पादित किया जाता है। हालांकि, इस तरह के डिजाइनों की संक्षिप्तता के साथ-साथ PLINQ में अंतर्निहित संसाधन प्रबंधन उपकरणों की उपस्थिति से यह कमी काफी हद तक दूर होती है। इसके अलावा, एकल-थ्रेडेड और बहु-थ्रेडेड कार्यान्वयन के बीच संक्रमण केवल एक कमांड के साथ किया जाता है, जो डिबगिंग प्रक्रिया को बहुत सुविधाजनक बनाता है।

मैं घुमाता हूं, मरोड़ता हूं, भ्रमित करना चाहता हूं

हम आंदोलन के संचालन के लिए आगे बढ़ते हैं। हिलते हुए सिरों के बारे में कुछ भी जटिल नहीं है। बस संयोग की चोटियों के बारे में मत भूलना: यदि आवश्यक हो, तो उनकी स्थिति भी बदलनी चाहिए।

एल्गोरिथ्म को शीर्ष स्थिति में एक गति वेक्टर जोड़कर कार्यान्वित किया जाता है। यह बदलाव मॉडल की उत्पत्ति ( धुरी ) के सापेक्ष होता है। यह ध्यान देने योग्य है कि ऐसे परिवर्तनों के दौरान बहुभुज की स्थिति बदल सकती है, लेकिन उनके कोने के मानदंड नहीं हो सकते। हालांकि, प्रस्तुति को आसान बनाने के लिए, हम इस बारीकियों पर विचार नहीं करेंगे।

सीएडी टूल्स में पुनर्गणना मानदंडों के लिए एक फ़ंक्शन है, जिसे आमतौर पर आवश्यक परिवर्तनों को लागू करने के बाद कहा जाता है। इस आवंटन को करने के विभिन्न तरीके हैं। सबसे आम प्रत्येक त्रिकोण के विमान के लिए सामान्य की गणना करता है, और फिर प्रत्येक शीर्ष के लिए एक सामान्य असाइन करता है त्रिकोण के मानदंडों के औसत के रूप में जो इस शीर्ष से संबंधित है।

सामान्य तौर पर, कोड को जटिल करने और परिवर्तन मैट्रिक्स को लागू करने का कोई अच्छा कारण नहीं है। एक गति वेक्टर को शीर्ष स्थिति में जोड़ने का परिणाम इसके आंदोलन के एक सहज विचार से मेल खाता है।

एक शीर्ष को स्थानांतरित करने के लिए लिस्टिंग के तरीके

 public struct Vertex { ... public void Translate(Vector3 movement, bool withCoincident = false) { var newPosition = position + movement; if (withCoincident) { var vertices = CustomMeshPool.GetMesh(_meshId).vertices; var mask = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(position); for (int i = 0; i < vertices.Length; i++) if (mask[i]) vertices[i] = newPosition; } else { position = newPosition; } } } public class CustomMesh { … public bool[] GetVerticesInPosition(Vector3 position) { bool[] buffer = new bool[vertices.Length]; for (int i = 0; i < buffer.Length; i++) { buffer[i] = Mathf.Abs(position.x - vertices[i].x) < Mathf.Epsilon && Mathf.Abs(position.y - vertices[i].y) < Mathf.Epsilon && Mathf.Abs(position.z - vertices[i].z) < Mathf.Epsilon; } return buffer; } }

किनारों और त्रिकोणों के आंदोलन को उसी तरह से लागू किया जाता है - एक विस्थापन वेक्टर को जोड़कर।

अभी भी जिफ हैं

त्रिकोण और किनारों को स्थानांतरित करने के लिए लिस्टिंग के तरीके

 public struct Edge { … public void Translate(Vector3 movement, bool withCoincident = false) { if (withCoincident) { var vertices = CustomMeshPool.GetMesh(MeshId).vertices; var newV0Position = v0.position + movement; var newV1Position = v1.position + movement; var maskV0 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v0.position); var maskV1 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v1.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; } } else { v0.Translate(movement); v1.Translate(movement); } } } public struct Triangle { … public void Translate(Vector3 movement, bool withCoincident = false) { if (withCoincident) { var vertices = CustomMeshPool.GetMesh(_meshId).vertices; var newV0Position = V0.position + movement; var newV1Position = V1.position + movement; var newV2Position = V2.position + movement; var maskV0 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V0.position); var maskV1 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V1.position); var maskV2 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V2.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; else if (maskV2[i]) vertices[i] = newV2Position; } } else { V0.Translate(movement); V1.Translate(movement); V2.Translate(movement); } } }

लेकिन ट्रांसफॉर्मेशन मैट्रिक्स का उपयोग करके इसे घुमाना और स्केल करना अधिक सुविधाजनक है। मॉडल के निर्देशांक की उत्पत्ति के सापेक्ष इन ऑपरेशनों को करने का परिणाम सबसे अधिक संभावना है कि आप क्या चाहते थे या देखना चाहते थे। रोटेशन और स्केलिंग का संदर्भ बिंदु आमतौर पर वस्तु के मध्य के रूप में लिया जाता है - मनुष्यों के लिए सबसे अधिक समझ में आता है।

GIFs के बहुत सारे

त्रिकोण और किनारों को घुमाने और स्केल करने की विधियां सूचीबद्ध करना

 public struct Edge { … public void Rotate(Quaternion rotation, bool withCoincident = false) { var pivot = (v0.position + v1.position) * 0.5f; var matrix = Matrix4x4.TRS(pivot, rotation, Vector3.one); var newV0Position = matrix.MultiplyPoint(v0.position - pivot); var newV1Position = matrix.MultiplyPoint(v1.position - pivot); if (withCoincident) { var vertices = CustomMeshPool.GetMesh(MeshId).vertices; var maskV0 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v0.position); var maskV1 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v1.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; } } else { v0.position = newV0Position; v1.position = newV1Position; } } public void Scale(Vector3 scale, bool withCoincident = false) { var pivot = (v0.position + v1.position) * 0.5f; var matrix = Matrix4x4.TRS(pivot, Quaternion.identity, scale); var newV0Position = matrix.MultiplyPoint(v0.position - pivot); var newV1Position = matrix.MultiplyPoint(v1.position - pivot); if (withCoincident) { var vertices = CustomMeshPool.GetMesh(MeshId).vertices; var maskV0 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v0.position); var maskV1 = CustomMeshPool.GetMesh(MeshId).GetVerticesInPosition(v1.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; } } else { v0.position = newV0Position; v1.position = newV1Position; } } } public struct Triangle { … public void Rotate(Quaternion rotation, bool withCoincident = false) { var pivot = (V0.position + V1.position + V2.position) / 3; var matrix = Matrix4x4.TRS(Vector3.zero, rotation, Vector3.one); var newV0Position = matrix.MultiplyPoint(V0.position - pivot) + pivot; var newV1Position = matrix.MultiplyPoint(V1.position - pivot) + pivot; var newV2Position = matrix.MultiplyPoint(V2.position - pivot) + pivot; if (withCoincident) { var vertices = CustomMeshPool.GetMesh(_meshId).vertices; var maskV0 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V0.position); var maskV1 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V1.position); var maskV2 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V2.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; else if (maskV2[i]) vertices[i] = newV2Position; } } else { Edges[0].v0.position = newV0Position; Edges[1].v0.position = newV1Position; Edges[2].v0.position = newV2Position; } Edges[0].v0.normal = matrix.MultiplyPoint(V0.normal); Edges[1].v0.normal = matrix.MultiplyPoint(V1.normal); Edges[2].v0.normal = matrix.MultiplyPoint(V2.normal); } public void Scale(Vector3 scale, bool withCoincident = false) { var pivot = (V0.position + V1.position + V2.position) / 3; var matrix = Matrix4x4.TRS(pivot, Quaternion.identity, scale); var newV0Position = matrix.MultiplyPoint(V0.position - pivot); var newV1Position = matrix.MultiplyPoint(V1.position - pivot); var newV2Position = matrix.MultiplyPoint(V2.position - pivot); if (withCoincident) { var vertices = CustomMeshPool.GetMesh(_meshId).vertices; var maskV0 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V0.position); var maskV1 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V1.position); var maskV2 = CustomMeshPool.GetMesh(_meshId).GetVerticesInPosition(V2.position); for (int i = 0; i < vertices.Length; i++) { if (maskV0[i]) vertices[i] = newV0Position; else if (maskV1[i]) vertices[i] = newV1Position; else if (maskV2[i]) vertices[i] = newV2Position; } } else { Edges[0].v0.position = newV0Position; Edges[1].v0.position = newV1Position; Edges[2].v0.position = newV2Position; } } }

खुद के लिए एक साफ सुथरा छेद

3 डी मॉडलिंग में, अक्सर एक अतिरिक्त ऑपरेशन का उपयोग किया जाता है। इसके कार्यान्वयन के लिए, गति वेक्टर (विस्थापन) और बहुभुज के सेट को ज्ञात होना चाहिए। बाहर निकालना प्रक्रिया दो चरणों में विघटित हो सकती है:

1. किसी दिए गए मोशन वेक्टर ( ऑफसेट ) द्वारा बहुभुज की ऑफसेट । इस मामले में, सीमा बहुभुज द्वारा अलग किए गए कोने को डुप्लिकेट करना आवश्यक है ताकि उन तत्वों की स्थिति को परेशान न करें जो विस्थापित भाग से संबंधित नहीं हैं। दूसरे शब्दों में, आपको चयनित टुकड़े को फाड़ने और स्थानांतरित करने की आवश्यकता है। यदि यह कदम पहले पूरा हो जाता है, तो मॉडल संभवतः उन टुकड़ों में गिर जाएगा जिन्हें भविष्य में शामिल होना होगा।

2. विस्थापित हिस्से की सीमा और बाहर निकलने के दौरान बनने वाली सीमा के बीच नई ज्यामिति जोड़ना। मॉडल के मुख्य और स्थानांतरित भागों के बीच की खाई एक दीवार बनाने वाले बहुभुज से भरी हुई है।

कार्यान्वयन में, पहले दीवार का निर्माण करना अधिक सुविधाजनक है, क्योंकि पारी से पहले हमारे पास सीमा पर किनारों की प्रारंभिक स्थिति है और हम तुरंत इस डेटा का उपयोग कर सकते हैं। अन्यथा, आपको या तो शीयर वेक्टर की दिशा को पलटना होगा, या मेष की प्रारंभिक स्थिति के बारे में कुछ जानकारी को सहेजना होगा।

जिस मॉडल और उसके हिस्सों के साथ हम काम करते हैं, वे जोड़ीदार आसन्न बहुभुज (त्रिकोण) के सेट से बने होते हैं। हम ऐसे प्रत्येक सेट को एक क्लस्टर कहते हैं ।

ब्लेंडर में दो समर्पित क्लस्टर

सबसे पहले, हमें उन सभी किनारों के किनारों को प्राप्त करने की आवश्यकता है जो चयनित समूहों को बांधते हैं। ऐसा करने के लिए, बस किनारों को सूची में क्रमिक रूप से जोड़ें। यदि एक मिलान किनारे पाया जाता है, तो इसे वर्तमान को जोड़ने के बिना हटा दिया जाना चाहिए। इस तरह के एक एल्गोरिथ्म के सही संचालन के लिए, प्रतिबंध लागू करना आवश्यक है: त्रिकोण के चयनित सेट पर, दो संयोग वाले किनारों से अधिक नहीं हैं। ऐसे मामलों में जहां एक्सट्रूड का उपयोग किया जाता है, मॉडल अक्सर इस स्थिति को संतुष्ट करते हैं, और अधिक जटिल एल्गोरिथ्म के लिए बड़े कम्प्यूटेशनल संसाधनों की आवश्यकता होती है।

किनारों को सम्‍मिलित करने की विधियां सूचीबद्ध करना

 internal static class LinkedListExtension { internal static IEnumerable<LinkedListNode<T>> Nodes<T>(this LinkedList<T> list) { for (var node = list.First; node != null; node = node.Next) { yield return node; } } } public struct Vertex { … public bool IsInPosition(Vector3 other) { return Mathf.Abs(position.x - other.x) < Mathf.Epsilon && Mathf.Abs(position.y - other.y) < Mathf.Epsilon && Mathf.Abs(position.z - other.z) < Mathf.Epsilon; } } public struct Edge { … public bool Coincides(Edge other, bool includeDirection = false) { return v0.IsInPosition(other.v0.position) && v1.IsInPosition(other.v1.position) || !includeDirection && v1.IsInPosition(other.v0.position) && v0.IsInPosition(other.v1.position); } } public class CustomMesh { … private LinkedList<Edge> ObtainHullEdges(int[] triIndices) { var edges = new LinkedList<Edge>(); for (var i = 0; i < triIndices.Length; i++) { var edge = edges.Nodes().FirstOrDefault(e => e.Value.Coincides(Triangles[triIndices[i]].Edges[0])); if (edge != null) edges.Remove(edge); else edges.AddFirst(Triangles[triIndices[i]].Edges[0]); edge = edges.Nodes().FirstOrDefault(e => e.Value.Coincides(Triangles[triIndices[i]].Edges[1])); if (edge != null) edges.Remove(edge); else edges.AddFirst(Triangles[triIndices[i]].Edges[1]); edge = edges.Nodes().FirstOrDefault(e => e.Value.Coincides(Triangles[triIndices[i]].Edges[2])); if (edge != null) edges.Remove(edge); else edges.AddFirst(Triangles[triIndices[i]].Edges[2]); } return edges; } }

समोच्च के सभी किनारों को प्राप्त करने के बाद, आपको संबंधित दीवारों का निर्माण करने की आवश्यकता है। कार्यान्वयन के लिए कई विकल्प हैं, लेकिन हमने कम से कम प्रतिरोध का रास्ता तय किया - अलग-अलग किनारों पर स्थित गति वेक्टर की दिशा में समांतर चतुर्भुज उत्पन्न करें। चूंकि हम सभी का एक विस्थापन है, इस क्रिया के परिणामस्वरूप, समांतर चतुर्भुज प्रत्येक क्लस्टर के लिए एक ठोस और बंद दीवार बनाएंगे। यह दीवार तत्वों के उन्मुखीकरण को निर्धारित करने के लिए बनी हुई है।

दीवार, पूरे जाल की तरह, त्रिकोण के होते हैं। OpenGL कन्वेंशन के अनुसार, एक अलग त्रिकोण स्क्रीन पर प्रदान किया जाता है, अगर स्क्रीन प्लेन पर उसके बिंदुओं को प्रोजेक्ट करते समय, उनके चारों ओर घूमना, दक्षिणावर्त घूमना मेल खाता है:

तो, एक त्रिकोण एक निश्चित सामान्य वेक्टर से मेल खाता है जो सामने की तरफ को परिभाषित करता है। प्रत्येक त्रिभुज तीन किनारों से मिलकर एक उत्तल समोच्च से घिरा होता है। प्रत्येक किनारे में v0 और v1 के रूप में हमारी संरचना में प्रतिनिधित्व किए गए दो कोने हैं। हम किनारे की दिशा को परिभाषित करते हैं ताकि v0 शुरुआत हो, v1 अंत हो। अब, यदि त्रिभुज के किनारों की दिशा इसके शीर्ष रेखाओं के अनुरेखण के अनुसार निर्धारित की जाती है, तो क्लस्टर के किसी भी बाहरी समोच्च में घड़ी या वामावर्त या तो किसी भी विपरीत दिशा में होना चाहिए, और किसी भी आंतरिक समोच्च को उल्टा होना चाहिए। हमने CustomMesh और त्रिभुज निर्माणकर्ताओं को लागू किया ताकि सभी त्रिभुजों के वर्टीकल का घुमाव घड़ी की दिशा से मेल खाता हो।

समोच्च को दरकिनार करने की दिशा में होने पर, हम यह सुनिश्चित कर सकते हैं कि पसली का कौन सा हिस्सा समोच्च का आंतरिक भाग है, और जो बाहरी है। इस जानकारी के आधार पर, हम दीवार के उन्मुखीकरण का चयन करेंगे। आज्ञा देना ( v0, v1 ) वह किनारा होना चाहिए जिसके आधार पर वांछित समांतरलोग्राम उत्पन्न किया जाना चाहिए। हम ऑफ़सेट पदों v0 और v1 के रूप में दो अंक v2 और v3 लेते हैं। फिर हम निम्नलिखित योजना के अनुसार दो त्रिकोण बनाते हैं:

और इसलिए समोच्च के प्रत्येक किनारे के लिए।

किनारों की सूची का उपयोग करके दीवारों के निर्माण के लिए एक विधि सूचीबद्ध करना

 public class CustomMesh { … private void ExtrudeEdgesSet(Edge[] edges, Vector3 offset) { if (offset == Vector3.zero || edges == null || edges.Length == 0) return; var initVerticesLength = vertices.Length; Array.Resize(ref vertices, initVerticesLength + edges.Length * 4); if (normals != null && normals.Length == initVerticesLength) { Array.Resize(ref normals, vertices.Length); } if (uv0 != null && uv0.Length == initVerticesLength) { Array.Resize(ref uv0, vertices.Length); } if (uv2 != null && uv2.Length == initVerticesLength) { Array.Resize(ref uv2, vertices.Length); } if (colors != null && colors.Length == initVerticesLength) { Array.Resize(ref colors, vertices.Length); } var initTrianglesLength = Triangles.Length; Array.Resize(ref Triangles, initTrianglesLength + edges.Length * 2); edges .AsParallel() .Select((edge, i) => { int j = initVerticesLength + i * 4; vertices[j] = edge.v0.position; vertices[j + 1] = edge.v1.position; vertices[j + 2] = edge.v0.position + offset; vertices[j + 3] = edge.v1.position + offset; if (normals != null && normals.Length == vertices.Length) { var normal = Vector3.Cross(vertices[j + 1] - vertices[j], offset); normals[j] = normals[j + 1] = normals[j + 2] = normals[j + 3] = normal; } if (uv0 != null && uv0.Length == vertices.Length) { uv0[j] = uv0[j + 2] = edge.v0.uv0; uv0[j + 1] = uv0[j + 3] = edge.v1.uv0; } if (uv2 != null && uv2.Length == vertices.Length) { uv2[j] = uv2[j + 2] = edge.v0.uv2; uv2[j + 1] = uv2[j + 3] = edge.v1.uv2; } if (colors != null && colors.Length == vertices.Length) { colors[j] = colors[j + 2] = edge.v0.color; colors[j + 1] = colors[j + 3] = edge.v1.color; } Triangles[initTrianglesLength + i * 2] = new Triangle( initTrianglesLength + i * 2, Id, j, j + 1, j + 2 ); Triangles[initTrianglesLength + i * 2 + 1] = new Triangle( initTrianglesLength + i * 2 + 1, Id, j + 3, j + 2, j + 1 ); return true; }).ToArray(); } }

इस दृष्टिकोण के साथ, उत्पन्न दीवारों के सामने की ओर स्लाइड और गड्ढों के लिए सही होगी। केवल एक महत्वपूर्ण सीमा है: त्रिकोण का सेट, जिस पर एक्सट्रूड ऑपरेशन किया जाता है, गति वेक्टर के संबंध में स्वयं के चारों ओर लपेटा नहीं जाना चाहिए।

बहुभुज का एक सबसेट जो ऑफसेट के संबंध में अमान्य है। इस तरह के एक एक्सट्रूड के साथ ब्लेंडर में भी, ज्यामिति वक्र से बचना संभव नहीं होगा।

बहुभुज के मान्य सबसेट

दीवार तैयार है, यह त्रिकोणों को स्थानांतरित करने के लिए बनी हुई है। एल्गोरिथ्म के इस चरण को समझना आसान है, हालांकि कार्यान्वयन बोझिल हो गया।

हमारे मामले में, हमें यह सुनिश्चित करने की आवश्यकता है कि क्लस्टर के प्रत्येक शीर्ष केवल उसके त्रिकोण के हैं। यदि शर्त पूरी नहीं होती है, तो कुछ पड़ोसी बहुभुज क्लस्टर के लिए पहुंच सकते हैं। इस स्थिति का समाधान प्रत्येक शीर्ष को डुप्लिकेट करना है जो क्लस्टर और बाकी मॉडल दोनों से संबंधित है। फिर, क्लस्टर में सभी बहुभुजों के लिए, इस शीर्ष के सूचकांक को डुप्लिकेट इंडेक्स से बदलें। जब स्थिति संतुष्ट हो जाती है, तो हम क्लस्टर के सभी कोने को गति वेक्टर में स्थानांतरित करते हैं।

बहुभुज के एक क्लस्टर को स्थानांतरित करने के लिए एक विधि सूचीबद्ध करना

 public class CustomMesh { … private void TranslateTrianglesHard(int[] triIndices, Vector3 offset, int[] hullVerts) { var newVertexIndices = new Dictionary<int, int>(); var initVerticesCount = vertices.Length; Triangles.Where((t, i) => !triIndices.Contains(i)).Select(t => { if (hullVerts.Contains(t.V0.Index) && !newVertexIndices.ContainsKey(t.V0.Index)) newVertexIndices.Add(t.V0.Index, initVerticesCount + newVertexIndices.Count); if (hullVerts.Contains(t.V1.Index) && !newVertexIndices.ContainsKey(t.V1.Index)) newVertexIndices.Add(t.V1.Index, initVerticesCount + newVertexIndices.Count); if (hullVerts.Contains(t.V2.Index) && !newVertexIndices.ContainsKey(t.V2.Index)) newVertexIndices.Add(t.V2.Index, initVerticesCount + newVertexIndices.Count); return false; }).ToArray(); Array.Resize(ref vertices, initVerticesCount + newVertexIndices.Count); foreach (var pair in newVertexIndices) vertices[pair.Value] = vertices[pair.Key] + offset; if (normals != null && normals.Length == initVerticesCount) { Array.Resize(ref normals, vertices.Length); foreach (var pair in newVertexIndices) normals[pair.Value] = normals[pair.Key]; } if (uv0 != null && uv0.Length == initVerticesCount) { Array.Resize(ref uv0, vertices.Length); foreach (var pair in newVertexIndices) uv0[pair.Value] = uv0[pair.Key]; } if (uv2 != null && uv2.Length == initVerticesCount) { Array.Resize(ref uv2, vertices.Length); foreach (var pair in newVertexIndices) uv2[pair.Value] = uv2[pair.Key]; } if (colors != null && colors.Length == initVerticesCount) { Array.Resize(ref colors, vertices.Length); foreach (var pair in newVertexIndices) colors[pair.Value] = colors[pair.Key]; } var alreadyMoved = new HashSet<int>(); for (var i = 0; i < triIndices.Length; i++) { if (newVertexIndices.ContainsKey(Triangles[triIndices[i]].V0.Index)) { var index = newVertexIndices[Triangles[triIndices[i]].V0.Index]; Triangles[triIndices[i]].Edges[0].v0.Index = index; Triangles[triIndices[i]].Edges[2].v1.Index = index; } else if (!alreadyMoved.Contains(Triangles[triIndices[i]].V0.Index)) { vertices[Triangles[triIndices[i]].V0.Index] += offset; alreadyMoved.Add(Triangles[triIndices[i]].V0.Index); } if (newVertexIndices.ContainsKey(Triangles[triIndices[i]].V1.Index)) { var index = newVertexIndices[Triangles[triIndices[i]].V1.Index]; Triangles[triIndices[i]].Edges[0].v1.Index = index; Triangles[triIndices[i]].Edges[1].v0.Index = index; } else if (!alreadyMoved.Contains(Triangles[triIndices[i]].V1.Index)) { vertices[Triangles[triIndices[i]].V1.Index] += offset; alreadyMoved.Add(Triangles[triIndices[i]].V1.Index); } if (newVertexIndices.ContainsKey(Triangles[triIndices[i]].V2.Index)) { var index = newVertexIndices[Triangles[triIndices[i]].V2.Index]; Triangles[triIndices[i]].Edges[1].v1.Index = index; Triangles[triIndices[i]].Edges[2].v0.Index = index; } else if (!alreadyMoved.Contains(Triangles[triIndices[i]].V2.Index)) { vertices[Triangles[triIndices[i]].V2.Index] += offset; alreadyMoved.Add(Triangles[triIndices[i]].V2.Index); } } } }

हो गया। अब, सभी चरणों के परिणामों को जोड़ते हुए, हमें एक छेद या एक पहाड़ी मिलती है।

एक्सट्रूड ऑपरेशन के लिए अंतिम विधि सूचीबद्ध करना

 public class CustomMesh { … public void ExtrudeTriangles(int[] triIndices, Vector3 offset) { var edges = ObtainHullEdges(triIndices); ExtrudeEdgesSet(edges.ToArray(), offset); var hullVertices = edges.Select(edge => edge.v0.Index).ToArray(); TranslateTrianglesHard(triIndices, offset, hullVertices); } }

बनावट स्कैन के निर्देशांक और समोच्च बिंदुओं के विस्थापन के साथ खेलने के बाद, आप इस तरह के अवकाश प्राप्त कर सकते हैं:

और यह सब नहीं है

ऊपर चर्चा किए गए संपादन कार्यों के अलावा, हम मॉडल के साथ काम करने के लिए अन्य सुविधाजनक तरीकों का भी उपयोग करते हैं।

उदाहरण के लिए, हमने अतिरिक्त रूप से दो CustomMesh को संयोजित करने के लिए Combine () विधि लिखी है। हमारे कार्यान्वयन और UnityEngine.Mesh.CombineMeshes () के बीच का महत्वपूर्ण अंतर यह है कि यदि मेषों के संयोजन के दौरान कुछ कोने पूरी तरह से बराबर हैं, तो हम उनमें से केवल एक को छोड़ देते हैं, इस प्रकार अनावश्यक ज्यामिति से बचते हैं।

उसी मॉड्यूल में, हमने Delaunay विमान त्रिकोणीय एल्गोरिथ्म को लागू किया । उदाहरण के लिए, आप इसका उपयोग कर सकते हैं, पानी के बनावट के साथ एक फ्लैट ढक्कन के साथ एक्सट्रूड का उपयोग करके बनाया गया एक बड़ा छेद बंद करें और एक झील प्राप्त करें:

खैर, इसे सुलझा लिया! अगले लेख में, हम एक परियोजना में .fbx को एकता में आयात करने और मॉडल सत्यापन के तरीकों पर विचार करेंगे।

एक नाश्ते के लिए (सिर्फ लुलज़ के लिए)

एकता: प्रक्रियात्मक जाल संपादन

मैं घुमाता हूं, मरोड़ता हूं, भ्रमित करना चाहता हूं

खुद के लिए एक साफ सुथरा छेद

और यह सब नहीं है

More articles: