LibGDX Tutoriais - Configurando o projeto Android / Desenhando a primeira Textura
Autor: João Neto | Publicado: 2012-09-19T12:48:00-03:00

Salve Pessoas!

Como eu disse no tutorial anterior, vou tentar ensinar o máximo sobre o LibGDX, um dos melhores frameworks de desenvolvimento de jogos para Android.

Continuando o tutorial anterior, vamos criar e configurar o projeto de Android para testarmos no emulador ou telefone, e desenharemos nossa primeira textura. O LibGDX facilita muito as coisas, e você vai ver que com poucas linhas de código vamos colocar uma imagem para ser exibida.

Primeiro, vamos criar e configurar o projeto de Android. Seguindo o que disse tutorial anterior, você já tem que ter pronto aí a IDE Eclipse já baixada e instalada, o ADT, que é o plugin do Eclipse para se programar para Android e a SDK do Android baixada e configurada.
Crie um novo projeto de Android no Eclipse, indo em File -&gt; New -&gt; Android Application Project:




Configure-o, com o nome da aplicação de ActivityPrincipal, o Project Name de LibgdxAndroid (Seguindo o padrão de nomenclatura que falei no tutorial anterior), o Package Name como&nbsp;com.deploy.libgdx, e o Build SDK, coloque a versão que quiser. Eu costumo usar a 2.2 por causa do meu Galaxy 5.





Projeto criado, agora as configurações. Volte ao diretório do LibGDX que você baixou no primeiro tutorial, e copie os seguintes para o diretório libs:


Diretório&nbsp;armeabi e seu conteúdo;
Diretório&nbsp;armeabi-v7a e seu conteúdo;
gdx-backend-android.jar


Vá no projeto Android,  (Botão Direito -&gt; Properties), selecione Java Build Path, e vá na aba Libraries. Adicione o Jar que copiamos anteriormente  e o jar gdx.jar, como foi feito no tutorial anterior:





Vá na aba Projects, e adicione o projeto LibgdxCore, como foi feito no tutorial anterior:





Assim como fizemos nos outros projetos, crie o package inicial com o nome de&nbsp;com.deploy.libgdx&nbsp;:





A próxima configuração é bem interessante. Como o foco do nosso desenvolvimento é o Android, todo e qualquer recurso, gráfico ou não, deve ser colocado no diretório assets por questões de padronização. Para que possamos utilizar estes mesmos recursos no projeto Desktop, basta fazermos referência ao diretório assets do projeto Android, e pronto! São esses detalhes que facilitam e muito o desenvolvimento usando a LibGDX. Vá nas propriedades do projeto LibgdxDesktop (Botão Direito -&gt; Properties), selecione Java Build Path, e vá na aba Source:





Clique no botão Link Source, e configure da seguinte forma:

Linked folder Location:&nbsp;WORKSPACE_LOC\LibgdxAndroid\assets\

Folder Name: assets





WORKSPACE_LOC é uma referência ao local atual do Workspace do Eclipse, e o restante do caminho aponta para o projeto de Android que criamos. Caso tenha problemas com isso (eu sempre tenho pois meus projetos não ficam no workspace) recupere o caminho real pelo Windows Explorer e coloque lá. Feito isso, nosso projeto Desktop agora possui mais um diretório disponível, o assets. Todo e qualquer recurso que for colocado agora lá no diretório assets do Android poderá ser utilizado aqui.

Por enquanto as configurações são essas, eu acho. Está na hora de codificar!

Primeiro, vamos colocar um recurso gráfico para podermos desenhá-lo. Eu vou usar esse, use o que quiser:





Coloque o recurso no diretório assets do projeto Android, como falamos anteriormente. Veja que ele ficará disponível no diretório linkado do projeto Desktop:





Agora vamos ao código. Abra a classe GameRoot, que se encontra no projeto Core. Como eu disse anteriormente, implementando ApplicationListener ela é uma classe básica, muito boa para quem está começando a entender o LibGDX. Uma coisa boa do LibGDX é a facilidade de se fazer a maioria das coisas. Para se desenhar uma textura, vulgo imagem, só precisamos de algumas linhas de código. O grande responsável por isso é um objeto de nome SpriteBatch, que faz o trabalho pesado de aplicar as texturas diretamente no GPU usando o openGL. O objeto de Textura também deve ser criado, para ser usado pelo SpriteBatch.

Na classe, declare nossos objetos Spritebatch e Texture:



private SpriteBatch currentBatch;

private Texture currentTexture;



Algumas informações aqui são necessárias. Toda e qualquer criação de instâncias deve ser feita no método create, todos os objetos devem ser descartados no método dispose e qualquer renderização deve ser feita no método render. Então vamos lá. Instancie o SpriteBatch e a Texture, como abaixo, dentro do método create:




currentBatch = new SpriteBatch();

currentTexture = new Texture("pikachu.png");




Veja que passei diretamente o nome da imagem para a criação da textura. O LibGDX sabe que essa textura vai estar no diretório assets, então basta fazer assim. &nbsp;Como eu disse, todo objeto criado deve ser descartado quando não for mais utilizado. Dentro do método dispose, coloque o descarte dos objetos como abaixo:




currentBatch.dispose();

currentTexture.dispose();




Até esse momento, sua classe deve estar mais ou menos assim:





Estamos quase lá. Agora vamos renderizar esse pikachu logo! no método render, temos alguns passos importantes: &nbsp;o SpriteBatch deve ser iniciado com a chamada do método begin(), desenhar o que for para desenhar com a chamada do método draw() e por fim fechar a renderização com o método end(). Modifique o método render como abaixo:




currentBatch.begin();

currentBatch.draw(currentTexture, 0, 0);

currentBatch.end();




Os parametros 0,0 são respectivamente a posição X e Y onde a textura será desenhada dentro da janela. Um detalhe importante sobre o LibGDX é que ele usa a direção do Y de baixo para cima, como no plano cartesiano padrão, diferente do que já vimos em outras formas de se desenhar:





Então, o Y sendo zero será sempre no lado de baixo da janela e quanto maior, mais para cima. Mais uma vez olhando a classe ela deve estar assim:





Agora, só executar a classe&nbsp;LibgdxGame no projeto desktop, e nosso Pikachu estará lá:





Você pode brincar com a posição, e desenhar mais vezes a mesma textura! Lembre-se que a ordem de desenho no código influencia diretamente na saída, ou seja, o ultimo a ser desenhado sempre ficará por cima do anterior e por aí vai. Outra coisa que é possível fazer com o SpriteBatch é aplicar coloração na textura, mudando como a mesma será renderizada. O código abaixo é uma experiência desenhando mais uma vez a textura em outra posição e mudando sua cor:




currentBatch.begin();

currentBatch.setColor(1, 1, 1, 1);

currentBatch.draw(currentTexture, 0, 0);

currentBatch.setColor(1, 0, 1, 1);

currentBatch.draw(currentTexture, 200, 20);

currentBatch.end();




E o resultado:





Parece complicado, mas tudo isso que foi feito até agora, dependendo do framework ou biblioteca utilizados, gastaria toneladas de linhas de código e horas de programação. Para encerrar, vamos construir a classe base do Android? Vamos lá.

Vá no projeto Android, no pacote que foi criado e crie uma classe de nome LibgdxActivity que&nbsp;estenda a classe&nbsp;AndroidApplication:





Sobreponha o método&nbsp;onCreate. Assim como fizemos com o projeto desktop, precisamos criar um objeto de configuração, neste caso o AndroidApplicationConfiguration. Altere o método como abaixo:




AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();

config.useAccelerometer = false;

config.useCompass = false;

config.useWakelock = false;

config.useGL20 = true;

config.numSamples = 2;




E por fim, instanciar a classe GameRoot, usando desta vez o método&nbsp;initialize&nbsp;da classe:



this.initialize(new GameRoot(), config);



Até este ponto, sua classe deve estar assim:





Todos os parametros de configurações eu poderei explicar aos poucos, não se preocupe com isso agora. &nbsp;Agora vamos para as configurações finais, que são muito importantes para o funcionamento da aplicação no Android. Se você criou uma Activity durante a criação do projeto, o que vou mostrar agora deve sobrescrever tudo que estiver no arquivo.&nbsp;

No projeto Android, abra o arquivo&nbsp;AndroidManifest.xml. Deixe seu conteúdo como abaixo:





agora, adicione as tags abaixo logo abaixo da tag de fechamento de&nbsp;uses-sdk:&nbsp;



&lt;supports-screens android:largeScreens="true" android:anyDensity="false" /&gt;



Agora, dentro da tag application, coloque este bloco:




&lt;activity android:name="com.deploy.libgdx.LibgdxActivity"

 android:screenOrientation="landscape"

 android:label="@string/app_name"&gt;

 &lt;intent-filter&gt;

  &lt;action android:name="android.intent.action.MAIN" /&gt;

  &lt;category android:name="android.intent.category.LAUNCHER" /&gt;

 &lt;/intent-filter&gt;

&lt;/activity&gt;




Até este ponto, seu arquivo deve estar assim:





E está pronto, pode publicar e ver a mágica.

UFA! escrevi muito, e não fizemos tanto. Começar costuma dar mais trabalho, mas com o tempo fica simples e automático. Muita coisa ficou obscura, como as configurações, mas espero poder esclarecer a cada novo tutorial.&nbsp;

No próximo eu pretendo falar sobre escrever na tela, e vamos conhecer o Hiero, o gerador de fontes do LibGDX.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !