🌭 🚶🏼 👃🏾 ओपन में WBOIT: छँटाई के बिना पारदर्शिता 🏛️ 🚳 🐍

यह पोस्ट वेटेड ब्लेंडेड ऑर्डर-इंडिपेंडेंट ट्रांसपेरेंसी (WBOIT) के बारे में है - जो ट्रिक 2013 में JCGT में कवर की गई थी।

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

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

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

टुकड़े आदेश महत्वपूर्ण है। ऑपरेटर के _पास एक खंड का रंग (सी _पास ) और अस्पष्टता ( α ) होता है और इसके पीछे सभी टुकड़ों का समग्र रंग (सी _दूर ) होता है। अपारदर्शिता 0 से 1 तक हो सकती है; 0 का मतलब है कि वस्तु पूरी तरह से पारदर्शी (अदृश्य) है और 1 का मतलब है कि यह पूरी तरह से अपारदर्शी है।

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

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

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

\ 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) \ अंत {मैट्रिक्स}

$\ 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) उस बिंदु (x, y) में प्रदान किए गए गैर-पारदर्शी टुकड़े का रंग है। हमारे पास कुल पारदर्शी टुकड़े हैं जो गहराई से उत्तीर्ण हुए हैं, और उनके पास सूचकांक हैं ∈ [1, n]। C _i , ith पारदर्शी अंश का रंग है और α _i इसकी अपारदर्शिता है।

फॉर्मूला (2) फॉर्मूला (1) से थोड़ा मिलता-जुलता है, हालांकि यह बहुत स्पष्ट नहीं है। बदलें

C के _पास , C _{0 के} साथ C _दूर और

α और सूत्र (1) के साथ वही होगा जो आपको मिलेगा। वास्तव में,

सभी पारदर्शी टुकड़ों के रंगों का भारित अंकगणित माध्य है ("द्रव्यमान के केंद्र" के लिए यांत्रिकी में समान सूत्र है), और यह पास के टुकड़े C के रंग के लिए जाएगा। सी ₀ उन सभी पारदर्शी अंशों के पीछे गैर-पारदर्शी टुकड़े का रंग है जिसके लिए हम भारित अंकगणितीय माध्य की गणना करते हैं। दूसरे शब्दों में, हम सभी पारदर्शी अंशों को एक "भारित माध्य" खंड के साथ प्रतिस्थापित करते हैं और मानक सम्मिश्रण ऑपरेटर - सूत्र (1) का उपयोग करते हैं। अब, α के लिए थोड़ा परिष्कृत सूत्र है, और हमें अभी तक इसके अर्थ का पता लगाना है।

A l p h a = 1 - p r o d_{i = 1}^{n} (1 - A l p h a_{i})

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

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

यदि कुछ टुकड़े की अस्पष्टता 0 है तो यह पूरी तरह से अदृश्य है। यह परिणामस्वरूप रंग में योगदान नहीं करता है।

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

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

यह अगली तस्वीर पर बेहतर है:

ऑरेंज ट्राइएंगल की अपारदर्शिता 1 है, पारदर्शिता के साथ हरे रंग का त्रिकोण केवल गैर-पारदर्शी वस्तुओं के साथ प्रदान किया गया है। यह ऑरेंज रंग के रूप में शीर्ष त्रिकोण के माध्यम से शिफ्ट के पीछे त्रिकोण के हरे रंग की तरह दिखता है।

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

कम opacities के साथ बाएँ और दाएँ चित्र बहुत समान दिखते हैं:

और वे उच्च अपारदर्शिता के साथ अलग-अलग हैं:

यहाँ एक पारदर्शी पॉलीहेड्रॉन है:

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

सम्मिश्रण ऑपरेटर में गहराई इंजेक्षन

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

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

कोड

अब सूत्र के OpenGL कार्यान्वयन के लिए (2)। आप GitHub पर कार्यान्वयन देख सकते हैं । यह एक क्यूटी-आधारित ऐप है, और आप जो चित्र यहां देख रहे हैं, वह ज्यादातर उसी से आया है।

यदि आप पारदर्शी प्रतिपादन के लिए नए हैं, तो यहां एक अच्छी प्रविष्टि-स्तरीय सामग्री है:
ओपनजीएल जानें। सम्मिश्रण

मैं इस पोस्ट के साथ आगे बढ़ने से पहले इसे पढ़ने की सलाह देता हूं।

सूत्र (2) का मूल्यांकन करने के लिए हमें 2 अतिरिक्त फ्रेमबफ़र, 3 मल्टीसमल बनावट और एक गहराई रेंडरबफ़र की आवश्यकता होती है। गैर-पारदर्शी वस्तुओं को पहले बनावट, colorTextureNT को प्रदान किया जाएगा। इसका प्रकार GL_RGB10_A2 है। दूसरी बनावट (colorTexture) टाइप GL_RGBA16F की होगी। ColorTexture के पहले तीन घटकों में सूत्र का यह भाग होगा (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 framewok का उपयोग करता हूं, और 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 );

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

  f->glBindFramebuffer(GL_FRAMEBUFFER, framebufferNT); // ... rendering non-transparent objects ... // ....... // done! (you didn't expect me to explain how do I render primitives in OpenGL, did you? // It's not relevant for this topic

हमने अभी-अभी सभी गैर-पारदर्शी वस्तुओं को colorTextureNT को रेंडर किया और रेंडरबफर में गहराई लिखी। अगले रेंडरिंग पास पर उसी रेंडरबफ़र का उपयोग करने से पहले, हमें यह आश्वस्त करने की ज़रूरत है कि गैर-पारदर्शी वस्तुओं से गहराई रेंडरबफ़र में सभी लेखन कार्य समाप्त हो गए हैं। इसे GL_FRAMEBUFFER_BARRIER_BIT के साथ हासिल किया गया है। पारदर्शी वस्तुओं के प्रदान किए जाने के बाद, हम ApplyTextures () फ़ंक्शन को कॉल करने जा रहे हैं, जो अंतिम रेंडरिंग पास करेगा, जहां फ़ार्मेशन 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(); { // ... rendering transparent objects ... } CleanupAfterTransparentRendering(); f->glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT); f->glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO); ApplyTextures();

defaultFBO एक फ्रेम-बफ़र है जिसका उपयोग हम स्क्रीन पर चित्र दिखाने के लिए करते हैं। ज्यादातर मामलों में यह 0 है, लेकिन Qt में यह QOpenGLWidget :: defaultFramebufferObject () है।

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

यहाँ ReadyToTransparentRendering () फ़ंक्शन की सामग्री है:

  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);

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

टुकड़ा shader:

 #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 आह्वान करने के लिए सिस्टम बनाती है (जबकि आम तौर पर इसे पिक्सेल के अनुसार एक बार लागू किया जाता है, अपने आउटपुट को सभी नमूनों के लिए लिखता है जो एक आदिम के भीतर आते हैं)।

शीर्ष 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); }

टुकड़ा shader:

 #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);

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

सम्मिश्रण ऑपरेटर में गहराई इंजेक्षन

कोड

More articles: