Quel est le rôle de glBindVertexArrays vs glBindBuffer et quelle est leur relation?

Je suis nouveau sur OpenGL et de Programmation Graphique. J'ai lu un livre qui a été très complète et bien écrite jusqu'à présent.Cependant, j'ai atteint un point dans le code que je ne suis pas tout à fait comprendre et je voudrais faire sens de ces lignes avant de me déplacer sur.

GLuint abuffer;

glGenVertexArrays(1, &abuffer);
glBindVertexArray(abuffer);
GLuint buffer;
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

Le livre explique que les trois premières lignes sont en train de créer un vertex array objet, qui est utilisé pour regrouper les données associées avec un vertex array. La deuxième ligne trouve un nom inutilisé (je suppose un entier non signé identifiant stockées dans abuffer) et le troisième ligne crée l'objet /le rend actif.

Le livre explique que la 4ème à la 7ème lignes de la création d'un tampon objet pour stocker nos données, avec la ligne 5 de nous donner un inutilisés identificateur (similaire à la ligne 2 pour le vertex array objet?), la ligne 6 de la création de la mémoire tampon, et la ligne 7 allouer suffisamment de mémoire de la CPU et de la création d'un pointeur de nos données (points) pour GL_STATIC_DRAW.

Ce que signifie il pour que l'objet soit active? Quand vous utilisez ensuite abuffer? Que signifie, pour un sommet de la matrice de regrouper les données associées, et quand les données associées à ce sommet-objet array?

Je suis confus au sujet de la relation entre abuffer et buffer. Je suis confus au sujet de ce que le sommet de la matrice de relation avec le tampon de l'objet, et à quel point cette relation est formée. Je ne suis pas sûr de savoir si elles sont en fait liées, mais elles sont présentées dans le manuel de l'un immédiatement après l'autre.

Toute aide serait appréciée. Merci.

InformationsquelleAutor DashAnimal | 2014-02-08
  1. 127

    À partir d'un faible niveau de point de vue, vous pouvez penser à un tableau de deux parties:

    • D'informations sur la taille, la forme et le type de la matrice (par exemple, 32 bits des nombres à virgule flottante, contenant les lignes de vecteurs avec les quatre éléments).

    • Les données du tableau, qui n'est guère plus qu'un gros blob d'octets.

    Même si le faible niveau du concept a la plupart du temps resté le même, la façon de spécifier les tableaux a changé plusieurs fois au fil des ans.

    OpenGL 3.0 /ARB_vertex_array_object

    C'est la façon dont vous probablement doit être en train de faire des choses aujourd'hui. Il est très rare de trouver des gens qui ne peuvent pas lancer d'OpenGL 3.x et encore reste encore de l'argent à dépenser sur votre logiciel.

    Un tampon d'objet dans OpenGL est un gros blob de bits. Penser à la "actif" de la mémoire tampon comme une variable globale, et il y a un tas de fonctions qui utilisent la mémoire tampon active au lieu d'utiliser un paramètre. Ces variables d'état sont du mauvais côté de l'OpenGL (avant
    directe de l'etat d'accès, qui est traité ci-dessous).

    GLuint buffer;

//Generate a name for a new buffer.
//e.g. buffer = 2
glGenBuffers(1, &buffer);

//Make the new buffer active, creating it if necessary.
//Kind of like:
//if (opengl->buffers[buffer] == null)
//    opengl->buffers[buffer] = new Buffer()
//opengl->current_array_buffer = opengl->buffers[buffer]
glBindBuffer(GL_ARRAY_BUFFER, buffer);

//Upload a bunch of data into the active array buffer
//Kind of like:
//opengl->current_array_buffer->data = new byte[sizeof(points)]
//memcpy(opengl->current_array_buffer->data, points, sizeof(points))
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

    Maintenant, votre typique vertex shader prend sommets en entrée, pas un gros blob de bits. Si vous avez besoin de spécifier comment le blob de bits (le tampon) est décodé en sommets. C'est le travail de la matrice. De même, il y a un "actif" de la matrice de laquelle vous pouvez penser que juste une variable globale:

    GLuint array;
//Generate a name for a new array.
glGenVertexArrays(1, &array);
//Make the new array active, creating it if necessary.
glBindVertexArray(array);

//Make the buffer the active array buffer.
glBindBuffer(GL_ARRAY_BUFFER, buffer);
//Attach the active buffer to the active array,
//as an array of vectors with 4 floats each.
//Kind of like:
//opengl->current_vertex_array->attributes[attr] = {
//    type = GL_FLOAT,
//    size = 4,
//    data = opengl->current_array_buffer
//}
glVertexAttribPointer(attr, 4, GL_FLOAT, GL_FALSE, 0, 0);
//Enable the vertex attribute
glEnableVertexAttribArray(attr);

    OpenGL 2.0 (à l'ancienne)

    En OpenGL 2.x, il n'y avait pas de vertex arrays et les données ont été juste, globale. Vous avez encore dû appeler glVertexAttribPointer() et glEnableVertexAttribArray(), mais vous avez eu à les appeler chaque fois que vous avez utilisé un tampon. Dans OpenGL 3.x, vous venez de configurer le tableau une fois.

    Revenir à OpenGL 1.5, vous pouvez utiliser des tampons, mais vous avez utilisé une fonction distincte de lier chaque type de données. Par exemple, glVertexPointer() était pour le sommet de données, et glNormalPointer() était normale des données. Avant d'OpenGL 1.5, il n'y avait pas de tampons, mais vous pouvez utiliser les pointeurs dans votre mémoire de l'application.

    OpenGL 4.3 /ARB_vertex_attrib_binding

    En 4.3, ou si vous avez la ARB_vertex_attrib_binding extension, vous pouvez spécifier l'attribut format et les données d'attribut séparément. C'est intéressant car il vous permet de basculer facilement d'un vertex array entre les différents tampons.

    GLuint array;
//Generate a name for a new array array.
glGenVertexArrays(1, &array);
//Make the new array active, creating it if necessary.
glBindVertexArray(array);

//Enable my attributes
glEnableVertexAttribArray(loc_attrib);
glEnableVertexAttribArray(normal_attrib);
glEnableVertexAttribArray(texcoord_attrib);
//Set up the formats for my attributes
glVertexAttribFormat(loc_attrib,      3, GL_FLOAT, GL_FALSE, 0);
glVertexAttribFormat(normal_attrib,   3, GL_FLOAT, GL_FALSE, 12);
glVertexAttribFormat(texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 24);
//Make my attributes all use binding 0
glVertexAttribBinding(loc_attrib,      0);
glVertexAttribBinding(normal_attrib,   0);
glVertexAttribBinding(texcoord_attrib, 0);

//Quickly bind all attributes to use "buffer"
//This replaces several calls to glVertexAttribPointer()
//Note: you don't need to bind the buffer first!  Nice!
glBindVertexBuffer(0, buffer, 0, 32);

//Quickly bind all attributes to use "buffer2"
glBindVertexBuffer(0, buffer2, 0, 32);

    OpenGL 4.5 /ARB_direct_state_access

    En OpenGL 4.5, ou si vous avez la ARB_direct_state_access extension, vous n'avez plus besoin d'appeler glBindBuffer() ou glBindVertexArray() juste pour mettre les choses en place... vous spécifiez les tableaux et les tampons directement. Vous avez seulement besoin de lier le tableau à la fin de la dessiner.

    GLuint array;
//Generate a name for the array and create it.
//Note that glGenVertexArrays() won't work here.
glCreateVertexArrays(1, &array);
//Instead of binding it, we pass it to the functions below.

//Enable my attributes
glEnableVertexArrayAttrib(array, loc_attrib);
glEnableVertexArrayAttrib(array, normal_attrib);
glEnableVertexArrayAttrib(array, texcoord_attrib);
//Set up the formats for my attributes
glVertexArrayAttribFormat(array, loc_attrib,      3, GL_FLOAT, GL_FALSE, 0);
glVertexArrayAttribFormat(array, normal_attrib,   3, GL_FLOAT, GL_FALSE, 12);
glVertexArrayAttribFormat(array, texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 24);
//Make my attributes all use binding 0
glVertexArrayAttribBinding(array, loc_attrib,      0);
glVertexArrayAttribBinding(array, normal_attrib,   0);
glVertexArrayAttribBinding(array, texcoord_attrib, 0);

//Quickly bind all attributes to use "buffer"
glVertexArrayVertexBuffer(array, 0, buffer, 0, 32);

//Quickly bind all attributes to use "buffer2"
glVertexArrayVertexBuffer(array, 0, buffer2, 0, 32);

//You still have to bind the array to draw.
glBindVertexArray(array);
glDrawArrays(...);

    ARB_direct_state_access est agréable pour beaucoup de raisons. Vous pouvez oublier sur la liaison des tableaux et des tampons (sauf lorsque vous dessinez) de sorte que vous n'avez pas à réfléchir sur les variables globales que OpenGL est suivi pour vous. Vous pouvez oublier la différence entre "générer un nom pour un objet" et "la création d'un objet" parce que glCreateBuffer() et glCreateArray() faire les deux en même temps.

    Vulkan

    Vulkan va encore plus loin et a vous écrire du code comme le pseudo-code que j'ai écrit ci-dessus. Donc, vous allez voir quelque chose comme:

    //This defines part of a "vertex array", sort of
VkVertexInputAttributeDescription attrib[3];
attrib[0].location = 0; //Feed data into shader input #0
attrib[0].binding = 0;  //Get data from buffer bound to slot #0
attrib[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrib[0].offset = 0;
//repeat for attrib[1], attrib[2]
    • +1 pour la description de GL sélecteur/mécanisme de verrouillage (par exemple le tampon d'objet de l'un des sommets du pointeur s'applique à est prise à partir de la limite de l'objet plutôt que de le passé en paramètre. Cette conception d'API peut être contourné en utilisant GL_EXT_direct_state_access, mais cela ne règle en cours d'exécution de votre code sur Mesa, Intel ou Apple pilotes malheureusement :-\ je pense Cependant qu'il est important de souligner que les Vertex Arrays ont existé depuis GL 1.1. La seule chose qui a changé dans GL 2.0, l'introduction de médicaments génériques vertex attrib machines à sous.
    • En parlant de l'OpenGL 1.1, cette version introduit également la texture objets. Comme les Vertex Array d'Objets, de textures étaient déjà pris en charge dans la GL avant de la Texture des Objets ont été lancés, mais les données/de l'état n'a pas été stocké de façon persistante. Au lieu de changer la limite de la texture de l'objet en OpenGL 1.0, la plupart des logiciel a été écrit pour effectuer la texture de données/de l'état de configuration de l'affichage des listes. GL 3.0 a fait quelque chose de similaire pour les vertex arrays, il introduit vertex array objets.
    • L'amour le contexte historique ici. L'un des plus dieu terriblement frustrant choses sur l'apprentissage GL est comment l'API et les meilleures pratiques ont changé au fil du temps.
    • Pour ton exemple sur OpenGL4.5, ne devriez-vous pas utiliser glCreateVertexArrays(1, &array) sur glGenVertexArrays(1, &array)? À ma connaissance, le vao n'a pas été créé avant de le lier à l'aide de glGenVertexArrays, afin qu'aucun de vos glEnableVertexArray* / glVertexArray* appels de travail?
    • Bonne prise, j'ai révisé pour essayer de faire clairement la différence entre la réalisation d'un nom et la création d'un objet.
    • Agréable et facile de répondre! Merci beaucoup!!!
    • grande réponse. Pouvez-vous expliquer une chose, mais - Vous de mentionner "Rapidement se lier tous les attributs à utiliser "buffer2"", donc avant de DSA, pour changer les attributs d'utiliser un autre tampon, vous auriez lier le vao, et d'appeler glVertexAttribPointer, c'est juste de la liaison à un autre tampon nettement plus rapide (c'est que le bénéfice)? Aussi pourquoi ne pas créer deux liaisons dans le vao et le changement glVertexArrayAttribBinding?
    • Avant ARB_direct_state_access / 4.5 vous pouvez utiliser ARB_vertex_attrib_binding / 4.3, qui est ce qui vous donne glVertexArrayAttribBinding comme vous le mentionnez.
    • Le pseudo-code est un moyen fantastique pour expliquer ce qui se passe derrière le lever du rideau d'appels OpenGL. Donc, bravo pour cela. Aussi, cette phrase, en particulier, a été un grand "a-ha" moment pour moi: Now, your typical vertex shader takes vertexes as input, not a big blob of bits. So you need to specify how the blob of bits (the buffer) is decoded into vertexes.

    InformationsquelleAutor Dietrich Epp
  2. 15

    Votre interprétation du livre n'est pas tout à fait correct. Vertex Array Objets stockent pas de données. Ils sont une classe d'objets connus comme des conteneurs, comme le Framebuffer Objets. Vous pouvez joindre/associer d'autres objets avec eux, mais ils n'ont jamais stocker des données elles-mêmes. En tant que tels, ils ne sont pas un contexte de ressources partageables.

    Fondamentalement Vertex Array Objets encapsulent les vertex array état en OpenGL 3.0. Début avec OpenGL 3.1 (au lieu de GL_ARB_compatibility) et OpenGL 3.2+ Core profils, vous devez avoir une valeur non nulle VAO tenu, à tout moment pour des commandes comme glVertexAttribPointer (...) ou glDrawArrays (...) à la fonction. Le VAO formes le contexte nécessaire pour ces commandes, et les magasins de l'état de façon persistante.

    Dans les anciennes versions de GL (et la compatibilité), l'état stocké par VAOs était une partie de l'état global de la machine.

    Il est également intéressant de mentionner que le "courant" de liaison pour GL_ARRAY_BUFFER est pas l'un des etats qui VAOs piste. Alors que cette liaison est utilisé par des commandes telles que glVertexAttribPointer (...), VAOs ne pas stocker la liaison ils ne font que stocker des pointeurs (le GL_ARB_vertex_attrib_binding extension introduit aux côtés de GL 4.3 complique un peu, alors laissez-nous l'ignorer pour des raisons de simplicité).

    VAOs ne rappelez-vous ce qui est lié à GL_ELEMENT_ARRAY_BUFFER, cependant, de sorte que l'indexation des commandes de dessin tels que glDrawElements (...) fonction de ce que vous pouvez attendre (par exemple VAOs ré-utiliser le dernier élément de la matrice de tampon lié).

    • Pourquoi le glVertexAttribPointer besoin d'un tampon comme GL_ARRAY_BUFFER à être lié? Ne pas le glVertexAttribPointer seulement de l'installation de l'état de l'VAO?
    • établit un pointeur qui est relatif à la mémoire de la propriété par tout ce qui est lié à GL_ARRAY_BUFFER lorsque la fonction est appelée. Honnêtement, il est une sorte de stupide conception d'une API conçue comme D3D, vous venez de passer l'ID de la mémoire tampon de l'objet de la VertexAttribPointer et ne jamais avoir à lier quelque chose. Mais en OpenGL, glVertexPointer (...) existe depuis plus de 10 ans avant d'Organisations ont été introduits, ils ont voulu réutiliser autant de l'API sans modification possible. Ils ont créé cette lier un non-zéro VBO premier business pour éviter d'ajouter un autre paramètre.
    • Merci! Il fait beaucoup plus de sens de penser à la VAO que les pointeurs.
    • Merci de remarquer que liaison pour GL_ARRAY_BUFFER n'est pas l'un des etats qui VAOs piste.
    InformationsquelleAutor Andon M. Coleman
  3. 6

    La relation est créée lors de l'appel de glVertexAttribPointer.

    Quel est le rôle de glBindVertexArrays vs glBindBuffer et quelle est leur relation?

    GL_VERTEX_ARRAY_BINDING et GL_ARRAY_BUFFER_BINDING sont des constantes, mais ils peuvent pointer à l'état global de la liaison. Je fais référence à l'état de ne pas la constante(en orange) dans l'image. Utilisation glGet à trouver sur les différents états globaux.

    VertexArray est le regroupement des informations(y compris le tableau tampon) sur un sommet ou parallèlement de nombreuses sommets.

    Utilisation GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING avec glGetVertexAttrib de trouver l'attribut tableau tampon est définie.

    glBindBuffer(GL_ARRAY_BUFFER définit l'état global GL_ARRAY_BUFFER_BINDING

    glBindVertexArray définit l'état global GL_VERTEX_ARRAY_BINDING

    • Hey, c'est un grand graphe. Avez-vous l'esprit de partage qui en est la source, s'il vous plaît?
    InformationsquelleAutor Jossi
  4. 5

    OpenGL est avec un état de l'interface. C'est mauvais, archaïque et moche, mais c'est l'héritage pour toi.

    Un vertex array objet est une collection de tampon de liaisons que le pilote peut utiliser pour obtenir les données pour le tirage au sort des appels, la plupart des tutoriels utiliser uniquement l'un et de ne jamais expliquer comment utiliser plusieurs VAOs.

    Un tampon de liaison indique à opengl utilisation de la mémoire tampon pour les méthodes connexes, en particulier pour les glVertexAttribPointer méthodes.

    • Certains impressionnante heuristique dans StackOverflow essayé de m'empêcher de faire des compliments vous sur critiquant OpenGL pour son statefulness.
    InformationsquelleAutor ratchet freak
  5. -2

    Il n'y a pas de relation entre VertexArray et VBO.

    Un vertex array alloue de la mémoire dans la RAM et envoie le pointeur à l'API. VBO alloue de la mémoire de la carte graphique - système de la mémoire n'a pas d'adresse pour cela. Si vous avez besoin d'accéder à la vbo données de système, vous devez les copier à partir de vbo pour le premier système.

    Également, dans les plus récentes versions d'OpenGL, vertex arrays sont complètement supprimés (depcrecated dans la version 3.0, enlevé en 3.1)

    • Vertex tableaux ne sont pas supprimés en 3.x. Vertex array objets étaient introduite dans la version 3.0, et obligatoire dans les versions ultérieures de la base du profil.
    • La question était sur le Vertex Array d'Objets, pas de vertex arrays en général. Et même si, vertex tableaux ne sont pas obsolètes, soit. L'API utilisée pour les définir a radicalement changé (pas plus spécialisés VetexPointer, NormalPointer, etc...), mais vertex arrays existent toujours (glVertexAttrib{I|L}Pointer (...) substitut pour des choses comme glVertexPointer (...) moderne GL).
    • J'aurais fait mon point de plus propre et de suppression. oups
    InformationsquelleAutor Gasim