वर्टेक्स बफर ऑब्जेक्ट्स प्रदर्शन में सुधार क्यों करते हैं?

Question

मेरी बुनियादी समझ से, एक वर्टेक्स बफर ऑब्जेक्ट कुछ इस तरह से काम करता है (छद्म कोड):

आम तौर पर, यदि कोई कहना चाहता था, तो एक वर्ग ड्रा करें, एक लाइन ड्राइंग कमांड जारी कर सकता है।

line (0, 0) -> (1, 0)
line (1, 0) -> (1, 1)
line (1, 1) -> (0, 1)
line (0, 1) -> (0, 0)

VBO का उपयोग करना, अगर मैं सही ढंग से समझूं, तो वर्बोज़ को VBO में लोड करूँगा।

define VBO
load (0,0) -> VBO
load (1,0) -> VBO
load (1,1) -> VBO
load (0,1) -> VBO
load (0,0) -> VBO

फिर आप एक ड्राइंग कमांड जारी कर सकते हैं।

draw VBO vertices

जबकि मैं समझता हूं कि वीबीओ कैसे काम करते हैं, मुझे नहीं पता कि वे प्रदर्शन में सुधार क्यों करते हैं।

वे प्रदर्शन में सुधार कैसे करते हैं?

Answer 1

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

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

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

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

Answer 2

दो चरण हैं जो VBO को तत्काल मोड से अधिक कुशल बनाते हैं।

1. तत्काल मोड ( glBegin / glEnd , glVertex * , आदि) का अर्थ है कि प्रत्येक फ्रेम में, आप ड्राइवर को वर्टिकल , स्थिति प्रति विशेषता (स्थिति, सामान्य, रंग आदि) के लिए चम्मच खिलाते हैं, जो तब उन्हें सुधारता है और अंत में भेजता है। GPU के लिए एक कमांड के रूप में पूरे पैकेज। प्रत्येक फ्रेम पर प्रति फंक्शन प्रति कॉल बहुत अधिक होता है।
   (ध्यान दें कि OpenGL 3.0 के बाद से तत्काल मोड को हटा दिया गया है, और 3.2 से पूरी तरह हटा दिया गया है ।)

2. वर्टेक्स एरेज़ ( glDrawArrays , glDrawElements , glVertexPointer , आदि देखें) का उपयोग करके , आप ड्राइवर को एक ही बार में पूरी चीज़ दे सकते हैं और इसे कोने को सुधारने के बोझ से बचा सकते हैं। आप प्रभावी ढंग से पूरे जाल के लिए सिर्फ एक मुट्ठी भर कॉल द्वारा प्रति फ़ंक्शन कॉल की जगह ले रहे हैं। लेकिन आपको अभी भी एक बार एक फ्रेम करने की आवश्यकता है।

3. वर्टेक्स बफर ऑब्जेक्ट , या वीबीओ ( glGenBuffers , glBindBuffer , आदि देखें) एक कदम आगे बढ़ते हैं और GPU की तरफ डेटा संग्रहीत करते हैं: आप इसे केवल एक बार भेजते हैं, और फिर बस इसे एक हैंडल द्वारा देखें। आप प्रत्येक फ्रेम में एक ही डेटा को बार-बार न भेजकर बैंडविड्थ बचाते हैं।

Answer 3

तत्काल मोड इंटरफ़ेस (जैसे पुरानी शैली OpenGL glBegin () / glEnd () / glVertex ()) का उपयोग करके आप प्रभावी रूप से एक समय में ड्राइवर को एक टुकड़ा खिला डेटा ड्रिप कर रहे हैं। इसके बाद डेटा के उस एक टुकड़े को लेना होता है, इसे रिफॉर्मेट करना होता है और इसे हार्डवेयर में पास करना होता है (जिसका मतलब है कि इन दिनों इसे कमांड बफ़र में रखा जाए)।

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

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