Qt के लिए OpenGL ES 2.0 आवरण

एक बार जब मैं एंड्रॉइड के लिए एक गेम लिख रहा था, तो मुझे OpenGL ES 1.1 से निपटने की आवश्यकता थी। ऐसा लगता है कि कुछ भी जटिल नहीं है, 2 डी ग्राफिक्स, आपको बस पीएनजी छवियों को खींचना होगा, जिसमें स्केल करने, घुमाने, पारदर्शिता जोड़ने की क्षमता होगी। तब मैंने इस पर लगभग एक सप्ताह बिताया, और शायद इससे भी अधिक, मुझे याद नहीं है। यह मुश्किल था क्योंकि मुझे ओपनजीएल से कोई लेना-देना नहीं था। Libgdx स्रोत कोड ने बहुत मदद की, जिसमें, वैसे, सभी निम्न-स्तरीय OpenGL फ़ंक्शन डेवलपर से छिपे हुए हैं।
टाइम्स बदल रहे हैं, OpenGL ES 1.1 को संस्करण 2.0 द्वारा प्रतिस्थापित किया जा रहा है, जो काफी अलग है। हमें यह पता लगाना होगा कि वे किस प्रकार के शेड हैं , और किसी भी तरह से उनके बिना क्यों। इसमें फिर कई दिन लगते हैं। ऐसा लगता है कि यह आसान होना चाहिए, क्योंकि 2 डी, सब कुछ सरल है। उदाहरण के लिए, यदि आप QML का उपयोग करते हैं, तो यह इस प्रकार किया जाता है:

Image { source: "brick.png" opacity: 0.8 rotation: 90 } 

और अगर आप C ++ में सब कुछ लिखते हैं, तो आपको कई, कोड की कई पंक्तियाँ मिलती हैं, जिन्हें समझना मुश्किल है, अगर आप OpenGL से परिचित नहीं हैं। मैंने कुछ लाइब्रेरी खोजने की कोशिश की, ओपनजीएल पर एक आवरण, जैसे कि libtdx, केवल Qt के लिए, लेकिन कोई फायदा नहीं हुआ। इसलिए, मैंने फैसला किया, मेरे लिए सब कुछ काम करने के बाद, मैं एक छोटा आवरण लिखूंगा जो सभी ओपनगैल कॉल को छुपाता है और आपको आसानी से 2 डी ग्राफिक्स के साथ काम करने की अनुमति देता है।

GitHub आवरण कोड
GitHub केस स्टडी

अपने आवेदन में आवरण का उपयोग करने के लिए, आपको .pro फ़ाइल में एक पंक्ति जोड़ने की आवश्यकता है:

 include (opengl-qt/opengl-qt.pri) 

OpenGLQt से इनहेरिट एप्लिकेशन विंडो :: विजेट:

 class Widget : public OpenGLQt::Widget { public: Widget(); protected: virtual void drawSprites(); }; 

फ़ाइल में पथ और डिजाइनर में उसमें छवियों की संख्या को पास करें। प्रारंभ टाइमर:

 Widget::Widget() : OpenGLQt::Widget(10, "spritesheet.png") , m_counter(0) { startTimer(); } 

ड्रॉस्प्राइट्स () विधि को ओवरराइड करें:

 void Widget::drawSprites() { static Sprite apple = {86, 118, 30, 30}; //  ,    static Color color = {1, 1, 1, 1}; //   static DrawSpriteArgs args; args.sprite = apple; args.color = color; args.x = 10; //      args.y = 15; //     args.angle = 3.14f / 2.0f; //   90    args.scaleX = 0.5f; //   50%    args.scaleY = -1.0f; //      drawSprite(args); } 

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


OpenGL का थोड़ा सा विवरण। वर्टेक्स शेडर:

 uniform mat4 mvp_matrix; attribute vec4 a_position; attribute vec2 a_texcoord; attribute vec4 a_color; varying vec4 v_color; varying vec2 v_texcoord; void main() { gl_Position = mvp_matrix * a_position; v_texcoord = a_texcoord; v_color = a_color; } 

टुकड़े टुकड़े करना:

 #ifdef GL_ES #define LOWP lowp precision mediump float; #else #define LOWP #endif varying vec2 v_texcoord; varying LOWP vec4 v_color; uniform sampler2D texture; void main() { gl_FragColor = v_color * texture2D(texture, v_texcoord); } 

कार्यक्रम के आरंभ के दौरान एक बार अधिकांश ओपनगेल कार्यों को बुलाया जाता है। उसके बाद, एक टाइमर शुरू होता है, जो प्रति सेकंड 60 बार स्क्रीन अपडेट का कारण बनता है:

 void Widget::startTimer() { m_timer.start(1000.0f / 60.0f, this); } void Widget::timerEvent(QTimerEvent *) { updateGL(); } void Widget::paintGL() { beginDraw(); drawSprites(); endDraw(); } void Widget::beginDraw() { m_idx = 0; glClear(GL_COLOR_BUFFER_BIT); glClearColor(m_background.r, m_background.g, m_background.b, m_background.a); } void Widget::endDraw() { glDrawArrays(GL_TRIANGLES, 0, m_idx / 2); } 

सभी आरेखण ड्रॉस्प्रिट्स () विधि में होते हैं, जिसका एक उदाहरण ऊपर दिया गया है। इसमें DrawSpriteArgs संरचना को भरना और प्रत्येक छवि के लिए drawSprite पद्धति को कॉल करना शामिल है जिसे तैयार करने की आवश्यकता है। यदि आप कुछ गैर-मानक चाहते हैं, उदाहरण के लिए, छवि को केंद्र के आसपास नहीं घुमाने के लिए, आप मैन्युअल रूप से निर्देशांक, बनावट और रंगों के सरणियों में भर सकते हैं। कंस्ट्रक्टर में प्रोग्राम शुरू करते समय सरणियों का अधिकतम आकार निर्धारित किया जाना चाहिए, क्योंकि QVector जब यह बड़ा हो जाता है, तो मेमोरी के दूसरे भाग में जा सकता है, और OpenGL को इस बारे में सूचित करना होगा:

  int vertexLocation = m_program->attributeLocation("a_position"); m_program->enableAttributeArray(vertexLocation); glVertexAttribPointer(vertexLocation, 2, GL_FLOAT, GL_FALSE, 0, &m_verts[0]); int texcoordLocation = m_program->attributeLocation("a_texcoord"); m_program->enableAttributeArray(texcoordLocation); glVertexAttribPointer(texcoordLocation, 2, GL_FLOAT, GL_FALSE, 0, &m_texCoords[0]); int colorLocation = m_program->attributeLocation("a_color"); m_program->enableAttributeArray(colorLocation); glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, &m_colors[0]); 

प्रक्षेपण मैट्रिक्स यहां से लिया गया था। यह विंडो आकार बदलने के दौरान सेट किया गया है:

 void Widget::resizeGL(int w, int h) { glViewport(0, 0, w, h); QMatrix4x4 mat( 2.0f/w, 0, 0, -1, 0, 2.0f/h, 0, -1, 0, 0, -1, 0, 0, 0, 0, 1 ); m_program->setUniformValue("mvp_matrix", mat); } 

शायद यही सब है। उन लोगों के लिए जो वास्तव में एक आवरण का उपयोग करना चाहते हैं, मैं अत्यधिक उदाहरणों को समझने और यह समझने की सलाह देता हूं कि यह कैसे काम करता है। कोड का परीक्षण विंडोज 7 (क्यूटी 4.8 मिनीजीडब्ल्यू, एमएसवीसी 2008), मैक ओएस एक्स 10.8 (क्यूटी 5.1 क्लैंग), नोकिया एन 9 (क्यूटी 4.7), ब्लैकबेरी 10 (क्यूटी 4.8) पर किया गया था, यह हर जगह सही ढंग से चलता है।

निष्कर्ष

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