ओपनजीएल

Question

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

मैंने पहले कुछ तत्काल मोड ओपनएल किया है, लेकिन अब इसे वीबीओ के पक्ष में हटा दिया गया है। वीबीओ के सभी उदाहरण मैं प्रत्येक बिंदु के स्टोर XYZ निर्देशांक पा सकते हैं।

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

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

क्या यह भी संभव है? क्या आप किसी भी नमूना कोड के बारे में जानते हैं जो यह करता है? या आप कम से कम मुझे कुछ छद्म कोड दे सकते हैं कि जीएल किस क्रम में कॉल करने के लिए काम करता है?

धन्यवाद!

संपादित करें: यकीन है कि यह स्पष्ट है करने के लिए यहां बराबर तत्काल मोड कोड है, और शिखर सरणी कोड:

// immediate 
glBegin(GL_LINE_STRIP); 
for(int i = 0; i < N; ++i) 
    glVertex2(i, y[i]); 
glEnd(); 

// vertex array 
struct { float x, y; } v[N]; 
for(int i = 0; i < N; ++i) { 
    v[i].x = i; 
    v[i].y = y[i]; 
} 
glVertexPointer(2, GL_FLOAT, 0, v); 
glDrawArrays(GL_LINE_STRIP, 0, N); 

ध्यान दें कि v[] दो बार y[] का आकार है।

Answer 1

ओपनजीएल के लिए यह बिल्कुल ठीक है।

वर्टेक्स बफर ऑब्जेक्ट्स (वीबीओ) जीएल समर्थित प्रारूप में से किसी एक में इच्छित जानकारी संग्रहीत कर सकता है। आप के साथ बस एक ही एक VBO भर सकते हैं समन्वय:

glGenBuffers(1, &buf_id); 
glBindBuffer(GL_ARRAY_BUFFER, buf_id); 
glBufferData(GL_ARRAY_BUFFER, N*sizeof(float), data_ptr, GL_STATIC_DRAW); 

और फिर एक ड्रॉ के लिए उचित शिखर विशेषता प्रारूप बाँध:

glBindBuffer(GL_ARRAY_BUFFER, buf_id); 
glEnableVertexAttribArray(0); // hard-coded here for the sake of example 
glVertexAttribPointer(0, 1, GL_FLOAT, false, 0, NULL); 

आदेश में इसका इस्तेमाल करने के लिए आपको एक सरल शेडर कार्यक्रम की आवश्यकता होगी ।शेडर कार्यक्रम से जोड़ने से पहले

#version 130 
in float at_coord_Y; 

void main() { 
    float coord_X = float(gl_VertexID); 
    gl_Position = vec4(coord_X,at_coord_Y,0.0,1.0); 
} 

, यदि आपके पास बाध्य करना चाहिए यह विशेषता सूचकांक आप इस्तेमाल करेंगे करने के लिए at_coord_Y है (= मेरी कोड में 0): शीर्ष शेडर की तरह लग सकता है

glBindAttribLocation(program_id,0,"at_coord_Y"); 

वैकल्पिक रूप से, आप सूचकांक जो करने के लिए इस विशेषता स्वचालित रूप से सौंपा गया था के लिए लिंक करने के बाद कार्यक्रम पूछ सकते हैं और फिर इसे का उपयोग करें:

const int attrib_pos = glGetAttribLocation(program_id,"at_coord_Y"); 

गुड लक!

Answer 2

क्या आप वीआरएएम में दस लाख एक्सवाई निर्देशांक स्टोर करेंगे?

मैं आपको उन निर्देशांकों को सीपीयू पर गणना करने का सुझाव दूंगा, और उन्हें शेडर पाइपलाइन को वर्दी के रूप में पास करने का सुझाव दूंगा (क्योंकि समन्वयित चित्रों को निर्देशित किया गया है)।

इसे सरल रखें।