🏵️ 🧘🏿 🤦🏼 हम अपना खुद का voxel इंजन लिखते हैं 🕊️ 😺 🈯️

नोट: इस परियोजना के लिए पूर्ण स्रोत कोड यहां उपलब्ध है: [ स्रोत ]।

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

मूल टास्क-बॉट कॉन्सेप्ट [हबर में अनुवाद ] जारी होने के बाद, मुझे लगा कि मैं उस दो-आयामी स्थान द्वारा सीमित था जिसमें मैंने काम किया था। ऐसा लग रहा था कि यह बॉट्स के उभरते व्यवहार के लिए संभावनाओं को वापस पकड़ रहा है।

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

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

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

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

इंजन की अवधारणा

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

मैंने मुख्य रूप से वोक्सल्स का उपयोग करने का फैसला किया क्योंकि मैं एक ग्रिड के साथ काम करना चाहता था जिसके कई फायदे हैं:

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

इंजन में एक विश्व डेटा सिस्टम, एक रेंडरिंग सिस्टम और कई सहायक कक्षाएं (उदाहरण के लिए, ध्वनि और इनपुट प्रसंस्करण के लिए) शामिल हैं।

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

विश्व वर्ग

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

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

class World{ public: World(std::string _saveFile){ saveFile = _saveFile; loadWorld(); } //Data Storage std::vector<Chunk> chunks; //Loaded Chunks std::stack<int> updateModels; //Models to be re-meshed void bufferChunks(View view); //Generation void generate(); Blueprint blueprint; bool evaluateBlueprint(Blueprint &_blueprint); //File IO Management std::string saveFile; bool loadWorld(); bool saveWorld(); //other... int SEED = 100; int chunkSize = 16; int tickLength = 1; glm::vec3 dim = glm::vec3(20, 5, 20); //...

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

 class Chunk{ public: //Position information and size information glm::vec3 pos; int size; BiomeType biome; //Data Storage Member int data[16*16*16] = {0}; bool refreshModel = false; //Get the Flat-Array Index int getIndex(glm::vec3 _p); void setPosition(glm::vec3 _p, BlockType _type); BlockType getPosition(glm::vec3 _p); glm::vec4 getColorByID(BlockType _type); };

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

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

फ्रैगमेंट स्टोरेज और मेमोरी हैंडलिंग

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

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

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

ऐसा करने के लिए, World::bufferChunks() विधि उन टुकड़ों को हटाती है जो आभासी मेमोरी में हैं, लेकिन अदृश्य हैं, और बुद्धिमानी से विश्व फ़ाइल से नए टुकड़े लोड करते हैं।

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

 void World::bufferChunks(View view){ //Load / Reload all Visible Chunks evaluateBlueprint(blueprint); //Chunks that should be loaded glm::vec3 a = glm::floor(view.viewPos/glm::vec3(chunkSize))-view.renderDistance; glm::vec3 b = glm::floor(view.viewPos/glm::vec3(chunkSize))+view.renderDistance; //Can't exceed a certain size a = glm::clamp(a, glm::vec3(0), dim-glm::vec3(1)); b = glm::clamp(b, glm::vec3(0), dim-glm::vec3(1)); //Chunks that need to be removed / loaded std::stack<int> remove; std::vector<glm::vec3> load; //Construct the Vector of chunks we should load for(int i = ax; i <= bx; i ++){ for(int j = ay; j <= by; j ++){ for(int k = az; k <= bz; k ++){ //Add the vector that we should be loading load.push_back(glm::vec3(i, j, k)); } } } //Loop over all existing chunks for(unsigned int i = 0; i < chunks.size(); i++){ //Check if any of these chunks are outside of the limits if(glm::any(glm::lessThan(chunks[i].pos, a)) || glm::any(glm::greaterThan(chunks[i].pos, b))){ //Add the chunk to the erase pile remove.push(i); } //Don't reload chunks that remain for(unsigned int j = 0; j < load.size(); j++){ if(glm::all(glm::equal(load[j], chunks[i].pos))){ //Remove the element from load load.erase(load.begin()+j); } } //Flags for the Viewclass to use later updateModels = remove; //Loop over the erase pile, delete the relevant chunks. while(!remove.empty()){ chunks.erase(chunks.begin()+remove.top()); remove.pop(); } //Check if we want to load any guys if(!load.empty()){ //Sort the loading vector, for single file-pass std::sort(load.begin(), load.end(), [](const glm::vec3& a, const glm::vec3& b) { if(ax > bx) return true; if(ax < bx) return false; if(ay > by) return true; if(ay < by) return false; if(az > bz) return true; if(az < bz) return false; return false; }); boost::filesystem::path data_dir( boost::filesystem::current_path() ); data_dir /= "save"; data_dir /= saveFile; std::ifstream in((data_dir/"world.region").string()); Chunk _chunk; int n = 0; while(!load.empty()){ //Skip Lines (this is dumb) while(n < load.back().x*dim.z*dim.y+load.back().y*dim.z+load.back().z){ in.ignore(1000000,'\n'); n++; } //Load the Chunk { boost::archive::text_iarchive ia(in); ia >> _chunk; chunks.push_back(_chunk); load.pop_back(); } } in.close(); } }

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

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

ब्लूप्रिंट क्लास और editBuffer

editBuffer एक सॉर्टेबल बफरऑब्जेक्ट कंटेनर है जिसमें दुनिया के अंतरिक्ष और टुकड़े के स्थान में संपादन के बारे में जानकारी है।

 //EditBuffer Object Struct struct bufferObject { glm::vec3 pos; glm::vec3 cpos; BlockType type; }; //Edit Buffer! std::vector<bufferObject> editBuffer;

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

इसलिए पहले मैं उन सभी परिवर्तनों को लिखता हूं, जिन्हें addEditBuffer विधि का उपयोग करके editBuffer के लिए किए जाने की आवश्यकता है (जो कि टुकड़ा स्थान में परिवर्तनों की स्थिति की गणना भी करता है)। उन्हें एक फ़ाइल में लिखने से पहले, मैं उन टुकड़ों के क्रम में परिवर्तन को सॉर्ट करता हूं, जो वे फ़ाइल में उनके स्थान के अनुसार हैं।

किसी फ़ाइल में परिवर्तन लेखन में एक फ़ाइल स्थानांतरण, प्रत्येक पंक्ति (यानी एक टुकड़ा) का लोड होता है, जिसके लिए editBuffer में परिवर्तन होते हैं, सभी परिवर्तन करते हैं और इसे एक अस्थायी फ़ाइल में तब तक लिखते हैं जब तक editBuffer खाली नहीं हो जाता। यह evaluateBlueprint() फ़ंक्शन में किया जाता है, जो काफी तेज है।

 bool World::evaluateBlueprint(Blueprint &_blueprint){ //Check if the editBuffer isn't empty! if(_blueprint.editBuffer.empty()){ return false; } //Sort the editBuffer std::sort(_blueprint.editBuffer.begin(), _blueprint.editBuffer.end(), std::greater<bufferObject>()); //Open the File boost::filesystem::path data_dir(boost::filesystem::current_path()); data_dir /= "save"; data_dir /= saveFile; //Load File and Write File std::ifstream in((data_dir/"world.region").string()); std::ofstream out((data_dir/"world.region.temp").string(), std::ofstream::app); //Chunk for Saving Data Chunk _chunk; int n_chunks = 0; //Loop over the Guy while(n_chunks < dim.x*dim.y*dim.z){ if(in.eof()){ return false; } //Archive Serializers boost::archive::text_oarchive oa(out); boost::archive::text_iarchive ia(in); //Load the Chunk ia >> _chunk; //Overwrite relevant portions while(!_blueprint.editBuffer.empty() && glm::all(glm::equal(_chunk.pos, _blueprint.editBuffer.back().cpos))){ //Change the Guy _chunk.setPosition(glm::mod(_blueprint.editBuffer.back().pos, glm::vec3(chunkSize)), _blueprint.editBuffer.back().type); _blueprint.editBuffer.pop_back(); } //Write the chunk back oa << _chunk; n_chunks++; } //Close the fstream and ifstream in.close(); out.close(); //Delete the first file, rename the temp file boost::filesystem::remove_all((data_dir/"world.region").string()); boost::filesystem::rename((data_dir/"world.region.temp").string(),(data_dir/"world.region").string()); //Success! return true; }

ब्लूप्रिंट क्लास में editBuffer, साथ ही कई तरीके हैं जो आपको विशिष्ट ऑब्जेक्ट्स (ट्री, कैक्टी, हट्स, आदि) के लिए editBuffers बनाने की अनुमति देते हैं। फिर ब्लूप्रिंट को उस स्थिति में परिवर्तित किया जा सकता है जहां आप ऑब्जेक्ट को रखना चाहते हैं, और फिर इसे दुनिया की मेमोरी में लिख दें।

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

मैं सक्रिय रूप से इसे विश्व पीढ़ी के चरण में एक फाइल में परिवर्तन के "अड़चन" का विस्तार करने के लिए उपयोग करता हूं।

 void World::generate(){ //Create an editBuffer that contains a flat surface! blueprint.flatSurface(dim.x*chunkSize, dim.z*chunkSize); //Write the current blueprint to the world file. evaluateBlueprint(blueprint); //Add a tree Blueprint _tree; evaluateBlueprint(_tree.translate(glm::vec3(x, y, z))); }

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

प्रतिपादन

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

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

रेंडरिंग के लिए बेस क्लास को व्यू कहा जाता है, इसमें अधिकांश महत्वपूर्ण चर होते हैं जो सिमुलेशन विज़ुअलाइज़ेशन को नियंत्रित करते हैं:

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

इसके अलावा, कई सहायक वर्ग हैं जो ओपनजीएल के प्रतिपादन और रैपिंग का प्रदर्शन करते हैं!

क्लास शेडर
- जीएलएसएल शेड्स लोड, संकलन, संकलन और उपयोग करता है
मॉडल वर्ग
- वीएओ (वर्टेक्स एरेस ऑब्जेक्ट) रेंडरिंग के लिए डेटा टुकड़े, मेष बनाने का कार्य और रेंडर विधि शामिल है।
क्लास का बिलबोर्ड
- FBO (FrameBuffer Object) को प्रस्तुत करता है - पोस्ट-प्रोसेसिंग और शैडोइंग इफ़ेक्ट बनाने के लिए उपयोगी।
स्प्राइट क्लास
- कैमरे के सापेक्ष एक चतुर्भुज उन्मुख खींचता है, एक बनावट फ़ाइल (बॉट्स और ऑब्जेक्ट्स के लिए) से लोड किया गया है। एनिमेशन भी संभाल सकते हैं!
इंटरफ़ेस वर्ग
- ImGUI के साथ काम करने के लिए
ऑडियो क्लास
- बहुत अल्पविकसित ध्वनि समर्थन (यदि आप इंजन संकलित करते हैं, तो "एम" दबाएं)

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

ऊपर की छवि कुछ मापदंडों को दिखाती है जिन्हें हेरफेर के दौरान बदला जा सकता है। मैंने फुल स्क्रीन मोड में स्विच करना भी लागू किया। छवि कैमरे की ओर निर्देशित एक बनावट चतुर्भुज के रूप में प्रदान किए गए बॉट स्प्राइट का एक उदाहरण दिखाती है। छवि में घरों और कैक्टि को ब्लूप्रिंट का उपयोग करके बनाया गया है।

फ्रैगमेंट मेश बनाना

प्रारंभ में, मैंने मेष बनाने के भोले संस्करण का उपयोग किया: मैंने बस एक घन बनाया और खाली स्थान नहीं छोड़े। हालाँकि, यह समाधान धीमा था, और नए टुकड़े लोड करते समय, मेषों का निर्माण फ़ाइल तक पहुंच से भी अधिक संकीर्ण "अड़चन" निकला।

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

 void Model::fromChunkGreedy(Chunk chunk){ //... (this is part of the model class - find on github!) }

सामान्य तौर पर, लालची जाल के संक्रमण ने 60% की औसत से खींची गई चौकों की संख्या कम कर दी। फिर, आगे की मामूली आशाओं (VBO अनुक्रमण) के बाद, संख्या को एक अन्य 1/3 (6 कोने से किनारे से 4 कोने तक) घटा दिया गया।

जब अधिकतम विंडो में 5x1x5 टुकड़े के दृश्य का प्रतिपादन नहीं किया जाता है, तो मुझे लगभग 140 FPS (VSYNC अक्षम के साथ) का औसत मिलता है।

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

शेड्स और वोक्सल हाइलाइटिंग

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

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

मुझे अभी भी वर्तमान प्रकाश मॉडल पसंद नहीं है, क्योंकि यह "अंधेरे" को बहुत अच्छी तरह से संभालता नहीं है। मुझे उम्मीद है कि यह भविष्य में तय होगा जब मैं दिन और रात बदलने के चक्र पर काम करूंगा।

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

"हाइलाइटेड" कद्दू।

खेल की कक्षाएं

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

 class eventHandler{ /* This class handles user input, creates an appropriate stack of activated events and handles them so that user inputs have continuous effect. */ public: //Queued Inputs std::deque<SDL_Event*> inputs; //General Key Inputs std::deque<SDL_Event*> scroll; //General Key Inputs std::deque<SDL_Event*> rotate; //Rotate Key Inputs SDL_Event* mouse; //Whatever the mouse is doing at a moment SDL_Event* windowevent; //Whatever the mouse is doing at a moment bool _window; bool move = false; bool click = false; bool fullscreen = false; //Take inputs and add them to stack void input(SDL_Event *e, bool &quit, bool &paused); //Handle the existing stack every tick void update(World &world, Player &player, Population &population, View &view, Audio &audio); //Handle Individual Types of Events void handlePlayerMove(World &world, Player &player, View &view, int a); void handleCameraMove(World &world, View &view); };

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

नवीनतम नोट

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

फिर मैंने टास्क-बॉट सिस्टम (इस परियोजना का वास्तविक दिल) को 3 डी दुनिया में चित्रित किया और इसकी क्षमताओं का काफी विस्तार किया, लेकिन बाद में उस पर अधिक (हालांकि, कोड पहले ही ऑनलाइन पोस्ट किया गया है)!

हम अपना खुद का voxel इंजन लिखते हैं