
	Conheça a iniciativa da Biblioteca dos Desenvolvedores


	Índice da Biblioteca


	Área dos Usuários


	Fórum de Discussão

39 - Escrevendo na tela com AllegroGL e GLUT

Nós avançamos rapidamente nossos estudos com o OpenGL,
o ato de escrever na tela a partir de agora vai ser necessário para entender os funcionamentos bases de nossos programas.

Existem muitos tutoriais ensinando a utilizar as funções da OpenGL, mais nenhum deles explica detalhes importantes nos programas.
Isto acaba bloqueando o aprendizado da tecnologia, e pensando nisto nos vimos obrigados a abordar este assunto agora!

A leitura deste tutorial é obrigatória para o aprendizado da OpenGL.
E por incrível que pareça, este material é escasso na internet!

Em todo jogo existe a necessidade de mostrar informações na tela.
Essas informações variam desde o status do personagem principal ao tempo de jogo controlado pelo próprio cenário.

VOCÊ PRECISA SABER...

Mostrar informações na tela será imprescindível para que possamos compreender como funcionam algumas funções da OpenGL.

O objetivo desse artigo é mostrar de uma maneira simples e objetiva como escrever na tela usando a biblioteca AllegroGL e Glut.
A fonte utlizada não vai apresentar nenhum tipo de personalização.

O código a seguir mostra como escrever na tela usando o AllegroGL

CÓDIGO...

// Exemplo de como escrever na tela em AllegroGL
// Autor: Bruno A. Rovela
// BDJogos
// Data: 29/10/2007
#include <allegro.h>
#include <alleggl.h>

FONT *agl_font = NULL;

int main()
{
   // Iniciações básicas da Allegro
   allegro_init();
   install_keyboard();

   // Iniciação da AllegroGL
   install_allegro_gl();
   allegro_gl_set(AGL_Z_DEPTH, 8);
   allegro_gl_set(AGL_COLOR_DEPTH, 16);
   allegro_gl_set(AGL_SUGGEST, AGL_Z_DEPTH | AGL_COLOR_DEPTH);

   // Setando o Modo Gráfico
   set_gfx_mode(GFX_OPENGL_WINDOWED, 640, 480, 0, 0);

   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

   // Iniciando a camera
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 60.0);
   glEnable(GL_TEXTURE_2D);

   agl_font = allegro_gl_convert_allegro_font(font, AGL_FONT_TYPE_TEXTURED, 250.0f);

   // Laço principal
   while( !key[KEY_ESC] )
   {
      glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

      glLoadIdentity();
      glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      allegro_gl_printf(agl_font, -0.25f, 0.20, 0.0f, makecol( 000, 255, 000), "EXEMPLO - NOTA %d", 1000);
      allegro_gl_printf(agl_font, -0.15f, 0.10, 0.0f, makecol( 255, 255, 000), " BD JOGOS");
      allegro_gl_printf(agl_font, -0.20f, 0.0f, 0.0f, makecol( 000, 000, 255), "Viva Allegro GL");

      allegro_gl_flip();
   }

   allegro_gl_destroy_font(agl_font);
   allegro_exit();
   return 0;
}
END_OF_MAIN();

FIM DE CÓDIGO...

Primeiramente precisamos declarar um ponteiro do tipo FONT.

O próximo passo é habilitar o sistema de textura 2D do OpenGL.
Sistemas de texturas serão vistos com mais calma mais tarde... Sem ele não conseguimos visualizar a fonte na tela.

Em seguida é necessário preencher o ponteiro com uma fonte texturizada.

VOCÊ PRECISA SABER...

O tamanho da fonte é dado em escala e se encontra no último argumento do comando allegro_gl_convert_allegro_font, nesse caso é 250.0f.

Quanto maior o valor da escala menor fica o tamanho da fonte na tela.

Agora é necessário utilizar o comando que realmente irá escrever o texto na tela.

O comando allegro_gl_printf recebe como argumentos o tipo da fonte, posição x-y-z, cor da fonte, texto e argumentos complementares.

E para finalizar, sempre que declaramos algum ponteiro é necessário desaloca-lo.
Nesse caso, o comando que irá desalocar a fonte da memória é allegro_gl_destroy_font.

O código a seguir mostra como escrever na tela usando o GLUT

CÓDIGO...

// Exemplo de como escrever na tela em GLUT
// Autor: Bruno A. Rovela
// BDJogos
// Data: 15/10/2007
#include <GL/glut.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

static void display( void );
static void key( unsigned char key, int x, int y );
static void idle(void);
static void resize(int width, int height);

static void EspecialKey( int key, int x, int y );
void DesenhaTexto( char *string, float x, float y );

char texto[30];

// Main padrão, o programa inicia aqui
int main(int argc, char *argv[])
{
   glutInit(&argc, argv);
   glutInitWindowSize(640,480);
   glutInitWindowPosition(0,0);
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
   glutCreateWindow("Teclado em OpenGL");

   // callbacks
   glutReshapeFunc(resize);
   glutDisplayFunc(display);
   glutKeyboardFunc(key);
   glutIdleFunc(idle);
   glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

   strcpy(texto, "");

   glutMainLoop();

   return EXIT_SUCCESS;
}

// Função que é chamada quando a janela é redimencionada
static void resize(int width, int height)
{
   const float ar = (float) width / (float) height;

   glViewport(0, 0, width, height);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glFrustum(-ar, ar, -1.0, 1.0, 1.0, 60.0);

   glLoadIdentity() ;
}

// Função que é chamada quando for preciso mostrar ou atualizar a tela
static void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();

   glColor3d( 0, 255, 0 );
   sprintf( texto, "EXEMPLO - NOTA %d", 1000);
   DesenhaTexto( texto, -0.25f, 0.20f );

   glColor3d( 255, 255, 0 );
   sprintf( texto, "BD JOGOS" );
   DesenhaTexto( texto, -0.15f, 0.10f );

   glColor3d( 0, 0, 255 );
   sprintf( texto, "Viva Glut" );
   DesenhaTexto( texto, -0.15f, 0.0f );

   glutSwapBuffers();
}

static void key(unsigned char key, int x, int y)
{
   switch (key)
   {
      case 27 :
      {
         // Sai do programa quando o código ASCII for "27" (ESC)
         exit(0);
         break;
      }
   }
}

// Função que executa rotinas padrões da Glut
static void idle(void)
{
   glutPostRedisplay();
}

void DesenhaTexto(char *string, float x, float y)
{
   glPushMatrix();

   // Posição no universo onde o texto será colocado
   glRasterPos2f(x, y);

  // Exibe caracter a caracter
   while(*string)
   {
      glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10,*string++);
   }

   glPopMatrix();
}

FIM DE CÓDIGO...

No glut desenvolvemos uma função responsável por desenhar o texto na tela na posição indicada pelo usuário.

O nome da função é DesenhaTexto e ela recebe como argumento um array de caracteres (string) e a posição x,y onde será posicionado o texto.
Ao executar o programa ele deverá mostrar a mesma tela que o exemplo do AllegroGL porém com uma fonte diferente.

A função glRasterPos2f serve para especificar um ponto de rasterização.

Observe que é necessário incluir:

#include <string.h>
#include <stdio.h>

A partir de agora essas funções que implementamos para escrever na tela serão utilizadas em todos os nossos programas.

Download do exemplo 1 - Allegro - Clique Aqui

Download do exemplo 1 - Glut - Clique Aqui

Contribuidor
Bruno A. Rovela
29/10/2007

« Anterior

01/06/2007 (C) Copyright. Todos os Direitos Reservados. Leia a política de privacidade do portal. É proibida a cópia de conteúdo deste site de acordo com a Lei Brasileira de Direitos Autorais.