पोर्टिंग क्वेक 3

Embox ऑपरेटिंग सिस्टम (जिसमें से मैं डेवलपर हूं) में, OpenGL के लिए समर्थन कुछ समय पहले दिखाई दिया था, लेकिन कोई समझदार प्रदर्शन की जांच नहीं थी, केवल कई ग्राफिक आदिमता वाले दृश्यों को प्रस्तुत करना था।

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

इस लेख में, मैं Embox पर Quake3 के निर्माण और चलाने के तरीके के बारे में बात करूंगा।

अधिक सटीक रूप से, हम स्वयं Quake3 नहीं चलाएंगे, लेकिन ioquake3 इस पर आधारित है, जिसमें ओपन सोर्स कोड भी है। सादगी के लिए, हम ioquake3 को सिर्फ भूकंप कहेंगे :)

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

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

पर निर्भर करता है

विचित्र रूप से पर्याप्त है, क्वेक 3 के निर्माण के लिए कई पुस्तकालयों की आवश्यकता नहीं है। हमें आवश्यकता होगी:

• POSIX + LibC - malloc() / memcpy() / printf() और इतने पर
• libcurl - नेटवर्किंग
• मेसा 3 डी - ओपनजीएल सपोर्ट
• एसडीएल - इनपुट और ऑडियो डिवाइस का समर्थन

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

libcurl

यह सबसे सरल था। Libc libcurl के निर्माण के लिए पर्याप्त है (बेशक, कुछ सुविधाएँ उपलब्ध नहीं होंगी, लेकिन उनकी आवश्यकता नहीं होगी)। इस लाइब्रेरी को कॉन्फ़िगर करना और निर्माण करना सांख्यिकीय रूप से बहुत सरल है।

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

उपयोग की गई निर्माण प्रणाली के आधार पर, विशिष्ट चरण अलग-अलग होंगे, लेकिन अर्थ कुछ इस प्रकार है:

 wget https://curl.haxx.se/download/curl-7.61.1.tar.gz tar -xf curl-7.61.1.tar.gz cd curl-7.61.1 ./configure --enable-static --host=i386-unknown-none -disable-shared make ls ./lib/.libs/libcurl.a #       

मेसा / OpenGL

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

एसडीएल

एसडीएल इनपुट डिवाइस, ऑडियो और ग्राफिक्स के साथ काम करने के लिए एक क्रॉस-प्लेटफॉर्म फ्रेमवर्क है।

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

ग्राफिक्स के साथ काम करने के लिए बैकएंड SDL2-2.0.8/src/video/SDL_video.c में सेट किए गए हैं।

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

 /* Available video drivers */ static VideoBootStrap *bootstrap[] = { #if SDL_VIDEO_DRIVER_COCOA &COCOA_bootstrap, #endif #if SDL_VIDEO_DRIVER_X11 &X11_bootstrap, #endif ... } 

नए प्लेटफ़ॉर्म के लिए "सामान्य" समर्थन से परेशान न होने के लिए, बस अपना VideoBootStrap जोड़ें

सादगी के लिए, आप आधार के रूप में कुछ ले सकते हैं, उदाहरण के लिए src/video/qnx/video.c या src/video/raspberry/SDL_rpivideo.c , लेकिन पहले हम कार्यान्वयन को लगभग खाली कर देंगे:

 /* SDL_sysvideo.h */ typedef struct VideoBootStrap { const char *name; const char *desc;``` int (*available) (void); SDL_VideoDevice *(*create) (int devindex); } VideoBootStrap; /* embox_video.c */ static SDL_VideoDevice *createDevice(int devindex) { SDL_VideoDevice *device; device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice)); if (device == NULL) { return NULL; } return device; } static int available() { return 1; } VideoBootStrap EMBOX_bootstrap = { "embox", "EMBOX Screen", available, createDevice }; 

अपने VideoBootStrap को सरणी में जोड़ें:

 /* Available video drivers */ static VideoBootStrap *bootstrap[] = { &EMBOX_bootstrap, #if SDL_VIDEO_DRIVER_COCOA &COCOA_bootstrap, #endif #if SDL_VIDEO_DRIVER_X11 &X11_bootstrap, #endif ... } 

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

 ./configure --host=i386-unknown-none \ --enable-static \ --enable-audio=no \ --enable-video-directfb=no \ --enable-directfb-shared=no \ --enable-video-vulkan=no \ --enable-video-dummy=no \ --with-x=no make ls build/.libs/libSDL2.a #      

हम खुद ही क्वेक कलेक्ट करते हैं

Quake3 में गतिशील पुस्तकालयों का उपयोग शामिल है, लेकिन हम इसे बाकी सब चीजों की तरह, सांख्यिकीय रूप से जोड़ेंगे।

ऐसा करने के लिए, Makefile में कुछ चर सेट करें

 CROSS_COMPILING=1 USE_OPENAL=0 USE_OPENAL_DLOPEN=0 USE_RENDERER_DLOPEN=0 SHLIBLDFLAGS=-static 

पहला लॉन्च

सादगी के लिए, हम qemu / x86 पर चलेंगे। ऐसा करने के लिए, आपको इसे स्थापित करने की आवश्यकता है (यहां और नीचे डेबियन के लिए कमांड होंगे, अन्य वितरण पैकेजों के लिए अलग-अलग कहा जा सकता है)।

 sudo apt install qemu-system-i386 

और खुद लॉन्च:

 qemu-system-i386 -kernel build/base/bin/embox -m 1024 -vga std -serial stdio 

हालांकि, क्वेक शुरू करते समय, हमें तुरंत एक त्रुटि मिलती है

 > quake3 EXCEPTION [0x6]: error = 00000000 EAX=00000001 EBX=00d56370 ECX=80200001 EDX=0781abfd GS=00000010 FS=00000010 ES=00000010 DS=00000010 EDI=007b5740 ESI=007b5740 EBP=338968ec EIP=0081d370 CS=00000008 EFLAGS=00210202 ESP=37895d6d SS=53535353 

त्रुटि खेल द्वारा प्रदर्शित नहीं की जाती है, लेकिन ऑपरेटिंग सिस्टम द्वारा। डेबैग ने दिखाया कि यह त्रुटि QEMU में x86 के लिए अपूर्ण SIMD समर्थन के कारण थी: निर्देशों का हिस्सा समर्थित नहीं है और एक अज्ञात कमांड अपवाद (अमान्य Opcode) को फेंकता है। अपडेट : टिप्पणियों में WGH द्वारा सुझाए गए अनुसार , वास्तविक समस्या यह थी कि मैं cr0 / cr4 में SSE समर्थन को स्पष्ट रूप से सक्षम करना भूल गया, इसलिए QEMU के साथ सब कुछ ठीक है।

यह केवल क्वेक में नहीं होता है, लेकिन ओपन लिलिंब में (यह वह पुस्तकालय है जिसका उपयोग हम गणितीय कार्यों - sin() , expf() और इसी तरह) को लागू करने के लिए करते हैं। OpenLibm पैच करें ताकि __test_sse() SSE पर वास्तविक जाँच न करे, लेकिन बस यह मानता है कि कोई समर्थन नहीं है।

उपरोक्त चरण चलाने के लिए पर्याप्त हैं, निम्न आउटपुट कंसोल में दिखाई देता है:

 > quake3 ioq3 1.36 linux-x86_64 Nov 1 2018 SSE instruction set not available ----- FS_Startup ----- We are looking in the current search path: //.q3a/baseq3 ./baseq3 ---------------------- 0 files in pk3 files "pak0.pk3" is missing. Please copy it from your legitimate Q3 CDROM. Point Release files are missing. Please re-install the 1.32 point release. Also check that your ioq3 executable is in the correct place and that every file in the "baseq3 " directory is present and readable ERROR: couldn't open crashlog.txt 

पहले से ही बुरा नहीं है, क्वेक 3 शुरू करने की कोशिश करता है और यहां तक ​​कि एक त्रुटि संदेश भी दिखाता है! जैसा कि आप देख सकते हैं, उसके पास baseq3 डायरेक्टरी में फाइलों का अभाव है। इसमें ध्वनियाँ, बनावट और वह सब शामिल है। ध्यान दें, pak0.pk3 को एक लाइसेंस प्राप्त सीडी-रॉम से लिया जाना चाहिए (हां, खुला स्रोत का मुफ्त उपयोग नहीं होता है)।

डिस्क की तैयारी

 sudo apt install qemu-utils #  qcow2- qemu-img create -f qcow2 quake.img 1G #   nbd sudo modprobe nbd max_part=63 #  qcow2-      sudo qemu-nbd -c /dev/nbd0 quake.img sudo mkfs.ext4 /dev/nbd0 sudo mount /dev/nbd0 /mnt cp -r path/to/q3/baseq3 /mnt sync sudo umount /mnt sudo qemu-nbd -d /dev/nbd0 

अब आप ब्लॉक डिवाइस को क्यूमू में स्थानांतरित कर सकते हैं

 qemu-system-i386 -kernel build/base/bin/embox -m 1024 -vga std -serial stdio -hda quake.img 

जब सिस्टम शुरू होता है, तो डिस्क को /mnt पर माउंट करें और इस निर्देशिका में quake3 चलाएं, इस बार बाद में क्रैश हो जाता है

 > mount -t ext4 /dev/hda1 /mnt > cd /mnt > quake3 ioq3 1.36 linux-x86_64 Nov 1 2018 SSE instruction set not available ----- FS_Startup ----- We are looking in the current search path: //.q3a/baseq3 ./baseq3 ./baseq3/pak8.pk3 (9 files) ./baseq3/pak7.pk3 (4 files) ./baseq3/pak6.pk3 (64 files) ./baseq3/pak5.pk3 (7 files) ./baseq3/pak4.pk3 (272 files) ./baseq3/pak3.pk3 (4 files) ./baseq3/pak2.pk3 (148 files) ./baseq3/pak1.pk3 (26 files) ./baseq3/pak0.pk3 (3539 files) ---------------------- 4073 files in pk3 files execing default.cfg couldn't exec q3config.cfg couldn't exec autoexec.cfg Hunk_Clear: reset the hunk ok Com_RandomBytes: using weak randomization ----- Client Initialization ----- Couldn't read q3history. ----- Initializing Renderer ---- ------------------------------- QKEY building random string Com_RandomBytes: using weak randomization QKEY generated ----- Client Initialization Complete ----- ----- R_Init ----- tty]EXCEPTION [0xe]: error = 00000000 EAX=00000000 EBX=00d2a2d4 ECX=00000000 EDX=111011e0 GS=00000010 FS=00000010 ES=00000010 DS=00000010 EDI=0366d158 ESI=111011e0 EBP=37869918 EIP=00000000 CS=00000008 EFLAGS=00010212 ESP=006ef6ca SS=111011e0 EXCEPTION [0xe]: error = 00000000 

यह त्रुटि फिर से Qemu में SIMD के साथ है। अपडेट : टिप्पणियों में WGH द्वारा सुझाए गए अनुसार , वास्तविक समस्या यह थी कि मैं cr0 / cr4 में SSE समर्थन को स्पष्ट रूप से सक्षम करना भूल गया, इसलिए QEMU के साथ सब कुछ ठीक है। इस समय, निर्देशों का उपयोग Quake3 x86 वर्चुअल मशीन में किया जाता है। X86 के लिए कार्यान्वयन को एक व्याख्या किए गए VM (Quake3 वर्चुअल मशीन के बारे में अधिक के साथ और, सैद्धांतिक रूप से, वास्तुशिल्प सुविधाओं में, आप एक ही लेख में सब कुछ पढ़ सकते हैं) के साथ समस्या को हल किया गया था। उसके बाद, एसडीएल के लिए हमारे कार्यों को बुलाया जाना शुरू होता है, लेकिन निश्चित रूप से, कुछ भी नहीं होता है, क्योंकि ये कार्य अभी तक कुछ नहीं करते हैं।

ग्राफिक्स समर्थन जोड़ें

 static SDL_VideoDevice *createDevice(int devindex) { ... device->GL_GetProcAddress = glGetProcAddress; device->GL_CreateContext = glCreateContext; ... } /*   OpenGL- */ SDL_GLContext glCreateContext(_THIS, SDL_Window *window) { OSMesaContext ctx; /*   -  --    .. */ sdl_init_buffers(); /*    Mesa */ ctx = OSMesaCreateContextExt(OSMESA_BGRA, 16, 0, 0, NULL); OSMesaMakeCurrent(ctx, fb_base, GL_UNSIGNED_BYTE, fb_width, fb_height); return ctx; } 

एसडीएल को यह बताने के लिए दूसरे हैंडलर की जरूरत है जो ओपनजीएल के साथ काम करते समय कॉल करता है।

ऐसा करने के लिए, हम एक सरणी शुरू करते हैं और शुरू से शुरू करते हैं हम जांचते हैं कि कौन सी कॉल गायब हैं, कुछ इस तरह से:

 static struct { char *proc; void *fn; } embox_sdl_tbl[] = { { "glClear", glClear }, { "glClearColor", glClearColor }, { "glColor4f", glColor4f }, { "glColor4ubv", glColor4ubv }, { 0 }, }; void *glGetProcAddress(_THIS, const char *proc) { for (int i = 0; embox_sdl_tbl[i].proc != 0; i++) { if (!strcmp(embox_sdl_tbl[i].proc, proc)) { return embox_sdl_tbl[i].fn; } } printf("embox/sdl: Failed to find %s\n", proc); return 0; } 

कुछ पुनरारंभ में, स्प्लैश स्क्रीन और मेनू को खींचने के लिए सूची पर्याप्त हो जाती है। सौभाग्य से, मेसा के पास सभी आवश्यक कार्य हैं। केवल एक चीज यह है कि किसी कारण से कोई glGetString() फ़ंक्शन नहीं है, _mesa_GetString() glGetString() का उपयोग किया जाना था।

अब जब एप्लिकेशन शुरू होता है, तो एक स्प्लैश स्क्रीन दिखाई देती है, चीयर्स!

इनपुट डिवाइस जोड़ें

एसडीएल में कीबोर्ड और माउस समर्थन जोड़ें।

घटनाओं के साथ काम करने के लिए, आपको एक हैंडलर जोड़ना होगा

 static SDL_VideoDevice *createDevice(int devindex) { ... device->PumpEvents = pumpEvents; ... } 

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

 static struct input_event last_event; static int sdl_indev_eventhnd(struct input_dev *indev) { /*    ,   last_event */ while (0 == input_dev_event(indev, &last_event)) { } } 

फिर, pumpEvents() ईवेंट को संसाधित करते हैं और इसे एसडीएल को पास करते हैं:

 static void pumpEvents(_THIS) { SDL_Scancode scancode; bool pressed; scancode = scancode_from_event(&last_event); pressed = is_press(last_event); if (pressed) { SDL_SendKeyboardKey(SDL_PRESSED, scancode); } else { SDL_SendKeyboardKey(SDL_RELEASED, scancode); } } 

 static int key_to_sdl[] = { [' '] = SDL_SCANCODE_SPACE, ['\r'] = SDL_SCANCODE_RETURN, [27] = SDL_SCANCODE_ESCAPE, ['0'] = SDL_SCANCODE_0, ['1'] = SDL_SCANCODE_1, ... ['8'] = SDL_SCANCODE_8, ['9'] = SDL_SCANCODE_9, ['a'] = SDL_SCANCODE_A, ['b'] = SDL_SCANCODE_B, ['c'] = SDL_SCANCODE_C, ... ['x'] = SDL_SCANCODE_X, ['y'] = SDL_SCANCODE_Y, ['z'] = SDL_SCANCODE_Z, }; 

यह सब कीबोर्ड के साथ है, बाकी को एसडीएल और क्वेक खुद संभालेंगे। वैसे, यह इधर-उधर हो गया कि कहीं कीस्ट्रोक्स के प्रसंस्करण में, भूकंप के निर्देश QEMU द्वारा समर्थित नहीं हैं, तो आपको x86 वर्चुअल मशीन से व्याख्या की गई वर्चुअल मशीन पर स्विच करना होगा, इसके लिए हम BASE_CFLAGS += -DNO_VM_COMPILED को Makefile में BASE_CFLAGS += -DNO_VM_COMPILED ।

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

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

 static void pumpEvents(_THIS) { if (from_keyboard(&last_event)) { /*      */ ... } else { /*      */ if (is_left_click(&last_event)) { /*     */ SDL_SendMouseButton(0, 0, SDL_PRESSED, SDL_BUTTON_LEFT); } else if (is_left_release(&last_event)) { /*     */ SDL_SendMouseButton(0, 0, SDL_RELEASED, SDL_BUTTON_LEFT); } else { /*   */ SDL_SendMouseMotion(0, 0, 1, mouse_diff_x(), /*      */ mouse_diff_y()); /*      */ } } } 

उसके बाद, कैमरे को नियंत्रित करना और शूट करना, चीयर्स करना संभव हो जाता है! वास्तव में, यह पहले से ही खेलने के लिए पर्याप्त है :)

अनुकूलन

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

आइए थोड़ा खून से खेल को गति देने की कोशिश करें।

संकलक अनुकूलन और कम संकल्प

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

इसके अलावा, हम प्रोसेसर के काम को सुविधाजनक बनाने के लिए न्यूनतम रिज़ॉल्यूशन - 320x240 का उपयोग करते हैं।

केवीएम

KVM (कर्नेल-आधारित वर्चुअल मशीन) आपको प्रदर्शन को बेहतर बनाने के लिए हार्डवेयर वर्चुअलाइजेशन (Intel VT और AMD-V) का उपयोग करने की अनुमति देता है। Qemu इस तंत्र का समर्थन करता है, इसका उपयोग करने के लिए आपको निम्न कार्य करने की आवश्यकता है।

सबसे पहले, आपको BIOS में वर्चुअलाइजेशन समर्थन को सक्षम करने की आवश्यकता है। मेरे पास एक गीगाबाइट B450M DS3H मदरबोर्ड है, और AMD-V को MIT -> उन्नत फ्रीक्वेंसी सेटिंग्स -> उन्नत CPU कोर सेटिंग्स -> SVM मोड -> सक्षम (गीगाबाइट, आपके साथ क्या गलत है?) के माध्यम से चालू किया गया है।

फिर हम आवश्यक पैकेज डालते हैं और उपयुक्त मॉड्यूल जोड़ते हैं

 sudo apt install qemu-kvm sudo modprobe kvm-amd #  kvm-intel 

यही है, अब आप qemu -enable-kvm फ्लैग को पास कर सकते हैं (या -no-kvm ताकि हार्डवेयर त्वरण का उपयोग न करें)।

परिणाम

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

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