Saudações caro leitores! Este é o primeiro post de Computação Gráfica. Pelo que percebi esta disciplina na faculdade será mais focada no entendimento dos comandos de OpenGL. Nas palavras do professor está aula será basicamente um “teste de mesa”, ou seja, olhar o código do programa e interpretá-lo passo a passo tentando entendê-lo através dos comentários. Depois executaremos o programa e depois modificaremos alguns parâmetros e executaremos de novo para vermos o resultado das alterações que fizemos.

Nas aulas será feita também a modelagem de objetos, como por exemplo uma mesa, e depois juntaremos tudo e modelaremos uma parte da faculdade (é mole? ¬¬).

O que é OpenGL?

Antes de seguir o que foi passado em aula, acredito que seja mais importante explicar aqui o que é o OpenGL.

O OpenGL é uma biblioteca de rotinas gráficas de modelagem, manipulação de objetos e exibição tridimensional que permite a criação de aplicações que usam Computação Gráfica. Seus recursos permitem ao usuário criar objetos gráficos com qualidade, de modo rápido, além de incluir recursos avançados de animação, tratamento de imagens e texturas. É possível ter visualização de vários ângulos.

Entre os recursos gráficos disponíveis pelo OpenGL, podem ser destacados os seguintes:

• Modos de desenho de pontos;
• Ajuste de largura de linhas
• Aplicação de transparência
• Ativação de desativação de serrilhamento (aliasing)
• Mapeamento de superfícies com textura
• Seleção de janela de desenho
• Manipulação de fontes/tipos de iluminação e sombreamento
• Transformação de sistemas de coordenadas
• Transformações em perspectiva
• Combinação de imagens (blending)

As implementações do OpenGL geralmente provêem bibliotecas auxiliares, tais como a GLU (OpenGL Utility Library), utilizada para realizar tarefas comuns, tais como manipulação de matrizes, geração de superfícies e construção de objetos por composição.

As especificações do OpenGL não descrevem as interações entre OpenGL e o sistema de janelas utilizado (X Window, Ruindows etc). Assim, tarefas comuns em uma aplicação, tais como criar janelas gráficas, gerenciar eventos provenientes de mouse e teclado e apresentação de menus ficam a cargo de bibliotecas próprias de cada sistema operacional.

Referência: ine 5341

Algumas dicas

• Ler o código
• Se compreender o comando, passar para a próxima linha do programa
• Se o próximo comando for uma função, ler a função
• Se tiver alguma dúvida, esclarecê-la antes de passar para a próxima linha

O Programa

#include <stdio.h>
#include <stlib.h>
#include <GL/glut.h>
#include <GL/glu.h>

int projecao=0; // Variável Lógica para Definir o Tipo de Projeção (Perspectiva ou Ortogonal)
int posx=0, posy=10, posz=20; // Variáveis que definem a posição da câmera
int oy=0,ox=0,oz=0; // Variáveis que definem para onde a câmera olha
int lx=0, ly=1,  lz=0; // Variáveis que definem qual eixo estará na vertical do monitor.

void INIT(void)
{
	glClearColor(0.0, 0.0, 0.0, 0.0); // função que determina a cor utilizada para limpar a janela.
	glEnable(GL_BLEND); // Habilita Transparência na cena
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); // O primeiro parâmetro se refere ao objeto da frente (tomando como referência o observador). O segundo argumento define que o objeto mais próximo será responsável por uma fraçao igual ao quarto argumento do glColor no cálculo total das cores
	glShadeModel(GL_SMOOTH); // glShadeModel é usada para especificar a técnica de colorização desejada. GL_SMOOTH seleciona o sistema de preenchimeto, permitindo de gradiente de cores
}
void DISPLAY(void)
{
	glMatrixMode(GL_PROJECTION); // glMatrixMode()- define qual matriz será alterada. SEMPRE defina o tipo de apresentação (Ortogonal ou Perspectiva) na matriz PROJECTION.
	glLoadIdentity(); // "Limpa" ou "transforma" a matriz em identidade, reduzindo possíveis erros.
	if (projecao==1)
		glOrtho(-50, 50, -50, 50, -50, 50); // Define a projeção como ortogonal
	else
		gluPerspective(45,1,1,100); // Define a projeção como perspectiva

	glMatrixMode(GL_MODELVIEW); // glMatrixMode()- define qual matriz será alterada. SEMPRE defina a câmera (Ortogonal ou Perspectiva) na matriz MODELVIEW (onde o desenho ocorrerá).
	glLoadIdentity(); // "Limpa" ou "transforma" a matriz em identidade, reduzindo possíveis erros.
	gluLookAt(posx,posy,posz,ox,oy,oz,lx,ly,lz); // Define a pos da câmera, para onde olha e qual eixo está na vertical.
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // "limpa" um buffer particular ou combinações de buffers, onde buffer é uma área de armazenamento para informações da imagem. Nesse caso, está "limpando os buffers para suportarem animações.
	glPushMatrix(); // Salva o estado atual da cena. O que for desenhado após não influencia o já representado
	glColor3ub(100, 255, 40); //DEFINE cor (R, G, B e percentual de transparência para o objeto)
	glutSolidTeapot(5.0);
	glColor4f(0.9, 0.2, 0.9, 0.35); //DEFINE cor (R, G, B e percentual de transparência para o objeto)
	glutSolidCube(10.0);
	glPopMatrix();  //Retorna ao estado anterior da cena. O que for desenhado após o Push não influenciou o já representado
	glutSwapBuffers(); //Executa a Cena. SwapBuffers dá suporte para mais de um buffer, permitindo execução de animações sem cintilações.
}
void MOUSE(int botao, int estado, int x, int y)
{  // botão recebe o código do botão pressionado. estado recebe se está pressionado ou não. x e y recebem respectivamente as posições do cursor do mouse
	switch (botao)
	{
		case GLUT_LEFT_BUTTON:
		if (estado == GLUT_DOWN)
		{
			projecao=1;
			posx=0; posy=10; posz=20;
       			ox=0,oy=0,oz=0;
			lx=0, ly=1,lz=0;
			glutPostRedisplay();
      		}
		break;
		case GLUT_RIGHT_BUTTON:
		if(estado == GLUT_DOWN)
		{
			projecao=0;
			posx=0; posy=10; posz=20;
			oy=0; ox=0;  oz=0;
			lx=0, ly=1,lz=0;
			glutPostRedisplay();
		}
		break;
	}
}
void keyboard (unsigned char key, int x, int y)
{  // Key recebe o código ASCII da tecla. x e y recebem respectivamente as posições do cursor do mouse (permite tratar os dois dispositivos)
	if (key=='d') { lz=0; ly=1; ox+=5; }
	else if (key=='e') { lz=0; ly=1; ox-=5;	}
	else if (key=='c') { lz=0; ly=1; oy+=5;	}
	else if (key=='b') { lz=0; ly=1; oy-=5; }
	else if (key==27) { exit(0); }
	glutPostRedisplay();
}
void TeclasEspeciais (unsigned char key, int x, int y)
{  //Key - recebe o código ASCII da tecla. x e y recebem respectivamente as posições do cursor do mouse (permite tratar os dois dispositivos)
	if (key==GLUT_KEY_RIGHT) { posx+=5; ox+=5; }
	else if (key==GLUT_KEY_PAGE_UP) { posy+=5; oy+=5; }
	else if (key==GLUT_KEY_UP) { posz-=5; oz-=5; }
	else if (key==GLUT_KEY_LEFT) { posx-=5; ox-=5; }
	else if (key==GLUT_KEY_PAGE_DOWN) { posy-=5; oy-=5; }
	else if (key==GLUT_KEY_DOWN) { posz+=5; oz+=5; }
	glutPostRedisplay();
}
int main(int argc, char *argv[])
{
	glutInit(&argc, argv); //Dá suporte para diferentes SO.
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); /* Avisa a GLUT que modo de exibição deve ser usado quando a janela é criada. GLUT_DOUBlE permite animações (sem cintilações). GLUT_RGB permite cores compostas por Vermelho, Verde e Azul. GLUT_STENCIL é o buffer que permite trablhar com profundidade e elimina faces escondidas.
	glutInitWindowSize(500, 500);
	glutInitWindowPosition(10, 10);
	glutCreateWindow("Estrutura para uma Aplicação 3D");
	INIT();
	glutDisplayFunc(DISPLAY);
	glutMouseFunc(MOUSE);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(TeclasEspeciais);
	glutMainLoop(); // Permite que a execução do programa continue
	return 0; // retorna falso para o SO, indicando que o programa foi finalizado.
}

A linguagem usada neste programa foi C. Para compilar usando o gcc basta abrir um terminal (xterm, por exemplo) e digitar:

gcc -o estrutura_basica -Wall -lglut -lGL -lGLU estrutura_basica.c

E para rodar basta digitar

./estrutura_basica

Comandos

GLUT_DOUBLE: Permite que a freqüência de apresentação não prejudique sua apresentação. Esse comando coloca mais de um buffer trabalhando para que não seja vista a cintilação. Se usarmos GLUT_SINGLE, acabamos vendo quadro a quadro.

GLUT_RGB: Define a cor que será trabalhada. RGB respectivamente significam red, green, blue (vermelho, verde, azul).

GLUT_DEPTH: Configura o ambiente para que o programa consiga representar animação com noção de profundidade.

GLUT_STENCIL: Habilita o gerenciamento de eliminação de superfície escondidas. Considera o ponto de vista do observador e o que está na frente pode ser visto, enquanto o que está atrás é eliminado. Respeita a hierarquia do ambiente (ou algo do tipo).

glutInitWindowSize: Define o tamanho da janela (em pixels).

glutInitWindowPosition: Define em qual posição da tela ele vai abrir a janela.

glutCreateWindow: Cria a janela

glClearColor: Limpa a janela com a cor que será usada. Os 3 primeiros valores definem respectivamente as cores vermelho, verde e azul (RGB) e o quarto valor define a transparência.

glEnable(GL_BLEND): Habilita a transparência. Enquanto glEnable é o comando que habilita alguma coisa, o GL_BLEND é a transparência que está sendo habilitada pelo glEnable.

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA): Trata a composição da cor do objeto tomando como ponto de referência o observador. O primeiro parâmetro se refere ao objeto de frente (tomando como referência o observador). O segundo define que o objeto será responsável por uma fração igual ao quarto argumento do glColor no cálculo total das cores.

glShadeModel(GL_SMOOTH): glShadeModel é usada para especificar a técnica de colorização desejada. GL_SMOOTH seleciona o sistema de preenchimento, permitindo gradiente de cores.

glutDisplayFunc: Faz o gerenciamento de uma função. No código visto neste post, o nome da função era Display, portanto o comando ficou da seguinte forma: glutDisplayFunc(DISPLAY). O nome da função pode ser qualquer um.

glutMouseFunc: Função que gerencia o mouse.

glutKeyboardFunc: Função que gerencia teclas comuns do teclado.

glutSpecialFunc: Função que gerencia teclas especiais do teclado como F1, F2, Esc, Enter etc.

glutMainLoop: Permite que a execução do programa continue.

glColor3ub: Define as cores (RGB).

glutSolidTeapot: Desenha um bule de chá.

glutWireTeapot: Desenha um bule de chá aramado.

glutSolidCube: Desenha um cubo

glutWireCube: Desenha um cubo aramado (se é que podemos chamar de aramado O.o)

Antes mesmo de fazer este post estava com um pressentimento de que essa aula não sairia da forma que eu queria. Realmente está muito vago isso e vou procurar melhorar nos próximos posts. Posso apenas dizer que isso é culpa da minha falta de conhecimento na matéria. Uma dica que posso dar (a mesma que o professor deu quando passou esta aula ¬¬) é que imprimam o código do programa que foi passado, peguem alguma apostila e/ou livro de OpenGL e façam uma boa leitura das funções. Por enquanto, fico na espera de comentários com sugestões, críticas, reclamações, dicas, dúvidas e, já que esta aula não saiu bem da forma como planejei, de uma turba de leitores enfurecidos com pedras nas mãos prontos para me apedrejar -.-

Technorati Tags: computação gráfica, computação, gráficos, gráfica, OpenGL, GL, jogos, filmes, animação, animações, placa de vídeo, vídeo, 3D, modelagem, objeto, ortogonal, perspectiva, teste de mesa, comandos, aulas, recursos, linhas, aliasing, pitch, pixel, glu, glut, API, X, Xwindow, Ruindows, janelas, windows, matrizes, superfícies, composição, library, bibliotecas, textura, blending, aliasing, desenho, linhas, pontos

Powered by ScribeFire.