Hace un par de días decidimos con un amigo meternos en el mundo de OpenGL, una librería gráfica de código abierto multiplataforma y multilenguaje pensada para el tratamiento de gráficos 2D y 3D. Empezamos a buscar información en internet sobre su API ( Application Programming Interface ) y nos dimos cuenta de la poca documentación que había disponible para novatos para la integración de OpenGL en Ubuntu sin librerías de ayuda como GLUT . Así que decidimos empezar con GLUT para familiarizarnos con el entorno OpenGL primero, y más tarde ya nos centraríamos en la librería <glx.h> que es la que ayuda a unir el X Window System con OpenGL, aunque a un nivel mucho mas bajo que GLUT y por lo tanto con más control.

Nos bajamos sus librerías de los repositorios ( freeglut es una copia del GLUT original pero su desarrollo esta continuado )

sudo aptitude freeglut3-dev

Así que nos plantamos delante de Geany para intentar hacer funcionar algo. En lugar de tutoriales, cogimos un código de ejemplo de la red y lo intentamos compilar ( para comprobar si habíamos instalado todas las librerías necesarias ) utilizando el siguiente comando:

gcc p1.c -o p1 -lGL -lGLU -lglut

La pantalla nos mostró todo de cuadrados girando de múltiples colores y tamaños, y eso fue suficiente, cerramos el programa y empezamos a rebuscar entre el código para buscar lo básico para empezar un programa en GLUT. Queríamos llegar a tener una ventana con un color ( muy básico ), pero además queríamos conseguir reducir el programa al máximo con tal de ver que cosas eran necesarias y cuáles no lo eran, el programa que quedó fue el siguiente:

</pre>
void renderFn() {    glClearColor ( R, G, B, 1.0f ); //Se establece el color con el que se limpiara la ventana

 glClear ( GL_COLOR_BUFFER_BIT ); //Se limpia la ventana con el color establecido

 glutSwapBuffers (); // Se intercambian los buffers ( doble buffer )

}

int main ( int argc, char** argv ) {

 glutInit ( &argc, argv ); //Se inicializa la librería GLUT y se establece conexión con el sistema de Ventanas X

 glutInitDisplayMode ( GLUT_RGB | GLUT_DOUBLE ); //Establecemos el modo de renderizado como RGB y con Buffer Doble

 glutCreateWindow ( "Ventana  a Color" ); //Creamos una ventana con el título "Ventana a Color"

 glutDisplayFunc ( renderFn ); //Se establece la función que se usará para renderizar    glutMainLoop ();

 return 0;
} 

Con este sencillo programa se crea una ventana con el color que pongas en los valores R, G, B ( del 0.0f al 1.0f ). Es el “Hello World!” de OpenGL y GLUT! Después, para probar un poco más decidimos hacer que la ventana fuera cambiando de color, esto ya requería un control del tiempo así que aprenderíamos nuevos conceptos de GLUT. El programa que quedó fue el siguiente:

#include<GL/freeglut.h>float R = 0.0f;
float G = 0.0f;
float B = 0.0f;
int helper = 0;

void timerFn ( int v ) {
    glClearColor ( R, G, B, 1.0f );
    glutPostRedisplay ();
    if(helper == 0){
        R = R + 0.01f;
    } else {
        R = R - 0.01f;
    }
    if ( R > 0.9f ) {
        helper = 1;
    } else if ( R < 0.1f ) {
        helper = 0;
    }
    glutTimerFunc ( 20, timerFn, 1 );
}
void renderFn() {
   glClear ( GL_COLOR_BUFFER_BIT );
   glutSwapBuffers ();
}
int main ( int argc, char** argv ) {

    glutInit ( &argc, argv ); /*Se inicializa la librería GLUT y

se establece conexión con el sistema de Ventanas X
    glutInitDisplayMode ( GLUT_RGB | GLUT_DOUBLE );
    glutCreateWindow ( "Ventana  a Color" );
    glutDisplayFunc ( renderFn );
    glutTimerFunc( 20, timerFn, 1 );
    glutMainLoop ();
    return 0;

}

Pero supongo que si habéis llegado hasta esta página y estáis leyendo estas lineas es que estáis interesados en este funcionamiento, ¿no?.  Bueno, pues tal y cómo he dicho la base es muy sencilla así que empezaré por allí.

El sistema Decimal

Los ordenadores ( la electrónica digital en general ) no puede utilizar el sistema de numeración que utilizamos nosotros habitualmente, llamado sistema Decimal, es el que te enseñaron el la escuela y que estás harto de utilizar. Al sistema decimal también se le llama sistema convencional en base 10 ( de aquí decimal ), que básicamente lo que quiere decir es que representamos todos los números con 10 símbolos {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, todos los números los creamos posicionando estos símbolos de la forma adecuada. La palabra posicionar es muy importante porque este sistema es un sistema posicional lo que quiere decir que la posición en la que están los símbolos decide su peso dentro del número en cuestión. Por ejemplo mostremos el caso del número 428:

El número 428 está compuesto por 3 símbolos, el ’4′, el ’2′ y el ’8′, pero podemos ver que ordenando los números de forma distinta no daría el mismo número ( muy lógico, ¿verdad? ), el 284 es diferente al 842 que a su vez es diferente al 482 que es diferente al 428. Esto es porque cada número, dependiendo de su posición, tendrá un peso mayor o menor dentro del número. En el sistema decimal cada posición hace que el valor de ese símbolo se multiplique por la potencia de 10 elevado a  la posición. El símbolo 4 está en la posición 2 ( siempre se empieza por cero y de derecha a izquierda ) así que su valor es de 4 x 10^2 ( 10^2 significa 10 elevado a 2 ) que equivale a 4 x 100 = 400, de la misma forma el dos tiene el valor de     2 x 10^1 = 2 x 10 = 20 y el 8 de 8 x 10^0 = 8 x 1 = 8. Si sumamos estos resultados nos da 400 + 20 + 8 = 428.

Pero, ¿todo esto que tiene que ver con el ordenador?, realmente nada pero nos ayudará a entender el sistema de numeración binario, o sistema convencional en base 2.

El sistema Binario

Como habrás podido deducir, el sistema convencional en base 2 sólo tiene dos símbolos, {0, 1} y a partir de estos dos símbolos se construyen todos los números posibles, y de hecho de la misma forma que el sistema decimal, veamos, en el sistema decimal cada símbolo se multiplicaba por 10^(posición), y 10 era la base. De la misma forma un número en Binario se obtiene multiplicando el símbolo con la base ( 2 ) elevada a la posición. Por ejemplo:

1010 = 1 x 2^3 + 0 x 2^2 + 1 x 2^1 + 0 = 1 x 8 + 0 x 4 + 1 x 2 + 0 x 1 = 10, así pues el número 1010 ( en base 2) es 10 ( en base 10 ), tal como se ve pasar del sistema binario al decimal es muy sencillo, basta con sumar las potencias de 2 de las posiciones en las que hay un 1.

Es exactamente igual al sistema decimal excepto porque sólo utiliza 2 símbolos en lugar de 10 y porque la base es diferente ( los números representados en binario son más largos también ).

¿Y porque los ordenadores utilizan este sistema? Porque trabajan con tensiones, cuando reciben una tensión de 5V ( no són 5V exactos y varían según el ordenador ), el ordenador la considera un 1 lógico y cuando reciben una tensión cercana al ’0′ lo consideran un ’0′ lógico.

Para reducir algunas de las cadenas de números en binario en computación habitualmente se utiliza también el sistema hexadecimal

El  sistema Hexadecimal

El sistema hexadecimal, o sistema convencional en base 16, utiliza los símbolos del sistema decimal hasta el 9 y después usa de la A a la F para representar del 10 al 15. El sistema hexadecimal es utilizado principalmente para reducir cadenas largas de números en binario. Esto es porque el 16 es una potencia de 2 y por lo tanto es sencillísimo pasar entre estas dos representaciones. Por ejemplo:

La cadena 100110101110 en binario ( 2478 en decimal ) se puede agrupar en grupos de 4 dígitos { 1001, 1010, 1110 } y pasarlos a Hexadecimal,         1001 (b) = 9 (d) = 9 (h) ; 1010 (b) = 10 (d) = A (h) ; 1110 (b) = 14 (d) = E (h), con lo qual tenemos que 100110101110 (b) = 2478 (d) = 9AE (h)

De esta forma sólo agrupando de 4 en 4 y pasando a su equivalente en Hexadecimal se pueden convertir cadenas de n dígitos en cadenas de (n+n%4)/4, esto es posible porque el mayor número que puede conseguirse en hexadecimal con un sólo dígito es el 15, que es a la vez el máximo que puede conseguirse en 4 dígitos en el sistema binario.

Esto es todo por este artículo, en el siguiente empezaré a hablar sobre algunos circuitos lógicos básicos y también me falta hablar sobre la representación de números enteros (con signo). Y poco a poco iremos entendiendo como todas estas cosas básicas llegan a hacer un procesador. Al final de esta serie de artículos tengo pensado que lleguéis a entender un procesador muy básico de 16 bits programable.

Si hay alguna pregunta sentiros libres de dejar vuestras dudas en los comentarios.

Saludos!