5.1. Descrição do programa jato.c

#define COORD_TEXTURA_PLANO 1.0
#define COORD_TEXTURA_AVIAO 1.0
#define COR_DO_PLANO 0.52,0.52,0.78,1.0
#define COR_DO_AVIAO 0.3,0.52,0.18,1.0
#define TEXTURA_DO_PLANO "montanhas.rgb"
#define TEXTURA_DO_AVIAO "camuflagem.rgb"

Define as cores e coordenadas das texturas do plano e do avião, além dos
nomes dos arquivos que contém as imagens das texturas.

GLint WIDTH =320;
GLint HEIGHT=240;

Especifica a largura (WIDTH) e a altura (HEIGHT) iniciais da janela de desenho.

GLfloat obs[3]={0.0,7.0,0.0};
GLfloat look[3]={0.0,3.0,0.0};

As coordenadas da posição do observador é armazenada no vetor obs[] e as do ponto para onde o observador olha é armazenado no
vetor look[]. De acordo com estes vetores, o observador
encontra-se no ponto (x,y,z)=(0,7,0) e está olhando para o ponto
(x,y,z)=(0,3,0).

GLuint  textura_plano;
GLuint  textura_aviao;

As variáveis textura_plano e textura_aviao armazenam os identificadores das texturas do
plano e do avião.

GLshort texturas=1;
GLfloat tetaxz=0;
GLfloat raioxz=6;
GLuint  jato;

A variável texturas é usada para habilitar/desabilitar
o uso de texturas nos objetos. As variáveis tetaxz e
raioxz armazenam o ângulo de rotação do ponto de
observação e a distância entre o observador e a origem, respectivamente. A
variável jato amazena o identificador para a lista de
apresentação do avião a jato.

GLfloat ctp[4][2]={
  {-COORD_TEXTURA_PLANO,-COORD_TEXTURA_PLANO},
  {+COORD_TEXTURA_PLANO,-COORD_TEXTURA_PLANO},
  {+COORD_TEXTURA_PLANO,+COORD_TEXTURA_PLANO},
  {-COORD_TEXTURA_PLANO,+COORD_TEXTURA_PLANO}
};

GLfloat cta[4][2]={
  {-COORD_TEXTURA_AVIAO,-COORD_TEXTURA_AVIAO},
  {+COORD_TEXTURA_AVIAO,-COORD_TEXTURA_AVIAO},
  {+COORD_TEXTURA_AVIAO,+COORD_TEXTURA_AVIAO},
  {-COORD_TEXTURA_AVIAO,+COORD_TEXTURA_AVIAO}
};

Quando uma textura é carregada, o OpenGL guarda em uma matriz e assume
coordenadas (0,0), (1,0), (1,1) e (0,1) para os quatro cantos da textura. Neste
exemplo, é assumido a repetição das texturas, de modo a poder cobrir todo o
objeto. As coordenadas especificadas neste trecho de código indicam que o objeto
será carimbado com sua respectiva textura e que as coordenadas das texturas que
serão usadas para criar os carimbos do plano e do avião serão ctp[] e cta[], respectivamente.

  GLUquadricObj *quadric;

Quádricas são superfícies definidas pela seguinte equação
a₁x² + a₂y²
+a₃z² + a₄xy + a₅yz +
a₆xz + a₇x + a₈y +a₉z +
a₁₀. Os tipos de quádricas mais conhecidos são os cones, os
cilindros, as esferas e os discos, modelados pelo ajuste adequado dos parâmetros
a_i. Estes objetos são guardados em uma estrutura de dados do tipo
GLUquadricObj.

  GLfloat asa[][3]={
    {-4.0,0.0,0.0},
    {+4.0,0.0,0.0},
    {0.0,0.0,3.0}
  };

  GLfloat cauda[][3]={
    {0.0,0.0,0.0},
    {0.0,2.0,-1.0},
    {0.0,2.0,0.0},
    {0.0,0.0,2.0}
  };

As variáveis asa[][] e cauda[][] armazenam as coordenadas dos polígonos que compõem a
asa e a cauda do avião, respectivamente.

  jato = glGenLists(1);
  glNewList(jato, GL_COMPILE);

A função glGenLists() aloca um conjunto contínuo de
listas de apresentação vazias e retorna o identificador utilizado para a lista
alocada. Neste exemplo, o conjunto contém apenas uma lista de apresentação. Mais
listas poderão ser alocadas com subseqüentes chamadas à mesma função.

A função glNewList() especifica o início de uma lista
de apresentação. Todos os comandos executados até a chamada de glEndList() ficarão armazenados nesta lista. A função glNewList() possui o seguinte protótipo:

list é um número inteiro maior que zero que
identifica de forma única a lista de apresentação. O parâmetro mode pode assumir os valores GL_COMPILE e GL_COMPILE_AND_EXECUTE. O primeiro apenas armazena
os comandos na lista; o segundo executa os comandos enquanto são armazenados na
lista.

  quadric = gluNewQuadric();
  gluQuadricTexture(quadric, GL_TRUE);
  gluCylinder(quadric, 0.5, 0.5, 4, 12, 3);

Inicia, usando a função gluNewQuadric(), a primeira
das quádricas do exemplo: o corpo do avião. Para esta quádrica, o mapeamento de
textura está habilitado. A função gluCylinder() possui o
seguinte protótipo:

O parâmetro quad é o objeto de quádrica; base, top e height especificam o raio da base, o raio do topo e
a altura do cilindro, respectivamente; slices
stacks especificam o número de subdivisões ao
redor do eixo z e ao longo do mesmo.

  obs[0]=raioxz*cos(2*PI*tetaxz/360);
  obs[2]=raioxz*sin(2*PI*tetaxz/360);
  gluLookAt(obs[0],obs[1],obs[2],look[0],look[1],look[2],0.0,1.0,0.0);

Na função display() as coordenadas x e z da posição
do observador são calculadas e a função gluLookAt() é
chamada para mudar a posição do observador. Recomenda-se a execução do Tutorial do Nate Robins (ver TelEduc) relacionado
ao uso da função gluLookAt().

  if(texturas){
    glEnable(GL_TEXTURE_2D);  
  }
  else{
    glDisable(GL_TEXTURE_2D);
  }

Aqui o mapeamento de texturas é habilitado ou desabilitado, de acordo com o
estado da variável texturas. Quando o mapeamento de
texturas é desabilitado, o objeto é desenhado utilizando as cores especificadas
pela função glColor*().

  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);

A função glTexEnvf() define os parâmetros do ambiente
de textura. O primeiro parâmetro é sempre GL_TEXTURE_ENV; o segundo parâmetro é sempre GL_TEXTURE_ENV_MODE e o terceiro especifica como a
textura será combinada com a cor para formar a superfície do objeto, neste caso
substituindo completamente a cor do objeto pela textura corrente.

  glBindTexture(GL_TEXTURE_2D,textura_plano);
   
  glBegin(GL_QUADS);
  glTexCoord2fv(ctp[0]);  glVertex3f(-10,0,10);
  glTexCoord2fv(ctp[1]);  glVertex3f(10,0,10);
  glTexCoord2fv(ctp[2]);  glVertex3f(10,0,-10);
  glTexCoord2fv(ctp[3]);  glVertex3f(-10,0,-10);
  glEnd();

glBindTexture() carrega a textura bidimensional
associada com a variável textura_plano. Em seguida, um
plano é desenhado usando GL_QUADS. Observe que,
antes de desenhar cada vértice, a função glTexCoord2fv()
é chamada para definir as coordenadas de textura correntes.

void carregar_texturas(void){
  IMAGE *img;
  GLenum gluerr;

  /* textura do plano */
  glGenTextures(1, &textura_plano);
  glBindTexture(GL_TEXTURE_2D, textura_plano);
  
  if(!(img=ImageLoad(TEXTURA_DO_PLANO))) {
    fprintf(stderr,"Error reading a texture.n");
    exit(-1);
  }

A carga das texturas é feita com uso da função ImageLoad(), implementada em image.c e definida em image.h. Esta função recebe como
parâmetro o nome do arquivo com a imagem da textura e retorna um ponteiro para
uma estrutura de dados do tipo IMAGE.

A função glGenTextures() gera 1 nome de textura em
textura_plano. Um nome de textura é qualquer inteiro
diferente de zero que identifique de forma única a textura. Assim, texturas
diferentes possuem nomes diferentes. Caso o segundo parâmetro desta função seja
um vetor de elementos GLuint, mais nomes de textura
podem ser gerados, um para cada elemento deste vetor.

  gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 
			   img->sizeX, img->sizeY, 
			   GL_RGB, GL_UNSIGNED_BYTE, 
			   (GLvoid *)(img->data));

Mipmaps são séries de versões em baixa resolução de um mapa de textura.
Geralmente é utilizado para texturizar um objeto cuja resolução na tela difere
da resolução no mapa de textura. Por exemplo, um objeto próximo da tela pode ser
desenhado utilizando uma resolução de textura maior que um objeto distante da
tela. O uso de mipmaps evita o efeito de serrilhamento (aliasing) e outros distúrbios de exibição quando um
objeto é aproximado ou afastado da tela.

Mipmaps bidimensionais são construídos com a função gluBuild2dMipmaps(), que possuiu seguinte protótipo:

target indica o tipo de mipmaps que se deseja
construir – neste caso uma textura bidimensional. internalFormat indica o tipo de armazenagem interna
do arquivo de textura. Neste exemplo, as texturas são imagens RGB, incluindo 3
(três) componentes de cor. Os parâmetros width e
height especificam a largura e a altura do dado.
Ambas estas dimensões devem ser potências de 2. format especifica o formato dos pixels do dado
(RGB). type especifica o tipo de dado
representado no vetor de dados. data especifica
o ponteiro para a posição de memória onde os dados de textura residem.

  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

A função glTexParameterf() define uma série de
parâmetros que controlam como uma textura é tratada e aplicada a um fragmento de
um dado objeto. Aqui, através dos parâmetros GL_TEXTURE_WRAP_S e GL_TEXTURE_WRAP_T, a função define que nas direções
s e t (coordenadas) a textura deverá será repetida no objeto.

  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

Neste trecho do código, as funções glTexParameterf()
define os tipos de filtro usados quando a textura for minimizada ou maximizada.
Pelo parâmetro GL_LINEAR_MIPMAP_LINEAR, o OpenGL
escolhe dois mipmaps que mais aproximam o tamanho do pixel a ser texturizado
calcula a média dos quatro elementos de textura mais próximos do centro do
pixel. O valor da textura para o pixel será a média desses dois valores. O
parâmetro GL_LINEAR, por sua vez não utiliza
mipmaps: associa ao pixel a ser texturizado a média dos quatro elementos de
textura mais próximos do centro do pixel.