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!