OpenGLES 2.0 tampons séparés pour les sommets, les couleurs et les coordonnées de texture

J'ai été à l'apprentissage d'OpenGL pour quelques jours en suivant des tutoriels et de codage de certaines expériences de ma propre. Mais il y a une chose que je ne comprends vraiment pas ce qui me bloque de le poursuivre. J'ai cherché sur google pour quelques heures maintenant et n'ai pas trouvé encore de réponse à ma question.

Où dois-je spécifier toutes les valeurs de couleur et de coordonnées de texture pour chaque vertex? Si ces propriétés toujours dans le même tableau (struct) que les positions des sommets? Comme:

const Vertex Vertices[] = {
    //Front
    {{1, -1, 0}, {1, 0, 0, 1}, {TEX_COORD_MAX, 0}},
    {{1, 1, 0}, {0, 1, 0, 1}, {TEX_COORD_MAX, TEX_COORD_MAX}},
    {{ -1, 1, 0}, {0, 0, 1, 1}, {0, TEX_COORD_MAX}},
    {{ -1, -1, 0}, {0, 0, 0, 1}, {0, 0}},

    ...

Ou est-il un moyen de mettre de la couleur des valeurs et des coordonnées de texture dans des tableaux distincts? Mais alors la question se pose: comment dois-je appeler glDrawElements avec des tableaux distincts?

Dans le cas où vous vous demandez pourquoi je veux séparer ces valeurs: je suis en train de faire mon propre .obj analyseur en obj-c et je me demandais: que faire si vous chargez un modèle sans texture, et que vous souhaitez uniquement afficher une couleur sur l'objet? Ou: si vous souhaitez charger un modèle avec seulement une texture mappée à elle, mais pas de couleur par sommet? Et: N'est-ce pas mettre les valeurs de la couleur et de la texture de coordonner les ballonnements le Sommet struct avec trop de données.

source d'informationauteur polyclick

En fait c'est la façon habituelle de séparer le vertex dans la position, la couleur, etc. l'utilisation de plusieurs tableaux/tampons.

Dernière fois que je suis venu en contact avec ES 2.0 est dans le cadre de WebGL (qui est un peu différent en spec, mais est finalement basé sur ES 2.0).

Ce qui est fait est d'écrire les données pour séparer les tampons à l'aide de

glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), positions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), colors, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);

...

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(ushort), indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

avec les positions et les couleurs flottent des tableaux contenant les vertex et les indices contenant les indices comme unsigned short dans ce cas.

De rendre ces données, vous devez utiliser les tampons et attribut des pointeurs vers votre shader:

glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexAttribPointer(vertexPositionAttribute, 3,  GL_FLOAT, false, 0, 0);

glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glVertexAttribPointer(vertexColorAttribute, 4, GL_FLOAT, false, 0, 0);

Enfin lier l'index de la mémoire tampon:

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

et de rendu:

glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, 0);

Pour obtenir les attributs:

glUseProgram(shaderProgram);

vertexPositionAttribute= glGetAttribLocation(shaderProgram, "vertexPosition");
glEnableVertexAttribArray(vertexPositionAttribute);

vertexColorAttribute = glGetAttribLocation(shaderProgram, "vertexColor");
glEnableVertexAttribArray(vertexColorAttribute );

...

Si vous n'avez pas personnalisé shaders(à l'aide de fonction fixe), vous pourriez être en mesure d'utiliser

glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexPointer(3,  GL_FLOAT, false, 0, 0);

glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glColorPointer(4, GL_FLOAT, false, 0, 0);

à la place. Je vous le déconseille, même si, comme il est obsolète (si disponible dans ES 2.0).
Si vous voulez continuer à l'utiliser, vous pouvez sauter toute la mémoire tampon entreprise tout à fait et l'utilisation

glVertexPointer(3, GL_FLOAT, false, 0, positions);
glColorPointer(4, GL_FLOAT, false, 0, colors);

avec

glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, indices);

J'espère que ce n'était pas trop compliqué et aide un peu. Pour plus de lecture, bien ciblées à OpenGL, je vous suggère de le Nehe tutoriels.

2

Vous pouvez bien sûr de vos données dans différents tampons. Gardez à l'esprit que c'est la glVertexAttribPointer appel qui détermine un attribut source. Donc, pour utiliser un autre tampon pour un attribut, juste lier un autre GL_ARRAY_BUFFER avant d'appeler glVertexAttribPointer. glDrawElements n'a rien à faire avec lui:
```
glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
glVertexAttribPointer(0, ...);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glVertexAttribPointer(1, ...);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glDrawElements(...);

glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
```
Lorsque vous n'utilisez pas des Organisations sises à vienne (dont je ne suis pas sûr, c'est possible dans ES 2.0), il suffit d'appeler glVertexAttribPointer avec un tableau différent pour chaque attribut:
```
glVertexAttribPointer(0, ..., positionArray);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, ..., colorArray);
glEnableVertexAttribArray(1);

glDrawElements(..., indexArray);

glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
```
Mais il est généralement plus performant pour garder un seul sommet attributs de l'ensemble comme dans votre exemple, c'est plus de cache sympathique. Si presque tous vos objets d'utiliser tous les tableaux, puis de les maintenir ensemble et il suffit de ne pas permettre à l'attribut pour les quelques objets qui ne les utilisent pas, peut-être une meilleure idée. Mais si les attributs sont vraiment différents d'objet à objet, la seconde solution tampon peut être une meilleure idée. Vous pouvez également stocker toutes attribut distinct des tableaux les uns après les autres dans un seul VBO et utilisation correspondante de la mémoire tampon de décalage de la glVertexAttribPointer appels, si vous avez encore besoin d'une seule VBO par objet.

Mais bien sûr, vous ne pouvez utiliser qu'un indice de tableau par objet et non pas d'index différents tableaux pour les postes et les couleurs. Cela peut vous obliger à post-traiter les données lues à partir d'un fichier OBJ, un peu, comme des fichiers OBJ peut en effet utiliser des indices différents pour les postes, les normales et texCoords.

Vous pouvez les séparer en sous-tampons mais si vous les utilisez, alors vous devez avoir pour tous les sommets et si vous vous utilisez l'index-tampons alors vous devez utiliser un index-tampon pour tous (la position, la couleur, texcoord, etc). Voici quelques extraits de mon code:

répartition

glBindBuffer(GL_ARRAY_BUFFER, mId);
glBufferData(GL_ARRAY_BUFFER,
               mMaxNumberOfVertices * (mVertexBlockSize + mNormalBlockSize + mColorBlockSize + mTexCoordBlockSize),
               0,
               mDrawMode);

remplir avec

glBufferSubData(GL_ARRAY_BUFFER, mVertexOffset, numberOfVertsToStore * mVertexBlockSize, vertices);
glBufferSubData(GL_ARRAY_BUFFER, mNormalOffset, numberOfVertsToStore * mNormalBlockSize, normals);
glBufferSubData(GL_ARRAY_BUFFER, mColorOffset, numberOfVertsToStore * mColorBlockSize, colors);
glBufferSubData(GL_ARRAY_BUFFER, mTexCoordOffset, numberOfVertsToStore * mTexCoordBlockSize, texCoords);

et d'utilisation (je ne pense pas que changer constamment clientStates est le plus pratique tout de même)

void Vbo::draw(GLenum primMode)
{
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(mVertexComponents, GL_FLOAT, 0, (void*)mVertexOffset);

  if(mNormalBlockSize){
    glEnableClientState(GL_NORMAL_ARRAY);
    glNormalPointer(GL_FLOAT, 0, (void*)mNormalOffset);
  }
  if(mColorBlockSize){
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(mColorComponents, GL_FLOAT, 0, (void*)mColorOffset);
  }
  if(mTexCoordBlockSize){
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(mTexCoordComponents, GL_FLOAT, 0, (void*)mTexCoordOffset);
  }

  if (mAttachedIndexBuffer)
  {
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mAttachedIndexBuffer);
    glDrawElements(primMode,
                   mAttachedIndexBuffer->getNumberOfStoredIndices(),
                   mAttachedIndexBuffer->getDataType(),
                   0);
  }
  else
  {
    glDrawArrays(primMode, 0, mNumberOfStoredVertices);
  }

  if(mTexCoordBlockSize)
  {
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  }
  if(mColorBlockSize)
  {
    glDisableClientState(GL_COLOR_ARRAY);
  }
  if(mNormalBlockSize)
  {
    glDisableClientState(GL_NORMAL_ARRAY);
  }
  glDisableClientState(GL_VERTEX_ARRAY);
}

Vous devez vous connecter pour publier un commentaire.