Terramel

O que é uma projeção? Se temos uma fonte de luz, um projetor, por exemplo, e colocamos qualquer objeto, como uma caneta, na frente, temos um desenho, ou uma projeção, deste objeto na parede. A mesma coisa acontece com Computação Gráfica. Temos fontes de luz e uma câmera virtual em um local aonde o objeto é projetado. Este local pode ter duas configurações básicas: ortogonal ou perspectiva. Na perspectiva, temos a possibilidade de trabalhar com animações que tem maior fidelidade dependendo da distância. Na ortogonal não temos este tipo de efeito, apesar de termos precisão para construir objetos.Vamos imaginar que temos uma área útil para desenhar, algo em torno de 20 centímetros. Como posso representar 2 metros dentro destes 20 centímetros? Simples, trabalhando com escala. Para trabalharmos com escala, temos que saber qual a menor dimensão que conseguimos representar. Um ponto nesta área é chamado de pixel. Podemos usar esse pixel para representar 1 centímetro.

Como estamos trabalhando com uma área de 20 centímetros, o maior objeto que posso representar neste caso será um com no máximo 20 centímetros. Se nos basearmos no tamanho do pixel, podemos saber quanto precisamos usar para representar os objetos que queremos modelar.

Uma saída é a projeção. Quando colocamos a glOrtho, é como se estivessemos dizendo ao programa o universo, a área e quantos pontos quero para trabalhar simplesmente informando os valores nos parâmetros do comando. Por exemplo, chamando a função glOrtho da seguinte forma:

glOrtho(-50,50,-50,50,-50,50);

É criado um volume com -50 à esquerda, 50 à direita, -50 para baixo, 50 para cima, -50 para o fundo e 50 para a frente.

Nesta aula vamos trabalhar na modelagem de uma mesa de 2 metros (ou 200 centímetros). Se queremos desenhar uma mesa com 200cm, precisamos trabalhar com escala. Podemos assumir que cada ponto representa 1 cm. Isso dependerá do projeto que queremos desenvolver. Qual o menor objeto que precisarei apresentar? Talvez um interruptor (1cm x 2cm)… Na hora da modelagem podemos dizer que um interruptor será representado por 1 ponto da coluna. Se o maior objeto a ser representado for uma sala ou uma cidade, quantos pontos precisaremos para fazê-lo?

Se modelarmos uma mesa de 2 metros em um volume que somando negativo com positivo terá um valor igual a 100 (igual o glOrtho do exemplo acima que foi chamado com os valores -50,50,-50,50,-50,50), a mesa obviamente não aparecerá inteira e sim recortada. A solução será chamar a função glOrtho com outros parâmetros que permitam que a mesa apareça inteiramente:

glOrtho(-500,500,-500,500,-500,500);

Extrusão

Extrusão é a técnica de modelar um objeto deformando outro já existente.

Usaremos esta técnica para modelarmos nossa mesa usando o cubo que criamos na aula anterior. Vamos criar 5 cubos para fazer a mesa: Um para a tampa da mesa e os quatro restantes para as pernas.

Biblioteca para o cubo

Para facilitar nosso trabalho, vamos pegar o código que foi usado para o cubo, dar uma modificada e criar uma biblioteca chamada cubo.h:

void cubo(float r, float g, float b, float x, float y, float z, float tam, float transp)
{
	r = r/255; g=g/255; b=b/255; // Como glColor4f só vai de 0 a 1 e não de 0 a 255, fizemos essa conversão para podermos usar os dados de 0 a 255

 	glBegin(GL_QUADS);

 		glColor4f(r,g,b,transp);
 		glTranslatef(x,y,z);

		glVertex3f(tam,tam,0);
	 	glVertex3f(-1*tam,tam,0);
 		glVertex3f(-1*tam,-1*tam,0);
  		glVertex3f(tam,-1*tam,0);

		glVertex3f(tam,tam,-10);
 		glVertex3f(-1*tam,tam,-10);
  		glVertex3f(-1*tam,-1*tam,-10);
  		glVertex3f(tam,-1*tam,-10);

		glVertex3f(-1*tam,tam,-10);
  		glVertex3f(-1*tam,tam,0);
  		glVertex3f(-1*tam,-1*tam,0);
  		glVertex3f(-1*tam,-1*tam,-10);

		glVertex3f(tam,-1*tam,-10);
  		glVertex3f(tam,-1*tam,0);
  		glVertex3f(tam,tam,0);
  		glVertex3f(tam,tam,-10);

		glVertex3f(tam,-1*tam,0);
  		glVertex3f(-1*tam,-1*tam,0);
  		glVertex3f(-1*tam,-1*tam,-10);
  		glVertex3f(5,-1*tam,-10);

		glVertex3f(-1*tam,tam,0);
  		glVertex3f(tam,tam,0);
  		glVertex3f(tam,tam,-10);
  		glVertex3f(-1*tam,tam,-10);

	glEnd();
}

Agora basta chamarmos a biblioteca cubo.h no início do código do arquivo estrutura.c informando corretamente o caminho da biblioteca. Por exemplo, se o arquivo cubo.h está em /home/saibot/estrutura, basta colocarmos o seguinte no código:

#include </home/saibot/estrutura/cubo.h>

Agora podemos chamar o cubo com os valores que quisermos, por exemplo:

cubo(50,50,50,0,0,0,200,0.25);

Os 3 primeiros valores definem a cor do cubo (RGB), os outros 3 movimentam o cubo (a menos que queira, não é necessário mudá-los, já que podemos movimentar cada parte do cubo usando glTranslatef na hora de criarmos cada parte de nossa mesa), o penúltimo valor define o tamanho do cubo e o último valor define a transparência.

Antes de começarmos a modelar nossa mesa, vamos ainda dar uma olhada em alguns comandos.

glTranslatef e glScalef

glTranslatef é a função que realiza a translação, ou seja, movimenta um objeto. A origem do sistema é transladada para a posição fornecida dentro dos parâmetros da função (mais uma vez lembrando que x indica o lado, y a altura e z a profundidade): glTranslatef(x,y,z)

glScalef altera a escala dos objetos. O resultado obtido é o alongamento ou encolhimento dos objetos no sentido dos eixos. A função é usada da seguinte forma: glScalef(x,y,z). Se o valor de algum dos parâmetros for 0, esta cordenada simplesmente será eliminada.

glPushMatrix e glPopMatrix

Essas funções permitem guardar temporariamente a matriz de transformação atual. Após a instrução glPopMatrix() todas as operações que alteram a matriz atual, como por exemplo, glTranslatef, efetuadas após o último glPushMatrix(), são ignoradas.

Por exemplo, se depois de criar e movimentar um cubo não usarmos o glPopMatrix, os outros objetos serão criados à partir do que foi definido depois do primeiro desenho. Se usarmos o glPushMatrix antes do cubo e o glPopMatrix depois, a origem do sistema mais uma vez será a que estava sendo trabalhada antes de criarmos o objeto.

Criando a mesa

Vamos fazer agora a modelagem de nossa mesa. Como já fizemos uma biblioteca para chamar o cubo, podemos chamá-la para criar a tampa e as pernas da mesa, colocando cada parte dentro de glPushMatrix() e glPopMatrix(). Vamos usar o comando glScalef para mudar os tamanhos dos cubos transformando-os na tampa e nas pernas da mesa e o comando glTranslatef para definirmos a posição de cada parte da mesa.

//
//Tampa da mesa
//

glPushMatrix();
	glScalef(1,0.05,50);
	cubo(160,180,160,0,0,0,200,0.25);
glPopMatrix();

//
//Pernas da mesa
//

glPushMatrix();
	glTranslatef(-180,-200,-0);
	glScalef(0.1,1,2);
	cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();

glPushMatrix();
	glTranslatef(180,-200,0);
	glScalef(0.1,1,2);
	cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();

glPushMatrix();
	glTranslatef(-180,-200,-480);
	glScalef(0.1,1,2);
	cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();

glPushMatrix();
	glTranslatef(180,-200,-480);
	glScalef(0.1,1,2);
	cubo(250,50,50,0,0,0,200,0.25);
glPopMatrix();

glRotatef

glRotatef é a função usada para podermos aplicar a rotação nos objetos. Os parâmetros usados nesta função são: ângulo, componente x, componente y e componente z. Depois de escolhermos o ângulo, damos os valores para x, y e z, que podem ser 0 ou 1.

Por exemplo, se quero rotacionar um objeto em 45 graus no eixo x, chamo a função da seguinte forma:

glRotatef(45,1,0,0);

Se quero rotacionar em 70 graus nos eixos y e z, chamo da seguinte forma:

glRotatef(70,0,1,1);

Exercícios

Agora que já modelamos nossa mesa, vamos criar umas cadeiras, rotacionar alguma(s) delas para deixar mais apresentável nosso desenho
Uma dica é criar uma biblioteca cadeira.h para ficar mais fácil colocar mais cadeiras no desenho. Lembre-se de usar os comandos glPushMatrix e glPopMatrix para cada uma das cadeiras e colocar dentro desses comandos as funções glTranslatef e glRotatef nas cadeiras que quiser rotacionar. Se quiser também pode usar glScalef para mudar o tamanho de algumas cadeira.

Se preferir pode também criar uma biblioteca mesa.h para facilitar a criação de mais mesas se desejar.

A imagem abaixo mostra o desenho que fiz de uma mesa com um bulê de chá e suas cadeiras. Fiz uma delas caída para dar aquela impressão de que algum cara meio chapado acabou derrubando a cadeira (talvez o chá dentro do bulê fosse de cogumelo… Quem sabe? Talvez os caras que beberam ;D)

Technorati Tags: Computação Gráfica, OpenGL, GL, CG, cubo, mesas, cadeiras, modelagem, objetos, sistema, dimensões, ortho, ortogonal, perspectiva, glScalef, glRotatef, glPushMatrix, glPopMatrix, glTranslatef, chá, cogumelo, chá de cogumelos, pés, pernas, pé, perna, tampa, tampas

Powered by ScribeFire.

Se você gostou deste post, pode me pagar um café que servirá como um excelente combustível para que eu escreva mais posts ;)

Leia Também:

• Worm multiplataforma para OpenOffice.org
• Passamos os 100 mil visitantes
• Conectando em redes sem fio com o Wicd
• A Evolução dos Computadores
• Juíz Federal + Ignorância + Coceira de Saco = Counter Strike Proibido
• OpenCola - O refri de cola Open-Source
• Blogueira mais velha do mundo morre aos 108 anos
• Apocalipse vai chegar atrasado! Fim do mundo adiado (de novo) para 21 de outubro
• Bill Gates 666: Críticas à Fundação Bill & Melinda Gates e sua filantropia e altruismo
• Meebo bloqueado? Desbloqueie com o Tor!

Tags: Aulas //