हम प्रक्रियात्मक रूप से विज्ञान-फाई मॉडल को जटिल बनाते हैं: ग्रीक क्या है और इसका उपयोग कैसे करें

शुरुआत करने के लिए, मुझे शिकायत करनी चाहिए कि "ग्रीबल" एक भयानक शब्द है जिसे शब्दकोष से गायब कर दिया जाना है।

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


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

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

सतह सामान्य

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

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

फिर हम इस वेक्टर को सामान्य करते हैं ताकि इसकी लंबाई 1 हो, क्योंकि सामान्य से सतह तक हमें केवल दिशा की आवश्यकता होती है, लंबाई की नहीं।

  फ़ंक्शन getFaceNormal (मेष, पाली)
   Vec3 v1 = mesh: getVertex (पाली [1])
   Vec3 v2 = mesh: getVertex (पाली [2])
   Vec3 v3 = mesh: getVertex (पाली [3])
   Vec3 e1 = v2 - v1
   वी 3 ए 2 = वी 3 - वी 2
   वी 3 सामान्य = ई 1: क्रॉस (ई 2)
   सामान्य लौटें: सामान्य करें ()
 अंत 

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

  फ़ंक्शन getFaceNormal (मेष, पाली)
   Vec3 n = Vec3 (0, 0, 0)
   i = 1 के लिए, # -2 -2 करो
     Vec3 v1 = mesh: getVertex (पाली [1])
     Vec3 v2 = mesh: getVertex (पाली [1+ i])
     Vec3 v3 = mesh: getVertex (पाली [2+ i])
     n: जोड़ें ((v2 - v1): क्रॉस (v3 - v1))
   अंत
   वापसी n: सामान्य करें ()
 अंत 

एक उदाहरण एक तलीय चतुष्कोण के बाहर निकलने को दर्शाता है।

extruding

अब जब हमारे पास सतह के बारे में जानकारी सामान्य है, तो हम बहुभुज को सामान्य दिशा में निकालने के लिए तैयार हैं। सीधे शब्दों में कहें, बहुभुज को बाहर निकालने के लिए, हम सतह के सामान्य की दिशा में पुराने कोने को घुमाकर नए सिरे बनाते हैं।

अधिक जानकारी:

1. सामान्य दिशा में पुराने "नए" शिखर बनाएं।
   
   नए शीर्षकों की गणना निम्नानुसार की जा सकती है:
   
   

     (पुराने शिखर की स्थिति) + (सामान्य दिशा) 

   
   यह सामान्य सतह की दिशा में पुरानी स्थिति को "बदलाव" करता है।
   
   उदाहरण के लिए, ऊपर दी गई छवि को देखें, इस पर v1 सामान्य दिशा में v5 की ओर बढ़ता है।
2. नए और पुराने कोने को जोड़ने के लिए चतुष्कोण बनाएं।
   
   यह ध्यान दिया जाना चाहिए कि नए बहुभुज में प्रत्येक सूचकांक के लिए, एक नया चतुर्भुज बनाया जाता है।
   
   उदाहरण के लिए, v8, v7, v3 और v4 से बने क्वाड पर एक नज़र डालें।
3. पुराने बहुभुज को एक नए बहुभुज से बदलकर नए सिरे से बनाएं। उदाहरण के लिए, v5, v6, v7 और v8 से बने क्वाड पर एक नज़र डालें।

  फंक्शन एक्सट्रूडली (मेष, पॉलीइंडेक्स, लंबाई)
   int [] पाली = mesh.polys [पॉलीइंडेक्स]
   int [] newPoly = []
   Vec3 n = getFaceNormal (मेष, पाली)

   - (1) एक्सट्रूडेड वर्ट्स बनाएं
   j = 1 के लिए, # करें
     स्थानीय पी = मेष: getVertex (पाली [जे])
     newPoly [#newPoly + 1] = # mesh.verts
     - लंबाई एक्सट्रूज़न की लंबाई निर्धारित करती है
     जाल: addertex (पी + (एन * लंबाई))
   अंत

   - (2) क्वाड के साथ बाहर निकालना पक्षों
   j0 = 1 के लिए, # करें
     स्थानीय j1 = j0% # पल्ली + 1
     जाल: addQuad (
       पाली [जे ०],
       पाली [j1],
       newPoly [j1],
       newPoly [j0]
     )
   अंत

   - (3) मौजूदा चेहरे को एक्सट्रूडेड वर्टीकल पर ले जाएं
   j = 1 के लिए, # करें
     mesh.polys [pi] [j] = newPoly [j]
   अंत
 अंत 

एक समान मशरूम बनाना।

सभी जाली मशरूम

अब जब हमारे पास getSurfaceNormal () फ़ंक्शन और एक्सट्रूड () फ़ंक्शन है, तो मशरूम बनाना बहुत आसान है! हम बस एक्सट्रूड () फ़ंक्शन को प्रत्येक मेष बहुभुज पर लागू करते हैं । हम एक यादृच्छिक लंबाई के साथ extruding का उपयोग करते हैं ताकि प्रत्येक extruded बहुभुज का आकार थोड़ा अलग हो, जो बनावट की भावना पैदा करता है। नीचे दिखाया गया एल्गोरिथ्म ऊपर प्रस्तुत क्यूब पर लागू होता है, जिसमें पूरी तरह से चतुष्कोण होते हैं।

  फ़ंक्शन ग्रीबल (जाल)
   i = 1 के लिए, # mesh.polys करते हैं
     - ये यादृच्छिक मान मनमानी हैं: पी
     फ्लोट की लंबाई = यादृच्छिक: getUniformRange (0.1, 1.0)
     एक्सट्रूडेप्रोली (मेष, आई, लंबाई)
   अंत
   वापसी का जाल
 अंत 

बधाई हो, हमारी मशरूमिंग ने कमाई की है। लेकिन हम और अधिक कर सकते हैं! अब मशरूम लगाना एक समान है। इसे और अधिक रोचक बनाने के लिए संशोधनों के दो उदाहरण यहां दिए गए हैं।

संशोधन 1: मौज-मस्ती की उपस्थिति मौके पर निर्भर करती है

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

  i = 1 के लिए, # mesh.polys करते हैं
    <strong> यदि यादृच्छिक: संयोग (0.33) तो </ strong>
      फ्लोट की लंबाई = यादृच्छिक (0.1, 1.0)
      एक्सट्रूडेप्रोली (मेष, आई, लंबाई)
    अंत
  अंत
  वापसी का जाल
 अंत 

संशोधन 2: एक्सट्रूज़न स्केल जोड़ें

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

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

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

  - पाली का केंद्र ढूंढें
 Vec3 c = mesh: getFaceCentroid (पॉली)
 j = 1 के लिए, # करें
   स्थानीय पी = मेष: getVertex (पाली [जे])
   newPoly [#newPoly + 1] = # mesh.verts
   स्वयं: addVertex (
     math.lerp (cx, px, scale.x) + nx * लंबाई,
     math.lerp (cy, py, scale.y) + ny * लंबाई,
     math.lerp (cz, pz, scale.z) + nz * लंबाई
   )
   जाल: addertex (पी + (एन * लंबाई))
 अंत 

अब आप इसे प्रत्येक बहुभुज के लिए यादृच्छिक मान द्वारा स्केलिंग एल्गोरिथ्म में उपयोग कर सकते हैं। तो हमें ऊपर दिखाई गई इमेज मिलती है।

  फ़ंक्शन ग्रीबल (जाल)
   i = 1 के लिए, # mesh.polys करते हैं
     फ्लोट की लंबाई = यादृच्छिक: getUniformRange (0.1, 1.0)
     Vec3 स्केल = (यादृच्छिक: getUniformRange (0.1, 1.0),
                   यादृच्छिक: getUniformRange (0.1, 1.0),
                   यादृच्छिक: getUniformRange (0.1, 1.0)
     extrudePoly (मेष, आई, लंबाई, स्केल)
   अंत
   वापसी का जाल
 अंत 

अंत

महान, हम अंत करने के लिए मिल गया! मुझे उम्मीद है कि यह ट्यूटोरियल आपके लिए मददगार रहा होगा।