Tipos de Datos, Convenciones y Estados en OpenGL

Este tutorial hace un breve repaso de tres conceptos importantes en la realización de aplicaciones con OpenGL, las convenciones del API, los tipos de datos manejados por este y los estados, con los cuales se controla gran parte del proceso de render.

TIPOS DE DATOS

Al igual que c, c++ y todos los lenguajes de programación definen unos tipos de datos básicos para representar valores de verdad, enteros, flotantes, bits y caracteres, OpenGL define sus propios tipos de datos que permiten trabajar de manera mas uniforme sobre el API en diferentes compiladores y sistemas operativos. Los tipos de datos en OpenGL son los siguientes:

Tipo GL Prefijo Tamaño Descripción
GLboolean 1 Valor de verdad
GLbyte b 8 Byte con signo, complemento a 2
GLubyte ub 8 Byte sin signo
GLchar 8 Caracter
GLshort s 16 Entero corto
GLushort us 16 Entero corto sin signo
GLint i 32 Entero con signo, complemento a 2
GLuint ui 32 Entero sin signo
GLsizei 32 Entero largo no-negativo
GLintptr ptrbits Entero complemento de 2 , es el numero de bits necesarios para representar un puntero a GLint
GLsizeiptr ptrbits Entero no-negativo, es el numero de bits necesarios para representar un puntero a GLsizei
GLbitfield 32 Campo de bits
GLfloat f 32 Numero de punto flotante
GLdouble d 64 Punto flotante de precisión doble.
GLclampd 64 Doble convertido al intervalo [0,1]

Las letras de la columna “Prefijo” se usan en las convenciones de funciones, para identificar el tipo de dato que la función recibe.

Los bits en la columna de “Tamaño” indican la mínima cantidad que debe tener el tipo de dato, ya que dependiendo de la implementación del fabricante de hardware este número puede ser mayor.

Las entrada de las funciones de OpenGL pueden ser cualquier tipo de dato que cumpla las especificaciones de arriba, es decir, el API no solamente funciona con los tipos de datos propios, sino que también puede funcionar con los tipos de datos de c, c++, algún binding de java, etc. Así es que por ejemplo se puede usar el float de c++ como entrada de una función con parámetro GLfloat de OpenGL sin problemas. Aun así es recomendable utilizar los tipos de datos de OpenGL para mantener una buena portabilidad de la aplicación.

CONVENCIONES

Todas las funciones de OpenGL siguen unas simples convenciones que permiten identificar su funcionamiento de manera rápida para el programador, dichas convenciones fueron establecidas inicialmente por SGI y hasta hace poco lo eran por el ARB. Actualmente y con el traspaso del ARB al grupo Kronos, se espera que dichas normas sean dictadas desde allí.

Una “disección” de una función en OpenGL luciría algo así como:

Name Function GL

  • Retorno: El retorno puede ser cualquiera de los tipos especificados anteriormente.
  • Liberaría: Indica la fuente de la función, las mas comunes son gl para OpenGL, glu para el OpenGL Utility Library y wgl para la librería de bindings OpenGL – win32. Para el caso de las extensiones, aparecen de la forma GL_EXT, GL_ARB, GL_NV (nvidia), GL_ATI y en general cualquier nombre de compañía que produzca extensiones de hardware para OpenGL.
  • Nombre: El nombre de la función.
  • # Parámetros: Cantidad de parámetros que recibe la función, pueden ser ninguno (se obvia), 1, 2, 3 o 4.
  • Tipo parámetros: Indica el tipo de todos los parámetros que recibe la función. Pueden ser cualquiera de los tipos con prefijo indicados en la tabla de Tipos de Datos de OpenGL. Si se le agrega la letra ‘v’ después del prefijo de tipo de parámetro, indica que la función recibe un arreglo de tamaño # Parámetros y tipo Tipo parámetros.
  • Parámetros: Los parámetros de la función.

Las mismas reglas anteriores pueden ser representada al estilo ANSI C se vería como: (Tomado de la especificación 2.1 de OpenGL)

tipoR Nombre{e1234}{e b s i f d ub us ui}{e v} ( [args ,] T arg1 , . . . , T argN [, args] );

donde tipoR es el tipo de retorno, seguido por el nombre de la función (incluido el indicador de librería) , los {} indican que un valor debe ser escogido entre todos los posibles, ‘e’ es el valor vació y los argumentos [args,] pueden o no estar presentes.

Uno de los ejemplos mas amplios para mostrar el funcionamiento de estas convenciones es de de glVertex(), todas las definiciones de estas función son:


void glVertex2d (GLdouble x, GLdouble y);
void glVertex2dv (const GLdouble *v);
void glVertex2f (GLfloat x, GLfloat y);
void glVertex2fv (const GLfloat *v);
void glVertex2i (GLint x, GLint y);
void glVertex2iv (const GLint *v);
void glVertex2s (GLshort x, GLshort y);
void glVertex2sv (const GLshort *v);
void glVertex3d (GLdouble x, GLdouble y, GLdouble z);
void glVertex3dv (const GLdouble *v);
void glVertex3f (GLfloat x, GLfloat y, GLfloat z);
void glVertex3fv (const GLfloat *v);
void glVertex3i (GLint x, GLint y, GLint z);
void glVertex3iv (const GLint *v);
void glVertex3s (GLshort x, GLshort y, GLshort z);
void glVertex3sv (const GLshort *v);
void glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void glVertex4dv (const GLdouble *v);
void glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void glVertex4fv (const GLfloat *v);
void glVertex4i (GLint x, GLint y, GLint z, GLint w);
void glVertex4iv (const GLint *v);
void glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
void glVertex4sv (const GLshort *v);

Como se evidencia, es posible “adivinar” el tipo de entrada que tendrá la función, solamente con observar su nombre.

No todas las funciones poseen numero de argumentos variable, así que en esos casos se omite el numero delante del nombre de la función, como por ejemplo en glTranslate(). Esto también puede ocurrir con el tipo de datos y si la función recibe como parámetros arreglos.

1 2

Compartir esta entrada

DiggReddit
  • Amparo

    GRACIAS POR SUBI 😆 R ESTA INFORMACION , EN VERDAD ME SERVIRA MUCHO PARA ENTER OPEN GL :)

  • http://black-byte.com Jotatsu

    Con gusto

  • CESAR

    NO ME SIRVIO DE NADA QUE MALA ONDA!!!!!!!

  • cirleyni

    de verdad que esta imformacion me sirvio para enredarme mas muchas gracias I LOVE