quarta-feira, 7 de novembro de 2007

OpenGL Parte II


Dae pessoal!
Perdão pela demora na atualização, mas meu trabalho está realmente exigindo muito de mim.
E a faculdade então, nem tenho o que falar.
Mas chega de choro, e vamos ao que interessa.

Vamos fazer uma pequena animação, onde desenharemos um retângulo e colocaremos cores em cada vértices.
A cada delay passado, será atualizada a cor de cada vértice, então teremos um efeito bem legal no nosso tutorial.
Bom, como normalmente, abra um editor de textos e mande ver.


#include <
GL/glut.h>
#include
<stdio.h>
#include <stdlib.h>
#define DELAY 200

float r1=0.7, r2=0.2, r3=0.5, r4=0.0;
float g1=0.3, g2=0.9, g3=0.3, g4=0.5;
float b1=0.1, b2=0.0, b3=0.8, b4=0.7;

void anima(){
r1+=0.1; g1+=0.1; b1+=0.1;
r2+=0.1; g2+=0.1; b2+=0.1;
r3+=0.1; g3+=0.1; b3+=0.1;
r4+=0.1; g4+=0.1; b4+=0.1;

if(r1>=1) r1=0; if(g1>=1) g1=0;
if(b1>=1) b1=0; if(r2>=1) r2=0;
if(g2>=1) g2=0; if(b2>=1) b2=0;
if(r3>=1) r3=0; if(g3>=1) g3=0;
if(b3>=1) b3=0; if(r4>=1) r4=0;
if(g4>=1) g4=0; if(b4>=1) b4=0;

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glColor3f(r1,g1,b1); glVertex3f(-0.5,-0.5,0);
glColor3f(r2,g2,b2); glVertex3f(0.5,-0.5,0);
glColor3f(r3,g3,b3); glVertex3f(0.5,0.5,0);
glColor3f(r4,g4,b4); glVertex3f(-0.5,0.5,0);
glEnd();
glFlush();
glutTimerFunc(DELAY,anima, 0);
}

void display(){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex3f(-0.5,-0.5,0);
glColor3f(1,0,0);
glVertex3f(0.5,-0.5,0);
glColor3f(0,1,0);
glVertex3f(0.5,0.5,0);
glColor3f(0,0,1);
glVertex3f(-0.5,0.5,0);
glColor3f(0,0,0);
glEnd();
glFlush();
}

void init(){
glClearColor(0,0,0,0);
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
glutInitWindowSize(1024,768);
glutInitWindowPosition(0,0);
glutCreateWindow("Draw Colors");

init();
glutDisplayFunc(display);
glutTimerFunc(DELAY,anima, 0);
glutMainLoop();

return 0;
}


Compile-o como fizemos anteriormente:
gcc -o teste main.c -lglut

Agora execute-o.

Agora vou explicar algumas coisas para todos nos situarmos:

Na Main, o que temos de novo é somente a função glutTimerFunc(DELAY, anima, 0);
Esta função como o próprio nome diz, cria um timer no programa, e chama uma função.
No primeiro argumento, você passa o delay em milisegundos. Coloquei um define para facilitar.
No segundo, se passa o rótulo da função. E o terceiro seria um parâmetro para a função.

Ok, dessa forma inicializamos uma animação. Mas se você reparar, dentro da função anima, esta função é chamada novamente. Isso é feito, porque a cada interação, ele perde o tempo, então, temos que reinicializa-la.

Agora que já explicamos a Main, vamos ver o que temos de novo em na função anima.
Depois de todos aqueles r's, g's e b's (que são as cores) temos o início de nosso retângulo, com o glBegin(GL_QUADS);.
Logo depois, antes de cada ponto glVertex3f(x, y, z); temos um cara chamado glColor3f(r,g,b);. Esse cara, faz com que cada vértice logo após ele, tenha a cor determinada. O legal do openGL, é que ele já faz a "mistura" das cores.
Fora isso não temos mais nenhuma novidade nessa função. Repare que temos novamente a chamada da glutTimerFunc(DELAY,anima, 0); no final da função. Isso é pelo motivo já explicado anteriormente.

Bom pessoal. O resto do software já foi explicado anteriormente, neste post.
Peço desculpas pela demora na atualização, e pretendo arranjar mais tempo para atualizar isso aqui com mais frequência.
Valeu pessoal! Qualquer dúvida/sugestão comments estão aí!
Abraços a todos!

Um comentário:

wribeiro disse...

Interessante este exemplo com as cores. Aqui funcionou normalmente, mas notei que na transição entre elas aparece uma linha preta aleatória em diferentes pontos do retângulo (como que piscando). Há como evitar esse "problema" na programação ou é coisa do meu sistema? Aguardo pelo exemplo com objetos 3D!

buscapé

dell
Saiba onde tem o melhor preço antes de comprar