Ya, ya, ya calma un poco tus ansias, que ya tienes ante tus ojos al fin la "Tercera entrega" de los tutoriales de GRRLIB. Ve por un refresco o por café, sientate tranquilamente, entra en el tutorial y lee todo con calma que el tutorial ya es tuyo para que sigas enredado en este fantástico mundillo.

Haciendo nuestro primer "Hola mundo"

Hasta aquí hemos visto la estructura mínima de un programa, pero si ejecutamos dicho programa en nuestra Wii sólo conseguiremos una pantalla en negro de la que se puede salir pulsando "home".

Si queremos que nuestro programa haga algo tenemos que añadir algunas instrucciones más dentro y fuera del bucle.

Para entender las instruciones que tenemos que añadir vamos a ver como funcionan las variables y los punteros en C.

Variables y tipos de datos en C

Como muchos de vosotros ya sabréis, una variable es una posición de memoria con nombre que se usa para mantener un valor. En C todas las variables deben ser declaradas antes de poder usarlas.

La forma general para declar una variable es la siguiente:

tipo lista_de_variables;

Aquí, tipo debe ser un tipo de datos válido en C y lista de variables una lista de nombres separada por comas.

Ejemplo:

int i,j,l;
float numero:
double a, b, c;

Existen tres sitios donde se puede declarar una variable:

• Dentro de las funciones.
• En la definición de parámetros de las funciones.
• Fuera de todas las funciones.

Hay que tener en cuenta que antes de que el programa llegue a la declaración de dicha variable, ésta no es visible en el programa.

Si colocamos un signo igual y una constante después del nombre de una variable se puede dar a la mayoría de las variables valor mientras se declaran.

La forma general de inicialización es:

tipo nombre_de_variable = constante;

Ejemplo:

char ch = 'a';
int primero = 0;
float balance = 123.23;

Punteros a variables

Un puntero es una dirección de memoria de una variable. Una variable de puntero es una variable específicamente declarada para contener un puntero.

En C los punteros tienen tres funciones básicas:

• Referenciar los elementos de un array (por ejemplo una cadena de caracteres es un array de char)
• Pasar parámetros a funciones que puedan ser modificados dentro de estas y conservar su valor una vez salimos de las funciones.
• Dar soporte a las listas enlazadas. (esto probablemente no lo tocaremos)

Para manejar punteros existen dos operadores que veremos a continuación.

El primer operador es &. Este operador devuelve la dirección de memoria de lo que pongamos detrás.

Ejemplo:

m = &cont;

guardará en la variable m la dirección de memoria de la variable cont.

Se puede pensar en & como "la dirección de".

Supongamos que la variable cont utiliza la posición de memoria 2000 para guardar su valor, supongamos además que el valor de cont es 100. Después de la asignación anterior, el valor de m será 2000.

El segundo operador de punteros es *. Éste operador es el complementario de &, y devuelve el valor de la variable ubicada en la dirección de memoria contenida en la variable de puntero que situamos a continuación. Por ejemplo si m contiene la dirección de memoria de la variable cont, entonces:

q = *m;

colocará el valor de cont en q. Siguiendo el ejemplo q tendrá un valor de 100, ya que el valor de cont era 100.

Las variables que vayan a contener punteros se han de declarar como tales. La declaración general de dichas variables se realiza colocando un * delante del nombre de variable.

Por ejemplo:

char *c;

Aquí la variable c no es un caracter, sino un puntero a caracter, es decir contiene la dirección de memoria de una variable tipo caracter.

Manejando fuentes TrueType en GRRLIB

Como os decía antes, en Wii no es tan sencillo como en un PC hacer un "Hola mundo". Lo primero que necesitamos para hacer nuestro Hola Mundo es lo que llamamos una fuente True Type.

Para poder usar dicha variable tendremos que incluir al principio de nuestro programa la siguiente línea:

#include "verdana_ttf.h"

El archivo verdana_ttf.h ha sido creado de forma automática por nuestro compilador con las variables verdana_ttf y verdana_ttf_size, que contienen la información de la fuente y su tamaño respectivamente.

Como norma general el compilador creará un archivo con el mismo nombre que el archivo de fuente, sustituyendo el "." por un guión bajo y añadiendole ".h". Los nombres de las variables, como habéis podido comprobar siguen reglas similares.

Una vez tenemos la información del archivo en la variable verdana_ttf no la podemos usar directamente la convertiremos con GRRLIB_LoadTTF cuya sintaxis es como sigue:

GRRLIB_ttfFont* GRRLIB_LoadTTF ( const u8 *file base, s32 file size )
Carga fuente TTF desde una variable en memoria.
 
Parametros
file_base Buffer con los datos del archivo TTF.
file_size Tamaño del Buffer TTF
 
Devuelve
Una variable tipo GRRLIB_ttfFont.

void GRRLIB PrintfTTF ( int x, int y, GRRLIB_ttfFont *myFont, const char *string, 
	unsigned int fontSize, const u32 color )	
Función que imprime un texto con una fuente TTF
 
Parametros:
x			Coordenada x de la esquina superior izquierda del texto
y			Coordenada y de la esquina superior izquierda del texto.
myFont		Una fuente TTF.
string		Texto a mostrar.
fontSize 	Tamaño en puntos de la fuente
color		Color del texto en formato RGBA

#include <grrlib.h>
#include <stdlib.h>
#include <wiiuse/wpad.h>
#include "verdana_ttf.h"
 
int main(int argc, char **argv) {
 
	// Inicializar gráficos
	GRRLIB_Init();
 
	// Inicializar wiimotes
	WPAD_Init();
 
	GRRLIB_ttfFont *myFont = GRRLIB_LoadTTF(verdana_ttf, verdana_ttf_size); // lo convertimos al formato usado por GRRLIB
 
    // Bucle sin fin
	while(1) {
 
        WPAD_ScanPads();  // Leer mandos
 
        // Si pulsamos home salimos del bucle
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;
 
        GRRLIB_PrintfTTF(10,10, myFont, "Hola mundo", 20, 0xFFFFFFFF);
 
 
        GRRLIB_Render();  // Refrescamos la pantalla
    }
 
	GRRLIB_FreeTTF (myFont); // Liberamos la fuente truetype
 
//	}
    GRRLIB_Exit(); // Liberamos memoria
 
    exit(0);  // Usar exit para salir del program (no usar return desde el main)
}