Usar Fontes TTF em C++ e SDL

Posted by admin on 3 de Fevereiro de 2014 | Filed under Línguagens de Programação, Programação

font

Para que possamos usar tipos de letra variados e específicos quando programamos em C++ e SDL necessitamos de usar fontes, e é isso que eu vou mostrar neste post.

Antes de qualquer outra coisa necessitamos de fazer o download de uma fonte no formato TTF, que são facilmente encontradas pela Internet.

O código que eu criei para este exemplo é o seguinte:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
//Include da Biblioteca SDL, Funcoes e tipos de dados
#include <sdl /SDL.h>
#include "SDL/SDL_image.h" //Biblioteca para poder fazer upload de imagens JPG, PNG
#include </sdl><sdl /SDL_ttf.h> //Biblioteca para fazer o uso das font's 
 
//Função para ajustar os espaço entre cada imagem individual do sprite
void setrects(SDL_Rect* clip)
{
        for(int i = 0; i < 7; i++) {
                //Basicamente a cada iteração do ciclo é incrementado 132px na imagem para obter o frame seguinte
                clip[i].x = 0 + i*132; 
                clip[i].y = 0;
                clip[i].w = 125;
                clip[i].h = 145;
        }
}
 
int main(int argc, char** argv)
 
{     // Inicializacaodo SDL
        SDL_Init(SDL_INIT_EVERYTHING);
 
        //Definição do Ecra
        SDL_Surface *screen = NULL;
        screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
        //Upload de imagens para memória
        SDL_Surface *image = NULL; //definição da variável de load da imagem
        //image = SDL_LoadBMP("Idle.bmp"); //upload de imagens BMP apenas
        image = IMG_Load("exp.png"); //upload de imagens JPG, PNG
        //Inicialização da biblioteca TTF
        TTF_Init();
        //Upload da fonte desejada
        TTF_Font* font = TTF_OpenFont("SIXTY.TTF", 36); //path da fonte, tamanho da fonte
 
        SDL_Surface *text; //definição da variável de load da fonte
 
        //Boleano para o teste de execucao
        bool running = true;
 
        //4 direcções
        bool b[4] = {0, 0, 0, 0};
 
        //Definicao dos controladores de FPS
        const int FPS = 30;
        Uint32 start;
 
        //Definicao dos pontos e da recta para desenho do quadrado no ecra
        SDL_Rect rect;
        rect.x = 0; //ponto de partida da imagem
        rect.y = 340;  //ponto de partida da imagem
        rect.w = 640; //alcance no eixo do x da imagem
        rect.h = 480; //alcance no eixo do y da imagem
 
        //Definição de variável para a velocidade dos frames
        float frame = 0;
 
        //Definicao das cores a usar quer em background quer no quadrado desenhado
        Uint32 color = SDL_MapRGB(screen->format, 0xff,0xff,0xff); // cor branca background
        Uint32 color2 = SDL_MapRGB(screen->format, 0,0,0);
 
        //Array para guardar cada imagem referente à animação do sprite
    SDL_Rect rects[7];
 
    //Chamada da Função para ajustar os espaço entre cada imagem individual do sprite
    setrects(rects);
 
    //Definição da Cor da  Fonte
    SDL_Color color3 =  {0,0,0};
    //Definição do texto a imprimir
    text = TTF_RenderText_Solid(font, "Hey, My Name is Nuno!", color3);
 
        //teste de verificacao da execução
        while(running) 
        {
                start = SDL_GetTicks();
                SDL_Event event;
 
                while(SDL_PollEvent(&event)) 
                {
                        switch(event.type) 
                        {
                                //caso escolha sair (x) termina a execuçao
                                case SDL_QUIT:
                                        running = false;
                                        break;
 
                                //caso Tecla Esteja pressionada
                                case SDL_KEYDOWN:
                                        switch(event.key.keysym.sym) 
                                        {
                                                case SDLK_DOWN: //Cima
                                                        b[0] = 1;
                                                        break;
                                                case SDLK_RIGHT: //Direita
                                                        b[1] = 1;
                                                        break;
                                                case SDLK_UP: //Baixo
                                                        b[2] = 1;
                                                        break;
                                                case SDLK_LEFT: //Esquerda
                                                        b[3] = 1;
                                                        break;
 
                                        }
                                        break;
 
                                //caso Tecla Não Esteja pressionada
                                case SDL_KEYUP:
                                        switch(event.key.keysym.sym) 
                                        {
                                                case SDLK_DOWN: //Cima
                                                        b[0] = 0;
                                                        break;
                                                case SDLK_RIGHT: //Direita
                                                        b[1] = 0;
                                                        break; 
                                                case SDLK_UP: //Baixo
                                                        b[2] = 0;
                                                        break;
                                                case SDLK_LEFT: //Esquerda
                                                        b[3] = 0;
                                                        break;
 
                                        }
                                        break;
                        }
                }
 
                //case UP pressionado decrementa 1 a Y
                if(b[0])
                        rect.y++;
                //Caso LEFT pressionado decremetna 1 a X
                if(b[1])
                        rect.x++;
                //case Down pressionado incrementa 1 a Y
                if(b[2])
                        rect.y--;
                //Caso RIGHT pressionado incremetna 1 a X
                if(b[3])
                        rect.x--;
 
                //Desenhar o background
                SDL_FillRect(screen, &screen->clip_rect, color);
                //Desenhar o texto na tela
                SDL_BlitSurface(text, NULL, screen, NULL);
 
                //Desenhar a Imagem no Ecrã
                SDL_BlitSurface(image, &rects[static_cast<int>(frame)], screen, &rect); // os argumentos começam pela imagem = image, pela sua orientação no ecrã = &rect e screen indica onde será apresentada
 
                //Update Screen
                SDL_Flip(screen);
 
                //Velocidade de transição entre frames
                frame += 0.5;
 
        if(frame > 7) {
                frame = 0;
        }
 
                if(1000/FPS > SDL_GetTicks()-start) 
                {
                        SDL_Delay(1000/FPS-(SDL_GetTicks()-start));
                }
 
        }
 
        //Libertar a imagem da memória
        SDL_FreeSurface(image);
        //Libertar a fonte da memória
        SDL_FreeSurface(text);
        //Fechar o upload da fonte
        TTF_CloseFont(font);
        //Terminar a execução da biblioteca TTF
        TTF_Quit();
 
        //Quit SDL
        SDL_Quit();
 
        return 0;
}
</int></sdl>

 

Um dos pormenores ao compilar o código é a necessidade de ser adicionada uma nova flag, mais precisamente a flag lSDL_ttf resultando no seguinte:

g++ -o exp exp.cpp -lSDL -lSDL_image -lSDL_ttf

Todo o código está comentado para que possa facilmente ser percebido.

 

 

Share

Leave a Reply