Ultramodern OpenGL। भाग 1

सभी को नमस्कार। ओपनजील विषय के बारे में थोड़ा जानने वाले हर कोई जानता है कि इस विषय पर बड़ी संख्या में लेख और पाठ्यक्रम हैं, लेकिन कई आधुनिक एपीआई को प्रभावित नहीं करते हैं, और उनमें से कुछ आमतौर पर glBegin और glEnd के बारे में बात करते हैं। मैं संस्करण 4 से शुरू होने वाले नए एपीआई की कुछ बारीकियों को कवर करने की कोशिश करूंगा। लेख के दूसरे भाग से लिंक करें

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

यदि आप इसे पसंद करते हैं, तो मैं OpenGL के अनुकूलन और ड्रॉ कॉल्स को कम करने के बारे में लिखूंगा।

चलो शुरू हो जाओ!

इस लेख में क्या होगा - आधुनिक ओपनजीएल की कार्यक्षमता
इस लेख में क्या नहीं होगा - ओपनजीएल पर प्रतिपादन के लिए आधुनिक दृष्टिकोण

डीएसए (डायरेक्ट स्टेट एक्सेस)

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

जैसा कि हम जानते हैं, OpenGL कई रेडियो बटन के साथ एक एपीआई है - glActiveTexture , glBindTexture , आदि।

यहाँ से हमें कुछ समस्याएं हैं :

• चयनकर्ता और वर्तमान राज्य राज्य में गहरा बदलाव कर सकते हैं।
• बनावट के लिए फ़िल्टर सेट करने के लिए सक्रिय इकाई को बाँधना / बदलना आवश्यक हो सकता है
• राज्य प्रबंधन समस्याग्रस्त हो जाता है जिसके परिणामस्वरूप आवेदन की जटिलता बढ़ती है
• अज्ञात राज्य अतिरिक्त सेटिंग्स की ओर जाता है
• राज्य को बचाने / बहाल करने के प्रयास समस्याग्रस्त हो सकते हैं

ख्रोनोस समूह ने हमें क्या पेशकश की और डीएसए कैसे मदद करता है?

• उन कार्यों को जोड़ता है जो सीधे ऑब्जेक्ट / ऑब्जेक्ट के साथ काम करते हैं
• निर्दिष्ट बनावट वस्तु के लिए बनावट फ़िल्टर सेट करता है, वर्तमान में नहीं।
• एक विशेष इकाई को एक बनावट बांधता है, सक्रिय को नहीं
• बहुत बड़ी संख्या में नई सुविधाएँ जोड़ता है
• OpenGL 1.x तक चीजें शामिल करता है
• अतिरिक्त सुविधाएँ जोड़ता है।

सिद्धांत रूप में, एक डीएसए गैर-प्रतिपादन और राज्य-बदलते संचालन की संख्या को शून्य तक कम करने में मदद कर सकता है ... लेकिन यह सटीक नहीं है।

अब मैं कुछ नई विशेषताओं के बारे में संक्षेप में बताऊंगा, मैंने मापदंडों पर विस्तार से ध्यान नहीं दिया, मैं विकि पर लिंक छोड़ दूंगा।

• glCreateTextures glGenTextures + glBindTexture (आरंभीकरण) को प्रतिस्थापित करता है ।
  यह था:
  

  glGenTextures(1, &name); glBindTexture(GL_TEXTURE_2D, name); 

  यह बन गया:
  

   glCreateTextures(GL_TEXTURE_2D, 1, &name); 

• glTextureParameterX glTexParameterX के बराबर है

   glGenTextures(1, &name); glBindTexture(GL_TEXTURE_2D, name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 

  अब हम इसे इस तरह लिखेंगे:
  

   glCreateTextures(GL_TEXTURE_2D, 1, &name); glTextureParameteri(name, GL_TEXTURE_WRAP_S, GL_CLAMP); glTextureParameteri(name, GL_TEXTURE_WRAP_T, GL_CLAMP); glTextureParameteri(name, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTextureParameteri(name, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTextureStorage2D(name, 1, GL_RGBA8, width, height); glTextureSubImage2D(name, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 

• glBindTextureUnit glActiveTexture + glBindTexture को बदलें
  यहाँ हमने यह कैसे किया:
  

   glActiveTexture(GL_TEXTURE0 + 3); glBindTexture(GL_TEXTURE_2D, name); 

  अब:
  

   glBindTextureUnit(3, name); 

परिवर्तनों ने glTextureImage को भी प्रभावित किया, अब इसका उपयोग नहीं किया जाता है, और यहां बताया गया है:

glTexImage बल्कि असुरक्षित है, अमान्य बनावट प्राप्त करना बहुत आसान है, क्योंकि फ़ंक्शन जब बुलाया जाता है तो मानों की जांच नहीं करता है, ड्रायवर ड्रॉ करते समय ऐसा करता है। इसे बदलने के लिए GlTexStorage को जोड़ा गया था।

glTexStorage एक कॉल के दौरान किए गए चेक के साथ बनावट बनाने का एक तरीका प्रदान करता है, जो त्रुटियों को कम करता है। बनावट रिपॉजिटरी अधिकांश द्वारा हल की जाती है, यदि सभी नहीं, तो उत्परिवर्तनीय बनावट के कारण समस्याएं, हालांकि अपरिवर्तनीय बनावट अधिक विश्वसनीय हैं।

परिवर्तनों ने फ्रेम बफर को भी प्रभावित किया:

• glCreateFramebuffers के बजाय glGenFramebuffers
• glNamedFramebufferTexture glFramebufferTexture को बदलें

ये सभी बदली हुई विशेषताएं नहीं हैं। अगली पंक्ति में बफ़र्स के लिए कार्य हैं:

• glGreateBuffers के बजाय glGenBuffers + glBindBuffer (आरंभीकरण)
• glNamedBufferData की जगह glBufferData
• glVertexAttribFormat और glBindVertexBuffer के बजाय glVertexAttribPointer

यहाँ DSA समर्थन में अब क्या शामिल है की एक सूची है:

• वर्टेक्स ऐरे ऑब्जेक्ट्स
• फ़्रेमबफ़र ऑब्जेक्ट
• प्रोग्राम ऑब्जेक्ट्स
• बफर ऑब्जेक्ट्स
• मैट्रिक्स ढेर
• बहुत सारी पुरानी बातें

डिबग

संस्करण 4.3 के बाद से, डिबग के लिए नई कार्यक्षमता जोड़ी गई है, मेरी राय में यह बहुत उपयोगी और सुविधाजनक है। अब OpenGL त्रुटियों और डिबग संदेशों के लिए हमारे कॉलबैक को कॉल करेगा, जिसका स्तर हम समायोजित कर सकते हैं।



हमें सक्षम करने के लिए केवल दो फ़ंक्शन कॉल करने की आवश्यकता है: glEnable & glDebugMessageCallback , कहीं भी आसान नहीं है।

 glEnable(GL_DEBUG_OUTPUT); glDebugMessageCallback(message_callback, nullptr); 

अब हम संदेश प्राप्त करने के लिए कॉलबैक फ़ंक्शन लिखेंगे:

 void callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar const* message, void const* user_param) { auto source_str = [source]() -> std::string { switch (source) { case GL_DEBUG_SOURCE_API: return "API"; case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "WINDOW SYSTEM"; case GL_DEBUG_SOURCE_SHADER_COMPILER: return "SHADER COMPILER"; case GL_DEBUG_SOURCE_THIRD_PARTY: return "THIRD PARTY"; case GL_DEBUG_SOURCE_APPLICATION: return "APPLICATION"; case GL_DEBUG_SOURCE_OTHER: return "OTHER"; default: return "UNKNOWN"; } }(); auto type_str = [type]() { switch (type) { case GL_DEBUG_TYPE_ERROR: return "ERROR"; case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "DEPRECATED_BEHAVIOR"; case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "UNDEFINED_BEHAVIOR"; case GL_DEBUG_TYPE_PORTABILITY: return "PORTABILITY"; case GL_DEBUG_TYPE_PERFORMANCE: return "PERFORMANCE"; case GL_DEBUG_TYPE_MARKER: return "MARKER"; case GL_DEBUG_TYPE_OTHER: return "OTHER"; default: return "UNKNOWN"; } }(); auto severity_str = [severity]() { switch (severity) { case GL_DEBUG_SEVERITY_NOTIFICATION: return "NOTIFICATION"; case GL_DEBUG_SEVERITY_LOW: return "LOW"; case GL_DEBUG_SEVERITY_MEDIUM: return "MEDIUM"; case GL_DEBUG_SEVERITY_HIGH: return "HIGH"; default: return "UNKNOWN"; } }(); std::cout << source_str << ", " << type_str << ", " << severity_str << ", " << id << ": " << message << std::endl; } 

हम glDebugMessageControl का उपयोग करके फ़िल्टर को भी कॉन्फ़िगर कर सकते हैं। फ़िल्टर स्रोत / प्रकार / महत्व या उनके पहचानकर्ताओं का उपयोग करके संदेशों का एक सेट द्वारा फ़िल्टरिंग मोड में काम कर सकता है।

संदेशों को एक विशिष्ट दायरे में फ़िल्टर करें:

 glPushDebugGroup( GL_DEBUG_SOURCE_APPLICATION, DEPTH_FILL_ID, 11, “Depth Fill”); //  Render_Depth_Only_Pass(); //  glPopDebugGroup(); //  

अतुल्यकालिक कॉल को अक्षम करने के लिए यह बहुत उपयोगी होगा ताकि हम फ़ंक्शन कॉल के क्रम को निर्धारित कर सकें, साथ ही डिबगिंग के समय स्टैक पर त्रुटि का स्थान भी ढूंढ सकें। यह काफी सरलता से किया जाता है:

 glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); 

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

SSO (अलग-अलग शेडर ऑब्जेक्ट)

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


एसएसओ हमें उन्हें फिर से जोड़ने के बिना फ्लाई पर shader कदम बदलने की अनुमति देते हैं। डिबगिंग के बिना एक सरल सॉफ्टवेयर पाइपलाइन बनाना और स्थापित करना इस प्रकार है:

 GLuint pipe = GL_NONE; // Create shaders GLuint fprog = glCreateShaderProgramv( GL_FRAGMENT_SHADER, 1, &text); GLuint vprog = glCreateShaderProgramv( GL_VERTEX_SHADER, 1, &text); // Bind pipeline glGenProgramPipelines( 1, &pipe); glBindProgramPipelines( pipe); // Bind shaders glUseProgramStages( pipe, GL_FRAGMENT_SHADER_BIT, fprog); glUseProgramStages( pipe, GL_VERTEX_SHADER_BIT, vprog); 

जैसा कि हम देखते हैं कि glCreateProgramPipelines एक डिस्क्रिप्टर जेनरेट करता है और ऑब्जेक्ट को इनिशियलाइज़ करता है, glCreateShaderProgramv , निर्दिष्ट स्रोतों का उपयोग करके शेडर प्रोग्राम को जेनरेट करता है, इनिशियलाइज़ करता है, लिंक करता है और glUreatProgramStages पाइप लाइन ऑब्जेक्ट पर प्रोग्राम स्टेप्स को अटैच करता है। glBindProgramPipeline - एक संदर्भ के साथ एक पाइपलाइन को जोड़ता है।

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

अधिक कठोर इंटरफ़ेस प्रदान करने के लिए, हमें अंतर्निहित इनपुट और आउटपुट ब्लॉकों को भी घोषित करने की आवश्यकता है जो हम प्रत्येक चरण के लिए उपयोग करना चाहते हैं।

अंतर्निहित ब्लॉक इंटरफेस को एक विकी के रूप में परिभाषित किया गया है:
वर्टेक्स:

 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[]; }; 

टेसूलेशन नियंत्रण:

 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[]; } gl_out[]; 

टेसेलेशन मूल्यांकन:

 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[]; }; 

ज्यामिति:

 out gl_PerVertex { vec4 gl_Position; float gl_PointSize; float gl_ClipDistance[]; }; 

एक अंतर्निहित मॉड्यूल को फिर से घोषित करने और एक नियमित रूप से वर्टेक्स शेडर में विशेषता स्थान का उपयोग करने का एक उदाहरण:

 #version 450 out gl_PerVertex { vec4 gl_Position; }; layout (location = 0) in vec3 position; layout (location = 1) in vec3 color; layout (location = 0) out v_out { vec3 color; } v_out; void main() { v_out.color = color; gl_Position = vec4(position, 1.0); }