La position actuelle:Accueil du site>Learnopengl Learning Notes - Advanced Data

Learnopengl Learning Notes - Advanced Data

2022-05-15 04:40:36La longueur du vent doit être mesurée.

Données avancées

On est là.OpenGLLes tampons sont largement utilisés pour stocker des données depuis longtemps.Il y a en fait des façons plus intéressantes de manipuler le tampon,Et il y a des façons plus intéressantes d'utiliser la texture pour passer beaucoup de sortie dans l'ombre.Dans cette section,Nous allons discuter de quelques fonctions de tampon plus intéressantes,Et comment utiliser les textures pour stocker de grandes quantités de données(La section texture n'est pas encore terminée).

OpenGLLe tampon dans n'est qu'un objet qui gère un bloc de mémoire spécifique,Il n'y a plus d'autres fonctions.Avant de le lier à une cible tampon(Buffer Target)Heure,C'est nous qui lui donnons un sens.Quand on lie un tampon àGL_ARRAY_BUFFERHeure,C'est un tampon Vertex Array,Mais on peut aussi facilement le lier àGL_ELEMENT_ARRAY_BUFFER.OpenGLUn tampon est stocké en interne pour chaque cible,Et selon les objectifs,Gérer les tampons différemment.

Jusqu'à présent,On a appeléglBufferDataFonction pour remplir la mémoire gérée par l'objet tampon,Cette fonction alloue un morceau de mémoire,Et ajouter des données à cette mémoire.Si on prenddataParamètre défini àNULL,Cette fonction n'attribuera alors que la mémoire,Mais pas de remplissage.C'est là que nous devons réserver(Reserve)Une certaine taille de mémoire,Il sera utile de revenir à ce tampon un peu plus tard pour le remplir.

En plus de remplir le tampon entier avec un seul appel de fonction,Nous pouvons également utiliserglBufferSubData, Remplir une zone spécifique du tampon .Cette fonction nécessite une cible tampon、Un décalage、La taille des données et les données elles - mêmes en tant que paramètres.La différence dans cette fonction est que, Nous pouvons fournir un décalage ,Spécifiez où commencer à remplir ce tampon.Cela nous permet d'insérer ou de mettre à jour une partie de la mémoire tampon.Notez que,Le tampon nécessite suffisamment de mémoire allouée,Donc pour un appel tamponnéglBufferSubDataVous devez d'abord appelerglBufferData.

glBufferSubData(GL_ARRAY_BUFFER, 24, sizeof(data), &data); // Champ d'application: [24, 24 + sizeof(data)]

Une autre façon d'importer des données dans un tampon est,Pointeur pour demander la mémoire tampon,Copier les données directement dans le tampon.Par appelglMapBufferFonctions,OpenGLRenvoie un pointeur de mémoire pour le tampon de liaison actuel,Pour notre fonctionnement:

float data[] = {
    
  0.5f, 1.0f, -0.35f
  ...
};
glBindBuffer(GL_ARRAY_BUFFER, buffer);
// Obtenir un pointeur
void *ptr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
// Copier les données en mémoire
memcpy(ptr, data, sizeof(data));
// N'oubliez pas de direOpenGLNous n'avons plus besoin de ce pointeur
glUnmapBuffer(GL_ARRAY_BUFFER);

Quand on utiliseglUnmapBufferFonctions,Dis - le.OpenGL Après avoir terminé l'opération pointeur ,OpenGL Vous saurez que vous avez terminé . Non cartographié (Unmapping)Après, Le pointeur ne sera plus disponible ,Et siOpenGL Capacité de cartographier avec succès vos données dans un tampon , Cette fonction renvoie GL_TRUE. Si vous voulez cartographier les données directement dans le tampon , Sans le stocker en mémoire temporaire ,glMapBuffer Cette fonction sera utile .Par exemple,, Vous pouvez lire les données du fichier , Et les copier directement dans la mémoire tampon .

Attributs de vertex par lots

En utilisantglVertexAttribPointer, Nous pouvons spécifier la disposition des attributs pour le contenu tampon du tableau Vertex .Dans le tampon Vertex Array,Nous avons décalé les attributs(Interleave)Traitement,C'est - à - dire,Nous allons positionner chaque Vertex、Normal et/Ou les coordonnées de texture sont placées ensemble.Maintenant que nous en savons plus sur les tampons,On pourrait faire autrement.

Ce qu'on peut faire,Emballer les données vectorielles pour chaque type d'attribut(Batch)Pour un grand bloc,Au lieu de les entrelacer.Avec une disposition décalée123123123123C'est différent., Nous utiliserons des lots (Batched)De la façon dont111122223333.

Lors du chargement des données Vertex à partir du fichier,Ce que vous obtenez habituellement est un tableau de localisation、Un tableau normal et/Ou un tableau de coordonnées de texture.Nous avons besoin d'un peu d'effort pour convertir ces tableaux en un grand tableau de données entrelacées.L'utilisation d'une approche par lots serait une solution plus simple, Nous pouvons facilement utiliser glBufferSubDataMise en œuvre de la fonction:

float positions[] = {
     ... }; float normals[] = {
     ... }; float tex[] = {
     ... };
// Remplir le tampon
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(positions), &positions);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(positions), sizeof(normals), &normals);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(positions) + sizeof(normals), sizeof(tex), &tex);

De cette façon, nous pouvons passer directement le tableau des attributs dans son ensemble au tampon,Sans avoir à les traiter à l'avance.Nous pouvons encore les combiner en un grand tableau,RéutiliserglBufferDataPour remplir le tampon,Mais pour ce genre de travail,UtiliserglBufferSubDataCe serait plus approprié.

Nous devons également mettre à jour le pointeur d'attribut Vertex pour refléter ces changements :

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);  
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)(sizeof(positions)));  
glVertexAttribPointer(
  2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)(sizeof(positions) + sizeof(normals)));

Cela nous donne une autre façon de définir les propriétés du Vertex . Aucune des méthodes utilisées n'est correcte OpenGL Quels sont les avantages immédiats , C'est juste une façon plus propre de définir les propriétés du Vertex . La méthode utilisée dépendra entièrement de vos préférences et du type de programme .

Copier le tampon

Quand votre tampon sera rempli de données,Vous voudrez peut - être partager les données avec d'autres tampons,Ou vous voulez copier le contenu du tampon dans un autre tampon.glCopyBufferSubDataIl est relativement facile de copier des données d'un tampon à un autre.Le prototype de cette fonction est le suivant:

void glCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset,GLintptr writeoffset, GLsizeiptr size);

readtargetEtwritetargetLe paramètre doit remplir les cibles tamponnées de la source de réplication et de la destination de réplication.Par exemple,,Nous pouvonsVERTEX_ARRAY_BUFFERTampon copié surVERTEX_ELEMENT_ARRAY_BUFFERTampon,Définissez ces cibles tamponnées aux cibles de lecture et d'écriture respectivement.Les tampons actuellement liés à ces cibles tampons seront affectés par.

Mais que se passe - t - il si nous voulons que les deux tampons différents des données de lecture et d'écriture soient tamponnés pour le tableau Vertex ?Nous ne pouvons pas lier deux tampons à la même cible de tampon en même temps.C'est pour ça que,OpenGLDeux autres cibles tampons,AppeléGL_COPY_READ_BUFFEREtGL_COPY_WRITE_BUFFER.Nous pouvons ensuite lier les tampons requis à ces deux cibles tamponnées,Et de prendre ces deux objectifs commereadtargetEtwritetargetParamètres.

Et puis...glCopyBufferSubDataÇa vient dereadtargetLire danssizeTaille des données,Et l'écrirewritetargetTamponnéwriteoffsetÀ l'offset.L'exemple suivant montre comment copier deux tampons Vertex Array:

float vertexData[] = {
     ... };
glBindBuffer(GL_COPY_READ_BUFFER, vbo1);
glBindBuffer(GL_COPY_WRITE_BUFFER, vbo2);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, sizeof(vertexData));

On peut aussi justewritetargetLe tampon est lié à l'un des nouveaux types de cibles de tampon:

float vertexData[] = {
     ... };
glBindBuffer(GL_ARRAY_BUFFER, vbo1);
glBindBuffer(GL_COPY_WRITE_BUFFER, vbo2);
glCopyBufferSubData(GL_ARRAY_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, sizeof(vertexData));

Avec ces connaissances supplémentaires sur le fonctionnement du tampon , Nous avons pu les utiliser d'une manière plus intéressante . Quand vous allez plus loin OpenGLHeure, Ces nouveaux tampons deviendront plus utiles .

Résumé des points de connaissance:

1.glBufferSubData Peut être utilisé pour remplir la zone tampon
2.glMapBuffer La fonction peut demander la mémoire tampon , Copier les données directement dans le tampon .Je m'en souviens.glUnmapBuffer Pointeur tampon .
3. Vous pouvez traiter les données par lots ou passer un tableau d'attributs dans son ensemble au tampon (AdoptionglBufferSubDataRemplir le tampon,Et utiliserglVertexAttribPointerBIND)
4.Peut être utiliséglCopyBufferSubData Copier les données tamponnées dans un autre tampon

https://learnopengl-cn.github.io/04%20Advanced%20OpenGL/07%20Advanced%20Data/

Mentions de copyright
Auteur de cet article [La longueur du vent doit être mesurée.],Réimpression s’il vous plaît apporter le lien vers l’original, merci
https://fra.chowdera.com/2022/135/202205142159252773.html

Recommandé au hasard