terça-feira, 25 de setembro de 2007

OpenGL - Um ínicio

E ai Pessoal!
Sei que demorei para postar algo novo neste blog, mas finalmente consegui um tempo para poder recomeçar uma nova série de tutoriais.
Como prometido a muito tempo atras, irei iniciar uma série de artigos a respeito de OpenGL. O OpenGL para quem não conhece, é uma API gráfica para criação e utilização de "objetos" gráficos 2D e 3D. Foi criada em 1992 pela Silicon Grafics e serviu de muito uso para a criação de vários jogos na atualidade. Bom, chega de historinhas e bla bla blas e vamos ao que interessa.
Neste exemplo vamos apenas criar uma janela de 1024x768 e vamos inserir nela um retangulo branco. Vamos nessa então:

#include <GL/glut.h>

void display(){
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex3f(0.25,-0.25,0);
        glVertex3f(-0.25,-0.25,0);
        glVertex3f(-0.25,0.25,0);
        glVertex3f(0.25,0.25,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(100, 100);
   glutCreateWindow("Teste OpenGL");
    init();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0;
}

Ok, vamos compilar com o comando: gcc -o teste main.c -lglut

Entenderam?
Fácil né?
Vamos as explicações então, começando pela main:
Temos a função glutInit, esta função vai inciar o glut para nós. Como no SDL, o glut é uma API portavel, que vai servir para nós podermos compilar o mesmo código no Linux, Windows ou no MAC independentemente de alterações.
Temos que passar os argumentos da main para que ele possa inicializar o openGL certo.
Depois nós temos a função glutInitDisplayMode, nela nos dizemos como que será a nossa aplicação. No caso estou iniciando com RGB e com um single buffer. Várias outras Flags podem ser passadas para o início do Glut, mas isso vou deixar para um próximo Post.
Depois temos um glutInitWindowSize, o nome já é explicativo, mas é para dizer o tamanho da janela.
Depois temos um glutCreateWindowPosition, que também é auto explicativo, mas diz a posição de onde deve-se iniciar a janela.
Depois temos uma função chamada glutCreateWindow, exatamente aqui é onde será instanciada a janela. No Linux será chamada uma janela nova do X e será atribuido o nome de "Teste OpenGL" para ela. No Windows creio que seja o windows forms que faça isso, me corrijam se eu estiver errado. No MAC acho que é a cocoa que se encarrega disso.
Depois há a chamada da função init. Esta função diz que a cor para a janela ser limpada é o preto.

Depois da função init temos uma chamada para a função glutDisplayFunc, passando como parametro a função display. Essa função é a função que fará todo o loop de renderização de nossa aplicação. Dentro dela deverá ficar todos os nossos desenhos de tela (pelo menos nesse início).
Vamos dar uma olhada na função display:
Iniciamos fazendo uma chamada de limpeza de tela;
Depois diz que a cor do objeto é o branco;
E dai inicia um objeto. Agora cabe uma pequena aula de desenho geométrico;
Lembram-se quando a professora de matemática da 7ª/8ª série dizia sobre plano cartesiano?
Então, o que temos aqui é justamente isso, um plano cartesiano que passa exatamente no meio de nossa tela.
                     |  ----> y = 1
                     |
                     |
x=-1 ________|_____________x = 1
                     |
                     |
                     |
                     |  ----> y = -1

Temos então uma chamada a função glBegin que indica que será incializado um polígono (GL_POLYGON) e temos logo após os pontos de cada extremidade desse polígono.
Então se temos um retangulo, temos 4 pontos.
Nós dissemos que queromos um ponto na posição (0.25, -0,25, 0) , então significa que queremos na posição 0.25 do X, -0.25 do Y e 0 do Z. O plano Z é o plano de profundidade, no momento não queremos nada longe, portanto deixamos 0.

                       +y
                       | 
(-0.25, 0.25)     |          (0.25, 0.25)
           .           |         .
-X___________|_____________+X
                       |
            .          |          .
(-0.25,-0.25)     |          (0.25, -0.25)
                       |  -y

Depois que fizemos todos os pontos, fechamos o poligonos com o glEnd;
E depois fizemos um glFlush onde chamamos um update de tela.

Depois de tudo isso, novamente na main, temos um glutMainLoop, que é a função que faz todo o tratamento da janela, como por exemplo fechar, cliques, ....
Pessoal, por hoje é isso, espero que tenham gostado do inicio de uma nova série de tutoriais, e a curiosidade por novas APIs. Obrigado pela visita, e pretendo voltar a postar daqui a alguns dias, assim que meu trabalho e essa faculdade me deixar.
Obrigado a todos e até mais!

4 comentários:

felipe tonello disse...

caramba, muito bom viu!!! parabéns pela iniciativa!!!!
=)
sempre tive vontade de ler sobre isso mas tinha preguiça como todo bom programador huahauhaahauh zuera!!

mas paranbéns!!

jmsousa disse...
Este comentário foi removido pelo autor.
jmsousa disse...

Boas.

Gostei muito ,e como tal compilei em Ubuntu.

so que nao esta a reconhecer a bibilioteca glut.

Sabes como configurar ???

Obrigado.

wribeiro disse...

Escrevi o código (porque que o melhor para aprender programação - qualquer que seja ela - é escrever você mesmo, não apenas copiar, colar e compilar o exemplo dos outros).

Está ótimo para um começo. Muito bem explicado também!

buscapé

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