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