nemediano

Bueno en el post pasado aprendimos como instalar el compilador y las librerías(bibliotecas para los puristas del idioma) en Ubuntu, para poder hacer nuestros propios programas de OpeGL y glut. Supongo que si estas leyendo esto es que todavía no sabes muy bien como programar en OpenGL y probablemente quieres un entorno de desarrollo medio amigable para hacer todo el show de codifico, intento compilar, corrijo errores, va de nuevo.Lo mas recomendable para hacer esto es construir un makefile (por eso en el post pasado instalamos el paquete build-essentials).

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).