ओपन में WBOIT: छँटाई के बिना पारदर्शिता

हम "भारित मिश्रित आदेश-स्वतंत्र पारदर्शिता" (इसके बाद WBOIT) के बारे में बात करेंगे - 2013 में JCGT में वर्णित तकनीक ( लिंक )।

जब स्क्रीन पर कई पारदर्शी वस्तुएं दिखाई देती हैं, तो पिक्सेल का रंग इस बात पर निर्भर करता है कि कौन पर्यवेक्षक के करीब है। यहाँ इस मामले के लिए एक प्रसिद्ध रंग मिश्रण सूत्र है:

$$

$$\ start {मैट्रिक्स} C = C_ {पास} \ अल्फा + C_ {दूर} (1- \ अल्फा) और& (1) \ अंत {मैट्रिक्स}$$

टुकड़े की व्यवस्था का क्रम इसके लिए महत्वपूर्ण है: पास के टुकड़े का रंग और इसकी अपारदर्शिता को C के _पास और α के रूप में दर्शाया जाता है, और इसके पीछे स्थित सभी टुकड़ों के परिणामस्वरूप रंग को C के रूप में निरूपित किया जाता _है । अपारदर्शिता एक संपत्ति है जो 0 से 1 तक मान लेती है, जहां 0 का अर्थ है कि वस्तु इतनी पारदर्शी है कि यह दिखाई नहीं दे रही है, और 1 - यह इतना अपारदर्शी है कि इसके पीछे कुछ भी दिखाई नहीं देता है ।

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

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

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

$$

$$\ start {मैट्रिक्स} C = {{sum_ {i = 1} ^ {n} C_i \ alpha_i} \ over {\ sum_ {i = 1} ^ {n} \ Alpha_i}} (1- \ prod_ i) = 1} ^ {n} (1- \ अल्फा_आई)) + C_0 \ prod_ {i = 1} ^ {n} (1- \ अल्फा_आई) और& (2) \ अंत {मैट्रिक्स}$$

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

इससे पहले कि हम पारदर्शी वस्तुओं को प्रस्तुत करना शुरू करें, हमें सभी अपारदर्शी लोगों को प्रस्तुत करना होगा। उसके बाद, पारदर्शी वस्तुओं का गहराई से परीक्षण किया जाता है, लेकिन गहराई बफर को लिखे बिना (यह इस प्रकार किया जाता है: glEnable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); )। यही है, कुछ स्क्रीन निर्देशांक (x, y) के साथ एक बिंदु पर ऐसा होता है: पारदर्शी टुकड़े जो अपारदर्शी की तुलना में करीब होते हैं, गहराई परीक्षण से गुजरते हैं, इस बात की परवाह किए बिना कि वे पहले से ही पारदर्शी टुकड़े के सापेक्ष गहराई में स्थित हैं, और पारदर्शी टुकड़े आगे दिखाई देते हैं। अपारदर्शी, गहराई परीक्षण पास नहीं करते हैं, और, तदनुसार, खारिज कर दिए जाते हैं।

सूत्र में सी ₀ (2) एक अपारदर्शी टुकड़े का रंग है, जिसके शीर्ष पर पारदर्शी टुकड़े खींचे जाते हैं, जिनमें से हमारे पास n टुकड़े हैं, सूचकांकों द्वारा n के माध्यम से 1 संकेत दिया गया है। C _i , i-th पारदर्शी टुकड़े का रंग है, α _i इसकी अपारदर्शिता है।

यदि आप बारीकी से देखते हैं, तो सूत्र (2) थोड़ा सा सूत्र (1) जैसा है। अगर आप ऐसा सोचते हैं C C के _{पास है} , C ₀ C _{दूर है} , और - यह α है , तो यह 1 सूत्र होगा, एक से एक। और वास्तव में - यह पारदर्शी टुकड़ों के रंगों का भारित औसत है (द्रव्यमान का केंद्र एक ही सूत्र द्वारा यांत्रिकी में निर्धारित किया जाता है), यह निकटतम टुकड़ा C का रंग होगा। सी ₀ सभी टुकड़ों के पीछे स्थित अपारदर्शी टुकड़े का रंग है, जिसके लिए हमने इस भारित औसत की गणना की, और यह सी _{दूर तक जाएगा} । यही है, हमने सभी पारदर्शी टुकड़ों को एक "औसत" टुकड़े के साथ बदल दिया और रंगों के मिश्रण के लिए मानक सूत्र लागू किया - सूत्र (1)। Α के लिए यह चालाक सूत्र क्या है कि मूल लेख के लेखक हमें प्रदान करते हैं?

$$

$$\ Alpha = 1- \ prod_ {i = 1} ^ {n} (1- \ Alpha_i)$$

यह n-आयामी अंतरिक्ष में एक अदिश कार्य है, इसलिए कई चर के कार्यों के अंतर विश्लेषण को याद करते हैं। यह देखते हुए कि सभी α _मैं 0 से 1 तक की सीमा के हैं, किसी भी चर के संबंध में आंशिक व्युत्पन्न हमेशा एक गैर-नकारात्मक स्थिरांक होगा। इसका मतलब यह है कि किसी भी पारदर्शी टुकड़े की बढ़ती अस्पष्टता के साथ "औसत" टुकड़े की अपारदर्शिता बढ़ जाती है, और ठीक यही है। इसके अलावा, यह रैखिक रूप से बढ़ता है।

यदि एक टुकड़े की अपारदर्शिता 0 है, तो यह बिल्कुल दिखाई नहीं देता है, यह परिणामी रंग को प्रभावित नहीं करता है।

यदि कम से कम एक टुकड़े की अपारदर्शिता 1 है, तो α 1 है। अर्थात, अपारदर्शी टुकड़ा अदृश्य हो जाता है, जो आम तौर पर अच्छा होता है। केवल अस्पष्टता के साथ टुकड़े के पीछे स्थित पारदर्शी टुकड़े = 1 अभी भी इसके माध्यम से चमकते हैं और परिणामी रंग को प्रभावित करते हैं:



यहाँ, एक नारंगी त्रिभुज ऊपर, हरे रंग के नीचे, और हरे रंग के नीचे ग्रे और सियान, और यह सब एक काले रंग की पृष्ठभूमि के खिलाफ है। नीला अपारदर्शिता = 1, अन्य सभी - 0.5। दाईं ओर की तस्वीर वही है जो होनी चाहिए। जैसा कि आप देख सकते हैं, WBOIT घृणित दिखता है। एकमात्र स्थान जहां सामान्य नारंगी रंग दिखाई देता है, वह हरे त्रिकोण का किनारा है, जो एक अपारदर्शी सफेद रेखा से घिरा हुआ है। जैसा कि मैंने अभी कहा, यदि पारदर्शी अंश की अपारदर्शिता 1 है तो एक अपारदर्शी टुकड़ा अदृश्य है।

यह और भी बेहतर है यहां देखें:



नारंगी त्रिकोण में 1 की अपारदर्शिता होती है, हरे रंग की पारदर्शिता बंद हो जाती है, बस अपारदर्शी वस्तुओं के साथ खींची जाती है। ऐसा लगता है कि ऑरेंज त्रिकोण के माध्यम से GREEN त्रिकोण चमकता है।

तस्वीर को सभ्य दिखने के लिए, सबसे आसान तरीका यह है कि वस्तुओं को उच्च अस्पष्टता न दी जाए। मेरी कार्यशील परियोजना में, मैं 0.5 से अधिक की अस्पष्टता निर्धारित करने की अनुमति नहीं देता। यह 3 डी सीएडी है, जिसमें वस्तुओं को योजनाबद्ध तरीके से खींचा जाता है, और विशेष यथार्थवाद की आवश्यकता नहीं होती है, इसलिए इस तरह के प्रतिबंध की अनुमति है।

कम अस्पष्टता मूल्यों के साथ, बाईं और दाईं ओर के चित्र लगभग समान हैं:



और उच्च के साथ वे स्पष्ट रूप से भिन्न होते हैं:



यह एक पारदर्शी पॉलीहेड्रॉन जैसा दिखता है:




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

गहराई आधारित WBOIT

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

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

कोड

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

उन लोगों के लिए जो केवल पारदर्शी वस्तुओं के प्रतिपादन का अध्ययन करना शुरू कर रहे हैं, मैं इन दो लेखों की सलाह देता हूं:

→ ओपनजीएल जानें। पाठ 4.3 - मिक्सिंग कलर्स
→ Direct3D 11 और OpenGL 4 पर लिंक की गई सूचियों का उपयोग करके आदेश-स्वतंत्र पारदर्शिता एल्गोरिदम

दूसरा, हालांकि, इस सामग्री को समझने के लिए इतना महत्वपूर्ण नहीं है, लेकिन पहला एक पढ़ा जाना चाहिए।

सूत्र (2) की गणना करने के लिए, हमें 2 अतिरिक्त फ़्रेमबफ़र, 3 मल्टीस्प्ल बनावट और एक रेंडर बफर की आवश्यकता होती है, जिसमें हम गहराई लिखेंगे। पहली बनावट में - colorTextureNT (NT का अर्थ गैर-पारदर्शी) - हम अपारदर्शी वस्तुओं को प्रस्तुत करेंगे। इसमें GL_RGB10_A2 टाइप है। दूसरी बनावट (colorTexture) GL_RGBA16F प्रकार की होगी; इस बनावट के पहले 3 घटकों में, हम सूत्र के इस टुकड़े को लिखेंगे (2): चौथे में - । प्रकार की एक और बनावट GL_R16 (एल्फा टेक्सचर) शामिल होगी ।

पहले आपको OpenGL से अपने पहचानकर्ता प्राप्त करने के लिए इन वस्तुओं को बनाने की आवश्यकता है:

  f->glGenFramebuffers (1, &framebufferNT ); f->glGenTextures (1, &colorTextureNT ); f->glGenRenderbuffers(1, &depthRenderbuffer); f->glGenFramebuffers(1, &framebuffer ); f->glGenTextures (1, &colorTexture); f->glGenTextures (1, &alphaTexture); 

जैसा कि मैंने कहा, Qt फ्रेमवर्क का उपयोग यहाँ किया गया है, और सभी OpenGL कॉल QOpenGLFunctions_4_5_Core प्रकार की एक वस्तु से गुज़रते हैं, जिसे हमेशा मेरे लिए f के रूप में जाना जाता है।

अब आपको मेमोरी आवंटित करनी चाहिए:

  f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT); f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples, GL_RGB16F, w, h, GL_TRUE ); f->glBindRenderbuffer(GL_RENDERBUFFER, depthRenderbuffer); f->glRenderbufferStorageMultisample( GL_RENDERBUFFER, numOfSamples, GL_DEPTH_COMPONENT, w, h ); f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTexture); f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples, GL_RGBA16F, w, h, GL_TRUE ); f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, alphaTexture); f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples, GL_R16F, w, h, GL_TRUE ); 

और फ़्रेमबफ़र कॉन्फ़िगर करें:

  f->glBindFramebuffer(GL_FRAMEBUFFER, framebufferNT); f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT, 0 ); f->glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderbuffer ); f->glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, colorTexture, 0 ); f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D_MULTISAMPLE, alphaTexture, 0 ); GLenum attachments[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1}; f->glDrawBuffers(2, attachments); f->glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderbuffer ); 

दूसरे रेंडरिंग पास पर, टुकड़े टुकड़े करने वाले से आउटपुट एक ही बार में दो बनावटों में जाएगा, और इसे glDrawBuffers का उपयोग करके स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए।

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

  f->glBindFramebuffer(GL_FRAMEBUFFER, framebufferNT); // ...   ... 

हमने अभी-अभी colorTextureNT बनावट पर सभी अपारदर्शी वस्तुओं को आकर्षित किया, और रेंडर बफर में गहराई लिखी। ड्राइंग के अगले चरण में एक ही रेंडरबफ़र का उपयोग करने से पहले, आपको यह सुनिश्चित करने की आवश्यकता है कि अपारदर्शी वस्तुओं की सभी गहराई पहले से ही वहां लिखी गई है। इसके लिए GL_FRAMEBUFFER_BARRIER_BIT का उपयोग किया जाता है। पारदर्शी वस्तुओं को प्रस्तुत करने के बाद, हम अपटैक्सचर () फ़ंक्शन को कॉल करते हैं, जो रेंडरिंग के अंतिम चरण को लॉन्च करेगा, जिसमें टुकड़ा shader textures colorTextureNT, colorTexture और AlphaTexture से फॉर्मूला (2) लागू करने के लिए डेटा पढ़ेगा। बनावट तब तक पूरी तरह से लिखी जानी चाहिए, इसलिए ApplyTextures () का उपयोग करने से पहले हम GL_TEXTURE_FETCH_BARRIER_BIT का उपयोग करते हैं।

  static constexpr GLfloat clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; static constexpr GLfloat clearAlpha = 1.0f; f->glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); f->glClearBufferfv(GL_COLOR, 0, clearColor); f->glClearBufferfv(GL_COLOR, 1, &clearAlpha); f->glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT); PrepareToTransparentRendering(); { // ...   ... } CleanupAfterTransparentRendering(); f->glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT); f->glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO); ApplyTextures(); 

defaultFBO फ्रेमबफ़र है जिसके माध्यम से हम छवि प्रदर्शित करते हैं। ज्यादातर मामलों में यह 0 है, लेकिन Qt में यह QOpenGLWidget :: defaultFramebufferObject () है।

हर बार जब टुकड़े टुकड़े को बुलाया जाता है, तो हमें वर्तमान टुकड़े के रंग और अस्पष्टता के बारे में जानकारी होगी। लेकिन ColorTexture बनावट के आउटपुट में हम इन राशियों के कुछ कार्यों के योग (और AlphaTexture बनावट के उत्पाद) प्राप्त करना चाहते हैं। इसके लिए ब्लेंडिंग का इस्तेमाल किया जाता है। इसके अलावा, चूंकि पहली बनावट के लिए हम योग की गणना करते हैं, और दूसरे के लिए - उत्पाद, प्रत्येक लगाव के लिए सम्मिश्रण सेटिंग्स (glBlendFunc और glBlendEquation) को अलग से सेट किया जाना चाहिए।

यहाँ तैयार की सामग्री है:

  f->glEnable(GL_DEPTH_TEST); f->glDepthMask(GL_FALSE); f->glDepthFunc(GL_LEQUAL); f->glDisable(GL_CULL_FACE); f->glEnable(GL_MULTISAMPLE); f->glEnable(GL_BLEND); f->glBlendFunci(0, GL_ONE, GL_ONE); f->glBlendEquationi(0, GL_FUNC_ADD); f->glBlendFunci(1, GL_DST_COLOR, GL_ZERO); f->glBlendEquationi(1, GL_FUNC_ADD); 

और CleanupAfterTransparentRendering () फ़ंक्शन की सामग्री:

  f->glDepthMask(GL_TRUE); f->glDisable(GL_BLEND); 

मेरे टुकड़े टुकड़े में, अस्पष्टता पत्र डब्ल्यू द्वारा इंगित किया गया है। W द्वारा रंग का उत्पाद और स्वयं w हम एक आउटपुट पैरामीटर को आउटपुट करते हैं, और 1 - w से दूसरे में। प्रत्येक आउटपुट पैरामीटर के लिए, एक लेआउट क्वालीफायर को "स्थान = X" के रूप में सेट किया जाता है, जहां एक्स अटैचमेंट एरे में तत्व का सूचकांक होता है, जिसे हमने 3 डी लिस्टिंग में ग्लड्राफर्फ़र्स को पारित किया था (विशेष रूप से, स्थान = 0 के साथ आउटपुट पैरामीटर GL_COLOR_ATTACHMENT0 के लिए बाध्य बनावट को भेजा गया है) , और GL_COLOR_ATTACHMENT1 से जुड़ी बनावट में स्थान = 1 के साथ पैरामीटर)। उसी संख्या का उपयोग glBlendFunci और glBlendEquationi फ़ंक्शन में किया जाता है, जिसके लिए हम अटैचमेंट पैरामीटर सेट करते हैं, जिसके लिए अटैचमेंट नंबर दर्शाते हैं।

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

 #version 450 core in vec3 color; layout (location = 0) out vec4 outData; layout (location = 1) out float alpha; layout (location = 2) uniform float w; void main() { outData = vec4(w * color, w); alpha = 1 - w; } 

ApplyTextures () फ़ंक्शन में, हम पूरी विंडो पर एक आयत बनाते हैं। टुकड़ा shader हमारे द्वारा बनाए गए सभी बनावटों से डेटा का अनुरोध करता है, वर्तमान स्क्रीन निर्देशांक बनावट निर्देशांक के रूप में और मौजूदा नमूना संख्या (gl_SampleID) बहुरूप बनावट में नमूना संख्या के रूप में उपयोग करता है। Shader में gl_SampleID चर का उपयोग करना स्वचालित रूप से उस मोड को चालू करता है जब प्रत्येक नमूने के लिए एक बार टुकड़ा shader को कॉल किया जाता है (सामान्य परिस्थितियों में, इसे पूरे पिक्सेल के लिए एक बार कहा जाता है, और परिणाम उन सभी नमूनों को लिखा जाता है जो आदिम के अंदर थे)

शीर्ष छाया में कुछ भी उल्लेखनीय नहीं है:

 #version 450 core const vec2 p[4] = vec2[4]( vec2(-1, -1), vec2( 1, -1), vec2( 1, 1), vec2(-1, 1) ); void main() { gl_Position = vec4(p[gl_VertexID], 0, 1); } 

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

 #version 450 core out vec4 outColor; layout (location = 0) uniform sampler2DMS colorTextureNT; layout (location = 1) uniform sampler2DMS colorTexture; layout (location = 2) uniform sampler2DMS alphaTexture; void main() { ivec2 upos = ivec2(gl_FragCoord.xy); vec4 cc = texelFetch(colorTexture, upos, gl_SampleID); vec3 sumOfColors = cc.rgb; float sumOfWeights = cc.a; vec3 colorNT = texelFetch(colorTextureNT, upos, gl_SampleID).rgb; if (sumOfWeights == 0) { outColor = vec4(colorNT, 1.0); return; } float alpha = 1 - texelFetch(alphaTexture, upos, gl_SampleID).r; colorNT = sumOfColors / sumOfWeights * alpha + colorNT * (1 - alpha); outColor = vec4(colorNT, 1.0); } 

और अंत में, ApplyTextures () फ़ंक्शन की सामग्री:

  f->glActiveTexture(GL_TEXTURE0); f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT); f->glUniform1i(0, 0); f->glActiveTexture(GL_TEXTURE1); f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTexture); f->glUniform1i(1, 1); f->glActiveTexture(GL_TEXTURE2); f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, alphaTexture); f->glUniform1i(2, 2); f->glEnable(GL_MULTISAMPLE); f->glDisable(GL_DEPTH_TEST); f->glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 

खैर, OpenGL के संसाधनों को समाप्त करने के बाद यह अच्छा होगा। मेरे पास यह कोड मेरे OpenGL विजेट के विनाशकर्ता में है:

  f->glDeleteFramebuffers (1, &framebufferNT); f->glDeleteTextures (1, &colorTextureNT); f->glDeleteRenderbuffers(1, &depthRenderbuffer); f->glDeleteFramebuffers (1, &framebuffer); f->glDeleteTextures (1, &colorTexture); f->glDeleteTextures (1, &alphaTexture);