एकता पर मेषों का वास्तविक समय में हेरफेर

खेल विकास के लिए एक मंच के रूप में एकता के फायदों में से एक इसका शक्तिशाली 3 डी इंजन है। इस ट्यूटोरियल में, आप 3D ऑब्जेक्ट्स और मेश हेरफेर की दुनिया के बारे में जानेंगे।

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

नोट: यह ट्यूटोरियल उन उपयोगकर्ताओं के लिए है जो एकता आईडीई से परिचित हैं और C # में कुछ प्रोग्रामिंग अनुभव हैं। यदि आपके पास ऐसा ज्ञान नहीं है, तो पहले ट्यूटोरियल इंट्रोडक्शन टू यूनिटी यूआई और इंट्रोडक्शन टू यूनिटी स्क्रिप्टिंग का अध्ययन करें।

आपको 2017.3.1 से कम नहीं एकता के संस्करण की आवश्यकता होगी। एकता के नवीनतम संस्करण को यहां डाउनलोड किया जा सकता है । यह ट्यूटोरियल एक कस्टम संपादक का उपयोग करता है, और आप उनके बारे में और अधिक विस्तार कर सकते हैं एकता संपादक ट्यूटोरियल।

काम पर लगना

आरंभ करने के लिए, 3 डी-ग्राफिक्स के मूल शब्दों से परिचित हों, जो आपको ट्यूटोरियल को बेहतर ढंग से समझने की अनुमति देगा।

3 डी ग्राफिक्स की बुनियादी तकनीकी शर्तें:

• कार्यक्षेत्र : प्रत्येक शीर्ष 3 डी अंतरिक्ष में एक बिंदु है।
• मेष : मॉडल के सभी कोने, किनारे, त्रिकोण, मानदंड और यूवी डेटा शामिल हैं।
• मेश फिल्टर : स्टोर मॉडल मेश डेटा।
• मेष रेंडरर : दृश्य में मेष डेटा को प्रस्तुत करता है।
• मानदंड : एक शीर्ष या सतह के वेक्टर। यह जावक की सतह के लिए लंबवत निर्देशित है।
• लाइन्स / किनारा : अदृश्य रेखाएँ एक-दूसरे को कोने जोड़ती हैं।
• त्रिकोण : तीन चोटियों को जोड़कर बनाया गया।
• यूवी मानचित्र : एक वस्तु के लिए सामग्री संलग्न करता है, इसके लिए एक बनावट और रंग बनाता है।

एक 3D वस्तु की शारीरिक रचना इसकी जाली से शुरू होती है। इस जाल का निर्माण इसके शीर्ष पर शुरू होता है। इन रेखाओं को जोड़ने वाली अदृश्य रेखाएँ त्रिभुज बनाती हैं जो वस्तु के मूल आकार को परिभाषित करती हैं।


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

यही है, एक 3D मॉडल बनाने के लिए छद्मकोड इस तरह दिखता है:

• "MyMesh" नामक एक नया जाल बनाएं।
• MyMesh के कोने और त्रिकोण के गुणों में डेटा जोड़ें।
• "MyMeshFilter" नामक एक नया मेष फ़िल्टर बनाएं।
• मेष संपत्ति myMesh के लिए MyMeshFilter सेट करें।

एक बार जब आप मूल बातें करने में महारत हासिल कर लेते हैं, तो प्रोजेक्ट डाउनलोड करें, फ़ाइलों को अनज़िप करें और यूनिटी में प्रोजेक्ट के वर्कपीस को चलाएं। प्रोजेक्ट विंडो में फ़ोल्डर संरचना देखें:


फ़ोल्डरों का विवरण:

• प्रीफ़ैब्स : इसमें स्फीयर प्रीफ़ैब होता है जिसका उपयोग एप्लिकेशन निष्पादन के दौरान 3 डी मेष को बचाने के लिए किया जाएगा।
• दृश्य : इस ट्यूटोरियल में हमारे द्वारा उपयोग किए जाने वाले तीन दृश्य हैं।
• संपादक : इस फ़ोल्डर के अंदर की स्क्रिप्ट हमें संपादक में सुपर-फीचर्स देती हैं जो हम विकास में उपयोग करते हैं।
• लिपियों : यहां रन-टाइम स्क्रिप्ट हैं जो गेमऑबजेक्ट से जुड़ी हैं और जब आप प्ले पर क्लिक करते हैं तो निष्पादित होते हैं।
• सामग्री : इस फ़ोल्डर में जाली के लिए सामग्री है।

अगले भाग में, हम एक 3 डी मेष के निर्माण की कल्पना करने के लिए एक कस्टम संपादक बनाएंगे।

कस्टम संपादक के साथ मेष बदलें

पर्दे के फ़ोल्डर में स्थित 01 मेष अध्ययन डेमो खोलें। दृश्य विंडो में, आपको एक 3D घन दिखाई देगा:


इससे पहले कि हम मेष में आएं, कस्टम संपादक स्क्रिप्ट पर एक नजर डालते हैं।

एक संपादक स्क्रिप्ट का संपादन

प्रोजेक्ट विंडो में संपादक फ़ोल्डर का चयन करें। इस फ़ोल्डर में स्क्रिप्ट विकास के दौरान संपादक (संपादक) के लिए कार्यक्षमता जोड़ते हैं और बिल्ड मोड में उपलब्ध नहीं हैं।


MeshInspector.cs खोलें और स्रोत कोड देखें। सभी संपादक लिपियों को Editor वर्ग को लागू करना चाहिए, इसकी CustomEditor विशेषता Editor वर्ग को बताती है कि यह किस प्रकार की वस्तु है। OnSceneGUI() एक घटना विधि है जो दृश्य विंडो में प्रस्तुत करने की अनुमति देता है; OnInspectorGUI() आपको निरीक्षक में अतिरिक्त GUI तत्व जोड़ने की अनुमति देता है।

MeshInspector.cs में, MeshInspector वर्ग शुरू करने से पहले MeshInspector निम्नलिखित जोड़ें:

 [CustomEditor(typeof(MeshStudy))] 

कोड स्पष्टीकरण: CustomEditor विशेषता एकता को बताती है कि कस्टम संपादक वर्ग किस प्रकार की वस्तु को संशोधित कर सकता है।

OnSceneGUI() से पहले EditMesh() निम्नलिखित जोड़ें:

 mesh = target as MeshStudy; Debug.Log("Custom editor is running"); 

कोड स्पष्टीकरण: Editor वर्ग में एक मानक target चर है। यहाँ, target MeshStudy रूपांतरण है। अब कस्टम एडिटर दृश्य विंडो में सभी GameObjects और उनसे जुड़ी MeshStudy.cs को आकर्षित करेगा। डिबगिंग संदेशों को जोड़ने से आप कंसोल में सत्यापित कर सकते हैं कि कस्टम संपादक वास्तव में चल रहा है।

फ़ाइल सहेजें और एकता पर लौटें। लिपियों फ़ोल्डर में जाओ और इसे संलग्न करने के लिए Hierarchy में GameObject Cube पर MeshStudy.cs को खींचें।


अब संदेश "कस्टम संपादक चल रहा है" कंसोल में प्रदर्शित किया जाना चाहिए, और इसका मतलब है कि हमने सब कुछ ठीक किया है! आप डिबग संदेश को हटा सकते हैं ताकि यह हमें कंसोल में परेशान न करे।

क्लोनिंग और मेष डंपिंग

कस्टम एडिटर का उपयोग करके एडिट मोड में 3 डी मेष के साथ काम करते समय, डिफ़ॉल्ट यूनिटी मेष को अधिलेखित न करने के लिए सावधान रहें। ऐसा होने पर आपको एकता को फिर से शुरू करना होगा।

मूल रूप को अधिलेखित किए बिना जाल को सुरक्षित रूप से क्लोन करने के लिए, MeshFilter.sharedmesh संपत्ति से जाल की एक प्रति बनाएं और इसे फिर से जाल फ़िल्टर पर असाइन करें।

ऐसा करने के लिए, कोड संपादक में फ़ाइल खोलने के लिए स्क्रिप्ट फ़ोल्डर में MeshStudy.cs पर डबल-क्लिक करें। यह स्क्रिप्ट MonoBehaviour वर्ग से विरासत में मिली है, और इसके Start() फ़ंक्शन को संपादन मोड में निष्पादित नहीं किया गया है।

MeshStudy.cs में, MeshStudy क्लास शुरू करने से पहले MeshStudy निम्नलिखित जोड़ें:

 [ExecuteInEditMode] 

कोड की व्याख्या: इस विशेषता को जोड़ने के बाद, Start() फ़ंक्शन को प्ले मोड और एडिट मोड दोनों में निष्पादित किया जाएगा। अब हम सबसे पहले मेष वस्तु को निकाल सकते हैं और इसे क्लोन कर सकते हैं।

InitMesh() निम्न कोड जोड़ें:

 oMeshFilter = GetComponent<MeshFilter>(); oMesh = oMeshFilter.sharedMesh; //1 cMesh = new Mesh(); //2 cMesh.name = "clone"; cMesh.vertices = oMesh.vertices; cMesh.triangles = oMesh.triangles; cMesh.normals = oMesh.normals; cMesh.uv = oMesh.uv; oMeshFilter.mesh = cMesh; //3 vertices = cMesh.vertices; //4 triangles = cMesh.triangles; isCloned = true; Debug.Log("Init & Cloned"); 

कोड स्पष्टीकरण:

1. MeshFilter घटक से मूल oMesh मेष प्राप्त करता है।
2. एक नए जाल cMesh लिए कॉपी करें।
3. फिर से कॉपी किए गए जालीदार जाली फिल्टर को असाइन करता है।
4. स्थानीय चर अद्यतन करता है।

फ़ाइल सहेजें और एकता पर लौटें। संदेश "Init & Cloned" डिबग कंसोल में प्रदर्शित किया जाना चाहिए। पदानुक्रम में GameObject Cube चयन करें और इंस्पेक्टर में इसके गुणों की जाँच करें। मेष फ़िल्टर को एक मेष परिसंपत्ति प्रदर्शित करना चाहिए जिसे क्लोन कहा जाता है। बहुत बढ़िया! इसका मतलब है कि हमने सफलतापूर्वक मेष को क्लोन कर दिया है।


संपादक फ़ोल्डर में, MeshInspector.cs पर नेविगेट करें। OnInspectorGUI() , कोड की दूसरी पंक्ति के बाद, निम्नलिखित जोड़ें:

 if (GUILayout.Button("Reset")) //1 { mesh.Reset(); //2 } 

कोड स्पष्टीकरण:

1. यह कोड इंस्पेक्टर में एक रीसेट बटन खींचता है।
2. जब दबाया जाता है, तो यह मेशस्ट्यूडी.के में Reset() फ़ंक्शन को कॉल करता है ।

फ़ाइल को सहेजें, MeshStudy.cs खोलें और निम्न कोड को Reset() फ़ंक्शन में जोड़ें:

 if (cMesh != null && oMesh != null) //1 { cMesh.vertices = oMesh.vertices; //2 cMesh.triangles = oMesh.triangles; cMesh.normals = oMesh.normals; cMesh.uv = oMesh.uv; oMeshFilter.mesh = cMesh; //3 vertices = cMesh.vertices; //4 triangles = cMesh.triangles; } 

कोड स्पष्टीकरण:

1. स्रोत और क्लोन जाल के अस्तित्व का सत्यापन।
2. मूल जाल में cMesh रीसेट करें।
3. cMesh oMeshFilter को असाइनमेंट।
4. स्थानीय चर को अद्यतन करना।

फ़ाइल सहेजें और एकता पर लौटें। इंस्पेक्टर में, घन जाल को विकृत करने के लिए टेस्ट एडिट बटन पर क्लिक करें । इसके बाद, रीसेट बटन पर क्लिक करें; क्यूब को अपने मूल रूप में लौटना चाहिए।

एकता में कोने और त्रिकोण की व्याख्या

एक जाली में किनारों से जुड़े कोने होते हैं। त्रिकोण वस्तु के मूल आकार को परिभाषित करते हैं।

मेष वर्ग:

• Vector3 को Vector3 मानों की एक सरणी के रूप में संग्रहीत किया जाता है।
• त्रिकोणों को वर्टेक्स सरणी के सूचकांकों के अनुरूप एक पूर्णांक सरणी के रूप में संग्रहीत किया जाता है।

अर्थात्, एक साधारण क्वाड जाल में, जिसमें चार कोने और दो त्रिकोण होते हैं, मेष डेटा इस तरह दिखेगा:

वर्टेक्स मैपिंग

यहां हम क्यूब के कोने को नीले डॉट्स के रूप में प्रदर्शित करना चाहते हैं।

MeshInspector.cs में हम EditMesh() फ़ंक्शन में EditMesh() और निम्नलिखित जोड़ेंगे:

 handleTransform = mesh.transform; //1 handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity; //2 for (int i = 0; i < mesh.vertices.Length; i++) //3 { ShowPoint(i); } 

कोड स्पष्टीकरण:

1. handleTransform mesh से रूपांतरण मान प्राप्त करता है।
2. handleRotation को वर्तमान जोड़ का रोटेशन मोड मिलता है।
3. जाल के कोने को ShowPoint() और ShowPoint() का उपयोग करके बिंदुओं को ShowPoint() ।

ShowPoint() फ़ंक्शन में, //draw dot कमेंट के तुरंत बाद, निम्नलिखित जोड़ें:

 Vector3 point = handleTransform.TransformPoint(mesh.vertices[index]); 

कोड स्पष्टीकरण: यह रेखा वर्टेक्स की स्थानीय स्थिति को विश्व अंतरिक्ष में एक समन्वय में परिवर्तित करती है।

उसी फ़ंक्शन में, if ब्लॉक में, कोड की लाइन के तुरंत बाद बस जोड़ा गया है, तो निम्न जोड़ें:

 Handles.color = Color.blue; point = Handles.FreeMoveHandle(point, handleRotation, mesh.handleSize, Vector3.zero, Handles.DotHandleCap); 

कोड स्पष्टीकरण:

1. Handles हेल्पर क्लास का उपयोग करके एक बिंदु का रंग, आकार और स्थिति निर्धारित करता है।
2. Handles.FreeMoveHandle() एक असीमित गति मैनिप्युलेटर बनाता है जो ड्रैग एंड ड्रॉप ऑपरेशन को सरल बनाता है, जो अगले भाग में हमारे लिए उपयोगी है।

फ़ाइल सहेजें और एकता पर लौटें। इंस्पेक्टर में घन संपत्ति की जाँच करें और सुनिश्चित करें कि मूव वर्टेक्स पॉइंट विकल्प सक्षम है। अब आपको यह देखना चाहिए कि स्क्रीन पर जाली कई नीले डॉट्स से चिह्नित है। यहाँ वे हैं - घन जाल के सबसे ऊपर! अन्य 3D ऑब्जेक्ट्स के साथ ऐसा करने का प्रयास करें और परिणाम देखें।

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

चलो जाल को हेरफेर करने के सबसे सरल चरण के साथ शुरू करते हैं - एक एकल शीर्ष पर जाना।

MeshInspector.cs पर जाएं। ShowPoint() फ़ंक्शन के अंदर, //drag टिप्पणी के तुरंत बाद और if ब्लॉक के समापन कोष्ठक से ठीक पहले, निम्नलिखित जोड़ें:

 if (GUI.changed) //1 { mesh.DoAction(index, handleTransform.InverseTransformPoint(point)); //2 } 

कोड स्पष्टीकरण:

1. GUI.changed बिंदुओं के साथ होने वाले सभी परिवर्तनों का ट्रैक रखता है, और एक ड्रैग और ड्रॉप ऑपरेशन को पहचानने के लिए Handles.FreeMoveHandle() साथ मिलकर काम करता है।
2. mesh.DoAction() करने mesh.DoAction() शीर्ष के लिए, mesh.DoAction() फ़ंक्शन अपने इंडेक्स और ट्रांसफॉर्म मानों को मापदंडों के रूप में प्राप्त करता है। चूंकि वर्टेक्स के ट्रांसफ़ॉर्म मान विश्व स्थान में हैं, इसलिए हम उन्हें InverseTransformPoint() का उपयोग करके स्थानीय स्थान में परिवर्तित करते हैं।

स्क्रिप्ट फ़ाइल को सहेजें और MeshStudy.cs पर जाएं । DoAction() , कोष्ठक खोलने के बाद, निम्नलिखित जोड़ें:

 PullOneVertex(index, localPos); 

फिर PullOneVertex() फ़ंक्शन के लिए निम्नलिखित जोड़ें:

 vertices[index] = newPos; //1 cMesh.vertices = vertices; //2 cMesh.RecalculateNormals(); //3 

कोड स्पष्टीकरण:

1. हम मान newPos साथ लक्ष्य शीर्ष को अद्यतन करते हैं।
2. अपडेट किए गए शीर्ष मानों को cMesh.vertices वापस cMesh.vertices ।
3. RecalculateNormals() मेष को पुनर्गणना करते हैं और जाल को लाल करते हैं ताकि यह परिवर्तनों से मेल खाता हो।

फ़ाइल सहेजें और एकता पर लौटें। क्यूब पर अंक खींचने की कोशिश करें; क्या आपको टूटी हुई जाली दिखाई दी?


ऐसा लगता है कि कुछ कोने में स्थिति समान है, इसलिए जब हम केवल एक को खींचते हैं, तो शेष कोने इसके पीछे रहते हैं, और मेष टूट जाता है। अगले भाग में, हम इस समस्या को ठीक करेंगे।

सभी समान कोने ढूँढना

नेत्रहीन, एक घन जाल में आठ कोने, छह पक्ष और 12 त्रिकोण होते हैं। आइए देखें कि क्या ऐसा है।


MeshStudy.cs खोलें, Start() फ़ंक्शन के सामने एक नज़र डालें और वर्टिस वेरिएबल ढूंढें। हम निम्नलिखित देखेंगे:

 [HideInInspector] public Vector3[] vertices; 

कोड स्पष्टीकरण: [HideInInspector] इंस्पेक्टर विंडो से एक साझा चर छुपाता है।

इस विशेषता पर टिप्पणी करें:

 //[HideInInspector] public Vector3[] vertices; 

ध्यान दें: वर्टेक्स मूल्यों को छिपाने से अधिक जटिल 3 डी मेष के साथ [HideInInspector] मदद मिलती है। चूंकि वर्टेक्स सरणी का आकार हजारों तत्वों तक पहुंच सकता है, इससे इंस्पेक्टर में सरणी मान को देखने की कोशिश करने पर एकता का निषेध हो सकता है।

फ़ाइल सहेजें और एकता पर लौटें। इंस्पेक्टर के पास जाओ। अब, मेष अध्ययन स्क्रिप्ट घटक के तहत, कोने की संपत्ति दिखाई दी है। इसके बगल में स्थित तीर आइकन पर क्लिक करें; तो आप Vector3 तत्वों Vector3 सरणी का Vector3 हैं।


आप देख सकते हैं कि सरणी का आकार 24 है, अर्थात्, समान स्थिति वाले कोने हैं! जारी रखने से पहले, [HideInInspector] ।


MeshStudy.cs में, निम्नलिखित के साथ DoAction() फ़ंक्शन के अंदर सभी कोड बदलें:

 PullSimilarVertices(index, localPos); 

आइए PullSimilarVertices() फ़ंक्शन में जाएं और निम्नलिखित जोड़ें:

 Vector3 targetVertexPos = vertices[index]; //1 List<int> relatedVertices = FindRelatedVertices(targetVertexPos, false); //2 foreach (int i in relatedVertices) //3 { vertices[i] = newPos; } cMesh.vertices = vertices; //4 cMesh.RecalculateNormals(); 

कोड स्पष्टीकरण:

1. हमें लक्ष्य शीर्ष की स्थिति मिलती है जिसे FindRelatedVertices() विधि के तर्क के रूप में उपयोग किया जाएगा।
2. यह विधि अनुक्रमणिका (अनुलंबों के अनुरूप) की सूची लौटाती है, जिसमें लक्ष्य शीर्ष के समान स्थिति होती है।
3. लूप पूरी सूची का पता newPos और newPos लिए newPos से newPos सेट करता है।
4. cMesh.vertices अपडेट किए गए vertices वापस cMesh.vertices । फिर हम नए मानों के साथ मेष को फिर से परिभाषित करने के लिए RecalculateNormals() कहते हैं।

फ़ाइल सहेजें और एकता पर लौटें। किसी भी कोने को खींचें; अब जाली को अपना आकार बनाए रखना चाहिए और ढहना नहीं चाहिए।


अब जब हमने मेश में हेरफेर करने के लिए पहला कदम पूरा कर लिया है, तो दृश्य को बचाएं और अगले भाग पर जाएं।

मेष का हेरफेर

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

चयनित अनुक्रमित एकत्रित करना

आइए उन लंबों का चयन करके शुरू करें जिन्हें हम वास्तविक समय में स्थानांतरित करेंगे।

दृश्य 02 खोलें दृश्य फ़ोल्डर से हार्ट मेष बनाएँ । दृश्य विंडो में, आप एक लाल क्षेत्र देखेंगे। पदानुक्रम में क्षेत्र का चयन करें और इंस्पेक्टर पर जाएं । आप देखेंगे कि हार्ट मेश स्क्रिप्ट घटक ऑब्जेक्ट से जुड़ा हुआ है।

अब हमें दृश्य विंडो में मेष के कोने प्रदर्शित करने के लिए इस ऑब्जेक्ट के लिए संपादक स्क्रिप्ट की आवश्यकता है। संपादक फ़ोल्डर पर जाएं और HeartMeshInspector.cs पर डबल-क्लिक करें।

ShowHandle() फ़ंक्शन में, if ब्लॉक के अंदर, निम्नलिखित जोड़ें:

 Handles.color = Color.blue; if (Handles.Button(point, handleRotation, mesh.pickSize, mesh.pickSize, Handles.DotHandleCap)) //1 { mesh.selectedIndices.Add(index); //2 } 

कोड स्पष्टीकरण:

1. सेट करता है और एक Handles.Button रूप में मेष के कोने प्रदर्शित करता है। Handles.Button ।
2. जब क्लिक किया जाता है, तो यह चयनित इंडेक्स को दबाया, mesh.selectedIndices ।

OnInspectorGUI() , समापन ब्रैकेट से पहले, निम्नलिखित जोड़ें:

 if (GUILayout.Button("Clear Selected Vertices")) { mesh.ClearAllData(); } 

कोड की व्याख्या: यह है कि हम mesh.ClearAllData() को कॉल करने के लिए इंस्पेक्टर को एक रीसेट बटन कैसे जोड़ते हैं mesh.ClearAllData() ।

फ़ाइल सहेजें और लिपियों फ़ोल्डर से HeartMesh.cs खोलें। ClearAllData() फ़ंक्शन में, निम्नलिखित जोड़ें:

 selectedIndices = new List<int>(); targetIndex = 0; targetVertex = Vector3.zero; 

कोड स्पष्टीकरण: कोड targetIndex और targetIndex में मूल्यों को साफ करता है। यह targetVertex भी रीसेट करता है।

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

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


नोट: संशोधित कस्टम इंस्पेक्टर में , हमारे पास शो ट्रांसफ़ॉर्म हैंडल का उपयोग करके ट्रांसफ़ॉर्म मैन्यूलेटर को दिखाने / छिपाने का विकल्प है। इसलिए यदि आप अन्य दृश्यों में ट्रांसफॉर्मर मैनिपुलेटर नहीं पाते हैं तो घबराएँ नहीं! बाहर निकलने से पहले इसे चालू करें।

एक गोले को दिल में बदलना

वास्तविक समय में जाली के सिरों को बदलना अनिवार्य रूप से तीन चरणों में होता है:

1. वर्तमान मेष कोने (एनीमेशन से पहले) mVertices पर mVertices ।
2. mVertices गणना mVertices हैं और mVertices में मूल्यों को mVertices ।
3. प्रत्येक चरण में बदलते समय mVertices साथ वर्तमान मेष कोने को अपडेट करें और एकता स्वचालित रूप से mVertices गणना करें।

OpenMesh.cs खोलें और Start() फ़ंक्शन से पहले निम्न चर:

 public float radiusofeffect = 0.3f; //1 public float pullvalue = 0.3f; //2 public float duration = 1.2f; //3 int currentIndex = 0; //4 bool isAnimate = false; float starttime = 0f; float runtime = 0f; 

कोड स्पष्टीकरण:

1. लक्ष्य शीर्ष से प्रभावित क्षेत्र की त्रिज्या।
2. बल खींचें।
3. एनीमेशन की अवधि।
4. selectedIndices सूची सूची का वर्तमान सूचकांक।

if ब्लॉक से पहले Init() फ़ंक्शन में, निम्नलिखित जोड़ें:

 currentIndex = 0; 

कोड की व्याख्या: खेल की शुरुआत में, currentIndex को 0 पर currentIndex जाता है, selectedIndices सूची सूची का पहला सूचकांक।

उसी Init() फ़ंक्शन में, else ब्लॉक के समापन ब्रैकेट से पहले, निम्नलिखित जोड़ें:

 StartDisplacement(); 

कोड स्पष्टीकरण: StartDisplacement() फ़ंक्शन को isEditMode यदि isEditMode गलत है।

StartDisplacement() फ़ंक्शन के अंदर, निम्नलिखित जोड़ें:

 targetVertex = oVertices[selectedIndices[currentIndex]]; //1 starttime = Time.time; //2 isAnimate = true; 

कोड स्पष्टीकरण:

1. एनीमेशन शुरू करने के लिए targetVertex चुनें।
2. प्रारंभ समय सेट करें और isAnimate के मान को सही में बदलें।

StartDisplacement() फ़ंक्शन के बाद, StartDisplacement() दिए गए कोड के साथ FixedUpdate() फ़ंक्शन बनाएं:

 void FixedUpdate() //1 { if (!isAnimate) //2 { return; } runtime = Time.time - starttime; //3 if (runtime < duration) //4 { Vector3 targetVertexPos = oFilter.transform.InverseTransformPoint(targetVertex); DisplaceVertices(targetVertexPos, pullvalue, radiusofeffect); } else //5 { currentIndex++; if (currentIndex < selectedIndices.Count) //6 { StartDisplacement(); } else //7 { oMesh = GetComponent<MeshFilter>().mesh; isAnimate = false; isMeshReady = true; } } } 

कोड स्पष्टीकरण:

1. FixedUpdate() फ़ंक्शन को एक निश्चित एफपीएस लूप में निष्पादित किया जाता है।
2. यदि कोई isAnimate गलत है, तो निम्न कोड छोड़ें।
3. runtime एनिमेशन बदलें।
4. यदि runtime duration भीतर है, तो हम targetVertex और targetVertex DisplaceVertices() के विश्व निर्देशांक प्राप्त करते हैं, pullvalue और radiusofeffect साथ लक्ष्य शीर्ष को कवर करते हैं।
5. अन्यथा, समय समाप्त हो गया है। currentIndex एक जोड़ें।
6. जाँच करें कि क्या currentIndex selectedIndices currentIndex । StartDisplacement() का उपयोग करके सूची में अगले शीर्ष पर जाएं।
7. अन्यथा, सूची के अंत में, oMesh डेटा को वर्तमान जाल में बदल दें और एनीमेशन को रोकने के लिए गलत को isAnimate ।

DisplaceVertices() निम्नलिखित जोड़ें:

 Vector3 currentVertexPos = Vector3.zero; float sqrRadius = radius * radius; //1 for (int i = 0; i < mVertices.Length; i++) //2 { currentVertexPos = mVertices[i]; float sqrMagnitute = (currentVertexPos - targetVertexPos).sqrMagnitude; //3 if (sqrMagnitute > sqrRadius) { continue; //4 } float distance = Mathf.Sqrt(sqrMagnitute); //5 float falloff = GaussFalloff(distance, radius); Vector3 translate = (currentVertexPos * force) * falloff; //6 translate.z = 0f; Quaternion rotation = Quaternion.Euler(translate); Matrix4x4 m = Matrix4x4.TRS(translate, rotation, Vector3.one); mVertices[i] = m.MultiplyPoint3x4(currentVertexPos); } oMesh.vertices = mVertices; //7 oMesh.RecalculateNormals(); 

कोड स्पष्टीकरण:

1. त्रिज्या का वर्ग।
2. हम जाल के प्रत्येक शीर्ष के माध्यम से लूप करते हैं।
3. currentVertexPos और sqrMagnitude बीच currentVertexPos sqrMagnitude ।
4. यदि sqrMagnitude से अधिक है, तो अगले शीर्ष पर जाएं।
5. अन्यथा, falloff मान को परिभाषित करके जारी रखें, जो गुंजाइश के केंद्र बिंदु से वर्तमान शीर्ष की distance पर निर्भर करता है।
6. नई Vector3 स्थिति Vector3 और वर्तमान शीर्ष पर इसके ट्रांसफ़ॉर्म को लागू करें।
7. जब आप लूप से बाहर निकलते हैं, तो हम mVertices में परिवर्तित mVertices मानों को असाइन करते हैं, और एकता को mVertices को फिर से लागू करने के लिए मजबूर करते हैं।

फ़ॉलऑफ़ टेक्नोलॉजी का स्रोत
मूल फॉर्मूला प्रोसीड्यूरल एग्जाम एसेट पैकेज फाइल से लिया गया है, जिसे यूनिटी एसेट स्टोर से मुफ्त में डाउनलोड किया जा सकता है।

फ़ाइल सहेजें और एकता पर लौटें। क्षेत्र का चयन करें, हार्टमेश घटक पर जाएं और चयनित सूचक संपत्ति में कुछ कोने जोड़ने का प्रयास करें। अक्षम मोड संपादित करें और अपने काम के परिणाम को देखने के लिए Play पर क्लिक करें।


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


Play पर क्लिक करें। क्या आपका क्षेत्र दिल में बदल गया है?


बधाई! अगले भाग में, हम भविष्य के उपयोग के लिए प्रीफ़ैब के रूप में मेष को बचाएंगे।

वास्तविक समय में मेष को सहेजना

प्ले मोड में एक दिल के आकार की प्रक्रियात्मक जाल को बचाने के लिए, आपको एक प्रीफैब तैयार करने की आवश्यकता है, जिसका बच्चा एक 3 डी ऑब्जेक्ट होगा, और फिर एक स्क्रिप्ट का उपयोग करके अपनी मेष संपत्ति को एक नए के साथ बदल देगा।

प्रोजेक्ट विंडो में, Prefabs फ़ोल्डर में CustomHeart खोजें। अपनी सामग्री का विस्तार करने और बाल का चयन करने के लिए तीर आइकन पर क्लिक करें। अब आपको इंस्पेक्टर पूर्वावलोकन विंडो में एक क्षेत्र वस्तु दिखाई देती है। यह प्रीफ़ैब है जो नए जाल के लिए डेटा संग्रहीत करेगा।


OpenMeshInspector.cs खोलें। बंद करने वाले ब्रैकेट से पहले OnInspectorGUI() फ़ंक्शन के अंदर, निम्नलिखित जोड़ें:

 if (!mesh.isEditMode && mesh.isMeshReady) { string path = "Assets/Prefabs/CustomHeart.prefab"; //1 if (GUILayout.Button("Save Mesh")) { mesh.isMeshReady = false; Object pfObj = AssetDatabase.LoadAssetAtPath(path, typeof(GameObject)); //2 Object pfRef = AssetDatabase.LoadAssetAtPath (path, typeof(GameObject)); GameObject gameObj = (GameObject)PrefabUtility.InstantiatePrefab(pfObj); Mesh pfMesh = (Mesh)AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)); //3 if (!pfMesh) { pfMesh = new Mesh(); } else { pfMesh.Clear(); } pfMesh = mesh.SaveMesh(); //4 AssetDatabase.AddObjectToAsset(pfMesh, path); gameObj.GetComponentInChildren<MeshFilter>().mesh = pfMesh; //5 PrefabUtility.ReplacePrefab(gameObj, pfRef, ReplacePrefabOptions.Default); //6 Object.DestroyImmediate(gameObj); //7 } } 

कोड स्पष्टीकरण:

1. CustomHeart prefab ऑब्जेक्ट के लिए path को सेट करता है।
2. CustomHeart prefab से दो ऑब्जेक्ट बनाता है, एक गेमऑबजेक्ट ( pfObj ) के रूप में एक उदाहरण बनाने के लिए, और दूसरा लिंक ( pfRef ) के रूप में।
3. CustomHeart से pfMesh मेष pfMesh का एक उदाहरण बनाता है। यदि यह नहीं पाया जाता है, तो एक नया जाल बनाता है, अन्यथा यह मौजूदा डेटा को साफ करता है।
4. नए जाल डेटा के साथ pfMesh को pfMesh करता है, और फिर इसे CustomHeart को एक संपत्ति के रूप में जोड़ता है।
   
5. gameObj में gameObj एक मेष संपत्ति को भरता है।
6. पूर्व-मौजूदा कनेक्शनों के मिलान gameObj गेमऑब्ज के साथ gameObj जगह।
7. तुरन्त खेल को नष्ट कर देता है।

फ़ाइल सहेजें और HeartMesh.cs पर जाएं । सामान्य SaveMesh() विधि में, nMesh आवृत्ति बनाने के बाद nMesh निम्नलिखित जोड़ें:

 nMesh.name = "HeartMesh"; nMesh.vertices = oMesh.vertices; nMesh.triangles = oMesh.triangles; nMesh.normals = oMesh.normals; 

कोड स्पष्टीकरण: दिल के आकार की जाली से मूल्यों के साथ एक मेष संपत्ति देता है।

फ़ाइल सहेजें और एकता पर लौटें। Play पर क्लिक करें। एनीमेशन पूरा होने के बाद, इंस्पेक्टर में सेव मेश बटन दिखाई देगा। नए जाल को बचाने के लिए बटन पर क्लिक करें, और फिर खिलाड़ी को रोकें।

Prefabs फ़ोल्डर में जाएं और CustomHeart prefab को देखें । आपको देखना चाहिए कि अब CustomHeart prefab ऑब्जेक्ट में एक पूरी तरह से नया दिल के आकार का मेष है।


बहुत अच्छा काम!

यह सब एक साथ रखना

पिछले दृश्य में, DisplaceVertices() फ़ंक्शन ने ड्रैग फोर्स को निर्धारित करने के लिए फ़ॉलऑफ़ फॉर्मूला का उपयोग किया था जो किसी दिए गए त्रिज्या के भीतर प्रत्येक शीर्ष पर लागू किया गया था। "फॉल ऑफ" की बात, जिस पर ड्रैग फोर्स कम होना शुरू होता है, जो उपयोग किए गए फॉलऑफ के प्रकार पर निर्भर करता है: रैखिक, गाऊसी या सुई। प्रत्येक प्रकार जाल में अलग-अलग परिणाम उत्पन्न करता है।


इस खंड में, हम एक और तरीके को जोड़तोड़ में हेरफेर करने के लिए देखेंगे: दिए गए वक्र का उपयोग कर। यह नियम लेते हुए कि गति समय (d = (v / t)) से विभाजित दूरी के बराबर है, हम वेक्टर की स्थिति निर्धारित कर सकते हैं, समय से विभाजित इसकी दूरी का जिक्र करते हुए।

वक्र विधि का उपयोग करना

करंट सीन को सेव करें और 03 को फोर्सेज को फोल्ड करें । आपको CustomHeart prefab का एक पदानुक्रम उदाहरण दिखाई देगा। अपनी सामग्री का विस्तार करने और बाल का चयन करने के लिए उसके बगल में स्थित तीर आइकन पर क्लिक करें।

इंस्पेक्टर में इसके गुण देखें।आप हार्ट मेश एसेट के साथ मेश फिल्टर घटक देखेंगे । एक घटक के रूप में बच्चे को एक कस्टम हार्ट स्क्रिप्ट संलग्न करें । अब संपत्ति को हार्टमेश से क्लोन में बदलना चाहिए ।


अगला, Scripts फ़ोल्डर से CustomHeart.cs खोलें । फ़ंक्शन से पहले, निम्नलिखित जोड़ें:Start()

 public enum CurveType { Curve1, Curve2 } public CurveType curveType; Curve curve; 

कोड की व्याख्या: यहां नाम के तहत एक सामान्य एनुम बनाया जाता है CurveType, जिसके बाद इसे इंस्पेक्टर से उपलब्ध कराया जाता है । निम्नलिखित पर

जाएं CurveType1()और जोड़ें:

 Vector3[] curvepoints = new Vector3[3]; //1 curvepoints[0] = new Vector3(0, 1, 0); curvepoints[1] = new Vector3(0.5f, 0.5f, 0); curvepoints[2] = new Vector3(1, 0, 0); curve = new Curve(curvepoints[0], curvepoints[1], curvepoints[2], false); //2 

कोड स्पष्टीकरण:

1. एक साधारण वक्र में तीन बिंदु होते हैं। पहले वक्र के लिए अंक निर्धारित करें।
2. हम मदद के साथ पहला वक्र बनाते हैं Curve()और इसके मान निर्दिष्ट करते हैं curve। यदि आप पिछले पैरामीटर के रूप में सही निर्दिष्ट करते हैं तो खींचा गया वक्र पूर्वावलोकन में प्रदर्शित किया जा सकता है।

CurveType2()निम्नलिखित पर जाएं और जोड़ें:

 Vector3[] curvepoints = new Vector3[3]; //1 curvepoints[0] = new Vector3(0, 0, 0); curvepoints[1] = new Vector3(0.5f, 1, 0); curvepoints[2] = new Vector3(1, 0, 0); curve = new Curve(curvepoints[0], curvepoints[1], curvepoints[2], false); //2 

कोड स्पष्टीकरण:

1. दूसरे वक्र के लिए अंक निर्धारित करें।
2. हम Curve()इसके साथ दूसरा वक्र बनाते हैं और इसके मान निर्दिष्ट करते हैं curve। यदि आप पिछले पैरामीटर के रूप में सही निर्दिष्ट करते हैं तो खींचा गया वक्र पूर्वावलोकन में प्रदर्शित किया जा सकता है।

बी StartDisplacement(), समापन ब्रैकेट से पहले, निम्नलिखित जोड़ें:

 if (curveType == CurveType.Curve1) { CurveType1(); } else if (curveType == CurveType.Curve2) { CurveType2(); } 

कोड स्पष्टीकरण: यहां हम उपयोगकर्ता द्वारा चुने गए विकल्प की जांच करते हैं curveTypeऔर तदनुसार उत्पन्न करते हैं curve।

B DisplaceVertices(), forकोष्ठक बंद करने से पहले लूप स्टेटमेंट के अंदर , निम्नलिखित जोड़ें:

 float increment = curve.GetPoint(distance).y * force; //1 Vector3 translate = (vert * increment) * Time.deltaTime; //2 Quaternion rotation = Quaternion.Euler(translate); Matrix4x4 m = Matrix4x4.TRS(translate, rotation, Vector3.one); mVertices[i] = m.MultiplyPoint3x4(mVertices[i]); 

कोड स्पष्टीकरण:

1. हम दिए गए मोड़ पर वक्र की स्थिति प्राप्त करते हैं distanceऔर प्राप्त करने के लिए इसके मूल्य yको गुणा forceकरते हैं increment।
2. Vector3वर्तमान शीर्ष की नई स्थिति को संग्रहीत करने और उसके अनुसार अपने ट्रांसफ़ॉर्म को लागू करने के लिए एक नया डेटा प्रकार बनाएं ।

फ़ाइल सहेजें और एकता पर लौटें। घटक के गुणों की जाँच करें CustomHeart खेल वस्तु बाल । आपको एक ड्रॉप-डाउन सूची दिखाई देगी जहां आप वक्र प्रकार का चयन कर सकते हैं । प्रकार संपादित करें ड्रॉप-डाउन सूची से, कोने की सूची अपडेट करने और विभिन्न सेटिंग्स के साथ प्रयोग करने के लिए Add Indices या Remove Indices चुनें ।


विभिन्न प्रकार के घटता के लिए विस्तृत परिणाम देखने के लिए, स्क्रीनशॉट के अनुसार मान दर्ज करें:


की सूची के लिए वक्र प्रकार , का चयन Curve1 , यह सुनिश्चित कर लें संपादित प्रकार का चयन करें कोई भी और पर क्लिक करें प्ले । आपको पैटर्न में जाली को देखना चाहिए। मॉडल को साइड व्यू में देखने के लिए रोल करें और दोनों प्रकार के कर्व्स के परिणामों की तुलना करें। यहां आप देखते हैं कि चयनित कर्व टाइप मेष ऑफसेट को कैसे प्रभावित करता है।



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

• त्रिज्या का मान।
• क्षेत्र में कोने का वितरण।
• चयनित कोने की पैटर्न स्थिति।
• ऑफ़सेट के लिए चुनी गई विधि।

आगे कहाँ जाना है?

तैयार परियोजना की फाइलें ट्यूटोरियल प्रोजेक्ट के संग्रह में हैं ।

वहां रुकना मत! यूनिटी प्रक्रियात्मक भूलभुलैया पीढ़ी के ट्यूटोरियल में उपयोग की जाने वाली अधिक परिष्कृत तकनीकों का प्रयास करें ।

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