2 डी प्रतिपादन के लिए गहराई बफर के पूर्ण संकल्प का उपयोग करना


9

मैं ऑर्थोग्राफिक प्रोजेक्शन का उपयोग करके 2 डी इंजन के लिए फ्रंट-टू-बैक रेंडरर पर काम कर रहा हूं। मैं ओवरड्रॉ से बचने के लिए गहराई बफर का उपयोग करना चाहता हूं। मेरे पास 16-बिट डेप्थ बफर है, Z = 100 पर एक कैमरा Z = 0, zNear 1 है, और zFar 1000 देख रहा है। प्रत्येक स्प्राइट रेंडर अपने Z को-ऑर्डिनेट्स को तेजी से दूर होने वाले मानों पर सेट करता है, जिससे गहराई परीक्षण को रेंडर करने की अनुमति मिलती है जो कुछ भी नीचे है।

हालाँकि मुझे पता है कि Z बफ़र मान के साथ Z स्थिति समाप्त होने का तरीका गैर-रैखिक है। मैं 16 बिट गहराई बफ़र के पूर्ण रिज़ॉल्यूशन का उपयोग करना चाहता हूं, अर्थात 65536 अद्वितीय मूल्यों की अनुमति देता हूं। इसलिए प्रत्येक स्प्राइट के लिए, मैं Z की स्थिति को अगले अद्वितीय गहराई बफ़र मूल्य से संबंधित करने के लिए Z स्थिति को बढ़ाना चाहता हूं।

दूसरे शब्दों में, मैं एक वृद्धिशील अनुक्रमणिका (0, 1, 2, 3 ...) को मोड़ना चाहता हूं, ताकि प्रत्येक स्प्राइट के लिए उपयुक्त जेड स्थिति में एक अद्वितीय गहराई बफर मान हो। मुझे इसके पीछे के गणित पर यकीन नहीं है। यह करने के लिए गणना क्या है?

नोट मैं WebGL (मूल रूप से OpenGL ES 2) में काम कर रहा हूं, और मुझे हार्डवेयर की एक विस्तृत श्रृंखला का समर्थन करने की आवश्यकता है, इसलिए जबकि gl_FragDepth जैसे एक्सटेंशन इसे आसान बना सकते हैं, मैं इसे संगतता कारणों से उपयोग नहीं कर सकता।


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

@MattEsch: यह विचार यह है कि उन सभी गणनाओं को GPU में धमाकेदार उच्च गति पर किया जाता है, इसलिए ऐसा करने का कोई मतलब नहीं है।
पांडा पजामा

@MattEsch: FWIW इसका उद्देश्य इंटेल इंटीग्रेटेड जीपीयू है, जो समर्पित GPU मेमोरी के बजाय सिस्टम मेमोरी का उपयोग करता है। यह उन्हें बहुत धीमी गति से और बहुत सारे स्प्राइट्स को ओवरड्राईड करने के लिए दर-दर की सीमा को मारने के लिए उत्तरदायी बनाता है। इंटेल ने इस दृष्टिकोण को मेरे आसपास काम करने के तरीके के रूप में सुझाया। संभवतः गहराई परीक्षण के उनके कार्यान्वयन को अच्छी तरह से अनुकूलित किया गया है और बहुत सारे भराव दर को बचा सकता है। हालांकि यह देखा जाना बाकी है, मैंने इसे अभी तक नहीं देखा है!
एशलेब्रेन

@ PandaPajama ब्लॉक कॉपी मेमोरी वास्तव में बहुत तेज़ है, इसलिए यदि आप केवल एक सतह पर बनावट को ब्लिट कर रहे थे तो यह वास्तव में बहुत तेज़ होगा। पहले प्रमुख ओवरहेड को पहले स्थान पर GPU पर डेटा मिल रहा है, जैसा कि एशले बताते हैं कि एकीकृत GPU पर अधिक महंगा हो सकता है। आप पाते हैं कि बहुत सारे 3 डी गेम सीपीयू पर काम नहीं करते हैं (जैसे हड्डी एनीमेशन), क्योंकि पहली बार में उन मैट्रिक्स कंप्यूटेशन को करने के लिए आवश्यक डेटा अपलोड करना बहुत महंगा है।
मैट एश

@MattEsch: केवल इतना है कि आप सिर्फ ब्लटिंग कर सकते हैं। रोटेशन, स्केलिंग और विकृतियाँ दिमाग में आती हैं, लेकिन जब से आपके पास पिक्सेल / वर्टेक्स शेड्स हैं, तो आप हार्डवेयर के साथ जो कर सकते हैं उसकी सीमा केवल ब्लटिंग के साथ जो आप कर सकते हैं उससे बहुत अधिक है।
पांडा पायजामा

जवाबों:


5

वास्तव में, z- बफर में संग्रहीत मान आपकी वस्तुओं के वास्तविक z निर्देशांक के लिए रैखिक नहीं हैं, लेकिन उनके पारस्परिक के लिए, जो कि पीछे के विमान के करीब है की तुलना में आंख के पास अधिक संकल्प देने के लिए।

तुम क्या है कि आप अपने नक्शा है zNearकरने के लिए 0और अपने zFarलिए 1। के लिए zNear=1और zFar=2, यह इस तरह दिखना चाहिए

Zbuffer

इसकी गणना करने का तरीका निम्नलिखित है:

z_buffer_value = k * (a + (b / z))

कहाँ पे

 k = (1 << N), maximum value the Z buffer can store
 N = number of bits of Z precision
 a = zFar / ( zFar - zNear )
 b = zFar * zNear / ( zNear - zFar )
 z = distance from the eye to the object

... और z_buffer_value एक पूर्णांक है।

उपरोक्त समीकरण आपके लिए इस भयानक पृष्ठ के सौजन्य से लाया गया है , जो z- बफ़र्स को बहुत अच्छे तरीके से समझाता है।

तो, zकिसी दिए गए के लिए आवश्यक खोजने के लिए z_buffer_value, हम बस स्पष्ट करते हैं z:

z = (k * b) / (z_buffer_value - (k * a))

जवाब के लिए धन्यवाद! मैं थोड़ा उलझन में हूँ कि आपको अपना अंतिम सूत्र कैसे मिला। यदि मैं ले z_buffer_value = k * (a + (b / z))और बस को हल करने के लिए पुनर्व्यवस्थित z, तो मुझे मिलता है: z = b / ((z_buffer_value / k) - a)- आप अलग-अलग अंतिम सूत्र पर कैसे पहुंचे?
एशलेब्रेन

@AshleysBrain: आप हर लेते हैं (v / k) - a => (v - k * a) / k, और पतन के लिए (k * b) / (v - (k * a))। यह एक ही परिणाम है।
पांडा पायजामा

ओह समझा। उत्तर के लिए धन्यवाद, यह अच्छी तरह से काम कर रहा है!
एशलेब्रेन

0

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

आशा है कि यह मदद कर सकता है। लोग हमेशा मुझसे कहते हैं कि चीजों को सरल रखो।


1
क्षमा करें, यह बहुत मदद नहीं है। मैं पहले से ही ऐसा कर रहा हूं। सवाल इस बात का है कि Z किन पदों को चुनें।
एशलेब्रेन

0

चूंकि आपके पास पहले से ही (सामने से पीछे) रेंडर करने के लिए चीजों की एक क्रमबद्ध सूची है, क्या आपको वास्तव में जेड इंडेक्स बढ़ाने की आवश्यकता है? क्या आप "चेकिंग फंक्शन" के लिए "कम या बराबर" का उपयोग नहीं कर सकते हैं? इस तरह यह वास्तव में जाँच करेगा कि क्या एक विशिष्ट पिक्सेल पहले से ही तैयार था या नहीं।


"कम या बराबर" अभी भी पूरी तरह से सब कुछ अधिक होने का कारण होगा, क्योंकि सब कुछ हमेशा एक समान जेड इंडेक्स होगा और इसलिए गहराई परीक्षण पास करेगा।
AshleysBrain
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.