1
2
3

// Incluimos las librerias de FreeType y FTGL
#pragma comment( lib, "freetype2312MT.lib" )
#pragma comment( lib, "ftgl_static.lib" )

1
2
3
4
5
6
7

// Definimos esto para que FTGL sepa que la 
// estamos usando de forma estatica.
// Si la hubieramos compilado con DLL no 
// habria que definirlo.
#define FTGL_LIBRARY_STATIC 1
// Incluimos el fichero de cabecera
#include <FTGL/ftgl.h>

1
2
3
4
5
6
7

// Variable de tipo unsigned int para guardar 
// el identificativo base de las "display list"
// que generara para almacenar las letras.
// A partir de este, los siguientes, en orden,
// seran usados en estricto orden.
// Ya no es necesario al usar FTGL para el texto
//GLuint	ListaFuente=0;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Creamos un objeto de fuente en textura para 
// las letras de la leyenda.
FTTextureFont fuente("dibus/comic.TTF");
// FTGL permite fuentes tipo raster que
// no usaremos al ser mas lentas.
// Si se quiere comparar hay que comentar 
// la linea anterior y descomentar esta.
//FTPixmapFont fuente("dibus/comic.TTF");
 
// Objeto texture font para el cartel grande
// que pondremos.
FTTextureFont fuente2("dibus/coop.TTF");
// Objeto outline font para el borde de las
// letras del cartel grande.
FTOutlineFont fuente3("dibus/coop.TTF");

1
2
3
4
5
6

// Pongo proyeccion ortogonal.
// Damos la vuelta a la proyeccion.
// FTGL la usa al reves que nosotros,
// que solemos usar esta:
// glOrtho(0,rect.right,rect.bottom,0,-1,1)
glOrtho(0,rect.right,0,rect.bottom,-1,1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// La antigua forma de pintar texto no hace falta.
 
// Le indico donde va a empezar a pintar de la
// pantalla en base a los parametros de nuestra
// funcion.
//glRasterPos2i(x,y);
// Esta funcion guarda los valores de lista. 
//glPushAttrib(GL_LIST_BIT);				
// Establecemos el identificativo base de las listas
// a usar (-32 porque el caracter de la fuente con valor
// ASCII mas bajo es el espacio cuyo valor es 32, y de ahi 
// para arriba.
//glListBase(ListaFuente-32);		
// Ejecuto tantas listas como la longitud del texto a 
// escribir, los indices son del tipo unsigned byte y 
// los indices de las listas estan en el puntero que se 
// pasa como tercer parametro(los codigos ASCII del texto).
// A estos indices se les suma la base establecida en la  
// funcion anterior.
//glCallLists(strlen(texto), GL_UNSIGNED_BYTE, texto);	
// Restablezco los valores de lista.
//glPopAttrib();

1
2
3
4
5

// Creamos un buffer para guardar una cadena de
// caracteres unicode. Lo hacemos asi para evitar 
// problemas desagradables si usamos caracteres con tilde
// o apertura de exclamacion o interrogacion, o dieresis.
wchar_t unicode[256];

1
2
3

// Convertimos el texto a escribir a unicode y lo 
// guardamos en el buffer.
MultiByteToWideChar(CP_ACP, 0, texto, -1, unicode, 256);

1
2
3
4
5
6
7
8
9

// Movemos lo que vamos a escribir a su sitio.
// Al cambiar la proyeccion, las coordenadas Y comienzan
// abajo en vez de arriba asi que para cabiarlo y darle
// las coordenadas empezando por arriba como en todo el programa,
// restaremos la coordenada que le damos (empezando arriba)
// del tamaño de nuestro area de dibujo.
// La funcion Descender() retorna la distancia de la fuente
// que baja de la linea de escritura.
glTranslatef(x, rect.bottom-y-fuente.Descender(), 0);

1
2
3
4

// Si en vez de TextureFont queremos probar los PixmapFont
// (tipo raster) para ver como nos ralentiza el programa
// hay que comentar la linea anterior y descomentar esta.
//glRasterPos2i(x,rect.bottom-y-fuente.Descender() );

1
2

// Por fin pintamos en pantalla el texto unicode.
fuente.Render(unicode);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Voy a pintar un cartel 
// Cambio a matriz de proyeccion
glMatrixMode(GL_PROJECTION);
// Cargo la matriz identidad
glLoadIdentity();
// Pongo la proyeccion ortogonal que 
// FTGL necesita.
glOrtho(0,rect.right,0,rect.bottom,-1,1);
// Vuelvo a la matriz de modelo
glMatrixMode(GL_MODELVIEW);
// Cargo la matriz identidad
glLoadIdentity();
// Pongo un azul claro
glColor3f(0.3,0.5,0.9);
// Voy donde quiero pintar	
glTranslatef(10,rect.bottom-120,0);
// Giro un poco el texto
glRotatef(10,0,0,-1);

1
2
3
4
5

// Pinto las letras. Uso la "L"
// para indicar que es una cadena unicode.
// En otros compiladores distintos de VC
// como MinGW no se puede hacer asi.
fuente2.Render(L"¡Letra FTGL!");

1
2
3
4
5
6
7
8
9

// Pongo el grosor de lineas a 2
glLineWidth(2);
// Pongo amarillo
glColor3f(1,1,0);
// Lo muevo un poquito adelante para 
// asegurarme que se pinta por encima.
glTranslatef(0,0,0.1);
// Pinto el borde de las letras.
fuente3.Render(L"¡Letra FTGL!");

1
2
3

// Ya no hace falta esto.
// Genero la fuente con la que voy a escribir.
//GeneraFuente();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Preparo las fuentes que voy a usar
// Indico que no use Display List
fuente.UseDisplayList(false);
// Me aseguro que usa unicode
fuente.CharMap(ft_encoding_unicode);
// Le pongo el tamaño
fuente.FaceSize(12);
// Lo mismo para la segunda
fuente2.UseDisplayList(false);
fuente2.CharMap(ft_encoding_unicode);
fuente2.FaceSize(50);
// ...y para la tercera. Esta del mismo 
// tamaño que la anterior porque es un 
// OutlineFont que usaremos para el borde 
// del texto escrito con la fuente 2.
fuente3.CharMap(ft_encoding_unicode);
fuente3.UseDisplayList(false);
fuente3.FaceSize(50);

1
2
3

// Borro las listas.
// Ya no hace falta esto
//glDeleteLists(ListaFuente, 256-32);