/Desenvolvimento

voltar
/Desenvolvimento

Instalando Eclipse C++ com OpenGL e CG Toolkit

PorVitor F. Pamplona em

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!

Deixe um comentário! 8

8 comentários

Comentários

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Comentando como Anônimo

  1. Porem o makefile não funcionou…

    *** missing separator.

    Mas criando o projeto com “Managed Make C Project” funcionou perfeitamente.

    Parabéns e Obrigado pela ajuda!

    1. Algumas correções:
      > S2 Spot
      > Porem o makefile não funcionou…
      > *** missing separator.
      Encontrei o mesmo erro. Basta dar um ‘tab’ na segunda linha do target. Exemplo:
      all :
      ${MAKE} main

      fica:

      all :
      ${MAKE} main


      Outro erro:

      O makefile deve informar ‘winmm’ ao inves de ‘winmn’ na lista de libraries. Segue como ficou o meu makefile completo:

      main : main.o
      g++ -o main main.o -L C:\Users\Lucio\MinGW\lib\gcc\mingw32\4.6.2\include -lstdc++ -lglut32 -lglu32 -lopengl32 -lwinmm -lgdi32

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

      all :
      ${MAKE} main

      clean :
      -del main.o

      Bom material de ajuda para quem quer começar a programar em opengl :)

      1. caramba, essa wiki não deixa colocar tabulações. No post anterior, favor considerar as tabulações do makefile.

  2. Tive o problema do makefile também mas contornei o problema da mesma forma que o “S2 Spot”.

    Seguindo os passos de instalação/configuração com cuidado consegui compilar/executar o exemplo do Cg com sucesso.

    Parabéns pelo artigo, bem completo!

  3. Olá ótimo tutorial, funcionou certinho no meu comp com XP, mas não no note com Win7 será que existe alguma configuração a ser acresentada?

    o erro apresentado no eclipse é esse:

    Lunch falied. Bynary not found

leia mais
Este projeto é mantido e patrocinado pelas empresas: