24 de nov. de 2009

Como acessar e controlar computador remotamente com o Ubuntu

Meu problema era o seguinte, eu queria acessar minha máquina ubuntu via VNC, tentei através do "Area de trabalho remota" e também com o "Terminal Server" e o resultado sempre era o mesmo, eu conseguia acessar e me conectar no computador remoto mas não conseguia controlar o computador pois alterações ocorriam mas a tela não atualizava, ou seja, conectava mas ficava sem feedback, travado na primeira imagem recebida. Após muito pesquisar a solução recebi uma dica através de um forum: http://www.vivaolinux.com.br/topico/vivaolinux/Area-de-trabalho-remota-conecta-mas-nao-controla/
e a solução é simplesmente executar este comando no computador a ser acessado:
metacity --replace
Ele troca o gerenciador/decorador de janelas Compiz nativo do ubuntu pelo Metacity que permite este tipo de conexão com atualização remota.
Espero ter ajudado alguem não perder horas da sua vida pra descobrir algo tão simples de resolver.
Abraço

7 de out. de 2009

Exmplo OSG+PhysX

//--------------------------

//Autor: Tiago buriol
//---------------------------


// C++ includes
#include < stdio.h >
#include < sys/time.h >

// OSG includes
#include < osgViewer/Viewer >
#include < osg/Geometry >
#include < osgGA/TrackballManipulator >
#include < osg/Vec3d >
#include < osg/PositionAttitudeTransform >
#include < osg/ShapeDrawable >

// PhysX include
#include "NxPhysics.h"

// Declaracao de variaveis globais para o PhysX
static NxPhysicsSDK*    gPhysicsSDK = NULL;
static NxScene*            gScene = NULL;

NxActor* box = NULL;

// Inicializa o Physx e define alguns parametros
static bool InitNx()
{
    // Inicializa o PhysX SDK
    NxPhysicsSDKDesc desc;

    gPhysicsSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION);
        if (!gPhysicsSDK)  return false;
        gPhysicsSDK->setParameter(NX_SKIN_WIDTH, 0.001);

    // Cria uma cena
    NxSceneDesc sceneDesc;
        //sceneDesc.simType = NX_SIMULATION_HW;
        sceneDesc.simType = NX_SIMULATION_SW;
        sceneDesc.gravity = NxVec3(0.0f, -9.81f, 0.0f);

    gScene = gPhysicsSDK->createScene(sceneDesc);

    // Set default material
    NxMaterial* defaultMaterial = gScene->getMaterialFromIndex(0);
        defaultMaterial->setRestitution(0.2f);
        defaultMaterial->setStaticFriction(0.01f);
        defaultMaterial->setDynamicFriction(0.01f);

    // Create ground plane
    NxPlaneShapeDesc planeDesc;
        //planeDesc.skinWidth = 0.01f;
    NxActorDesc actorDesc;
        actorDesc.shapes.pushBack(&planeDesc);
        actorDesc.globalPose.t = NxVec3(0.0, 0.0, 0.0);
    gScene->createActor(actorDesc);

    // Add a single-shape actor to the scene
    NxActorDesc boxActorDesc;
    NxBodyDesc boxBodyDesc;

    // The actor has one shape, a box, 1m on a side
    NxBoxShapeDesc boxDesc;
    boxDesc.dimensions.set(1.0, 1.0, 1.0);
    //boxDesc.skinWidth = 0.01f;
    boxActorDesc.shapes.pushBack(&boxDesc);
    boxActorDesc.body        = & boxBodyDesc;
    boxActorDesc.density     = 5.0f;
    boxActorDesc.globalPose.M.fromQuat(NxQuat(30.0, NxVec3(1, 0, 0)));
    boxActorDesc.globalPose.t     = NxVec3(0,5.0,0);

    box = gScene->createActor(boxActorDesc);

    //printf("altura %f\n",box->getGlobalPosition().y);
    return true;
}

int main(int argc, char** argv)
{
      double delta_t;
      struct timeval tv1, tv2;

      // Cria o visualizador
      osgViewer::Viewer viewer;
      osg::ref_ptr root = new osg::Group;

      osg::Sphere* unitSphere = new osg::Sphere(osg::Vec3(0,0,0), 1.0);
      osg::ShapeDrawable* unitSphereDrawable = new osg::ShapeDrawable(unitSphere);
          unitSphereDrawable->setColor(osg::Vec4(1, 0, 0, 1));
      osg::Geode* unitSphereGeode = new osg::Geode();
          unitSphereGeode->addDrawable(unitSphereDrawable);
      osg::PositionAttitudeTransform* unitSpherePAT = new osg::PositionAttitudeTransform();
          unitSpherePAT->setPosition(osg::Vec3(2.0,0.0,1.0));
          unitSpherePAT->addChild(unitSphereGeode);

      // Cria o cubo a ser renderizado
      osg::Box* unitBox = new osg::Box(osg::Vec3(0,0,-0.5), 1.0, 1.0, 1.0);
      osg::ShapeDrawable* unitBoxDrawable = new osg::ShapeDrawable(unitBox);
          unitBoxDrawable->setColor(osg::Vec4(1, 1, 0, 1));
      osg::Geode* unitBoxGeode = new osg::Geode();
          unitBoxGeode->addDrawable(unitBoxDrawable);
      osg::PositionAttitudeTransform* unitBoxPAT = new osg::PositionAttitudeTransform();
          unitBoxPAT->addChild(unitBoxGeode);

      // Desenha um plano
       osg::Vec3 coords[] = { osg::Vec3(-3.0, 3.0, -0.01),
                             osg::Vec3(3.0, 3.0, -0.01),
                             osg::Vec3(3.0, -3.0, -0.01),
                             osg::Vec3(-3.0, -3.0, -0.01)
                           };
      osg::Vec3Array* vertices = new osg::Vec3Array(4,coords);
      osg::Geometry* planeGeometry = new osg::Geometry();
          planeGeometry->setVertexArray(vertices);
          planeGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4));
      osg::Vec4Array* colors = new osg::Vec4Array;
          colors->push_back(osg::Vec4(0.8f,0.8f,1.0f,1.0f));
          planeGeometry->setColorArray(colors);
          planeGeometry->setColorBinding(osg::Geometry::BIND_OVERALL);
      osg::Vec3Array *shared_normals = new osg::Vec3Array;
          shared_normals->push_back(osg::Vec3(0.0f,-1.0f,0.0f));
          // use the shared normal array.
          planeGeometry->setNormalArray(shared_normals);
          planeGeometry->setNormalBinding(osg::Geometry::BIND_OVERALL);
      osg::Geode* planeGeode = new osg::Geode();
             planeGeode->addDrawable(planeGeometry);

      root->addChild(unitSpherePAT);
      root->addChild(unitBoxPAT);
      root->addChild(planeGeode);

      viewer.setSceneData(root.get());
      viewer.setUpViewInWindow(0, 0, 800, 600);
      viewer.setCameraManipulator(new osgGA::TrackballManipulator());
      viewer.realize();

      // Initialize physics scene and start the application main loop if scene was created
      if (InitNx())
      delta_t = 0.001;

      // Loop principal da simulacao
      while (!viewer.done()) {

        // Pega o tempo inicial
        gettimeofday(&tv1, NULL);

            // Realiza um passo da simulacao para um intervalo de tempo igual a delta_t
            gScene->simulate((NxReal)delta_t);
            gScene->flushStream();
            gScene->fetchResults(NX_RIGID_BODY_FINISHED, false);

            // Sincroniza as posicao e rotacao dos cubos simulado e renderizado
            unitBoxPAT->setAttitude(osg::Quat(box->getGlobalOrientationQuat().x,
                                              box->getGlobalOrientationQuat().z,
                                              box->getGlobalOrientationQuat().y,
                                              box->getGlobalOrientationQuat().w) );
            unitBoxPAT->setPosition(osg::Vec3d(box->getGlobalPosition().x,
                                               box->getGlobalPosition().z,
                                               box->getGlobalPosition().y) );
            // Atualiza o frame
            viewer.frame();

        // Pega o tempo final e calcula o tempo entre um frame e outro
        gettimeofday(&tv2, NULL);
        delta_t = (tv2.tv_usec - tv1.tv_usec)*0.000001;
      }

    return 0;
}

23 de set. de 2009

NVidia PhysX 2.8.1 com o Eclipse 3.5 no Linux Ubuntu 9.04 - Setup and Run

1) Baixando e Instalando o PhysX

Baixar em:  http://developer.nvidia.com/object/physx_downloads.html
Então, a partir do diretório de download, descompactar e instalar todos os pacotes.  Usuários de sistemas 64 bit precisam forçar a instalação via linha de comando:
64bit:
sudo dpkg -i --force-architecture *.deb
Bibliotecas compartilhadas são instaladas em do diretório específico da versão “/usr/lib/PhysX/v2.8.1/”, assim, é preciso likar com “/usr/lib”.
sudo ln -s /usr/lib/PhysX/v2.8.1/libNxCharacter.so.1 /usr/lib/libNxCharacter.so.1
sudo ln -s /usr/lib/PhysX/v2.8.1/libNxCooking.so.1 /usr/lib/libNxCooking.so.1
sudo ln -s /usr/lib/PhysX/v2.8.1/libPhysXCore.so.1 /usr/lib/libPhysXCore.so.1
Pronto!  Tente rodar algum exemplo do diretório “/usr/sbin/PhysX_Samples_2.8.1_FC4/Bin/linux/”.
Nem todos os exemplos funcionam corretamente. Um dos que funcionam é o
/usr/sbin/PhysX_Samples_2.8.1_FC4/Bin/linux/SampleBoxes

2) Compilando e rodando seu próprio projeto

Agora, para compilar um exemplo usando o Eclipse (neste caso o Galileo, v3.5) fazemos o seguinte:
Primeiramente, em máquinas 64bit certifique-se que você possui as extensões 32bit do gcc instaladas
64bit:
sudo apt-get install g++-multilib lib32stdc++6
Crie um novo projeto C++ vazio (Empty Project) e vá em Propriedades. Vá em Settings e na seção C/C++ Build. Então vamos configurar as flags do g++ para compilar o projeto corretamente: em GCC C++ Compiler, em Preprocessor adicione as seguintes palavras em Definied symbols:
LINUX, NX32, CORELIB, NX_DISABLE_FLUIDS

Em Directories adicione os seguintes caminhos (paths):
/usr/include/PhysX/v2.8.1/SDKs/Physics/include
/usr/include/PhysX/v2.8.1/LowLevel/API/include
/usr/include/PhysX/v2.8.1/SDKs/Cooking/include
/usr/include/PhysX/v2.8.1/SDKs/PhysXLoader/include
/usr/include/PhysX/v2.8.1/LowLevel/hlcommon/include
/usr/include/PhysX/v2.8.1/SDKs/Foundation/include
/usr/include/PhysX/v2.8.1/SDKs/NxCharacter/include
64bit: Em Miscellaneous  adicione em Other flags
64bit:
-m32
Esta flag irá dizer para o compilador para criar binários 32bit ao invés de 64bit.

Agora, em  GCC C++ Linker e em Libraries, adicione as bibliotecas (libs):
dl, pthread, PhysXLoader
GLU, GL, glut
 As bibliotecas GLU, GL, glut são da Glut e OpenGL, necessários para rodar esse exemplo.


64bit: Em Library search path:
/usr/lib32
64bit: Em Miscellaneous:
-m32
Bom, agora o ambiente está configurado, experimente rodar os códigos contido em: SampleBoxes.tar
Um projeto com as configurações já feitas: SampleBoxesCDT.tar


Você pode rodar esses exemplos com as linhas de comando abaixo:
g++ -DNX_DISABLE_FLUIDS -DCORELIB -DNX32 -DLINUX -I/usr/include/PhysX/v2.8.1/SDKs/Physics/include -I"" -I/usr/include/PhysX/v2.8.1/LowLevel/API/include -I/usr/include/PhysX/v2.8.1/SDKs/Cooking/include -I/usr/include/PhysX/v2.8.1/SDKs/PhysXLoader/include -I/usr/include/PhysX/v2.8.1/LowLevel/hlcommon/include -I/usr/include/PhysX/v2.8.1/SDKs/Foundation/include -I/usr/include/PhysX/v2.8.1/SDKs/NxCharacter/include -O3 -Wall -c -fmessage-length=0 -m32 -o"SampleBoxes.o" "./SampleBoxes.cpp"
g++ -L/usr/lib32 -m32 -o"physx_test"  ./SampleBoxes.o   -lPhysXLoader -lGLU -lGL -lglut -ldl -lpthread


Fonte: http://about.something.pl/art/howto-setup-physx-sdk-in-linux.html


28 de ago. de 2009

Instalar o PyCUDA no Ubuntu 9.04


Fonte: http://wiki.tiker.net/PyCuda/Installation/Linux/Ubuntu

1) Instalando o NumPy

$ sudo apt-get install python-numpy -y

2) Baixando, decompactando e instalando PyCUDA

Instalando as bibliotecas necessárias…
$ sudo apt-get install build-essential python-dev python-setuptools libboost-python1.37-dev -y
Baixando (http://pypi.python.org/pypi/pycuda/0.93rc3) e descompactando PyCUDA
$ tar xzvf pycuda-0.93rc3.tar.gz
Configurando, construindo e instalando
$ cd pycuda-0.93rc3
$./configure.py --cuda-root=/usr/local/cuda --cudadrv-lib-dir=/usr/lib/ --boost-inc-dir=/usr/include/ --boost-lib-dir=/usr/lib/ --boost-python-libname=boost_python-mt --boost-thread-libname=boost_thread-mt
$ make -j 4
$ sudo python setup.py install

21 de ago. de 2009

Instalando o Subversion com Apache 2 e SSL no Ubuntu 9.04

I) Atualizando e instalando os pacotes utilizados

Para atualizar os repositórios do apt e instalar quaisquer atualizações disponíveis:

$ sudo apt-get update
$ sudo apt-get upgrade


Os pacotes necessários são:
1) subversion – pacote contendo arquivos binários, ferramentas de administração svnadmin e distribuição svnserve;
2) libapache2-svn – módulos mod_dav_svn e mod_authz_svn que permitem o acesso aos repositórios através do protocolo http e https via WebDAV;
3) apache2 – servidor web. Veja mais em: http://pt.wikipedia.org/wiki/Servidor_Apache;
4) ssl-cert – pacote que permite a instalação de outros pacotes que precisam criar certificados SSL. Leia também sobre OpenSSL.

Para instalação desse pacotes:

$ sudo apt-get install subversion libapache2-svn apache2 ssl-cert


II) Abilitando o suporte ao SSL

Para habilitar o suporte a SSL no Apache 2 é necessário criar um certificado digital utilizando o comando make-ssl-cert e um arquivo modelo de configuração. Por padrão o Ubuntu 9.04 já traz este modelo em /usr/share/ssl-cert/ssleay.cnf com o seguinte conteúdo:
#
# SSLeay example configuration file.
#
RANDFILE = /dev/urandom
[ req ]
default_bits = 1024
default_keyfile = privkey.pem
distinguished_name = req_distinguished_name
prompt = no
policy = policy_anything
Não há problemas caso você não faça nenhuma modificação neste modelo.
Crie o diretório onde o certificado será criado:

 
$ sudo mkdir /etc/apache2/ssl

Agora, utilizando o make-ssl-cert e o modelo no arquivo ssleay.cnf vamos criar o certificado armazenando-o no arquivo apache.pem:

$ sudo make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

Surgirá uma tela, como a figura abaixo, onde será solicitado o nome do servidor. Você pode preencher com o IP da máquina se desejar.









Para definir a permissão ao arquivo.

$ sudo chmod 660 /etc/apache2/ssl/apache.pem


III) Configurando Apache 2 e habilitando o SSL
Verifique se o Apache 2 para que seja habilitada o suporte a porta 443. Para isso visualize o arquivo ports.conf no diretório do Apache 2:

$ gedit /etc/apache2/ports.conf

Seu arquivo deverá estar como mostro abaixo:
NameVirtualHost *:80
Listen 80

# SSL name based virtual hosts are not yet supported, therefore no
# NameVirtualHost statement here
Listen 443

Para habilitar o módulo de suporte ao SSL no Apache 2 é necessário utilizar o script a2enmod. O a2enmod criará um link simbólico no diretório /etc/apache2/mod-enabled. Para desabilitar um módulo utilize o script a2dismod. A linha de comando é:

$ sudo a2enmod ssl

O último passo da configuração do Apache 2, para o perfeito funcionamento do SSL, consiste em criar o arquivo svn em /etc/apache2/sites-available, este arquivo deve conter as configurações para a porta 443, ou seja, a porta ao qual definimos como responsável pelo SSL.

Para isso vamos copiar o arquivo default que está em /etc/apache2/sites-available para o arquivo svn.

$ sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/svn

Agora edite o arquivo utilizando, por exemplo, o gedit:

$ sudo gedit /etc/apache2/sites-available/svn

Altere a linha VirtualHost *:80 para VirtualHost *:443 e logo abaixo adicione as linhas:
SSLEngine on
ServerSignature On
SSLCertificateFile /etc/apache2/ssl/apache.pem

Vamos entender cada uma das três linhas acima:

1) SSLEngine on – Ativa se definida como “on” a utilização do protocolo SSL/TLS;
2) SeverSignature On – Ativa ou desativa a exbição da assinatura do servidor, ou seja, a linha que exibe as configurações do Apache. Por exemplo: Apache/2.2.9 (Ubuntu) DAV/2 SVN/1.5.1 PHP/5.2.6-2ubuntu4.1 with Suhosin-Patch mod_ssl/2.2.9 OpenSSL/0.9.8g Server at 192.168.0.30 Port 44. Na influencia no funcionamento do servidor;
3) SSLCertificateFile – Define o caminho para certificado.

Após a criação do arquivo svn, então é necessário habilitá-lo no Apache 2. Para isso utilize o script a2ensite. Este script habilita arquivos que contenham o bloco no Apache2. Para desabilitar um arquivo de configuração utilize o script a2dissite. A linha de comando é esta:

$ sudo a2ensite svn

Reinicialize o Apache 2 com o comando:

$ sudo /etc/init.d/apache2 force-reload

Caso ocorra algum erro, então consulte o arquivo de log do Apache 2. Este arquivo está localizado em /var/log/apache2/error.log.

Teste seu servidor, digitando no navegador o endereço IP precedido por https, por exemplo: https://200.45.202.123.





Você poderá ver uma página como a da figura abaixo. Fique tranquilo! Essa mensagem não reflete um problema em seu servidor. Na verdade a mensagem é exibida, pois você configurou um certificado próprio (auto-assinado) e não foi emitido por uma autoridade certificadora, como é o caso de sites que utilizam certificado homologado pela VeriSign. Apenas clique no link “você pode adicionar uma exceção” e depois no botão “Adicionar exceção…”. Aparecerá seu endereço IP. “Clique em verificar certificado” e logo em seguida, clique no botão “Confirmar exceção de segurança”. Pronto.













Configurando o Subversion

Vamos criar um repositório de teste para que possamos garantir a correta instalação (e na sequência vamos finalizar a instalação). Para criarmos um repositório é necessário criar um diretório e a partir dele, alterarmos o “proprietário” do diretório e definir as permissões. Após estes passos, então poderemos adicioná-lo ao Subversion com o comando svnadmin. Com o svnadmin é possível manipular usuários, projetos, repositórios e acessos.
$ sudo mkdir /var/svn/teste
$ sudo chown -R www-data:www-data /var/svn/teste
$ sudo chmod -R g+ws /var/svn/teste
$ sudo svnadmin create /var/svn/teste

Agora vamos habilitar a autenticação no Apache 2. O htpasswd é o responsável pela criação e atualização de arquivos que armazenam o nome de usuário (login) e a senha para autenticação via HTTP.
$ sudo htpasswd -c -m /etc/apache2/dav_svn.passwd admin


Importante, este comando serve apenas para quando se está criando o primeiro usuário, para outros usuários deve ser utilizado o mesmo comando sem a opção -c , pois ela faz a criação do arquivo, deve ser utilizado apenas a opção -m para que a senha armazenada seja com HASH MD5

Repare que no final da linha, após o caminho, existe o nome de usuário utilizado, ou seja, admin. Após executado comando acima, será solicitada uma senha. Evite esquecer a senha.
Após a definição da senha, então devemos editar o arquivo dav_svn.conf para habilitar o WebDAV e o SVN no Apache 2.

$ sudo gedit /etc/apache2/mods-available/dav_svn.conf
Agora altere o arquivo dav_svn.conf para a estrutura como mostrada abaixo:

DAV svn
SVNParentPath /var/svn
AuthType Basic
AuthName "Repositorio da Logica Digital"
AuthUserFile /etc/apache2/dav_svn.passwd
Require valid-user
SSLRequireSSL


Entendendo as linhas de configuração:

1) Como o repositório deve aparecer no navegador, no caso irá aparecer https://ip-do-servidor/svn;
2) DAV svn – habilita o repositório;

3) SVNParentPath – utilizado para múltiplos repositórios;
4) AuthType Basic – define o método de autenticação de usuário. É possível inclusive utilizar LDAP para habilitar Single sign-on. Prometo que farei um post sobre essa configuração;
5) AuthName – serve apenas como descritivo;
6) AuthUserFile – caminho do arquivo criado pelo comando htpasswd;
7) Require valid-user – confi
guração para que apenas usuários autenticados tenham acesso ao repositório. É possível tornar o servidor acessível à usuários anônimos, porém eu não acho uma boa prática;
8) SSLRequireSSL – obriga que a comunicação com o servidor de controle de versão seja feita sobre o protocolo SSL.

Após configurado o arquivo de integração entre o Subversion e o Apache 2, então é necessário reinicializar o Apache 2:

$ sudo /etc/init.d/apache2 force-reload

Acesse, através do seu navega
dor, o endereço https://ip-do-servidor/svn/teste. Assim você estará testando seu novo servidor de controle de versão com Subversion. Caso ele esteja funcionando corretamente, após a autenticação, será exibida uma página como abaixo:











Pronto. O servidor de controle de versão com Subversion, Apache 2 com SSL no Ubuntu Intrepid Ibex está funcionado. O próximo post virá com dicas de utilização.

Fontes:
1) http://andreferraro.wordpress.com/2009/04/05/linux-instalando-o-subversion-com-apache-2-e-ssl-no-ubuntu-intrepid-ibex-ubuntu-810/
2) https://help.ubuntu.com/9.04/serverguide/C/subversion.html

3) http://moisesfontana.blogspot.com/2007/09/mover-repositrio-do-svn-entre.html

4) https://help.ubuntu.com/9.04/serverguide/C/subversion.html
5) http://linuxieu.blogspot.com/2009/06/ubuntu-subversion.html

10 de ago. de 2009

Como fazer o checkout (SVN) de um projeto utilizando o Eclipse subversion

Versões de software utilizadas:
Ubuntu (Jaunty)
Eclipse Galileo
Subeclipse 1.4.x

Baixe o Eclipse
http://www.eclipse.org/downloads/download.php
Como esta versão não precisa ser instalada, descompacte em uma pasta e execute o eclipse.

Instale o Subeclipse
Vá em Windows -> Preferences -> Install/Update -> Avaliable Software
clique em Add, e digite:
Name: Subversion
Location: http://subclipse.tigris.org/update_1.4.x
Agora vá em Help -> Install New Software
Em Work with selecione Subversion como na imagem abaixo

Check os 3 ítens referentes ao subversion e clique em next -> next -> finish
Pronto, o subeclipse está instalado

Existem duas formas de iniciar um projeto de software utlizando o subeclipse:

1) Criar um novo projeto SVN diretamente apartir do repositório SVN
Clique File -> New -> Project -> SVN - > Checkout Projects from SVN
Selecione create a new repository location, digite o endereço do repositório
A seguir aparecerá o conteúdo do repositório, selecione a pasta do programa, aquela que contem os arquivos e diretórios do sistema (src, Debug, etc).
Selecione Check out as a project in the workspace, você alterar o nome do projeto que aparecerá na sua máquina, next -> finish.

2) Importar um projeto local já "checkado"
Caso você já tenha feito o ckeckout do seu projeto na sua máquina local. OBS: Isso pode ser feito através de programas svn client como o Tortoise (para windows) ou o rapidSVN (para linux).
Altere o workspace para o diretório no qual está contido o seu projeto: File -> Switch Workspace
Vá em File -> Import -> General -> Existing projects into workspace
Agora clique em Browse e selecione a pasta do projeto, o diretório aparecerá checkado como na figura abaixo, clique em Finish.



Se tudo ocorreu bem você terá o seu projeto já devidamente configurado e com os ícones personalizados assim como na imagem abaixo.



Sucesso a todos
Matheus Rosendo


Como configurar o OSG em Linux

Este tutorial foi escrito utilizando as seguintes versões de sistemas:
Eclipse Galileo
Ubuntu (Jaunty) 9.04
OpenSceneGraph 2.8.2
Cmake 2.6

Instale o compilador g++ e o CMake
Use o seguinte comando:
#apt-get install g++
#apt-get install cmake


instale a OpenGl Utility Toolkit
#apt-get install freeglut-dev

Instale as dependencias do OSG:
#apt-get install libtiff4-dev
#apt-get build-dep openscenegraph

Instale o OSG
Baixe o arquivo OpenSceneGraph-2.8.2.zip em http://www.openscenegraph.org/projects/osg/wiki/Downloads
Crie uma pasta chamada osg e descompacte o arquivo nesta pasta
Entre na pasta osg e rode o CMake  
#cd osg  
#ccmake OpenSceneGraph-2.8.2

Caso ocorra o erro: "ccmake: command not found", instale o cmake-curses-gui e tente de novo

# apt-get install cmake-curses-gui

 

Pressione "t" para ver a lista completa de variáveis
vá até o item OPENGL_glu_LIBRARY e coloque ao lado a seguinte path: /usr/lib/libGLU.so


Para que as bibliotecas sejam instaladas no diretório padrão vá até o item CMAKE_INSTALL_PREFIX e coloque ao lado: /usr

Pressione "c" para configurar e então pressione o "g" para gerar o Makefile.

Volte para o terminal com o diretorório corrente "osg"
Agora rode o comando make para compilar a biblioteca e instalá-la no sistema.
#make
#make install (caso ocorra algum erro por falta de privilegios de administrador digite #sudo make install)

Reinicie o computador

Instale o java
Obs: Caso ainda não tenha instalado (necessário para rodar o Eclipse)
#apt-get install sun-java6-jre

Instale e configure o Eclipse
Como no momento em que este artigo foi escrito a versão do eclipse estava desatualizada no repositório do debian, utilizaremos a última versão do eclipse cdt para desenvolvedores C++ disponível em http://www.eclipse.org/downloads/download.php. Esta versão não precisa ser instalada, apenas descompacte o conteúdo do arquivo (pasta eclipse), entre na pasta eclipse e rode o arquivo eclipse

Crie um novo projeto C++
Vá em File -> New -> C++ Project, digite "osgteste" em Project Name, Finish.


Adicione as bibliotecas OSG
Entre em GCC C++ Linker-> Libraries, para cada biblioteca clique no botão Add e entre com o nome. Nesta versão (2.8.2) são elas:
OpenThreads, osgAnimation, osgFX, osgManipulator, osgShadow, osgTerrain, osgUtil, osgVolume, osg, osgDB, osgGA, osgParticle, osgSim, osgText, osgViewer, osgWidget


Rode um exemplo
Substitua o conteúdo do arquivo osgteste.cpp criado pelo eclipse pelo conteúdo de um dos exemplos osg, como por exemplo, o osganimationmakepath. Este e mais vários outros exemplos estão disponíveis para download em
http://www.openscenegraph.org/projects/osg/wiki/Support/UserGuides/Examples. Com o projeto selecionado vá em Project -> Build Project para compilar e então pressione Ctrl + F11 para rodar o exemplo.
Pronto! Se tudo deu certo você verá uma bolinha se movimentando pela tela.

Sucesso a todos!
Matheus Rosendo

9 de ago. de 2009

Dicas para instalar drivers da nVidia no Linux


Para instalar os drivers de placas gráficas da nVidia no Linux (no meu caso Ubuntu 9.04), às vezes, é preciso "derrubar" a interface gráfica antes. Isso pode ser feito facilmente com os comandos descritos a seguir.

Inicialmetne é preciso baixar os drivers no site da nVidia (
www.nvidia.com). Para o driver da placa, acesse este link. Se desejar instalar também os drivers para CUDA, use este link. Observe que será necessario, para o CUDA, instalar: (1) o driver, (2) o toolkit e (3) o SDK. nessa ordem.

Feito os downloads, abra um terminal e digite

$sudo /etc/init.d/gdm stop

para derrubar a inteface gráfica.

Depois pressione Alt+F2 para voltar ao prompt. Faça o login novamente se for solicitado.
Então, a partir do diretório onde foram salvos os drivers baixados, use algo como

$sudo sh nome-do-arquivo-do-driver-baixado.run

para rodar o instalador.

Bom, aí o programa de instalação irá fazer algumas perguntas, possivelmente vai compilar o núcleo do driver, vai perguntar se você quer que ele atualize o arquivo de configuração xorg.config,etc.

De forma semelhante, você pode instalar os driver para CUDA, o Toolkit e o SDK.
Depois de finalizado, use


$sudo /etc/init.d/gdm restart

para reiniciar a interface gráfica.

Fui
!