Jump to content
  • Revista PROGRAMAR: Já está disponível a edição #60 da revista programar. Faz já o download aqui!

Sign in to follow this  
morther

Open GL "iluminação"

Recommended Posts

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;

}

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  

×

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.