Ponto V!

Home OpenGL Desenhando polígonos – Parte 2
Vinícius Godoy de Mendonça
Desenhando polígonos – Parte 2Imprimir
Escrito por Vinícius Godoy de Mendonça

No artigo anterior, vimos mais profundamente como desenhar polígonos, colori-los, alterar a forma como seus lados são desenhados (ou mesmo eliminar completamente o desenho de um dos seus lados) e como deixar o seu desenho suave. Nesse artigo, vamos continuar estudando o desenho de polígonos.

O gabarito do exercício anterior pode ser obtido aqui. Você pode girar o cubo usando as setas do teclado.

Teste de profundidade

Se você fez o exercício anterior, deve ter notado que até ativar o culling, o OpenGL falhava ao desenhar qual figura vinha à frente, e qual vinha atrás. Esse problema ocorre porque, por padrão, o OpenGL não se preocupa em esconder a figura que está atrás, caso outra já tenha sido desenhada na frente dela.

Esse teste é chamado de “teste de profundidade”, e é opcional por só fazer sentido em ambientes tridimensionais. Você pode ativa-lo usando a opção glEnable(GL_DEPTH_TEST);

Dessa forma, o OpenGL levará em consideração a posição não só a distância da figura em relação ao observador, mas também se há outras figuras sobreponto o que está sendo desenhado. Caso haja, as partes sobrepostas não serão desenhadas. Falaremos em mais detalhes sobre o teste de profundidade quando explicarmos sobre os buffers do OpenGL.

Ocultando arestas

No exercício anterior, se mandarmos somente as linhas do cubo serem desenhadas, é possível ver também uma das diagonais do cubo. Isso ocorre porque, como cada face é desenhada por 2 triângulos, a diagonal que corresponde a um dos lados do triângulo é também desenhada.

Isso quase nunca é desejável. Felizmente, o OpenGL possui uma função para remover as arestas desnecessárias, chamada glEdgeFlag(GLboolean isEdge); Há uma variação dessa função, chamada glEdgeFlagv, onde um uma única posição de um array (ou o ponteiro para um boolean) pode ser informado. A função aceita os valores GL_TRUE, que indica que aquela aresta deve ser desenhada, ou GL_FALSE, para impedir o desenho da aresta. Todas as arestas após o comando são afetadas, até que o comando seja dado novamente.

Aplicando padrões de desenho

Assim como as linhas, a pintura de um polígono não precisa ser “lisa”. Podemos aplicar padrões na pintura. Os padrões são definidos por um mapa de bits de 32×32 bytes (ou 256×256 bits, se você preferir assim). Do contrário das linhas, o OpenGL lê os bits na ordem normal, sem inverter nada.

Para habilitar preenchimento de polígonos, devemos dar o comando glEnable(GL_POLYGON_STIPPLE); Em seguida, usamos a função void glPolygonStipple(const GLuByte* mask) para definir qual o padrão de pintura a ser utilizado.

Por exemplo, o seguinte padrão, retirado do livro OpenGL SuperBible, preenche o cubo com o desenho de uma chama:

glEnable(GL_POLYGON_STIPPLE);
GLubyte fire[] =
 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x01, 0xf0,
   0x00, 0x00, 0x07, 0xf0, 0x0f, 0x00, 0x1f, 0xe0,
   0x1f, 0x80, 0x1f, 0xc0, 0x0f, 0xc0, 0x3f, 0x80,
   0x07, 0xe0, 0x7e, 0x00, 0x03, 0xf0, 0xff, 0x80,
   0x03, 0xf5, 0xff, 0xe0, 0x07, 0xfd, 0xff, 0xf8,
   0x1f, 0xfc, 0xff, 0xe8, 0xff, 0xe3, 0xbf, 0x70,
   0xde, 0x80, 0xb7, 0x00, 0x71, 0x10, 0x4a, 0x80,
   0x03, 0x10, 0x4e, 0x40, 0x02, 0x88, 0x8c, 0x20,
   0x05, 0x05, 0x04, 0x40, 0x02, 0x82, 0x14, 0x40,
   0x02, 0x40, 0x10, 0x80, 0x02, 0x64, 0x1a, 0x80,
   0x00, 0x92, 0x29, 0x00, 0x00, 0xb0, 0x48, 0x00,
   0x00, 0xc8, 0x90, 0x00, 0x00, 0x85, 0x10, 0x00,
   0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00 };
 glPolygonStipple(fire);

Esses padrões de preenchimento, embora sejam interessantes, não acompanham a rotação da figura. Portanto, só podem ser utilizados em desenhos simples, geralmente de duas dimensões (como desenhos de plantas ou jogos 2D, por exemplo). Veremos uma forma muito mais atraente de se preencher polígonos no futuro, ao tratarmos de texturas.

Exercícios

  1. Desligue o culling e experimente rotacionar o polígono sem o teste de profundidade. Depois, ative o teste de profundidade e rotacione o polígono. Procure observar a diferença do desenho e memorizar a necessidade desse teste em ambientes tridimensionais. Você pode ver como rotacionar baixando o gabarito no início desse texto;
  2. Troque o modo de desenho para o de linhas usando a função glPolygonMode, vista no artigo anterior e use a função glEdgeFlag para ocultar a diagonal das laterais do seu cubo;
  3. Volte o seu cubo ao normal e aplique o padrão de pintura descrito acima. Experimente rotacionar o cubo.
  4. Tente desenhar um cone usando duas vezes a primitiva GL_TRIANGLE_FAN, uma para o corpo do cone, outra para a base;
  5. Tente desenhar uma pirâmide de base triangular;
  6. Tente desenhar uma pirâmide de base retangular;
  7. Usando apenas pontos, tente desenhar uma figura no formato de uma mola;

Comentários (3)
  • isabela mayara ribeiro
    avatar

    :confused: naum consegui achar oq eu queria então este site naum é preciso para mim mais muito obr por me ajuda!!! :unsure:
    gosti muito desses bichinhos

  • Anônimo
    avatar

    como coloca-los no msn?
    :0 :o

  • Nivaldo de Arruda  - Como desenhar uma bola sem serrilhado
    avatar

    Oi tudo bem ?

    Estou usando o codeblocks com c++ e fiz uma bola azul, mas ela fica com serrilhado.
    Como usar uma bola assim ?
    eu quero que ela fique bem redonda, sem serrilhado.
    O que fazer ?
    No aguardo e obrigado.

Escrever um comentário
Your Contact Details:
Gravatar enabled
Comentário:
[b] [i] [u] [url] [quote] [code] [img]   
:angry::0:confused::cheer:B):evil::silly::dry::lol::kiss::D:pinch::(:shock:
:X:side::):P:unsure::woohoo::huh::whistle:;):S:!::?::idea::arrow:
Security
Por favor coloque o código anti-spam que você lê na imagem.
LAST_UPDATED2  

Busca

Linguagens

Twitter