Todo sobre los Objetos OpenGL

El modelo estándar para objetos OpenGL es el siguiente.

Los objetos tienen estado. Piensa en ellos como un struct. Así que podrías tener un objeto definido así:

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

El objeto tiene ciertos valores almacenados en él y tiene estado. Los objetos OpenGL también tienen estado.

Estado cambiante

En C / C++, si tiene una instancia de tipo Object, cambiaría su estado de la siguiente manera: obj.count = 5; Se referiría directamente a un instancia del objeto, obtener la pieza particular de estado que desea cambiar, y empujar un valor en él.

En OpenGL, no hacer esto.

Por razones heredadas que es mejor dejar sin explicar, para cambiar el estado de un objeto OpenGL, primero debe vincularlo al contexto. Esto se hace con algunos de glBind* llamada.

El C / C++ equivalente a esto es el siguiente:

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

Las texturas son interesantes; representan un caso especial de encuadernación. Muchas llamadas glBind* tienen un parámetro "target". Esto representa diferentes ubicaciones en el contexto OpenGL donde se pueden enlazar objetos de ese tipo. Por ejemplo, puede enlazar un objeto framebuffer para leer (GL_READ_FRAMEBUFFER) o para escribir (GL_DRAW_FRAMEBUFFER). Esto afecta a cómo OpenGL usa el búfer. Esto es lo que representa el parámetro loc anterior.

Las texturas son especiales porque cuando primero las vinculas a un objetivo, obtienen información especial. Cuando se une por primera vez una textura como GL_TEXTURE_2D, se en realidad están estableciendo un estado especial en la textura. Estás diciendo que esta textura es una textura 2D. Y siempre será una textura 2D; este estado no se puede cambiar nunca. Si tiene una textura que fue enlazada primero como GL_TEXTURE_2D, debe siempre enlazarla como GL_TEXTURE_2D; intentar enlazarla como GL_TEXTURE_1D dará lugar a un error (mientras se ejecuta).

Una vez que el objeto está enlazado, su estado puede ser cambiado. Esto se hace a través de funciones genéricas específicas para que objeto. También toman una ubicación que representa qué objeto modificar.

En C / C++, esto se ve como:

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

Observe cómo esta función establece lo que sucede que está en el valor actualmente enlazado loc.

Para los objetos de textura, las principales funciones de cambio de estado de textura son glTexParameter. Las únicas otras funciones que cambian el estado de textura son glTexImage funciones y sus variaciones (glCompressedTexImage, glCopyTexImage, el reciente glTexStorage). Las distintas versiones SubImage cambian el contenido de la textura, pero técnicamente no cambian su estado . Las funciones Image asignan el almacenamiento de texturas y establecen el formato de la textura; las funciones SubImage simplemente copian píxeles. Eso no se considera el estado de la textura.

Permítanme repetir: estas son las solo funciones que modifican el estado de textura. glTexEnv modifica el estado del entorno; no afecta a nada almacenado en la textura objeto.

Textura activa

La situación para las texturas es más compleja, de nuevo por razones heredadas que es mejor dejar sin revelar. Aquí es donde glActiveTexture entra.

Para las texturas, no hay solo objetivos (GL_TEXTURE_1D, GL_TEXTURE_CUBE_MAP, etc). También hay texture units . En términos de nuestro ejemplo de C/C++, lo que tenemos es esto:

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

Observe que ahora, no solo tenemos una lista 2D de Object s, sino que también tenemos el concepto de un objeto actual. Tenemos un función para establecer el objeto actual, tenemos el concepto de un número máximo de objetos actuales, y todas nuestras funciones de manipulación de objetos se ajustan para seleccionar del objeto actual.

Cuando cambia el objeto actualmente activo, cambia todo el conjunto de ubicaciones de destino. Así que puede enlazar algo que entra en el objeto actual 0, cambiar al objeto actual 4, y estará modificando un objeto completamente diferente.

Esta analogía con los objetos de textura es perfecta... Casi.

Véase, glActiveTextureno toma un entero; toma un enumerador. Lo que en teoría significa que puede tomar cualquier cosa de GL_TEXTURE0 a GL_TEXTURE31. Pero hay una cosa que debes entender:

ESTO ES FALSO!

El rango real que glActiveTexture puede tomar se rige por GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS. Ese es el número máximo de multitexturas simultáneas que permite una implementación. Estos se dividen en diferentes grupos para diferentes etapas de sombreado. Para ejemplo, en la LG 3.hardware de clase x, obtienes 16 texturas de sombreador de vértices, 16 texturas de sombreador de fragmentos y 16 texturas de sombreador de geometría. Por lo tanto, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS será 48.

Pero no hay 48 enumeradores. Es por eso que glActiveTexture realmente no toma enumeradores. La correcta forma de llamar glActiveTexture es la siguiente:

glActiveTexture(GL_TEXTURE0 + i);

Donde i es un número entre 0 y GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS.

Rendering

Entonces, ¿qué tiene que ver todo esto con el renderizado?

Cuando usando shaders, usted establece sus uniformes sampler a una unidad de imagen de textura (glUniform1i(samplerLoc, i), donde i es la unidad de imagen). Eso representa el número que usaste con glActiveTexture. El muestreador elegirá el objetivo basado en el tipo de muestreador. Así que un sampler2D escogerá del objetivo GL_TEXTURE_2D. Esta es una de las razones por las que los muestreadores tienen diferentes tipos.

Ahora esto suena sospechosamente como si pudieras tener dos samplers GLSL, con diferentes tipos que usan la misma unidad de imagen de textura. Pero no puedes; OpenGL prohíbe esto y le dará un error cuando intente renderizar.