|
Este programa desenha numa janela com fundo branco, de dimensões 256x256 pixels, um quadrado vermelho, com vértice superior esquerdo de coordenadas (x,y)=(30, 226) e vértice inferior direito de coordenadas (x,y) = (226, 30). Quando a tecla a (keycode=97) for pressionada, o quadrado deverá ficar com a cor azul. Quando a tecla v (keycode=118) for pressionada, o quadrado deverá voltar à cor vermelha. Quando a tecla ESC (keycode=27) for pressionada o programa deverá ser finalizado.
Solução:
quadrado.cpp
#include
#define AZUL 0.0, 0.0, 1.0
#define VERMELHO 1.0, 0.0, 0.0
void init(void);
void display(void);
void quadradoVermelho();
void quadradoAzul();
void keyboard(unsigned char key, int x, int y);
int main(int argc, char** argv){
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (256, 256);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Desenhando um Quadrado");
init();
gluOrtho2D(250.0f, 250.0f, 250.0f, 250.0f);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
void init(void){
glClearColor(1.0, 1.0, 1.0, 1.0);
glOrtho (0, 256, 0, 256, -1 ,1);
}
void display(void){
quadradoVermelho();
glFlush();
}
void keyboard(unsigned char key, int x, int y){
switch (key) {
case 27:
exit(0);
break;
case 97:
quadradoAzul();
break;
case 118:
quadradoVermelho();
break;
}
glFlush();
}
void quadradoAzul(void){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (AZUL);
glBegin(GL_QUADS);
glVertex2i( 30,226);
glVertex2i( 30, 30);
glVertex2i(226, 30);
glVertex2i(226,226);
glEnd();
}
void quadradoVermelho(void){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (VERMELHO);
glBegin(GL_QUADS);
glVertex2i( 30,226);
glVertex2i( 30, 30);
glVertex2i(226, 30);
glVertex2i(226,226);
glEnd();
}
Desenhe duas linhas que representem os eixos cartesianos do universo, acrescentando os quatro vértices necessários para o desenho dos eixos);Desenhe duas linhas que representem os eixos cartesianos do universo, acrescentando os quatro vértices necessários para o desenho dos eixos;Desenhe duas linhas que representem os eixos cartesianos do universo acrescentando os quatro vértices necessários para o desenho dos eixo. Desenhe um triângulo e um quadrado, que devem ser definidos de maneira a formar uma casinha, como mostra a figura abaixo:
Inclua teclas especiais com as seguintes funções:
a. rotacionar o objeto para esquerda cada vez o usuário pressiona a tecla Page Up.
b. rotacionar o objeto para direita cada vez o usuário pressiona a tecla Page Down.
c. aumentar o tamanho do objeto cada vez que o usuário pressionar o botão esquerdo do mouse.
d. diminuir o tamanho do objeto cada vez que o usuário pressionar o botão direito do mouse.
e. transladar o objeto para cima, para baixo, para a esquerda e para a direita sempre que o usuário pressionar cada uma das teclas de setas.
Solução
#include <glut.h>
GLint tx, ty, angulo;
GLfloat ex, ey;
// Função callback chamada para fazer o desenho
void Desenha(void)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Limpa a janela de visualização com a cor de fundo especificada
glClear(GL_COLOR_BUFFER_BIT);
// Desenha eixos cartesianos
glBegin(GL_LINES);
glColor3f(1.1f, 1.1f, 1.1f);
glLineWidth(1.0f);
glVertex2f(-600,0);
glVertex2f(600,0);
glVertex2f(0,-600);
glVertex2f(0,600);
glEnd();
// Especifica que a cor corrente é vermelha
// R G B
glColor3f(1.0f, 0.0f, 0.0f);
// Desenha um quadrado preenchido com a cor corrente
glLineWidth(3);
glTranslatef(tx, ty, 0);
glScalef(ex, ey, 1);
glRotatef(angulo,0,0,1);
glBegin(GL_TRIANGLES);
glColor3f(0.0f, 0.0f, 1.0f);
glVertex2i(50,100);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex2i(100,150);
glColor3f(0.0f, 0.0f, 1.0f);
glVertex2i(150,100);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2i(50,1);
glVertex2i(50,99);
glVertex2i(150,99);
glVertex2i(150,1);
glEnd();
// Executa os comandos OpenGL
glFlush();
}
// Inicializa parâmetros de rendering
void Inicializa (void)
{
tx= 0;
ty= 0;
angulo= 0;
ex= 1;
ey= 1;
// Define a cor de fundo da janela de visualização como preta
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}
// Função callback chamada quando o tamanho da janela é alterado
void AlteraTamanhoJanela(GLsizei w, GLsizei h)
{
// Evita a divisao por zero
if(h == 0) h = 1;
// Especifica as dimensões da Viewport
glViewport(0, 0, w, h);
// Inicializa o sistema de coordenadas
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Estabelece a janela de seleção (left, right, bottom, top)
if (w <= h)
// gluOrtho2D (0.0f, 250.0f, 0.0f, 250.0f*h/w);
// else
// gluOrtho2D (0.0f, 250.0f*w/h, 0.0f, 250.0f);
gluOrtho2D(-250.0f, 250.0f, -250.0f, 250.0f);
}
void TeclasEspeciais(int key, int x, int y)
{
switch (key)
{
case GLUT_KEY_PAGE_UP:
angulo++;
break;
case GLUT_KEY_PAGE_DOWN:
angulo--;
break;
case GLUT_KEY_UP:
ty++;
break;
case GLUT_KEY_DOWN:
ty--;
break;
case GLUT_KEY_LEFT:
tx--;
break;
case GLUT_KEY_RIGHT:
tx++;
break;
}
glutPostRedisplay();
}
void Clique_Mouse(int b,int state,int x, int y)
{
switch(b)
{
case GLUT_LEFT_BUTTON:
ex= ex + 0.1;
ey= ey + 0.1; //ey++;
break;
case GLUT_RIGHT_BUTTON:
ex= ex - 0.1;
ey= ey - 0.1;
break;
}
glutPostRedisplay();
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(10,10);
glutCreateWindow("Quadrado");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutSpecialFunc(TeclasEspeciais);
glutMouseFunc(Clique_Mouse);
Inicializa();
glutMainLoop();
}
Programa que mostra um objeto hierárquico, as transformações aplicadas na base do objeto são propagadas para as outras partes, há uma composição das transformações geométricas. Deve ser aplicada uma escala somente na base, pois os "braços" foram modelados com um tamanho maior que a base.
Implementar o zoom, quando clicar com o botão direito do mouse, e decrementar quando clicar com o botão esquerdo.
Criar menu para que o usuário possa trocar a cor da borboleta. Devem existir duas opções de cores.
A execução do programa deverá ser igual a figura abaixo:
Solução:
#include <glut.h>
#include <stdio.h>
// variáveis para zoom do objeto e cores da borboleta.
GLfloat win, r, g, b;
// Declaração das variáveis de translação.
GLfloat txObj, txBorboleta;
// Declaração das Variáveis usadas nos braços.
GLfloat braco1, braco2;
// Declara e Inicializa variável que determina o tamanho da borboleta.
GLsizei tamanhoBorboleta = 1;
// Tamanho do incremento na direção x a cada intervalo de tempo.
GLfloat moveXPassos = 0.8;
// Declaração de Variáveis responsáveis pela Largura e Altura da janela.
GLfloat LarguraJ;
GLfloat AlturaJ;
//Função que desenha a borboleta.
void DesenhaBorboleta()
{
glLineWidth(2);
glBegin(GL_LINE_LOOP);
glVertex2f( 0.5, 1.0);
glVertex2f( 0.5,-1.0);
glVertex2f(-0.5, 1.0);
glVertex2f(-0.5,-1.0);
glEnd();
}
//Função que desenha o braço1.
void DesenhaBraco()
{
glLineWidth(2);
glBegin(GL_LINE_LOOP);
glVertex2f( 1.0, 4.6);
glVertex2f( 1.0,-0.8);
glVertex2f(-1.0,-0.8);
glVertex2f(-1.0, 4.6);
glEnd();
glPointSize(2);
glBegin(GL_POINTS);
glVertex2i(0,0);
glEnd();
}
//Função desenha braço2.
void DesenhaBraco2()
{
glLineWidth(2);
glBegin(GL_LINE_LOOP);
glVertex2f( 1.0, 4.6);
glVertex2f( 1.0,-0.8);
glVertex2f(-1.0,-0.8);
glVertex2f(-1.0, 4.6);
glEnd();
glPointSize(2);
glBegin(GL_POINTS);
glVertex2i(0,0);
glEnd();
}
// Função que desenha a base.
void DesenhaBase()
{
glLineWidth(2);
glBegin(GL_LINE_LOOP);
glVertex2f( 1.5, 1);
glVertex2f( 1.5,-1.5);
glVertex2f( 1.0,-1.5);
glVertex2f( 1.0,-1);
glVertex2f(-1.0,-1);
glVertex2f(-1.0,-1.5);
glVertex2f(-1.5,-1.5);
glVertex2f(-1.5, 1);
glEnd();
}
//Função desenha piso.
void DesenhaPiso()
{
glLineWidth(4);
glBegin(GL_LINES);
glColor3f(0.0, 0.7, 0.0);
glVertex2f(-400.0, -4.8);
glVertex2f( 400.0, -4.8);
glEnd();
}
// Função para executar as inicializações.
void Inicializa(void)
{
// Cor Azul
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
r = 1.0;
g = 0.0;
b = 1.0;
win = 20;
txObj = 0;
braco1 = 0;
braco2 = 270;
txBorboleta = 0;
printf(" Setas para esquerda e para direita movimentam a base (vermelha).");
printf("
Home e End rotacionam o braco 1 (verde).");
printf("
PageUP e PageDn rotacionam o braco 2 (azul).");
printf("
Botoes direito para aumentar zoom.");
printf("
Botoes esquerdo para diminuir zoom.");
printf("
Botao de scroll do mouse exibe menu com opcoes de cor da borboleta.");
}
// Callback chamada quando o tamanho da janela é alterado
void AlteraTamanhoJanela(GLsizei w, GLsizei h)
{
// Especifica o tamanho da Viewport
glViewport(0, 0, w, h);
// Inicializa o sistema de coordenadas
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Estabelece a janela de seleção (left, right, bottom, top)
if (w <= h)
{
AlturaJ = win*h/w;
LarguraJ = win;
}
else
{
LarguraJ = win*w/h;
AlturaJ = win;
}
// Estabelece o volume de visualização (left, right, bottom, top)
gluOrtho2D(-win, LarguraJ, -win, AlturaJ);
}
// Callback chamada de acordo com um "idle"
void Timer(int value)
{
// Muda a direção da borboleta antes de chegar a borda esquerda ou direita
if(txBorboleta > LarguraJ-tamanhoBorboleta-7 || txBorboleta < -15)
moveXPassos = -moveXPassos;
/* Verifica as bordas. Se a window for menor e a
borboleta sair do volume de visualização */
if(txBorboleta > LarguraJ-tamanhoBorboleta)
txBorboleta = LarguraJ-tamanhoBorboleta-1;
// Movimenta borboleta
txBorboleta += moveXPassos;
glutPostRedisplay();
glutTimerFunc(120,Timer, 1);
}
// Callback chamada quando as teclas especiais são pressionadas
void TeclasEspeciais(int key, int x, int y)
{
// Move a base
if(key == GLUT_KEY_LEFT)
txObj--;
if(key == GLUT_KEY_RIGHT)
txObj++;
// Rotaciona braco1
if(key == GLUT_KEY_HOME)
braco1-=2;
if(key == GLUT_KEY_END)
braco1+=2;
// Rotaciona braco2
if(key == GLUT_KEY_PAGE_UP)
braco2-=2;
if(key == GLUT_KEY_PAGE_DOWN)
braco2+=2;
glutPostRedisplay();
}
// Controla as opções de cor do menu.
void MenuTrocaCorBorboleta(int opcao)
{
switch(opcao) {
case 0:
r = 0.0; // verde
g = 1.0;
b = 0.0;
break;
case 1:
r = 1.0; //vermelho
g = 0.0;
b = 0.0;
break;
/* case 2:
r = 0.0; // azul
g = 0.0;
b = 1.0;
break; */
}
glutPostRedisplay();
}
// Cria o menu com opções de cores para a borboleta.
void MenuOpcoes()
{
int menu;
menu = glutCreateMenu(MenuTrocaCorBorboleta);
glutAddMenuEntry("Verde",0);
glutAddMenuEntry("Vermelho",1);
//glutAddMenuEntry("Azul",2);
glutAttachMenu(GLUT_MIDDLE_BUTTON);
}
// Função callback chamada para gerenciar eventos do mouse.
void GerenciaMouse(int button, int state, int x, int y)
{
// Zoom out
if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
win--;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D (-win, win, -win, win);
}
// Zoom in
if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
win++;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D (-win, win, -win, win);
}
//opções do Menu
if (button == GLUT_MIDDLE_BUTTON)
{
if (state == GLUT_DOWN)
MenuOpcoes();
}
glutPostRedisplay();
}
// Callback chamada para fazer o desenho
void Desenha(void)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
// Borboleta
glPushMatrix();
glColor3f(r, g, b);
glTranslatef(txBorboleta,15.0,1.0);
DesenhaBorboleta();
glPopMatrix();
// Objeto
glPushMatrix();
glTranslatef(txObj,0.0,0.0);
// Braços
glPushMatrix();
glRotatef(braco1, 0.0, 0.0, 1.0);
// Braço 2
glPushMatrix();
glColor3f(0.0, 0.0, 1.0);
glTranslatef(0.1, 2.8, 0.0);
glRotatef(braco2, 0.0, 0.0, 1.0);
DesenhaBraco2();
glPopMatrix();
// Braço 1
glPushMatrix();
glColor3f(0.0, 1.0, 0.0);
DesenhaBraco();
glPopMatrix();
glPopMatrix();
// Base
glPushMatrix();
glColor3f(1.0, 0.0, 0.0);
glTranslatef(0.0,-1.5,0.0);
glScalef(2.0,2.0,1.0);
DesenhaBase();
glPopMatrix();
glPopMatrix();
// Piso
DesenhaPiso();
//glFlush();
glutSwapBuffers();
}
// Programa principal
void main(void)
{
glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(400,350);
glutInitWindowPosition(10,10);
glutCreateWindow("Trabalho1");
Inicializa();
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutSpecialFunc(TeclasEspeciais);
glutMouseFunc(GerenciaMouse);
glutTimerFunc(120, Timer, 1);
glutMainLoop();
}
Programa que realiza as transformações geométricas: translação, rotação e escala e a iluminação de em um objeto 3D.
Solução:
#include <glut.h>
#include <stdio.h>
// GLfloat fAngulo, fAspect, x_obj, y_obj, scala_obj, rotaciona_obj;
GLfloat fAngulo, scala_obj, rotaciona_obj, fAspect, x_obj, y_obj;
// Função callback chamada para fazer o desenho
void Desenha(void)
{
// Limpa a janela e o depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
glColor3f(0.2f, 0.5f, 1.0f ); // azul claro
glPushMatrix();
glTranslatef(x_obj,y_obj,0.0);
glScalef(scala_obj, scala_obj,1.0);
glRotatef(rotaciona_obj, 0.0, 90.0, 1.0);
glutSolidTeapot(40.0f);
glPopMatrix();
glutSwapBuffers();
}
// Inicializa parâmetros de rendering
void Inicializa (void)
{
GLfloat luzAmbiente[4]={0.2,0.2,0.2,1.0};
// "cor"
GLfloat luzDifusa[4]={0.7,0.7,0.7,1.0};
// "brilho"
GLfloat luzEspecular[4]={1.0, 1.0, 1.0, 1.0};
GLfloat posicaoLuz[4]={0.0, 50.0, 50.0, 1.0};
// Capacidade de brilho do material
GLfloat especularidade[4]={1.0,1.0,1.0,1.0};
GLint especMaterial = 60;
// Especifica que a cor de fundo da janela será preta
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// Habilita o modelo de colorização de Gouraud
glShadeModel(GL_SMOOTH);
// Define a refletância do material
glMaterialfv(GL_FRONT,GL_SPECULAR, especularidade);
// Define a concentração do brilho
glMateriali(GL_FRONT,GL_SHININESS,especMaterial);
// Ativa o uso da luz ambiente
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, luzAmbiente);
// Define os parâmetros da luz de número 0
glLightfv(GL_LIGHT0, GL_AMBIENT, luzAmbiente);
glLightfv(GL_LIGHT0, GL_DIFFUSE, luzDifusa );
glLightfv(GL_LIGHT0, GL_SPECULAR, luzEspecular );
glLightfv(GL_LIGHT0, GL_POSITION, posicaoLuz );
// Habilita a definição da cor do material a partir da cor corrente
glEnable(GL_COLOR_MATERIAL);
//Habilita o uso de iluminação
glEnable(GL_LIGHTING);
// Habilita a luz de número 0
glEnable(GL_LIGHT0);
// Habilita o depth-buffering
glEnable(GL_DEPTH_TEST);
fAngulo=70;
x_obj = 0.0;
y_obj = 0.0;
scala_obj = 1;
rotaciona_obj = 0.0;
printf(" [Setas] movem o objeto nos eixos (X) e (Y).");
printf("
[Home e End] aumenta ou diminui a escala.");
printf("
[PageUP e PageDn] rotacionam o objeto no eixo Y.");
}
// Função usada para especificar o volume de visualização
void EspecificaParametrosVisualizacao(void)
{
// Especifica sistema de coordenadas de projeção
glMatrixMode(GL_PROJECTION);
// Inicializa sistema de coordenadas de projeção
glLoadIdentity();
// Especifica a projeção perspectiva
gluPerspective(fAngulo,fAspect,0.4,500);
// Especifica sistema de coordenadas do modelo
glMatrixMode(GL_MODELVIEW);
// Inicializa sistema de coordenadas do modelo
glLoadIdentity();
// Especifica posição do observador e do alvo
gluLookAt(0,0,200, 0,0,0, 0,1,0);
}
// Função callback chamada quando o tamanho da janela é alterado
void AlteraTamanhoJanela(GLsizei w, GLsizei h)
{
// Para previnir uma divisão por zero
if ( h == 0 ) h = 1;
// Especifica o tamanho da viewport
glViewport(0, 0, w, h);
// Calcula a correção de aspecto
fAspect = (GLfloat)w/(GLfloat)h;
EspecificaParametrosVisualizacao();
}
// Função callback chamada para gerenciar eventos do mouse
void GerenciaMouse(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
{
// Zoom-in
if (fAngulo >= 10) fAngulo -= 5;
}
}
if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
{
// Zoom-out
if (fAngulo <= 130) fAngulo += 5;
}
}
EspecificaParametrosVisualizacao();
glutPostRedisplay();
}
// Callback chamada quando as teclas especiais são pressionadas
void TeclasEspeciais(int key, int x, int y)
{
if(key == GLUT_KEY_LEFT)
x_obj -= 2;
if(key == GLUT_KEY_RIGHT)
x_obj += 2;
if(key == GLUT_KEY_UP)
y_obj += 2;
if(key == GLUT_KEY_DOWN)
y_obj -= 2;
if(key == GLUT_KEY_HOME)
scala_obj += 0.2;
if(key == GLUT_KEY_END)
scala_obj -= 0.2;
if(key == GLUT_KEY_PAGE_UP)
rotaciona_obj-=2;
if(key == GLUT_KEY_PAGE_DOWN)
rotaciona_obj+=2;
glutPostRedisplay();
}
// Programa Principal
int main(void)
{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(400,350);
glutCreateWindow("Bule Azul em 3D");
glutDisplayFunc(Desenha);
glutReshapeFunc(AlteraTamanhoJanela);
glutSpecialFunc(TeclasEspeciais);
glutMouseFunc(GerenciaMouse);
Inicializa();
glutMainLoop();
}