Al principio me gustó la idea, después de todo, traía fresco lo de la graficada y el programa parecía ser muy sencillo, le dije que solo preparara la recurrencia matemática y que después pasaría a ayudarle, después de una semana pase a verlo y como suele suceder no había hecho nada ni yo ni el, sin embargo el programa resulto ser lo bastante simple para que solo me llevara un par de horas terminarlo.

Pueden descargar el código aquí. Y para probar mis últimos dos plugines agregados al blog me decidí a escribir este post. los dos plugines de los que hablo son el WP-sintax que permite poner código de algún lenguaje de programación en tus post y el WP-LaTeX que agregar una fórmula escrita en LaTeX, (en forma de imagen) a tus post.

Copo de Koch

La primeras lineas solo incluyen las dos bibliotecas que vamos a usar, la primera es la glut estandar para levantar OpenGL y la otra es math.h, para hacer cálculos.

Veamos después de eso que hay:

6
7
8

typedef struct {
	float x, y, z;
}Punto;

Con estas lineas definimos un nuevo tipo de dato, lo bautizamos como Punto y tiene adentro tres flotantes, para representar coordenadas, aunque el programa es en esencia bidimensional, como el OpenGL trabaja en 3D, me gusta declarar todo como si estuviera dibujando en 3D.

Después se declaran algunas variables globales, y el prototipo de las funciones, las variables globales son:

• xMax, yMax: Guardan el tope de las coordenadas del mundo, es decir de donde a donde corre la parte visible de la ventana en X y en Y, con respecto al origen (situada al centro de la ventana)
• vertices: Es un arreglo de tres puntos, que guardara la única información que necesitamos para empezar a generar el copo de nieve, la posición de tres vértices.
• numPtos: Este guarda el número de vértices proporcionados por el usuario, es un contador para poner la siguiente lógica: “Si ya tienes tres puntos, empieza a hacer el fractal, si tienes menos de tres puntos, continua esperando…”
• fondo: Otro entero que guardará la profundidad máxima para hacer el fractal, donde un cero, pinta un triangulo, un uno la estrella de David y así en adelante. Es si lo quieren ver así el numero de veces que se manda a llamar recursivamente el fractal.

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

int main(int argc, char** argv) {
 
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGBA);
   glutInitWindowSize (640, 480);
   glutInitWindowPosition (100, 105);
   glutCreateWindow (argv[0]);
   inicializar();
 
   glutDisplayFunc(dibuja);
   glutReshapeFunc(redimensiona);
   glutKeyboardFunc(teclado);
   glutSpecialFunc(tecladoEspecial);
   glutMouseFunc(raton);
 
   glutMainLoop();
 
   return 0;
}

La función main, no mucho que decir, es muy estándar en el estilo glut, pone la maquina de estados en el estado adecuado, manda llamar a inicializar, registra cinco funciones de callback y por ultimo manda al loop principal de glut. Utilizo un solo buffer por que no voy a hacer animación, y ocupo el nombre del programa para el titulo de la ventana.

47
48
49
50
51
52

void inicializar () {
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glPointSize(5.0);
   numPtos = 0;
   fondo = 1;
}

La primer función en ser ejecutada, pone el color del fondo en negro, a los puntos les da tamaño 5, inicializa el contador de puntos y a profundidad.

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

void redimensiona (int ancho, int alto) {
   float aspect;
 
   glViewport (0, 0, ancho, alto);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
 
   if (alto == 0){
   	  alto = 1;
   }
 
   aspect = (float) ancho / (float) alto;
 
   if (ancho <= alto) {
   	  glOrtho(-MUNDO, MUNDO, -MUNDO/aspect, MUNDO/aspect, -MUNDO, MUNDO);
   	  xMax = MUNDO;
   	  yMax = MUNDO / aspect;
 
   } else {
   	  glOrtho(-MUNDO * aspect, MUNDO * aspect, -MUNDO, MUNDO, -MUNDO, MUNDO);
   	  xMax = MUNDO * aspect;
   	  yMax = MUNDO;
   }
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

La función redimensiona, es llamada al inicio del programa, (el estándar de glut así lo indica) y cada vez que hay un evento de resize a la ventana. es una función muy común en estilo glut, lo único raro, quizás es que guarda en variables globales el valor de la máxima coordenada Y y la máxima coordenada X. Por lo demás es muy normal, da una proyección ortogonal, i.e: pone el sistema de referencia.

82
83
84
85
86
87
88
89
90
91
92
93

void teclado (unsigned char key, int cx, int cy) {
 
	switch (key) {
		case 27:
		   exit(0);
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

La función teclado es muy simple, si detecta un evento de la tecla “Esc”, termina el programa con codigo 0.

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

void tecladoEspecial (int key, int cy, int cx) {
 
	switch (key) {
		case GLUT_KEY_PAGE_UP:
		   fondo++;
		break;
 
		case GLUT_KEY_PAGE_DOWN:
		   if (fondo > 1) fondo--;
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

Está función sirve para cachar eventos de las teclas PgUp y PgDn, y en respuesta aumenta el valor de la variable global fondo, es decir hace que el fractal itere mas o menos veces, después de poner el nuevo valor en fondo, avisa a la ventana que necesita volver a dibujarse.

112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

void raton (int boton, int estado, int cx, int cy) {
	float x, y;
 
	/* Calculamos las coordenadas de mundo (relativas) apartir de 
	 * las de ventana (absolutas) */
 
	x = ((GLfloat)cx * 2.0 * xMax) / glutGet(GLUT_WINDOW_WIDTH) - xMax;
	y = yMax - ((GLfloat)cy * 2.0 * yMax) / glutGet(GLUT_WINDOW_HEIGHT);
 
	if (boton == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) {
 
		if (numPtos < 3) {
		   vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   ++numPtos;
	    }
	    else {
	       numPtos = 0;
	       vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   numPtos++;
	    }
	}
 
	glutPostRedisplay();
}

Este código cacha las acciones del ratón, las lineas 118 y 119, calculan la posicion en x y en y en donde el usuario realizo el click, recordemos que el glut, nos pasa como parámetros dos enteros que representan el pixel en el que se hizo el click, pero para la lógica de nuestro programa lo queremos en coordenadas de mundo.

En las lineas siguientes, se pregunta si el mouse dio click izquierdo de ser así, preguntamos cuantos puntos llevamos, si son menos de tres, seguimos esperando si no que este sea el primero, de esta manera cada cuarto punto se resetea, el estado del programa, así que si después de pintar un fractal queremos pintar otro simplemente damos un nuevo click y ese es el primer punto de un nuevo fractal.

142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

void dibuja (void) {
	int i;
 
	glClear(GL_COLOR_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
 
 
	if (numPtos != 3) {
	   glColor3f(1.0, 1.0, 1.0);
	   glBegin(GL_POINTS);
	      for (i = 0; i <numPtos; i++) {
	   	     glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
	      }
	   glEnd();
	}
 
	if (numPtos == 3) {
	   glColor3f(1.0, 1.0, 0.0);
	   glBegin(GL_LINE_STRIP);
	      koch(vertices[0], vertices[1], 0);
	      koch(vertices[1], vertices[2], 0);
	      koch(vertices[2], vertices[0], 0);
	   glEnd();
	}	
 
	glFlush();
}

Esta función se encarga de dibujar el fractal, primero limpia la pantalla, luego pone el estado de dibujar y pregunta si tenemos algún numero de puntos que no sea tres (por la lógica de la función anterior esto solo puede pasar cuando son menos que tres) de ser así solo pone los puntos que llevamos. En caso contrario se prepara a dibujar el fractal, para esto hace uso de la función auxiliar koch, que da los vértices de una curva de koch, así que para hacer el copo de koch, pinta tres curvas de koch: Una del vértice 0, al vértice 1, otra del vértice 1 al vértice 2 y por ultimo una que cierra el copo del vértice 2 al vértice 0.

Dibujando la curva de Koch

Ahora viene la parte mas interesante: ¿Como se dibuja la curva de Koch?
La función encargada de hacerlo es la función koch, pide como argumento dos puntos y un entero, que es el nivel de profundidad en la recursividad del algoritmo, es decir: la primera vez que se llame tendrá valor 0, la segunda vez que se llame tendrá valor 1 y así sucesivamente. Aquí esta el código de la función:

173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

void koch (Punto p0, Punto p1, int profundidad) {
	Punto a, b, p2;
 
	if (profundidad < fondo) {
		a.x = 2.0 / 3.0 * p0.x + 1.0 / 3.0 * p1.x;
		a.y = 2.0 / 3.0 * p0.y + 1.0 / 3.0 * p1.y;
		a.z = 0.0;
 
		b.x = 1.0 / 3.0 * p0.x + 2.0 / 3.0 * p1.x;
		b.y = 1.0 / 3.0 * p0.y + 2.0 / 3.0 * p1.y;
		b.z = 0.0;
 
		p2.x = 0.5 * p0.x + 0.5 * p1.x + a.y - b.y;
		p2.y = 0.5 * p0.y + 0.5 * p1.y + b.x - a.x;
		p2.z = 0.0;
 
		glVertex3f(p0.x, p0.y, p0.z);
		koch(p0, a, profundidad + 1);
		glVertex3f(a.x, a.y, a.z);
		koch(a, p2, profundidad + 1);
		glVertex3f(p2.x, p2.y, p2.z);
		koch(p2, b, profundidad + 1);
		glVertex3f(b.x, b.y, b.z);
		koch(b, p1, profundidad + 1);
		glVertex3f(p1.x, p1.y, p1.z);
 
	} 
 
	return;
}

En la linea 176, se pregunta cuantas veces se ha ejecutado esta función en la recursión, si es mas que lo que vale la variable fondo, regresa sin hacer ninguna operación, poniendo fin a la recursión. Sin embargo si aun es menor, se ejecutan los cálculos necesarios (se hace otra iteración) y dentro del procedimiento se llama recursivamente la función koch aumentando el nivel de profundidad.

La lógica de la función koch se explica a continuación:

La idea principal es que como entrada tenemos dos puntos (p0 y p1), los cuales representan un segmento y queremos a partir de ellos calcular tres puntos mas (a, b y p2). Como se ve en la figura:

Segmento de recta

Para calcular cada uno de estos puntos, se hace uso de la ecuación paramétrica de un segmento de recta. Si tenemos dos puntos p y q entonces la ecuación paramétrica en t, del semento de recta entre p y q es: con con esta ecuación podemos calcular fácilmente tanto a, como b. Sin embargo para calcular p2 tendremos que hacer algunas cosas mas.

Puntos a calcular en el nuevo segmento de koch

Primero calculamos el punto medio del segmento, a ese vector hay que sumarle la elevación del nuevo punto, para calcularla necesitamos sumarle un nuevo vector que sea perpendicular al segmento, para esto utilizamos el hecho de que el producto punto de dos vectores perpendiculares entre si, siempre es cero. Así que construimos el vector que va de a a b y de ahí lo volteamos es decir:

Dado un vector:

Es perpendicular a el vector v dado por:

Por lo que podemos encontrar el punto p2 de la siguiente manera:

Recordemos que el vector que va de a a b se puede ver como b-a.

Descargas

• Código fuente el programa
• Ejecutable de win32

¿Por que solo pongo el ejecutable para Windows, si yo siempre uso GNU/Linux?, por que los usuarios del lado luminoso de la fuerza les conviene mas compilar el fuente, que al cabo es solo uno, recuerden que deberán tener instalado OpenGL y glut.

Pantallazos

[Show as slideshow]

Instalar Geany, no debe de dar mayor problema, pues se encuentra en los repositorios oficiales de Ubuntu, lo podemos hacer via apt-get, o synaptic, o incluso se encuentra disponible en agregar o quitar programas bajo la categoría de desarrollo, si su sistema esta en español (el Ubuntu), geany también vendrá en español.

Bueno, por que querría yo usar un editor de texto aparte de gedit? Pues por que geany me da ciertas ventajas que no me da por ejemplo gedit, al escribir código, estoy hablando a que nos da mas ventajas que el simple sintax highlight

Pues aquí viene lo bonito del asunto, si queremos usar Geany para escribir código de OpenGL y glut en Ubuntu, y ya sabemos hacer nuestros propios makefiles, como lo explique en el post anterior.

Ahora podemos usar todo esto a nuestro favor para tener un entorno de desarrollo muy amigable, para empezar guardemos todos nuestros archivos fuentes y makefile en una sola carpeta luego iniciamos geany.

Ahora suponemos que en nuestro makefile, define cierto nombre para el ejecutable por ejemplo “Modelo3D”, y que definimos un make all, de defualt, y que también pusimos un “make destroy”, que elimina los objetos y el ejecutable.

Pues abrimos Geany, de ahí abrimos todos nuestros archivos fuentes, Archivo -> abrir y luego nos vamos al menú que dice: construir

En la ultima opción se encuentra Selecciona Inclusiones y Argumentos, al entrar a esta opción vemos una ventana como esta:

Ahora vemos que Geany ya ha dado valores de default, pues sabe que estamos escribiendo código en C, por que abrimos un archivo .c, sin embargo como nosotros ya hicimos nuestro propio makefile, la vamos a cambiar esas opciones, para que llame a nuestro make.

Lo que tenga escrito en la primer caja de de compilar es lo que se va a ejecutar, cuando apretemos el botón de compilar, ahora nosotros queremos que antes de compilar elimine todos los objetos y el ejecutable, y luego intente compilar todo, es decir queremos que ejecute “make destroy” y luego “make all”, y como esta instrucción se va a mandar al shell tal como la escribimos podemos escribir:
make destroy; make
Ahora lo que escribamos en argumentso para el programa, es lo que ejecuta cuando presionamos el boton de ejecutar, así que podemos poner ahi ./nombre_de_ejecutable o para nuestro ejemplo:
./modelo3D

Y listo, ahora podemos programar cómodamente en Geany, usando glut y OpenGL, cada que queramos compilar, solo presionamos el botón de compilar y al ejecutar el botón de ejecutar.

Algunas observaciones

• Geany es muy ligero y tiene la enorme ventaja que no hace archivos de proyecto, o de configuración, esto es una ventaja para programas pequeños.
• La ventaja de tener total control de los argumentos con nuestro propio makefile.
• También se puede importar código muy fácil, ya que geany, nos da lo mínimo, para poder escribir entre Windows y GNU/Linux, es decir nos deja cambiar el carácter de terminación de linea de los archivos fuentes y la codificación de caracteres, la codificación de GNU/Linux y en particular de Ubuntu es UTF8, la codificación en Windows es depende del idioma en que lo tengamos, pero seguro aparece en el menú de geany. La terminación de linea en Windows es CRLF y en GNU/Linux es LF.
• Tenemos las opciones que mas comúnmente se usan al programar en un Editor muy ligero y que no para instalar no necesitamos traer montones de librerías como en los casos de editores mas poderosos.

El makefile es un archivo de texto plano, que usa la herramienta make, dicho archivo debe ser escrito por el desarrollador y dice como se compila el programa que escribió. Usualmente los makefiles son complejos y contienen un montón de reglas, sin embargo nosotros nos vamos a limitar a tres: una para compilar, una para limpiar y otra para reconstruir.

Así que abrimos nuestro editor de texto plano favoritos y construimos un archivo que tenga por nombre makefile (el nombre es muy importante).

Si nuestro programa solo va tener un archivo fuente esta sera nuestra plantilla:

1
2
3
4
5
6
7
8
9
10

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = -Wall
LIBRARIES = -lglut -lGL -lGLU -lm
ejecutable: fuente.c
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
destroy:
	rm -f *.o ejecutable
clean:
	rm -f *.o

En donde ejecutable es el nombre que queremos que tenga nuestro archivo ejecutable y fuente es el nombre de nuestro único archivo fuente.

Analizando un poco vemos que el makefile define unas variables en las primeras lineas, y luego define unas reglas, las reglas siempre son de la forma:

[objetivo]: [dependencia]
[comandos]

Donde objetivo es el nombre de la operación que queremos hacer, dependencia es todo lo que necesitamos para llevarla a acabo y comandos es lo que debemos hacer para llevar a cabo la operación.

Las reglas que defino son ejecutable que sirve para hacer el ejecutable, clean que sirve para borrar todos los los archivos intermedios que hace el compilador (por ejemplo los .o) y destroy que borra todo lo que hace el compilador y nos deja listos para intentar compilar de nuevo (por ejemplo en nuestro periodo de ensayo error).

Se observa que uso gcc como compilador, por que el lenguaje C es usualmente nuestro default, si piensan programar en c++, cambien gcc por g++. Tambien fijense que entra las librerías mando a GL a GLU y a glut, que es por que queremos hacer un programa de OpenGL con glut, pero además mando un misterioso -lm, estas son as demás librerías de default de C, por ejemplo si en nuestro programa queremos usar funciones definidas en math.h.

Si queremos hacer un programa con mas de un código fuente esta es otra plantilla:

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

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = $(COMPILERFLAGS)
LIBRARIES = -lglut -lGL -lGLU -lm
OBJ = fuente1.o fuente2.o fuente3.o fuente4.o
BIN = ejecutable
 
all: $(BIN)
$(BIN) : $(OBJ)
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
 
fuente1.o: fuente1.c
	$(CC) -c fuente1.c -o fuente1.o $(CFLAGS)
 
fuente2.o: fuente2.c
	$(CC) -c fuente2.c -o fuente2.o $(CFLAGS)
 
fuente3.o: fuente3.c
	$(CC) -c fuente3.c -o fuente3.o $(CFLAGS)
 
fuente4.o: fuente4.c
	$(CC) -c fuente4.c -o fuente4.o $(CFLAGS)
 
destroy:
	rm -f $(OBJ) $(BIN)
clean:
	rm -f $(OBJ)

En donde fuente1, … fuentei, son todos los archivos fuentes que componen el programa y ejecutable es el nombre del ejecutable.

Ahora lo importante:

Es ampliamente recomendado tener una carpeta donde guardar todo lo referente a nuestro programa y solo eso, es decir mi fuente y mi makefile deben estar en una carpeta para ellos solos (esto para facilitar su transporte) y que no se vayan a volar algo sin querer al escribir una regla mal del make XD
Para compilar nuestro programa simplemente escribimos en la linea de comandos “make”: (obviamente debemos estar parados en el directorio donde esta todo):

$make

Si nuestro programa compilo correctamente genero el archio ejecutable, pero si tuvimos errores, veremos los errores y warnings en la shell y debemos de hacer los siguiente:
ejecutar make destroy, para limpiar toda al basura generada por la compilación fallida, corregir nuestro fuente y luego volver a intentar compilar.

$make destroy 

Algunas observaciones:

• Estos makefiles son solo recomendaciones y de hecho no siguen las reglas GNU de los makefiles, para aprender mas de eso pueden visitar: http://www.gnu.org/software/make/
• Para escribir este post me base en la guia publicada por el area de linux de la fesa, quizas si le dan un ojo les quede mas claro http://www.acatlan.unam.mx/linux/graficacion/compilalinux.html
• Si nuestro fuente tiene cabeceras por ejemplo cabecera.h, estas no necesitan ser compiladas y por lo tanto no se ponen en el make, basta que en el fuente sean usadas #include, Siempre que la cabecera no tenga código en C, si no mas bien declaraciones de estructuras y variables globales (que es como debe ser).

Paso 1

Instalar el compilador de C.

Una de las cosas que mas me sorprendió es que Ubuntu, no viene con el compilador de C, en su instalación de default (hasta ahora es el único Gnu/Linux donde me ha pasado esto), así que tienes que instalarlo desde los repositorios.

En Ubuntu solo es cuestión de instalarte los paquetes ya sea vía apt-get o via synaptic lo que te acomode mejor, al caso debes de instalar los siguientes paquetes:

• build-essential
• g++
• g77
• gcc
• make

Estos paquetes no vienen solos, es decir probablemente necesites descargar muchos paquetes mas para satisfacer las dependencias de estos, sin embargo dado que tanto synaptic como apt-get, pueden satisfacer sus dependencia de manera automática solo debemos indicarle estos paquetes. tanto de gcc, como de g++ y g77, hay varias versiones de los paquetes, sin embargo el paquete sin números siempre es un paquete con la versión mas actual.

En resumen lo único que un usuario novato debe de teclear es:

 	$sudo apt-get install build-essential g++ g77 gcc make

Paso 1.5 Probamos la instalación del compilador de C

En nuestro editor de textos plano favorito tecleamos un programa de C, básico por ejemplo un clásico hola mundo: hello.c Lo guardamos por ejemplo con el nombre de hello.c y vamos a compilarlo.

Con la siguiente instrucción:

$gcc hello.c -o hello

Podemos observa que la sintaxis para compilar un programa en C, es la siguiente:

$gcc [archivo fuente.c] -o [nombre de mi ejeculable]

En realidad el gcc es mucho mas completo, un tutorial de como compilar programas con C lo puedes encontrar aqui.

2 Instalamos las librerias necesarias para OpenGL

Ahora necesitaremos instalar los siguientes paquetes:

freeglut3 freeglut3-dbg freeglut3-dev ftgl-dev gle-doc glut-doc glutg3 glutg3-dev libglu1-mesa libglu1-mesa-dev libgl1-mesa libgl1-mesa-dev libgl1-mesa-dri libglut3 libglut3-dev mesa-common-dev mesa-demos mesa-swrast-source mesa-utils

No se cuales sean los esenciales, yo siempre he instalado con todos, pero se que así funciona, muchos de ellos son dependencias, así que no igual lo único que debes de tener en cuenta es tratar de instalar freeglut-dev.

Importante: Si piensas tener tu computadora con Aceleración Gráfica (por ejemplo para tener Beryl), es decir instalar los drivers propietarios de ATI o de nVidia, debes hacerlo antes de hacer esta instalación, se pueden tener ambas funcionando pero poner el driver gráfico debe ser anterior a la instalación de OpenGL. De la contrario nuestros programas de OpenGL no tendrán aceleración

Para saber si nuestra computadora tiene o no aceleración Gráfica puedes ejecutar el comando glxinfo y ver la salida, en el renglón donde dice direct rendering: un “Yes”, significa que tenemos Aceleración gráfica. Una forma de filtrarlo es:

 	 $glxinfo | grep rendering

Por supuesto que tener o no Aceleración Gráfica es totalmente dependiente de tu hardware. Por lo que no se puede escribir una guía general, sin embargo hay muchísima información en la red sobre esto, mi experiencia es que si tu computadora tiene tarjeta de vídeo Intel o nVidia, no debes tener ningún problema, las ATI, en cambio debes de investigar un poco antes de hacerlas funcionar.

2.5Probar la instalación de OpenGL y glut

Nos tecleamos un programa sencillo de glut y OpenGL, por ejemplo este: ventana.c

Y ahora vamos intentar la compilación:

$gcc ventana.c -o ventana -lglut

Y debemos ver una ventana negra.
Si en al linea de comandos ven un warning que dice algo así como:

libGL warning: 3D driver claims to not support visual 0x5b

Pero la ejecución de el programa continua, no deben de preocuparse, este warning solo significa que no esta correctamente configurado su driver de la tarjeta de vídeo, pero es algo que no debe de afectar sus programas escritos en OpenGL, mas que en el performance, y no es un problema de su programa si no del driver de la computadora.

Obviamente el caso ideal es tener tanto el OpenGL como la aceleración gráfica funcionando al mismo tiempo, si ya tenían la aceleración gráfica y siguen este método no deben de tener ningún problema y ni siquiera les debe marcar ese molesto warning.

Usuarios de Red Hat y similares la receta es la misma, solo que deberán de tratar de instalar el freeglut-devel***.rpm, donde *** usualmente son la distribución, la arquitectura y versión del paquete, se recomienda que instalen el paquete que viene en sus discos, usualmente este paquete tiene muchas dependencias, así que la ayuda de un gestor de paquetes como yump o synaptic sin duda les ayudara.

En un post posterior hablare de como tener un IDE funcional que nos de mas ayuda a compilar programas de OpenGL en Linux, en particular en Ubuntu la idea es que el final de mi serie de post del tema se pueda tener un entorno de programación cómodo y funcional en Ubuntu, como para que puedan con ayuda de algún libro como el libro rojo autoaprender a programar con OpenGL