Computación Gráfica con OpenGL

grafics_computerCuando hablamos de computación gráfica nos referimos al campo de la
informática visual, donde se utilizan
computadoras para generar imágenes visuales y espaciales del mundo real.

También se puede definir como el arte de transmitir información usando imágenes que son generadas mediante un ordenador.

Todos los que usamos ordenadores conocemos las gráficas por computadoras las usamos a diario para interactuar con el ordenador mediante Interfaces Gráficas de Usuario (GUI), mencionadas gráficas están  presente en todos los dispositivos tecnológicos que usamos a diario, pero la inquietud surge como hace el ordenador para crear dichas interfaces que ayuden al usuario a interactuar con el, dichas interfaces  se asemeja al mundo real usando un lenguaje gráfico fácil de entender para el humano.

En el mercado existen 2 tecnologías más usadas para el desarrollo de aplicaciones gráficas ya sea para crear GUI, o Juegos súper complejos. Mencionadas aplicaciones son usadas por los sistemas operativos mayormente conocidos como son Windows, GNU/Linux y Mac.

En el caso de Windows cuenta con su propia API de nombre DirectX que es basada en OPenGL; pero que pasa con el resto de plataformas como crean los gráficos si mencionada API solo funciona en sus plataformas, pues déjame contarte que existe una potente librería que es la más usada por las grandes compañías que desarrollan aplicaciones CAD o Videojuegos entre otras aplicaciones. Esta librería recibe el nombre de  OPenGL, en la cual puedes desarrollar para muchas plataformas incluyendo el mismo windows la usa para muchos de sus productos.

Para una mejor comprensión dejo un par de presentaciones que nos ayudaran a comprender de mejor manera este mundo de la computación gráfica, las presentaciones incluyen la historia y parte del Hardware usado para crear o usar dichas aplicaciones.

Hardware para computación Gráfica

 

¿Qué es OPenGL?

Es un estándar creado por Silicon Graphics en el año 1992 para el diseño de una librería 2D/3D portable. Actualmente es una de las tecnologías más empleadas en el diseño de aplicaciones 3D, y su última versión, a la fecha de hoy (2015), es la 4.5.

  • La librería OpenGL, que proporciona todo lo necesario para acceder a las funciones de dibujado de OpenGL.
  • La librería GLU (OpenGL Utility Library), una librería de utilidades que proporciona acceso rápido a algunas de las funciones más comunes de OpenGL., a través de la ejecución de comandos de más bajo nivel, pertenecientes a la librería OpenGL propiamente dicha [REDBOOK].
  • GLX (OpenGL Extension to the X Window System) proporciona un acceso a OpenGL para poder interactuar con un sistema de ventanas X Window, y está incluido en la propia implementación de OpenGL (su equivalente en Windows es la librería WGL, externa a la implementación de OpenGL).

Usos de OpenGL

DirectX -> Windows
OpenGL -> Windows, Linux, Mac (unix)
XBox 360 -> DirectX
Wii -> OpenGL
Playstation 3 -> OpenGL
Resto de consolas -> OpenGL

Ahora que ya conoces la importancia de esta librería, es necesario detallar algunos elementos que intervienen ya sea para el uso o para desarrollar. Nuestros ordenadores poseen mencionados elementos como son: el hardware y el Software partes que no deben faltar, para el caso del Hardware lo podemos encontrar en las tarjetas de Vídeo, fabricadas por AMD, Intel y Nvidia, dichas compañías distribuyen los dispositivos acompañadas de su respectivo controlador, lo más común es encontrar estos controladores para las plataformas Windows; pero hoy en día estas empresas están desarrollando controladores para GNU/Linux y Mac.

Cuando no referimos a controlador de mencionadas tarjetas es software que realiza la comunicación y configuración directa con el hardware el cual es esencial para cualquier sistema operativo para mostrar las gráficas con alta resolución y procesamiento de gráficos. Todo lo antes mencionado es necesario simplemente para hacer uso de las gráficas de alta calidad, de lo contrario contaremos con unas gráficas pobres   al usar un controlador genérico como VESA.

Por el lado de los desarrolladores es necesario contar con el hardware y software que satisfaga sus necesidades que va desde aplicaciones básicas hasta la creación de motores gráficos o vídeo juegos. Sea uno de estos tus objetivos o ideal es comenzar por lo más fácil haciendo nuestros primeros contacto con la librería; pero antes debemos de preparar nuestro ordenador con las herramientas necesarias para desarrollar nuestros primeros script de computación gráfica. Este post esta orientado para plataformas GNU/Linux, en el caso de windows pueden hacer uso del Visual estudio integrando las herramientas de software que detallare continuación.

Requisitos de software

  • Windows, Linux, Unix, Mac OS, etc.
  • Un compilador de C (C++)
  • Las librerías de OpenGL:

En el caso de la instalación de los compiladores ya sea el de C o el de C++ pueden apoyarse en la siguiente entrada http://www.lhernandez.org/programacion-en-cc-en-gnulinux/

Librerías necesarias

  • <gl.h> Librería básica
  • <glu.h> Librería con utilidades básicas
  • <glut.h> Librería con utilidades avanzadas
    (para hacer menús y manejar el API de Windows.

Paquetes a instalar

  • libglu1-mesa-dev Incluye cabeceras y librerías estáticas para compilar con GLU. Proporciona <GL/glu.h>
  • freeglut3-dev Proporciona la librería de cabecera <GL/glut.h> que permite escribir programas con ventanas independientes.
  • mesa-common-dev Incluye los archivos  de cabecera de desarrollo comunes para todos los paquetes de Mesa.

Es de mencionar que estos paquetes los encontraras en las distros derivadas de GNU/debian, para otros sistemas tendrás que buscar los paquetes que contengan la librería glut.h.

Editores para escribir nuestras aplicaciones

Puedes escribir programas en C/C++ usando OpenGL en cualquier editor de texto plano que prefieras pero algunos que reconocen sintaxis y que poseen otras bondades que nos ahorran tiempo al momento de programar puedes usan cualesquiera de estos:

Muchos prefieren a Code::Block, pero eso es gusto de cada desarrollador.

Instalar paquetes necesarios en GNU/debian

apt-get install libglu1-mesa-dev freeglut3-dev

Con todas las herramientas necesarias instaladas en nuestro ordenador podemos comenzar a escribir nuestro primeros scripts; pero antes es recomendable leer un poco sobre OpenGL y C/C++ http://www.glprogramming.com/red/

Cuando leas ese material podrás comprender las lineas básicas de nuestro primer programa en C++ y OpenGL y GLUT.

Primer contacto con las librerías y C++, en el siguiente script generaremos un cuadrilátero , te preguntaras cuanto código para el primer programa; es por ello que debemos leer bastante, ya que escribir programas con estas librerías no es nada fácil, para que comprendas un poco mejor te dejo un ejemplo. En el libro antes señalado se te explica muchas de las instrucciones que observas en el presente script.

Copia el script, guárdalo con un nombre ej. hello.cpp en el editor que prefieras y luego procede a compilar de la siguiente manera.

g++ hello.cpp -o hello -lglut -lGL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include &lt;GL/gl.h&gt;
#include &lt;GL/glut.h&gt;
void display(void)
{
    glClear (GL_COLOR_BUFFER_BIT);
    glColor3f (1.0, 1.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex3f (0.25, 0.25,0.0);
    glVertex3f (0.75, 0.25,0.0);
    glVertex3f (0.75, 0.75,0.0);
    glVertex3f (0.25, 0.75,0.0);
    glEnd();
    glFlush ();
 
}
void init (void)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1, 1, -1, 1, -1, 1);
}
 
int main(int argc, char** argv)
{
    glutInit(&amp;argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (250, 250);
    glutInitWindowPosition (100, 100);
    glutCreateWindow ("hello");
    init ();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

Compilado el programa solo da doble clic sobre el ejecutable para que observes el resultado.

Análisis del código

La estructura de un clásico programa sobre GLUT es la que se aprecia en el hello.cpp Analicemos la función main():

glutInit(&argc, argv);

Esta función es la que inicializa la GLUT y negocia con el sistema de ventanas para abrir una. Los parámetros deben ser los mismos argc y argv, sin modificar, de la función main(). Además, Glut entiende una serie de parámetros que pueden ser pasados por línea de comandos.

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

Define el modo en el que debe dibujar en la ventana. Los parámetros, como gran parte de las funciones que iremos viendo, se definen con flags o máscaras de bits. En este caso en concreto, GLUT_SINGLE indica que se debe usar un solo buffer y GLUT_RGB el tipo de modelo de color con el que se dibujará.

glutInitWindowPosition(100, 100);

Posición x e y de la esquina superior izquierda de la nueva ventana, con respecto al escritorio en el que se trabaje.

glutInitWindowSize(250, 250);

El ancho y alto de la nueva ventana.

glutCreateWindow("Hello");

Esta función es la que propiamente crea la ventana y el parámetro es el nombre de la misma.

init();

En esta función, que hemos definido, activamos y definimos una serie de estados de ogl, antes de pasar el control del programa a la GLUT.

glutDisplayFunc(display);

Aquí se define el primer callback. La función pasada como parámetro será llamada cada vez que GLUT determine oportuno que la ventana debe ser redibujada, como al maximizarse, poner otras ventanas por encima y después quitarlas, etc.

glutMainLoop();

Esta función cede el control del flujo del programa a GLUT que, a partir de estos “eventos”, irá llamando a las funciones que han sido pasadas como callbacks.

 glClear(GL_COLOR_BUFFER_BIT);

Ajusta el área de plano binario de la ventana a los valores previamente seleccionados

glColor3f (1.0, 1.0, 1.0);

Con esto se define el color con el que se borrara el buffer al hacer un glClear(). Los 3 primeros parámetros son las componentes R, G y B, siguiendo un rango de [0..1]. La última es el valor alpha.

glMatrixMode(GL_PROJECTION);

Especifica la matriz actual para realizar la composición. En ogl las operaciones de rotación, translación, escalado, etc. se realizan a través de matrices de transformación. Dependiendo de lo que estemos tratando, hay tres tipos de matriz (que son los tres posibles flags que puede llevar de parámetro la función): matriz de proyección (GL_PROJECTION), matriz de modelo (GL_MODELVIEW) y matriz de textura (GL_TEXTURE). Con esta función indicamos a cual de estas tres deben afectar las operaciones. Concretamente, GL_PROJECTION afecta a las vistas o perspectivas o proyecciones. Todo esto se verá en el capítulo 4.

glLoadIdentity();

Con esto cargamos en la matriz actual la matriz identidad (equivale a resetear la matriz).

glOrtho(-1, 1, -1, 1, -1, 1);

glOrtho() define una perspectiva ortonormal. Esto quiere decir que lo que se ves será una proyección paralela en uno de los planos definidos por los ejes. Los parámetros sirven para delimitar el volumen de vista y son, por este orden: x_mínima, x_máxima, y_mínima, y_máxima, z_mínima, z_máxima, (estos dos últimos no son coordenadas como los cuatro primeros, son distancias desde el punto de vista, positivas hacia donde apunta y negativas hacia el lado contrario) considerando que, por defecto, el punto de vista está en el origen de coordenadas mirando hacia el eje negativo de z, estos valores son desplazamientos desde este punto. Con estos seis valores se define el volumen que incluirá los objetos que se proyecten.

Analicemos ahora el contenido de la función display():

Carga la matriz identidad.

 glBegin(GL_POLYGON);
    glVertex3f (0.25, 0.25,0.0);
    glVertex3f (0.75, 0.25,0.0);
    glVertex3f (0.75, 0.75,0.0);
    glVertex3f (0.25, 0.75,0.0);
  glEnd();

Analizamos toda esta parte entera, por formar una estructura. glBegin() comienza una secuencia de vértices con los que se construirán primitivas. El tipo de primitivas viene dado por el parámetro de glBegin(), en este caso GL_POLYGON. Al haber cuatro vértices dentro de la estructura, está definiendo un cuadrilátero. glEnd() simplemente cierra la estructura.

glFlush();

Dependiendo del hardware, controladores, etc., ogl guarda los comandos como peticiones en pila, para optimizar el rendimiento. El comando glFlush causa la ejecución de cualquier comando que quede en espera en la pila.

Para seguir practicando puedes leer un poco sobre las siguientes primitivas

tabla

 

 

 

 

 

La sintaxis es similar al ejemplo ilustrado, solo es de saber los vértices que se colocaran según el tipo de primitiva.

En las próximas entradas estaremos escribiendo algunos script para representar primitivas antes descritas en la tabla.

 

Comparte este contenido!.Tweet about this on TwitterShare on Google+Share on FacebookEmail this to someone

One Comment on “Computación Gráfica con OpenGL


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *