|
Usuário: Fábio Campos
Categoria: Java
Visualizações: 970
Depois que vocês aprenderam a criar o básico, que é a janela de renderização, onde tudo acontece. Vamos agora partir para o segundo tutorial que é bem básico ainda.
No primeiro tutorial eu ensinei como criar uma janela no LWJGL. Neste tutorial eu ensinarei como criar um triângulo utilizando GL_TRIANGLES e um quadrado utilizando GL_QUADS.
Vamos aproveitar ocódigo do primeiro tutorial, e a ele nós adicionaremos linhas ao método render() como segue abaixo:
protected void render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Limpa a Tela e o Buffer de profundidade
glLoadIdentity(); // Reinicia a Matrix corrente ModelView
//*************************************NOVO************************************************//
Quando você chama o método glLoadIdentity(), o que você faz, é mover as coordenadas(X, Y, Z) de volta ao centro da tela, com o eixo X apontando para direita, o eixo Y apontando para cima, e o eixo Z apontando para fora da tela.
O centro de uma tela em OpenGL é 0.0f no eixo X e Y. Para a esquerda, com referência o centro da tela, as coordenadas se tornam negativas. Para a direita as coordenadas se tornam positivas. Para cima se tornam positivas. Para baixo negativas. Para fora da tela positivas e para dentro da tela negativas.
O método glTranslatef(x, y, z) move ao longo dos eixos X, Y e Z respectivamente. A linha de código abaixo move 1.5 unidades para esquerda no eixo X. Ela não move no eixo Y (0.0), e ela move para dentro da tela 8.0 unidades. Quando você move, você não está movendo uma quantidade de unidades a partir de um ponto inicial do centro da tela, você está movendo uma quantidade de unidades a partir de qualquer lugar que você realmente esteja na tela.
glTranslatef(-1.5f, 0.0f, -8.0f); // Move para esquerda 1.5 unidades e 8.0 unidades pra dentro da tela
Agora que você moveu 1.5 unidades para esquerda do centro da tela, e que nós definimos a sua visualização para dentro da tela o suficiente(-8.0), nós podemos ver toda cena que desenharemos o triângulo e o quadrado.
O comando glBegin(GL_TRIANGLES) significa que nós estamos preparando a OpenGL para iniciar o desenho de um triângulo, e glEnd() diz para a OpenGL que nós terminamos de desenhar o triângulo.
Desenhar triângulos é razoavelmente rápido em muitas placas de video. Se você precisa de 4 vértices, use GL_QUADS para facilitar sua vida. Finalmente se você precisa mais do que 4 vértices, use GL_POLYGON.
Neste nosso programa simples, nós desenhamos apenas um triângulo. Se nós precisassemos desenhar um segundo triângulo, nós poderiamos incluir outras 3 linhas de código(3 vértices), logo após as 3 primeiras. Todas 6 linhas de código
poderiam estar entre glBegin(GL_TRIANGLES) e glEnd(). Não há nenhum problema em fazer um glBegin(GL_TRIANGLES) e um glEnd() para cada 3 vértices(cada triângulo) se assim você preferir. Isto se aplica também há quadrados. Se você sabe como desenhar todos quadrados, você pode incluir o segundo grupo de 4 linhas de código logo após as 4 primeiras linhas. Um polígono por outro lado (GL_POLYGON) pode ser feito com qualquer quantidade de vértices que você desejar, não importa quantas linhas você tem entre glBegin(GL_POLYGON) e glEnd().
A primeira linha após glBegin, define o primeiro vértice do nosso polígono, neste caso é um triângulo. O primeiro
parâmetro do comando glVertex é para o eixo X, o segundo parâmetro é para o eixo Y, e o terceiro parâmetro é para o eixo Z. Então, na primeira linha, nós não movemos no eixo X. Nós movemos para cima 1.0f unidade no eixo Y, e nós não movemos no eixo Z. Com isso, fazemos o vértice da parte superior do triângulo. O segundo glVertex move 1.0f unidade para esquerda no eixo X e 1.0f unidade para baixo no eixo Y. Com isso, fazemos o vértice inferior esquerdo do triângulo. O terceiro glVertex move 1.0f unidade para direita, e 1.0f unidade para baixo. Com isso, fazemos o vértice inferior direito. glEnd() diz a OpenGL que não há mais vértices para ser desenhado. O triângulo preenchido será mostrado.
glBegin(GL_TRIANGLES); // Definir para desenhar usando triângulos
glVertex3f( 0.0f, 1.0f, 0.0f); // Vértice do Topo
glVertex3f(-1.0f,-1.0f, 0.0f); // Vértice inferior esquerdo
glVertex3f( 1.0f,-1.0f, 0.0f); // Vértice inferior direito
glEnd(); // Fim do desenho do triângulo
Agora que temos o triângulo desenhado e mostrado do lado esquerdo da tela, nós precisamos mover a posição de
desenho para o lado direito da tela. Para fazer isso, nós usaremos novamente glTranslatef. Desta vez nós devemos mover para direita, então X tem que ser um valor positivo. Como nós já movemos 1.5 unidades para esquerda, para alcançarmos novamente o centro da tela, devemos mover 1.5 unidads pra direita, assim o X ficaria na posição (0.0). Depois que alcançarmos o centro, nós precisamos mover 1.5 unidades para direita do centro. Então, no total, nós precisamos nos mover 3.0 unidades para direita.
glTranslatef(3.0f, 0.0f, 0.0f); // Move para direita 3 unidades
Depois que posicionamos o eixo no local que vamos desenhar, nós criaremos o quadrado. Nós iremos usar o comando GL_QUADS. Um QUAD(quadrilátero) é basicamente um polígono de 4 lados, que é perfeito para fazermos um quadrado.
O código para criar um quadrado é muito parecido com o código que nós utilizamos para criar o triângulo. A única diferença é o uso de GL_QUADS, ao invés de, GL_TRIANGLES, e um outro comando glVertex3f pois o quadrilátero possui 4 lados e por consequência 4 vértices.
Para a criação do quarto vértice. Nós iremos desenhar o canto superior esquerdo, superior direito, inferior direito e inferior esquerdo do quadrado, essa ordem que eu coloquei é a ordem no sentido horário. Por desenhar no sentido horário, o quadrado será desenhado como "face traseira". Isso significa que o lado do quadrado que nós iremos ver, é na verdade sua face traseira. Objetos desenhados no sentido anti-horário mostrarão sua face frontal para nós. No momento, isso não é importante, mas adiante você deverá pretar atenção na ordem que você desenha os vértices.
glBegin(GL_QUADS); // Definir para desenhar quadrilátero
glVertex3f(-1.0f, 1.0f, 0.0f); // Vértice superior esquerdo
glVertex3f( 1.0f, 1.0f, 0.0f); // Vértice superior direito
glVertex3f( 1.0f,-1.0f, 0.0f); // Vértice inferior direito
glVertex3f(-1.0f,-1.0f, 0.0f); // Vértice inferior esquerdo
glEnd(); // Fim do desenho do quadrilátero
}
}
Bom, chegamos ao final do segundo tutorial, neste tutorial falamos muito de translação de eixo, de camera, de coordenadas de vértices, etc., movemos bastante coisas. Qual unidade de medida que eu usei para fazer estes movimentos? polegadas? milímetros? metros? Estas unidades de medidas tem alguma coisa haver com OpenGL?
A resposta é, em uma palavra, NÃO.
As projeções e transformações são feitas sem unidades específicas. Se você pensar em planos, estando perto ou longe, que eles estão localizados entre 1.0 e 20.0 metros, polegadas, milímetros ou qualquer outra medida de distância, isto é com você. A única regra que você tem que seguir, é que você tem que manter consistente o sistema de dimensionamento que escolher, isso quer dizer, que se você escolher metros, todas as medidas no seu projeto vão ter que estar em metros.
Neste turorial eu tentei explicar tudo em muitos detalhes, todo passo que involve o desenhos de polígonos numa tela de OpenGL e LWJGL. Se você tiver algum comentário ou pergunta, por favor comente. Se você achou algum comentário errado da minha parte, ou um código que pode ser escrito de uma forma melhor, por favor me avise.
Minha intenção é escrever tutoriais simples e de fácil entendimento por todos, Sinta-se a vontade para mandar sugestões ou críticas. Obrigado. Até o próximo tutorial.
Fábio Campos.
Download Lição02
|
|
