Mejores prácticas de OpenGL VAO

Estoy enfrentando un problema que creo que depende de VAO, pero no estoy seguro.

No estoy seguro del uso correcto de un VAO, lo que solía hacer durante la inicialización de GL era un simple

glGenVertexArrays(1,&vao)

seguido de un

glBindVertexArray(vao)

y más tarde, en mi canal de dibujo, llamé glBindBuffer (), glVertexAttribPointer (), glEnableVertexAttribArray () y así sucesivamente ... sin importarme el VAO inicialmente vinculado

¿Es esta una práctica correcta?

Los VAO actúan de manera similar a los VBO y las texturas con respecto a cómo se unen. Tener un solo VAO limitado para toda la duración de su programa no producirá beneficios de rendimiento porque también podría estar renderizando sin VAO en absoluto. De hecho, puede ser más lento dependiendo de cómo la implementación intercepta la configuración de los atributos de vértice a medida que se dibujan.

El objetivo de un VAO es ejecutar todos los métodos necesarios para dibujar un objeto una vez durante la inicialización y eliminar toda la sobrecarga adicional de llamadas a métodos durante el ciclo principal. El punto es tener varios VAO y cambiar entre ellos al dibujar.

En términos de mejores prácticas, así es como debe organizar su código:

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

Esto evita el lío de vincular / desvincular búferes y pasar todas las configuraciones para cada atributo de vértice y lo reemplaza con una sola llamada al método, vinculando un VAO.

No, no es así como se usa VAO. Debe usar VAO de la misma manera que usa VBO o texturas o sombreadores. Primero configúrelo. Y durante el renderizado solo enlazarlos, sin modificarlo.

Entonces con VAO haces lo siguiente:

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(..)
}

Vea también estos enlaces:

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

¿Es esta una práctica correcta?

Sí, esto es perfectamente legal y válido. ¿Esta bien? Bien...

Ha habido algunas pruebas de rendimiento informales sobre este tipo de cosas. Y parece que, al menos en el hardware NVIDIA donde se probó esto, el uso "adecuado" de los VAO (es decir, lo que todos los demás defendían) en realidad es más lento en muchos casos. Esto es especialmente cierto si el cambio de VAO no cambia qué búferes están vinculados.

Hasta donde yo sé, no se han realizado pruebas de rendimiento similares en hardware AMD. En general, a menos que algo cambie con ellos, este es un uso aceptable de los VAO.

La respuesta de Robert anterior funcionó para mí cuando la probé. Por lo que vale aquí es el código, en Go, de usar múltiples objetos de atributo de vértice:

// 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()

Luego, en su bucle principal, puede usarlos como tales:

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)
    }
}

Si desea ver la fuente completa, está disponible como Gist y se deriva de los ejemplos en go-gl:

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

Gracias a todos por las respuestas originales, tenía la misma pregunta que ECrownofFire.