Ir para o conteúdo
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

morther

Open GL "iluminação"

Mensagens Recomendadas

morther

Boas Pessoal,

comecei a muito pouco tempo a utilizar o openGL e ainda estou muito verde no assunto, e precisava aqui de uma ajudinha...

Tenho um objecto desenhado, a cena permite interacção com o teclado e tem um menu com alguns submenus de opçoes, no entanto gostava de acrescentar iluminação segundo o seguinte enunciado:

____________________________________________________________________________

Pretende-se que ilumine a cena que desenhou no exercício prático de avaliação anterior.

Para demonstrar a interacção da luz com os materiais dos objectos na cena, tenha em

conta o seguinte:

a) Parta do programa criado no exercício de avaliação anterior e acrescente 2 tipos de

luz: uma direccional e um spotlight que podem ser ligadas e desligadas através de um

menu de pop-up

:P Atribua 2 tipos diferentes de material ao objecto que compõe a cena.

c) Acrescente uma terceira luz de forma a demonstrar o efeito de posicionamento de luz:

luz a deslocar-se com o ponto de vista (tipo lanterna do mineiro).

__________________________________________________________________________

Precisava de alguma ajuda aqui.

P.S. Se conseguirem resolver tambem os varios BUGS que tem agradecia  ;)

Já desenvolvi o seguinte:

#include <gl\glut.h>

#include <math.h>

#include <stdio.h>

//medidas

GLfloat altura=8;

GLint n_faces=100;

GLfloat raio=1;

GLfloat alt_triang=altura/2+5;

//rotação

GLfloat xrot=0;

GLfloat yrot=0;

GLfloat zrot=0;

GLint rotx=0;

GLint roty=0;

GLint rotz=0;

//translação

GLfloat xtrans=0;

GLfloat ytrans=0;

GLfloat transx=0;

GLfloat transy=0;

//cor

GLfloat r=1;

GLfloat g=1;

GLfloat b=1;

GLfloat rT=0.5;

GLfloat gT=0.4;

GLfloat bT=0;

GLfloat rC=0;

GLfloat gC=1;

GLfloat bC=0;

GLfloat azul[3]={0,0,1};

//Scale

GLfloat scalex=1;

GLfloat scaley=1;

GLfloat scalez=1;

GLfloat xscale=0;

GLfloat yscale=0;

GLfloat zscale=0;

//iluminação

GLfloat light_pos[] = {-2,2,2,1};

GLfloat light_ka[] = {0,0,0,1.0};

GLfloat light_kd[] = {1,1,1,1};

GLfloat light_ks[] = {1,1,1,1};

GLfloat material_ka[]={0.11,0.06,0.11,1.00};

GLfloat material_kd[]={0.43,0.47,0.54,1.00};

GLfloat material_ks[]={0.33,0.33,0.52,1.00};

GLfloat material_ke[]={0,1,1,1};

GLfloat material_se = 1;

GLfloat luz_ambiente[] = {0.5,0.5,0.5, 1.0};

GLfloat luz_difusa[] = {0.8,0.8,0.8, 1.0};

GLfloat luz_posicao[] = {5,8,0, 1.0};

//char texto[30];

void piramide(float raio, float altura, int n_faces)

{

GLint i;

GLfloat inc=2*3.1415/4;

glColor3f(rC,gC,bC); // definição da cor de desenho dos objectos

glBegin(GL_TRIANGLE_FAN);

glNormal3f(0,1,0);

glVertex3f(0,alt_triang,0);

for (i=0;i<=4;i++)

{

glVertex3f(4*raio*cos(inc*i),altura/2,4*raio*sin(inc*i));

}

glEnd();

glBegin(GL_QUAD_STRIP);

glNormal3f(0,1,0);

for (i=0;i<=4;i++)

{

glVertex3f(4*raio*cos(inc*i),altura/2,4*raio*sin(inc*i));

}

glEnd();

}

void cilindro(float raio, float altura, int n_faces)

{

glColor3f(rT,gT,bT); // definição da cor de desenho dos objectos

GLint i;

GLfloat inc=2*3.1415/n_faces;

glBegin(GL_TRIANGLE_FAN);

glNormal3f(0,1,0);

glVertex3f(0,altura/2,0);

for (i=0;i<=n_faces;i++)

{

glVertex3f(raio*cos(inc*i),altura/2,raio*sin(inc*i));

}

glEnd();

glBegin(GL_TRIANGLE_FAN);

glNormal3f(0,1,0);

glVertex3f(0,-altura/2,0);

for (i=0;i<=n_faces;i++)

{

glVertex3f(raio*cos(inc*i),-altura/2,raio*sin(inc*i));

}

glEnd();

glBegin(GL_QUAD_STRIP);

glNormal3f(0,1,0);

for (i=0;i<=n_faces;i++)

{

glVertex3f(raio*cos(inc*i),altura/2,raio*sin(inc*i));

glVertex3f(raio*cos(inc*i),-altura/2,raio*sin(inc*i));

}

glEnd();

}

void display(void) // a cena a desenhar

{

    glClearColor (r,g,b,0.0);// seleccionar a cor do background da janela

glClear(GL_COLOR_BUFFER_BIT |GL_DEPTH_BUFFER_BIT);// inicialização dos pixels

//gluLookAt(0,0,50,0,0,0,0,1,0);

glPushMatrix();

glRotatef(xrot,1,0,0);

glRotatef(yrot,0,1,0);

glRotatef(zrot,0,0,1);

glScalef(scalex,scaley,scalez);

//iluminação

glEnable(GL_LIGHTING);

glEnable(GL_COLOR_MATERIAL);

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, luz_ambiente);

glLightfv(GL_LIGHT0, GL_AMBIENT, luz_ambiente);

glLightfv(GL_LIGHT0, GL_DIFFUSE, luz_difusa);

glLightfv(GL_LIGHT0, GL_POSITION, luz_posicao);

glEnable(GL_LIGHT0);

//

glTranslatef(xtrans,ytrans,0);

cilindro(raio,altura,n_faces);

glBegin(GL_LINES);

glVertex4fv(luz_posicao);

glVertex3f(0,0,0);

glEnd();

piramide(raio,altura,n_faces);

glutSwapBuffers();

    glFlush(); // nao esperar, iniciar processamento rotinas em buffer do OpenGL

}

void alteraTamanho(int w, int h)

{

    glViewport( 0, 0, w, h);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(-10,10,-10,10,-10,10);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

}

// Gerenciamento do menu com as opções de cores         

void MenuCor(int op)

{

  switch(op) {

            case 0:

                    r = 1.0f;

                    g = 0.0f;

                    b = 0.0f;

                    break;

            case 1:

                    r = 1.0f;

                    g = 1.0f;

                    b = 0.0f;

                    break;

            case 2:

                    r = 0.0f;

                    g = 0.0f;

                    b = 1.0f;

                    break;

case 3:

                    r = 1.0f;

                    g = 0.0f;

                    b = 1.0f;

                    break;

            case 4:

                    r = 0.0f;

                    g = 0.0f;

                    b = 0.0f;

                    break;

            case 5:

                    r = 1.0f;

                    g = 1.0f;

                    b = 1.0f;

                    break;

    }

    glutPostRedisplay();

}

void MenuCorCopa(int op)

{

  switch(op) {

            case 0:

                    rC = 1.0f;

                    gC = 0.0f;

                    bC = 0.0f;

                    break;

            case 1:

                    rC = 1.0f;

                    gC = 1.0f;

                    bC = 0.0f;

                    break;

            case 2:

                    rC = 0.0f;

                    gC = 0.0f;

                    bC = 1.0f;

                    break;

case 3:

                    rC = 0.0f;

                    gC = 1.0f;

                    bC = 0.0f;

                    break;

            case 4:

                    rC = 0.0f;

                    gC = 0.0f;

                    bC = 0.0f;

                    break;

            case 5:

                    rC = 1.0f;

                    gC = 1.0f;

                    bC = 1.0f;

                    break;

    }

    glutPostRedisplay();

void MenuCorTronco(int op)

{

  switch(op) {

            case 0:

                    rT = 1.0f;

                    gT = 0.0f;

                    bT = 0.0f;

                    break;

            case 1:

                    rT = 1.0f;

                    gT = 1.0f;

                    bT = 0.0f;

                    break;

            case 2:

                    rT = 0.0f;

                    gT = 0.0f;

                    bT = 1.0f;

                    break;

case 3:

                    rT = 0.5f;

                    gT = 0.4f;

                    bT = 0.0f;

                    break;

            case 4:

                    rT = 0.0f;

                    gT = 0.0f;

                    bT = 0.0f;

                    break;

            case 5:

                    rT = 1.0f;

                    gT = 1.0f;

                    bT = 1.0f;

                    break;

    }

    glutPostRedisplay();

}               

// Gerenciamento do menu principal         

void MenuPrincipal(int op)

{

switch(op) {

            case 0: xrot=-rotx;

rotx=0;

yrot=-roty;

roty=0;

zrot=-rotz;

rotz=0;

r=1;

g=1;

b=1;

rT=0.5;

gT=0.4;

bT=0;

rC=0;

gC=1;

bC=0;

glutPostRedisplay();

if (scalex>1&&xscale!=0&&scalex!=1)

{

scalex-=xscale;

xscale=0;

scaley-=yscale;

yscale=0;

scalez-=zscale;

zscale=0;

glutPostRedisplay();

}

else if (scalex<1&&scalex>0&&xscale!=0&&scalex!=1)

{

scalex+=-1*xscale;

xscale=0;

scaley+=-1*yscale;

yscale=0;

scalez+=-1*zscale;

zscale=0;

glutPostRedisplay();

}

else if (scalex<0&&xscale!=0&&scalex!=1)

{

scalex-=xscale;

xscale=0;

scaley-=yscale;

yscale=0;

scalez-=zscale;

zscale=0;

glutPostRedisplay();

}

if (transx==0)

break;

if (transy==0)

break;

xtrans-=transx;

transx=0;

ytrans-=transy;

transy=0;

glutPostRedisplay();

scalex=1;

scaley=1;

scalez=1;

    }

}

void MenuReset(int op)

{

switch(op) {

//cor

            case 0: r=1;

g=1;

b=1;

rT=0.5;

gT=0.4;

bT=0;

rC=0;

gC=1;

bC=0;

glutPostRedisplay();

break;

//tranlação

case 1: if (transx==0)

break;

if (transy==0)

break;

xtrans-=transx;

transx=0;

ytrans-=transy;

transy=0;

glutPostRedisplay();

break;

//rotação

case 2: xrot=-rotx;

rotx=0;

yrot=-roty;

roty=0;

zrot=-rotz;

rotz=0;

glutPostRedisplay();

break;

//zoom

case 3: if (scalex==1)

break;

else if (xscale==0)

break;

else if (scalex>1)

{

scalex-=xscale;

xscale=0;

scaley-=yscale;

yscale=0;

scalez-=zscale;

zscale=0;

glutPostRedisplay();

break;

}

else if (scalex<1&&scalex>0)

{

scalex+=-1*xscale;

xscale=0;

scaley+=-1*yscale;

yscale=0;

scalez+=-1*zscale;

zscale=0;

glutPostRedisplay();

break;

}

else if (scalex<0)

{

scalex-=xscale;

xscale=0;

scaley-=yscale;

yscale=0;

scalez-=zscale;

zscale=0;

glutPostRedisplay();

break;

}

scalex=1;

scaley=1;

scalez=1;

    }

}

// Criacao do Menu

void CriaMenu(int x, int y)

{

    int menu,submenu1,submenu2,submenu3,submenu4;

    submenu1 = glutCreateMenu(MenuCor);

    glutAddMenuEntry("Vermelho",0);

    glutAddMenuEntry("Amarelo",1);

    glutAddMenuEntry("Azul",2);

glutAddMenuEntry("Rosa",3);

glutAddMenuEntry("Preto",4);

glutAddMenuEntry("Branco",5);

submenu2 = glutCreateMenu(MenuCorCopa);

    glutAddMenuEntry("Vermelho",0);

    glutAddMenuEntry("Amarelo",1);

    glutAddMenuEntry("Azul",2);

glutAddMenuEntry("Verde",3);

glutAddMenuEntry("Preto",4);

glutAddMenuEntry("Branco",5);

submenu3 = glutCreateMenu(MenuCorTronco);

    glutAddMenuEntry("Vermelho",0);

    glutAddMenuEntry("Amarelo",1);

    glutAddMenuEntry("Azul",2);

glutAddMenuEntry("Castanho",3);

glutAddMenuEntry("Preto",4);

glutAddMenuEntry("Branco",5);

submenu4 = glutCreateMenu(MenuReset);

glutAddMenuEntry("Cor",0);

glutAddMenuEntry("Tranlação",1);

glutAddMenuEntry("Rotação",2);

glutAddMenuEntry("Zoom",3);

    menu = glutCreateMenu(MenuPrincipal);

    glutAddSubMenu("Cor de Fundo",submenu1);

glutAddSubMenu("Cor da Copa",submenu2);

glutAddSubMenu("Cor do Tronco",submenu3);

glutAddSubMenu("Reset",submenu4);

glutAddMenuEntry("Reset All",0);

   

    glutAttachMenu(GLUT_RIGHT_BUTTON);

}

// Função callback chamada para gerenciar eventos do rato

void GerenciaMouse(int button, int state, int x, int y)

{       

    if (button == GLUT_RIGHT_BUTTON)

        if (state == GLUT_DOWN)

            CriaMenu(x,y);

       

    glutPostRedisplay();

}

void teclado(unsigned char key, int x, int y)

{// tratamento da interacção com o teclado

xrot=0;

yrot=0;

zrot=0;

xtrans=0;

ytrans=0;

scalex=1;

scaley=1;

scalez=1;

switch (key)

{

case 'x': xrot=xrot+2;

if (xrot>360)

xrot=xrot-360;

rotx+=2;

break;

case 'y': yrot=yrot+2;

if (yrot>360)

yrot=yrot-360;

roty+=2;

break;

case 'z': zrot=zrot+2;

if (zrot>360)

zrot=zrot-360;

rotz+=2;

break;

case 'a':  xtrans-=0.5;

transx-=0.5;

break;

case 'd':  xtrans+=0.5;

transx+=0.5;

break;

case 'w':  ytrans+=0.5;

transy+=0.5;

break;

case 's':  ytrans-=0.5;

transy-=0.5;

break;

case '+':  scalex+=0.1;

xscale+=0.1;

scaley+=0.1;

yscale+=0.1;

scalez+=0.1;

zscale+=0.1;

break;

case '-':  scalex-=0.1;

xscale-=0.1;

scaley-=0.1;

yscale-=0.1;

scalez-=0.1;

zscale-=0.1;

break;

case 'r':  xrot=-rotx;

rotx=0;

yrot=-roty;

roty=0;

zrot=-rotz;

rotz=0;

break;

default: break;

}

glutPostRedisplay();

}

void init()

{

glEnable(GL_DEPTH_TEST);

}

int main(int argc, char** argv)

{

printf("Interaccao com o teclado/rato:\n\nTecla                    Funcao\n  a -  deslocacao negativa no eixo dos xx;\n  d -  deslocacao positiva no eixo dos xx;\n");

printf("  w -  deslocacao positiva no eixo dos yy;\n  s -  deslocacao negativa no eixo dos yy;\n\n  x -  rotacao em x;\n  y -  rotacao em y;\n");

printf("  z -  rotacao em z;\n\n  + -  zoom in;\n  - -  zoom out;\n\n  r    -  Reset\n\nMouse_Right_buttom - Acesso ao menu");

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DEPTH |GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Projecto 1");

init();

glutMouseFunc(GerenciaMouse);

glutDisplayFunc(display);

glutReshapeFunc(alteraTamanho);

glutKeyboardFunc(teclado);

glutMainLoop();

return 0;

}

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora

×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.