Desenho de objetos em OpenGL -- Computação Gráfica

jSeção 3.2  

 

 

          3.2. Primitivas Geométricas



Apesar de ser muito poderoso o OpenGL conta apenas com 10 primitivas geométricas, sendo divididas da seguinte forma:
  • um tipo de ponto
  • três tipos de linhas
  • seis tipos de polígonos

Cada primitiva geométrica precisa de um conjunto de vértices específicos para formar objetos. Os vértices são definidos pelo comando Vertex. Veja alguns exemplos:

    >> glVertex2f( float x, float y); // vértice para um eixo 2D

    >> glVertex3d(double x,double y, double z); // vértice para um eixo 3D

As primitivas precisam ser delimitadas através de Begin ... End conforme abaixo:

     Begin ( nome da primitiva);
     ... // aqui serão colocados comandos Vertex.
      End (void);

Se reparar no procedimento Render do exemplo básico verá que existe uma estrutura semelhante a essa para definir um objeto, que no caso é um triângulo:

    glBegin(GL_POLYGON); // Primitiva para desenhar um polígono
        glVertex2f( 0.0f, 0.0f);  // define o primeiro vértice do polígono
        glVertex2f( 0.25f, 0.50f); // define o segundo vértice do polígono
        glVertex2f( 0.50f, 0.0f); // define o terceiro vértice do polígono
    glEnd(); 

Veja que GL_POLYGON define um polígono convexo qualquer. Existem outras primitivas relacionadas que serão descritas a seguir. Para ilustrar o efeito de cada uma toma-se partida do seguinte código:

    glBegin( nome da primitiva );
        glVertex2f( 0.0f, 0.0f); 
        glVertex2f( 0.25f, 0.50f); 
        glVertex2f( 0.50f, 0.0f); 
    glEnd(); 

Por exemplo, a primitiva responsável em desenhar pontos na tela é GL_POINTS. Para ilustrar a mesma basta o seguinte código:

    glBegin( GL_POINTS );
        glVertex2f( 0.0f, 0.0f); 
        glVertex2f( 0.25f, 0.50f); 
        glVertex2f( 0.50f, 0.0f); 
    glEnd(); 

O código acima desenha 3 pontos na tela. Cada vértice torna-se um ponto. Abaixo seguem outras primitivas relacionadas e você deve fazer o mesmo que foi feito com GL_POINTS, ou seja, substituir nome_da_primitiva pela constante que define a primitiva. 

 

GL_LINES
Cria linhas independentes. O terceira coordenada é ignorada pois a linha é formada por dois vértices. Se houvesse um quarto vértice, uma nova linha entre o terceiro e quarto vértice seria exibida.

d

GL_LINE_STRIP
Cria linhas consecutivas, ligando o primeiro vértice com o segundo, o segundo com o terceiro e assim por diante.

 

d

GL_LINE_LOOP
Funciona de maneira semelhante ao anterior, porém o último vértice é ligado a primeira, devido a isso o LOOP no seu nome. O espessura de uma linha pode ser modificada através do comando glLineWidth (GLint espessura), bastando passar como parâmetro a espessura da linha. 

d

GL_POLYGON

  
Desenha polígonos convexos de acordo com as especificações das coordenadas. É semelhante ao LINE_LOOP no fato de ligar a última coordenada a primeira. 

 

d

Para as próximas primitivas é necessário mudar um pouco o código devido ao número de vértices, caso contrário não iríamos demonstrar corretamente o efeito da mesma . Eis o código:

    glBegin( nome da primitiva ); 
        glVertex2f( 0.0f, 0.0f); 
        glVertex2f( 0.25f, 0.50f); 
        glVertex2f( 0.50f, 0.0f); 
        glVertex2f(0.75f,0.50f);
        glVertex2f(1.0f,0.0f);
    glEnd(); 

GL_TRIANGLE_STRIP

 
Desenha uma série de triângulos que são conectados uns aos outros ao longo dos  lados que podem ser compartilhados. 

 

d

GL_TRIANGLE_FAN

 
Funciona de forma semelhante ao anterior , mas os triângulos criados possuem a mesma origem.

 

d

GL_TRIANGLES

  
Gera como resultado triângulos independentes. Ela ignora os dois últimos vértices, pois cinco vértices não formam dois triângulos independentes.

 

d

Para as próximas primitivas é necessário mudar um pouco o código devido ao número de vértices, caso contrário não iríamos demonstrar corretamente o efeito da mesma . Eis o código:

    glBegin( nome da primitiva ); 
        glVertex2f( 0.0f, 0.0f); 
        glVertex2f( 0.0f, 0.25f); 
        glVertex2f( 0.25f, 0.0f); 
        glVertex2f(0.25f,0.25f);
        glVertex2f(0.5f,0.0f);
        glVertex2f(0.5f,0.25f);
    glEnd(); 

GL_QUAD_STRIP

  
Desenha uma série de quadriláteros entre os lados compartilhados.

 

d

GL_QUADS

  
Desenha quadriláteros independentes. Ela ignora os dois últimos vértices, pois 6 vértices não formam dois quadriláteros independentes.

 

d

Pode estar havendo confusões em relação as primitivas que desenham triângulos e quadrados. Por isso abaixo serão colocadas figuras que ilustram o funcionamento das mesmas.

Iremos começar ilustrando as primitivas para desenhar triângulos. Veja a figura abaixo:

Os lados em azul são os chamados lados compartilhados. Os triângulos cinzas são os criados entre os lados compartilhados pelas primitivas. A diferença entre TRIANGLE_FAN e TRIANGLE_STRIP, é que o primeiro cria triângulos entre os lados compartilhados, porém com a origem dos triângulos são comuns. O segundo cria triângulos entre os lados compartilhados mas não leva em conta as origens.

Agora iremos abordar as primitivas para desenhar quadriláteros. Veja a figura abaixo:

Os lados em azul definem os chamados lados compartilhados. Na QUAD_STRIP, os quadriláteros se unem através dos seus lados compartilhados, formando um único quadrilátero. Na QUADS os quadriláteros são criados de forma independente. 

 
 

[principal]

[anterior]

[próxima]