यह लेख Qt 5.1 - भाग 1 और भाग 2 में OpenGL के लेख का अनुवाद है

भाग 1

---

यह लेख एक श्रृंखला में पहला है। वह दिखाएगा कि Qt 5 में OpenGL का उपयोग कैसे किया जाए। यह आलेख Qt में OpenGL के समर्थन के इतिहास में एक छोटा सा विषयांतर होगा। फिर हम Qt 5.1 में पेश की गई नई विशेषताओं के पहले भाग का वर्णन करेंगे। बाद के लेख अधिक सुविधाओं का वर्णन करेंगे, साथ ही साथ कुछ सरल उदाहरण भी हैं कि क्यूटी को ओपनजीएल के साथ काम करने के लिए कितनी आसानी से इस्तेमाल किया जा सकता है।

(बहुत) Qt और OpenGL का संक्षिप्त इतिहास

Qt का OpenGL का उपयोग करके ड्राइंग समर्थन का एक लंबा इतिहास है। अधिकांश Qt डेवलपर्स के पास QGLWidget का विचार है और संभवत: कुछ OpenGL- आधारित इंजन हैं। यह आपको कच्चे ओपनजीएल के साथ काम करने या QPainter API द्वारा दी गई सुविधाओं का उपयोग करने की अनुमति देता है। इसके अतिरिक्त, Qt विभिन्न ओपन ऑब्जेक्ट्स के आसपास कई उपयोगी आवरण प्रदान करता है: QGLShaderProgram , QGLFramebufferObject , QGLBuffer , आदि।

Qt 5 को डिज़ाइन करते समय, इन QGL * वर्गों को "किया गया" के रूप में चिह्नित किया गया था और नवीनतम QOpenGL * कक्षाएं QtGui मॉड्यूल ( अनुवादक के नोट का हिस्सा बन गईं - यह QtOpenGL हुआ ​​करती थीं )। इन परिवर्तनों का कारण यह है कि Qt Quick 2 में नया दृश्य OpenGL पर आधारित है, और वर्तमान में Qt के ग्राफ़िकल प्रसाद का एक प्रमुख हिस्सा है। इसके अलावा, नई QOpenGL * कक्षाओं का उपयोग पुराने QGL * वर्गों के लिए सीधे प्रतिस्थापन के रूप में किया जा सकता है। अब QtGui पुस्तकालय से QOpenGL * कक्षाओं का उपयोग करने की सिफारिश की गई है।

क्यूटी 5.0 प्रदान करता है (मूल रूप से) ओपनजीएल कार्यक्षमता का वही सबसेट जो क्यूटी 4.8 प्रदान करता है। क्यूटी क्विक 2 में आवश्यक कार्यक्षमता के लिए यह आवश्यक था, अन्य बातों के साथ। क्यूटी ४.४ की कार्यक्षमता के अलावा, क्यूटी ५.० किसी भी प्लेटफ़ॉर्म पर कस्टम ओपनजीएल विंडो और संदर्भों को आसानी से बनाने के लिए उपकरण प्रदान करता है। अब आपको एक संदर्भ बनाने के लिए विभिन्न प्लेटफार्मों की सुविधाओं से परेशान होने की आवश्यकता नहीं है जो ओपनजीएल प्रोफाइल का समर्थन कर सकते हैं। आप बस QOpenGLContext का उपयोग कर सकते हैं और अपने आप को भूरे बालों से बचा सकते हैं!

Qt 5.1 में, हमारे कारनामे OpenGL और Qt को सरल, सुरुचिपूर्ण और उम्मीद के साथ मज़ेदार बनाने के लिए अधिक से अधिक OpenGL कार्यक्षमता का प्रदर्शन करते हैं! इसके लिए, केडीएबी ने क्यूटी और ओपनजीएल की सीमाओं के विस्तार में भारी निवेश किया है।

हर जगह कार्य, कार्य!

खुलकर, कुछ प्लेटफार्मों पर ओपनजीएल के साथ काम करना मुश्किल हो सकता है
। इन कठिनाइयों के मुख्य कारणों में से एक प्रवेश बिंदु के पते को गतिशील रूप से चलाने की आवश्यकता है, रन टाइम पर, और बिल्ड समय पर नहीं (जब लिंकर ऐसा करने में सक्षम है)। उदाहरण के लिए, Microsoft Windows पर, OpenGL के संस्करण 1.1 से शुरू होने वाले किसी भी फ़ंक्शन का पता रनटाइम पर सौंपा जाना चाहिए। यही है, इसे आधुनिक ओपनजीएल में उपयोग किए जाने वाले लगभग सभी कार्यों के लिए किया जाना चाहिए!

इन समस्याओं को हल करने के लिए, Qt उपयोगी उपयोगिताओं की एक जोड़ी प्रदान करता है: QOpenGLContext :: GetProcAddress () और QOpenGLFunctions । पूर्व का उपयोग प्रवेश बिंदुओं को मैन्युअल रूप से असाइन करने के लिए किया जा सकता है, जबकि उत्तरार्द्ध एक वर्ग है, जिसके तरीके ओपनजीएल 2 और ओपनजीएल ईएस 2 फ़ंक्शन का एक सामान्य सबसेट प्रदर्शित करते हैं। ये मददगार जितना संभव हो उतना अच्छा है। समस्या यह है कि QOpenGLFunctions प्रदान की गई विधियों (OpenGL 2 और OpenGL ES 2 के सबसेट) में सीमित है। प्रवेश बिंदुओं का एक मैनुअल असाइनमेंट एक बहुत थकाऊ काम है, त्रुटियों से भरा। वैकल्पिक रूप से, आप इन समस्याओं को हल करने वाले तृतीय-पक्ष पुस्तकालयों से कार्यों का उपयोग कर सकते हैं, जैसे कि Glew या GLee । सच है, ये समाधान Qt के साथ आवश्यक कार्यक्षमता और सुविधाजनक कार्य प्राप्त करने के लिए भी समस्या पैदा करते हैं (उदाहरण के लिए, हेडर के आदेश को ध्यान में रखते हुए)।

QOpenGLContext :: versionFunctions () का उपयोग करें! यह एक मामूली सा कार्य है - ओपनगेल कार्यों के पते (प्रवेश बिंदु) के "यूटोपिया" के लिए आपका मार्गदर्शन :) इस फ़ंक्शन का उपयोग आवश्यक संस्करण और ओपनजीएल प्रोफाइल में किसी ऑब्जेक्ट के लिए एक संकेतक (प्रत्येक फ़ंक्शन के तरीकों के साथ) के लिए किया जा सकता है। आइए एक साधारण उदाहरण देखें। मान लीजिए कि हमारे पास QWindow का एक उपवर्ग है जो प्रस्तुत करता है। हम एक OpenGL 4.3 कोर प्रोफ़ाइल बनाना चाहते हैं और प्रदान की गई सभी सुविधाओं का उपयोग करना चाहते हैं। यह करना बहुत आसान है:

Window::Window(QScreen * screen) : QWindow(screen) { //  Qt    OpenGL    setSurfaceType(OpenGLSurface); //     -  QSurfaceFormat format; format.setDepthBufferSize(24); format.setMajorVersion(4); format.setMinorVersion(3); format.setSamples(4); format.setProfile(QSurfaceFormat::CoreProfile); setFormat(format); create(); //  OpenGL  m_context = new QOpenGLContext; m_context->setFormat(format); m_context->create(); //       m_context->makeCurrent(this); //         // m_funcs  : QOpenGLFunctions_4_3_Core * m_funcs m_funcs = m_context->versionFunctions(); if (!m_funcs) { qWarning("Could not obtain OpenGL versions object"); exit(1); } m_funcs->initializeOpenGLFunctions(); } 

अब से, हम बस QOpenGLFunctions_4_3_Core ऑब्जेक्ट के सदस्य कार्यों का उपयोग कर सकते हैं। उदाहरण के लिए:

  //  Vertex Attrib Divisor //    instanced rendering // (  OpenGL 3.3) m_funcs->glVertexAttribDivisor(pointLocation, 1); //    compute shader // (  OpenGL 4.3) m_funcs->glDispatchCompute(512 / 16, 512 / 16, 1); 

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

ओपनगेल एक्सटेंशन्स

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

ओपनजीएल एक्सटेंशन का उपयोग करने के लिए, आपको दो चरणों से गुजरना होगा। Qt दोनों चरणों में मदद करता है:

स्टेज 1:

सत्यापित करें कि वर्तमान कार्यान्वयन आवश्यक एक्सटेंशन का समर्थन करता है। यदि एक्सटेंशन एक नया एपीआई पेश करता है, तो प्रवेश बिंदु निर्दिष्ट करें। यह सत्यापित करने के लिए कि एक्सटेंशन समर्थित है, आपको QOpenGLContext :: hasExtension () विधि का उपयोग करने की आवश्यकता है। इसके अलावा, समर्थित एक्सटेंशन की पूरी सूची प्राप्त करने के लिए, आप OpenGLContext का उपयोग कर सकते हैं :: एक्सटेंशन () :

 //   QList extensions = m_context->extensions().toList(); std::sort(extensions); qDebug() << "Supported extensions (" << extensions.count() <<")"; foreach (const QByteArray &extension, extensions) { qDebug() << " " << extension; } 

स्टेज 2:

दूसरे चरण में, हमें अपने पुराने मित्र - QOpenGLContext :: GetProcAddress () पद्धति का उपयोग करने की आवश्यकता होगी। Qt 5.1 में, QtOpenGLExtensions मॉड्यूल इसके लिए जिम्मेदार है। यह मॉड्यूल एक स्थिर पुस्तकालय है और इसमें ख्रोनोस रजिस्ट्री से प्रत्येक ओपनजीएल एक्सटेंशन (जो एक नया एपीआई पेश करता है) के लिए एक वर्ग शामिल है। OpenGL एक्सटेंशन का उपयोग करने के लिए, निम्न के समान कोड का उपयोग करें:

  //    if (!m_context->hasExtension(QByteArrayLiteral("GL_ARB_instanced_arrays")) { qFatal("GL_ARB_instanced_arrays is not supported"); } //          QOpenGLExtension_ARB_instanced_arrays * m_instanceFuncs = new QOpenGLExtension_ARB_instanced_arrays(); m_instanceFuncs->initializeOpenGLFunctions(); //    m_instanceFuncs->glVertexAttribDivisorARB(pointLocation, 1); 

कोर ओपनग्ल फीचर के साथ, एक्सटेंशन के लिए कोड उत्पन्न होता है और इसलिए भविष्य में अपडेट करना आसान होता है।

भाग २

---

वर्टेक्स एरे ऑब्जेक्ट्स

Qt के पास एक QOpenGLBuffer है (इससे पहले QGLBuffer था) विभिन्न प्रकार की OpenGL बफर ऑब्जेक्ट्स, जैसे- pertex विशेषता डेटा और एलिमेंट इंडेक्स बफ़र्स को प्रबंधित करने में मदद करने के लिए। ओपनजीएल में एक विशेष कंटेनर भी है, जिसके प्रकार को ऑब्जेक्ट्स वर्टेक्स एरे (वीएओ) कहा जाता है, जो वर्टेक्स बफर ऑब्जेक्ट (वीबीओ) सेट के साथ मदद करता है।

KDAB ने Qt 5.1 के लिए कोड जोड़ा है जो कई VAO को QOpenGLVertexArrayObject क्लास के साथ इनकैप्सुलेट करता है। इस वर्ग का एक उदाहरण बाइंडिंग OpenGL को बताता है कि वर्टेक्स विनिर्देश के किसी भी राज्य को "याद रखें" जिसे आप बाद में सेट करना चाहते हैं। हम बाद में केवल वीएओ को फिर से जोड़कर आवश्यक राज्य विनिर्देशों को बहुत जल्दी बहाल कर सकते हैं। यह हमें "ऑब्जेक्ट्स" के लिए शीर्ष राज्यों के बीच बहुत तेज़ी से स्विच करने की अनुमति देता है जिसे हम अपने रेंडरिंग फ़ंक्शन में प्रस्तुत करना चाहते हैं:

 void Scene::initialize() { //      QOpenGLContext  // m_shaderProgram  QOpenGLShaderProgram //  VAO     m_vao1 = new QOpenGLVertexArrayObject( this ); m_vao1->create(); m_vao1->bind(); //   VBO  IBO ( QOpenGLBuffer   , //  ,    ..).   "" //    VAO m_positionBuffer.create(); m_positionBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw); m_positionBuffer.bind(); m_positionBuffer.allocate(positionData, vertexCount * 3 * sizeof(float)); m_shaderProgram.enableAttributeArray("vertexPosition"); m_shaderProgram.setAttributeBuffer ("vertexPosition", GL_FLOAT, 0, 3); m_colorBuffer.create(); m_colorBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw); m_colorBuffer.bind(); m_colorBuffer.allocate(colorData, vertexCount * 3 * sizeof(float)); m_shaderProgram.enableAttributeArray("vertexColor"); m_shaderProgram.setAttributeBuffer ("vertexColor", GL_FLOAT, 0, 3); //    ,  , // , ... ... //  VAO     m_vao2 = new QOpenGLVertexArrayObject(this); m_vao2->create(); m_vao2->bind(); //   VBO  IBO    ... // "  "    (.  ) m_skyBoxVAO = new QOpenGLVertexArrayObject(this); ... } void Scene::render() { //   m_funcs->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //       m_phongShaderProgram->bind(); ... //           m_vao1->bind(); m_funcs->glDrawElements(...); //           m_vao2->bind(); m_funcs->glDrawElements(...); //    /   .. //     m_skyboxShaderProgram->bind(); ... m_skyboxVAO->bind(); m_funcs->glDrawElements(...); ... } 

ओपन ओपन 3 के बाद से वीएओ पेश किए गए हैं, लेकिन उन्हें कोर प्रोफाइल के साथ 3.1 से अधिक पुराने ओपनजीएल संस्करणों की आवश्यकता है। इसके अलावा, VAOs क्रमशः OpenGL 2 और OpenGL ES 2 में GL_ARB_vertex_array_object या GL_OES_vertex_array_object एक्सटेंशन के रूप में उपलब्ध हैं। QOpenGLVertexArrayObject वर्ग मुख्य कार्यक्षमता का उपयोग करेगा (यदि संभव हो तो) या यदि आवश्यक हो तो विस्तार (यदि कोई हो) का संदर्भ लें।

VAO का उपयोग विज़ुअलाइज़ेशन कोड को सरल कर सकता है और उत्पादकता बढ़ा सकता है, जैसा कि OpenGL ड्राइवर कम सत्यापन जांच करेगा (यदि यह अधिक बफर संचालन करेगा)।

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