Olá pessoal. O objetivo dessa matéria é ensinar a criar um ambiente de desenvolvimento C++ completo utilizando a IDE Eclipse, com recursos de OpenGL e GPU.

O Eclipse é um ambiente integrado de desenvolvimento (IDE) feito em Java e pode ser utilizado com diferentes linguagens de programação: C, C++, Java, PHP, Ruby, Phyton e até COBOL. Basta que os plugins necessários estejam corretamente instalados e configurados. Como o Eclipse é feito em Java, ele precisa do pacote de desenvolvimento do Java (JDK – SDK) para executar. Se não estiver instalado na máquina alvo, baixe e instale o mais atual a partir de http://java.sun.com .

Para que a IDE suporte a linguagem C/C++ é necessário instalar um plugin. Neste tutorial será utilizado o plugin CDT (C++ Development Tools: http://www.eclipse.org/cdt/) da própria Eclipse Foundation. Outros tutoriais para instalação do CDT podem ser encontrados em  http://www.cs.umanitoba.ca/~eclipse/7-EclipseCDT.pdf  e em http://www-128.ibm.com/.../opensource/library/os-ecc/ . Para saber mais sobre a arquitetura do CDT, leia http://www.eclipsecon.org/.../eclipsecon_marineau_cdt_presentation.pdf .

Os plugins de C/C++ para o Eclipse não acompanham ferramentas de compilação, linkedição e debug, portanto utilizaremos o pacote MinGW. A sigla MinGW vem de Minimalist GNU for Windows (Um projeto GNU), ou seja, é um conjunto mínimo de ferramentas GNU para desenvolvimento sobre o ambiente Windows. Outro tutorial bom para instalar o MinGW pode ser encontrado em: http://web.inf.ufpr.br/egon/mingw/ . Se desejar instalar com outros compiladores, dois tutoriais podem lhe ajudar: http://eclipsewiki.editme.com/InstallingCDTWithMSVisualC e http://eclipsewiki.editme.com/InstallingCDTWithIntelCompiler .

A OpenGL (Open Graphics Library: http://www.opengl.org/) é uma especificação que define uma API multiplataforma e multi-linguagem para aplicações com alto processamento gráfico 2D e 3D. A interface consiste de cerca de 250 funções diferentes que podem ser utilizadas para desenhar cenas tridimensionais complexas. A OpenGL é bastante popular na indústria dos videogames e compete diretamente com o Direct3D (no Microsoft Windows). O OpenGL é bastante utilizado em ferramentas CAD, realidade virtual, simulações e visualizações científicas e desenvolvimento no campo dos videogames. (Wikipédia: http://pt.wikipedia.org/wiki/OpenGL).

Como estamos falando de aplicações com alto processamento gráfico, nada melhor que utilizarmos a Graphics Processing Unit (GPU) das placas de vídeo. A GPU é um processador especializado em processamento gráfico que existe nas placas da NVidia e ATI. Com este recurso é possível que trechos de seu programa possam ser executados diretamente na placa de vídeo de uma maneira muito mais rápida que se fossem executados no processador normal do seu computador. Para tal será utilizado as libs do CG Toolkit da NVidia. É claro que esse recurso só está disponível se a sua placa de vídeo suportar GPU.

Para determinar onde cada ferramenta é instalada, este tutorial utiliza palavras chave como se fossem variáveis de ambiente, ou seja, uma sequência de concatenações: sinal de menor, o nome do aplicativo, a palavra HOME em maiúsculas e o sinal de maior. Um exemplo é o diretório de instalação do Eclipse que ficaria desta maneira: <ECLIPSE_HOME>.

Bom, chega de papo. Vamos começar!

1. Instalando a IDE Eclipse

Com o Java (JDK) instalado, vá até a página do Eclipse (http://www.eclipse.org), clique em Downloads, em All Versions e selecione o SDK do tipo de build Stream Stable Build. A versão baixada para criar este artigo foi a 3.2M5a. Aguarde o download e descompacte em qualquer diretório. Crie um atalho para o eclipse.exe em seu desktop e pronto. Já temos um ambiente de desenvolvimento Java instalado. Partiremos, então, para o ambiente C++.

2. Instalando o MinGW
Faça o download do MinGW-5.0.2.exe ou superior da página http://sourceforge.net/projects/mingw. Execute o aplicativo, clique em Next e Selecione um mirror. Clique em Next novamente e selecione o tipo de instalação Custom, marcando MinGW base tools, g++ compiler  e make. Clique em next e selecione o diretório de instalação. Selecione o atalho que você deseja criar e clique em Install. Após instalar clique em Finish.

Adicione o diretório <MINGW_HOME>/bin à variável de ambiente PATH, caso o instalador não tenha feito isso.

3. Baixando e instalando o CDT (plugin C++)
Execute o Eclipse, clique no menu Help/Software Updates/Find And Install. Na tela que abrirá, selecione Search for new features to install e clique em Next. Clique no botão New Remote Site, e na tela que abrirá, coloque C++ como nome e esta URL: http://download.eclipse.org/tools/cdt/releases/eclipse3.1

Clique em OK para fechar a tela e em Finish. O Eclipse irá procurar por plugins na URL. Se abrir uma tela para escolher um mirror, selecione o mais próximo de você e clique em OK. Ao aparecer a versão do CDT para instalar, selecione-a e clique em Finish. O Eclipse irá baixar os plugins. Após o download, o Eclipse mostrará a licença do Plugin, aceite os termos e clique em Install All. Depois de instalar, o Eclipse reiniciará a IDE e seu ambiente C++ está pronto para ser utilizado.

Antes de testarmos, vamos alterar uma configuração. A IDE tem, por default, o ambiente de instalação Cygwin e, portanto, temos que alterá-la para o MinGW. Entre no menu Window/Preferences. Abra o C/C++/Make/New Make Project e desmarque a opção Use Default. No build command, coloque: mingw32-make -f makefile

Marque a opção Build on resource save que fará executar o build a cada alteração de suas classes e clique em Finish.

4. Testando o ambiente.
Clique no menu File/New/Project. Abra a pasta C++, selecione Standard Make C++ Project e clique em Next. Coloque o nome do projeto, exemplo teste, e Next. Clique em Finish. Se pedir para trocar de perspectiva clique em Sim. Seu projeto C++ está criado.

Botão direito sobre o projeto e entre em propriedades. Abra o C/C++ Build na paleta Build Settings  e se certifique que opção Use Default esteja desmarcada e no Build command, esteja: mingw32-make -f makefile

Clique com o botão direito sobre o nome do projeto e selecione New/Source File. Coloque um nome para o seu arquivo fonte, exemplo: main.cpp e clique em Finish.

Digite:

#include <stdio.h>

int main( int argc, const char* argv[] )
{
printf( "\nHello World\n\n" );
}

Clique no menu File/New/File, entre com o nome makefile e clique em Finish.

Abra o arquivo e digite:

main : main.o
g++ -o main main.o -L C:/MinGW/lib/gcc/mingw32/3.4.2/include -lstdc++

main.o : main.cpp
g++ -ggdb -c main.cpp

all :
${MAKE} main

clean :
-del main.o

Esteja certo que o caminho do MinGW presente neste arquivo esteja correto.

Clique com o botão direto no projeto e clique em Create Make Target, digite all e continue. Você verá que será criado um executável com o nome main.exe. Basta dar um duplo clique e ver ele sendo executado. Se a IDE resolver abrir o arquivo como um arquivo Txt, clique com o botão direito sobre o executável e abra como (Open as) System Editor

Você pode utilizar também o Managed Project onde o Eclipse cria o makefile automaticamente.

5. Partindo para libs gráficas (Glut e Glui)
Primeiramente iremos instalar as extensões Glut e o Glui. Descompacte o arquivo GLUT.zip que encontra-se em anexo a este documento e coloque os arquivos .h em <MinGW_HOME>\include\GL. Os arquivos .a em <MinGW_HOME>\lib e os .dll no Windows\System32.

Reabra o Eclipse e crie um novo projeto C++. Clique com o botão direito sobre o projeto e vá em properties. Selecione C/C++ Build e na tela ao lado GCC C++ Linker/Libraries. Na lista Libraries (-l) adicione os nomes: glut32, glu32, opengl32, winmn, gdi32 nesta ordem.
Para testar, crie um arquivo fonte C++ e digite o seguinte código:

#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glut.h>

void init(void);
void display(void);

int main(int argc, char **argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowSize(250,250);
glutInitWindowPosition(100,200);
glutCreateWindow("My First Glut/OpenGL Program");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

void init(void) {
glClearColor(0.0f ,0.0f ,0.0f ,0.0f);
glColor3f(0.0f,0.0f,1.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)250/(GLfloat)250,0.1f,100.0f);
}

void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glVertex3f( 0.0f, 1.0f, -10.0f);
glVertex3f(-1.0f,-1.0f, -10.0f);
glVertex3f( 1.0f,-1.0f, -10.0f);
glEnd();
glutSwapBuffers();
}

Basta compilar e executar. Se tudo ocorrer como o planejado aparecerá um triângulo em uma nova tela. Não esqueça de verificar as opções de compilação. Clique com o botão direito sobre o projeto e entre em propriedades. Abra o C/C++ Build na paleta Build Settings  e se certifique que opção Use Default esteja desmarcada e no  Build command, esteja: mingw32-make -f makefile

6. Libs CG para GPU.
Primeiramente baixe o CG Toolkit da Nvídia ( http://developer.nvidia.com/object/cg_toolkit.html#downloads ). O baixado por este tutorial foi o Cg_1.4.0rc1-4.exe. Instale o CG Toolkit e permita que ele altere a sua variável de ambiente PATH. Coloque o diretório <CG_TOOLKIT_HOME>/bin do CG Toolkit na variável de ambiente PATH, se ele já não estiver lá.

Crie um novo projeto Managed C++ para testar. Clique com o botão direito sobre o projeto e vá em properties. Selecione C/C++ Build e na tela ao lado GCC C++ Linker/Libraries. Na lista Libraries (-l) adicione os nomes: glut32, glu32, opengl32, winmn, gdi32, cg e cgGL nesta ordem. Na mesma tela, na lista Library Search Path (-L) adicione o path para o diretório <CG_TOOLKIT_HOME>/lib. Isto incluirá as libs da CG nos Includes do projeto.

Não esqueça de verificar as opções de compilação. Abra o C/C++ Build na paleta Build Settings  e se certifique que opção Use Default esteja desmarcada e no  Build command, esteja: mingw32-make -f makefile.

Crie um novo código fonte e digite o seguinte código:

#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
#include <cg/cg.h>
#include <cg/cgGL.h>

// globals
CGcontext          cg_context;
CGprofile          cg_profile;
CGprogram          cg_program;

void cgErrorCallback(void) {
CGerror err = cgGetError();
if (err != CG_NO_ERROR) {
       printf("cgErrorCallback(): %s", cgGetErrorString(err));
       exit(1);
}
}

void init() {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

void display() {
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

cgGLEnableProfile(cg_profile);
cgGLBindProgram(cg_program);

    glColor3f(1.0, 1.0, 1.0);
    glBegin(GL_TRIANGLES);
    glVertex3f(0.25, 0.25, 0.0);
    glVertex3f(0.75, 0.25, 0.0);
    glVertex3f(0.5, 0.75, 0.0);
    glEnd();
   

cgGLDisableProfile(cg_profile);

glFlush();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(250, 250);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("cg");
    init();
    glutDisplayFunc(display);

cgSetErrorCallback(cgErrorCallback);
cg_context = cgCreateContext();
cg_profile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
cgGLSetOptimalOptions(cg_profile);
printf("profile: %s\n", cgGetProfileString(cg_profile));
cg_program = cgCreateProgramFromFile(cg_context, CG_SOURCE, "main.cg",
                                                                  cg_profile, "main", 0);
cgGLLoadProgram(cg_program);

    glutMainLoop();

cgDestroyContext(cg_context);
    return 0;
}

Crie um arquivo chamado main.cg com o seguinte código:

float4 main(void) : COLOR {
return float4(0.0, 1.0, 0.0, 1.0);
}

O Eclipse possui um problema com os arquivos de CG. O Run normal não consegue ler o arquivo corretamente, então é necessário usar o External Tools para executar. Vá no menu Run/External Tools/External Tools e crie uma nova configuração de programa. Na guia Main e entrada Location selecione o executável criado na compilação. Na entrada working directory, selecione o diretório onde o arquivo main.cg está. Clique em Run.

O código normal (OpenGL) exibe um triângulo branco. O código com o programa CG pinta o triângulo de verde.

7. Instalando o Plugin CERP para refatorações em C++
Como a IDE Eclipse possui recursos de plugins, podemos adicionar algumas facilidades ao nosso ambiente de desenvolvimento. Uma delas é o plugin CERP, que faz algumas refatorações de código de maneira automatizada.

Clique no menu Help/Software Updates/Find And Install. Na tela que abrirá, selecione Search for new features to install e clique em Next. Clique no botão New Remote Site, e na tela que abrirá, coloque CERP como nome e esta URL abaixo: http://www.cavegn.cc/cerp.

Clique em OK para fechar a tela e em Finish. O Eclipse irá procurar por plugins na URL. Se abrir uma tela para escolher um mirror, selecione o mais próximo de você e clique em OK. Ao aparecer a versão do CERP para instalar, selecione-a e clique em Finish. O Eclipse irá baixar o plugin. Após o download, o Eclipse mostrará a licença do Plugin, aceite os termos e clique em Install All. Depois de instalar, o Eclipse reiniciará a IDE e pronto, seu ambiente C++ está pronto para ser utilizado.

É isso aí pessoal, espero que toda a instalação tenha se encaminhado sem problemas (o que é um pouco difícil com o C/C++) e que seu ambiente esteja pronto para começar as brincadeiras.

Até a próxima!