संक्षिप्त समीक्षा

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

सबसे पहले, मैं दिखाऊंगा कि एक गहराई बफर के लिए एक पूर्ण एमआईपी श्रृंखला कैसे उत्पन्न की जाती है, जो कि बनावट बफ़र में गहराई प्रश्नों की सटीकता को संरक्षित करती है (या एनडीसी) यहां तक कि गहराई बफर आकारों के लिए दो की शक्तियों के बराबर नहीं है। (इंटरनेट पर, मैं ऐसे कोड उदाहरणों के साथ आया हूं जो इस सटीकता की गारंटी नहीं देते हैं, जो उच्च स्तर के स्तरों पर सटीक प्रश्नों के निष्पादन को जटिल बनाता है।)

फिर, ऐसे मामलों के लिए जिनमें केवल एक स्तर की डाउनसैंपलिंग की आवश्यकता होती है, मैं प्रदर्शित करता हूं कि इस स्तर को एक कॉल के साथ एक कंपाउंडर शेडर में कैसे उत्पन्न किया जाए जो कार्यसमूह की साझा स्मृति में परमाणु संचालन का उपयोग करता है। मेरे आवेदन के लिए, जहां केवल 1/16 x 1/16 रिज़ॉल्यूशन आवश्यक है (एमआईपी स्तर 4), कम्प्यूटेशनल शेडर के साथ विधि कई पासों में एमआईपी श्रृंखला को डाउनसम्प्लिंग करने के साथ सामान्य दृष्टिकोण से 2-3 गुना तेज है।

परिचय

पदानुक्रमित गहराई (जिसे हाय-जेड भी कहा जाता है) एक तकनीक है जिसका उपयोग अक्सर 3 डी ग्राफिक्स में किया जाता है। यह अदृश्य ज्यामिति (रोड़ा culling) (में की ट्रिमिंग तेजी लाने के लिए प्रयोग किया जाता है सीपीयू , के रूप में अच्छी तरह के रूप में GPU , की गणना) स्क्रीन स्थान में प्रतिबिंब , अनुमापी कोहरा, और भी बहुत कुछ।

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

हाय-जेड का मूल विचार निचले रिज़ॉल्यूशन बफ़र्स से पढ़कर गहराई क्वेरी संचालन को गति देना है। यह बफ़र से पूर्ण रिज़ॉल्यूशन डेप्थ को दो कारणों से पढ़ने से तेज़ है:

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

डाउन-सैंपल किए गए हाई-जेड बफर स्तरों की सामग्री इस बात पर निर्भर करती है कि उनका उपयोग कैसे किया जाता है (क्या गहराई बफर "उलटा" होगा , किस प्रकार के अनुरोधों का उपयोग किया जाना चाहिए)। सामान्य तौर पर, हाय-जेड बफर स्तर के स्टोर में एक टेक्सल minया maxपिछले स्तर पर संबंधित सभी टेक्सल्स। कभी कभी के मूल्यों minऔर एक ही समय में जमा हो जाती है max। सरल औसत मूल्य (जो अक्सर नियमित पाठ के एमआईपी स्तरों में उपयोग किए जाते हैं) को अक्सर उपयोग किया जाता है क्योंकि वे इस प्रकार के प्रश्नों के लिए शायद ही कभी उपयोगी होते हैं।

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

कृपया ध्यान दें कि मैंने "बिल्कुल" वाक्यांश का उपयोग किया है: यदि Z <= प्राप्त मूल्य (अधिकतम) का समन्वय करता है, तो यह ज्ञात नहीं है कि इसका बफर ओवरलैप करता है या नहीं। कुछ अनुप्रयोगों में, अनिश्चितता के मामलों में, पूर्ण रिज़ॉल्यूशन की गहराई के लिए बफर की खोज करना आवश्यक हो सकता है; अन्य मामलों में, यह आवश्यक नहीं है (उदाहरण के लिए, यदि केवल अनावश्यक गणना दांव पर है, और सही प्रतिपादन नहीं है)।

मेरा आवेदन: एक कम्प्यूटेशनल shader में कणों का प्रतिपादन

अपने PARTICULAL VR अनुप्रयोग के इंजन में कम्प्यूटेशनल shader में कण रेंडरिंग को लागू करते समय मुझे Hi-Z का उपयोग करने की आवश्यकता का सामना करना पड़ा । चूंकि यह रेंडरिंग तकनीक नियत कार्यों के साथ रेखांकन का उपयोग नहीं करती है, इसलिए इसे प्रत्येक कण के लिए एक पिक्सेल के आकार के साथ अपनी स्वयं की गहराई जांच का उपयोग करने की आवश्यकता होती है। और चूंकि कणों को किसी भी तरह से सॉर्ट नहीं किया जाता है, गहराई बफर तक पहुंच (मामलों में सबसे खराब) लगभग यादृच्छिक है। पूर्ण-स्क्रीन रैंडम-एक्सेस बनावट पर खोज संचालन खराब प्रदर्शन का तरीका है। लोड कम करने के लिए, मैं पहली बार मूल से 1/16 x 1/16 के रिज़ॉल्यूशन के साथ कम गहराई वाले बफर में गहराई की खोज करता हूं। इस बफ़र में गहराई मान है।

min, जो पूर्ण रिज़ॉल्यूशन डेप्थ टेस्ट को छोड़ने के लिए दृश्यमान कणों के विशाल बहुमत के लिए कम्प्यूटेशनल रेंडरिंग शेडर की अनुमति देता है। (यदि कण गहराई <न्यूनतम रिज़ॉल्यूशन बफर में संग्रहीत न्यूनतम गहराई है, तो हम जानते हैं कि यह बिल्कुल दिखाई दे रहा है। यदि यह> = मिनट है, तो हमें पूर्ण रिज़ॉल्यूशन डेप्थ बफर की जांच करने की आवश्यकता है।) इसके लिए

धन्यवाद, सामान्य मामले में दृश्य कणों के लिए गहराई परीक्षण। एक कम लागत वाला ऑपरेशन बन जाता है। (ज्यामिति द्वारा ओवरलैप किए गए कणों के लिए, यह अधिक महंगा है, लेकिन यह हमें सूट करता है, क्योंकि यह प्रतिपादन लागत का कारण नहीं बनता है, इसलिए कणों को अभी भी कम गणना की आवश्यकता होती है।)

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

अब हम एक पदानुक्रमित गहराई बफर बनाने के लिए दो तकनीकों को देखेंगे।

तकनीक 1: एक पूरी Mip श्रृंखला का निर्माण

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

पूर्ण रिज़ॉल्यूशन डेप्थ बफर से एक एमआईपी चेन बनाना आमतौर पर एक सरल कार्य है - प्रत्येक टेक्सल के लिए स्तर एन में हम पहले से उत्पन्न स्तर एन -1 में संबंधित 4 टेक्सल्स लेते हैं max( minया दोनों)। हम अनुक्रमिक पास (प्रत्येक बार आकार को आधे से कम करते हुए) तब तक करते हैं जब तक कि हमें आकार में अंतिम एमआईपी स्तर 1x1 नहीं मिलता।

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

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

तो, वास्तव में हमारे द्वारा प्राप्त एमआईपी-स्तर एन पर व्यक्तिगत टेक्सल का मूल्य क्या होगा? यह न्यूनतम मान होना चाहिए (minपूर्ण-स्क्रीन डेप्थ बफर के सभी टेक्सल्स का), (सामान्यीकृत) बनावट में समान स्थान पर कब्जा कर अंतरिक्ष को समन्वयित करता है।

दूसरे शब्दों में, यदि बनावट का एक अलग समन्वय (अंतराल में)

[0, 1]^{2}

$[0, 1]^2$ ) पूर्ण रिज़ॉल्यूशन बफर के एक व्यक्तिगत टेक्सल के लिए (निकटतम पड़ोसियों को फ़िल्टर करके) मैप किया जाता है, फिर पूर्ण रिज़ॉल्यूशन minके इस टेक्सल को प्रत्येक बाद के उच्च एमआईपी स्तर पर टेक्सल के लिए गणना किए गए मूल्य के लिए एक उम्मीदवार के रूप में माना जाना चाहिए , जिसके साथ एक ही बनावट का समन्वय होता है।

यदि इस पत्राचार की गारंटी दी जाती है, तो हम सुनिश्चित करेंगे कि उच्च एमआईपी स्तरों पर खोज ऑपरेशन पूर्ण रिज़ॉल्यूशन बफर (स्तर 0) के अनुरूप समान बनावट में गहराई मूल्य> टेक्सल वैल्यू को कभी वापस नहीं करेगा। एक अलग एन के मामले में, यह गारंटी उसके नीचे के सभी स्तरों (<एन) के लिए बनी हुई है।

यहां तक कि आयामों के लिए (और पूर्ण रिज़ॉल्यूशन बफ़र्स के मामले में, जो दो की शक्तियां हैं, यहां तक कि प्रत्येक स्तर पर आयाम अंतिम तक, जहां आयाम 1 के बराबर हो जाते हैं) करना आसान होगा। एक-आयामी मामले में, एक सूचकांक के साथ टेक्सल के लिए

i

$i$ स्तर N पर हमें सूचकांकों के साथ स्तर N-1 पर टेक्सल्स लेने की आवश्यकता है

2

$2$ तथा

2 i + 1

$2i + 1$ और उनका अर्थ खोजें min। अर्थात

D_{N} [i] = min (D_{N - 1} [2 i], D_{N - 1} [2 i + 1])

$D_{N}[i] = \text{min}(D_{N-1}[2i], D_{N-1}[2i + 1])$ । हम सीधे "2 से 1" अनुपात में टेक्सल्स की तुलना कर सकते हैं (और इसलिए बनावट का आकार निर्देशांक करता है), क्योंकि प्रत्येक स्तर का आकार पिछले एक के मुकाबले आधा है।

सम स्तर के आकारों का एक उदाहरण: इस स्तर पर 6 टेक्सल्स को उच्च स्तर पर घटाकर 3 कर दिया जाता है। तीन उच्च-स्तरीय टेक्सल्स में से प्रत्येक की बनावट समन्वय आकार हर दो निचले-स्तर के टेक्सल्स पर सटीक रूप से लगाया जाता है। (डॉट्स टेक्सल्स के केंद्र हैं, और वर्ग निकटतम पड़ोसियों को छानते समय बनावट के आयामों का समन्वय करते हैं।)

विषम स्तर के आकार के मामले में (और पूर्ण रिज़ॉल्यूशन बफ़र्स जो दो की शक्ति नहीं हैं, उनके पास विषम आकार के साथ कम से कम एक स्तर होगा) सब कुछ। कठिन हो रहा है। विषम आकार के स्तर N-1 के लिए

{d i m}_{N - 1}

$\mathit{dim}_{N-1}$ अगले स्तर (N) का आकार बराबर होगा

{d i m}_{N} = ⌊ \frac{{d i m}_{N - 1}}{2} ⌋

$\mathit{dim}_{N} = \lfloor \frac{\mathit{dim}_{N-1}}{2} \rfloor$ , अर्थात

\neq \frac{{d i m}_{N - 1}}{2}

$\neq \frac{\mathit{dim}_{N-1}}{2}$ ।

इसका मतलब है कि अब हमारे पास स्तर N-1 के स्तर के टेक्सल्स के 2 से 1 मैपिंग का स्पष्ट स्तर नहीं है। अब स्तर N पर प्रत्येक टेक्सल के बनावट समन्वय का आकार स्तर N-1 पर 3% पार्कों के आकार से अधिक है ।

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

इसलिये

D_{N} [i] = min (D_{N - 1} [2 i], D_{N - 1} [2 i + 1], D_{N - 1} [2 i + 2])

$D_{N}[i] = \text{min}(D_{N-1}[2i], D_{N-1}[2i + 1], D_{N-1}[2i + 2])$ । इसका मतलब यह है कि एन -1 के स्तर पर एक टेक्सल कभी-कभी एन के स्तर पर 2 टेक्सल्स के minलिए गणना किए गए मूल्य को प्रभावित करता है। ऊपर वर्णित तुलना को बनाए रखने के लिए यह आवश्यक है। ऊपर दिए गए विवरण को सादगी के लिए सिर्फ एक आयाम में प्रस्तुत किया गया है। दो आयामों में, यदि N-1 स्तर के दोनों आयाम समान हैं, तो N-1 स्तर पर 2x2 टेक्सल क्षेत्र को N स्तर पर एक टेक्सल पर मैप किया जाता है। यदि आयामों में से कोई एक विषम है, तो N-1 स्तर पर 2x3 या 3x2 क्षेत्र को एक मैप किया जाता है। स्तर एन पर टेक्सेल। यदि दोनों आयाम विषम हैं , तो "कोणीय" टेक्सल को भी ध्यान में रखा जाना चाहिए, अर्थात स्तर एन -1 पर 3x3 क्षेत्र की तुलना स्तर एन में एक टेक्सल के साथ की जाती है।

कोड उदाहरण

जीएलएसएल शेडर कोड नीचे वर्णित एल्गोरिदम को लागू करता है जिसे हमने वर्णित किया है। इसे प्रत्येक बाद के एमआईपी के लिए निष्पादित किया जाना चाहिए, 1 स्तर (स्तर 0 पूर्ण रिज़ॉल्यूशन स्तर) से शुरू होता है।

uniform sampler2D u_depthBuffer;
uniform int u_previousLevel;
uniform ivec2 u_previousLevelDimensions;

void main() {
	ivec2 thisLevelTexelCoord = ivec2(gl_FragCoord);
	ivec2 previousLevelBaseTexelCoord = 2 * thisLevelTexelCoord;

	vec4 depthTexelValues;
	depthTexelValues.x = texelFetch(u_depthBuffer,
                                    previousLevelBaseTexelCoord,
                                    u_previousLevel).r;
	depthTexelValues.y = texelFetch(u_depthBuffer,
                                    previousLevelBaseTexelCoord + ivec2(1, 0),
                                    u_previousLevel).r;
	depthTexelValues.z = texelFetch(u_depthBuffer,
                                    previousLevelBaseTexelCoord + ivec2(1, 1),
                                    u_previousLevel).r;
	depthTexelValues.w = texelFetch(u_depthBuffer,
                                    previousLevelBaseTexelCoord + ivec2(0, 1),
                                    u_previousLevel).r;

	float minDepth = min(min(depthTexelValues.x, depthTexelValues.y),
                         min(depthTexelValues.z, depthTexelValues.w));

    // Incorporate additional texels if the previous level's width or height (or both) 
    // are odd. 
	bool shouldIncludeExtraColumnFromPreviousLevel = ((u_previousLevelDimensions.x & 1) != 0);
	bool shouldIncludeExtraRowFromPreviousLevel = ((u_previousLevelDimensions.y & 1) != 0);
	if (shouldIncludeExtraColumnFromPreviousLevel) {
		vec2 extraColumnTexelValues;
		extraColumnTexelValues.x = texelFetch(u_depthBuffer,
                                              previousLevelBaseTexelCoord + ivec2(2, 0),
                                              u_previousLevel).r;
		extraColumnTexelValues.y = texelFetch(u_depthBuffer,
                                              previousLevelBaseTexelCoord + ivec2(2, 1),
                                              u_previousLevel).r;

		// In the case where the width and height are both odd, need to include the 
        // 'corner' value as well. 
		if (shouldIncludeExtraRowFromPreviousLevel) {
			float cornerTexelValue = texelFetch(u_depthBuffer,
                                                previousLevelBaseTexelCoord + ivec2(2, 2),
                                                u_previousLevel).r;
			minDepth = min(minDepth, cornerTexelValue);
		}
		minDepth = min(minDepth, min(extraColumnTexelValues.x, extraColumnTexelValues.y));
	}
	if (shouldIncludeExtraRowFromPreviousLevel) {
		vec2 extraRowTexelValues;
		extraRowTexelValues.x = texelFetch(u_depthBuffer,
                                           previousLevelBaseTexelCoord + ivec2(0, 2),
                                           u_previousLevel).r;
		extraRowTexelValues.y = texelFetch(u_depthBuffer,
                                           previousLevelBaseTexelCoord + ivec2(1, 2),
                                           u_previousLevel).r;
		minDepth = min(minDepth, min(extraRowTexelValues.x, extraRowTexelValues.y));
	}

	gl_FragDepth = minDepth;
}

इस कोड में पंजे

सबसे पहले, पूर्ण रिज़ॉल्यूशन की गहराई बफ़र्स के मामले में, जिसके लिए एक आयाम दूसरे आयाम के आकार से दो गुना से अधिक है, कॉल इंडेक्स texelFetchपरे जा सकते हैं u_depthBuffer। (ऐसे मामलों में, छोटा आयाम दूसरे से पहले 1 में बदल जाता है।) मैं इस उदाहरण texelFetch(पूर्णांक निर्देशांक का उपयोग करके) का उपयोग करना चाहता था ताकि जो हो रहा था वह जितना संभव हो उतना स्पष्ट हो, और व्यक्तिगत रूप से ऐसे विशेष रूप से विस्तृत / उच्च गहराई वाले बफ़र्स का सामना न करें। यदि आप ऐसी समस्याओं का सामना करते हैं, तो आप clampप्रसारित texelFetchनिर्देशांक को सीमित कर सकते हैं या textureबनावट के सामान्यीकृत निर्देशांक का उपयोग कर सकते हैं ( नमूना में, किनारे पर एक सीमा निर्धारित करें)। गणना करते समय minया maxसीमा रेखा के मामलों की उपस्थिति के लिए हमेशा एक टेक्सल पर विचार करना चाहिए।

दूसरे, इस तथ्य के बावजूद कि पहले चार कॉल texelFetchको एक के साथ बदला जा सकता है textureGather, यह चीजों को जटिल करता है (चूंकि textureGatherएमआईपी स्तर को इंगित नहीं किया जा सकता है); इसके अलावा, मैंने उपयोग करते समय गति में वृद्धि पर ध्यान नहीं दिया textureGather।

प्रदर्शन

मैंने अपने वीआर इंजन में दो (एक आंख के लिए एक) गहराई बफ़र्स के लिए दो पूर्ण एमआईपी चेन उत्पन्न करने के लिए ऊपर के टुकड़े टुकड़े करने वाले का उपयोग किया। परीक्षण में, प्रत्येक आंख के लिए संकल्प 1648x1776 था, जिसके कारण 10 अतिरिक्त कम मील स्तरों (जिसका अर्थ है 10 पास) का निर्माण हुआ। यह NVIDIA GTX 980 पर 0.25 एमएस और AMD R9 290 पर दोनों आंखों के लिए एक पूर्ण श्रृंखला बनाने के लिए ले लिया।

Mip- 4, 5 6, , . ( , , , .) Mip- 4 — , (103x111) 2.

mip-

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

ध्यान दें, पिछले एक की तरह, यह वैकल्पिक विधि पूर्ण रिज़ॉल्यूशन बफ़र्स के साथ काम करने के लिए डिज़ाइन की गई है जिनके आकार दो की शक्तियां नहीं हैं (लेकिन, निश्चित रूप से, वे दो की शक्तियों के बराबर आकार के साथ काम करते हैं)।

इस वैकल्पिक विधि में, जब प्रत्येक आउटपुट टेक्सेल को जोड़ने के बजाय एक विषम चौड़ाई (या ऊँचाई) के स्तर को नीचे ले जाता है, तो पिछले (निचले) स्तर के टेक्सल्स का एक अतिरिक्त कॉलम (या पंक्ति), हम केवल अधिकतम सूचकांकों ("चरम" टेक्सल्स के आउटपुट टेक्सल्स के लिए यह ऑपरेशन करते हैं) ) केवल एक चीज जो ऊपर प्रस्तुत किए गए टुकड़े shader में बदलती है, मान सेट कर रही है shouldIncludeExtraColumnFromPreviousLevelऔर shouldIncludeExtraRowFromPreviousLevel:

// If the previous level's width is odd and this is the highest-indexed "edge" texel for 
// this level, incorporate the rightmost edge texels from the previous level. The same goes 
// for the height. 
bool shouldIncludeExtraColumnFromPreviousLevel =
    (previousMipLevelBaseTexelCoords.x == u_previousLevelDimensions.x - 3);
bool shouldIncludeExtraRowFromPreviousLevel =
    (previousMipLevelBaseTexelCoords.y == u_previousLevelDimensions.y - 3);

इस वजह से, उच्चतम सूचकांक वाले चरम टेक्सल्स बहुत "मोटे" हो जाते हैं, क्योंकि प्रत्येक विभाजन में 2 विषम आयाम इस तथ्य की ओर ले जाते हैं कि वे सामान्यीकृत बनावट के समन्वित अंतरिक्ष के अनुपात में बड़े अंतराल पर कब्जा कर लेते हैं।

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

नीचे दिया गया कोड स्निपेट NDC स्पेस से माइग्रेट हो रहा है

[- 1, 1]^{2}

$[-1, 1]^2$ MIP स्तर पर Texel निर्देशांक के लिए higherMipLevel:

vec2 windowCoords = (0.5 * ndc.xy + vec2(0.5)) * textureSize(u_depthBuffer, 0);
// Account for texel centers being halfway between integers. 
ivec2 texelCoords = ivec2(round(windowCoords.xy - vec2(0.5)));
ivec2 higherMipLevelTexelCoords =
    min(texelCoords / (1 << higherMipLevel),
        textureSize(u_depthBuffer, higherMipLevel).xy - ivec2(1));

तकनीक 2: एक कंप्यूटिंग हाइडर का उपयोग करके एक एकल हाय-जेड स्तर उत्पन्न करें

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

अधिकांश हाय-जेड अनुप्रयोगों में, केवल एक गहराई स्तर की आवश्यकता होती है, इसलिए मुझे यह स्थिति सामान्य लगती है। मैंने अपनी विशिष्ट आवश्यकताओं के लिए एक संगणक shader लिखा (स्तर 4 का निर्माण, जिसका मूल से 1/16 x 1/16 का रिज़ॉल्यूशन है)। विभिन्न स्तरों को उत्पन्न करने के लिए समान कोड का उपयोग किया जा सकता है।

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

मैंने कम्प्यूटेशनल शेड्स के आधार पर दो मुख्य समाधानों की कोशिश की। पहले में, प्रत्येक थ्रेड को atomicMinएक साझा मेमोरी चर के लिए बुलाया गया था ।

कृपया ध्यान दें कि चूंकि प्रोग्रामर (किसी विशेष निर्माता के हार्डवेयर के लिए एक्सटेंशन के बिना) गैर-पूर्णांक मानों (और मेरी गहराई के रूप में संग्रहीत float) पर परमाणु संचालन कर सकते हैं , यहां कुछ चाल की आवश्यकता है। चूंकि IEEE 754 मानक के गैर-नकारात्मक फ्लोटिंग पॉइंट मान अपने ऑर्डर को बनाए रखते हैं जब उनके बिट्स को अहस्ताक्षरित पूर्णांक मानों के रूप में संसाधित किया जाता है, हम floatBitsToUintगहराई मानों floatको लाने के लिए (फिर से इंटरप्रिट का उपयोग करके) का उपयोग कर सकते हैं uint, और फिर कॉल कर सकते हैं atomicMin(तब uintBitsToFloatसमाप्त न्यूनतम मूल्य के लिए निष्पादित करें uint)। ।

सबसे स्पष्ट समाधान atomicMin16x16 थ्रेड समूह बनाने के लिए होगा जिसमें प्रत्येक थ्रेड को एक टेक्सल प्राप्त होता है और फिर atomicMinसाझा मेमोरी में एक मूल्य के साथ इसे निष्पादित करता है । मैंने छोटे स्ट्रीम ब्लॉक्स (8x8, 4x8, 4x4, 2x4, 2x2) का उपयोग करके इस दृष्टिकोण की तुलना की, जिसमें प्रत्येक स्ट्रीम को एक टेक्सल क्षेत्र प्राप्त होता है और अपने स्वयं के स्थानीय न्यूनतम की गणना करता है, और फिर कॉल करता है atomicMin।

इन सभी के साथ सबसे तेज परीक्षण किए गए समाधानatomicMinएनवीआईडीआईए और एएमडी दोनों 4x4 स्ट्रीम ब्लॉक के साथ एक समाधान के लिए निकले (जिसमें प्रत्येक स्ट्रीम खुद एक 4x4 टेक्सल एरिया प्राप्त करता है)। मुझे यह समझ में नहीं आया कि यह विकल्प सबसे तेज़ क्यों निकला, लेकिन शायद यह स्वतंत्र प्रवाह में परमाणु संचालन और गणना की प्रतिस्पर्धा के बीच एक समझौता दर्शाता है। यह भी ध्यान देने योग्य है कि 4x4 वर्कग्रुप का आकार प्रति ताना / लहर में केवल 16 धागे का उपयोग करता है (और यह भी 32 या 64 का उपयोग करना संभव है), जो दिलचस्प है। नीचे दिया गया उदाहरण इस दृष्टिकोण को लागू करता है।

उपयोग करने के विकल्प के रूप में, atomicMinमैंने इस सक्रिय रूप से उद्धृत एनवीआईडीआईए प्रस्तुति में प्रयुक्त तकनीकों का उपयोग करते हुए समानांतर कमी करने की कोशिश की। (मूल विचार कार्यसमूह में थ्रेड्स की संख्या के साथ-साथ समान आकार के साझा मेमोरी एरे का उपयोग करना है

\log_{2} (n)

$\log_{2} (n)$ minपूरे कार्य समूह के अंतिम न्यूनतम प्राप्त होने तक प्रत्येक स्ट्रीम के न्यूनतम अंकों की अनुक्रमिक संयुक्त गणना के लिए गुजरता है।)

मैंने समाधान सी के रूप में सभी समान कार्य समूहों के साथ इस समाधान की कोशिश की atomicMin। यहां तक कि एनवीआईडीआईए प्रस्तुति में वर्णित सभी अनुकूलन के साथ, समानांतर कमी समाधान atomicMinमेरे पास आए समाधान की तुलना में थोड़ा (दोनों जीपीयू पर दस जीपीयू के भीतर) धीमा है। इसके अलावा, समाधान atomicMinकोड के संदर्भ में बहुत सरल है।

कोड उदाहरण

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

ivec2 reducedResTexelCoords = texelCoords / ivec2(downscalingFactor);

मेरे मामले में (एमआईपी-स्तर 4 के समकक्ष उत्पन्न करना) downscalingFactor16 है।

जैसा कि ऊपर उल्लेख किया गया है, यह जीएलएसएल कम्प्यूटेशनल शेडर atomicMin4x4 वर्कग्रुप आकारों के साथ एक समाधान को लागू करता है, जहां प्रत्येक धागा पूर्ण रिज़ॉल्यूशन बफर से 4x4 टेक्सल क्षेत्र प्राप्त करता है। परिणामी घटा हुआ मान गहराई बफर minपूर्ण रिज़ॉल्यूशन बफर आकार का 1/16 x 1/16 है (पूर्ण रिज़ॉल्यूशन आकार 16 पूरी तरह से विभाज्य नहीं होने पर गोल)।

uniform sampler2D u_inputDepthBuffer;
uniform restrict writeonly image2DArray u_outputDownsampledMinDepthBufferImage;
// The dimension in normalized texture coordinate space of a single texel in 
// u_inputDepthBuffer. 
uniform vec2 u_texelDimensions;

// Resulting image is 1/16th x 1/16th resolution, but we fetch 4x4 texels per thread, hence 
// the divisions by 4 here. 
layout(local_size_x = 16/4, local_size_y = 16/4, local_size_z = 1) in;

// This is stored as uint because atomicMin only works on integer types. Luckily 
// (non-negative) floats maintain their order when their bits are interpreted as uint (using 
// floatBitsToUint). 
shared uint s_workgroupMinDepthEncodedAsUint;

void main() {
	if (gl_LocalInvocationIndex == 0) {
        // Initialize to 1.0 (max depth) before performing atomicMin's. 
		s_workgroupMinDepthEncodedAsUint = floatBitsToUint(1.0);
	}

	memoryBarrierShared();
	barrier();

	// Fetch a 4x4 texel region per thread with 4 calls to textureGather. 'gatherCoords' 
    // are set up to be equidistant from the centers of the 4 texels being gathered (which 
    // puts them on integer values). In my tests textureGather was not faster than 
    // individually fetching each texel - I use it here only for conciseness. 
    // 
    // Note that in the case of the full-res depth buffer's dimensions not being evenly 
    // divisible by the downscaling factor (16), these textureGather's may try to fetch 
    // out-of-bounds coordinates - that's fine as long as the texture sampler is set to 
    // clamp-to-edge, as redundant values don't affect the resulting min. 

	uvec2 baseTexelCoords = 4 * gl_GlobalInvocationID.xy;
	vec2 gatherCoords1 = (baseTexelCoords + uvec2(1, 1)) * u_texelDimensions;
	vec2 gatherCoords2 = (baseTexelCoords + uvec2(3, 1)) * u_texelDimensions;
	vec2 gatherCoords3 = (baseTexelCoords + uvec2(1, 3)) * u_texelDimensions;
	vec2 gatherCoords4 = (baseTexelCoords + uvec2(3, 3)) * u_texelDimensions;

	vec4 gatheredTexelValues1 = textureGather(u_inputDepthBuffer, gatherCoords1);
	vec4 gatheredTexelValues2 = textureGather(u_inputDepthBuffer, gatherCoords2);
	vec4 gatheredTexelValues3 = textureGather(u_inputDepthBuffer, gatherCoords3);
	vec4 gatheredTexelValues4 = textureGather(u_inputDepthBuffer, gatherCoords4);

	// Now find the min across the 4x4 region fetched, and apply that to the workgroup min 
    // using atomicMin. 
	vec4 gatheredTexelMins = min(min(gatheredTexelValues1, gatheredTexelValues2),
                                 min(gatheredTexelValues3, gatheredTexelValues4));
	float finalMin = min(min(gatheredTexelMins.x, gatheredTexelMins.y),
                         min(gatheredTexelMins.z, gatheredTexelMins.w));
	atomicMin(s_workgroupMinDepthEncodedAsUint, floatBitsToUint(finalMin));

	memoryBarrierShared();
	barrier();

    // Thread 0 writes workgroup-wide min to image. 
	if (gl_LocalInvocationIndex == 0) {
		float workgroupMinDepth = uintBitsToFloat(s_workgroupMinDepthEncodedAsUint);

		imageStore(u_outputDownsampledMinDepthBufferImage,
		           ivec2(gl_WorkGroupID.xy),
                   // imageStore can only be passed vec4, but only a float is stored. 
				   vec4(workgroupMinDepth));
	}
}

प्रदर्शन

मैंने उपर्युक्त कम्प्यूटेशनल शैडर का उपयोग उसी आयाम के साथ पूर्ण रिज़ॉल्यूशन डेप्थ बफ़र को संसाधित करने के लिए किया था जिसका उपयोग पूर्ण मिप श्रृंखला (प्रत्येक आंख के लिए 1648x1776 बफ़र्स) उत्पन्न करने के लिए किया गया था। यह NVIDIA GTX 980 पर 0.12 ms और AMD R9 290 पर 0.08 ms चलता है। यदि हम केवल mip के स्तर की पीढ़ी के समय की तुलना करें तो 1-4 (NVIDIA पर 0.22 ms, 0.25 ms AMD)। एक कम्प्यूटेशनल shader के साथ समाधान NVIDIA GPUs के साथ 87% तेजी से निकला और AMD GPU की तुलना में 197% अधिक तेज था ।

पूर्ण शब्दों में, त्वरण इतना बड़ा नहीं है, लेकिन हर 0.1 एमएस महत्वपूर्ण है, विशेष रूप से वीआर में :)

पदानुक्रमित गहराई

संक्षिप्त समीक्षा

परिचय

मेरा आवेदन: एक कम्प्यूटेशनल shader में कणों का प्रतिपादन

तकनीक 1: एक पूरी Mip श्रृंखला का निर्माण

कोड उदाहरण

इस कोड में पंजे

प्रदर्शन

mip-

तकनीक 2: एक कंप्यूटिंग हाइडर का उपयोग करके एक एकल हाय-जेड स्तर उत्पन्न करें

कोड उदाहरण

प्रदर्शन

More articles: