🎌 🧑🏼‍🤝‍🧑🏼 🤛🏾 Direct3D 11 और OpenGL 4 पर लिंक की गई सूचियों का उपयोग करके आदेश-स्वतंत्र पारदर्शिता एल्गोरिदम 🕘 🌪️ 🤰🏿

ऑर्डर-इंडिपेंडेंट ट्रांसपेरेंसी (OIT) को लागू करना, शायद, कंप्यूटर ग्राफिक्स प्रोग्रामिंग का क्लासिक कार्य माना जा सकता है। संक्षेप में, OIT एल्गोरिदम एक साधारण लागू समस्या को हल करते हैं - पारभासी वस्तुओं का एक सेट कैसे खींचना है ताकि वे उस क्रम के बारे में चिंता न करें जिसमें वे खींचे गए हैं। रेंडर करते समय रंगों को मिलाने के नियम, हमें इसकी आवश्यकता होती है कि पारभासी वस्तुएं दूर से पास की ओर खींची जाती हैं, लेकिन विस्तारित वस्तुओं या जटिल आकार की वस्तुओं के मामले में यह हासिल करना मुश्किल है। सबसे उन्नत एल्गोरिदम में से एक का कार्यान्वयन, लिंक की गई सूचियों का उपयोग करके ओआईटी, 2010 में डायरेक्ट 3 डी 11 के लिए एएमडी द्वारा पेश किया गया था । सच कहूँ तो, उन वर्षों के व्यापक रूप से उपलब्ध ग्राफिक्स कार्ड पर एल्गोरिदम का प्रदर्शन मुझ पर उचित प्रभाव नहीं डाल पाया। 4 साल बाद, मैंने एएमडी की प्रस्तुति को खोदा और एल्गोरिदम को न केवल डायरेक्ट 3 डी 11 पर लागू करने का फैसला किया, बल्कि ओपनजीएल 4.3 पर भी। जो लोग इस उद्यम से बाहर आए हैं, उनमें दिलचस्पी है, मैं एक बिल्ली के लिए पूछता हूं।

एल्गोरिथ्म के कार्यान्वयन के बारे में बातचीत शुरू करने से पहले, मैं ध्यान देता हूं कि डेमो यहां व्यापक दर्शकों के लिए उपलब्ध है । प्रोजेक्ट को Demo_OIT कहा जाता है। बनाने के लिए, आपको Visual Studio 2012/2013 और CMake की आवश्यकता होगी। पद के अंत में उपयोगी शब्दावली प्रदान की जाती है।

OIT एल्गोरिदम का अवलोकन

पारभासी वस्तुओं के प्रतिपादन में कई विशेषताएं हैं:

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

सामान्यीकृत OIT एल्गोरिथ्म को निम्नानुसार दर्शाया जा सकता है:

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

यहां मुख्य कठिनाई अंक 3 और 4 है, अर्थात्, अलग-अलग गहराई के साथ टुकड़े कैसे प्राप्त करें, जहां सहेजना है और बाद में उन्हें कैसे सॉर्ट करना है।

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

लिंक्ड सूचियों का उपयोग करके ऑर्डर-इंडिपेंडेंट ट्रांसपेरेंसी एल्गोरिदम को लागू करना

आरंभ करने के लिए, मैं कार्यान्वयन आवश्यकताओं को निर्धारित करूंगा:

एल्गोरिथ्म Direct3D 11 और OpenGL 4.3 पर काम करता है;
एल्गोरिथ्म कंप्यूट कंप्यूटर्स का उपयोग नहीं करता है। फ्रैगमेंट शैडर काफी पर्याप्त है;
एल्गोरिथ्म MSAA का समर्थन करता है।

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

एल्गोरिथ्म को लागू करने के लिए, हमें आवश्यकता है:

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

ऑपरेशन के सिद्धांत की बेहतर समझ के लिए, निम्नलिखित आकृति पर विचार करें।

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

पहली नज़र में, ऐसा लगता है कि सब कुछ सरल है, चलो कार्यान्वयन विवरणों पर चलते हैं।

Direct3D 11 कार्यान्वयन

Direct3D 11 पर इस एल्गोरिथ्म को लागू करने के लिए, हमें तथाकथित अनअॉर्डर-एक्सेस संसाधनों की आवश्यकता है: बनावट ( RWTexture2D ) और संरचित बफर ( RWStructuredBuffer )। इन संसाधनों की ख़ासियत यह है कि उनके लिए पढ़ना और लिखना छाया में उपलब्ध हैं। डायरेक्ट 3 डी एपीआई में उनके लिए कमांड का एक विशेष सेट है, उदाहरण के लिए, शेड में चर के साथ यूए संसाधनों को संबद्ध करने के लिए, OMSetRenderTargetsAndUnorderedAccessViews विधि का उपयोग करें। इस विधि का उल्लेख संयोग से नहीं किया गया था। डायरेक्ट 3 डी 11 का संगठन ऐसा है कि पिक्सेल शेड्स के साथ एक गुच्छा बनाते समय यूए संसाधन रेंडर टारगेट के साथ प्रतिस्पर्धा करते हैं, अर्थात। यदि उपकरण 8 बनावट का एमआरटी प्रदान करता है, और 2 स्लॉट्स लक्ष्य पर कब्जा कर लेते हैं, तो 6 से अधिक स्लॉट यूए संसाधनों पर नहीं रहते हैं। GPU के अत्यधिक समानांतर आर्किटेक्चर के कारण, परमाणु संचालन का उपयोग करके UA संसाधनों के साथ काम किया जाना चाहिए।

खंड काउंटर को संरचित बफर के लिए D3D11_BUFFER_UAV_FLAG_COUNTER ध्वज का उपयोग करके लागू किया जाएगा। Direct3D 11 आपको एक संरचित बफर में एक परमाणु काउंटर संलग्न करने की अनुमति देता है, हमारे मामले में चिह्नित वस्तुओं को संग्रहीत करने के लिए एक बफर का उपयोग करना तर्कसंगत है।

Direct3D 11 पर एल्गोरिथ्म को लागू करने के लिए, हम बनाएंगे:

सूचियों के प्रमुख तत्वों के पते संग्रहीत करने के लिए बनावट। प्रारूप - DXGI_FORMAT_R32_UINT , शेड्स के साथ संचार के लिए झंडे - D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE , आकार बैक बफर के आकार के बराबर है;
लिंक किए गए सूची आइटम संग्रहीत करने के लिए एक संरचित बफर। HLSL में प्रत्येक सूची आइटम को निम्न संरचना द्वारा दर्शाया गया है:
```
struct ListNode { uint packedColor; uint depthAndCoverage; uint next; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
इस प्रकार, प्रत्येक सूची आइटम में 12 बाइट्स होती हैं। बैक बफर के प्रत्येक टुकड़े के लिए कई ऐसे तत्व हैं। ऐसी स्थिति की कल्पना करें जहां कैमरे के ठीक सामने 8 समानांतर पारभासी विमान हों जो पूरी स्क्रीन को घेरे हुए हों। इस मामले में, बैक बफर के प्रत्येक टुकड़े के लिए, 8 तत्वों की एक सूची बनाई जाएगी। इस डेटा को संग्रहीत करने के लिए, आकार 12 * डब्ल्यू * एच * 8 बाइट्स के एक बफर की आवश्यकता होती है, जहां डब्ल्यू, एच बैक बफर की लंबाई और चौड़ाई है। एक दुर्लभ कंप्यूटर गेम को फ्रेम में बहुत सारे दृश्यमान पारभासी अंशों की आवश्यकता होती है, इसलिए हम इन 8 विमानों को सीमित करने के मामले में लेते हैं। 1920x1080 रियर बफर को हल करने के लिए, संरचित बफर का आकार लगभग 190 एमबी है। ऊपर वर्णित ध्वज का उपयोग करके उसी बफ़र को टुकड़ा काउंटर संलग्न करें।

हम निम्नलिखित योजना के अनुसार फ्रेम तैयार करेंगे:

हम 0xffffffff मान के साथ सूचियों के प्रमुख तत्वों के पते की बनावट को साफ करते हैं। इसके लिए एक विशेष विधि ClearUnorderedAccessViewUint है। हम टुकड़ों के काउंटर को रीसेट करते हैं;
शून्य बफर लक्ष्य के रूप में पीछे बफर सेट करें, इंडेक्स 1 को प्रमुख तत्वों की बनावट मिलेगी, इंडेक्स 2 - सूची तत्वों का एक संरचित बफर;
हम दृश्य के एक अपारदर्शी भाग (एक स्काईबॉक्स और डेमो में कई अपारदर्शी चायदानी खींचे जाते हैं) खींचते हैं;
हम दृश्य के पारभासी हिस्से के टुकड़ों की सूची बनाते हैं। सब कुछ बाहर काम करने के लिए, पीछे के चेहरों की कतरन बंद करें ( डी 3 डी 11_काॅल_नोन ), गहराई बफर के लिए नए मानों को लिखना बंद करें (लेकिन गहराई परीक्षण को स्वयं बंद न करें), बनावट को रंग लिखना बंद कर दें (इस कदम पर हमारे पास खींचने के लिए कुछ भी नहीं है, हम केवल सूची बनाते हैं)। टुकड़े की सूची बनाने वाले पिक्सेल शेडर को नीचे दिया गया है।
```
 #include <common.h.hlsl> #include <pscommon.h.hlsl> struct ListNode { uint packedColor; uint depthAndCoverage; uint next; }; globallycoherent RWTexture2D<uint> headBuffer; globallycoherent RWStructuredBuffer<ListNode> fragmentsList; uint packColor(float4 color) { return (uint(color.r * 255) << 24) | (uint(color.g * 255) << 16) | (uint(color.b * 255) << 8) | uint(color.a * 255); } [earlydepthstencil] float4 main(VS_OUTPUT input, uint coverage : SV_COVERAGE, bool frontFace : SV_IsFrontFace) : SV_TARGET { float4 color = computeColorTransparent(input, frontFace); uint newHeadBufferValue = fragmentsList.IncrementCounter(); if (newHeadBufferValue == 0xffffffff) { return float4(0, 0, 0, 0); } uint2 upos = uint2(input.position.xy); uint previosHeadBufferValue; InterlockedExchange(headBuffer[upos], newHeadBufferValue, previosHeadBufferValue); uint currentDepth = f32tof16(input.worldPos.w); ListNode node; node.packedColor = packColor(float4(color.rgb, color.a)); node.depthAndCoverage = currentDepth | (coverage << 16); node.next = previosHeadBufferValue; fragmentsList[newHeadBufferValue] = node; return float4(0, 0, 0, 0); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
इस कोड में सबसे दिलचस्प स्थानों पर विचार करें। [अर्लीडेपस्टैंसिल] संशोधक बहुत महत्वपूर्ण भूमिका निभाता है। तथ्य यह है कि टुकड़े टुकड़े परीक्षण (गहराई परीक्षण, स्टेंसिल परीक्षण, आदि) आमतौर पर पिक्सेल पाइपलाइन के निष्पादन के बाद ग्राफिक्स पाइपलाइन के अंतिम चरण में किए जाते हैं। हमारे मामले में, यह अस्वीकार्य है, क्योंकि इस स्तर पर तैयार किए गए सभी टुकड़े लिंक किए गए सूचियों में आते हैं। सूचियों में प्रवेश करने से पहले अतिरिक्त टुकड़ों को काटने के लिए, प्रारंभिक गहराई परीक्षण (पिक्सेल shader) करना आवश्यक है।

यह देखना आसान है कि टुकड़े का रंग संरचना में यूंट के रूप में संग्रहीत है। Uint में फ्लोट 4 मान को पैक करने से 12 बाइट्स बचते हैं। 32-बिट गहराई को 16-बिट में पैक किया गया है, और मुफ्त 16-बिट का उपयोग कवरेज मूल्य (MSAA के कार्यान्वयन के लिए आवश्यक) को संग्रहीत करने के लिए किया जाता है।

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

खंडित रंग = टुकड़े का वर्तमान रंग * 1 + छायाकार से टुकड़े का रंग * छाया से टुकड़े का अल्फा ;

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

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

पिक्सेल shader में टुकड़े सॉर्ट करने के लिए कोड नीचे दिखाया गया है।
```
 void insertionSortMSAA(uint startIndex, uint sampleIndex, inout NodeData sortedFragments[MAX_FRAGMENTS], out int counter) { counter = 0; uint index = startIndex; for (int i = 0; i < MAX_FRAGMENTS; i++) { if (index != 0xffffffff) { uint coverage = (fragmentsList[index].depthAndCoverage >> 16); if (coverage & (1 << sampleIndex)) { sortedFragments[counter].packedColor = fragmentsList[index].packedColor; sortedFragments[counter].depth = f16tof32(fragmentsList[index].depthAndCoverage); counter++; } index = fragmentsList[index].next; } } for (int k = 1; k < MAX_FRAGMENTS; k++) { int j = k; NodeData t = sortedFragments[k]; while (sortedFragments[j - 1].depth < t.depth) { sortedFragments[j] = sortedFragments[j - 1]; j--; if (j <= 0) { break; } } if (j != k) { sortedFragments[j] = t; } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
Direct3D 11 में MSAA के कार्यान्वयन का उल्लेख करना भी उचित है। जब MSAA सक्षम किया जाता है, तो थोड़ा अलग पदों के साथ टुकड़े के भीतर प्रत्येक टुकड़े के लिए अंक (नमूने) का एक सेट बनता है। ऐसे बिंदुओं की संख्या MSAA स्तर (आमतौर पर 2, 4, 8, 16) की संख्या से मेल खाती है। प्रत्येक बिंदु के लिए, एक त्रिभुज (कवरेज परीक्षण) से संबंधित जाँच की जाती है, और यदि कम से कम एक बिंदु त्रिकोण के अंदर है, तो पिक्सेल शैडर को वर्तमान टुकड़े के लिए निष्पादित किया जाता है, और परिणाम उन सभी नमूनों के बीच प्रक्षेपित होता है जो परीक्षण पारित कर चुके हैं। यह समझने के लिए कि त्रिकोण के अंदर कौन से नमूने हैं (यानी, वे परीक्षण पास करते हैं और टुकड़े के परिणामस्वरूप रंग को प्रभावित करते हैं), कवरेज नामक एक मुखौटा बनता है। यह वह मूल्य था जो हमने पिछले चरण में प्रत्येक पारभासी अंश के लिए बचाया था।

अब, जब हम प्रतिपादन करते हैं, तो हम उस सूची से अंशों का चयन कर सकते हैं जो साधारण स्थिति कवरेज और (1 << नमूनाइंडेक्स) का उपयोग करके किसी विशेष नमूने के अनुरूप है ! = 0 । आपको निरंतर MAX_FRAGMENTS पर भी ध्यान देना चाहिए। सीपीयू पर भी कुशलतापूर्वक लिंक की गई सूचियों को क्रमबद्ध करना आसान नहीं है, जीपीयू पर, हम और भी सीमित हैं। इसलिए, सॉर्ट करने से पहले, लिंक की गई सूची को एक निश्चित लंबाई के एक सरणी में कॉपी किया जाता है, जो श्रृंखला में पारभासी अंशों की संख्या को सीमित करता है।

यह दिलचस्प है कि कवरेज मास्क द्वारा टुकड़ों को छानने के बाद, जो टुकड़े बिल्कुल एक ही गहराई और थोड़ा अलग रंग सूची में रहते हैं। यह विशेष रूप से कम गुणवत्ता वाले MSAA के साथ बहुभुज मॉडल के किनारों पर कलाकृतियों के निर्माण की ओर जाता है। विरूपण साक्ष्य को खत्म करने के लिए, समान गहराई के साथ टुकड़ों के रंग को औसत करना आवश्यक है। चूंकि टुकड़ों की आउटपुट सूची गहराई से क्रमबद्ध होती है, इसलिए समान गहराई मान वाले टुकड़े एक पंक्ति में जाते हैं। यह केवल उन्हें गिनने और एकत्र करने के लिए ही रहता है। स्पॉइलर के नीचे पूरा शेडर कोड छिपा होता है।
इस स्टेज के लिए पिक्सेल शेडर कोड
```
 #include <tpcommon.h.hlsl> float4 main(VS_OUTPUT input, uint sampleIndex : SV_SAMPLEINDEX) : SV_TARGET { uint2 upos = uint2(input.position.xy); uint index = headBuffer[upos]; clip(index == 0xffffffff ? -1 : 1); float3 color = float3(0, 0, 0); float alpha = 1; NodeData sortedFragments[MAX_FRAGMENTS]; [unroll] for (int j = 0; j < MAX_FRAGMENTS; j++) { sortedFragments[j] = (NodeData)0; } int counter; insertionSortMSAA(index, sampleIndex, sortedFragments, counter); // resolve multisampling int resolveBuffer[MAX_FRAGMENTS]; float4 colors[MAX_FRAGMENTS]; int resolveIndex = -1; float prevdepth = -1.0f; [unroll(MAX_FRAGMENTS)] for (int i = 0; i < counter; i++) { if (sortedFragments[i].depth != prevdepth) { resolveIndex = -1; resolveBuffer[i] = 1; colors[i] = unpackColor(sortedFragments[i].packedColor); } else { if (resolveIndex < 0) { resolveIndex = i - 1; } colors[resolveIndex] += unpackColor(sortedFragments[i].packedColor); resolveBuffer[resolveIndex]++; resolveBuffer[i] = 0; } prevdepth = sortedFragments[i].depth; } // gather [unroll(MAX_FRAGMENTS)] for (int i = 0; i < counter; i++) { [branch] if (resolveBuffer[i] != 0) { float4 c = colors[i] / float(resolveBuffer[i]); alpha *= (1.0 - ca); color = lerp(color, c.rgb, ca); } } return float4(color, alpha); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```

Direct3D 11 द्वारा कार्यान्वित एल्गोरिथम के परिणाम नीचे देखे जा सकते हैं।

OpenGL 4.3 कार्यान्वयन

ओपनजीएल 4.3 पर कार्यान्वयन पिछले कार्यान्वयन के समान कई मायनों में है। यहाँ संरचित बफ़र्स का एक एनालॉग स्टोरेज ब्लॉक हैं (मानक संस्करण में जोड़ा गया है 4.3 संस्करण में)। बनावट के साथ काम करने के लिए, जिसमें आप शेड्स से पढ़ और लिख सकते हैं, जीएलएसएल के पास विशेष प्रकार हैं (हमें uimage2D की आवश्यकता है)। कुल मिलाकर, एल्गोरिथ्म के कार्यान्वयन के लिए हमें चाहिए:

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

फ्रेम रेंडरिंग प्रक्रिया में एक प्रमुख विशेषता है। OpenGL हमें मैन्युअल रूप से पढ़ने / लिखने के संचालन के सिंक्रनाइज़ेशन को नियंत्रित करने की पेशकश करता है। इसके लिए एक विशेष कार्य glMemoryBarrier है , जिसे हम इस प्रकार कहेंगे:

 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_ATOMIC_COUNTER_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT);

यह एक फ्रेम ड्राइंग के विभिन्न चरणों के बीच डेटा अखंडता सुनिश्चित करेगा।

हम निम्नलिखित योजना के अनुसार फ्रेम तैयार करेंगे:

हम 0xffffffff मान के साथ लिंक किए गए सूचियों के प्रमुख तत्वों के पते से बनावट को साफ करते हैं। OpenGL 4.3 में, आपको एक shader को कॉल करने की आवश्यकता होती है, जो प्रत्येक टुकड़े के लिए निम्नलिखित ऑपरेशन करेगी:

 imageStore(headBuffer, upos, uvec4(0xffffffff));

हम टुकड़ों के काउंटर को रीसेट करते हैं ( glClearBufferSubData );
हम प्रतिपादन के लिए फ्रेमबफ़र को उजागर करते हैं;
हम एक दृश्य के एक अपारदर्शी भाग को खींचते हैं;
हम दृश्य के पारभासी हिस्से के टुकड़ों की सूची बनाते हैं। इस स्तर पर, पहले से घोषित सुविधा है। ओपनगेल "साइड इफेक्ट्स" के बिना केवल टुकड़े टुकड़े के लिए एक प्रारंभिक गहराई परीक्षण कर सकता है। दुर्भाग्य से, "साइड इफेक्ट्स" में स्टोरेज ब्लॉक को लिखना शामिल है। इस एल्गोरिथ्म के लिए प्रारंभिक गहराई परीक्षण की महत्वपूर्ण भूमिका पर पहले चर्चा की गई थी, इसलिए हमारे पास स्वयं गहराई परीक्षण को लागू करने के अलावा कोई विकल्प नहीं है। जीएलएसएल टुकड़ा shader का हिस्सा नीचे दिखाया गया है।
```
 void main() { outputColor = vec4(0); uint newHeadBufferValue = atomicCounterIncrement(fragmentsListCounter); if (newHeadBufferValue == 0xffffffff) discard; ivec2 upos = ivec2(gl_FragCoord.xy); float depth = texelFetch(depthMap, upos, 0).r; if (gl_FragCoord.z > depth) discard; vec4 color = computeColorTransparent(gl_FrontFacing); uint previosHeadBufferValue = imageAtomicExchange(headBuffer, upos, newHeadBufferValue); uint currentDepth = packHalf2x16(vec2(psinput.worldPos.w, 0)); fragments[newHeadBufferValue].packedColor = packColor(vec4(color.rgb, color.a)); fragments[newHeadBufferValue].depthAndCoverage = currentDepth | (gl_SampleMaskIn[0] << 16); fragments[newHeadBufferValue].next = previosHeadBufferValue; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
लेखन गहराई और रंग बफ़र्स, साथ ही क्लिपिंग बैक किनारों को इस स्तर पर अक्षम किया जाना चाहिए, जैसा कि Direct3D पर कार्यान्वयन के समान है।

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

 void main() { ivec2 upos = ivec2(gl_FragCoord.xy); uint index = imageLoad(headBuffer, upos).x; if (index == 0xffffffff) discard; vec3 color = vec3(0); float alpha = 1.0f; NodeData sortedFragments[MAX_FRAGMENTS]; for (int i = 0; i < MAX_FRAGMENTS; i++) { sortedFragments[i] = NodeData(0, 0.0f); } int counter; insertionSort(index, gl_SampleID, sortedFragments, counter); for (int i = 0; i < MAX_FRAGMENTS; i++) { if (i < counter) { vec4 c = unpackColor(sortedFragments[i].packedColor); alpha *= (1.0 - ca); color = mix(color, c.rgb, ca); } } outputColor = vec4(color, alpha); }

हम glBlitFramebuffer फ़ंक्शन का उपयोग करके फ़्रेमबफ़र से स्क्रीन पर कॉपी करते हैं।

नेत्रहीन, OpenGL 4.3 पर प्रदान करते समय प्राप्त परिणाम Direct3D 11 से अलग नहीं है।

समस्याओं

एल्गोरिथ्म में 3 प्रमुख समस्याएं हैं:

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

उत्पादकता

निम्न कॉन्फ़िगरेशन वाले कंप्यूटर पर प्रदर्शन माप किए गए थे: विंडोज 8.1 पर चलने वाले AMD Phenom II X4 970 3.79GHz, 16Gb RAM, AMD Radeon HD 7700 Series।

औसत फ्रेम समय। Direct3D 11 / 1920x1080 / 400k-800k पारभासी टुकड़े।

MSAA / MAX_FRAGMENTS	8	16	32
0	1.4835ms	1.67446ms	2.1275ms
2x	3.49895ms	6.66149ms	8.52533ms
4x	5.78841ms	12.3358ms	15.7224ms
8x	8.93051ms	18.4825ms	24.8538ms

औसत फ्रेम समय। ओपनजीएल 4.3 / 1920x1080 / 400k-800k पारभासी टुकड़े।

MSAA / MAX_FRAGMENTS	8	16	32
0	3.25259ms	4.10712ms	16.8482ms
2x	5.06972ms	7.16611ms	33.6713ms
4x	7.22944ms	12.3625ms	62.5776ms
8x	11.2621ms	19.0938ms	115.026ms

औसत फ्रेम समय। Direct3D 11 / 1920x1080 / ~ 5000k पारभासी टुकड़े।

MSAA / MAX_FRAGMENTS	8	16	32
0	4.94471ms	5.73306ms	7.95545ms
2x	9.91625ms	26.6783ms	40.4808ms
4x	16.653ms	50.7367ms	77.038ms
8x	28.3847ms	91.0873ms	143.419ms

औसत फ्रेम समय। OpenGL 4.3 / 1920x1080 / ~ 5000 k पारभासी टुकड़े।

MSAA / MAX_FRAGMENTS	8	16	32
0	16.2532ms	22.0057ms	139.678ms
2x	22.1646ms	35.0568ms	275.324ms
4x	30.4289ms	56.7788ms	536.241ms
8x	46.6934ms	197.024ms	1009.09ms

यह देखना आसान है कि Direct3D 11 पर एल्गोरिथ्म का कार्यान्वयन OpenGL 4.3 की तुलना में तेज है। इसके अलावा, 5 मिलियन पारभासी अंशों पर, MSGL सक्षम और बड़े MAX_FRAGMENTS मूल्यों के साथ OpenGL कार्यान्वयन "मर जाता है"। प्रोफाइलिंग परिणामों से पता चला कि एल्गोरिथ्म समय के अंतिम चरण में थोक खर्च करता है, अर्थात। छँटाई और सम्मिश्रण रंग के टुकड़े पर। यह भी ध्यान में रखा जाना चाहिए कि मेरा वीडियो कार्ड नवीनतम से बहुत दूर है, और दिए गए आंकड़े केवल फ्रेम समय की गतिशीलता को दर्शाते हैं।

निष्कर्ष

लिंक की गई सूचियों का उपयोग संभवतः OIT के कार्यान्वयन के लिए सबसे आधुनिक दृष्टिकोण माना जा सकता है। एल्गोरिथ्म दृश्य के पारभासी हिस्से की गुणवत्ता और जटिलता के लिए उचित सेटिंग्स के साथ बहुत तेज़ी से काम करता है। फ्रेम में 5 मिलियन दृश्यमान पारभासी अंश हैं, मेरी राय में, सबसे आधुनिक गेम के लिए भी पर्याप्त है (1920x1080 पारभासी टुकड़े के संकल्प के साथ स्क्रीन को कवर करने के लिए)। MSAA से, जो एल्गोरिथ्म को धीमा कर सकता है, यदि आवश्यक हो, तो आप बिल्कुल भी मना कर सकते हैं या इसे दूसरे एंटी-एलियासिंग एल्गोरिदम के साथ बदल सकते हैं। एल्गोरिथ्म, ज़ाहिर है, इसमें खामियां हैं, लेकिन वे सभी समझने योग्य हैं, और आप उनसे लड़ सकते हैं।

शब्दावली के बारे में थोड़ा

ऐसा हुआ कि कंप्यूटर ग्राफिक्स की शब्दावली लगभग पूरी तरह से विदेशी है। स्पॉइलर के नीचे मैंने कई शब्द दिए हैं जो किसी पोस्ट को पढ़ते समय उपयोगी हो सकते हैं।

मामले

प्रतिपादन एक द्वि-आयामी माध्यम (स्क्रीन, बनावट) पर तीन-आयामी दृश्य खींचने की प्रक्रिया है।

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

रेखांकन एक वस्तु के वेक्टर प्रतिनिधित्व से रेखापुंज छवि उत्पन्न करने की प्रक्रिया है।

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

MSAA (मल्टी-सैंपलिंग एंटीलियासिसिंग) OpenGL और Direct3D दोनों में लागू एंटी-अलियासिंग एल्गोरिदम में से एक है।

MSAA बनावट - antialiasing के साथ प्रतिपादन के लिए बनावट। यह एक विशेष प्रारूप, प्रकार और संचालन के सेट shaders में है।

रेंडर टारगेट - जहाँ रेंडरिंग की जाती है। इस शब्द का इस्तेमाल आमतौर पर एक बनावट में एक दृश्य को चित्रित करते समय किया जाता है।

MRT (कई रेंडर टारगेट) एक ऐसी टेक्नॉलॉजी है जो एक साथ कई रेंडर टार्गेट में रेंडर करने की सुविधा देती है।

कम्प्यूट-शेडर - GPU के लिए एक कार्यक्रम, जिसे एक सामान्य उद्देश्य कार्य (संभवतः कंप्यूटर ग्राफिक्स से संबंधित नहीं) को हल करने के लिए डिज़ाइन किया गया है।

बैक बफर - मल्टी बफर रेंडरिंग मॉडल में, वह बफर, जो आमतौर पर प्रदान किया जाता है, और जिसे फ्रेम खींचने के बाद फ्रंट बफर (फ्रंट बफर) के साथ स्वैप किया जाता है।

फ़्रेमबफ़र ओपनजीएल में एक विशेष वस्तु है जो आपको कई रेंडर लक्ष्यों और एक गहराई बफर को संयोजित करने की अनुमति देता है।

भराव - लगभग पिक्सेल के साथ स्क्रीन को भरें।

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