👷🏻 🔪 💨 तीन आयामी मॉडल की प्रक्रियात्मक पीढ़ी 🧒🏾 ⬛️ 🌍

प्रक्रियात्मक पीढ़ी एक अद्भुत चीज है! सबसे दिलचस्प बात ग्राफिक्स के साथ काम करना है, खासकर तीन-आयामी वाले - आप तुरंत परिणाम देख सकते हैं। बस एक-दो निर्देश पर्याप्त है कि त्रिकोण का एक बादल बनाया जाए जैसा कि ऊपर की तस्वीर में है।

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

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

त्रिकोण

आइए सबसे सरल रूप से शुरू करें - एक त्रिकोण। एकता और कई अन्य इंजन मॉडल का वर्णन करने के लिए लोकप्रिय तरीके का उपयोग करते हैं: कोने, त्रिकोण और मानदंडों के सरणियों का उपयोग करना। इसके अतिरिक्त, बनावट के uv- निर्देशांक का उपयोग बनावट के लिए किया जाता है। मॉडल के साथ काम करने के लिए, एक मेष वर्ग है, जिसमें प्रत्येक डेटा सेट के लिए एक अलग सरणी है। कोने के निर्देशांक Mesh.vertices में संग्रहीत किए जाते हैं, और तीन के समूह में कोने के सूचकांक Mesh.triangles में संग्रहीत किए जाते हैं । और Mesh.normals और Mesh.uv में सामान्य वैक्टर और यूवी मैप्स के निर्देशांक होते हैं, जिनमें से सूचकांकों को संबंधित कोने के सूचकांकों के साथ मेल खाना चाहिए, अर्थात, सरणियों में क्रम समान होना चाहिए। मैं इसे स्पष्ट करने के लिए आपको एक उदाहरण दिखाऊंगा।

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

public static Mesh Triangle(Vector3 vertex0, Vector3 vertex1, Vector3 vertex2) { var mesh = new Mesh(); mesh.vertices = new [] {vertex0, vertex1, vertex2}; mesh.triangles = new [] {0, 1, 2}; return mesh; }

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

 var normal = Vector3.Cross((vertex1 - vertex0), (vertex2 - vertex0)).normalized;

पहले, दो वैक्टर तीन बिंदुओं से बने थे, और फिर गुणा किया गया था। यह सामान्य त्रिकोण के सभी कोने पर समान होगा।

 mesh.normals = new [] {normal, normal, normal};

यह uv- निर्देशांक जोड़ने के लिए बनी हुई है, तीन कोने के लिए यह सरल है।

 mesh.uv = new [] {new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1)};

ठीक है, यह त्रिकोण तैयार है। अब इसका उपयोग किया जा सकता है।

त्रिकोण

 public static Mesh Triangle(Vector3 vertex0, Vector3 vertex1, Vector3 vertex2) { var normal = Vector3.Cross((vertex1 - vertex0), (vertex2 - vertex0)).normalized; var mesh = new Mesh { vertices = new [] {vertex0, vertex1, vertex2}, normals = new [] {normal, normal, normal}, uv = new [] {new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1)}, triangles = new [] {0, 1, 2} }; return mesh; }

चतुष्कोष

त्रिकोण के अलावा, मॉडलिंग के लिए एक और लोकप्रिय आदिम है - अगर आपको यह पसंद है तो एक चतुर्भुज, कुआं या एक ट्रैक्टर।

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

मैं आपको याद दिलाता हूं कि कोने अभी भी दक्षिणावर्त लिखे गए हैं।

चतुष्कोष

 public static Mesh Quad(Vector3 origin, Vector3 width, Vector3 length) { var normal = Vector3.Cross(length, width).normalized; var mesh = new Mesh { vertices = new[] { origin, origin + length, origin + length + width, origin + width }, normals = new[] { normal, normal, normal, normal }, uv = new[] { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) }, triangles = new[] { 0, 1, 2, 0, 2, 3} }; return mesh; }

अब जबकि हमारे पास दो बुनियादी आदिम हैं, हम किसी भी मॉडल का निर्माण कर सकते हैं।

विमान

हम एक विमान के उदाहरण का उपयोग करके मॉडल की विधानसभा के साथ प्रयोग करेंगे। बहुत सारे वर्ग लें और संयुक्त को संयुक्त में विस्तारित करें।

आलस्य प्रगति का इंजन है, इसलिए हम मॉडल में वर्गों को इकट्ठा करने के लिए Mesh.CombineMeshes का उपयोग करेंगे। यह विधि एक इनपुट के रूप में CombineInstance संरचना को लेती है, जिसमें आप मॉडल, इसके सूचकांक और परिवर्तन मैट्रिक्स को निर्दिष्ट कर सकते हैं। हमारे लिए, केवल पहला महत्वपूर्ण है; हम बाकी को अनदेखा करते हैं।

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

विमान

 public static Mesh Plane(Vector3 origin, Vector3 width, Vector3 length, int widthCount, int lengthCount) { var combine = new CombineInstance[widthCount * lengthCount]; var i = 0; for (var x = 0; x < widthCount; x++) { for (var y = 0; y < lengthCount; y++) { combine[i].mesh = Quad(origin + width * x + length * y, width, length); i++; } } var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

समानांतर खात

एक विमान पर टाइल बिछाने बहुत आसान है, तीसरे आयाम पर जाने का समय है।

वर्गों से, क्यूब्स अच्छी तरह से काम करते हैं। इससे भी बेहतर, हमारे छद्म की मदद से आप न केवल क्यूब्स बना सकते हैं, बल्कि समानताएं भी बना सकते हैं। केवल शाह! किसी को बताना मत।

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

समानांतर खात

 public static Mesh Cube(Vector3 width, Vector3 length, Vector3 height) { var corner0 = -width/2 - length/2 - height/2; var corner1 = width/2 + length/2 + height/2; var combine = new CombineInstance[6]; combine[0].mesh = Quad(corner0, length, width); combine[1].mesh = Quad(corner0, width, height); combine[2].mesh = Quad(corner0, height, length); combine[3].mesh = Quad(corner1, -width, -length); combine[4].mesh = Quad(corner1, -height, -width); combine[5].mesh = Quad(corner1, -length, -height); var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

octahedron

ऑक्टाहेड्रॉन एक घन की तरह है, इसके कोने की गणना करना बहुत आसान है, सबसे बड़ी कठिनाई त्रिकोण में कोने के क्रम का पता लगाना है। ऑक्टाहेड्रोन गोले में फिट बैठता है, इसलिए यह इस क्षेत्र के त्रिज्या के साथ इसे बनाने के लिए समझ में आता है। सभी कोने प्राथमिक रूप से बनाए गए हैं, इसलिए मैं यहां नहीं रुकता

octahedron

 public static Mesh Octahedron(float radius) { //  var v0 = new Vector3(0, -radius, 0); //   var v1 = new Vector3(-radius, 0, 0); var v2 = new Vector3(0, 0, -radius); var v3 = new Vector3(+radius, 0, 0); var v4 = new Vector3(0, 0, +radius); //  var v5 = new Vector3(0, radius, 0); var combine = new CombineInstance[8]; combine[0].mesh = Triangle(v0, v1, v2); combine[1].mesh = Triangle(v0, v2, v3); combine[2].mesh = Triangle(v0, v3, v4); combine[3].mesh = Triangle(v0, v4, v1); combine[4].mesh = Triangle(v5, v2, v1); combine[5].mesh = Triangle(v5, v3, v2); combine[6].mesh = Triangle(v5, v4, v3); combine[7].mesh = Triangle(v5, v1, v4); var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

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

त्रिकोण में सामान्य कोने के साथ ऑक्टाहेड्रोन

 public static Mesh Octahedron(float radius) { var v = new Vector3[6]; v[0] = new Vector3(0, -radius, 0); v[1] = new Vector3(-radius, 0, 0); v[2] = new Vector3(0, 0, -radius); v[3] = new Vector3(+radius, 0, 0); v[4] = new Vector3(0, 0, +radius); v[5] = new Vector3(0, radius, 0); var mesh = new Mesh { vertices = v, triangles = new[] { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1, 5, 2, 1, 5, 3, 2, 5, 4, 3, 5, 1, 4} }; mesh.RecalculateNormals(); return mesh; }

अंत में, मैंने Mesh.RecalculateNormals लागू किया, जो स्वचालित रूप से मानदंडों की गणना करता है , यह आसान है।

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

चतुर्पाश्वीय

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

ताज़ा स्मृति? चलिए जारी रखते हैं।

हमारे टेट्राहेड्रोन को किसी एक चेहरे पर खड़े होने दें, फिर विपरीत शीर्ष को तुरंत जोड़ा जा सकता है:

 var v = new Vector3[4]; v[0] = new Vector3(0, 1, 0);

शेष कोने को एक समभुज त्रिकोण बनाना चाहिए। उनके निर्देशांक साइन और कोजाइन का उपयोग करते हुए पाए जा सकते हैं। एकता में Mathf.Sin और Mathf.Cos फ़ंक्शंस हैं , जो रेडियन में गणना करते हैं। सर्कल को तीन भागों में विभाजित करें और उस पर तीन बिंदु खोजें:

 var segmentAngle = Mathf.PI * 2 / 3; var currentAngle = 0f; for (var i = 1; i <= 3; i++) { v[i] = new Vector3(Mathf.Sin(currentAngle), 0, Mathf.Cos(currentAngle)); currentAngle += segmentAngle; }

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

 var tetrahedralAngle = Mathf.PI * 119.4712f / 180;

और पाश में:

 v[i] = new Vector3(Mathf.Sin(currentAngle) * Mathf.Sin(tetrahedralAngle), Mathf.Cos(tetrahedralAngle), Mathf.Cos(currentAngle) * Mathf.Sin(tetrahedralAngle));

इतना मुश्किल नहीं है, मुझे उम्मीद है कि हर कोई सब कुछ समझता है। स्केलिंग को जोड़ने के साथ अंत में यह कैसा दिखता है:

टेट्राहेड्रॉन अधिक जटिल है

 public static Mesh Tetrahedron(float radius) { var tetrahedralAngle = Mathf.PI * 109.4712f / 180; var segmentAngle = Mathf.PI * 2 / 3; var currentAngle = 0f; var v = new Vector3[4]; v[0] = new Vector3(0, radius, 0); for (var i = 1; i <= 3; i++) { v[i] = new Vector3(radius * Mathf.Sin(currentAngle) * Mathf.Sin(tetrahedralAngle), radius * Mathf.Cos(tetrahedralAngle), radius * Mathf.Cos(currentAngle) * Mathf.Sin(tetrahedralAngle)); currentAngle = currentAngle + segmentAngle; } var combine = new CombineInstance[4]; combine[0].mesh = Triangle(v[0], v[1], v[2]); combine[1].mesh = Triangle(v[1], v[3], v[2]); combine[2].mesh = Triangle(v[0], v[2], v[3]); combine[3].mesh = Triangle(v[0], v[3], v[1]); var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

लेकिन गणित के बिना समान टेट्राहेड्रॉन, कठोर-कोडित सिरों के साथ, अंतर महसूस करते हैं:

सरल टेट्राहेड्रॉन

 public static Mesh Tetrahedron(float radius) { var v0 = new Vector3(0, radius, 0); var v1 = new Vector3(0, -radius * 0.333f, radius * 0.943f); var v2 = new Vector3(radius * 0.816f, -radius * 0.333f, -radius * 0.471f); var v3 = new Vector3(-radius * 0.816f, -radius * 0.333f, -radius * 0.471f); var combine = new CombineInstance[4]; combine[0].mesh = Triangle(v0, v1, v2); combine[1].mesh = Triangle(v1, v3, v2); combine[2].mesh = Triangle(v0, v2, v3); combine[3].mesh = Triangle(v0, v3, v1); var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

विंशतिफलक

अंत में, सबसे स्वादिष्ट icosahedron है। यदि आप icosahedron को संरेखित करते हैं और इसे सही कोण पर देखते हैं, तो आप देखेंगे कि इसके दो कोने एक-दूसरे के नीचे एक ही धुरी पर स्थित हैं, और बाकी दो वृत्तों पर स्थित हैं।

प्रत्येक सर्कल पर उनमें से पांच हैं, जिसका अर्थ है कि उनके बीच का अंतराल 72 डिग्री है। सर्कल के बीच ऑफसेट 36 डिग्री है। चोटियों को संरेखित करने के लिए, हमें फिर से विकिपीडिया के जादू के कोने की आवश्यकता है: “यदि दो कोने उत्तरी और दक्षिणी ध्रुवों (अक्षांश ° 90 °) पर लिए जाएँ, तो अन्य दस कोने अक्षांश ct आर्कन (1/2 ≈ ± 26.57) पर हैं ° ”है। रूसी में अनुवादित, इसका मतलब है कि जादू का कोना एक सेकंड का अभिजात वर्ग है ।

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

विंशतिफलक

 public static Mesh Icosahedron(float radius) { var magicAngle = Mathf.PI * 26.565f/180; var segmentAngle = Mathf.PI * 72 / 180; var currentAngle = 0f; var v = new Vector3[12]; v[0] = new Vector3(0, radius, 0); v[11] = new Vector3(0, -radius, 0); for (var i=1; i<6; i++) { v[i] = new Vector3(radius * Mathf.Sin(currentAngle) * Mathf.Cos(magicAngle), radius * Mathf.Sin(magicAngle), radius * Mathf.Cos(currentAngle) * Mathf.Cos(magicAngle)); currentAngle += segmentAngle; } currentAngle = Mathf.PI*36/180; for (var i=6; i<11; i++) { v[i] = new Vector3(radius * Mathf.Sin(currentAngle) * Mathf.Cos(-magicAngle), radius * Mathf.Sin(-magicAngle), radius * Mathf.Cos(currentAngle) * Mathf.Cos(-magicAngle)); currentAngle += segmentAngle; } var combine = new CombineInstance[20]; combine[0].mesh = Triangle(v[0], v[1], v[2]); combine[1].mesh = Triangle(v[0], v[2], v[3]); combine[2].mesh = Triangle(v[0], v[3], v[4]); combine[3].mesh = Triangle(v[0], v[4], v[5]); combine[4].mesh = Triangle(v[0], v[5], v[1]); combine[5].mesh = Triangle(v[11], v[7], v[6]); combine[6].mesh = Triangle(v[11], v[8], v[7]); combine[7].mesh = Triangle(v[11], v[9], v[8]); combine[8].mesh = Triangle(v[11], v[10], v[9]); combine[9].mesh = Triangle(v[11], v[6], v[10]); combine[10].mesh = Triangle(v[2], v[1], v[6]); combine[11].mesh = Triangle(v[3], v[2], v[7]); combine[12].mesh = Triangle(v[4], v[3], v[8]); combine[13].mesh = Triangle(v[5], v[4], v[9]); combine[14].mesh = Triangle(v[1], v[5], v[10]); combine[15].mesh = Triangle(v[6], v[7], v[2]); combine[16].mesh = Triangle(v[7], v[8], v[3]); combine[17].mesh = Triangle(v[8], v[9], v[4]); combine[18].mesh = Triangle(v[9], v[10], v[5]); combine[19].mesh = Triangle(v[10], v[6], v[1]); var mesh = new Mesh(); mesh.CombineMeshes(combine, true, false); return mesh; }

निष्कर्ष

यदि आप लेख में कोड को ध्यान से पढ़ते हैं, तो आप शायद ध्यान दें कि ऊपर दिए गए उदाहरण से अनावश्यक गणित, एक ही Mathf.Cos (मैजिकएंगल) हैं। यदि वांछित है, तो इसे केवल एक बार गिना जा सकता है और एक चर में डाल दिया जा सकता है, यह इतना स्पष्ट और समझ में नहीं आएगा, लेकिन तेज।

इसके अलावा, उत्पन्न मॉडल सबसे सुविधाजनक यूवी कार्ड नहीं हैं, उन्हें ठीक करना अच्छा होगा, लेकिन इसके लिए आपको बहुत सारे कोड को फिर से करना होगा, अब तक यह करेगा।

और गोले और सिलेंडर कहां हैं? - आप पूछें। हाबराहाब पर लेख संपादक, बेशक, अद्भुत है, लेकिन इसमें पाठ के बड़े संस्करणों पर नेविगेशन बहुत सुविधाजनक नहीं है, इसलिए मैं अगली बार गोले छोड़ दूंगा।

विभिन्न प्लेटफार्मों के लिए स्रोत और बायनेरिज़ नीचे दिए गए लिंक पर डाउनलोड किए जा सकते हैं।

एकता वेब प्लेयर | विंडोज | लिनक्स | मैक | गिटहब स्रोत

तीन आयामी मॉडल की प्रक्रियात्मक पीढ़ी