El tutorial anterior, sólo se muestran las imágenes, no mencionó cómo mostrar texto, sí SDL no muestra la función de texto, tiene que usar SDL_ttf biblioteca ampliada de texto de la pantalla. TTF es un acrónimo de fuentes True Type, el TTF es la fuente predeterminada en Windows, tiene una hermosa, enfocar la ventaja de no deformación, y por lo tanto ampliamente utilizado en muchas ocasiones.
La primera biblioteca cosa ttf utilizando fuentes de Windows desde una fuente a cabo la siguiente copia, preferiblemente la fuente china, que puede apoyar tanto Inglés y visualización chino. Por lo general se encuentra en c: \ windows \ fonts directorio. Por ejemplo, en simhei.ttf negrita es la imitación, copia este archivo en el directorio de archivos fuente.
Para utilizar la biblioteca SDL_ttf primero debe descargar las extensiones: http: //www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf.html
la descarga se ha completado antes de la instalación por la forma (instalación SDL tutorial no hablar), entonces su el archivo de origen para cargar el archivo de cabecera "SDL_ttf.h". Para mostrar el texto debe realizar los siguientes pasos:
biblioteca inicial A TTF
biblioteca inicialización TTF ser llamado TTF_Init (), un retorno éxito -1, 0 se devuelve éxito.
En segundo lugar abrir una fuente TTF_Font.
Uso TTF_Font * TTF_OpenFont (char const * archivo , int ptsize); función abre la fuente
qué archivo es la ruta del archivo de fuente puede ser una ruta relativa o absoluta, ptsize se refiere a tamaño, es decir, el tamaño de fuente. Se basa, hay una forma sencilla de estimar el tamaño de la fuente, seleccionar el tamaño adecuado puede ser visto en Word a efecto, devuelve NULL 720 ppp no tiene éxito. El siguiente es un código abierto junto tamaño de la fuente de cuerpo negro 20, archivo de fuente con el archivo original en el mismo directorio.
// Abrir simfang.ttf fuente, el número del sistema 20 es
font = TTF_OpenFont ( "simhei.ttf", 20 es);
IF (fuente == NULL)
{
fprintf (stderr, "% S de fuente abierta fracaso \ n-", SDL_GetError ( ));
Exit (-1);
}
En tercer convertir texto en una superficie
con el fin de mostrar texto, en primer lugar para representar el texto en una imagen, la imagen Representación del texto en una superficie, hay tres renderizado:
Sólido haciendo que el más rápido, pero menos eficaz, el texto no es suave, es monocromo texto, sin fronteras.
La sombra de representación más lento de lo sólido, pero la pantalla es mejor que el sólido, a la sombra.
Mezcla de renderizado el más lento, pero la pantalla es la mejor.
IV. SDL_Surface la salida de texto para la visualización en pantalla, si no se requiere, debe liberar
el texto como superficie y otras superficies, se puede transmitir a la superficie de visualización de la pantalla.
Cinco estrecha TTF_Font fuente.
Uso vacío TTF_CloseFont (TTF_Font * fuente); cerca de la fuente
de la biblioteca TTF VI liberación
si no necesitan texto de la pantalla se puede liberar la biblioteca RSA, utilice TTF_Quit vacío ();
El siguiente ejemplo muestra cómo mostrar texto, el programa resultados operativos:
En este caso tenemos que aprender a mostrar occidental, china y cómo configurar el título del programa, icono. El código principal del programa es el siguiente:
#Include. 1 <stdio.h>
2 #include <stdlib.h>
. 3 #include <string.h>
. 4 #include "font.h"
. 5
. 6 int main (int argc, char * el argv [])
. 7 {
. 8 Char A [] = "el Hello World!";
. 9 int = 0 dejar de fumar;
10 wchar_t * P;
. 11 tmp char [] = "Hello World!";
12 se wchar_t MSG [] = L "decreto";
13 es
14 IF ( ! init ( "texto", "icon.bmp"))
15 {
16 Exit (0);
. 17}
18 es
. 19 // fuente simfang.ttf abierta, número de conjunto de fuentes 20 es
20 es TTF_OpenFont font = ( "simhei.ttf", 20 es);
21 es IF (fuente == NULL)
22 es {
23 es fprintf (stderr, "% S de fuente abierta fracaso \ n-", SDL_GetError ());
24 Exit (-1);
25}
26
27 gpBackground = loadImage ( "background.jpg");
28 applySurface (0,0, gpBackground, gpScreen);
29
30 // TTF_SetFontStyle (fuente, TTF_STYLE_BOLD | TTF_STYLE_ITALIC);
31
32 //显示西文
33 gpMessage [0] = TTF_RenderText_Solid (fuente, a, RGB_Black);
34 gpMessage [1] = TTF_RenderText_Shaded (fuente, a, RGB_Black, RGB_White);
35 gpMessage [2] = TTF_RenderText_Blended (fuente, a, RGB_Black);
36 applySurface (80120, gpMessage [0], gpScreen);
37 applySurface (80150, gpMessage [1], gpScreen);
38 applySurface (80180, gpMessage [2], gpScreen);
39 SDL_Flip (gpScreen);
40
41
42 //显示中文
43 p = cstringToUnicode (TMP);
44 gpChinese = TTF_RenderUNICODE_Solid (fuente, p, RGB_Black);
45 applySurface (340120, gpChinese, gpScreen);
46 SDL_FreeSurface (gpChinese);
47 gpChinese = TTF_RenderUNICODE_Shaded (fuente, p, RGB_Black, RGB_White);
48 applySurface (340150, gpChinese, gpScreen);
49 SDL_FreeSurface (gpChinese);
50 gpChinese = TTF_RenderUNICODE_Blended (fuente, p, RGB_Black);
51 applySurface (340180, gpChinese, gpScreen);
52 SDL_FreeSurface (gpChinese);
53 SDL_Flip (gpScreen);
54 libre (p);
55 p = NULL;
56
57 TTF_CloseFont (fuente);
58
59 //重新打开simfang.ttf字库,设字体为40
60 font = TTF_OpenFont ( "simhei.ttf", 40);
61 Si (fuente == NULL)
62 {
63 fprintf (stderr, "fracaso abierto fuente% s \ n", SDL_GetError ());
64 de salida (-1);
} 65
66 gpChinese = TTF_RenderUNICODE_Solid (fuente, MSG, RGB_Yellow);
67 applySurface (260,50, gpChinese, gpScreen);
68 SDL_Flip (gpScreen);
69 SDL_FreeSurface (gpChinese);
70
71 es gpChinese = TTF_RenderUNICODE_Solid (fuente, L "C Idioma siempre imitado, nunca superado "RGB_Red) ;!
72 applySurface (100.240, gpChinese, gpScreen);
73 SDL_FreeSurface (gpChinese);
74
75 gpChinese = TTF_RenderUNICODE_Solid (fuente, L" no dicen que ellos no entienden programador de lenguaje C !", RGB_Red);
76 applySurface (100300, gpChinese, gpScreen);
77 SDL_FreeSurface (gpChinese);
78 SDL_Flip (gpScreen);
79
80 // evento de manipulación
81 el tiempo (qUIT)
82 {
83 IF (SDL_PollEvent (y MyEvent))
{84
85 IF (myEvent.type == SDL_Quit)
86 {
87 dejar de fumar = 1;
88}
89}
90}
91 return 0;
92}
En donde font.h propia declaración archivo de cabecera definición variables utilizadas comúnmente, constantes, funciones, las cuales código es el siguiente:
#ifndef FONT_H_2012_05_31
#define FONT_H_2012_05_31
# include "SDL.h"
# include "SDL_image.h"
# include "SDL_ttf.h"
# include <Windows.h>
// definir Boolean
typedef int BOOL;
. #Define TRUE 1
#define FALSO 0
// resolución de la pantalla
# define SCREEN_WIDTH 718
#define SCREEN_HEIGHT 419
#define SCREEN_BPP 32
// superficie declarar
extern SDL_Surface * gpBackground; // superficie de fondo
extern SDL_Surface * gpScreen; // superficie de la pantalla
extern SDL_Surface * gpMessage [3]; // superficie texto occidental
SDL_Surface extern * gpChinese; // superficie de escritura china
// declaración evento
externo SDL_Event MyEvent;
// fuente declaración
extern TTF_Font * fuente;
/ *****************************声明常见颜色***************** ************************ /
const extern SDL_Color RGB_Black;
extern const SDL_Color RGB_Red;
extern const SDL_Color RGB_Green;
extern const SDL_Color RGB_Blue;
extern const SDL_Color RGB_Cyan;
extern const SDL_Color RGB_Magenta;
extern const SDL_Color RGB_Yellow;
extern const SDL_Color RGB_White;
extern const SDL_Color RGB_Gray;
extern const SDL_Color RGB_Grey;
extern const SDL_Color RGB_Maroon;
extern const SDL_Color RGB_Darkgreen;
extern const SDL_Color RGB_Navy;
extern const SDL_Color RGB_Teal;
extern const SDL_Color RGB_Purple;
extern const SDL_Color RGB_Olive;
extern const SDL_Color RGB_Noname;
/ *****************************函数声明****************** *********************** /
BOOL init (char * aCaption, char * Aicon);
SDL_Surface * loadImage (char * filename);
applySurface vacío (int x, int y, SDL_Surface * fuente, SDL_Surface * destino);
limpieza void ();
char * localeToUTF8 (char * src);
wchar_t * cstringToUnicode (char * CAES);
#terminara si
En el que citó windows.h, porque para hacer el carácter ancho conversión y la cadena de lenguaje C en donde la función de uso. C lenguaje en sí mismo no hace tipo BOOL, por lo que el uso typedef definir su propio tipo de Boole y declara constantes booleanas VERDADERO y FALSO.
Aquí empezamos con la función principal, las líneas de fila 10 y 12 vemos un nuevo tipo de datos wcha_t, de hecho, este es un tipo que acaba de agregar C99 caracteres anchos, tipo de lenguaje C carbón representados por un un byte ANSI personajes, sino personajes, como los caracteres japoneses no se pueden representar, por lo que la introducción de wchar_t, wchar_t representa un personaje con dos bytes, por lo que puede representar la gran mayoría de los personajes, si es el tipo de lenguaje, caracteres unicode wchar_t es una implementación en lenguaje C, cadena unicode en general son de tipo wchar_t. TTF biblioteca ofrece una visualización de secuencia de la secuencia Unicode UTF-8 y la pantalla, para mostrar chino debe haber dos cadenas que se mostrarán.
La línea 14 de la función init completar la inicialización del sistema, incluyendo la inicialización de SDL, el establecimiento de la ventana principal, la biblioteca de inicialización TTF, establecer el título del programa, icono. Código es el siguiente:
/ *
Nombre de la función: init
Función: para completar la inicialización del sistema
parámetros de la función: aCaption barra de título muestra el nombre del programa, el lenguaje C de cadena
icono del programa Aicon, debe ser de 32 * 32bmp foto
función Valor de retorno: Ninguno
* /
BOOL init (char * aCaption , Aicon char *)
{
// inicializar la SDL
IF (SDL_Init (SDL_INIT_EVERYTHING) == -1)
{
FALSO retorno;
}
// Cargar el icono del programa
SDL_WM_SetIcon (SDL_LoadBMP (Aicon), NULL );
// Inicialización ventana
gpScreen = SDL_SetVideoMode (SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE || SDL_HWSURFACE);
SI (gpScreen == NULL) // detecta si la inicialización con éxito
{
FALSO retorno;
}
atexit (Cleanup);
// Inicializar la biblioteca de fuentes
IF (TTF_Init () == -1)
de retorno FALSE;
// establecer el nombre de la ventana y el icono
SDL_WM_SetCaption (localeToUTF8 (aCaption), NULL);
return TRUE;
}
Nota Para configurar el icono del programa, se debe llamar antes del establecimiento de la ventana SDL_WM_SetIcon principal (SDL_LoadBMP (Aicon), NULL); para establecer el icono, el icono debe ser bmp foto 32 * 32, debido a la biblioteca TTF no es SDL propia, por lo que debe llamar TTF_Init ( ) inicialización solo; último título del programa conjunto, tenga en cuenta el título si el Inglés se puede visualizar directamente, pero si nos gusta este programa de manera que la pantalla china, debe convertir la cadena en UTF-8 con el fin de mostrar, por lo que llamamos a una función personalizada localeToUTF8 ( aCaption) el proceso de convertir una cadena a UTF8 c cadena de formato de lenguaje, esta función se define de la siguiente manera:
/ * ------------------------------------------------ --------------------
nombre de la función: localeToUTF8
parámetros: char * cadena lenguaje C src
valor de retorno: char * cadena UTF8
funciones: la cadena en lenguaje C UTF8 cadena
Nota:
--------------------------------------------- * ------------------------- /
char * localeToUTF8 (char * la src)
{
static char * buf = NULL;
wchar_t * unicode_buf;
int nRetLen;
si (BUF) {
libre (buf);
buf = NULL;
}
NRetLen = MultiByteToWideChar (CP_ACP, 0, src, -1, NULL, 0);
unicode_buf = (wchar_t *) malloc ((nRetLen + 1) * sizeof (wchar_t));
MultiByteToWideChar (CP_ACP, 0, src, -1, unicode_buf, nRetLen);
nRetLen = WideCharToMultiByte (CP_UTF8,0, unicode_buf, -1, NULL, 0, NULL, NULL);
buf = (char *) malloc (nRetLen + 1);
WideCharToMultiByte (CP_UTF8,0, unicode_buf, -1, buf, nRetLen, NULL, NULL);
libre (unicode_buf);
buf regresar;
}
Esta función convierte la cadena de finalización lenguaje C en la cadena de formato UTF8. Por lo que podemos definir el título del programa chino.
En la línea 20 de las principales funciones que abrimos una biblioteca de fuentes, y establecer el tamaño de la fuente a 20, aproximadamente del tamaño de la fuente se puede abrir la palabra a mirar el tamaño de la fuente. A continuación, se llama TTF_RenderText_Solid línea 33 hará que el texto en una imagen, la imagen devuelve un puntero a la superficie, esta función sólo puede mostrar occidental, el chino no se puede visualizar. El prototipo:
SDL_Surface * TTF_RenderText_Solid (TTF_Font fuente *, const char * texto, SDL_Color FG);
parámetros: fuente, la fuente abierta; sarta de lenguaje C con formato de texto que se mostrará (en \ 0 ¿terminador); fg es el color del texto, se introdujo a principios de estructura SDL_Color, no voy a decir nada más.
Además de esta representación, así como:
SDL_Surface * TTF_RenderText_Shaded (fuente TTF_Font *, const char * texto, SDL_Color fg, SDL_Color BG);
que, como la fuente, el texto y fg en el TTF_RenderText_Solid, bg color de fondo del texto.
SDL_Surface * TTF_RenderText_Blended (* TTF_Font fuente, const char * texto, SDL_Color fg) parámetros y TTF_RenderText_Solid como anteriormente en relación con las tres diferencias de representación ya mencionados, la página de resultados muestra los mejores mezcla, sólida peor, la sombra se puede configurar el fondo del texto.
A continuación, muestran la misma imagen y visualizar estas superficies pueden ser, y 36-40 que llamamos un texto de la pantalla función personalizada:
applySurface vacío (int x, int y, SDL_Surface Fuente *, haces * Dónde quiere SDL_Surface);
posición X, Y del texto que aparece en la pantalla, el texto fuente de la superficie, ¿Dónde quieres que la superficie del blanco es, en general, que muestra una superficie.
espectáculo occidental es relativamente simple. Mostrar pequeños focos de tensión chinos, si se pone tmp char [] = "Hola mundo!"; Para la pantalla, llamada sólo TTF_RenderText_Solid muestran un montón de galimatías, porque esta función sólo puede mostrar occidental, si desea mostrar falta chino a la llamada :
cadena UTF8 pantalla
SDL_Surface * TTF_RenderUTF8_Solid (TTF_Font fuente *, const char * texto, SDL_Color FG);
SDL_Surface * TTF_RenderUTF8_Shaded (TTF_Font fuente *, const char * texto, SDL_Color FG, SDL_Color BG);
SDL_Surface TTF_RenderUTF8_Blended * (* fuente TTF_Font, const char * texto, SDL_Color fg) ;
pantalla unicode cadena
SDL_Surface TTF_RenderUNICODE_Solid * (* TTF_Font fuente, texto const * Uint16, SDL_Color FG);
SDL_Surface TTF_RenderUNICODE_Shaded * (* TTF_Font fuente, texto const * Uint16, SDL_Color FG, SDL_Color BG);
* TTF_RenderUNICODE_Blended SDL_Surface (TTF_Font * fuente, const Uint16 * texto, SDL_Color fg);
codificación UTF8 favor verifica: http: //baike.baidu.com/view/25412.htm; UNICODE de codificación por favor verifica: http: //baike.baidu .com / vista / 40801.htm
parámetros y funciones similares a los de delante, la única diferencia es el requisito deberá ser texto o en formato unicode UTF-8. Cómo convertir cadenas de lenguaje C en la cadena de UTF-8 o Unicode cadena de ella, ya que utilizamos carbón función definida anteriormente * localeToUTF8 (char * src) a la secuencia de c en la cadena UTF8 se devuelve, la secuencia de c en cadena unicode, definimos sus propias funciones:
/ * ------------------------------------------------ --------------------
función nombre: cstringToUnicode
parámetros: char * cadena de lenguaje C src
valor de retorno: wchar_t * Unicode cadenas
función: cadena en lenguaje C cadena unicode
Nota:
--------------------------------------------- * ------------------------- /
wchar_t cstringToUnicode * (char * CAES)
{
int size;
unicodestr wchar_t * = NULL;
if (! CAES)
{
retorno NULL;
}
size = la MultiByteToWideChar (CP_ACP, 0, ASRC, -1, NULL, 0);
unicodestr = la malloc (. (tamaño + 1) * el sizeof (wchar_t));
la MultiByteToWideChar (CP_ACP, 0, ASRC, -1, unicodestr, tamaño);
retorno unicodestr;
}
Esta función será completar las cadenas de la conversión del lenguaje C a cadena Unicode se devuelve, utilice estas funciones notar que en nuestra función dinámicamente asigna memoria para almacenar UTF8 o una cadena Unicode, y luego regresar, por lo que llamamos a la función estas cadenas deben ser liberados después de que el espacio de exposición ocupada. La línea 43 será la cadena principal función tmp Unicode se convierte en una parte posterior de cadena a p, entonces la pantalla 54 se libera en una fila p.
En la línea 57 cerramos frente a una fuente abierta, porque aquí vamos a utilizar un tipo de letra más grande, si desea mostrar los chinos, de hecho, la forma más fácil es definir directamente tipo array wchar_t de cadenas Unicode almacenados en el programa se pueden visualizar directamente esta cadena, en la línea 12 definimos msg wchar_t [] = L "decreto"; cadena unicode, cadena unicode atención deben comenzar con L, de lo contrario se trata de una cadenas de lenguaje C. En la línea de los EEUU 66-69 directamente a la pantalla mostrará una. También puede mostrar las constantes de cadena Unicode, los primeros 71-78 filas que muestran las dos constantes de cadena Unicode.
Aquí hablamos sólo los chinos que el problema debajo de la plataforma de Windows, si va a ser diferente en Linux, se puede comprobar la plataforma Linux específica información relevante. Si quieres un ejemplo del código fuente, haga clic aquí. archivo de fuentes de código es demasiado grande, borrado, puede copiar un archivo desde el directorio de fuentes TTF chino bajo el directorio de Windows al archivo de origen en él.