🏺 🙏🏽 🚣🏼 एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 2 - एसडीएल निर्देशांक और ब्लिटिंग 🤷🏼 🗒️ 💗

पहले सबक के आधार पर, हम एसडीएल सतहों की दुनिया में तल्लीन करेंगे। जैसा कि मैंने कहा, एसडीएल सतहों मूल रूप से स्मृति में संग्रहीत चित्र हैं। कल्पना कीजिए कि हमारे पास आकार में 320x240 पिक्सेल की एक खाली खिड़की है। एसडीएल समन्वय प्रणाली में, विंडो को निम्नानुसार दर्शाया गया है:

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

चूंकि हमारे पास पहले से ही एक तैयार और अनुकूलित सतह ( Surf_Display ) है, इसलिए हमें बस छवियों को प्रस्तुत करने का एक तरीका खोजना होगा। इस विधि को ब्लिटिंग कहा जाता है (अंग्रेजी ब्लिटिंग से - बिट्स के एक समूह को एक स्थान से दूसरे स्थान पर ले जाना, हमारे मामले में इसका मतलब है एक छवि को स्थानांतरित करना (या इसका एक हिस्सा) दूसरे के ऊपर), अर्थात्। ओवरले की तरह। लेकिन इससे पहले कि हम ऐसा कर सकें, हमें इन छवियों को मेमोरी में लोड करने का एक तरीका भी खोजना होगा। SDL अपनी योजना को कार्यान्वित करने के लिए एक सरल कार्य प्रदान करता है - SDL_LoadBMP (नोट: SDL_LoadBMP केवल * .BMP प्रारूप में ही चित्र डाउनलोड करने की क्षमता प्रदान करता है, जैसा कि इसके नाम का अर्थ है। अन्य स्वरूपों की छवियों को लोड करने के लिए, आपको SDL_image लाइब्रेरी को प्रोजेक्ट से कनेक्ट करने की आवश्यकता है, जैसा कि किसी ने टिप्पणियों में सही रूप से नोट किया है)। पहले पाठ में alrusdi , और फ़ंक्शन IMG_Load का उपयोग करें)। एक नमूना कोड इस तरह दिख सकता है:

उदाहरण

SDL_Surface* Surf_Temp; if((Surf_Temp = SDL_LoadBMP("mypicture.bmp")) == NULL) { //! }

यहां सब कुछ काफी सरल है, SDL_LoadBMP पैरामीटर के रूप में केवल एक तर्क लेता है - उस फ़ाइल का पथ जिसे आप लोड करना चाहते हैं, और यह सतह को निर्दिष्ट छवि देता है। यदि फ़ंक्शन NULL देता है , तो या तो फ़ाइल नहीं मिली है, या यह क्षतिग्रस्त है, या अन्य, अधिक जटिल त्रुटियां हुई हैं। दुर्भाग्य से, दक्षता की गिरावट के लिए, यह विधि सभी प्रकार की लोडिंग त्रुटियों की पूर्ण कवरेज प्रदान नहीं करती है। बहुत बार, डाउनलोड की गई छवि सतह के पिक्सेल-बाय-पिक्सेल प्रारूप से मेल नहीं खाती है जिसमें हम इसे लोड करते हैं। इस प्रकार, प्रदर्शन के दौरान, प्रदर्शन, छवि रंग आदि खो सकते हैं। (यह महत्वपूर्ण है कि तैयार की गई सतह और भरी हुई छवि सभी मामलों में एक दूसरे को फिट करती है, अर्थात (अतिशयोक्तिपूर्ण) बॉक्स का आकार लोड के आयामों को फिट करेगा)। सौभाग्य से, SDL के पास इस समस्या के लिए एक त्वरित और दर्द रहित वर्कअराउंड है - SDL_DisplayFormat । यह फ़ंक्शन पहले से लोड की गई छवि को सेट करता है, और प्रदर्शित प्रारूप के लिए उपयुक्त एक नई सतह देता है।
अब आपको पिछले पाठ में बनाई गई परियोजना को खोलने और दो फ़ाइलों को जोड़ने की आवश्यकता है: CSurface.h और CSurface.cpp । CSurface.h खोलें और निम्नलिखित जोड़ें:

CSurface.h

 #ifndef _CSURFACE_H_ #define _CSURFACE_H_ #include <SDL/SDL.h> class CSurface { public: CSurface(); public: static SDL_Surface* OnLoad(char* File); }; #endif

इस प्रकार, हमने एक सरल ओनलॉड फ़ंक्शन बनाया जो हमारे लिए सतह को लोड करेगा। अब CSurface.cpp खोलें और जोड़ें:

CSurface.cpp

 #include "CSurface.h" CSurface::CSurface() { } SDL_Surface* CSurface::OnLoad(char* File) { SDL_Surface* Surf_Temp = NULL; SDL_Surface* Surf_Return = NULL; if((Surf_Temp = SDL_LoadBMP(File)) == NULL) { return NULL; } Surf_Return = SDL_DisplayFormat(Surf_Temp); SDL_FreeSurface(Surf_Temp); return Surf_Return; }

तो, कुछ बातों पर ध्यान देना चाहिए:
1. हमेशा किसी भी तरह से उपयोग करने से पहले अपने पॉइंटर्स को रीसेट करें (NULL या "0" कोई फर्क नहीं पड़ता)। यह विभिन्न समस्याओं और त्रुटियों के ढेर से बचने में मदद करेगा;
2. याद रखें कि SDL_DisplayFormat पुरानी के आधार पर एक नई सतह देता है, इसलिए उस पुरानी सतह के कब्जे वाले संसाधनों को मुक्त करना न भूलें। अन्यथा, हम स्मृति में सतह "भटक" का निरीक्षण करेंगे क्योंकि यह प्रसन्न होता है।
अब हमारे पास सतहों को मेमोरी में लोड करने का एक तरीका है, लेकिन हमें उन्हें अन्य सतहों पर मैप करने का एक तरीका भी चाहिए। छवियों को लोड करने के साथ-साथ SDL के पास इसके लिए एक फ़ंक्शन है: SDL_BlitSurface । यह SDL_LoadBMP के रूप में उपयोग करना उतना आसान नहीं हो सकता है, लेकिन डरें नहीं। CSurface.h खोलें और निम्न फ़ंक्शन प्रोटोटाइप जोड़ें:

CSurface.h

 #ifndef _CSURFACE_H_ #define _CSURFACE_H_ #include <SDL/SDL.h> class CSurface { public: CSurface(); public: static SDL_Surface* OnLoad(char* File); static bool OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y); }; #endif

CSurface.cpp को फिर से खोलें और निम्नलिखित जोड़ें:

CSurface.cpp

 #include "CSurface.h" CSurface::CSurface() { } SDL_Surface* CSurface::OnLoad(char* File) { SDL_Surface* Surf_Temp = NULL; SDL_Surface* Surf_Return = NULL; if((Surf_Temp = SDL_LoadBMP(File)) == NULL) { return NULL; } Surf_Return = SDL_DisplayFormat(Surf_Temp); SDL_FreeSurface(Surf_Temp); return Surf_Return; } bool CSurface::OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y) { if(Surf_Dest == NULL || Surf_Src == NULL) { return false; } SDL_Rect DestR; DestR.x = X; DestR.y = Y; SDL_BlitSurface(Surf_Src, NULL, Surf_Dest, &DestR); return true; }

सबसे पहले, आइए OnDraw फ़ंक्शन को पारित किए गए तर्कों पर एक नज़र डालें। हम दो सतहों को देखते हैं, और दो प्रकार के इंट इंट । पहली सतह को आधार के रूप में लिया जाता है (पहले पाठ में बोर्ड को याद रखें?), आई। जिस पर हम भविष्य में सब कुछ प्रदर्शित करेंगे। तदनुसार, दूसरी सतह वह है जिसे हम आधार पर लगाएंगे (और यहां हमारे स्टिकर हैं)। असल में, हम सिर्फ Surf_Src को Surf_Dest के ऊपर रखते हैं , यह पूरा रहस्य है। X और Y वे चर हैं जो Surf_Dest सतह पर उस स्थान के निर्देशांक को दर्शाते हैं जिनसे हम Surf_Src को मैप करेंगे ।
फ़ंक्शन की शुरुआत में, हमें यह सुनिश्चित करने की आवश्यकता है कि हमारे पास सतहों हैं, अन्यथा हम झूठे लौटते हैं। अगला, हम SDL_Rect प्रकार का एक वैरिएबल बनाते हैं । यह एक एसडीएल संरचना है जिसमें चार गुण होते हैं: एक्स , वाई , डब्ल्यू , एच। बेशक, आपने पहले ही अनुमान लगाया था कि यह सतह के प्रदर्शित क्षेत्र के मापदंडों को निर्धारित करता है। अब तक, हम केवल उस स्थान के निर्देशांक में रुचि रखते हैं जहां हम आयत प्रदर्शित करेंगे, और हमें इसके आकार की परवाह नहीं है। तो, आगे हम एक्स , वाई फ़ंक्शन को हस्तांतरित निर्देशांक प्रदर्शित क्षेत्र की संरचना को सौंपते हैं। यदि आप इस बारे में उत्सुक हैं कि NULL पैरामीटर हमारे SDL_BlitSurface में क्या है (हाँ, लेखक, हम रुचि रखते हैं!), यह SDL_Rect प्रकार का एक और पैरामीटर है। हम थोड़ी देर बाद इस पर वापस आएंगे।
बाद में आया! मुझे लगता है कि अगर हम कुछ समय पहले SDL_BlitSurface हस्ताक्षर पर हस्ताक्षर नहीं करते हैं तो कोई भी नाराज नहीं होगा। मैं संक्षेप में समझाता हूं: हमें हमेशा पूरी सतह को दूसरे के ऊपर प्रदर्शित करने की आवश्यकता नहीं होती है, ऐसे कई मामले हैं जब आपको छवि के कुछ हिस्से का चयन करने की आवश्यकता होती है (उदाहरण के लिए, हमारे पास एक टाइलसेट है (अंग्रेजी टाइल से - छवियों का एक सेट, बस एक छवि में इकट्ठे हुए बहुत सारे चित्र) और आप इसे एक बनावट या चरित्र, आदि के साथ एक निश्चित वर्ग से चुनने की जरूरत है)। तो यहाँ है

 int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);

क्रम में पैरामीटर के रूप में स्वीकार करता है, बाएं से दाएं:

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

मुझे लगता है कि अब सब कुछ कम या ज्यादा पारदर्शी और समझ में आ गया है।
फ़ंक्शन के अंत में, हम अनुकूलित सतहों को आकर्षित करते हैं और सच लौटाते हैं ।

अब, यह सुनिश्चित करने के लिए कि सब कुछ काम करता है, चलो एक परीक्षण सतह बनाते हैं। CApp.h खोलें, और एक नई सतह जोड़ें, और हमारे द्वारा बनाई गई CSurface.h शीर्ष लेख फ़ाइल शामिल करें:

CApp.h

 #ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL/SDL.h> #include "CSurface.h" class CApp { private: bool Running; SDL_Surface* Surf_Display; SDL_Surface* Surf_Test; public: CApp(); int OnExecute(); public: bool OnInit(); void OnEvent(SDL_Event* Event); void OnLoop(); void OnRender(); void OnCleanup(); }; #endif

इसके अलावा, कंस्ट्रक्टर में, हमारी सतहों को पहले शून्य करना न भूलें:

CApp.cpp

 CApp::CApp() { Surf_Test = NULL; Surf_Display = NULL; Running = true; }

और साफ करना याद रखें!

CApp_OnCleanup.cpp

 #include "CApp.h" void CApp::OnCleanup() { SDL_FreeSurface(Surf_Test); SDL_FreeSurface(Surf_Display); SDL_Quit(); }

कुछ डाउनलोड करने का समय आ गया है। CApp_OnInit.cpp खोलें और इसे इस तरह बनाएं :

CApp_OnInit.cpp

 #include "CApp.h" bool CApp::OnInit() { if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { return false; } if((Surf_Display = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) { return false; } if((Surf_Test = CSurface::OnLoad("myimage.bmp")) == NULL) { return false; } return true; }

सुनिश्चित करें कि आपके पास वास्तव में myimage.bmp फ़ाइल है। यदि नहीं, तो इसे स्वयं डाउनलोड करें या ड्रा करें और इसे अपने गेम की निष्पादन योग्य फ़ाइल के साथ निर्देशिका में रखें। CApp_OnRender.cpp खोलें और निम्नलिखित जोड़ें:

CApp_OnRender.cpp

 #include "CApp.h" void CApp::OnRender() { CSurface::OnDraw(Surf_Display, Surf_Test, 0, 0); SDL_Flip(Surf_Display); }

नया SDL_Flip फ़ंक्शन देखें। यह बफर को अपडेट करता है और स्क्रीन पर Surf_Display प्रदर्शित करता है। इसे डबल बफरिंग कहा जाता है। यह निर्मित सतहों को पहले मेमोरी में तैयार करता है, और फिर स्क्रीन पर तैयार एक को प्रदर्शित करता है। यदि हमने इसका उपयोग नहीं किया होता, तो हमें एक चंचल स्क्रीन दिखाई देती। SDL_DOUBLEBUF ध्वज याद रखें जो हमने सतह बनाते समय निर्दिष्ट किया था? यह ठीक यही है जो डबल बफरिंग मोड को सक्षम करता है।
अब आप परियोजना को संकलित कर सकते हैं, और सुनिश्चित कर सकते हैं कि सब कुछ सही ढंग से काम करता है। आपको विंडो के ऊपरी बाएं कोने में एक छवि देखनी चाहिए। यदि हां, तो बधाई हो, आप असली खेल के करीब एक कदम हैं। यदि नहीं, तो सुनिश्चित करें कि myimage.bmp निष्पादन योग्य फ़ाइल के समान फ़ोल्डर में है, और यह ग्राफिक्स दर्शक में सामान्य रूप से खुलता है। यहाँ मुझे क्या मिला है:

(और हां, मैंने कोड को थोड़ा संशोधित किया और अपने अवतार को * .PNG प्रारूप में IMG_Load का उपयोग करके अपलोड किया । मैं आपको इस फ़ंक्शन के साथ प्रयोग करने की सलाह देता हूं, और दूसरों के साथ भी। इसके लिए जाएं और आप सफल होंगे!)। यदि आपको संदेश deprecated conversion from string constant to 'char*' -wwrite-strings लिए मिलता है, तो deprecated conversion from string constant to 'char*' -wwrite-strings आपको deprecated conversion from string constant to 'char*' -wwrite-strings OnLoad (char * File) फ़ंक्शन के हस्ताक्षर को OnLoad (const char * File) में बदलने की आवश्यकता है और तदनुसार, CSurface.cpp में ।

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

tilesets

यानी केवल एक छवि होने के नाते, हमें इसका केवल एक हिस्सा निकालना होगा। CSurface.h खोलें, और निम्न कोड जोड़ें:

CSurface.h

 #ifndef _CSURFACE_H_ #define _CSURFACE_H_ #include <SDL/SDL.h> class CSurface { public: CSurface(); public: static SDL_Surface* OnLoad(char* File); static bool OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y); static bool OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y, int X2, int Y2, int W, int H); }; #endif

CSurface.cpp खोलें, और निम्न फ़ंक्शन जोड़ें (महत्वपूर्ण, हम दूसरा OnDraw फ़ंक्शन जोड़ते हैं, और मौजूदा एक को प्रतिस्थापित नहीं करते हैं! क्या आप फ़ंक्शन ओवरलोडिंग के बारे में जानते हैं?) :

CSurface.cpp

 bool CSurface::OnDraw(SDL_Surface* Surf_Dest, SDL_Surface* Surf_Src, int X, int Y, int X2, int Y2, int W, int H) { if(Surf_Dest == NULL || Surf_Src == NULL) { return false; } SDL_Rect DestR; DestR.x = X; DestR.y = Y; SDL_Rect SrcR; SrcR.x = X2; SrcR.y = Y2; SrcR.w = W; SrcR.h = H; SDL_BlitSurface(Surf_Src, &SrcR, Surf_Dest, &DestR); return true; }

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

CApp_OnRender.cpp

 #include "CApp.h" void CApp::OnRender() { CSurface::OnDraw(Surf_Display, Surf_Test, 0, 0); CSurface::OnDraw(Surf_Display, Surf_Test, 100, 100, 0, 0, 50, 50); SDL_Flip(Surf_Display); }

और यहाँ मेरे अवतार का एक टुकड़ा है जो स्क्रीन के ऊपर और बाएँ किनारे से 100 पिक्सेल का है:

स्रोत कोड लिंक:

सभी पाठों के लिंक:

एक खेल ढांचे का विकास। भाग 1 - एसडीएल की मूल बातें
एक खेल ढांचे का विकास। भाग 2 - निर्देशांक और मानचित्रण
एक खेल ढांचे का विकास। भाग 3 - घटनाएँ
एक खेल ढांचे का विकास। भाग 4 - टिक टीएसी को पैर की अंगुली
एक खेल ढांचे का विकास। भाग 5 - एनिमेशन
एक खेल ढांचे का विकास। भाग 6 - संस्थाएँ

एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 2 - एसडीएल निर्देशांक और ब्लिटिंग

More articles: