नमस्कार! मेरा नाम जीलेब मैरीन है, मैं सेंट पीटर्सबर्ग एचएसई में स्नातक "एप्लाइड गणित और कंप्यूटर विज्ञान" के अपने पहले वर्ष में हूं। दूसरे सेमेस्टर में, हमारे कार्यक्रम के सभी नए लोग C ++ में टीम प्रोजेक्ट बनाते हैं। मेरे साथियों और मैंने एक खेल इंजन लिखने का फैसला किया।

पढ़ें कि हमें बिल्ली के नीचे क्या मिलता है।

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

हर कोई जो हमारे कार्यान्वयन के बारे में जानने में रुचि रखता है - पढ़ने का आनंद लें!

ललित कलाएं

पहली विंडो, माउस और कीबोर्ड

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

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

तब मुख्य खेल चक्र दिखाई दिया:

Event ev;
bool running = true;
while (running):
	ev = pullEvent();
	for handler in handlers[ev.type]:
		handler.handleEvent(ev);

प्रत्येक घटना संचालकों संलग्न - handlersजैसे handlers[QUIT] = {QuitHandler()}। उनका कार्य संबंधित घटना को संभालना है। QuitHandlerउदाहरण में, यह उजागर करेगा running = false, जिससे खेल रुक जाएगा।

नमस्ते दुनिया

इंजन में ड्राइंग के लिए हम उपयोग करते हैं OpenGL। पहला Hello World, जैसा कि मुझे लगता है, कई परियोजनाओं में, एक काले रंग की पृष्ठभूमि पर एक सफेद वर्ग था:

glBegin(GL_QUADS);
glVertex2f(-1.0f, 1.0f);
glVertex2f(1.0f, 1.0f);
glVertex2f(1.0f, -1.0f);
glVertex2f(-1.0f, -1.0f);
glEnd();

फिर हम कैसे एक दो आयामी बहुभुज बनाने के लिए सीखा है और एक अलग वर्ग में आंकड़े बाहर किया GraphicalObject2dउस के साथ बारी बारी से कर सकते हैं glRotate, के साथ कदम glTranslateऔर साथ खिंचाव glScale। हम चार चैनलों का उपयोग करके रंग सेट करते हैं glColor4f(r, g, b, a)।

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

कैमरा

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

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

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

जैसा कि आप देख सकते हैं, तीन चरण हैं। तीन मैट्रिक्स से गुणा उनके अनुरूप है। हमने इन मैट्रीस को बुलाया Model, Viewऔर Projection।

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

Model = Translate * Scale * Rotate.

इसके अलावा, कैमरे की स्थिति को जानते हुए, हम इसके आधार में निर्देशांक निर्धारित करना चाहते हैं: मैट्रिक्स द्वारा पहले से प्राप्त निर्देशांक को गुणा करें View। C ++ में, फ़ंक्शन का उपयोग करके आसानी से गणना की जाती है:


glm::mat4 View = glm::lookAt(cameraPosition, objectPosition, up);

शाब्दिक: objectPositionएक स्थिति से देखो cameraPosition, और ऊपर की दिशा "ऊपर" है। यह दिशा क्यों आवश्यक है? एक चायदानी फोटो खिंचवाने की कल्पना करो। आप उस पर कैमरे को इंगित करते हैं और केतली को फ्रेम में रखते हैं। इस बिंदु पर, आप बिल्कुल कह सकते हैं कि फ्रेम शीर्ष पर कहां है (सबसे अधिक संभावना है जहां केतली में ढक्कन है)। कार्यक्रम हमारे लिए यह तय नहीं कर सकता है कि फ्रेम को कैसे व्यवस्थित किया जाए, और इसीलिए "अप" वेक्टर को निर्दिष्ट किया जाना चाहिए।

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

स्क्रीन पर वर्टेक्स के निर्देशांक प्राप्त करने के लिए, आपको कम से कम पांच बार मैट्रिक्स द्वारा वेक्टर को गुणा करना होगा। सभी मैट्रिसेस का साइज़ 4 बाई 4 है, इसलिए आपको काफी गुणा ऑपरेशन करना होगा। हम प्रोसेसर कोर को बहुत सारे सरल कार्यों के साथ लोड नहीं करना चाहते हैं। इसके लिए, आवश्यक संसाधनों वाले एक वीडियो कार्ड बेहतर है। तो, आपको एक shader लिखने की आवश्यकता है: एक वीडियो कार्ड के लिए एक छोटा निर्देश। OpenGL में C के समान एक विशेष GLSL शेडर भाषा है, जो हमें ऐसा करने में मदद करेगी। आइए एक shader लिखने के विवरण में न जाएं, आखिरकार यह हुआ कि क्या हुआ, यह देखना बेहतर होगा:

स्पष्टीकरण: दस वर्ग हैं जो एक दूसरे के पीछे थोड़ी दूरी पर हैं। उनके दाईं ओर एक खिलाड़ी है जो घूमता है और कैमरा ले जाता है।

भौतिक विज्ञान

भौतिकी के बिना खेल क्या है? भौतिक इंटरैक्शन को संभालने के लिए, हमने Box2d लाइब्रेरी का उपयोग करने का निर्णय लिया और एक वर्ग बनाया, WorldObject2dजो विरासत में मिला GraphicalObject2d। दुर्भाग्य से, Box2d ने बॉक्स से बाहर काम नहीं किया, इसलिए बहादुर इल्या ने b2Body के लिए एक आवरण और सभी भौतिक कनेक्शन लिखे जो इस पुस्तकालय में हैं।

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

मामलों के बीच प्रकाश व्यवस्था दिखाई दी। इसे बनाने के लिए, प्रत्येक पिक्सेल को खींचने के लिए उपयुक्त निर्देश लिखना आवश्यक था - एक टुकड़ा shader।

बनावट

हमने छवियों को अपलोड करने के लिए डेविल लाइब्रेरी का उपयोग किया। प्रत्येक GraphicalObject2dवर्ग का एक उदाहरण बन गया GraphicalPolygon- वस्तु का अगला भाग - और GraphicalEdge- दूसरा भाग। प्रत्येक पर आप अपनी बनावट को बढ़ा सकते हैं। पहला परिणाम:

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

राज्य मशीन, वस्तु व्यवहार को परिभाषित करना

प्रत्येक वस्तु, जो कुछ भी हो - एक राज्य मशीन में एक राज्य, ग्राफिक या भौतिक - "टिक" होना चाहिए, अर्थात, गेम लूप के प्रत्येक पुनरावृत्ति को अद्यतन किया जाता है।

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

void loop():
    onAwake();
    awake = true;
    while (awake):
        onStart();
        running = true
        while (running):
            onActive();
        onStop();
    onDestroy();

अभी के लिए running == true, कोई ऐसा फ़ंक्शन कह सकता है pause()जो करता है running = false। यदि कोई कॉल करता है kill(), तो awake, और पूरी तरह से बंद करने के लिए गतिविधि और runningचालू करें false।

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

समाधान: सभी के Behaviorपास एक सरणी subBehaviorsहोगी जिसे वह अपडेट करेगा, वह है:

void onStart():
	onStart() 		//     
	for sb in subBehaviors:
		sb.onStart()	//       Behavior
void onActive():
	onActive()
	for sb in subBehaviors:
		sb.onActive()

और इतने पर, प्रत्येक फ़ंक्शन के लिए।

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

bool isTransitionActivated(): 		//  idle_walk->attack
	return canSee(enemy);

वांछित पैटर्न एक राज्य मशीन है। हमने उसे उत्तराधिकारी भी बनाया Behavior, क्योंकि प्रत्येक टिक पर यह जांचना आवश्यक है कि क्या राज्य को बदलने का समय आ गया है। यह न केवल खेल में वस्तुओं के लिए उपयोगी है। उदाहरण के लिए, Levelयह एक स्थिति है Level Switcher, और नियंत्रक मशीन के अंदर संक्रमण खेल में स्तरों को बदलने के लिए स्थितियां हैं।

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

संरक्षण

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

एक सेव बनाने के लिए, यह dump()प्रत्येक ऑब्जेक्ट के लिए बस ओवरराइड करने के लिए रहता है । लोडिंग एक स्ट्रिंग है जिसमें ऑब्जेक्ट के बारे में सभी जानकारी होती है। डाउनलोड तब पूरा होता है जब प्रत्येक ऑब्जेक्ट के लिए ऐसा कंस्ट्रक्टर बनाया जाता है।

वास्तव में, खेल और संपादक लगभग एक ही वर्ग हैं, केवल खेल में स्तर रीड मोड में, और रिकॉर्ड मोड में संपादक में लोड किया जाता है। इंजन रैपसनजोन लाइब्रेरी का उपयोग करता है और वस्तुओं को जौन से लिखता है।

जीयूआई

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

मूल संस्करण में, उसे विरासत में मिली Game2dऔर ओवरराइड करना होगा onActive, और कक्षा के क्षेत्रों में वस्तुओं का निर्माण करना होगा। लेकिन निर्माण के दौरान, वह यह नहीं देख सकता कि वह क्या बना रहा है, और उसे अपने कार्यक्रम और हमारे पुस्तकालय से लिंक करने के लिए भी संकलन करना होगा। डरावनी! प्लसस होंगे - कोई भी ऐसे जटिल व्यवहार पूछ सकता है जिसकी कोई कल्पना कर सकता है: उदाहरण के लिए, खिलाड़ी के जीवन में भूमि के ब्लॉक को स्थानांतरित करें, और ऐसा करें ताकि यूरेनस नक्षत्र वृषभ में हो और यूरो से अधिक न हो 40 रूबल। हालांकि, हमने अभी भी एक ग्राफिकल इंटरफ़ेस बनाने का फैसला किया है।

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

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

यहां बताया गया है कि आलेख के जारी होने के समय GUI कैसा दिखता है:

स्तर संपादक

स्टेट मशीन एडिटर

निष्कर्ष

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

अभी भी बहुत काम है, लेकिन हम इस समय जो हमारे पास हैं उससे खुश हैं।

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

जिहब परियोजना का लिंक: github.com/Glebanister/ample

अपने पहले वर्ष में एक गेम इंजन लिखना: आसान! (लगभग)