Tout Sur Les Objets OpenGL

Le modèle standard pour les objets OpenGL est le suivant.

Les objets ont un État. Pensez-y comme un struct. Alors vous pourriez avoir un objet défini comme ceci:

struct Object
{
    int count;
    float opacity;
    char *name;
};

L'objet a certaines valeurs stockées dans celui-ci et il a état. Les objets OpenGL ont aussi un État.

Changement D'État

En C / C++, si vous avez une instance de type Object, vous modifierez son état comme suit: obj.count = 5; vous référencerez directement une instance de l'objet, obtenez le morceau d'état particulier que vous voulez changer, et y enfoncer une valeur.

Dans OpenGL, vous ne faites pas cela.

Pour des raisons héritées mieux laissées inexpliquées, pour changer l'état D'un objet OpenGL, vous devez d'abord lier au contexte. Ceci est fait avec certains de glBind* appel.

L'équivalent C/c++ est le suivant:

Object *g_objs[MAX_LOCATIONS] = {NULL};    
void BindObject(int loc, Object *obj)
{
  g_objs[loc] = obj;
}

Les Textures sont intéressantes; elles représentent un cas particulier de reliure. De nombreux appels glBind* ont un paramètre "cible". Cela représente différents emplacements dans le contexte OpenGL où les objets de ce type peuvent être liés. Par exemple, vous pouvez lier un objet framebuffer pour la lecture (GL_READ_FRAMEBUFFER) ou par écrit (GL_DRAW_FRAMEBUFFER). Cela affecte la façon dont OpenGL utilise le tampon. C'est ce que représente le paramètre loc ci-dessus.

Les Textures sont spéciales car lorsque vous les liez d'abord à une cible, elles obtiennent des informations spéciales. Lorsque vous liez d'abord une texture en tant que GL_TEXTURE_2D, Vous sont en train de définir un état spécial dans la texture. Vous dites que cette texture est une texture 2D. Et il sera toujours une texture 2D; cet état ne peut jamais être changé jamais . Si vous avez une texture qui a d'abord été liée en tant que GL_TEXTURE_2D, vous devez toujours la lier en tant queGL_TEXTURE_2D; tenter de la lier en tant que GL_TEXTURE_1D donnera lieu à une erreur (lors de l'exécution).

Une fois l'objet lié, son état peut être modifié. Ceci est fait via des fonctions génériques spécifiques à cela objet. Ils prennent un emplacement qui représente l'objet à modifier.

En C/C++, cela ressemble à:

void ObjectParameteri(int loc, ObjectParameters eParam, int value)
{
  if(g_objs[loc] == NULL)
    return;

  switch(eParam)
  {
    case OBJECT_COUNT:
      g_objs[loc]->count = value;
      break;
    case OBJECT_OPACITY:
      g_objs[loc]->opacity = (float)value;
      break;
    default:
      //INVALID_ENUM error
      break;
  }
}

Notez comment cette fonction définit ce qui se trouve dans la valeur loc actuellement liée.

Pour les objets de texture, les principales fonctions de modification de l'état de texture sont glTexParameter. Les seules autres fonctions qui changent l'état de la texture sont glTexImage fonctions et leurs variations (glCompressedTexImage, glCopyTexImage, le récent glTexStorage). Les différentes versions SubImage modifient le contenu de la texture, mais elles ne changent pas techniquement son état . Les fonctions Image allouent le stockage de texture et définissent le format de la texture; les fonctions SubImage copient simplement les pixels. Cela n'est pas considéré comme l'état de la texture.

Permettez-moi de répéter: ce sont les fonctions uniquement qui modifient l'état de la texture. glTexEnv modifie l'état de l'environnement; il n'affecte rien stocké dans la texture objet.

Texture Active

La situation pour les textures est plus complexe, encore une fois pour des raisons héritées mieux laisser non divulguées. C'est là glActiveTexture vient dans.

Pour les textures, il n'y a pas que des cibles (GL_TEXTURE_1D, GL_TEXTURE_CUBE_MAP, etc). Il y a aussi texture unités . En termes de notre exemple C / C++, ce que nous avons est ceci:

Object *g_objs[MAX_OBJECTS][MAX_LOCATIONS] = {NULL};
int g_currObject = 0;

void BindObject(int loc, Object *obj)
{
  g_objs[g_currObject][loc] = obj;
}

void ActiveObject(int currObject)
{
  g_currObject = currObject;
}

Remarquez que maintenant, nous avons non seulement une 2D liste de Objects, mais nous avons également le concept d'un objet courant. Nous avons un fonction pour définir l'objet actuel, nous avons le concept d'un nombre maximum d'objets actuels, et toutes nos fonctions de manipulation d'objets sont ajustées pour sélectionner l'objet actuel.

Lorsque vous modifiez l'objet actif, vous modifiez l'ensemble des emplacements cibles. Ainsi, vous pouvez lier quelque chose qui va dans l'objet actuel 0, passer à l'objet actuel 4, et va modifier un objet complètement différent.

Cette analogie avec les objets de texture est parfaite... Presque.

Voir, glActiveTexture ne prenez pas un entier, il faut un énumérateur. Ce qui en théorie signifie qu'il peut prendre n'importe quoi de GL_TEXTURE0 à GL_TEXTURE31. Mais il y a une chose que vous devez comprendre:

C'EST FAUX!

La plage réelle que glActiveTexture peut prendre est régie par GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS. C'est le nombre maximum de multitextures simultanées qu'une implémentation permet. Ceux-ci sont chacun divisés en différents groupes pour différentes étapes de shader. Pour exemple, sur GL 3.matériel de classe x, vous obtenez 16 textures de shader de vertex, 16 textures de shader de fragment et 16 textures de shader de géométrie. Par conséquent, {[35] } sera 48.

Mais il n'y a pas 48 recenseurs. C'est pourquoi glActiveTexture ne prend pas vraiment les recenseurs. La façon correcte d'appeler glActiveTexture est la suivante:

glActiveTexture(GL_TEXTURE0 + i);

Où i est un nombre entre 0 et GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS.

Rendu

Alors, qu'est-ce que tout cela a à voir avec le rendu?

Quand à l'aide de shaders, vous définissez vos uniformes d'échantillonneur sur une unité d'image de texture (glUniform1i(samplerLoc, i), où i est l'unité d'image). Cela représente le nombre que vous avez utilisé avec glActiveTexture. L'échantillonneur sélectionnera la cible en fonction du type d'échantillonneur. Donc, un {[44] } choisira parmi la cible GL_TEXTURE_2D. C'est l'une des raisons pour lesquelles les échantillonneurs ont des types différents.

Maintenant, cela semble étrangement comme si vous pouviez avoir deux échantillonneurs GLSL, avec des types différents qui utilisent la même unité d'image de texture. Mais vous ne pouvez pas; OpenGL interdit cela et vous donnera une erreur lorsque vous tentez de vous rendre.