एक तकनीकी-डेमो गेम के रूप में लॉजिक एल्गोरिदम का वर्णन, और एक कामकाजी उदाहरण का विश्लेषण

इस डेमो के WebGL2 संस्करण https://danilw.itch.io/flat-maze-web अन्य लिंक के लिए, लेख देखें।

लेख को दो भागों में विभाजित किया गया है, पहला तर्क के बारे में, और दूसरा भाग खेल में आवेदन के बारे में, पहला भाग :

• मुख्य विशेषताएं
• लिंक और एक संक्षिप्त विवरण।
• तर्क का एल्गोरिथ्म।
• तर्क की सीमाएँ। कीड़े / सुविधाएँ, और कोण कीड़े।
• सूचकांक डेटा तक पहुंच।

गेम डेमो का दूसरा विवरण, दूसरा भाग :

• इस तर्क की विशेषताएँ। और एक मिलियन पिक्सेल कणों का तेजी से प्रतिपादन।
• कार्यान्वयन, कोड पर कुछ टिप्पणियां, दो दिशाओं में टकराव का वर्णन। और खिलाड़ी के साथ बातचीत।
• उपयोग किए गए ग्राफिक्स के लिए लिंक ओपेंजामर्ट, और छाया के लिए एक छायादार। और cyberleninka.ru पर लेख लिंक

भाग 1

1. प्रमुख विशेषताएं

यह विचार वास्तविक समय में, जहां प्रत्येक कण की एक विशिष्ट पहचानकर्ता ID , आपस में सैकड़ों-हजारों कणों का टकराव / भौतिकी है।

जब प्रत्येक कण को ​​अनुक्रमित किया जाता है, तो किसी भी कण के किसी भी पैरामीटर को नियंत्रित करना संभव होता है , उदाहरण के लिए द्रव्यमान, इसका स्वास्थ्य (hp) या क्षति, त्वरण, मंदी, जो कि कणों के प्रकार / सूचकांक के आधार पर घटना का सामना करने और प्रतिक्रिया करने के लिए वस्तुओं, प्रत्येक कण के लिए अद्वितीय टाइमर भी हैं। , और इतने पर आवश्यक है।

GLSL पर सभी तर्क किसी भी गेम इंजन और किसी भी OS के लिए पूरी तरह से पोर्टेबल है जिसमें GLES3 सपोर्ट है।

कणों की अधिकतम संख्या फ्रेमबफ़र (फैबो, सभी पिक्सेल) के आकार के बराबर है।

कणों की एक आरामदायक संख्या (जब बातचीत करने के लिए कणों के लिए जगह होती है) (Resolution.x*Resolution.y/2)/2 । x (Resolution.x*Resolution.y/2)/2 x हर दूसरा पिक्सेल है और y में हर दूसरा पिक्सेल है, यही कारण है कि लॉजिक विवरण ऐसा कहता है।

लेख का पहला भाग न्यूनतम तर्क दिखाता है, दूसरे में, एक खेल के उदाहरण का उपयोग करके, बड़ी संख्या में बातचीत की शर्तों के साथ तर्क।

2. लिंक और संक्षिप्त विवरण

मैंने इस तर्क पर तीन डेमो किए:

1. GLSL के टुकड़े-टुकड़े पर, shadertoy पर https://www.shadertoy.com/view/tstSz7 पर , सभी तर्क में बफ़र कोड देखें। यह कोड आपको अपने यूवी के साथ एक मनमाना स्थिति में, अंश-कणों का उपयोग किए बिना एक टुकड़े-टुकड़े पर, सैकड़ों कणों को प्रदर्शित करने की अनुमति देता है।

2. इंस्टेंटेड पार्टिकल्स को लॉजिक लॉजिक (गोडोट द्वारा एक इंजन के रूप में उपयोग किया जाता है)

लिंक वेब संस्करण , एक्सई (जीत) , स्रोत प्रोजेक्ट कण_2D_self_collision ।

संक्षिप्त विवरण: यह इंस्टेंस्ड-कणों पर एक बुरा प्रदर्शन है , इस तथ्य के कारण कि मैं अधिकतम वृद्धि करता हूं जहां पूरा नक्शा दिखाई देता है, 640x360 कण (230k) हमेशा संसाधित होते हैं, यह बहुत कुछ है। खेल के विवरण में नीचे देखें, वहां मैंने अतिरिक्त कणों के बिना, इसे सही किया। (वीडियो में एक कण सूचकांक त्रुटि है, यह कोड में तय किया गया है)

3. खेल, खेल के विवरण में इसके बारे में नीचे। लिंक वेब संस्करण , exe (जीत) , स्रोत

3. तर्क का एल्गोरिथ्म

संक्षेप में:

तर्क गिरने वाली रेत के समान है, प्रत्येक पिक्सेल स्थिति के आंशिक मूल्य (उसके पिक्सेल के भीतर शिफ्ट) और वर्तमान त्वरण को संरक्षित करता है।

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

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

डेटा इस तरह से संग्रहीत किया जाता है: (इस बग के कारण, प्रतिबंध देखें)

 pixel.rgba r=[0xfffff-posx, 0xf-data] g=[0xfffff-posy, 0xf-data] b=[0xffff-velx, 0xff-data] a=[0xffff-vely, 0xff-data] 

कोड में , BufC https://www.shadertoy.com/view/tstSz7 , 115 ट्रांस्फ़ॉर्म-चेक, 139 टक्कर-चेक के लिए लाइन नंबर।

आसन्न मूल्यों को लेने के लिए ये सरल लूप हैं। और स्थिति यह है, यदि स्थिति को वर्तमान पिक्सेल की स्थिति के बराबर लिया जाता है, तो हम उस डेटा को इस पिक्सेल (इस प्रतिबंध के कारण) , और पड़ोसी पिक्सल के आधार पर vel परिवर्तनों के मान को स्थानांतरित करते हैं, यदि कोई हो।

यह सब कण तर्क है।

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

इसके बाद प्रतिपादन (रेंडरिंग) आता है, खंड-शेडर के मामले में, प्रतिच्छेदन क्षेत्रों को प्रदर्शित करने के लिए पिक्सल को 1 के दायरे में लिया जाता है। इंस्टेंटेड-पार्टिकल्स के मामले में, एक पिक्सेल को एक रैखिक दृश्य से दो आयामी सरणी में अनुवादित INSTANCE_ID पते पर लिया जाता है।

4. तर्क की सीमा। बग्स / सुविधाएँ, और ANGLE बग्स

1. पिक्सेल आकार , कोड में BALL_SIZE , गणना की सीमा के भीतर, sqrt(2)/2 से अधिक और 1 से कम होना चाहिए। 1 के करीब, पिक्सेल के अंदर चलने के लिए कम स्थान (पिक्सेल स्वयं), जितना कम स्थान। इस तरह के आकार की आवश्यकता होती है ताकि पिक्सेल एक-दूसरे में न गिरें, 1 से कम सेट किया जा सकता है जब आपके पास छोटी वस्तुएं हों, तो 1 पिक्सेल (गणना) से कम वस्तुओं का भ्रम पैदा होता है।
2. गति 1 पिक्सेल से अधिक नहीं हो सकती है अन्यथा पिक्सेल गायब हो जाएंगे। लेकिन फ्रेम प्रति 1 से अधिक की गति होना संभव है, यदि आप कई फ्रेमबफ़र (फ़ोबो / व्यूपोर्ट) बनाते हैं और एक ही बार में कई लॉजिक चरणों को संसाधित करते हैं, तो फ़्रेम-गति अतिरिक्त फ़ेबो की संख्या के बराबर गुना बढ़ जाएगी। यह मैंने फलों के डेमो में किया है, और shadertoy (bufC को bufD पर कॉपी किया गया) के लिंक का उपयोग कर रहा है।
3. दबाव सीमा (जैसे गुरुत्वाकर्षण, या अन्य बल-सामान्य-नक्शा)। यदि कई पड़ोसी पिक्सेल इस की स्थिति लेते हैं (ऊपर चित्र देखें), तो केवल एक ही बचाया जाता है, शेष पिक्सेल गायब हो जाते हैं। Shadertoy पर डेमो में नोटिस करना आसान है , माउस को फोर्स पर सेट करें, MOUSE_F का मान कॉमन 10 में बदलें, और कणों को स्क्रीन के कोने तक निर्देशित करें, वे एक दूसरे में गायब हो जाएंगे। या maxG में गुरुत्व मान maxG साथ समान है ।
4. एंगल में बग। इस तर्क के लिए GPU (इंस्टेंस्ड) -पार्टिकल में काम करने के लिए, स्थिति की गणना करने के लिए सबसे अच्छा (सस्ता, तेज) है और उदाहरण के लिए , अन्य सभी कण पैरामीटर, उदाहरण के लिए- shader में । लेकिन एंगल शैडर के लिए एक से अधिक फ़ेबो-टेक्सचर का उपयोग करने की अनुमति नहीं देता है , इसलिए लॉजिक के भाग की गणना को वेरटेक्स-शेडर में स्थानांतरित किया जाना चाहिए, जहां उदाहरण के लिए शेडर से इंडेक्स नंबर को स्थानांतरित करना है। यह वही है जो मैंने GPU कणों के साथ दोनों डेमो में किया था।
5. दोनों डेमो में एक गंभीर बग (खेल को छोड़कर) स्थिति मान खो जाएगा यदि यह 1/0xfffff का एक से अधिक नहीं है 1/0xfffff बग परीक्षण यहां https://www.shadertoy.com/view/WdtSWS है
   अधिक सटीक रूप से, यह बग नहीं है, और ऐसा होना चाहिए, सादगी के लिए, इस एल्गोरिथ्म के हिस्से के रूप में, मैंने इसे बग कहा।

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

5. इंडेक्स डेटा तक पहुंच

इंस्टेंट-पार्टिकल का अपना INSTANCE_ID , यह फ्रेम लॉकर की बनावट से एक कण लेता है जिसमें कण लॉजिक (bufC, shader के लिए उदाहरण) होता है, अगर हम इस कण के कण को ​​अनपैक करते हैं (देखें डेटा स्टोरेज) इस आईडी की आईडी , इस आईडी द्वारा हम कणों के लिए डेटा के साथ बनावट पढ़ते हैं (bufB) , एक shader पर एक उदाहरण)।

Shadertoy उदाहरण में, bufB प्रत्येक कण के लिए केवल रंग संग्रहीत करता है, लेकिन यह स्पष्ट है कि कोई भी डेटा हो सकता है, जैसा कि द्रव्यमान, त्वरण, मंदी ने पहले लिखा था, साथ ही साथ कोई भी तार्किक क्रियाएं (उदाहरण के लिए, आप किसी भी कण को ​​किसी भी स्थिति (teleport) में स्थानांतरित कर सकते हैं यदि किया गया हो कोड में संगत तार्किक कार्रवाई), आप कीबोर्ड से किसी भी कण या समूह की गति को नियंत्रित कर सकते हैं ...

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

भाग २

1. इस तर्क की प्रयुक्त विशेषताएँ। और एक लाख पिक्सेल कणों का तेजी से प्रतिपादन

कणों के लिए फ्रेमबफ़र (फैबो / व्यूपोर्ट) का आकार 1280x720 है, भागों 1 के बाद स्थित हैं, यह 230 हजार सक्रिय कण (भूलभुलैया में सक्रिय तत्व) है।
स्क्रीन पर हमेशा 12 हजार से अधिक जीपीओ-इंस्टेंट कण नहीं होते हैं।

तर्क का उपयोग करता है:

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

फलों के डेमो की तुलना में, जहां ओवरहेड है, इस गेम में GPU- इंस्टेंट कणों की संख्या केवल 12 हजार है।

यह इस तरह दिखता है:

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

2. कार्यान्वयन, कोड पर कुछ टिप्पणियां।

सभी गेम कोड GPU पर है।

/Shaders/scene2/particle_logic2.shader फ़ाइल में वर्टेक्स फ़ंक्शन में वृद्धि के साथ स्क्रीन में कणों की शिफ्ट की गणना करने के लिए तर्क एक कण shader फ़ाइल (वर्टेक्स और टुकड़ा) है, न कि एक इंस्टेंट shader, इंस्टेंट shader कुछ भी नहीं करता है, केवल इसके सूचकांक के कारण गुजरता है ऊपर वर्णित बग।

कणों द्वारा प्रकार और एक फ़ाइल में कणों की बातचीत का पूरा तर्क, यह एक फ्रेम shader shader फ़ाइल shaders / scene2 / कणों_fbo_logic.shader की एक फ़ाइल है

 // 1-2 ghost // 3-zombi // 4-18 blocks // +20 is on fire // 40 is bullet(right) 41 left 42 top 43 down 

डेटा स्टोरेज पिक्सेल [pos.x, pos.y, [0xffff-vel.x, 0xff-data1],[0xffff-vel.y, 0xff-data2]]
data1 एक प्रकार है, data2 एक HP या टाइमर है।

टाइमर प्रत्येक कण में फ़्रेम में जाता है, टाइमर का अधिकतम मूल्य 255 है, मुझे इसकी बहुत आवश्यकता नहीं है, मैं केवल 1-16 अधिकतम ( 0xf ) का उपयोग करता हूं, और 0xf अप्रयुक्त रहता है जहां उदाहरण के लिए आप वास्तविक एचपी मूल्य को स्टोर कर सकते हैं, यह मेरे लिए उपयोग नहीं किया जाता है। (वह है, हाँ, मैं टाइमर के लिए 0xff उपयोग करता हूं , लेकिन वास्तव में मेरे पास केवल एनीमेशन के 16 से कम फ्रेम हैं, और 0xf पर्याप्त 0xf , लेकिन मुझे अतिरिक्त डेटा की आवश्यकता नहीं थी)
वास्तव में 0xff उपयोग केवल जलते हुए पेड़ों के टाइमर पर किया जाता है, वे 255 फ्रेम के बाद लाश में बदल जाते हैं। टाइमर तर्क आंशिक रूप से कण type_hp_logic शेडर (ऊपर लिंक) में type_hp_logic में है।

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

फ़ाइल शेड्स / सीन 2 / कण_फबो_लॉजिक.शेयर लाइन 438:

 if (((real_index == 40) || (real_index == 41) || (real_index == 42) || (real_index == 43)) && (type_hp.y > 22)) { int h_id = get_id(fragCoord + vec2(float(x), float(y))); ivec2 htype_hp = unpack_type_hp(h_id); int hreal_index = htype_hp.x; if ((hreal_index != 40) && (hreal_index != 41) && (hreal_index != 42) && (hreal_index != 43)) type_hp.y = 22; } else { if (!need_upd) { int h_id = get_id(fragCoord + vec2(float(x), float(y))); ivec2 htype_hp = unpack_type_hp(h_id); int hreal_index = htype_hp.x; if (((hreal_index == 40) || (hreal_index == 41) || (hreal_index == 42) || (hreal_index == 43)) && (htype_hp.y > 22)) { need_upd = true; } } } 

real_index एक प्रकार है, प्रकार ऊपर सूचीबद्ध हैं, 40-43 एक आग का गोला है ।
आगे type_hp.y > 22 टाइमर का मूल्य है, अगर यह 22 से अधिक है तो आग का गोला कुछ भी सामना नहीं किया।
h_id = get_id(... सामने आए कण के प्रकार और HP (टाइमर) का मान लें
hreal_index != 40... उपेक्षित प्रकार (अन्य आग का गोला )
type_hp.y = 22 एक टाइमर type_hp.y = 22 पर सेट है, यह एक संकेतक है कि यह आग का गोला एक वस्तु से टकरा गया।
else { if (!need_upd) चर need_upd चेक करता है कि कोई दोहराया टकराव नहीं है, क्योंकि फ़ंक्शन एक लूप में है, हम एक फायरबॉल का सामना करते हैं।
h_id = get_id(... यदि अभी तक कोई टक्कर नहीं हुई है, तो हम प्रकार और टाइमर की एक वस्तु लेते हैं।
hreal_index == 40...htype_hp.y > 22 कि टक्कर ऑब्जेक्ट आग का गोला है और यह बाहर नहीं जाता है।
need_upd = true flag कि आग का सामना करने के बाद से उस प्रकार को अपडेट करना आवश्यक है।

आगे की लाइन 481
if((need_upd)&&(real_index<24)){ real_index <24 प्रकार के 24 से कम गैर जलते हुए ज़ोंबी और भूत के पेड़ हैं, और फिर इस स्थिति में हम वर्तमान प्रकार के आधार पर प्रकार को अपडेट करते हैं।

इस प्रकार, वस्तुओं की लगभग कोई भी बातचीत की जा सकती है।

खिलाड़ी के साथ बातचीत:

फाइल शेडर्स / सीन 2 / लॉजिक.शेयर लाइन 143 फंक्शन player_collision

यह तर्क 4x4 पिक्सेल त्रिज्या में खिलाड़ी के चारों ओर पिक्सेल को पढ़ता है, प्रत्येक पिक्सेल की स्थिति लेता है और खिलाड़ी की स्थिति के साथ तुलना करता है, यदि कोई तत्व पाया जाता है, तो टाइपिंग की जाँच अगले है, अगर यह एक राक्षस है तो हम खिलाड़ी से एचपी लेते हैं।

यह थोड़ा गलत काम करता है और मैं इसे ठीक नहीं करना चाहता था , इस फ़ंक्शन को अधिक सटीक बनाया जा सकता है।

एक हमले के दौरान खिलाड़ी और प्रतिकर्षण प्रभाव से कण दूर हो जाते हैं:

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

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

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

3. इस्तेमाल किए गए ग्राफिक्स के लिंक ओपेंजामर्ट और छाया शेडर के साथ

मुझे cyberleninka.ru पर एक लेख का लिंक दिया गया
जिसमें मेरे द्वारा उपयोग किए गए एल्गोरिथ्म का वर्णन, शायद इसमें , मेरे, लेख की तुलना में अधिक विस्तृत और सही विवरण है।

इस shader https://www.shadertoy.com/view/XsK3RR (मेरे पास एक संशोधित कोड है) के आधार पर, छायादार बहुत सरलता से काम करता है
शेडर 1 डी रेडियल लाइटमैप बनाता है

और फर्श पेंटिंग कोड में छायांकन / दृश्य 2 / mainImage.shader

उपयोग किए गए ग्राफिक्स के लिंक , साइट से गेम के सभी ग्राफिक्स https://opengameart.org
fireball https://opengameart.org/content/animated-traps-and-obstructionles
चरित्र https://opengameart.org/content/legend-of-faune
पेड़ और ब्लॉक https://opengameart.org/content/lolly-set-01
(और opengameart के साथ कुछ और तस्वीरें)

मेनू में ग्राफिक्स 2D_GI shader द्वारा प्राप्त किए गए थे , ऐसे मेनू बनाने के लिए एक उपयोगिता:

अंत तक किसने पढ़ा - अच्छा किया :)
यदि आपके कोई प्रश्न हैं, तो पूछें, मैं अनुरोध पर विवरण को पूरक कर सकता हूं।