ओपन VAO सर्वोत्तम प्रथाओं

Question

इम एक मुद्दा सामना करना पड़ रहा है जो मुझे VAO पर निर्भर है, लेकिन मैं निश्चित नहीं मानते ..

मैं एक VAO, का सही उपयोग क्या मैं जीएल आरंभीकरण के दौरान करते थे के बारे में निश्चित नहीं हूँ एक सरल

glGenVertexArrays(1,&vao) 

एक

glBindVertexArray(vao) 

के बाद किया गया और बाद में, मेरी ड्राइंग पाइप लाइन में, मैं सिर्फ glBindBuffer(), glVertexAttribPointer(), glEnableVertexAttribArray (कहा जाता है) और इतने initally बाध्य VAO

यह एक सही व्यवहार है के बारे में देखभाल के बिना पर ..?

Answer 1

VAOs के संबंध में VBOs और बनावट की तरह ही काम करते हैं वे कैसे बंधे हैं। एक भी VAO अपने कार्यक्रम कोई प्रदर्शन लाभ निकलेगा क्योंकि आप के रूप में अच्छी बस सब पर VAOs बिना प्रतिपादन हो सकता है की पूरी लंबाई के लिए बाध्य करने के बाद। वास्तव में यह धीमी कैसे कार्यान्वयन अवरोध शिखर सेटिंग्स विशेषता के रूप में वे तैयार किया जा रहा हो पर निर्भर करता है हो सकता है।

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

initialization: 
    for each batch 
     generate, store, and bind a VAO 
     bind all the buffers needed for a draw call 
     unbind the VAO 

main loop/whenever you render: 
    for each batch 
     bind VAO 
     glDrawArrays(...); or glDrawElements(...); etc. 
    unbind VAO 

यह प्रत्येक शिखर विशेषता के लिए बाध्यकारी/unbinding बफ़र्स और गुजर सभी सेटिंग्स की गंदगी से बचा जाता है और साथ बस एक ही यह बदल देता है:

सबसे अच्छा अभ्यास के संदर्भ में, यहाँ कैसे आप अपने कोड का आयोजन करना चाहिए विधि कॉल, एक वीएओ बाध्यकारी।

Answer 2

नहीं, ऐसा नहीं है कि आप वीएओ का उपयोग कैसे करते हैं। आप उसी तरह तुम कैसे VBO या बनावट, या shaders का उपयोग कर रहे हैं में VAO उपयोग करना चाहिए। पहले इसे स्थापित करें। और प्रतिपादन के दौरान केवल उन्हें संशोधित किए बिना बाध्य करें।

VAO साथ

तो आप निम्नलिखित है:

void Setup() { 
    glGenVertexArrays(..); 
    glBindVertexArray(..); 
    // now setup all your VertexAttribPointers that will be bound to this VAO 
    glBindBuffer(..); 
    glVertexAttribPointer(..); 
    glEnableVertexAttribArray(..); 
} 

void Render() { 
    glBindVertexArray(vao); 
    // that's it, now call one of glDraw... functions 
    // no need to set up vertex attrib pointers and buffers! 
    glDrawXYZ(..) 
} 

भी देखें इन कड़ियों:

• http://www.swiftless.com/tutorials/opengl4/4-opengl-4-vao.html
• http://www.lastrayofhope.com/2011/07/30/using-vertex-array-objects/

Answer 3

क्या यह एक सही अभ्यास है?

हाँ, यह पूरी तरह से कानूनी और वैध है। अच्छी है? खैर ...

वहाँ बात की इस तरह के बारे में कुछ informal performance testing किया गया है। और ऐसा लगता है, कम से कम एनवीआईडीआईए हार्डवेयर पर जहां इसका परीक्षण किया गया था, वीएओ के "उचित" उपयोग (यानी: हर किसी ने वकालत की) वास्तव में धीमी कई मामलों में है। यह विशेष रूप से सच है यदि वीएओ बदलना बदलता नहीं है तो कौन से बफर बंधे हैं।

मेरे ज्ञान के लिए एएमडी हार्डवेयर पर कोई समान प्रदर्शन परीक्षण नहीं हुआ है।आम तौर पर, जब तक उनके साथ कुछ बदलाव नहीं होता है, यह वीएओ का स्वीकार्य उपयोग है।

Answer 4

जब मैंने कोशिश की तो रॉबर्ट का उत्तर मेरे लिए काम करता था। क्या इसे यहाँ लायक है कोड, गो में, कई वर्टेक्स गुण वस्तुओं का उपयोग करने का है:

// VAO 1

vao1 := gl.GenVertexArray() 
vao1.Bind() 

vbo1 := gl.GenBuffer() 
vbo1.Bind(gl.ARRAY_BUFFER) 

verticies1 := []float32{0, 0, 0, 0, 1, 0, 1, 1, 0} 
gl.BufferData(gl.ARRAY_BUFFER, len(verticies1)*4, verticies1, gl.STATIC_DRAW) 

pa1 := program.GetAttribLocation("position") 
pa1.AttribPointer(3, gl.FLOAT, false, 0, nil) 
pa1.EnableArray() 
defer pa1.DisableArray() 

vao1.Unbind() 

// VAO 2 

vao2 := gl.GenVertexArray() 
vao2.Bind() 

vbo2 := gl.GenBuffer() 
vbo2.Bind(gl.ARRAY_BUFFER) 

verticies2 := []float32{-1, -1, 0, -1, 0, 0, 0, 0, 0} 
gl.BufferData(gl.ARRAY_BUFFER, len(verticies2)*4, verticies2, gl.STATIC_DRAW) 

pa2 := program.GetAttribLocation("position") 
pa2.AttribPointer(3, gl.FLOAT, false, 0, nil) 
pa2.EnableArray() 
defer pa2.DisableArray() 

vao2.Unbind() 

फिर अपने मुख्य पाश में आप उन्हें इस तरह के रूप में उपयोग कर सकते हैं:

for !window.ShouldClose() { 
    gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) 

    vao1.Bind() 
    gl.DrawArrays(gl.TRIANGLES, 0, 3) 
    vao1.Unbind() 

    vao2.Bind() 
    gl.DrawArrays(gl.TRIANGLES, 0, 3) 
    vao2.Unbind() 

    window.SwapBuffers() 
    glfw.PollEvents() 

    if window.GetKey(glfw.KeyEscape) == glfw.Press { 
     window.SetShouldClose(true) 
    } 
} 

https://gist.github.com/mdmarek/0f73890ae2547cdba3a7

:

आप पूर्ण स्रोत को देखने के लिए चाहते हैं, यह एक सार के रूप में उपलब्ध है और गो-जीएल में उदाहरण से प्राप्त होता है

मूल उत्तर के लिए सभी को धन्यवाद, मेरे पास ECrownofFire के समान प्रश्न था।