OpenGl com OpenTK no Visual Studio

Imagem gerada por Reza Ali no OpenGL.

A programação de gráficos é uma das partes mais importantes no desenvolvimento de jogos. E  é por isto que é importante saber como criar gráficos 3D em qualquer aplicação. Por isto, vamos iniciar uma pequena série sobre como usar o OpenGL em um aplicativo Windows. Escolhi o OpenGL por ser gratuito e ser bem disseminado. Eu vou também empregar o Visual Studio Express 2010, mais especificamente a sua versão C++/CLI. Esta versão é muito próxima do C#, então programadores nesta linguagem poderão facilmente adaptar seu código. Minha escolha por este ambiente é por mera preferência: eu já estou mais acostumado a programar ali. No momento que escrevo este post, há a versão 2013 para se fazer download. Escolhi não atualizar ainda, pois isto poderia levar um tempo que eu ainda não tenho, tanto para atualizar quanto para me acostumar com o novo ambiente. De qualquer forma, acredito que o que eu vou escrever aqui sirva para qualquer um dos dois.

Instalando o OpenGL

Antigamente quando se desejava usar o OpenGL em seus projetos, bastava incluir os cabeçalhos do OpenGL no seu programa e começar a usar suas funções. Isto é bem mais complicado em programas C++/CLI ou C#. Eles precisam importar cada função da DLL do OpenGL, antes de usá-las. Felizmente, algumas pessoas facilitaram nossa vida, criando wrappers para o OpenGL. Você instala o wrapper, e emprega as funções OpenGL, da mesma forma que fazia antes.
Um que me foi recomendado é o OpenTK. Não tive tempo de testar outros, mas provavelmente devem ter as mesmas funcionalidades. O OpenTK tem a vantagem de traduzir todas as variáveis de um ambiente não gerenciado para um ambiente gerenciado como o C# e o C++/CLI. O OpenTK tem um tutorial bem fácil de seguir, para aqueles que desejam se aventurar com ele.
Então, o primeiro passo é fazer o download do OpenTK e instalá-lo em qualquer diretório.
Depois disto, o tutorial informa, na parte de instalação, que devemos clicar em References na janela Solution Explorer do Visual Studio. Bem, no meu Visual Studio, esta opção não está na Solution Explorer diretamente, mas pode ser acessada clicando-se com o botão direito no nome do projeto, nesta janela. A janela de Referências será aberta...

Se você clicar no botão Add New Reference, vai aparecer uma lista de possíveis referências. O OpenTK se encontrará na aba .NET:

Adicione esta referência, clicando em OK. É importante observar que o projeto também deve ter uma referência a System.Drawing, então verifique se esta referência existe, e a adicione caso contrário.
Podemos agora adicionar um novo componente à nossa caixa de ferramentas. É interessante que o passo de se adicionar referências pode ser deixado de lado, caso você queira usar este componente. Trata-se do GLControl. Acontece que ao adicionar o GLControl à caixa de ferramentas já adiciona também as referências necessárias para se usá-lo. Caso não se opte por usar este componente (se você, por exemplo, quer usar toda a janela com o OpenGL), deverá adicionar as referências manualmente, como explicado acima.
Para adicionar este componente, basta clicar em algum lugar da caixa de ferramentas com o botão direito e escolher Choose Items. Uma lista de componentes disponíveis será exibida, e você deverá selecionar o componente GLControl nesta lista.

Ao clicarmos em OK, o controle aparecerá na caixa de ferramentas no grupo General. Como acontece com todos os componentes do Visual Studio, basta agora clicar no componente e criá-lo na nossa janela. Estarei criando nossa janela OpenGL com o nome de glGraphicWindow. Para empregarmos os comandos OpenGL em nosso código, devemos inserir as duas seguintes linhas abaixo, na área apropriada do código:

 using namespace OpenTK::Graphics;
 using namespace OpenTK::Graphics::OpenGL;

Depois de adicionar estas linhas, adicione o evento Paint de nosso glGraphicWindow. Depois de adicionar este evento, insira o seguinte código:

 private: System::Void glGraphicWindow_Paint(System::Object^  sender, System::Windows::Forms::PaintEventArgs^  e) 
{
     GL::Clear(ClearBufferMask::ColorBufferBit | ClearBufferMask::DepthBufferBit);
     glGraphicWindow->SwapBuffers();
}

Usamos duas funções acima que são definidas pelo OpenGL. A função GL::Clear é o wrapper da função glClear do OpenGL, que limpa a tela do componente. Já o método SwapBuffers do nosso objeto GLControl faz a troca de buffers de imagem. Se neste momento mandarmos executar o programa, uma janela com uma parte preta será exibida:

Bem, uma janela assim não é muito significativa, não é? Mas por enquanto ela serve para ilustrar o uso do OpenGL. Vamos agora, para concluir, testar mais um último comando antes de inicializarmos o viewport. Para este comando, vamos adicionar também o evento Load do componente glGraphicWindow. O código adicionado será o seguinte:

 private: System::Void glGraphicWindow_Load(System::Object^  sender, System::EventArgs^  e) 
{
     GL::ClearColor(Color::Red);
}

O que fizemos agora é chamar a função glClearColor do OpenGL, que define a cor de fundo da janela que criamos. Observe que nesta função usamos uma definição do próprio C++/CLR para definir a cor de fundo. Pelo OpenGL teríamos que usar os valores RGB da cor desejada. Como resultado, temos a nova janela:

Conclusão

Esta é a primeira parte de nossa série sobre o OpenGL, que mostra alguns comandos básicos. Esperamos apresentar alguns recursos, suficientes para fazer uma pequena animação e controlá-la. No próximo post, esperamos tratar de algumas formas de desenho.