भाग 1-3: जाल, रंग और सेल ऊँचाई

भाग 4-7: धक्कों, नदियों और सड़कों

भाग 8-11: जल, भू-भाग और प्राचीर

12-15 भाग: बचत और लोडिंग, बनावट, दूरियां

भाग 16-19: रास्ता खोजना, खिलाड़ी दस्ते, एनिमेशन

भाग 20-23: कोहरे के युद्ध, मानचित्र अनुसंधान, प्रक्रियात्मक पीढ़ी

भाग 24-27: जल चक्र, अपरदन, बायोम, बेलनाकार नक्शा

भाग 4: खुरदरापन

सामग्री की तालिका

• शोर बनावट का नमूना।
• सिरों को घुमाएं।
• हम कोशिकाओं के समतलता को संरक्षित करते हैं।
• कोशिकाओं के किनारों को उप-विभाजित करें।

जबकि हमारा ग्रिड मधुकोश का एक सख्त पैटर्न था। इस भाग में, हम नक्शे को और अधिक प्राकृतिक बनाने के लिए धक्कों को जोड़ेंगे।


कोई और भी हेक्सागोन्स।

शोर

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

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

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

शोर बनावट

हम बनावट का उपयोग करेंगे, इसलिए शोर ट्यूटोरियल वैकल्पिक है। इसलिए हमें एक बनावट की आवश्यकता है। यहाँ यह है:


निर्बाध रूप से पर्लिन शोर की बनावट को जोड़ते हैं।

ऊपर दिखाई गई बनावट में पर्लिन की मूल रूप से युग्मित बहु-आवृत्ति शोर शामिल है। यह एक ग्रेस्केल इमेज है। इसका औसत मान 0.5 है, और चरम मान 0 और 1 तक है।

लेकिन रुकिए, प्रत्येक बिंदु के लिए केवल एक मूल्य है। यदि हमें 3 डी विरूपण की आवश्यकता है, तो हमें कम से कम तीन छद्म यादृच्छिक नमूने की आवश्यकता है! इसलिए, हमें अलग शोर के साथ दो और बनावट की आवश्यकता है।

हम उन्हें बना सकते हैं या प्रत्येक रंग चैनलों में विभिन्न शोर मूल्यों को संग्रहीत कर सकते हैं। यह हमें एक बनावट में चार शोर पैटर्न तक संग्रहीत करने की अनुमति देगा। यहाँ यह बनावट है।


एक में चार।


इस बनावट को डाउनलोड करें और इसे अपनी एकता परियोजना में आयात करें। चूंकि हम कोड के माध्यम से बनावट का नमूना लेने जा रहे हैं, यह पठनीय होना चाहिए। टेक्सचर प्रकार को उन्नत पर स्विच करें और पढ़ें / सक्षम सक्षम करें । यह बनावट डेटा को मेमोरी में बचाएगा और C # कोड से एक्सेस किया जा सकता है। प्रारूप को स्वचालित Truecolor पर सेट करें, अन्यथा कुछ भी काम नहीं करेगा। हम अपने शोर पैटर्न को नष्ट करने के लिए बनावट संपीड़न नहीं चाहते हैं।

आप जनरेट मैप मैप्स को निष्क्रिय कर सकते हैं, क्योंकि हमें उनकी आवश्यकता नहीं है। इसके अलावा बायपास sRGB सैंपलिंग को सक्षम करें। हमें इसकी आवश्यकता नहीं होगी, लेकिन ऐसा होगा। यह पैरामीटर इंगित करता है कि बनावट में गामा स्थान में रंग डेटा शामिल नहीं है।



आयातित शोर बनावट।

शोर का नमूना

चलो HexMetrics शोर नमूना कार्यक्षमता को HexMetrics ताकि आप इसे कहीं भी उपयोग कर सकें। इसका मतलब है कि HexMetrics में शोर बनावट का संदर्भ होना चाहिए।

  public static Texture2D noiseSource; 

चूंकि यह एक घटक नहीं है, इसलिए हम इसे संपादक के माध्यम से एक बनावट प्रदान नहीं कर सकते हैं। इसलिए, एक मध्यस्थ के रूप में, हम HexGrid उपयोग HexGrid । चूंकि HexGrid पहले कार्य करेगा, यह ठीक होगा यदि हम इसकी Awake विधि की शुरुआत में बनावट पास करते हैं।

  public Texture2D noiseSource; void Awake () { HexMetrics.noiseSource = noiseSource; … } 

हालाँकि, यह दृष्टिकोण Play मोड में पुनर्संयोजन से नहीं बचेगा। स्टैटिक वैरिएबल को एकता इंजन द्वारा क्रमबद्ध नहीं किया जाता है। इस समस्या को हल करने के लिए, OnEnable इवेंट पद्धति में बनावट को पुन: असाइन करें। इस विधि को पुनर्संयोजन के बाद कहा जाएगा।

  void OnEnable () { HexMetrics.noiseSource = noiseSource; } 

एक शोर बनावट असाइन करें।

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

  public static Vector4 SampleNoise (Vector3 position) { } 

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

नतीजतन, हमें एक रंग मिलता है जिसे 4D वेक्टर में परिवर्तित किया जा सकता है। इस तरह की कमी अप्रत्यक्ष हो सकती है, अर्थात हम सीधे रंग वापस कर सकते हैं, स्पष्ट रूप से (Vector4) सहित।

  public static Vector4 SampleNoise (Vector3 position) { return noiseSource.GetPixelBilinear(position.x, position.z); } 

unitypackage

वर्टेक्स आंदोलन

हम छत्ते की हमारी चिकनी ग्रिड को विकृत करेंगे, व्यक्तिगत रूप से प्रत्येक कोने को घुमाते हुए। ऐसा करने के लिए, चलिए Perturb पद्धति को Perturb । यह एक unmoving बिंदु लेता है और स्थानांतरित एक को वापस करता है। ऐसा करने के लिए, वह शोर का नमूना लेते समय एक गैर-स्थानांतरित बिंदु का उपयोग करता है।

  Vector3 Perturb (Vector3 position) { Vector4 sample = HexMetrics.SampleNoise(position); } 

आइए बस शोर के नमूने X, Y और Z को संबंधित बिंदु निर्देशांक में सीधे जोड़ते हैं और परिणामस्वरूप इसका उपयोग करते हैं।

  Vector3 Perturb (Vector3 position) { Vector4 sample = HexMetrics.SampleNoise(position); position.x += sample.x; position.y += sample.y; position.z += sample.z; return position; } 

हम सभी कोने को स्थानांतरित करने के लिए HexMesh को जल्दी से कैसे बदलते हैं? AddTriangle और AddQuad में सूची में शीर्ष जोड़ते समय प्रत्येक शीर्ष को बदलकर। चलो करते हैं।

  void AddTriangle (Vector3 v1, Vector3 v2, Vector3 v3) { int vertexIndex = vertices.Count; vertices.Add(Perturb(v1)); vertices.Add(Perturb(v2)); vertices.Add(Perturb(v3)); … } void AddQuad (Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4) { int vertexIndex = vertices.Count; vertices.Add(Perturb(v1)); vertices.Add(Perturb(v2)); vertices.Add(Perturb(v3)); vertices.Add(Perturb(v4)); … } 

कोने या तो चले गए हैं या नहीं।

हालांकि परिवर्तन बहुत ध्यान देने योग्य नहीं हैं, केवल सेल लेबल गायब हो गए हैं। ऐसा इसलिए हुआ क्योंकि हमने शोर के नमूनों को अंकों में जोड़ा, और वे हमेशा सकारात्मक रहे। इसलिए, परिणामस्वरूप, सभी त्रिकोण अपने निशान से ऊपर उठे, उन्हें बंद कर दिया। हमें परिवर्तनों को केंद्र में रखना चाहिए ताकि वे दोनों दिशाओं में हो। शोर नमूने के अंतराल को 0-1 से –1–1 तक बदलें।

  Vector3 Perturb (Vector3 position) { Vector4 sample = HexMetrics.SampleNoise(position); position.x += sample.x * 2f - 1f; position.y += sample.y * 2f - 1f; position.z += sample.z * 2f - 1f; return position; } 

केन्द्रित विस्थापन।

विस्थापन का परिमाण (बल)

अब यह स्पष्ट है कि हमने ग्रिड को विकृत कर दिया है, लेकिन यह प्रभाव मुश्किल से ध्यान देने योग्य है। प्रत्येक आयाम में परिवर्तन 1 इकाई से अधिक नहीं है। यही है, सैद्धांतिक अधिकतम विस्थापन ≈3 units 1.73 इकाइयां हैं, जो कि बहुत कम ही होगा, यदि बिल्कुल भी हो। चूंकि कोशिकाओं की बाहरी त्रिज्या 10 इकाइयां हैं, इसलिए विस्थापन अपेक्षाकृत छोटा है।

समाधान HexMetrics लिए एक HexMetrics पैरामीटर HexMetrics ताकि आप आंदोलनों को स्केल कर सकें। आइए बल प्रयोग करने का प्रयास करें 5. इस मामले में, सैद्धांतिक अधिकतम विस्थापन ≈75 6 8.66 इकाई होगा, जो कि अधिक ध्यान देने योग्य है।

  public const float cellPerturbStrength = 5f; 

हम HexMesh.Perturb में नमूनों द्वारा इसे गुणा करके बल लागू HexMesh.Perturb ।

  Vector3 Perturb (Vector3 position) { Vector4 sample = HexMetrics.SampleNoise(position); position.x += (sample.x * 2f - 1f) * HexMetrics.cellPerturbStrength; position.y += (sample.y * 2f - 1f) * HexMetrics.cellPerturbStrength; position.z += (sample.z * 2f - 1f) * HexMetrics.cellPerturbStrength; return position; } 

बढ़ी हुई ताकत।

शोर पैमाना

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

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


10 से 10 ग्रिड ओवरलैप कोशिकाओं की पंक्तियाँ।

हमें शोर के नमूने को स्केल करना होगा ताकि बनावट बहुत बड़े क्षेत्र को कवर करे। चलो इस पैमाने को HexMetrics और इसे 0.003 का मान देते हैं, और फिर इस कारक द्वारा नमूनों के निर्देशांक को स्केल करते हैं।

  public const float noiseScale = 0.003f; public static Vector4 SampleNoise (Vector3 position) { return noiseSource.GetPixelBilinear( position.x * noiseScale, position.z * noiseScale ); } 

यह अचानक पता चला है कि हमारी बनावट 333 & frac13; वर्ग इकाइयाँ, और इसकी स्थानीय अखंडता स्पष्ट हो जाती है।



शोर मचाया।

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

unitypackage

सेल केंद्रों को संरेखित करना

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


नक्शा कम सख्त हो गया, लेकिन अधिक समस्याएं दिखाई दीं।

चौराहे की समस्या को हल करने का सबसे आसान तरीका कोशिकाओं के केंद्रों को सपाट बनाना है। चलो HexMesh.Perturb में Y समन्वय को न बदलें।

  Vector3 Perturb (Vector3 position) { Vector4 sample = HexMetrics.SampleNoise(position); position.x += (sample.x * 2f - 1f) * HexMetrics.cellPerturbStrength; // position.y += (sample.y * 2f - 1f) * HexMetrics.cellPerturbStrength; position.z += (sample.z * 2f - 1f) * HexMetrics.cellPerturbStrength; return position; } 

संरेखित कोशिकाएं।

इस परिवर्तन के साथ, सभी ऊर्ध्वाधर स्थिति अपरिवर्तित रहेंगी, दोनों कोशिकाओं के केंद्र में और अगुवाई के चरणों में। यह ध्यान दिया जाना चाहिए कि यह केवल XZ विमान में ≈50 this 7.07 के अधिकतम विस्थापन को कम करता है।

यह एक अच्छा बदलाव है, क्योंकि यह अलग-अलग कोशिकाओं की पहचान को आसान बनाता है और इससे एलर्जेस बहुत ज्यादा अराजक नहीं हो जाते हैं। लेकिन फिर भी थोड़ा ऊर्ध्वाधर आंदोलन जोड़ना अच्छा होगा।

सेल की ऊँचाई पर जाएँ

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

  public const float elevationPerturbStrength = 1.5f; 

HexCell.Elevation प्रॉपर्टी को बदलें ताकि यह सेल के वर्टिकल पोजिशन में यह मूव HexCell.Elevation ।

  public int Elevation { get { return elevation; } set { elevation = value; Vector3 position = transform.localPosition; position.y = value * HexMetrics.elevationStep; position.y += (HexMetrics.SampleNoise(position).y * 2f - 1f) * HexMetrics.elevationPerturbStrength; transform.localPosition = position; Vector3 uiPosition = uiRect.localPosition; uiPosition.z = -position.y; uiRect.localPosition = uiPosition; } } 

इस कदम को तुरंत लागू करने के लिए, हमें HexGrid.CreateCell में प्रत्येक सेल की ऊंचाई स्पष्ट रूप से निर्धारित करने की आवश्यकता है। अन्यथा, ग्रिड शुरू में सपाट होगा। UI बनाने के बाद, इसे अंत में करते हैं।

  void CreateCell (int x, int z, int i) { … cell.Elevation = 0; } 

दरारें के साथ विस्थापित ऊंचाइयों।

समान ऊंचाइयों का उपयोग करना

मेष में कई दरारें दिखाई दीं, क्योंकि जब हम मेष को त्रिकोण करते हैं, तो हम एक ही सेल ऊंचाइयों का उपयोग नहीं करते हैं। चलिए इसकी स्थिति प्राप्त करने के लिए HexCell एक संपत्ति जोड़ें ताकि आप इसे कहीं भी उपयोग कर सकें।

  public Vector3 Position { get { return transform.localPosition; } } 

अब हम सेल के केंद्र को निर्धारित करने के लिए HexMesh.Triangulate में इस गुण का उपयोग कर सकते हैं।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.Position; … } 

और जब हम पड़ोसी कोशिकाओं के ऊर्ध्वाधर पदों को परिभाषित करते हैं, तो हम इसे TriangulateConnection में उपयोग कर सकते हैं।

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { … Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; v3.y = v4.y = neighbor.Position.y; … HexCell nextNeighbor = cell.GetNeighbor(direction.Next()); if (direction <= HexDirection.E && nextNeighbor != null) { Vector3 v5 = v2 + HexMetrics.GetBridge(direction.Next()); v5.y = nextNeighbor.Position.y; … } } 

सेल ऊंचाई का लगातार उपयोग।

unitypackage

सेल एज यूनिट

यद्यपि कोशिकाओं में एक सुंदर बदलाव है, फिर भी वे स्पष्ट हेक्सागोन्स की तरह दिखते हैं। यह अपने आप में कोई समस्या नहीं है, लेकिन हम उनकी उपस्थिति में सुधार कर सकते हैं।


स्पष्ट रूप से दृश्यमान हेक्सागोनल कोशिकाएं।

यदि हमारे पास अधिक कोने हैं, तो अधिक स्थानीय परिवर्तनशीलता होगी। तो चलो प्रत्येक कोने कोनों के बीच में किनारे के शीर्ष को जोड़कर सेल के प्रत्येक किनारे को दो भागों में विभाजित करें। इसका मतलब यह है कि HexMesh.Triangulate को एक नहीं, बल्कि दो HexMesh.Triangulate को जोड़ना चाहिए।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.Position; Vector3 v1 = center + HexMetrics.GetFirstSolidCorner(direction); Vector3 v2 = center + HexMetrics.GetSecondSolidCorner(direction); Vector3 e1 = Vector3.Lerp(v1, v2, 0.5f); AddTriangle(center, v1, e1); AddTriangleColor(cell.color); AddTriangle(center, e1, v2); AddTriangleColor(cell.color); if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, v1, v2); } } 

छह के बजाय बारह पक्ष।

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

  Vector3 e1 = Vector3.Lerp(v1, v2, 1f / 3f); Vector3 e2 = Vector3.Lerp(v1, v2, 2f / 3f); AddTriangle(center, v1, e1); AddTriangleColor(cell.color); AddTriangle(center, e1, e2); AddTriangleColor(cell.color); AddTriangle(center, e2, v2); AddTriangleColor(cell.color); 

18 पक्ष।

रिब जॉइंट डिवीजन

बेशक, हमें किनारे के जोड़ों को वश में करने की भी आवश्यकता है। इसलिए, हम TriangulateConnection लिए नए शीर्ष किनारों को पास करेंगे।

  if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, v1, e1, e2, v2); } 

TriangulateConnection लिए उपयुक्त पैरामीटर जोड़ें ताकि यह अतिरिक्त कोने के साथ काम कर सके।

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 e1, Vector3 e2, Vector3 v2 ) { … } 

हमें पड़ोसी कोशिकाओं के लिए किनारों के अतिरिक्त किनारों की गणना करने की भी आवश्यकता है। पुल को दूसरी तरफ से जोड़ने के बाद हम उनकी गणना कर सकते हैं।

  Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; v3.y = v4.y = neighbor.Position.y; Vector3 e3 = Vector3.Lerp(v3, v4, 1f / 3f); Vector3 e4 = Vector3.Lerp(v3, v4, 2f / 3f); 

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

  if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces(v1, v2, cell, v3, v4, neighbor); } else { AddQuad(v1, e1, v3, e3); AddQuadColor(cell.color, neighbor.color); AddQuad(e1, e2, e3, e4); AddQuadColor(cell.color, neighbor.color); AddQuad(e2, v2, e4, v4); AddQuadColor(cell.color, neighbor.color); } 

उपविभाजित कनेक्शन।

किनारों के किनारों का मिलन

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

 using UnityEngine; public struct EdgeVertices { public Vector3 v1, v2, v3, v4; } 

इसमें एक सुविधाजनक कंस्ट्रक्टर विधि जोड़ें, जो किनारे के मध्यवर्ती बिंदुओं की गणना से निपटेगा।

  public EdgeVertices (Vector3 corner1, Vector3 corner2) { v1 = corner1; v2 = Vector3.Lerp(corner1, corner2, 1f / 3f); v3 = Vector3.Lerp(corner1, corner2, 2f / 3f); v4 = corner2; } 

अब हम सेल के केंद्र और उसके किनारों के बीच त्रिकोण के एक प्रशंसक बनाने के लिए HexMesh लिए एक अलग HexMesh विधि जोड़ सकते हैं।

  void TriangulateEdgeFan (Vector3 center, EdgeVertices edge, Color color) { AddTriangle(center, edge.v1, edge.v2); AddTriangleColor(color); AddTriangle(center, edge.v2, edge.v3); AddTriangleColor(color); AddTriangle(center, edge.v3, edge.v4); AddTriangleColor(color); } 

और दो किनारों के बीच चतुष्कोण की एक पट्टी को त्रिभुज बनाने की एक विधि।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color c1, EdgeVertices e2, Color c2 ) { AddQuad(e1.v1, e1.v2, e2.v1, e2.v2); AddQuadColor(c1, c2); AddQuad(e1.v2, e1.v3, e2.v2, e2.v3); AddQuadColor(c1, c2); AddQuad(e1.v3, e1.v4, e2.v3, e2.v4); AddQuadColor(c1, c2); } 

यह हमें Triangulate पद्धति को सरल बनाने की अनुमति देगा।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.Position; EdgeVertices e = new EdgeVertices( center + HexMetrics.GetFirstSolidCorner(direction), center + HexMetrics.GetSecondSolidCorner(direction) ); TriangulateEdgeFan(center, e, cell.color); if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, e); } } 

चलिए TriangulateConnection पर चलते हैं। अब हम TriangulateEdgeStrip उपयोग कर सकते हैं, लेकिन अन्य प्रतिस्थापन करने की आवश्यकता है। जहां हम v1 का उपयोग करते थे, हमें e1.v1 का उपयोग करने की आवश्यकता है। इसी तरह, v2 e1.v4 बन जाता है, v3 e2.v1 बन जाता है, और v4 e2.v4 बन जाता है।

  void TriangulateConnection ( HexDirection direction, HexCell cell, EdgeVertices e1 ) { HexCell neighbor = cell.GetNeighbor(direction); if (neighbor == null) { return; } Vector3 bridge = HexMetrics.GetBridge(direction); bridge.y = neighbor.Position.y - cell.Position.y; EdgeVertices e2 = new EdgeVertices( e1.v1 + bridge, e1.v4 + bridge ); if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces(e1.v1, e1.v4, cell, e2.v1, e2.v4, neighbor); } else { TriangulateEdgeStrip(e1, cell.color, e2, neighbor.color); } HexCell nextNeighbor = cell.GetNeighbor(direction.Next()); if (direction <= HexDirection.E && nextNeighbor != null) { Vector3 v5 = e1.v4 + HexMetrics.GetBridge(direction.Next()); v5.y = nextNeighbor.Position.y; if (cell.Elevation <= neighbor.Elevation) { if (cell.Elevation <= nextNeighbor.Elevation) { TriangulateCorner( e1.v4, cell, e2.v4, neighbor, v5, nextNeighbor ); } else { TriangulateCorner( v5, nextNeighbor, e1.v4, cell, e2.v4, neighbor ); } } else if (neighbor.Elevation <= nextNeighbor.Elevation) { TriangulateCorner( e2.v4, neighbor, v5, nextNeighbor, e1.v4, cell ); } else { TriangulateCorner( v5, nextNeighbor, e1.v4, cell, e2.v4, neighbor ); } } 

लेडिज डिवीजन

हमें कड़ियों को विभाजित करने की आवश्यकता है। इसलिए, हम किनारों को TriangulateEdgeTerraces पास करते हैं।

  if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces(e1, cell, e2, neighbor); } 

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

  void TriangulateEdgeTerraces ( EdgeVertices begin, HexCell beginCell, EdgeVertices end, HexCell endCell ) { EdgeVertices e2 = EdgeVertices.TerraceLerp(begin, end, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.color, endCell.color, 1); TriangulateEdgeStrip(begin, beginCell.color, e2, c2); for (int i = 2; i < HexMetrics.terraceSteps; i++) { EdgeVertices e1 = e2; Color c1 = c2; e2 = EdgeVertices.TerraceLerp(begin, end, i); c2 = HexMetrics.TerraceLerp(beginCell.color, endCell.color, i); TriangulateEdgeStrip(e1, c1, e2, c2); } TriangulateEdgeStrip(e2, c2, end, endCell.color); } 

EdgeVertices.TerraceLerp विधि बस दो किनारों के EdgeVertices.TerraceLerp सभी चार जोड़े के बीच की EdgeVertices.TerraceLerp को प्रक्षेपित करती है।

  public static EdgeVertices TerraceLerp ( EdgeVertices a, EdgeVertices b, int step) { EdgeVertices result; result.v1 = HexMetrics.TerraceLerp(a.v1, b.v1, step); result.v2 = HexMetrics.TerraceLerp(a.v2, b.v2, step); result.v3 = HexMetrics.TerraceLerp(a.v3, b.v3, step); result.v4 = HexMetrics.TerraceLerp(a.v4, b.v4, step); return result; } 

उपविभाजित अगुवाई।

unitypackage

चट्टानों और पुलों को फिर से कनेक्ट करें

अब तक, हमने चट्टानों और पट्टियों के जंक्शन में दरारें की अनदेखी की है। इस समस्या को हल करने का समय आ गया है। आइए पहले चट्टान-ढलान-ढलान (OSS) और ढलान-चट्टान-ढलान (SOS) मामलों को देखें।


मेष छेद।

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

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

  void AddTriangleUnperturbed (Vector3 v1, Vector3 v2, Vector3 v3) { int vertexIndex = vertices.Count; vertices.Add(v1); vertices.Add(v2); vertices.Add(v3); triangles.Add(vertexIndex); triangles.Add(vertexIndex + 1); triangles.Add(vertexIndex + 2); } 

TriangulateBoundaryTriangle बदलें ताकि वह इस विधि का उपयोग करे। इसका मतलब यह है कि उसे स्पष्ट रूप से सभी सीमाओं को स्थानांतरित करना होगा, सीमा वाले लोगों को छोड़कर।

  void TriangulateBoundaryTriangle ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 boundary, Color boundaryColor ) { Vector3 v2 = HexMetrics.TerraceLerp(begin, left, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, 1); AddTriangleUnperturbed(Perturb(begin), Perturb(v2), boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v2; Color c1 = c2; v2 = HexMetrics.TerraceLerp(begin, left, i); c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, i); AddTriangleUnperturbed(Perturb(v1), Perturb(v2), boundary); AddTriangleColor(c1, c2, boundaryColor); } AddTriangleUnperturbed(Perturb(v2), Perturb(left), boundary); AddTriangleColor(c2, leftCell.color, boundaryColor); } 

यह निम्नलिखित ध्यान देने योग्य है: चूँकि हम किसी अन्य बिंदु को प्राप्त करने के लिए v2 का उपयोग नहीं करते हैं, हम इसे तुरंत स्थानांतरित कर सकते हैं। यह एक सरल अनुकूलन है और यह कोड की मात्रा को कम करता है, तो आइए इसे पेश करते हैं।

  void TriangulateBoundaryTriangle ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 boundary, Color boundaryColor ) { Vector3 v2 = Perturb(HexMetrics.TerraceLerp(begin, left, 1)); Color c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, 1); AddTriangleUnperturbed(Perturb(begin), v2, boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v2; Color c1 = c2; v2 = Perturb(HexMetrics.TerraceLerp(begin, left, i)); c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, i); AddTriangleUnperturbed(v1, v2, boundary); AddTriangleColor(c1, c2, boundaryColor); } AddTriangleUnperturbed(v2, Perturb(left), boundary); AddTriangleColor(c2, leftCell.color, boundaryColor); } 

बेमिसाल सीमाएँ।

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

  Vector3 boundary = Vector3.Lerp(Perturb(begin), Perturb(right), b); 

TriangulateCornerCliffTerraces पद्धति के लिए भी यही सत्य है।

  Vector3 boundary = Vector3.Lerp(Perturb(begin), Perturb(left), b); 

छेद हो गए हैं।

डबल चट्टान और ढलान

शेष सभी समस्याग्रस्त मामलों में, दो चट्टानें और एक ढलान मौजूद हैं।


एकल त्रिकोण के कारण बड़ा छेद।

यह समस्या मैन्युअल रूप से TriangulateCornerTerracesCliff के अंत में else ब्लॉक में एकल त्रिभुज को स्थानांतरित करके हल की गई है।

  else { AddTriangleUnperturbed(Perturb(left), Perturb(right), boundary); AddTriangleColor(leftCell.color, rightCell.color, boundaryColor); } 

वही TriangulateCornerCliffTerraces लिए जाता है।

  else { AddTriangleUnperturbed(Perturb(left), Perturb(right), boundary); AddTriangleColor(leftCell.color, rightCell.color, boundaryColor); } 

नवीनतम दरारों से छुटकारा पाएं।

unitypackage

पुनर्निमाण

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



अविभाजित और विकृत मेष।

ऐसा लगता है कि कोशिकाओं को विकृत करने के लिए बल 5 बहुत महान है।


कोशिकाओं की विकृति 0 से 5 तक है।

चलो ग्रिड की सुविधा को बढ़ाने के लिए इसे 4 तक कम करें, बिना इसे सही किए। यह सुनिश्चित करता है कि अधिकतम XZ ऑफसेट ≈32 units 5.66 यूनिट होगा।

  public const float cellPerturbStrength = 4f; 

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


0.75 से 0.95 तक अखंडता का गुणांक।

0.8 की अखंडता के गुणांक में थोड़ी वृद्धि भविष्य में हमारे जीवन को थोड़ा सरल करेगी।

  public const float solidFactor = 0.8f; 

अखंडता का गुणांक 0.8।

अंत में, आप देख सकते हैं कि ऊंचाई स्तरों के बीच अंतर बहुत तेज हैं। यह सुविधाजनक है जब आपको यह सुनिश्चित करने की आवश्यकता होती है कि मेष सही ढंग से उत्पन्न हुआ है, लेकिन हम पहले से ही इसके साथ कर रहे हैं। चलो इसे 1 यूनिट प्रति चरण चरण तक कम करें, अर्थात 3 तक।

  public const float elevationStep = 3f; 

पिच कम हो गई है 3.

हम पिच विरूपण की ताकत भी बदल सकते हैं। लेकिन अब इसका मूल्य 1.5 है, जो ऊंचाई में आधा कदम के बराबर है, जो हमें सूट करता है।

ऊँचाई के छोटे चरण ऊंचाई के सभी सात स्तरों के अधिक तार्किक उपयोग की अनुमति देते हैं। इससे मानचित्र की परिवर्तनशीलता बढ़ जाती है।


हम ऊंचाइयों के सात स्तरों का उपयोग करते हैं।

unitypackage

भाग 5: बड़े कार्ड

• हम ग्रिड को टुकड़ों में विभाजित करते हैं।
• हम कैमरे को नियंत्रित करते हैं।
• रंगों और ऊंचाइयों को अलग-अलग रंग दें।
• कोशिकाओं के बढ़े हुए ब्रश का उपयोग करें।

अभी तक हम बहुत छोटे नक्शे के साथ काम कर रहे हैं। इसे बढ़ाने का समय आ गया है।


इसमें ज़ूम करने का समय है।

जाल के टुकड़े

हम ग्रिड को बहुत बड़ा नहीं बना सकते, क्योंकि हम एक जाली में फिट होने की सीमा में चलते हैं। इस समस्या को कैसे हल करें? कई जालों का उपयोग करें। ऐसा करने के लिए, हमें अपने ग्रिड को कई टुकड़ों में विभाजित करना होगा। हम निरंतर आकार के आयताकार टुकड़े का उपयोग करते हैं।


ग्रिड को 3 से 3 खंडों में विभाजित करना।

आइए 5 का उपयोग 5 ब्लॉकों में करें, यानी प्रति खंड 25 कोशिकाएं। उन्हें परिभाषित करें HexMetrics।

  public const int chunkSizeX = 5, chunkSizeZ = 5; 

अब हम जाल के लिए किसी भी आकार का उपयोग नहीं कर सकते हैं, यह कई आकार का होना चाहिए। इसलिए, इसे बदल दें HexGridताकि यह अलग-अलग कोशिकाओं में नहीं बल्कि टुकड़ों में अपना आकार निर्धारित करे। डिफ़ॉल्ट आकार को 4 से 3 टुकड़े पर सेट करें, अर्थात, केवल 12 टुकड़े या 300 सेल। इसलिए हमें एक सुविधाजनक परीक्षा कार्ड मिलता है।

  public int chunkCountX = 4, chunkCountZ = 3; 

हम अभी भी उपयोग करते हैं widthऔर height, लेकिन अब उन्हें निजी होना चाहिए। और उनका नाम बदल cellCountXऔर cellCountZ। एक ही बार में इन चर की सभी घटनाओं का नाम बदलने के लिए संपादक का उपयोग करें। अब यह स्पष्ट होगा कि हम टुकड़ों या कोशिकाओं की संख्या के साथ काम कर रहे हैं।

 // public int width = 6; // public int height = 6; int cellCountX, cellCountZ; 

टुकड़ों में आकार निर्दिष्ट करें।

बदलो Awakeताकि, यदि आवश्यक हो, तो टुकड़ों की संख्या से कोशिकाओं की संख्या की गणना की जाए। हम एक अलग तरीके से कोशिकाओं के निर्माण को उजागर करते हैं, ताकि रोकना न हो Awake।

  void Awake () { HexMetrics.noiseSource = noiseSource; gridCanvas = GetComponentInChildren<Canvas>(); hexMesh = GetComponentInChildren<HexMesh>(); cellCountX = chunkCountX * HexMetrics.chunkSizeX; cellCountZ = chunkCountZ * HexMetrics.chunkSizeZ; CreateCells(); } void CreateCells () { cells = new HexCell[cellCountZ * cellCountX]; for (int z = 0, i = 0; z < cellCountZ; z++) { for (int x = 0; x < cellCountX; x++) { CreateCell(x, z, i++); } } } 

भगदड़ प्रीफ़ब

जाल के टुकड़े का वर्णन करने के लिए, हमें एक नए प्रकार के घटक की आवश्यकता है।

 using UnityEngine; using UnityEngine.UI; public class HexGridChunk : MonoBehaviour { } 

आगे हम एक प्रीफैब टुकड़ा बनाएंगे। हम हेक्स ग्रिड ऑब्जेक्ट को डुप्लिकेट करके और हेक्स ग्रिड चंक का नाम बदलकर ऐसा करेंगे । इसके घटक को निकालें HexGridऔर इसके बजाय एक घटक जोड़ें HexGridChunk। फिर इसे प्रीफ़ैब में बदल दें और ऑब्जेक्ट को सीन से हटा दें।



अपने स्वयं के कैनवास और जाल के साथ एक टुकड़ा प्रीफ़ैब।

चूंकि वह इन अंशों के उदाहरण बनाएगा HexGrid, इसलिए हम उसे खंड के प्रीफ़ैब का लिंक देंगे।

  public HexGridChunk chunkPrefab; 

अब टुकड़ों के साथ।

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

  HexGridChunk[] chunks; void Awake () { … CreateChunks(); CreateCells(); } void CreateChunks () { chunks = new HexGridChunk[chunkCountX * chunkCountZ]; for (int z = 0, i = 0; z < chunkCountZ; z++) { for (int x = 0; x < chunkCountX; x++) { HexGridChunk chunk = chunks[i++] = Instantiate(chunkPrefab); chunk.transform.SetParent(transform); } } } 

एक टुकड़े को शुरू करना हम हेक्सागोन्स के एक ग्रिड को कैसे शुरू करते हैं, इसके समान है। वह सब कुछ सेट Awakeकरती है और इसमें त्रिकोणासन करती है Start। इसके कैनवास और जाल के संदर्भ के साथ-साथ कोशिकाओं के लिए एक सरणी की आवश्यकता होती है। हालांकि, टुकड़ा इन कोशिकाओं का निर्माण नहीं करेगा। ग्रिड ऐसा करना जारी रखेगा।

 public class HexGridChunk : MonoBehaviour { HexCell[] cells; HexMesh hexMesh; Canvas gridCanvas; void Awake () { gridCanvas = GetComponentInChildren<Canvas>(); hexMesh = GetComponentInChildren<HexMesh>(); cells = new HexCell[HexMetrics.chunkSizeX * HexMetrics.chunkSizeZ]; } void Start () { hexMesh.Triangulate(cells); } } 

टुकड़े करने के लिए सेल निरुपित

HexGridअभी भी सभी सेल बनाता है। यह सामान्य है, लेकिन अब हमें प्रत्येक सेल को एक उपयुक्त टुकड़े में जोड़ने की आवश्यकता है, और उन्हें अपने स्वयं के जाल और कैनवास का उपयोग करके सेट नहीं करना है।

  void CreateCell (int x, int z, int i) { … HexCell cell = cells[i] = Instantiate<HexCell>(cellPrefab); // cell.transform.SetParent(transform, false); cell.transform.localPosition = position; cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.color = defaultColor; … Text label = Instantiate<Text>(cellLabelPrefab); // label.rectTransform.SetParent(gridCanvas.transform, false); label.rectTransform.anchoredPosition = new Vector2(position.x, position.z); label.text = cell.coordinates.ToStringOnSeparateLines(); cell.uiRect = label.rectTransform; cell.Elevation = 0; AddCellToChunk(x, z, cell); } void AddCellToChunk (int x, int z, HexCell cell) { } 

हम पूर्णांक विभाजन का उपयोग करके xऔर zखंड आकार द्वारा सही टुकड़ा पा सकते हैं ।

  void AddCellToChunk (int x, int z, HexCell cell) { int chunkX = x / HexMetrics.chunkSizeX; int chunkZ = z / HexMetrics.chunkSizeZ; HexGridChunk chunk = chunks[chunkX + chunkZ * chunkCountX]; } 

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

  void AddCellToChunk (int x, int z, HexCell cell) { int chunkX = x / HexMetrics.chunkSizeX; int chunkZ = z / HexMetrics.chunkSizeZ; HexGridChunk chunk = chunks[chunkX + chunkZ * chunkCountX]; int localX = x - chunkX * HexMetrics.chunkSizeX; int localZ = z - chunkZ * HexMetrics.chunkSizeZ; chunk.AddCell(localX + localZ * HexMetrics.chunkSizeX, cell); } 

तब यह HexGridChunk.AddCellसेल को अपने सरणी में रखता है, और फिर यह सेल और उसके UI के लिए मूल तत्वों को सेट करता है।

  public void AddCell (int index, HexCell cell) { cells[index] = cell; cell.transform.SetParent(transform, false); cell.uiRect.SetParent(gridCanvas.transform, false); } 

मिटाना

इस बिंदु पर, वह HexGridअपने बच्चों के कैनवास और षट्भुज जाल से छुटकारा पा सकता है, साथ ही साथ कोड भी।

 // Canvas gridCanvas; // HexMesh hexMesh; void Awake () { HexMetrics.noiseSource = noiseSource; // gridCanvas = GetComponentInChildren<Canvas>(); // hexMesh = GetComponentInChildren<HexMesh>(); … } // void Start () { // hexMesh.Triangulate(cells); // } // public void Refresh () { // hexMesh.Triangulate(cells); // } 

चूंकि हमें छुटकारा मिल गया है Refresh, हमें HexMapEditorइसका उपयोग नहीं करना चाहिए ।

  void EditCell (HexCell cell) { cell.color = activeColor; cell.Elevation = activeElevation; // hexGrid.Refresh(); } 

हेक्सागोन्स की साफ ग्रिड।

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


प्ले मोड में बाल टुकड़े।

शायद हमें सेल लेबल के साथ कुछ समस्याएं हैं। प्रारंभ में, हमने लेबल की चौड़ाई 5 पर सेट की। यह उन दो पात्रों को प्रदर्शित करने के लिए पर्याप्त था जो हमारे लिए एक छोटे से नक्शे पर पर्याप्त थे। लेकिन अब हमारे पास ,10 जैसे निर्देशांक हो सकते हैं, जिसमें तीन वर्ण हैं। वे फिट नहीं होंगे और छंटनी की जाएगी। इसे ठीक करने के लिए, सेल लेबल की चौड़ाई बढ़ाकर 10 या इससे भी अधिक कर दें।



विस्तारित सेल लेबल।

अब हम बहुत बड़े मानचित्र बना सकते हैं! चूंकि हम पूरे ग्रिड को स्टार्टअप में उत्पन्न करते हैं, इसलिए बड़े मानचित्र बनाने में लंबा समय लग सकता है। लेकिन पूरा होने के बाद, हमारे पास प्रयोग के लिए एक विशाल स्थान होगा।

सेल संपादन ठीक करें

संपादन वर्तमान चरण में काम नहीं करता है, क्योंकि हम अब ग्रिड को अपडेट नहीं करते हैं। हम टुकड़े, तो एक विधि की जरूरत अद्यतन किया जा करने के लिए जोड़ Refreshलिए HexGridChunk।

  public void Refresh () { hexMesh.Triangulate(cells); } 

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

लेकिन हम कैसे जानते हैं कि अद्यतन करने के लिए कौन सा टुकड़ा है? सबसे आसान तरीका यह है कि प्रत्येक कोशिका को पता हो कि वह किस टुकड़े से संबंधित है। तब सेल इस सेल को बदलते समय इसके टुकड़े को अपडेट कर सकेगी। तो चलिए HexCellइसके टुकड़े का लिंक देते हैं।

  public HexGridChunk chunk; 

HexGridChunk जोड़ने पर सेल में खुद को जोड़ सकते हैं।

  public void AddCell (int index, HexCell cell) { cells[index] = cell; cell.chunk = this; cell.transform.SetParent(transform, false); cell.uiRect.SetParent(gridCanvas.transform, false); } 

उन्हें जोड़कर, हम HexCellविधि में जोड़ते हैं Refresh। हर बार एक सेल अपडेट होने के बाद, यह बस इसके टुकड़े को अपडेट करेगा।

  void Refresh () { chunk.Refresh(); } 

हमें इसे HexCell.Refreshसामान्य बनाने की आवश्यकता नहीं है , क्योंकि जब इसे बदला गया था तो सेल स्वयं बेहतर जानता है। उदाहरण के लिए, इसकी ऊंचाई को बदलने के बाद।

  public int Elevation { get { return elevation; } set { … Refresh(); } } 

वास्तव में, हमें इसे तभी अपडेट करने की आवश्यकता है जब इसकी ऊंचाई एक अलग मूल्य में बदल गई हो। यदि हमें पहले की तरह ही ऊँचाई प्रदान करनी हो, तो उसे फिर से गणना करने की आवश्यकता नहीं है। इसलिए, हम सेटर की शुरुआत से बाहर निकल सकते हैं।

  public int Elevation { get { return elevation; } set { if (elevation == value) { return; } … } } 

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

  int elevation = int.MinValue; 

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

  public Color Color { get { return color; } set { if (color == value) { return; } color = value; Refresh(); } } Color color; 

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

  void Refresh () { if (chunk) { chunk.Refresh(); } } 

हम अंततः कोशिकाओं को फिर से बदल सकते हैं! हालाँकि, एक समस्या उत्पन्न होती है। जब टुकड़ों की सीमाओं के साथ ड्राइंग, सीम दिखाई देते हैं।


टुकड़ों की सीमाओं में त्रुटियां।

यह तर्कसंगत है, क्योंकि जब एक एकल कोशिका बदलती है, तो उसके पड़ोसियों के साथ सभी कनेक्शन भी बदलते हैं। और ये पड़ोसी अन्य टुकड़ों में हो सकते हैं। सबसे सरल समाधान सभी पड़ोसी कोशिकाओं को अद्यतन करना है यदि वे अलग-अलग हैं।

  void Refresh () { if (chunk) { chunk.Refresh(); for (int i = 0; i < neighbors.Length; i++) { HexCell neighbor = neighbors[i]; if (neighbor != null && neighbor.chunk != chunk) { neighbor.chunk.Refresh(); } } } } 

हालांकि यह काम करता है, लेकिन यह पता चल सकता है कि हम एक टुकड़े को कई बार अपडेट करते हैं। और जब हम एक बार में कई कोशिकाओं को रंगना शुरू करते हैं, तो सब कुछ खराब हो जाएगा।

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

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

हम LateUpdateइसके बजाय उपयोग करते हैंUpdate वर्तमान फ्रेम के लिए परिवर्तन पूरा होने के बाद यह सुनिश्चित करने के लिए कि त्रिकोणासन होता है।

  public void Refresh () { // hexMesh.Triangulate(cells); enabled = true; } void LateUpdate () { hexMesh.Triangulate(cells); enabled = false; } 

चूंकि हमारा घटक डिफ़ॉल्ट रूप से सक्षम है, इसलिए हमें अब स्पष्ट रूप से त्रिकोणासन करने की आवश्यकता नहीं है Start। इसलिए, इस विधि को हटाया जा सकता है।

 // void Start () { // hexMesh.Triangulate(cells); // } 

10,000 कोशिकाओं वाले 20 से 20 के टुकड़े।

सामान्यीकृत सूची

यद्यपि हमने ग्रिड को त्रिभुजित करने के तरीके में महत्वपूर्ण रूप से परिवर्तन किया है, HexMeshयह एक समान है। उसे काम करने की जरूरत है, यह एक सरणी है। अगर हेक्सागोन्स या उनमें से कई का एक जाल है तो वह परवाह नहीं करता है। लेकिन हमने अभी तक कई मेश का उपयोग करने पर विचार नहीं किया है। शायद यहाँ कुछ सुधारा जा सकता है?

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

  static List<Vector3> vertices = new List<Vector3>(); static List<Color> colors = new List<Color>(); static List<int> triangles = new List<int>(); void Awake () { GetComponent<MeshFilter>().mesh = hexMesh = new Mesh(); meshCollider = gameObject.AddComponent<MeshCollider>(); hexMesh.name = "Hex Mesh"; // vertices = new List<Vector3>(); // colors = new List<Color>(); // triangles = new List<int>(); } 

unitypackage

कैमरा नियंत्रण

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

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


कैमरे का पदानुक्रम।

कैमरा काज (कुंडा) का लक्ष्य उस कोण को नियंत्रित करना है जिस पर कैमरा नक्शे पर दिखता है। आइए हम इसे एक मोड़ दें (45, 0, 0)। हैंडल (स्टिक) उस दूरी को नियंत्रित करता है जिस पर कैमरे स्थित हैं। आइए उसकी स्थिति निर्धारित करें (0, 0, -45)।

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

 using UnityEngine; public class HexMapCamera : MonoBehaviour { Transform swivel, stick; void Awake () { swivel = transform.GetChild(0); stick = swivel.GetChild(0); } } 

षट्कोण मानचित्र कैमरा।

ज़ूम

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

  float zoom = 1f; 

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

  void Update () { float zoomDelta = Input.GetAxis("Mouse ScrollWheel"); if (zoomDelta != 0f) { AdjustZoom(zoomDelta); } } void AdjustZoom (float delta) { } 

ज़ूम स्तर को बदलने के लिए, हम बस इसमें एक डेल्टा जोड़ते हैं और फिर मान को सीमित करते हैं (0-8)।

  void AdjustZoom (float delta) { zoom = Mathf.Clamp01(zoom + delta); } 

ज़ूम इन और आउट करते समय, कैमरे की दूरी तदनुसार बदलनी चाहिए। यह Z की हैंडल की स्थिति को बदलकर किया जा सकता है। न्यूनतम और अधिकतम ज़ूम पर हैंडल की स्थिति को समायोजित करने के लिए दो सामान्य फ्लोट चर जोड़ें। चूंकि हम अपेक्षाकृत छोटे मानचित्र विकसित कर रहे हैं, इसलिए मानों को -250 और -45 पर सेट करें।

  public float stickMinZoom, stickMaxZoom; 

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

  void AdjustZoom (float delta) { zoom = Mathf.Clamp01(zoom + delta); float distance = Mathf.Lerp(stickMinZoom, stickMaxZoom, zoom); stick.localPosition = new Vector3(0f, 0f, distance); } 

न्यूनतम और अधिकतम स्टिक मान।

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

  public float swivelMinZoom, swivelMaxZoom; 

संभाल की स्थिति के साथ, हम एक उपयुक्त ज़ूम कोण खोजने के लिए प्रक्षेपित करते हैं। फिर हम काज के रोटेशन को सेट करते हैं।

  void AdjustZoom (float delta) { zoom = Mathf.Clamp01(zoom + delta); float distance = Mathf.Lerp(stickMinZoom, stickMaxZoom, zoom); stick.localPosition = new Vector3(0f, 0f, distance); float angle = Mathf.Lerp(swivelMinZoom, swivelMaxZoom, zoom); swivel.localRotation = Quaternion.Euler(angle, 0f, 0f); } 

कुंडा का न्यूनतम और अधिकतम मूल्य।

माउस व्हील के इनपुट मापदंडों की संवेदनशीलता को बदलकर ज़ूम के परिवर्तन की दर को समायोजित किया जा सकता है। वे संपादन / परियोजना सेटिंग्स / इनपुट में पाए जा सकते हैं । उदाहरण के लिए, उन्हें ०.१ से ०.०२५ तक बदलने पर, हमें ज़ूम में एक धीमी और चिकनी बदलाव मिलता है।


माउस व्हील इनपुट विकल्प।

विस्थापन

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

  void Update () { float zoomDelta = Input.GetAxis("Mouse ScrollWheel"); if (zoomDelta != 0f) { AdjustZoom(zoomDelta); } float xDelta = Input.GetAxis("Horizontal"); float zDelta = Input.GetAxis("Vertical"); if (xDelta != 0f || zDelta != 0f) { AdjustPosition(xDelta, zDelta); } } void AdjustPosition (float xDelta, float zDelta) { } 

सबसे सरल तरीका कैमरा सिस्टम की वर्तमान स्थिति को प्राप्त करना है, इसमें डेल्टास एक्स और जेड को जोड़ना है, और सिस्टम की स्थिति को परिणाम असाइन करना है।

  void AdjustPosition (float xDelta, float zDelta) { Vector3 position = transform.localPosition; position += new Vector3(xDelta, 0f, zDelta); transform.localPosition = position; } 

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

  public float moveSpeed; void AdjustPosition (float xDelta, float zDelta) { float distance = moveSpeed * Time.deltaTime; Vector3 position = transform.localPosition; position += new Vector3(xDelta, 0f, zDelta) * distance; transform.localPosition = position; } 

गति बढ़ रही है।

अब हम एक्स या जेड कुल्हाड़ियों के साथ एक स्थिर गति से आगे बढ़ सकते हैं। लेकिन जब एक ही समय (तिरछे) दोनों कुल्हाड़ियों के साथ आगे बढ़ेंगे तो आंदोलन तेज होगा। इसे ठीक करने के लिए, हमें डेल्टा वेक्टर को सामान्य करने की आवश्यकता है। यह आपको गंतव्य के रूप में उपयोग करने की अनुमति देगा।

  void AdjustPosition (float xDelta, float zDelta) { Vector3 direction = new Vector3(xDelta, 0f, zDelta).normalized; float distance = moveSpeed * Time.deltaTime; Vector3 position = transform.localPosition; position += direction * distance; transform.localPosition = position; } 

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

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

  Vector3 direction = new Vector3(xDelta, 0f, zDelta).normalized; float damping = Mathf.Max(Mathf.Abs(xDelta), Mathf.Abs(zDelta)); float distance = moveSpeed * damping * Time.deltaTime; 

क्षीणन के साथ आंदोलन।

अब आंदोलन अच्छी तरह से काम करता है, कम से कम ज़ूम में वृद्धि के साथ। लेकिन कुछ ही दूरी पर यह बहुत धीमा हो जाता है। कम ज़ूम के साथ, हमें गति बढ़ाने की आवश्यकता है। यह moveSpeedन्यूनतम और अधिकतम ज़ूम के लिए दो के साथ एक चर को प्रतिस्थापित करके और फिर इंटरपोलिंग करके किया जा सकता है । उन्हें 400 और 100 के मान प्रदान करें।

 // public float moveSpeed; public float moveSpeedMinZoom, moveSpeedMaxZoom; void AdjustPosition (float xDelta, float zDelta) { Vector3 direction = new Vector3(xDelta, 0f, zDelta).normalized; float damping = Mathf.Max(Mathf.Abs(xDelta), Mathf.Abs(zDelta)); float distance = Mathf.Lerp(moveSpeedMinZoom, moveSpeedMaxZoom, zoom) * damping * Time.deltaTime; Vector3 position = transform.localPosition; position += direction * distance; transform.localPosition = position; } 

आंदोलन की गति ज़ूम स्तर के साथ बदलती है।

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

  public HexGrid grid; 

ग्रिड आकार का अनुरोध करने की आवश्यकता है।

एक नई स्थिति में जाने के बाद, हम नई विधि का उपयोग करके इसे सीमित करेंगे।

  void AdjustPosition (float xDelta, float zDelta) { … transform.localPosition = ClampPosition(position); } Vector3 ClampPosition (Vector3 position) { return position; } 

स्थिति X का न्यूनतम मान 0 है, और अधिकतम मानचित्र के आकार से निर्धारित होता है।

  Vector3 ClampPosition (Vector3 position) { float xMax = grid.chunkCountX * HexMetrics.chunkSizeX * (2f * HexMetrics.innerRadius); position.x = Mathf.Clamp(position.x, 0f, xMax); return position; } 

यही स्थिति Z पर लागू होती है।

  Vector3 ClampPosition (Vector3 position) { float xMax = grid.chunkCountX * HexMetrics.chunkSizeX * (2f * HexMetrics.innerRadius); position.x = Mathf.Clamp(position.x, 0f, xMax); float zMax = grid.chunkCountZ * HexMetrics.chunkSizeZ * (1.5f * HexMetrics.outerRadius); position.z = Mathf.Clamp(position.z, 0f, zMax); return position; } 

वास्तव में, यह थोड़ा गलत है। प्रारंभिक बिंदु कोशिका के केंद्र में है, बाईं ओर नहीं। इसलिए, हम चाहते हैं कि कैमरा सबसे सही कोशिकाओं के केंद्र में बंद हो। ऐसा करने के लिए, एक्स के अधिकतम से आधे सेल को घटाएं।

  float xMax = (grid.chunkCountX * HexMetrics.chunkSizeX - 0.5f) * (2f * HexMetrics.innerRadius); position.x = Mathf.Clamp(position.x, 0f, xMax); 

उसी कारण से, हमें अधिकतम जेड को कम करने की आवश्यकता है। चूंकि मैट्रिक्स थोड़ा अलग हैं, हमें पूर्ण सेल को घटाना होगा।

  float zMax = (grid.chunkCountZ * HexMetrics.chunkSizeZ - 1) * (1.5f * HexMetrics.outerRadius); position.z = Mathf.Clamp(position.z, 0f, zMax); 

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

आप कीबोर्ड इनपुट सुनने से यूआई को रोक सकते हैं। यह EventSystem ऑब्जेक्ट को नेविगेशन नेविगेशन इवेंट्स को निष्पादित नहीं करने का निर्देश देकर किया जा सकता है ।


कोई और नेविगेशन इवेंट नहीं।

मोड़

देखना चाहते हैं कि चट्टान के पीछे क्या है? कैमरे को घुमाने में सक्षम होना सुविधाजनक होगा! आइए इस सुविधा को जोड़ते हैं।

रोटेशन के लिए ज़ूम स्तर महत्वपूर्ण नहीं है, केवल गति पर्याप्त है। एक सामान्य चर जोड़ें rotationSpeedऔर इसे 180 डिग्री पर सेट करें। रोटेशनUpdate अक्ष की जांच करके और यदि आवश्यक हो तो रोटेशन को बदलकर रोटेशन डेल्टा की जाँच करें ।

  public float rotationSpeed; void Update () { float zoomDelta = Input.GetAxis("Mouse ScrollWheel"); if (zoomDelta != 0f) { AdjustZoom(zoomDelta); } float rotationDelta = Input.GetAxis("Rotation"); if (rotationDelta != 0f) { AdjustRotation(rotationDelta); } float xDelta = Input.GetAxis("Horizontal"); float zDelta = Input.GetAxis("Vertical"); if (xDelta != 0f || zDelta != 0f) { AdjustPosition(xDelta, zDelta); } } void AdjustRotation (float delta) { } 

मुड़ने की गति।

वास्तव में, रोटेशन अक्ष डिफ़ॉल्ट रूप से नहीं है। हमें इसे स्वयं बनाना होगा। इनपुट मापदंडों पर जाएं और सबसे ऊपरी प्रविष्टि को लंबवत डुप्लिकेट करें । डुप्लिकेट का नाम बदलकर Rotation और कुंजियों को QE और अल्पविराम (,) के साथ एक अवधि () में बदलें।


इनपुट अक्ष को चालू करें।


रोटेशन कोण हम ट्रैक करेंगे और अंदर बदलेंगे AdjustRotation। जिसके बाद हम पूरे कैमरा सिस्टम को रोटेट करेंगे।

  float rotationAngle; void AdjustRotation (float delta) { rotationAngle += delta * rotationSpeed * Time.deltaTime; transform.localRotation = Quaternion.Euler(0f, rotationAngle, 0f); } 

चूंकि पूर्ण चक्र 360 डिग्री है, इसलिए हम रोटेशन कोण को रोल करते हैं ताकि यह 0 से 360 तक हो।

  void AdjustRotation (float delta) { rotationAngle += delta * rotationSpeed * Time.deltaTime; if (rotationAngle < 0f) { rotationAngle += 360f; } else if (rotationAngle >= 360f) { rotationAngle -= 360f; } transform.localRotation = Quaternion.Euler(0f, rotationAngle, 0f); } 

कार्रवाई में बारी।

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

  void AdjustPosition (float xDelta, float zDelta) { Vector3 direction = transform.localRotation * new Vector3(xDelta, 0f, zDelta).normalized; … } 

सापेक्ष विस्थापन।

unitypackage

उन्नत संपादन

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

वैकल्पिक रंग और ऊंचाई

हम टॉगल समूह में एक खाली चयन विकल्प जोड़कर रंगों को वैकल्पिक बना सकते हैं। रंग स्विचेस में से किसी एक को डुप्लिकेट करें और इसके लेबल को --- या कुछ इसी तरह से इंगित करें कि यह रंग नहीं है। फिर इसके ऑन वैल्यू चेंजेड इवेंट के तर्क को बदलकर its1 कर दें।


अमान्य रंग सूचकांक।

बेशक, यह सूचकांक रंगों की एक सरणी के लिए मान्य नहीं है। हम यह निर्धारित करने के लिए उपयोग कर सकते हैं कि क्या रंग कोशिकाओं पर लागू होना चाहिए।

  bool applyColor; public void SelectColor (int index) { applyColor = index >= 0; if (applyColor) { activeColor = colors[index]; } } void EditCell (HexCell cell) { if (applyColor) { cell.Color = activeColor; } cell.Elevation = activeElevation; } 

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

  bool applyElevation = true; void EditCell (HexCell cell) { if (applyColor) { cell.Color = activeColor; } if (applyElevation) { cell.Elevation = activeElevation; } } 

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


वैकल्पिक रंग और ऊंचाई।

ऊंचाई को सक्षम करने के लिए, हमें एक नई विधि की आवश्यकता है, जिसे हम UI के साथ जोड़ेंगे।

  public void SetApplyElevation (bool toggle) { applyElevation = toggle; } 

इसे ऊंचाई स्विच से कनेक्ट करके, सुनिश्चित करें कि डायनामिक बूल विधि का उपयोग विधियों की सूची के शीर्ष पर किया जाता है। सही संस्करण निरीक्षक में चेकमार्क प्रदर्शित नहीं करते हैं।


हम ऊंचाई स्विच की स्थिति को प्रसारित करते हैं।

अब हम केवल फूलों या केवल ऊंचाई के साथ रंग का चयन कर सकते हैं। या दोनों, हमेशा की तरह। हम या तो एक या दूसरे को नहीं बदलने का विकल्प चुन सकते हैं, लेकिन अभी तक यह हमारे लिए विशेष रूप से उपयोगी नहीं है।


रंग और ऊंचाई के बीच स्विच करें।

ब्रश का आकार

आकार देने योग्य ब्रश आकार का समर्थन करने के लिए, पूर्णांक चर brushSizeऔर UI के माध्यम से इसे सेट करने के लिए एक विधि जोड़ें । हम स्लाइडर का उपयोग करेंगे, इसलिए फिर से हमें मान को फ्लोट से इंट में बदलना होगा।

  int brushSize; public void SetBrushSize (float size) { brushSize = (int)size; } 

ब्रश के आकार का स्लाइडर।

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


ब्रश आकार स्लाइडर सेटिंग्स।

अब जब हम एक ही समय में कई कोशिकाओं को संपादित कर सकते हैं, तो हमें विधि का उपयोग करने की आवश्यकता है EditCells। इस विधि में EditCellशामिल सभी कोशिकाओं के लिए कॉल किया जाएगा । प्रारंभ में चयनित सेल को ब्रश का केंद्र माना जाएगा।

  void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { EditCells(hexGrid.GetCell(hit.point)); } } void EditCells (HexCell center) { } void EditCell (HexCell cell) { … } 

ब्रश का आकार संपादन की त्रिज्या निर्धारित करता है। 0 की त्रिज्या के साथ, यह केवल एक केंद्रीय सेल होगा। 1 की त्रिज्या के साथ, यह केंद्र और इसके पड़ोसी होंगे। 2 के दायरे में, केंद्र के पड़ोसी और उनके निकटवर्ती पड़ोसी स्विच ऑन हैं। और इसी तरह।


त्रिज्या तक। 3.

कोशिकाओं को संपादित करने के लिए, आपको एक लूप में उनके चारों ओर जाने की आवश्यकता है। पहले हमें केंद्र के एक्स और जेड निर्देशांक की आवश्यकता होती है।

  void EditCells (HexCell center) { int centerX = center.coordinates.X; int centerZ = center.coordinates.Z; } 

हम त्रिज्या को घटाकर न्यूनतम Z समन्वय पाते हैं। तो हम शून्य रेखा को परिभाषित करते हैं। इस लाइन पर शुरू करते हुए, हम केंद्र में लाइन को कवर करने तक लूप करते हैं।

  void EditCells (HexCell center) { int centerX = center.coordinates.X; int centerZ = center.coordinates.Z; for (int r = 0, z = centerZ - brushSize; z <= centerZ; z++, r++) { } } 

नीचे की पंक्ति में पहली सेल में केंद्र सेल के समान एक्स समन्वय होता है। यह समन्वय बढ़ती संख्या के साथ घटता जाता है।

अंतिम सेल में हमेशा केंद्र समन्वय प्लस त्रिज्या के बराबर एक एक्स समन्वय होता है।

अब हम प्रत्येक पंक्ति के चारों ओर लूप कर सकते हैं और उनके निर्देशांक द्वारा कोशिकाएं प्राप्त कर सकते हैं।

  for (int r = 0, z = centerZ - brushSize; z <= centerZ; z++, r++) { for (int x = centerX - r; x <= centerX + brushSize; x++) { EditCell(hexGrid.GetCell(new HexCoordinates(x, z))); } } 

हमारे पास अभी तक HexGrid.GetCellसमन्वय पैरामीटर के साथ एक विधि नहीं है , इसलिए इसे बनाएं। विस्थापन के निर्देशांक में परिवर्तित करें और सेल प्राप्त करें।

  public HexCell GetCell (HexCoordinates coordinates) { int z = coordinates.Z; int x = coordinates.X + z / 2; return cells[x + z * cellCountX]; } 

ब्रश का निचला हिस्सा, आकार 2.

हम बाकी ब्रश को कवर करते हैं, ऊपर से नीचे तक एक चक्र का प्रदर्शन करते हैं। इस स्थिति में, तर्क को प्रतिबिंबित किया जाता है और केंद्रीय पंक्ति को बाहर करने की आवश्यकता होती है।

  void EditCells (HexCell center) { int centerX = center.coordinates.X; int centerZ = center.coordinates.Z; for (int r = 0, z = centerZ - brushSize; z <= centerZ; z++, r++) { for (int x = centerX - r; x <= centerX + brushSize; x++) { EditCell(hexGrid.GetCell(new HexCoordinates(x, z))); } } for (int r = 0, z = centerZ + brushSize; z > centerZ; z--, r++) { for (int x = centerX - brushSize; x <= centerX + r; x++) { EditCell(hexGrid.GetCell(new HexCoordinates(x, z))); } } } 

संपूर्ण ब्रश, आकार 2.

यह तब तक काम करता है, जब तक कि हमारा ब्रश ग्रिड की सीमाओं से परे नहीं जाता है। जब ऐसा होता है, तो हमें एक इंडेक्स-आउट-ऑफ-रेंज अपवाद मिलता है। इससे बचने के लिए, सीमाओं की जांच करें HexGrid.GetCellऔर nullजब कोई भी बिना सेल के अनुरोध किया जाता है तो वापस लौटें ।

  public HexCell GetCell (HexCoordinates coordinates) { int z = coordinates.Z; if (z < 0 || z >= cellCountZ) { return null; } int x = coordinates.X + z / 2; if (x < 0 || x >= cellCountX) { return null; } return cells[x + z * cellCountX]; } 

नल-संदर्भ-अपवाद से बचने के लिए, यह HexMapEditorसंपादित करने से पहले जांचना चाहिए कि क्या सेल वास्तव में मौजूद है।

  void EditCell (HexCell cell) { if (cell) { if (applyColor) { cell.Color = activeColor; } if (applyElevation) { cell.Elevation = activeElevation; } } } 

कई ब्रश आकार का उपयोग करना।

सेल लेबल दृश्यता टॉगल करें

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

  public void ShowUI (bool visible) { gridCanvas.gameObject.SetActive(visible); } 

आइए यूआई को डिफ़ॉल्ट रूप से छिपाते हैं।

  void Awake () { gridCanvas = GetComponentInChildren<Canvas>(); hexMesh = GetComponentInChildren<HexMesh>(); cells = new HexCell[HexMetrics.chunkSizeX * HexMetrics.chunkSizeZ]; ShowUI(false); } 

के बाद से यूआई की उपस्थिति पूरे नक्शे के लिए स्विच, एक विधि जोड़ने ShowUIमें HexGrid। यह सिर्फ इसके अंशों के लिए अनुरोध पारित करता है।

  public void ShowUI (bool visible) { for (int i = 0; i < chunks.Length; i++) { chunks[i].ShowUI(visible); } } 

HexMapEditor ग्रिड के अनुरोध को पारित करने के लिए एक ही विधि प्राप्त होती है।

  public void ShowUI (bool visible) { hexGrid.ShowUI(visible); } 

अंत में, हम UI में एक स्विच जोड़ सकते हैं और इसे कनेक्ट कर सकते हैं।


टैग दृश्यता स्विच।

unitypackage

भाग 6: नदियाँ

• नदियों को कोशिकाओं में जोड़ना।
• ड्रॉइंग नदियों के लिए समर्थन खींचें और छोड़ें।
• रिवरबेड बनाना।
• प्रति टुकड़ा कई जाल का उपयोग करना।
• एक साझा सूची पूल बनाएँ।
• त्रिकोणीयकरण और बहते पानी का एनीमेशन।

पिछले भाग में, हमने बड़े मानचित्रों का समर्थन करने के बारे में बात की थी। अब हम बड़े राहत तत्वों की ओर बढ़ सकते हैं। इस बार हम नदियों के बारे में बात करेंगे।


पहाड़ों से नदियाँ बहती हैं।

नदी की कोशिकाएँ

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

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


पांच संभव नदी विन्यास।

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

नदी की ट्रैकिंग

जिस सेल के साथ नदी बहती है उसे एक साथ आने वाली और बाहर जाने वाली नदी माना जा सकता है। यदि इसमें नदी की शुरुआत शामिल है, तो इसमें केवल एक बहने वाली नदी है। और अगर इसमें नदी का अंत शामिल है, तो इसमें केवल एक आने वाली नदी है। हम इस जानकारी को HexCellदो बूलियन मानों का उपयोग करके संग्रहीत कर सकते हैं।

  bool hasIncomingRiver, hasOutgoingRiver; 

लेकिन यह पर्याप्त नहीं है। हमें इन नदियों की दिशा को भी जानना होगा। एक आउटगोइंग नदी के मामले में, यह इंगित करता है कि यह कहां घूम रहा है। एक आने वाली नदी के मामले में, यह इंगित करता है कि यह कहां से आया है।

  bool hasIncomingRiver, hasOutgoingRiver; HexDirection incomingRiver, outgoingRiver; 

कोशिकाओं को त्रिकोणीय करते समय हमें इस जानकारी की आवश्यकता होगी, इसलिए हम इसमें उपयोग करने के लिए गुण जोड़ेंगे। हम उन्हें सीधे असाइन करने का समर्थन नहीं करेंगे। ऐसा करने के लिए, हम आगे एक अलग विधि जोड़ेंगे।

  public bool HasIncomingRiver { get { return hasIncomingRiver; } } public bool HasOutgoingRiver { get { return hasOutgoingRiver; } } public HexDirection IncomingRiver { get { return incomingRiver; } } public HexDirection OutgoingRiver { get { return outgoingRiver; } } 

एक महत्वपूर्ण सवाल यह है कि क्या सेल में एक नदी है, विवरण की परवाह किए बिना। इसलिए, हम इसके लिए एक संपत्ति भी जोड़ते हैं।

  public bool HasRiver { get { return hasIncomingRiver || hasOutgoingRiver; } } 

एक और तार्किक सवाल: सेल में नदी की शुरुआत या अंत है। यदि आने वाली और बाहर जाने वाली नदी की स्थिति अलग है, तो यह सिर्फ मामला है। इसलिए, हम इसे एक और संपत्ति बनाएंगे।

  public bool HasRiverBeginOrEnd { get { return hasIncomingRiver != hasOutgoingRiver; } } 

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

  public bool HasRiverThroughEdge (HexDirection direction) { return hasIncomingRiver && incomingRiver == direction || hasOutgoingRiver && outgoingRiver == direction; } 

नदी निकालना

इससे पहले कि हम एक नदी को एक सेल में जोड़ना शुरू करें, चलो पहले नदी को हटाने के लिए समर्थन लागू करें। शुरू करने के लिए, हम नदी के केवल बाहर जाने वाले हिस्से को हटाने के लिए एक विधि लिखेंगे।

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

  public void RemoveOutgoingRiver () { if (!hasOutgoingRiver) { return; } hasOutgoingRiver = false; Refresh(); } 

लेकिन यह सब नहीं है। बाहर जाने वाली नदी को कहीं पर चलना चाहिए। इसलिए, आने वाली नदी के साथ एक पड़ोसी होना चाहिए। हमें उससे छुटकारा पाने की जरूरत है।

  public void RemoveOutgoingRiver () { if (!hasOutgoingRiver) { return; } hasOutgoingRiver = false; Refresh(); HexCell neighbor = GetNeighbor(outgoingRiver); neighbor.hasIncomingRiver = false; neighbor.Refresh(); } 

किसी नदी को किसी सेल से निकालने से केवल उस सेल की उपस्थिति बदल जाती है। ऊंचाई या रंग के संपादन के विपरीत, यह पड़ोसियों को प्रभावित नहीं करता है। इसलिए, हमें केवल सेल को ही अपडेट करने की आवश्यकता है, लेकिन इसके पड़ोसियों की नहीं।

  public void RemoveOutgoingRiver () { if (!hasOutgoingRiver) { return; } hasOutgoingRiver = false; RefreshSelfOnly(); HexCell neighbor = GetNeighbor(outgoingRiver); neighbor.hasIncomingRiver = false; neighbor.RefreshSelfOnly(); } 

यह विधि RefreshSelfOnlyकेवल उस खंड को अपडेट करती है, जो सेल का है। चूँकि हम ग्रिड इनिशियलाइज़ेशन के दौरान नदी को नहीं बदलते हैं, इसलिए हमें यह चिंता करने की ज़रूरत नहीं है कि क्या एक टुकड़ा पहले ही सौंपा जा चुका है।

  void RefreshSelfOnly () { chunk.Refresh(); } 

आने वाली नदियों को हटाना उसी तरह से काम करता है।

  public void RemoveIncomingRiver () { if (!hasIncomingRiver) { return; } hasIncomingRiver = false; RefreshSelfOnly(); HexCell neighbor = GetNeighbor(incomingRiver); neighbor.hasOutgoingRiver = false; neighbor.RefreshSelfOnly(); } 

और पूरी नदी को हटाने का सीधा मतलब है नदी के आने वाले और बाहर जाने वाले दोनों हिस्सों को हटाना।

  public void RemoveRiver () { RemoveOutgoingRiver(); RemoveIncomingRiver(); } 

नदियों को जोड़ना

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

यदि नदी पहले से मौजूद है, तो हमें कुछ भी करने की आवश्यकता नहीं है।

  public void SetOutgoingRiver (HexDirection direction) { if (hasOutgoingRiver && outgoingRiver == direction) { return; } } 

अगला, हमें यह सुनिश्चित करने की आवश्यकता है कि सही दिशा में पड़ोसी है। इसके अलावा, नदियां नहीं बह सकतीं। इसलिए, यदि पड़ोसी अधिक है, तो हमें ऑपरेशन पूरा करना होगा।

  HexCell neighbor = GetNeighbor(direction); if (!neighbor || elevation < neighbor.elevation) { return; } 

अगला हमें पिछली निवर्तमान नदी को साफ करने की आवश्यकता है। और हमें आने वाली नदी को भी हटाने की जरूरत है, अगर यह एक नई निवर्तमान नदी पर आरोपित है।

  RemoveOutgoingRiver(); if (hasIncomingRiver && incomingRiver == direction) { RemoveIncomingRiver(); } 

अब हम निवर्तमान नदी की स्थापना के लिए आगे बढ़ सकते हैं।

  hasOutgoingRiver = true; outgoingRiver = direction; RefreshSelfOnly(); 

और इसकी वर्तमान आने वाली नदी को हटाने के बाद आने वाली नदी को किसी अन्य सेल के लिए सेट करना न भूलें, अगर यह मौजूद है।

  neighbor.RemoveIncomingRiver(); neighbor.hasIncomingRiver = true; neighbor.incomingRiver = direction.Opposite(); neighbor.RefreshSelfOnly(); 

बह रही नदियों से छुटकारा

अब जबकि हमने केवल सही नदियों को जोड़ना संभव बना दिया है, अन्य कार्य अभी भी गलत बना सकते हैं। जब हम सेल की ऊंचाई बदलते हैं, तो हमें फिर से यह सुनिश्चित करना चाहिए कि नदियां केवल नीचे बह सकती हैं। सभी अनियमित नदियों को हटाया जाना चाहिए।

  public int Elevation { get { return elevation; } set { … if ( hasOutgoingRiver && elevation < GetNeighbor(outgoingRiver).elevation ) { RemoveOutgoingRiver(); } if ( hasIncomingRiver && elevation > GetNeighbor(incomingRiver).elevation ) { RemoveIncomingRiver(); } Refresh(); } } 

unitypackage

नदियों को बदलो

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

  enum OptionalToggle { Ignore, Yes, No } OptionalToggle riverMode; 

और हमें UI के माध्यम से नदी शासन को बदलने के लिए एक विधि की आवश्यकता है।

  public void SetRiverMode (int mode) { riverMode = (OptionalToggle)mode; } 

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


यूआई नदियों

ड्रैग एंड ड्रॉप मान्यता

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

हमें यह जानना होगा कि क्या यह ड्रैग सही होगा, और इसकी दिशा भी निर्धारित करेगा। और ड्रैग और ड्रॉप को पहचानने के लिए, हमें पिछली सेल को याद रखना होगा।

  bool isDrag; HexDirection dragDirection; HexCell previousCell; 

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

  void Update () { if ( Input.GetMouseButton(0) && !EventSystem.current.IsPointerOverGameObject() ) { HandleInput(); } else { previousCell = null; } } void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { EditCells(hexGrid.GetCell(hit.point)); } else { previousCell = null; } } 

वर्तमान सेल वह है जिसे हमने बीम को जाल के साथ पार करके पाया है। कोशिकाओं को संपादित करने के बाद, इसे अपडेट किया जाता है और नए अपडेट के लिए पिछली सेल बन जाती है।

  void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { HexCell currentCell = hexGrid.GetCell(hit.point); EditCells(currentCell); previousCell = currentCell; } else { previousCell = null; } } 

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

  if (Physics.Raycast(inputRay, out hit)) { HexCell currentCell = hexGrid.GetCell(hit.point); if (previousCell && previousCell != currentCell) { ValidateDrag(currentCell); } else { isDrag = false; } EditCells(currentCell); previousCell = currentCell; isDrag = true; } 

हम ड्रैग और ड्रॉप की जांच कैसे करते हैं? यदि वर्तमान सेल पिछले एक का पड़ोसी है तो जाँच करना। हम एक चक्र में इसके पड़ोसियों को दरकिनार करके इसकी जांच करते हैं। यदि हमें कोई मेल मिलता है, तो हम तुरंत ड्रैग की दिशा भी पहचान लेते हैं।

  void ValidateDrag (HexCell currentCell) { for ( dragDirection = HexDirection.NE; dragDirection <= HexDirection.NW; dragDirection++ ) { if (previousCell.GetNeighbor(dragDirection) == currentCell) { isDrag = true; return; } } isDrag = false; } 

कोशिकाओं को बदलें

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

  void EditCell (HexCell cell) { if (cell) { if (applyColor) { cell.Color = activeColor; } if (applyElevation) { cell.Elevation = activeElevation; } if (riverMode == OptionalToggle.No) { cell.RemoveRiver(); } else if (isDrag && riverMode == OptionalToggle.Yes) { previousCell.SetOutgoingRiver(dragDirection); } } } 

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

  else if (isDrag && riverMode == OptionalToggle.Yes) { HexCell otherCell = cell.GetNeighbor(dragDirection.Opposite()); if (otherCell) { otherCell.SetOutgoingRiver(dragDirection); } } 

अब हम नदियों को संपादित कर सकते हैं, लेकिन उन्हें अभी तक नहीं देख सकते हैं। हम यह सत्यापित कर सकते हैं कि यह डिबग इंस्पेक्टर में संशोधित कोशिकाओं की जांच करके काम करता है।


डिबग इंस्पेक्टर में एक नदी के साथ एक सेल।


unitypackage

कोशिकाओं के बीच रिवरबेड्स

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

नदी का सबसे सरल हिस्सा वह है जहां यह कोशिकाओं के बीच जंक्शनों में बहती है। जबकि हम इस क्षेत्र को त्रिभुज की पट्टी के साथ जोड़ रहे हैं। हम बीच के क्वाड को कम करके और दो चैनल की दीवारों को जोड़कर इसमें एक रिवर बेड जोड़ सकते हैं।


एक रिब पट्टी में एक नदी जोड़ना।

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


हमेशा चौमासा।

समान संख्या में चतुर्भुज का निरंतर उपयोग सुविधाजनक है, इसलिए इस विकल्प को चुनें।

एज टॉप्स जोड़ना

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

  public Vector3 v1, v2, v4, v5; 

सब कुछ का नाम बदलने के बाद, एक नया जोड़ें v3।

  public Vector3 v1, v2, v3, v4, v5; 

कंस्ट्रक्टर में एक नया शीर्ष जोड़ें। यह कोने की चोटियों के बीच में स्थित है। इसके अलावा, अन्य कोने अब, और ices में होने चाहिए, और frac13 में नहीं; और frac23;

  public EdgeVertices (Vector3 corner1, Vector3 corner2) { v1 = corner1; v2 = Vector3.Lerp(corner1, corner2, 0.25f); v3 = Vector3.Lerp(corner1, corner2, 0.5f); v4 = Vector3.Lerp(corner1, corner2, 0.75f); v5 = corner2; } 

में जोड़ें v3और TerraceLerp।

  public static EdgeVertices TerraceLerp ( EdgeVertices a, EdgeVertices b, int step) { EdgeVertices result; result.v1 = HexMetrics.TerraceLerp(a.v1, b.v1, step); result.v2 = HexMetrics.TerraceLerp(a.v2, b.v2, step); result.v3 = HexMetrics.TerraceLerp(a.v3, b.v3, step); result.v4 = HexMetrics.TerraceLerp(a.v4, b.v4, step); result.v5 = HexMetrics.TerraceLerp(a.v5, b.v5, step); return result; } 

अब मुझे HexMeshरिब के त्रिकोण के प्रशंसकों में एक अतिरिक्त शीर्ष शामिल करना होगा।

  void TriangulateEdgeFan (Vector3 center, EdgeVertices edge, Color color) { AddTriangle(center, edge.v1, edge.v2); AddTriangleColor(color); AddTriangle(center, edge.v2, edge.v3); AddTriangleColor(color); AddTriangle(center, edge.v3, edge.v4); AddTriangleColor(color); AddTriangle(center, edge.v4, edge.v5); AddTriangleColor(color); } 

और इसके चतुर्भुजों की धारियों में भी।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color c1, EdgeVertices e2, Color c2 ) { AddQuad(e1.v1, e1.v2, e2.v1, e2.v2); AddQuadColor(c1, c2); AddQuad(e1.v2, e1.v3, e2.v2, e2.v3); AddQuadColor(c1, c2); AddQuad(e1.v3, e1.v4, e2.v3, e2.v4); AddQuadColor(c1, c2); AddQuad(e1.v4, e1.v5, e2.v4, e2.v5); AddQuadColor(c1, c2); } 

प्रति छोर चार और पांच कोने की तुलना।

नदी तल की ऊँचाई

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

आइए इस ऑफसेट को HexMetricsऊंचाई के रूप में सेट करें और इसे व्यक्त करें। एक स्तर के ऑफसेट पर्याप्त होंगे।

  public const float streamBedElevationOffset = -1f; 

हम HexCellसेल नदी के तल की ऊर्ध्वाधर स्थिति प्राप्त करने के लिए गुणों को जोड़ने के लिए इस मीट्रिक का उपयोग कर सकते हैं ।

  public float StreamBedY { get { return (elevation + HexMetrics.streamBedElevationOffset) * HexMetrics.elevationStep; } } 

एक चैनल बनाना

जब HexMeshएक कोशिका के छह त्रिकोणीय भागों में से एक को त्रिभुजित किया जाता है, तो हम यह निर्धारित कर सकते हैं कि क्या नदी इसके किनारे से बहती है। यदि ऐसा है, तो हम रिब के मध्य शिखर को नदी के बिस्तर की ऊंचाई तक कम कर सकते हैं।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.Position; EdgeVertices e = new EdgeVertices( center + HexMetrics.GetFirstSolidCorner(direction), center + HexMetrics.GetSecondSolidCorner(direction) ); if (cell.HasRiverThroughEdge(direction)) { e.v3.y = cell.StreamBedY; } TriangulateEdgeFan(center, e, cell.Color); if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, e); } } 

रिब के मध्य शीर्ष को बदलें।

हम देख सकते हैं कि नदी के पहले लक्षण कैसे दिखाई देते हैं, लेकिन राहत में छेद पैदा होते हैं। उन्हें बंद करने के लिए, हमें दूसरे किनारे को बदलना होगा और फिर कनेक्शन को त्रिभुज करना होगा।

  void TriangulateConnection ( HexDirection direction, HexCell cell, EdgeVertices e1 ) { HexCell neighbor = cell.GetNeighbor(direction); if (neighbor == null) { return; } Vector3 bridge = HexMetrics.GetBridge(direction); bridge.y = neighbor.Position.y - cell.Position.y; EdgeVertices e2 = new EdgeVertices( e1.v1 + bridge, e1.v5 + bridge ); if (cell.HasRiverThroughEdge(direction)) { e2.v3.y = neighbor.StreamBedY; } … } 

रिब जोड़ों के पूर्ण चैनल।

unitypackage

एक सेल से होकर गुजरने वाले रिवरबेड

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

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


हम चैनल को त्रिकोण में सम्मिलित करते हैं।

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


चैनल त्रिकोणासन।

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

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.Position; EdgeVertices e = new EdgeVertices( center + HexMetrics.GetFirstSolidCorner(direction), center + HexMetrics.GetSecondSolidCorner(direction) ); if (cell.HasRiver) { if (cell.HasRiverThroughEdge(direction)) { e.v3.y = cell.StreamBedY; TriangulateWithRiver(direction, cell, center, e); } } else { TriangulateEdgeFan(center, e, cell.Color); } if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, e); } } void TriangulateWithRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { } 

छेद जिसमें नदियाँ होनी चाहिए।

यह देखने के लिए कि क्या होता है, अस्थाई रूप से सेल विकृति को निष्क्रिय करें।

  public const float cellPerturbStrength = 0f; // 4f; 

अविरल चोटियाँ।

सेल के माध्यम से सीधे त्रिकोणासन

सेल के भाग के माध्यम से सीधे एक चैनल बनाने के लिए, हमें केंद्र को एक पंक्ति में फैलाने की आवश्यकता है। इस लाइन की चैनल की चौड़ाई समान होनी चाहिए। हम केंद्र से दूरी के पिछले भाग के पहले कोने तक ले जाकर बाईं ओर का शीर्ष ढूँढ सकते हैं।

  void TriangulateWithRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { Vector3 centerL = center + HexMetrics.GetFirstSolidCorner(direction.Previous()) * 0.25f; } 

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

  Vector3 centerL = center + HexMetrics.GetFirstSolidCorner(direction.Previous()) * 0.25f; Vector3 centerR = center + HexMetrics.GetSecondSolidCorner(direction.Next()) * 0.25f; 

केंद्र और किनारे के बीच शीर्ष किनारों को बनाकर मध्य रेखा को पाया जा सकता है।

  EdgeVertices m = new EdgeVertices( Vector3.Lerp(centerL, e.v1, 0.5f), Vector3.Lerp(centerR, e.v5, 0.5f) ); 

अगला, मध्य रिब के मध्य शीर्ष, साथ ही केंद्र को बदल दें, क्योंकि वे चैनल के निचले बिंदु बन जाएंगे।

  m.v3.y = center.y = e.v3.y; 

अब हम TriangulateEdgeStripमध्य रेखा और किनारे रेखा के बीच के स्थान को भरने के लिए उपयोग कर सकते हैं ।

  TriangulateEdgeStrip(m, cell.Color, e, cell.Color); 

संकुचित चैनल।

दुर्भाग्य से, चैनल संकुचित दिखते हैं। ऐसा इसलिए होता है क्योंकि पसली के मध्य कोने एक-दूसरे के बहुत करीब होते हैं। ऐसा क्यों हुआ?

यदि हम मानते हैं कि बाहरी किनारे की लंबाई 1 है, तो केंद्र रेखा की लंबाई length होगी। चूंकि बीच का किनारा उनके बीच में है, इसलिए इसकी लंबाई in के बराबर होनी चाहिए।

चैनल की चौड़ाई ½ है और स्थिर रहना चाहिए। चूंकि मध्य किनारे की लंबाई ¾ है, केवल according बनी हुई है, & frac18 के अनुसार; चैनल के दोनों किनारों पर।


सापेक्ष लंबाई।

चूंकि मध्य किनारे की लंबाई middle है, तो & frac18; मध्य रिब की लंबाई के सापेक्ष और frac16 के बराबर हो जाता है ;; इसका मतलब यह है कि इसके दूसरे और चौथे कोने को छठे से नहीं, बल्कि क्वार्टर से इंटरपोल किया जाना चाहिए।

हम EdgeVerticesदूसरे कंस्ट्रक्टर में जोड़कर ऐसे वैकल्पिक प्रक्षेप के लिए सहायता प्रदान कर सकते हैं । के बजाय के लिए निश्चित प्रक्षेप v2और v4एक पैरामीटर का उपयोग करते हैं।

  public EdgeVertices (Vector3 corner1, Vector3 corner2, float outerStep) { v1 = corner1; v2 = Vector3.Lerp(corner1, corner2, outerStep); v3 = Vector3.Lerp(corner1, corner2, 0.5f); v4 = Vector3.Lerp(corner1, corner2, 1f - outerStep); v5 = corner2; } 

अब हम इसे & frac16 के साथ उपयोग कर सकते हैं; सी HexMesh.TriangulateWithRiver।

  EdgeVertices m = new EdgeVertices( Vector3.Lerp(centerL, e.v1, 0.5f), Vector3.Lerp(centerR, e.v5, 0.5f), 1f / 6f ); 

सीधा चैनल।

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

  AddTriangle(centerL, m.v1, m.v2); AddTriangleColor(cell.Color); AddTriangle(centerR, m.v4, m.v5); AddTriangleColor(cell.Color); 

साइड त्रिकोण।

यह अच्छा लग रहा है, इसलिए चैनल के अंतिम भाग को बनाते हुए, शेष स्थान को दो चतुष्कोणों से भरें।

  AddTriangle(centerL, m.v1, m.v2); AddTriangleColor(cell.Color); AddQuad(centerL, center, m.v2, m.v3); AddQuadColor(cell.Color); AddQuad(center, centerR, m.v3, m.v4); AddQuadColor(cell.Color); AddTriangle(centerR, m.v4, m.v5); AddTriangleColor(cell.Color); 

वास्तव में, हमारे पास AddQuadColorकेवल एक पैरामीटर की आवश्यकता के लिए कोई विकल्प नहीं है । जबकि हमें इसकी जरूरत नहीं थी। तो चलिए इसे बनाते हैं।

  void AddQuadColor (Color color) { colors.Add(color); colors.Add(color); colors.Add(color); colors.Add(color); } 

सीधे चैनलों को पूरा किया।

त्रिकोणासन शुरू करें और समाप्त करें

एक भाग की त्रिकोणीयता जिसमें केवल एक नदी की शुरुआत या अंत होता है, काफी अलग होता है, और इसलिए उसे अपनी विधि की आवश्यकता होती है। इसलिए, हम इसे जांचेंगे Triangulateऔर उपयुक्त विधि को कॉल करेंगे ।

  if (cell.HasRiver) { if (cell.HasRiverThroughEdge(direction)) { e.v3.y = cell.StreamBedY; if (cell.HasRiverBeginOrEnd) { TriangulateWithRiverBeginOrEnd(direction, cell, center, e); } else { TriangulateWithRiver(direction, cell, center, e); } } } 

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

  void TriangulateWithRiverBeginOrEnd ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { EdgeVertices m = new EdgeVertices( Vector3.Lerp(center, e.v1, 0.5f), Vector3.Lerp(center, e.v5, 0.5f) ); } 

ताकि चैनल बहुत जल्दी उथले न हो जाए, हम नदी के तल की ऊँचाई को मध्य शिखर को सौंप देंगे। लेकिन केंद्र को बदलने की जरूरत नहीं है।

  m.v3.y = e.v3.y; 

हम एक रिब स्ट्रिप और एक प्रशंसक के साथ त्रिकोण कर सकते हैं।

  TriangulateEdgeStrip(m, cell.Color, e, cell.Color); TriangulateEdgeFan(center, m, cell.Color); 

अंक शुरू और समाप्त करें।

वन-स्टेप टर्न

इसके बाद, आसन्न कोशिकाओं के बीच उस झिझक को तेज करें। हम उन्हें भी संभाल लेंगे TriangulateWithRiver। इसलिए, हमें यह निर्धारित करने की आवश्यकता है कि हम किस प्रकार की नदी के साथ काम कर रहे हैं।


ज़िगज़ग नदी।

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

  Vector3 centerL, centerR; if (cell.HasRiverThroughEdge(direction.Opposite())) { centerL = center + HexMetrics.GetFirstSolidCorner(direction.Previous()) * 0.25f; centerR = center + HexMetrics.GetSecondSolidCorner(direction.Next()) * 0.25f; } else { centerL = centerR = center; } 

कर्ल किए हुए ज़िगज़ैग।

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

  if (cell.HasRiverThroughEdge(direction.Opposite())) { centerL = center + HexMetrics.GetFirstSolidCorner(direction.Previous()) * 0.25f; centerR = center + HexMetrics.GetSecondSolidCorner(direction.Next()) * 0.25f; } else if (cell.HasRiverThroughEdge(direction.Next())) { centerL = center; centerR = Vector3.Lerp(center, e.v5, 0.5f); } else if (cell.HasRiverThroughEdge(direction.Previous())) { centerL = Vector3.Lerp(center, e.v1, 0.5f); centerR = center; } else { centerL = centerR = center; } 

यह तय करने के बाद कि बाएं और दाएं बिंदु कहां हैं, हम औसत केंद्र को उनके द्वारा निर्धारित कर सकते हैं।

  if (cell.HasRiverThroughEdge(direction.Opposite())) { … } center = Vector3.Lerp(centerL, centerR, 0.5f); 

ऑफसेट केंद्रीय रिब।

हालांकि चैनल की दोनों तरफ समान चौड़ाई है, यह काफी संकुचित दिखता है। यह केंद्र रेखा 60 ° मोड़ने के कारण होता है। केंद्र रेखा की चौड़ाई को थोड़ा बढ़ाकर आप इस प्रभाव को सुचारू कर सकते हैं। ½ के साथ प्रक्षेप करने के बजाय, हम & frac23 का उपयोग करते हैं;

  else if (cell.HasRiverThroughEdge(direction.Next())) { centerL = center; centerR = Vector3.Lerp(center, e.v5, 2f / 3f); } else if (cell.HasRiverThroughEdge(direction.Previous())) { centerL = Vector3.Lerp(center, e.v1, 2f / 3f); centerR = center; } 

संपीड़न के बिना ज़िगज़ैग।

दो-चरण बदल जाता है

शेष मामले झीग्ज और सीधी नदियों के बीच के हैं। ये दो-चरण मोड़ हैं जो धीरे-धीरे घुमावदार नदियों का निर्माण करते हैं।


बहती हुई नदी।

दो संभावित झुकावों के बीच अंतर करने के लिए, हमें उपयोग करने की आवश्यकता है direction.Next().Next()। लेकिन इसे और अधिक जोड़कर सुविधाजनक बनाते हैं HexDirectionविस्तार के तरीकों Next2और Previous2।

  public static HexDirection Previous2 (this HexDirection direction) { direction -= 2; return direction >= HexDirection.NE ? direction : (direction + 6); } public static HexDirection Next2 (this HexDirection direction) { direction += 2; return direction <= HexDirection.NW ? direction : (direction - 6); } 

पर वापस HexMesh.TriangulateWithRiver। अब हम अपने साथ बहने वाली नदी की दिशा को पहचान सकते हैं direction.Next2()।

  if (cell.HasRiverThroughEdge(direction.Opposite())) { centerL = center + HexMetrics.GetFirstSolidCorner(direction.Previous()) * 0.25f; centerR = center + HexMetrics.GetSecondSolidCorner(direction.Next()) * 0.25f; } else if (cell.HasRiverThroughEdge(direction.Next())) { centerL = center; centerR = Vector3.Lerp(center, e.v5, 2f / 3f); } else if (cell.HasRiverThroughEdge(direction.Previous())) { centerL = Vector3.Lerp(center, e.v1, 2f / 3f); centerR = center; } else if (cell.HasRiverThroughEdge(direction.Next2())) { centerL = centerR = center; } else { centerL = centerR = center; } 

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

  else if (cell.HasRiverThroughEdge(direction.Next2())) { centerL = center; centerR = center + HexMetrics.GetSolidEdgeMiddle(direction.Next()) * 0.5f; } else { centerL = center + HexMetrics.GetSolidEdgeMiddle(direction.Previous()) * 0.5f; centerR = center; } 

बेशक, अब हमें ऐसी विधि जोड़ने की जरूरत है HexMetrics। उसे बस आसन्न कोणों के दो वैक्टरों को औसत करना होगा और अखंडता गुणांक लागू करना होगा।

  public static Vector3 GetSolidEdgeMiddle (HexDirection direction) { return (corners[(int)direction] + corners[(int)direction + 1]) * (0.5f * solidFactor); } 

थोड़ा संकुचित घटता है।

हमारी केंद्र रेखाएं अब 30 ° सही ढंग से घूम रही हैं। लेकिन वे लंबे समय तक पर्याप्त नहीं हैं, यही वजह है कि चैनल थोड़ा संकुचित हैं। ऐसा इसलिए होता है क्योंकि रिब का मध्यबिंदु रिब के कोण की तुलना में केंद्र के करीब होता है। इसकी दूरी आंतरिक त्रिज्या के बराबर है, बाहरी नहीं। यानी हम गलत पैमाने पर काम कर रहे हैं।

हम पहले से ही बाहरी से आंतरिक त्रिज्या में परिवर्तित कर रहे हैं HexMetrics। हमें रिवर्स ऑपरेशन करने की आवश्यकता है। तो चलो दोनों रूपांतरण कारक उपलब्ध कराते हैं HexMetrics।

  public const float outerToInner = 0.866025404f; public const float innerToOuter = 1f / outerToInner; public const float outerRadius = 10f; public const float innerRadius = outerRadius * outerToInner; 

अब हम सही पैमाने पर आगे बढ़ सकते हैं HexMesh.TriangulateWithRiver। चैनल अभी भी अपनी बारी के कारण थोड़ा निचोड़ा हुआ रहेगा, लेकिन यह ज़िगज़ैग के मामले में बहुत कम स्पष्ट है। इसलिए, हमें इसकी भरपाई करने की आवश्यकता नहीं है।

  else if (cell.HasRiverThroughEdge(direction.Next2())) { centerL = center; centerR = center + HexMetrics.GetSolidEdgeMiddle(direction.Next()) * (0.5f * HexMetrics.innerToOuter); } else { centerL = center + HexMetrics.GetSolidEdgeMiddle(direction.Previous()) * (0.5f * HexMetrics.innerToOuter); centerR = center; } 

चिकनी घटता है।

unitypackage

नदियों के आसपास के क्षेत्रों में त्रिकोणासन

हमारी नदियां तैयार हैं। लेकिन हमने अभी तक नदियों से युक्त कोशिकाओं के अन्य भागों को नहीं मिलाया है। अब हम इन छेदों को बंद कर देंगे।


चैनलों के पास छेद।

यदि सेल में एक नदी है, लेकिन यह वर्तमान दिशा में नहीं बहती है, तो Triangulateहम एक नई विधि को कॉल करेंगे।

  if (cell.HasRiver) { if (cell.HasRiverThroughEdge(direction)) { e.v3.y = cell.StreamBedY; if (cell.HasRiverBeginOrEnd) { TriangulateWithRiverBeginOrEnd(direction, cell, center, e); } else { TriangulateWithRiver(direction, cell, center, e); } } else { TriangulateAdjacentToRiver(direction, cell, center, e); } } else { TriangulateEdgeFan(center, e, cell.Color); } 

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

  void TriangulateAdjacentToRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { EdgeVertices m = new EdgeVertices( Vector3.Lerp(center, e.v1, 0.5f), Vector3.Lerp(center, e.v5, 0.5f) ); TriangulateEdgeStrip(m, cell.Color, e, cell.Color); TriangulateEdgeFan(center, m, cell.Color); } 

घटता और सीधी नदियों में ओवरले।

चैनल का मिलान करें

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

आइए जाँच करके देखें कि क्या हम वक्र के अंदर हैं। इस मामले में, पिछली और अगली दोनों दिशाओं में नदी शामिल है। यदि ऐसा है, तो हमें केंद्र को किनारे पर ले जाने की आवश्यकता है।

  if (cell.HasRiverThroughEdge(direction.Next())) { if (cell.HasRiverThroughEdge(direction.Previous())) { center += HexMetrics.GetSolidEdgeMiddle(direction) * (HexMetrics.innerToOuter * 0.5f); } } EdgeVertices m = new EdgeVertices( Vector3.Lerp(center, e.v1, 0.5f), Vector3.Lerp(center, e.v5, 0.5f) ); 

एक ऐसा मामला तय किया जहां नदी दोनों ओर से बहती है।

यदि हमारे पास एक अलग दिशा में एक नदी है, लेकिन पिछले एक में नहीं है, तो हम यह देखने के लिए जांचते हैं कि क्या यह सीधा है। यदि ऐसा है, तो केंद्र को पहले कोने में ले जाएं।

  if (cell.HasRiverThroughEdge(direction.Next())) { if (cell.HasRiverThroughEdge(direction.Previous())) { center += HexMetrics.GetSolidEdgeMiddle(direction) * (HexMetrics.innerToOuter * 0.5f); } else if ( cell.HasRiverThroughEdge(direction.Previous2()) ) { center += HexMetrics.GetFirstSolidCorner(direction) * 0.25f; } } 

सीधी नदी के साथ आधा ओवरले।

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

  if (cell.HasRiverThroughEdge(direction.Next())) { if (cell.HasRiverThroughEdge(direction.Previous())) { center += HexMetrics.GetSolidEdgeMiddle(direction) * (HexMetrics.innerToOuter * 0.5f); } else if ( cell.HasRiverThroughEdge(direction.Previous2()) ) { center += HexMetrics.GetFirstSolidCorner(direction) * 0.25f; } } else if ( cell.HasRiverThroughEdge(direction.Previous()) && cell.HasRiverThroughEdge(direction.Next2()) ) { center += HexMetrics.GetSecondSolidCorner(direction) * 0.25f; } 

और कोई ओवरले नहीं।

unitypackage

हेक्समेश सामान्यीकरण

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

Perturb विधि को आगे बढ़ाना

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

विधि को अंदर की ओर ले जाकर HexMetrics, इसे सामान्य और स्थिर बनाएं और फिर इसका नाम सही करें।

  public static Vector3 Perturb (Vector3 position) { Vector4 sample = SampleNoise(position); position.x += (sample.x * 2f - 1f) * cellPerturbStrength; position.z += (sample.z * 2f - 1f) * cellPerturbStrength; return position; } 

त्रिभुज विधियों को आगे बढ़ाना

में HexGridChunkचर के परिवर्तन hexMeshसाझा चर में terrain।

  public HexMesh terrain; // HexMesh hexMesh; void Awake () { gridCanvas = GetComponentInChildren<Canvas>(); // hexMesh = GetComponentInChildren<HexMesh>(); cells = new HexCell[HexMetrics.chunkSizeX * HexMetrics.chunkSizeZ]; ShowUI(false); } 

अगला, हम c Add…से सभी तरीकों को HexMeshरिफ्लेक्टर करते हैं terrain.Add…। फिर सभी तरीकों Triangulate…को स्थानांतरित करें HexGridChunk। फिर आप तरीकों के नाम को सही कर सकते Add…में HexMeshहैं और उन्हें आम हैं। नतीजतन, सभी जटिल त्रिभुज तरीके मिलेंगे HexGridChunk, और जाल में डेटा जोड़ने के लिए सरल तरीके अंदर रहेंगे HexMesh।

हम अभी तक नहीं किए गए हैं। अब इसे HexGridChunk.LateUpdateअपनी विधि कहनी चाहिए Triangulate। इसके अलावा, इसे अब एक तर्क के रूप में कोशिकाओं को पारित नहीं करना चाहिए। इसलिए, यह Triangulateअपना पैरामीटर खो सकता है। और उसे जाल डेटा की सफाई और अनुप्रयोग को सौंपना होगा HexMesh।

  void LateUpdate () { Triangulate(); // hexMesh.Triangulate(cells); enabled = false; } public void Triangulate () { terrain.Clear(); // hexMesh.Clear(); // vertices.Clear(); // colors.Clear(); // triangles.Clear(); for (int i = 0; i < cells.Length; i++) { Triangulate(cells[i]); } terrain.Apply(); // hexMesh.vertices = vertices.ToArray(); // hexMesh.colors = colors.ToArray(); // hexMesh.triangles = triangles.ToArray(); // hexMesh.RecalculateNormals(); // meshCollider.sharedMesh = hexMesh; } 

आवश्यक विधियां जोड़ें Clearऔर Applyमें HexMesh।

  public void Clear () { hexMesh.Clear(); vertices.Clear(); colors.Clear(); triangles.Clear(); } public void Apply () { hexMesh.SetVertices(vertices); hexMesh.SetColors(colors); hexMesh.SetTriangles(triangles, 0); hexMesh.RecalculateNormals(); meshCollider.sharedMesh = hexMesh; } 

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


एक राहत प्रदान करें।

सूची पूल बनाना

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

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

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

 public static class ListPool<T> { } 

एक पूल में सूचियों का संग्रह संग्रहीत करने के लिए, हम स्टैक का उपयोग कर सकते हैं। मैं आमतौर पर सूचियों का उपयोग नहीं करता हूं क्योंकि एकता उन्हें क्रमबद्ध नहीं करती है, लेकिन इस मामले में यह महत्वपूर्ण नहीं है।

 using System.Collections.Generic; public static class ListPool<T> { static Stack<List<T>> stack = new Stack<List<T>>(); } 

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

  public static List<T> Get () { if (stack.Count > 0) { return stack.Pop(); } return new List<T>(); } 

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

  public static void Add (List<T> list) { list.Clear(); stack.Push(list); } 

अब हम पूल का उपयोग कर सकते हैं HexMesh। स्थैतिक सूची को गैर-स्थिर निजी लिंक से बदलें। आइए उन्हें चिह्नित करें NonSerializedताकि एकता पुनर्संयोजन के दौरान उन्हें संरक्षित न करें। या स्क्रिप्ट की शुरुआत में लिखना System.NonSerializedया जोड़ना using System;।

  [NonSerialized] List<Vector3> vertices; [NonSerialized] List<Color> colors; [NonSerialized] List<int> triangles; // static List<Vector3> vertices = new List<Vector3>(); // static List<Color> colors = new List<Color>(); // static List<int> triangles = new List<int>(); 

चूंकि नए डेटा को जोड़ने से पहले मेष को ठीक से साफ किया जाता है, यह यहां है कि आपको पूल से सूचियां प्राप्त करने की आवश्यकता है।

  public void Clear () { hexMesh.Clear(); vertices = ListPool<Vector3>.Get(); colors = ListPool<Color>.Get(); triangles = ListPool<int>.Get(); } 

इन जालों को लगाने के बाद, हमें अब उनकी आवश्यकता नहीं है, इसलिए यहां हम उन्हें पूल में जोड़ सकते हैं।

  public void Apply () { hexMesh.SetVertices(vertices); ListPool<Vector3>.Add(vertices); hexMesh.SetColors(colors); ListPool<Color>.Add(colors); hexMesh.SetTriangles(triangles, 0); ListPool<int>.Add(triangles); hexMesh.RecalculateNormals(); meshCollider.sharedMesh = hexMesh; } 

इसलिए हमने सूचियों के कई उपयोगों को लागू किया, भले ही हम एक ही समय में कितने जाल भरें।

वैकल्पिक कॉलर

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

  public bool useCollider; 

एक जाल कोलेडर का उपयोग करना।

हमें केवल उस चालू होने पर उसे बनाया और असाइन किया गया कोलाइडर बनाने की आवश्यकता है।

  void Awake () { GetComponent<MeshFilter>().mesh = hexMesh = new Mesh(); if (useCollider) { meshCollider = gameObject.AddComponent<MeshCollider>(); } hexMesh.name = "Hex Mesh"; } public void Apply () { … if (useCollider) { meshCollider.sharedMesh = hexMesh; } … } 

वैकल्पिक रंग

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

  public bool useCollider, useColors; public void Clear () { hexMesh.Clear(); vertices = ListPool<Vector3>.Get(); if (useColors) { colors = ListPool<Color>.Get(); } triangles = ListPool<int>.Get(); } public void Apply () { hexMesh.SetVertices(vertices); ListPool<Vector3>.Add(vertices); if (useColors) { hexMesh.SetColors(colors); ListPool<Color>.Add(colors); } … } 

बेशक, इलाके को रंगों के रंगों का उपयोग करना चाहिए, इसलिए उन्हें चालू करें।


रंगों का उपयोग।

वैकल्पिक यूवी

जब हम ऐसा कर रहे हैं, हम वैकल्पिक यूवी निर्देशांक के लिए समर्थन भी जोड़ सकते हैं। हालाँकि राहत इनका उपयोग नहीं करती है, फिर भी हमें पानी की आवश्यकता होगी।

  public bool useCollider, useColors, useUVCoordinates; [NonSerialized] List<Vector2> uvs; public void Clear () { hexMesh.Clear(); vertices = ListPool<Vector3>.Get(); if (useColors) { colors = ListPool<Color>.Get(); } if (useUVCoordinates) { uvs = ListPool<Vector2>.Get(); } triangles = ListPool<int>.Get(); } public void Apply () { hexMesh.SetVertices(vertices); ListPool<Vector3>.Add(vertices); if (useColors) { hexMesh.SetColors(colors); ListPool<Color>.Add(colors); } if (useUVCoordinates) { hexMesh.SetUVs(0, uvs); ListPool<Vector2>.Add(uvs); } … } 

हम यूवी निर्देशांक का उपयोग नहीं करते हैं।

इस फ़ंक्शन का उपयोग करने के लिए, त्रिभुज और क्वाड्रैंगल्स में यूवी निर्देशांक जोड़ने के लिए तरीके बनाएं।

  public void AddTriangleUV (Vector2 uv1, Vector2 uv2, Vector3 uv3) { uvs.Add(uv1); uvs.Add(uv2); uvs.Add(uv3); } public void AddQuadUV (Vector2 uv1, Vector2 uv2, Vector3 uv3, Vector3 uv4) { uvs.Add(uv1); uvs.Add(uv2); uvs.Add(uv3); uvs.Add(uv4); } 

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

  public void AddQuadUV (float uMin, float uMax, float vMin, float vMax) { uvs.Add(new Vector2(uMin, vMin)); uvs.Add(new Vector2(uMax, vMin)); uvs.Add(new Vector2(uMin, vMax)); uvs.Add(new Vector2(uMax, vMax)); } 

unitypackage

वर्तमान नदियाँ

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

 Shader "Custom/River" { … void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color; o.Albedo = c.rgb * IN.color; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; o.Albedo.rg = IN.uv_MainTex; } ENDCG } FallBack "Diffuse" } 

HexGridChunkसामान्य क्षेत्र में जोड़ें HexMesh rivers। हम इसे साफ करते हैं और राहत के मामले में उसी तरह से लागू करते हैं।

  public HexMesh terrain, rivers; public void Triangulate () { terrain.Clear(); rivers.Clear(); for (int i = 0; i < cells.Length; i++) { Triangulate(cells[i]); } terrain.Apply(); rivers.Apply(); } 

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



नदियों के साथ प्रीफैब टुकड़ा। हमारे नए शेडर का उपयोग करके रिवर

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


Subobject Rivers।

पानी को ट्राई करें

इससे पहले कि हम पानी को त्रिकोणीय कर सकें, हमें इसकी सतह के स्तर को निर्धारित करना होगा। चलो इसे ऊंचाई में एक बदलाव बनाते हैं HexMetrics, जैसा कि हमने नदी के बिस्तर के साथ किया था। चूंकि सेल का ऊर्ध्वाधर विरूपण आधी ऊंचाई की शिफ्ट के बराबर है, इसलिए इसका उपयोग नदी की सतह को स्थानांतरित करने के लिए करें। इसलिए हम गारंटी देते हैं कि पानी कभी भी सेल की स्थलाकृति से ऊपर नहीं होगा।

  public const float riverSurfaceElevationOffset = -0.5f; 

HexCellअपनी नदी की सतह की ऊर्ध्वाधर स्थिति प्राप्त करने के लिए एक संपत्ति जोड़ें ।

  public float RiverSurfaceY { get { return (elevation + HexMetrics.riverSurfaceElevationOffset) * HexMetrics.elevationStep; } } 

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

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y ) { v1.y = v2.y = v3.y = v4.y = y; rivers.AddQuad(v1, v2, v3, v4); } 

हम यहां चतुर्भुज के यूवी-निर्देशांक जोड़ेंगे। बस बाएं से दाएं और नीचे से ऊपर तक घूमें।

  rivers.AddQuad(v1, v2, v3, v4); rivers.AddQuadUV(0f, 1f, 0f, 1f); 

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

  void TriangulateWithRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … TriangulateRiverQuad(centerL, centerR, m.v2, m.v4, cell.RiverSurfaceY); TriangulateRiverQuad(m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY); } 

पानी के पहले लक्षण।

प्रवाह के साथ चल रहा है

वर्तमान में, यूवी निर्देशांक नदी की दिशा के अनुरूप नहीं हैं। हमें यहां निरंतरता बनाए रखने की जरूरत है। मान लीजिए कि नदी के बाईं ओर U समन्वय 0 है, और नीचे की ओर देखने पर दाईं ओर 1 है। और V निर्देशांक नदी की दिशा में 0 से 1 तक भिन्न होना चाहिए।

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

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y, bool reversed ) { v1.y = v2.y = v3.y = v4.y = y; rivers.AddQuad(v1, v2, v3, v4); if (reversed) { rivers.AddQuadUV(1f, 0f, 1f, 0f); } else { rivers.AddQuadUV(0f, 1f, 0f, 1f); } } 

जैसा कि TriangulateWithRiverहम जानते हैं कि हम दिशा चालू करने की आवश्यकता है, जब भेजे नदी के साथ काम कर।

  bool reversed = cell.IncomingRiver == direction; TriangulateRiverQuad( centerL, centerR, m.v2, m.v4, cell.RiverSurfaceY, reversed ); TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, reversed ); 

नदियों की सहमति वाली दिशा।

नदी की शुरुआत और अंत

अंदर, TriangulateWithRiverBeginOrEndहमें केवल यह जांचने की आवश्यकता है कि प्रवाह की दिशा निर्धारित करने के लिए हमारे पास एक आने वाली नदी है या नहीं। फिर हम बीच और रिब के बीच एक और क्वाड नदी डाल सकते हैं।

  void TriangulateWithRiverBeginOrEnd ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … bool reversed = cell.HasIncomingRiver; TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, reversed ); } 

केंद्र और मध्य के बीच का हिस्सा एक त्रिकोण है, इसलिए हम इसका उपयोग नहीं कर सकते हैं TriangulateRiverQuad। यहां एकमात्र महत्वपूर्ण अंतर यह है कि केंद्रीय शिखर नदी के बीच में है। इसलिए, इसका समन्वय यू हमेशा its के बराबर है।

  center.y = m.v2.y = m.v4.y = cell.RiverSurfaceY; rivers.AddTriangle(center, m.v2, m.v4); if (reversed) { rivers.AddTriangleUV( new Vector2(0.5f, 1f), new Vector2(1f, 0f), new Vector2(0f, 0f) ); } else { rivers.AddTriangleUV( new Vector2(0.5f, 0f), new Vector2(0f, 1f), new Vector2(1f, 1f) ); } 

शुरुआत और अंत में पानी।

कोशिकाओं के बीच प्रवाह

कोशिकाओं के बीच पानी जोड़ते समय, हमें ऊंचाई में अंतर के बारे में सावधान रहना चाहिए। ताकि पानी ढलान और चट्टानों से नीचे बह सके, इसे TriangulateRiverQuadदो ऊंचाई वाले मापदंडों का समर्थन करना चाहिए। तो चलिए एक दूसरा जोड़ते हैं।

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y1, float y2, bool reversed ) { v1.y = v2.y = y1; v3.y = v4.y = y2; rivers.AddQuad(v1, v2, v3, v4); if (reversed) { rivers.AddQuadUV(1f, 0f, 1f, 0f); } else { rivers.AddQuadUV(0f, 1f, 0f, 1f); } } 

इसके अलावा, सुविधा के लिए, आइए एक विकल्प जोड़ें जो एक ऊंचाई प्राप्त करेगा। यह सिर्फ एक और तरीका कहेगा।

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y, bool reversed ) { TriangulateRiverQuad(v1, v2, v3, v4, y, y, reversed); } 

अब हम क्वाड नदी और में जोड़ सकते हैं TriangulateConnection। कोशिकाओं के बीच होने के कारण, हम तुरंत यह पता नहीं लगा सकते हैं कि हम किस प्रकार की नदी के साथ काम कर रहे हैं। यह निर्धारित करने के लिए कि क्या मोड़ आवश्यक है, हमें यह जाँचने की आवश्यकता है कि क्या हमारे पास एक आने वाली नदी है और यदि वह हमारे दिशा में आगे बढ़ रही है।

  if (cell.HasRiverThroughEdge(direction)) { e2.v3.y = neighbor.StreamBedY; TriangulateRiverQuad( e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, cell.HasIncomingRiver && cell.IncomingRiver == direction ); } 

पूरी हो चुकी नदी।

वी समन्वय खिंचाव

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

हम V निर्देशांक को खींचकर पुनरावृत्ति की संख्या को कम कर सकते हैं ताकि वे पूरे सेल प्लस एक कनेक्शन में 0 से 1 तक जा सकें। यह प्रत्येक खंड में वी समन्वय को 0.2 से बढ़ाकर किया जा सकता है। यदि हम केंद्र में 0.4 डालते हैं, तो मध्य में यह 0.6 हो जाएगा, और किनारे पर यह 0.8 तक पहुंच जाएगा। फिर सेल कनेक्शन में, मान 1 होगा।

यदि नदी विपरीत दिशा में बहती है, तो हम अभी भी केंद्र में 0.4 डाल सकते हैं, लेकिन बीच में यह 0.2 हो जाता है, और किनारे पर - 0. यदि हम इसे सेल में शामिल होने तक जारी रखते हैं, तो हमें परिणाम के रूप में -0.2 मिलता है। यह सामान्य है क्योंकि यह दोहराने वाले फ़िल्टरिंग मोड के साथ बनावट के लिए 0.8 के समान है, जैसे कि 0 1 के बराबर है।


निर्देशांक V में परिवर्तन।

इसके लिए समर्थन बनाने के लिए, हमें TriangulateRiverQuadएक और पैरामीटर जोड़ना होगा ।

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y, float v, bool reversed ) { TriangulateRiverQuad(v1, v2, v3, v4, y, y, v, reversed); } void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y1, float y2, float v, bool reversed ) { … } 

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

  else { rivers.AddQuadUV(0f, 1f, v, v + 0.2f); } 

हम 0.8 और 0.6 से समन्वय को घटाकर एक उल्टे दिशा के साथ काम कर सकते हैं।

  if (reversed) { rivers.AddQuadUV(1f, 0f, 0.8f - v, 0.6f - v); } 

अब हमें सही निर्देशांक प्रेषित करना चाहिए, जैसे कि हम एक निवर्तमान नदी के साथ काम कर रहे थे। के साथ शुरू करते हैं TriangulateWithRiver।

  TriangulateRiverQuad( centerL, centerR, m.v2, m.v4, cell.RiverSurfaceY, 0.4f, reversed ); TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, 0.6f, reversed ); 

फिर TriangulateConnectionनिम्नानुसार बदलें।

  TriangulateRiverQuad( e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, 0.8f, cell.HasIncomingRiver && cell.IncomingRiver == direction ); 

और अंत में TriangulateWithRiverBeginOrEnd।

  TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, 0.6f, reversed ); center.y = m.v2.y = m.v4.y = cell.RiverSurfaceY; rivers.AddTriangle(center, m.v2, m.v4); if (reversed) { rivers.AddTriangleUV( new Vector2(0.5f, 0.4f), new Vector2(1f, 0.2f), new Vector2(0f, 0.2f) ); } else { rivers.AddTriangleUV( new Vector2(0.5f, 0.4f), new Vector2(0f, 0.6f), new Vector2(1f, 0.6f) ); } 

स्ट्रेच्ड V निर्देशांक। V निर्देशांक

के तह को सही ढंग से प्रदर्शित करने के लिए, सुनिश्चित करें कि वे नदी के किनारे में सकारात्मक बने हुए हैं।

  if (IN.uv_MainTex.y < 0) { IN.uv_MainTex.y += 1; } o.Albedo.rg = IN.uv_MainTex; 

संकुचित निर्देशांक V.

unitypackage

नदी का एनीमेशन

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

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

एनीमेशन खेल के समय के आधार पर V निर्देशांक को स्थानांतरित करके बनाया गया है। एकता आपको एक वैरिएबल का उपयोग करके उसका मूल्य प्राप्त करने की अनुमति देती है _Time। इसके घटक Y में अपरिवर्तित समय होता है, जिसका हम उपयोग करते हैं। अन्य घटकों में अलग-अलग समय के पैमाने होते हैं।

हम वी के साथ तह से छुटकारा पा लेंगे, क्योंकि हमें अब इसकी आवश्यकता नहीं है। इसके बजाय, हम वर्तमान समय को V समन्वय से घटाते हैं। यह समन्वय को नीचे गिरा देता है, जो नदी के प्रवाह के नीचे बहने वाले प्रवाह का भ्रम पैदा करता है।

 // if (IN.uv_MainTex.y < 0) { // IN.uv_MainTex.y += 1; // } IN.uv_MainTex.y -= _Time.y; o.Albedo.rg = IN.uv_MainTex; 

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

  IN.uv_MainTex.y -= _Time.y; IN.uv_MainTex.y = frac(IN.uv_MainTex.y); o.Albedo.rg = IN.uv_MainTex; 

एनिमेटेड V निर्देशांक।

शोर का उपयोग

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

  void surf (Input IN, inout SurfaceOutputStandard o) { float2 uv = IN.uv_MainTex; uv.y -= _Time.y; float4 noise = tex2D(_MainTex, uv); fixed4 c = _Color * noise.r; o.Albedo = c.rgb; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } 

नदी सामग्री को शोर बनावट निर्दिष्ट करें और सुनिश्चित करें कि यह सफेद है।



शोर बनावट का उपयोग करना।

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

  float2 uv = IN.uv_MainTex; uv.x *= 0.0625; uv.y -= _Time.y; 

यू को समन्वित करना।

चलो प्रति सेकंड एक चौथाई तक भी धीमा कर दें ताकि बनावट चक्र पूरा होने में चार सेकंड लगें।

  uv.y -= _Time.y * 0.25; 

वर्तमान शोर।

शोर मिलाना

सब कुछ पहले से बहुत बेहतर लग रहा है, लेकिन पैटर्न हमेशा समान रहता है। पानी जैसा व्यवहार नहीं करता है।

चूंकि हम केवल शोर के एक छोटे बैंड का उपयोग करते हैं, इसलिए हम बनावट के साथ इस बैंड को स्थानांतरित करके पैटर्न को अलग-अलग कर सकते हैं। यह यू समन्वय के लिए समय जोड़कर किया जाता है। हमें इसे धीरे-धीरे करना चाहिए, अन्यथा नदी बग़ल में बहती प्रतीत होगी। चलो 0.005 के गुणांक का प्रयास करें। इसका मतलब है कि पैटर्न को पूरा करने में 200 सेकंड लगते हैं।

  uv.x = uv.x * 0.0625 + _Time.y * 0.005; 

चलती हुई आवाज।

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

ताकि परिणामस्वरूप, हम कभी भी एक ही शोर पैटर्न को ओवरलैप न करें, हम दूसरे नमूने के लिए एक अलग चैनल का उपयोग करते हैं।

  float2 uv = IN.uv_MainTex; uv.x = uv.x * 0.0625 + _Time.y * 0.005; uv.y -= _Time.y * 0.25; float4 noise = tex2D(_MainTex, uv); float2 uv2 = IN.uv_MainTex; uv2.x = uv2.x * 0.0625 - _Time.y * 0.0052; uv2.y -= _Time.y * 0.23; float4 noise2 = tex2D(_MainTex, uv2); fixed4 c = _Color * (noise.r * noise2.a); 

दो स्थानांतरण शोर पैटर्न का एक संयोजन।

पारभासी जल

हमारा पैटर्न काफी गतिशील दिखता है। अगला कदम इसे पारभासी बनाना है।

सबसे पहले, सुनिश्चित करें कि पानी छाया नहीं डालता है। आप उन्हें प्रीफ़ैब में नदियों ऑब्जेक्ट के रेंडरर घटक के माध्यम से अक्षम कर सकते हैं ।


छाया कास्टिंग अक्षम है।

अब shader को पारदर्शी मोड पर स्विच करें। इसे इंगित करने के लिए, shader टैग का उपयोग करें। फिर #pragma surfaceकीवर्ड को लाइन में जोड़ें alpha। जब हम यहां हैं, तो आप कीवर्ड हटा सकते हैं fullforwardshadows, क्योंकि हम अभी भी छाया नहीं डालते हैं।

  Tags { "RenderType"="Transparent" "Queue"="Transparent" } LOD 200 CGPROGRAM #pragma surface surf Standard alpha // fullforwardshadows #pragma target 3.0 

अब हम नदी के रंग को निर्धारित करने के तरीके को बदल देंगे। शोर को रंग से गुणा करने के बजाय, हम उसमें शोर जोड़ देंगे। फिर हम saturateपरिणाम को सीमित करने के लिए फ़ंक्शन का उपयोग करते हैं ताकि यह 1 से अधिक न हो।

  fixed4 c = saturate(_Color + noise.r * noise2.a); 

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



रंगीन पारभासी जल।

unitypackage

पुनर्निमाण

अब जब सब कुछ काम करने लग रहा है, यह समय है चोटियों को फिर से विकृत करने का। कोशिकाओं के किनारों को विकृत करने के अलावा, यह हमारी नदियों को असमान बना देगा।

  public const float cellPerturbStrength = 4f; 

विकृत और विकृत चोटियां।

विकृति के कारण उत्पन्न होने वाली समस्याओं के लिए इलाके की जाँच करें। लगता है जैसे वे हैं! चलो लंबे झरने की जाँच करें।


चट्टानों द्वारा काटे गए पानी।

एक ऊंचे झरने से गिरने वाला पानी एक चट्टान के पीछे गायब हो जाता है। जब ऐसा होता है, तो यह बहुत ही ध्यान देने योग्य होता है, इसलिए हमें इसके बारे में कुछ करने की जरूरत है।

बहुत कम स्पष्ट है कि झरने सीधे नीचे उतरने के बजाय ढलान वाले हो सकते हैं। हालांकि वास्तविकता में पानी उस तरह नहीं बहता है, यह विशेष रूप से ध्यान देने योग्य नहीं है। हमारा मस्तिष्क इस तरह से व्याख्या करेगा कि यह हमें सामान्य लगता है। तो बस इसे नजरअंदाज करें।

पानी की कमी से बचने का सबसे आसान तरीका है नदी के किनारों को गहरा करना। इसलिए हम पानी की सतह और नदी के बिस्तर के बीच अधिक जगह बनाएंगे। यह चैनल की दीवारों को और अधिक ऊर्ध्वाधर बना देगा, इसलिए बहुत गहराई तक न जाएं। चलो पूछते हैंHexMetrics.streamBedElevationOffsetमान -1.75। यह समस्याओं के थोक को हल करेगा, और बिस्तर बहुत गहरा नहीं होगा। पानी का एक हिस्सा अभी भी काट दिया जाएगा, लेकिन पूरे झरने नहीं।

  public const float streamBedElevationOffset = -1.75f; 

गहराई से चैनल।

unitypackage

भाग 7: सड़कें

• सड़क समर्थन जोड़ें।
• सड़क को त्रिकोणित करें।
• हम सड़कों और नदियों को मिलाते हैं।
• सड़कों की सूरत सुधारना।

सभ्यता के पहले लक्षण।

सड़कों के साथ सेल

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

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


14 संभावित सड़क विन्यास।

सड़क की ट्रैकिंग

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

  [SerializeField] bool[] roads; 

छह सड़कों के साथ Prefab सेल।

यह जांचने के लिए एक विधि जोड़ें कि क्या सेल में एक निश्चित दिशा में एक रास्ता है।

  public bool HasRoadThroughEdge (HexDirection direction) { return roads[(int)direction]; } 

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

  public bool HasRoads { get { for (int i = 0; i < roads.Length; i++) { if (roads[i]) { return true; } } return false; } } 

सड़क हटाने

नदियों के साथ के रूप में, हम सेल से सभी सड़कों को हटाने के लिए एक विधि जोड़ देंगे। यह एक लूप के साथ किया जा सकता है जो हर सड़क को डिस्कनेक्ट करता है जो पहले सक्षम था।

  public void RemoveRoads () { for (int i = 0; i < neighbors.Length; i++) { if (roads[i]) { roads[i] = false; } } } 

बेशक, हमें पड़ोसियों में भी इसी महंगी कोशिकाओं को निष्क्रिय करने की आवश्यकता है।

  if (roads[i]) { roads[i] = false; neighbors[i].roads[(int)((HexDirection)i).Opposite()] = false; } 

उसके बाद, हमें प्रत्येक सेल को अपडेट करना होगा। चूंकि सड़कें कोशिकाओं के लिए स्थानीय हैं, हमें केवल अपने पड़ोसियों के बिना केवल कोशिकाओं को अपडेट करने की आवश्यकता है।

  if (roads[i]) { roads[i] = false; neighbors[i].roads[(int)((HexDirection)i).Opposite()] = false; neighbors[i].RefreshSelfOnly(); RefreshSelfOnly(); } 

सड़कें जोड़ना

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

  public void AddRoad (HexDirection direction) { if (!roads[(int)direction]) { SetRoad((int)direction, true); } } public void RemoveRoads () { for (int i = 0; i < neighbors.Length; i++) { if (roads[i]) { SetRoad(i, false); } } } void SetRoad (int index, bool state) { roads[index] = state; neighbors[index].roads[(int)((HexDirection)index).Opposite()] = state; neighbors[index].RefreshSelfOnly(); RefreshSelfOnly(); } 

हम एक ही समय में एक ही दिशा में एक नदी और सड़क दोनों नहीं बना सकते। इसलिए, सड़क को जोड़ने से पहले, हम जांच करेंगे कि क्या इसके लिए कोई जगह है।

  public void AddRoad (HexDirection direction) { if (!roads[(int)direction] && !HasRiverThroughEdge(direction)) { SetRoad((int)direction, true); } } 

इसके अलावा, सड़कों को चट्टानों से नहीं जोड़ा जा सकता है क्योंकि वे बहुत तेज हैं। या शायद यह एक कम चट्टान के माध्यम से मार्ग प्रशस्त करने के लायक है, लेकिन एक उच्च के माध्यम से नहीं? इसे निर्धारित करने के लिए, हमें एक ऐसी विधि बनाने की ज़रूरत है जो हमें एक निश्चित दिशा में ऊँचाई का अंतर बताए।

  public int GetElevationDifference (HexDirection direction) { int difference = elevation - GetNeighbor(direction).elevation; return difference >= 0 ? difference : -difference; } 

अब हम सड़कों को पर्याप्त ऊँचाई के अंतर पर जोड़ सकते हैं। मैं खुद को केवल ढलान तक सीमित करूंगा, यानी अधिकतम 1 यूनिट।

  public void AddRoad (HexDirection direction) { if ( !roads[(int)direction] && !HasRiverThroughEdge(direction) && GetElevationDifference(direction) <= 1 ) { SetRoad((int)direction, true); } } 

गलत रास्तों को हटाना

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

यह हमारे लिए पर्याप्त होगा कि हम सड़क के लिए कहें false, चाहे सड़क कोई भी हो। इस स्थिति में, दोनों सेल हमेशा अपडेट रहेंगे, इसलिए हमें अब स्पष्ट रूप से कॉल करने की आवश्यकता नहीं RefreshSelfOnlyहै SetOutgoingRiver।

  public void SetOutgoingRiver (HexDirection direction) { if (hasOutgoingRiver && outgoingRiver == direction) { return; } HexCell neighbor = GetNeighbor(direction); if (!neighbor || elevation < neighbor.elevation) { return; } RemoveOutgoingRiver(); if (hasIncomingRiver && incomingRiver == direction) { RemoveIncomingRiver(); } hasOutgoingRiver = true; outgoingRiver = direction; // RefreshSelfOnly(); neighbor.RemoveIncomingRiver(); neighbor.hasIncomingRiver = true; neighbor.incomingRiver = direction.Opposite(); // neighbor.RefreshSelfOnly(); SetRoad((int)direction, false); } 

एक और ऑपरेशन जो सड़क को गलत बना सकता है वह है ऊँचाई में बदलाव। इस मामले में, हमें सभी दिशाओं में सड़कों की जांच करनी होगी। यदि ऊंचाई अंतर बहुत बड़ा है, तो मौजूदा सड़क को हटाने की आवश्यकता है।

  public int Elevation { get { return elevation; } set { … for (int i = 0; i < roads.Length; i++) { if (roads[i] && GetElevationDifference((HexDirection)i) > 1) { SetRoad(i, false); } } Refresh(); } } 

unitypackage

सड़क का संपादन

संपादन सड़कें नदियों को संपादित करने की तरह ही काम करती हैं। इसलिए HexMapEditor, एक और स्विच की आवश्यकता है, साथ ही इसके राज्य की स्थापना के लिए एक विधि।

  OptionalToggle riverMode, roadMode; public void SetRiverMode (int mode) { riverMode = (OptionalToggle)mode; } public void SetRoadMode (int mode) { roadMode = (OptionalToggle)mode; } 

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

  void EditCell (HexCell cell) { if (cell) { if (applyColor) { cell.Color = activeColor; } if (applyElevation) { cell.Elevation = activeElevation; } if (riverMode == OptionalToggle.No) { cell.RemoveRiver(); } if (roadMode == OptionalToggle.No) { cell.RemoveRoads(); } if (isDrag) { HexCell otherCell = cell.GetNeighbor(dragDirection.Opposite()); if (otherCell) { if (riverMode == OptionalToggle.Yes) { otherCell.SetOutgoingRiver(dragDirection); } if (roadMode == OptionalToggle.Yes) { otherCell.AddRoad(dragDirection); } } } } } 

हम नदी पट्टी को कॉपी करके और स्विचेस द्वारा बुलाए गए तरीके को बदलकर यूआई में सड़क पट्टी को जल्दी से जोड़ सकते हैं।

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


सड़कों के साथ यूआई।

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



पांच रंग: पीला, हरा, नीला, नारंगी और सफेद।

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


निरीक्षक में सड़कों के साथ सेल।

unitypackage

सड़क का त्रिकोणासन

सड़कों को प्रदर्शित करने के लिए, आपको उन्हें त्रिकोणित करने की आवश्यकता है। यह नदियों के लिए एक जाल बनाने के समान है, केवल नदी के किनारे राहत में दिखाई नहीं देंगे।

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

 Shader "Custom/Road" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Metallic ("Metallic", Range(0,1)) = 0.0 } SubShader { Tags { "RenderType"="Opaque" } LOD 200 CGPROGRAM #pragma surface surf Standard fullforwardshadows #pragma target 3.0 sampler2D _MainTex; struct Input { float2 uv_MainTex; }; half _Glossiness; half _Metallic; fixed4 _Color; void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = fixed4(IN.uv_MainTex, 1, 1); o.Albedo = c.rgb; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } ENDCG } FallBack "Diffuse" } 

इस shader का उपयोग करके एक सड़क सामग्री बनाएँ।


सामग्री सड़क।

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



बाल वस्तु सड़कें।

उसके बाद, HexGridChunkसामान्य फ़ील्ड में जोड़ें HexMesh roadsऔर इसे इसमें शामिल करें Triangulate। इसे इंस्पेक्टर में रोड्स ऑब्जेक्ट से कनेक्ट करें ।

  public HexMesh terrain, rivers, roads; public void Triangulate () { terrain.Clear(); rivers.Clear(); roads.Clear(); for (int i = 0; i < cells.Length; i++) { Triangulate(cells[i]); } terrain.Apply(); rivers.Apply(); roads.Apply(); } 

रोड्स ऑब्जेक्ट जुड़ा हुआ है।

कोशिकाओं के बीच की सड़कें

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

  void TriangulateRoadSegment ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 v5, Vector3 v6 ) { roads.AddQuad(v1, v2, v4, v5); roads.AddQuad(v2, v3, v5, v6); } 

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

  void TriangulateRoadSegment ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 v5, Vector3 v6 ) { roads.AddQuad(v1, v2, v4, v5); roads.AddQuad(v2, v3, v5, v6); roads.AddQuadUV(0f, 1f, 0f, 0f); roads.AddQuadUV(1f, 0f, 0f, 0f); } 

कोशिकाओं के बीच सड़क का एक खंड।

इस पद्धति को कॉल करना तर्कसंगत होगा TriangulateEdgeStrip, लेकिन केवल अगर वहाँ वास्तव में एक सड़क है। इस जानकारी को पारित करने के लिए विधि में एक बूलियन पैरामीटर जोड़ें।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color c1, EdgeVertices e2, Color c2, bool hasRoad ) { … } 

बेशक, अब हम संकलक त्रुटियों को प्राप्त करेंगे, क्योंकि अभी तक यह जानकारी अभी तक प्रसारित नहीं हुई है। सभी मामलों में अंतिम तर्क के रूप में, कॉल TriangulateEdgeStripको जोड़ा जा सकता है false। हालाँकि, हम यह भी घोषित कर सकते हैं कि इस पैरामीटर का डिफ़ॉल्ट मान बराबर है false। इसके कारण, पैरामीटर वैकल्पिक हो जाएगा और संकलन त्रुटियां गायब हो जाएंगी।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color c1, EdgeVertices e2, Color c2, bool hasRoad = false ) { … } 

सड़क को त्रिभुज करने के लिए TriangulateRoadSegment, यदि आवश्यक हो, तो केवल मध्य छह चोटियों के साथ कॉल करें ।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color c1, EdgeVertices e2, Color c2, bool hasRoad = false ) { terrain.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2); terrain.AddQuadColor(c1, c2); terrain.AddQuad(e1.v2, e1.v3, e2.v2, e2.v3); terrain.AddQuadColor(c1, c2); terrain.AddQuad(e1.v3, e1.v4, e2.v3, e2.v4); terrain.AddQuadColor(c1, c2); terrain.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5); terrain.AddQuadColor(c1, c2); if (hasRoad) { TriangulateRoadSegment(e1.v2, e1.v3, e1.v4, e2.v2, e2.v3, e2.v4); } } 

यह है कि हम फ्लैट सेल कनेक्शन कैसे संभालते हैं। सड़कों पर सड़कों का समर्थन करने के लिए, हमें यह भी बताना होगा TriangulateEdgeTerracesकि सड़क को कहां जोड़ा जाना चाहिए। वह बस इस जानकारी को व्यक्त कर सकता है TriangulateEdgeStrip।

  void TriangulateEdgeTerraces ( EdgeVertices begin, HexCell beginCell, EdgeVertices end, HexCell endCell, bool hasRoad ) { EdgeVertices e2 = EdgeVertices.TerraceLerp(begin, end, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.Color, endCell.Color, 1); TriangulateEdgeStrip(begin, beginCell.Color, e2, c2, hasRoad); for (int i = 2; i < HexMetrics.terraceSteps; i++) { EdgeVertices e1 = e2; Color c1 = c2; e2 = EdgeVertices.TerraceLerp(begin, end, i); c2 = HexMetrics.TerraceLerp(beginCell.Color, endCell.Color, i); TriangulateEdgeStrip(e1, c1, e2, c2, hasRoad); } TriangulateEdgeStrip(e2, c2, end, endCell.Color, hasRoad); } 

TriangulateEdgeTerracesअंदर बुलाया TriangulateConnection। यह यहां है कि हम यह निर्धारित कर सकते हैं कि क्या वास्तव में वर्तमान दिशा में एक सड़क जा रही है, दोनों जब एक किनारे पर त्रिकोणीय और जब त्रिकोणीय सीढ़ियां हैं।

 if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces( e1, cell, e2, neighbor, cell.HasRoadThroughEdge(direction) ); } else { TriangulateEdgeStrip( e1, cell.Color, e2, neighbor.Color, cell.HasRoadThroughEdge(direction) ); } 

कोशिकाओं के बीच सड़क खंड।

प्रतिपादन पर सेल

सड़कें बनाते समय, आप देखेंगे कि सड़क खंड कोशिकाओं के बीच दिखाई देते हैं। इन खंडों के मध्य किनारों पर नीले रंग के संक्रमण के साथ बैंगनी होगा।

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

राहत पहुंचाने के बाद सबसे पहले हम सड़कों को खींचना चाहते हैं। यह सामान्य ज्यामिति के प्रतिपादन के बाद उन्हें प्रस्तुत करके प्राप्त किया जा सकता है, अर्थात्, बाद में प्रतिपादन कतार में रखकर।

  Tags { "RenderType"="Opaque" "Queue" = "Geometry+1" } 

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

  Tags { "RenderType"="Opaque" "Queue" = "Geometry+1" } LOD 200 Offset -1, -1 

कोशिकाओं के माध्यम से सड़कें

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

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


सड़क के एक हिस्से का त्रिकोणासन।

इस योजना को त्रिभुज करने के लिए, हमें सेल के केंद्र, बाएँ और दाएँ मध्य कोने और किनारे के कोने को जानना होगा। TriangulateRoadउपयुक्त मापदंडों के साथ एक विधि जोड़ें ।

  void TriangulateRoad ( Vector3 center, Vector3 mL, Vector3 mR, EdgeVertices e ) { } 

सड़क खंड बनाने के लिए, हमें एक अतिरिक्त चोटी की आवश्यकता है। यह बाएँ और दाएँ मध्य शिखर के बीच स्थित है।

  void TriangulateRoad ( Vector3 center, Vector3 mL, Vector3 mR, EdgeVertices e ) { Vector3 mC = Vector3.Lerp(mL, mR, 0.5f); TriangulateRoadSegment(mL, mC, mR, e.v2, e.v3, e.v4); } 

अब हम शेष दो त्रिकोणों को भी जोड़ सकते हैं।

  TriangulateRoadSegment(mL, mC, mR, e.v2, e.v3, e.v4); roads.AddTriangle(center, mL, mC); roads.AddTriangle(center, mC, mR); 

हमें त्रिभुजों के यूवी निर्देशांक को भी जोड़ना होगा। उनकी दो चोटियाँ सड़क के बीच में हैं, और शेष किनारे पर है।

  roads.AddTriangle(center, mL, mC); roads.AddTriangle(center, mC, mR); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(1f, 0f) ); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f) ); 

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

  void Triangulate (HexDirection direction, HexCell cell) { … if (cell.HasRiver) { … } else { TriangulateWithoutRiver(direction, cell, center, e); } … } void TriangulateWithoutRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { TriangulateEdgeFan(center, e, cell.Color); if (cell.HasRoadThroughEdge(direction)) { TriangulateRoad( center, Vector3.Lerp(center, e.v1, 0.5f), Vector3.Lerp(center, e.v5, 0.5f), e ); } } 

कोशिकाओं के बीच से गुजरती सड़कें।

सड़क की पसलियाँ

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

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

  void TriangulateRoadEdge (Vector3 center, Vector3 mL, Vector3 mR) { roads.AddTriangle(center, mL, mR); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f) ); } 

सड़क के किनारे का हिस्सा।

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

  void TriangulateRoad ( Vector3 center, Vector3 mL, Vector3 mR, EdgeVertices e, bool hasRoadThroughCellEdge ) { if (hasRoadThroughCellEdge) { Vector3 mC = Vector3.Lerp(mL, mR, 0.5f); TriangulateRoadSegment(mL, mC, mR, e.v2, e.v3, e.v4); roads.AddTriangle(center, mL, mC); roads.AddTriangle(center, mC, mR); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(1f, 0f) ); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f) ); } else { TriangulateRoadEdge(center, mL, mR); } } 

अब किसी भी सड़क के सेल से गुजरने TriangulateWithoutRiverपर कॉल करना होगा TriangulateRoad। और उसे इस बारे में जानकारी प्रसारित करनी होगी कि क्या सड़क वर्तमान किनारे से गुजरती है।

  void TriangulateWithoutRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { TriangulateEdgeFan(center, e, cell.Color); if (cell.HasRoads) { TriangulateRoad( center, Vector3.Lerp(center, e.v1, 0.5f), Vector3.Lerp(center, e.v5, 0.5f), e, cell.HasRoadThroughEdge(direction) ); } } 

पूर्ण पसलियों के साथ सड़कें।

सड़क का सुचारू होना

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

आइए जानें कि प्रक्षेपक का उपयोग करने के लिए एक अलग विधि बनाएं। चूंकि उनमें से दो हैं, हम इसमें परिणाम डाल सकते हैं Vector2। इसका घटक X बाएं बिंदु का प्रक्षेपक होगा, और घटक Y दाएं बिंदु का प्रक्षेपक होगा।

  Vector2 GetRoadInterpolators (HexDirection direction, HexCell cell) { Vector2 interpolators; return interpolators; } 

यदि वर्तमान दिशा में कोई सड़क जा रही है, तो हम बिंदुओं को बीच में रख सकते हैं।

  Vector2 GetRoadInterpolators (HexDirection direction, HexCell cell) { Vector2 interpolators; if (cell.HasRoadThroughEdge(direction)) { interpolators.x = interpolators.y = 0.5f; } return interpolators; } 

अन्यथा, विकल्प अलग हो सकते हैं। बाएं बिंदु के लिए, हम ½ का उपयोग कर सकते हैं यदि पिछली दिशा में जाने वाली सड़क है। यदि यह नहीं है, तो हमें ¼ का उपयोग करना चाहिए। वही सही बिंदु पर लागू होता है, लेकिन निम्नलिखित दिशा को ध्यान में रखते हुए।

  Vector2 GetRoadInterpolators (HexDirection direction, HexCell cell) { Vector2 interpolators; if (cell.HasRoadThroughEdge(direction)) { interpolators.x = interpolators.y = 0.5f; } else { interpolators.x = cell.HasRoadThroughEdge(direction.Previous()) ? 0.5f : 0.25f; interpolators.y = cell.HasRoadThroughEdge(direction.Next()) ? 0.5f : 0.25f; } return interpolators; } 

अब आप इस नई विधि का उपयोग यह निर्धारित करने के लिए कर सकते हैं कि कौन से प्रक्षेपक उपयोग किए जाते हैं। इसके लिए धन्यवाद, सड़कों को सुचारू किया जाएगा।

  void TriangulateWithoutRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { TriangulateEdgeFan(center, e, cell.Color); if (cell.HasRoads) { Vector2 interpolators = GetRoadInterpolators(direction, cell); TriangulateRoad( center, Vector3.Lerp(center, e.v1, interpolators.x), Vector3.Lerp(center, e.v5, interpolators.y), e, cell.HasRoadThroughEdge(direction) ); } } 

चिकनी सड़कें।

unitypackage

नदियों और सड़कों का संयोजन

वर्तमान स्तर पर, हमारे पास कार्यात्मक सड़कें हैं, लेकिन केवल अगर कोई नदियाँ नहीं हैं। यदि सेल में एक नदी है, तो सड़कों को त्रिकोणित नहीं किया जाएगा।


नदियों के पास सड़कें नहीं हैं।

आइए TriangulateRoadAdjacentToRiverइस स्थिति को संभालने के लिए एक विधि बनाएं । हम इसे सामान्य मापदंडों पर सेट करते हैं। हम इसे विधि की शुरुआत में कहेंगे TriangulateAdjacentToRiver।

  void TriangulateAdjacentToRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { if (cell.HasRoads) { TriangulateRoadAdjacentToRiver(direction, cell, center, e); } … } void TriangulateRoadAdjacentToRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { } 

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

 void TriangulateRoadAdjacentToRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { bool hasRoadThroughEdge = cell.HasRoadThroughEdge(direction); Vector2 interpolators = GetRoadInterpolators(direction, cell); Vector3 roadCenter = center; Vector3 mL = Vector3.Lerp(roadCenter, e.v1, interpolators.x); Vector3 mR = Vector3.Lerp(roadCenter, e.v5, interpolators.y); TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge); } 

इसलिए हम नदियों के साथ कोशिकाओं में आंशिक सड़कों का निर्माण करेंगे। जिन दिशाओं से होकर नदियाँ गुजरती हैं, वे सड़कों के अंतराल से कट जाएँगी।


रिक्त स्थान वाली सड़कें।

नदी का आरंभ या अंत

आइए पहले किसी नदी की शुरुआत या अंत वाली कोशिकाओं को देखें। ताकि सड़कें पानी के साथ ओवरलैप न हों, चलो नदी से सड़क के केंद्र को स्थानांतरित करें। आने वाली या बाहर जाने वाली नदी की दिशा पाने के लिए, HexCellसंपत्ति जोड़ें ।

  public HexDirection RiverBeginOrEndDirection { get { return hasIncomingRiver ? incomingRiver : outgoingRiver; } } 

अब हम इस संपत्ति का उपयोग HexGridChunk.TriangulateRoadAdjacentToRiverविपरीत दिशा में सड़क के केंद्र को स्थानांतरित करने के लिए कर सकते हैं । इस दिशा में एक तिहाई को मध्य रिब में स्थानांतरित करने के लिए पर्याप्त होगा।

  bool hasRoadThroughEdge = cell.HasRoadThroughEdge(direction); Vector2 interpolators = GetRoadInterpolators(direction, cell); Vector3 roadCenter = center; if (cell.HasRiverBeginOrEnd) { roadCenter += HexMetrics.GetSolidEdgeMiddle( cell.RiverBeginOrEndDirection.Opposite() ) * (1f / 3f); } Vector3 mL = Vector3.Lerp(roadCenter, e.v1, interpolators.x); Vector3 mR = Vector3.Lerp(roadCenter, e.v5, interpolators.y); TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge); 

संशोधित सड़कें।

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

हम नदी के विन्यास की परवाह किए बिना ऐसा करेंगे, इसलिए इस कोड को विधि के अंत में रखें।

  Vector3 mL = Vector3.Lerp(roadCenter, e.v1, interpolators.x); Vector3 mR = Vector3.Lerp(roadCenter, e.v5, interpolators.y); TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge); if (cell.HasRiverThroughEdge(direction.Previous())) { TriangulateRoadEdge(roadCenter, center, mL); } if (cell.HasRiverThroughEdge(direction.Next())) { TriangulateRoadEdge(roadCenter, mR, center); } 

तैयार सड़कें।

सीधी नदियाँ

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


एक सीधी नदी को ओवरलैप करते हुए सड़कें।

यदि सेल में नदी की शुरुआत या अंत नहीं है, तो हम जांच कर सकते हैं कि आने वाली और बाहर जाने वाली नदियां विपरीत दिशाओं में जाती हैं या नहीं। यदि ऐसा है, तो हमारे पास एक सीधी नदी है।

  if (cell.HasRiverBeginOrEnd) { roadCenter += HexMetrics.GetSolidEdgeMiddle( cell.RiverBeginOrEndDirection.Opposite() ) * (1f / 3f); } else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite()) { } 

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

  bool hasRoadThroughEdge = cell.HasRoadThroughEdge(direction); bool previousHasRiver = cell.HasRiverThroughEdge(direction.Previous()); bool nextHasRiver = cell.HasRiverThroughEdge(direction.Next()); Vector2 interpolators = GetRoadInterpolators(direction, cell); Vector3 roadCenter = center; if (cell.HasRiverBeginOrEnd) { roadCenter += HexMetrics.GetSolidEdgeMiddle( cell.RiverBeginOrEndDirection.Opposite() ) * (1f / 3f); } else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite()) { if (previousHasRiver) { } else { } } Vector3 mL = Vector3.Lerp(roadCenter, e.v1, interpolators.x); Vector3 mR = Vector3.Lerp(roadCenter, e.v5, interpolators.y); TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge); if (previousHasRiver) { TriangulateRoadEdge(roadCenter, center, mL); } if (nextHasRiver) { TriangulateRoadEdge(roadCenter, mR, center); } 

हमें सड़क के केंद्र को नदी से विपरीत दिशा में इंगित करने वाले कोणीय वेक्टर में स्थानांतरित करना होगा। यदि नदी पिछली दिशा से गुजरती है, तो यह दूसरा ठोस कोण है। अन्यथा, यह पहला ठोस कोण है।

  else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite()) { Vector3 corner; if (previousHasRiver) { corner = HexMetrics.GetSecondSolidCorner(direction); } else { corner = HexMetrics.GetFirstSolidCorner(direction); } } 

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

  else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite()) { Vector3 corner; if (previousHasRiver) { corner = HexMetrics.GetSecondSolidCorner(direction); } else { corner = HexMetrics.GetFirstSolidCorner(direction); } roadCenter += corner * 0.5f; center += corner * 0.25f; } 

विभाजित सड़कें।

हमने इस सेल के अंदर सड़कों का एक नेटवर्क साझा किया। यह सामान्य है जब नदी के दोनों तरफ सड़कें होती हैं। लेकिन अगर एक तरफ सड़क नहीं है, तो हमारे पास एक अलग सड़क का एक छोटा टुकड़ा होगा। यह अतार्किक है, तो आइए ऐसे हिस्सों से छुटकारा पाएं।

सुनिश्चित करें कि वर्तमान दिशा में एक सड़क जा रही है। यदि ऐसा नहीं है, तो सड़क की उपस्थिति के लिए नदी के उसी तरफ की दूसरी दिशा की जांच करें। यदि वहां या वहां से कोई गुजरने वाली सड़क नहीं है, तो हम त्रिकोणासन से पहले विधि से बाहर निकलते हैं।

  if (previousHasRiver) { if ( !hasRoadThroughEdge && !cell.HasRoadThroughEdge(direction.Next()) ) { return; } corner = HexMetrics.GetSecondSolidCorner(direction); } else { if ( !hasRoadThroughEdge && !cell.HasRoadThroughEdge(direction.Previous()) ) { return; } corner = HexMetrics.GetFirstSolidCorner(direction); } 

सड़कों को काट दिया।

ज़िगज़ैग नदियाँ

नदी का अगला प्रकार ज़िग्जैग है। ऐसी नदियाँ सड़क नेटवर्क को साझा नहीं करती हैं, इसलिए हमें बस सड़क के केंद्र को स्थानांतरित करने की आवश्यकता है।


सड़कों से गुजर रहे झूले

ज़िगज़ैग की जांच करने का सबसे आसान तरीका आने वाली और बहने वाली नदियों की दिशाओं की तुलना करना है। यदि वे आसन्न हैं, तो हमारे पास एक ज़िगज़ैग है। यह प्रवाह की दिशा के आधार पर दो संभावित विकल्पों की ओर जाता है।

  if (cell.HasRiverBeginOrEnd) { … } else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite()) { … } else if (cell.IncomingRiver == cell.OutgoingRiver.Previous()) { } else if (cell.IncomingRiver == cell.OutgoingRiver.Next()) { } 

हम आने वाली नदी की दिशा के कोनों में से एक का उपयोग करके सड़क के केंद्र को स्थानांतरित कर सकते हैं। आपके द्वारा चुना गया कोण प्रवाह की दिशा पर निर्भर करता है। 0.2 के कारक के साथ इस कोण से सड़क के केंद्र को स्थानांतरित करें।

  else if (cell.IncomingRiver == cell.OutgoingRiver.Previous()) { roadCenter -= HexMetrics.GetSecondCorner(cell.IncomingRiver) * 0.2f; } else if (cell.IncomingRiver == cell.OutgoingRiver.Next()) { roadCenter -= HexMetrics.GetFirstCorner(cell.IncomingRiver) * 0.2f; } 

सड़क को ज़िगज़ैग से दूर धकेल दिया।

कुटिल नदियों के अंदर

अंतिम नदी विन्यास एक चिकनी वक्र है। सीधी नदी की तरह, यह सड़कें भी अलग कर सकती हैं। लेकिन इस मामले में, पक्ष अलग होंगे। पहले हमें वक्र के अंदर के साथ काम करने की आवश्यकता है।


पक्की सड़कों के साथ एक घुमावदार नदी।

जब हमारे पास वर्तमान दिशा के दोनों तरफ एक नदी होती है, तो हम वक्र के अंदर होते हैं।

  else if (cell.IncomingRiver == cell.OutgoingRiver.Next()) { … } else if (previousHasRiver && nextHasRiver) { } 

हमें सड़क के केंद्र को सेल के वर्तमान किनारे की ओर ले जाने की जरूरत है, जिससे सड़क थोड़ी छोटी हो जाए। 0.7 का गुणांक करेगा। सेल केंद्र को 0.5 के गुणांक के साथ भी स्थानांतरित करना चाहिए।

  else if (previousHasRiver && nextHasRiver) { Vector3 offset = HexMetrics.GetSolidEdgeMiddle(direction) * HexMetrics.innerToOuter; roadCenter += offset * 0.7f; center += offset * 0.5f; } 

छोटी सड़कें।

सीधी नदियों के मामले में, हमें सड़कों के अलग-अलग हिस्सों को काटने की आवश्यकता होगी। इस मामले में, यह केवल वर्तमान दिशा की जांच करने के लिए पर्याप्त है।

  else if (previousHasRiver && nextHasRiver) { if (!hasRoadThroughEdge) { return; } Vector3 offset = HexMetrics.GetSolidEdgeMiddle(direction) * HexMetrics.innerToOuter; roadCenter += offset * 0.7f; center += offset * 0.5f; } 

सड़कों को काट दिया।

कुटिल नदियों के बाहर

पिछले सभी मामलों की जाँच के बाद, केवल शेष विकल्प घुमावदार नदी का बाहरी हिस्सा था। बाहर सेल के तीन हिस्से हैं। हमें मध्य दिशा खोजने की जरूरत है। इसे प्राप्त करने के बाद, हम सड़क के केंद्र को 0.25 के कारक से इस रिब की ओर ले जा सकते हैं।

  else if (previousHasRiver && nextHasRiver) { … } else { HexDirection middle; if (previousHasRiver) { middle = direction.Next(); } else if (nextHasRiver) { middle = direction.Previous(); } else { middle = direction; } roadCenter += HexMetrics.GetSolidEdgeMiddle(middle) * 0.25f; } 

सड़क के बाहर बदल दिया।

अंतिम चरण के रूप में, हमें नदी के इस तरफ की सड़कों को छोटा करना होगा। सबसे आसान तरीका बीच के सापेक्ष सड़क की तीनों दिशाओं की जांच करना है। अगर सड़कें नहीं हैं, तो हम काम करना बंद कर देते हैं।

  else { HexDirection middle; if (previousHasRiver) { middle = direction.Next(); } else if (nextHasRiver) { middle = direction.Previous(); } else { middle = direction; } if ( !cell.HasRoadThroughEdge(middle) && !cell.HasRoadThroughEdge(middle.Previous()) && !cell.HasRoadThroughEdge(middle.Next()) ) { return; } roadCenter += HexMetrics.GetSolidEdgeMiddle(middle) * 0.25f; } 

क्लिपिंग से पहले और बाद में सड़कें।

सभी नदी विकल्पों को संसाधित करने के बाद, हमारी नदियाँ और सड़कें सह-अस्तित्व में आ सकती हैं। नदियाँ सड़कों की उपेक्षा करती हैं, और सड़कें नदियों के अनुकूल होती हैं।


नदियों और सड़कों का संयोजन।

unitypackage

सड़कों की सूरत

उस क्षण तक, हमने सड़क के रंगों के रूप में उनके यूवी निर्देशांक का उपयोग किया। चूंकि केवल यू समन्वय बदल गया, हमने वास्तव में सड़क के मध्य और किनारे के बीच संक्रमण को प्रदर्शित किया।


यूवी निर्देशांक का प्रदर्शन।

अब जब सड़कें बिल्कुल सही ढंग से त्रिकोणित हो गई हैं, तो हम सड़क के शेडर को बदल सकते हैं ताकि यह सड़कों की तरह कुछ और प्रस्तुत करे। जैसा कि नदियों के मामले में, यह एक साधारण दृश्य होगा, कोई तामझाम नहीं।

हम सड़कों के लिए ठोस रंग का उपयोग करके शुरू करेंगे। बस सामग्री के रंग का उपयोग करें। मैंने इसे लाल कर दिया।

  void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = _Color; o.Albedo = c.rgb; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } 

लाल सड़कें।

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

  void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = _Color; float blend = IN.uv_MainTex.x; o.Albedo = c.rgb; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = blend; } 

ऐसा लगता है कि यह कुछ भी नहीं बदला है। ऐसा इसलिए हुआ क्योंकि हमारा शेप अपारदर्शी है। अब उसे अल्फा ब्लेंडिंग की जरूरत है। विशेष रूप से, हमें एक संभोग decal सतह के लिए एक shader की आवश्यकता है। हम निर्देश के लिए एक #pragma surfaceपंक्ति जोड़कर आवश्यक shader प्राप्त कर सकते हैं decal:blend।

  #pragma surface surf Standard fullforwardshadows decal:blend 

सड़कों का मिश्रण।

इसलिए हमने मध्य से किनारे तक एक चिकनी रैखिक मिश्रण बनाया जो बहुत सुंदर नहीं दिखता है। इसे सड़क की तरह बनाने के लिए, हमें एक ठोस क्षेत्र की आवश्यकता है, इसके बाद एक अपारदर्शी क्षेत्र में त्वरित संक्रमण होता है। आप इसके लिए फ़ंक्शन का उपयोग कर सकते हैं smoothstep। यह 0 से 1 तक एक रैखिक प्रगति को एस-आकार के वक्र में परिवर्तित करता है।


रैखिक प्रगति और smoothstep।

फ़ंक्शन smoothstepमें एक मनमाना अंतराल में वक्र फिट करने के लिए न्यूनतम और अधिकतम पैरामीटर है। सीमा के बाहर इनपुट मान वक्र को सपाट रखने के लिए सीमित हैं। कर्व की शुरुआत में 0.4 और अंत में 0.7 का उपयोग करते हैं। इसका मतलब यह है कि यू 0 से 0.4 तक समन्वय पूरी तरह से पारदर्शी होगा। और यू 0.7 से 1 तक समन्वय पूरी तरह से अपारदर्शी होगा। संक्रमण 0.4 और 0.7 के बीच होता है।

  float blend = IN.uv_MainTex.x; blend = smoothstep(0.4, 0.7, blend); 

अपारदर्शी और पारदर्शी क्षेत्रों के बीच त्वरित संक्रमण।

शोर के साथ सड़क

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

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

सतह की छाया में दुनिया की स्थिति तक पहुंच प्राप्त करने के लिए, इनपुट संरचना में जोड़ें float3 worldPos।

  struct Input { float2 uv_MainTex; float3 worldPos; }; 

अब हम surfमुख्य बनावट के नमूने के लिए इस स्थिति का उपयोग कर सकते हैं । साथ ही ज़ूम आउट करें, अन्यथा बनावट बहुत बार दोहराएगी।

  float4 noise = tex2D(_MainTex, IN.worldPos.xz * 0.025); fixed4 c = _Color; float blend = IN.uv_MainTex.x; 

हम समन्वय यू को गुणा करके संक्रमण को विकृत करते हैं noise.x। लेकिन चूंकि शोर मान औसतन 0.5 है, इसलिए अधिकांश सड़कें गायब हो जाएंगी। इससे बचने के लिए, गुणा से पहले शोर में 0.5 जोड़ें।

  float blend = IN.uv_MainTex.x; blend *= noise.x + 0.5; blend = smoothstep(0.4, 0.7, blend); 

सड़क के विकृत किनारे।

इसे समाप्त करने के लिए, हम सड़कों के रंग को भी विकृत करेंगे। यह सड़कों को फजी किनारों के अनुरूप गंदगी की सनसनी देगा।

एक अन्य शोर चैनल द्वारा रंग को गुणा करें, द्वारा कहें noise.y। इसलिए हमें औसतन आधे रंग का मूल्य मिलता है। चूंकि यह बहुत अधिक है, हम शोर पैमाने को थोड़ा कम कर देंगे और एक निरंतर जोड़ देंगे ताकि योग 1 तक पहुंच सके।

  fixed4 c = _Color * (noise.y * 0.75 + 0.25); 

खस्ताहाल सड़कें।

unitypackage