Instalação e Configuração do ADJZ - COMPLETO

Instalação e Configuração do Ambiente de Desenvolvimento de jogos para Zeebo - COMPLETO

EDITADO:
Modificado o início da estrutura do código base para ter a variável AEEApplet ao invés da interface IApplet


1 - Introdução

Com o lançamento do video game Zeebo no Brasil, o mercado de desenvolvimento de jogos
está crescendo bastante por aqui e muitas empresas de jogos casuais estão começando a
aparecer um pouco mais.
Mas infelizmente na minha humilde opnião, essas empresas não deveriam nem sequer ter
começado a programar para a plataforma Zeebo sem antes estudá-la direito.
Ports de games feitos para celulares? iPhone? Se o Zeebo tivesse o hardware muito limitado
como o de um celular tudo bem, mas com 128 MB de RAM, chip de vídeo dedicado com
aceleração 3D, CPU ARM11 de meio gigahertz, portar games de celular para o Zeebo
é uma piada.

Este artigo visa explicar como deixar seu pc preparado para iniciar seus estudos no
desenvolvimento de aplicativos para o vídeo game Zeebo, como criar seu primeiro
programa e como rodá-lo no simulador e seguir o fluxo da execução do programa
passo a passo no Visual C++ 2008.

Infelizmente, por enquanto não existe um game maker disponível para criar os jogos
sem ter que programar. Por enquanto, é necessário que se tenha conhecimento básico em
linguagem C e OpenGL.
Caso não tenha, uma passada rápida por qualquer site de busca retornará várias fontes boas
para um pontapé inicial no aprendizado. Para aprender o básico sobre OpenGL eu sugiro
o site http://nehe.gamedev.net (em inglês) ou meu site (bem desatualizado) em português
que também tenta ensinar algumas coisas sobre OpenGL para Windows, mas já serve: http://matheusmetal.x-br.com/stigma29a/

Para qualquer dúvida, sugestão ou crítica, fiquem a vontade para me contatar pelo
email mario.olofo arroba gmail.com.


2 - Ferramentas necessárias

Para deixar seu pc preparado para rodar seus programas no Simulador do Zeebo são
necessários alguns programas que podem ser baixados gratuitamente nos seus
respectivos sites oficiais. São eles:

Visual C++ 2008 Express
http://www.microsoft.com/express/download/

Editor de códigos em linguagem C/C++ e compilador.
Esté é a ferramenta que deve ser instalada antes de mais nada. Sem o compilador você
não será apto a criar novos programas, nem sequer compilar os programas de demonstração
de como usar o OpenGL ES para exibir o conteúdo do aplicativo em 3D.
Caso queira, já está disponível a versão 2010, mas ainda está cheia de bugs e não
é tão rápida como a versao 2008.


BREW SDK 4.0.2
https://brewx.qualcomm.com/brew/sdk/download.jsp

Kit com código fonte base do BREW, cabeçalhos, exemplos e simulador.
Já foi lançada a versão 4.0.4, mas esta versão não é detectada pelo instalador
do SDK do Zeebo. No site da Zeebo Inc é informado que o SDK também
funciona com a versão 4.0.3 do BREW SDK, mas não cheguei a testar.
Escolha fazer o download do SDK versão 4.0.2 e na próxima página clique em
install na opção BREW SDK 4.0.2 SP09 (4.0.2.22) para baixar o instalador BREWSDK402SP09.exe


BREW SDK Tools 1.1.1
https://brewx.qualcomm.com/brew/sdk/download.jsp?page=dx/devmisc

Pacote com ferramentas para editar recursos, MIF, conversor de imagens entre outros.
Versão baixada foi a 1.1.1 SP06, lançada dia 30 de outubro de 2009.
Clique em install, aceite a licença e clique no link para baixar o instalador BREWSDKTOOLS111SP06.exe

Zeebo SDK 1.2.4
http://www.zeeboinc.com/

No próprio site da Zeebo Inc é possível fazer o download do SDK mas é preciso se
cadastrar para isso. Passe o mouse no item Resources para exibir um menu e selecione
a primeira opção, sdk download.
Feito isso, será informado que você deve se cadastrar no site. Cadastre-se e baixe o
Zeebo SDK 1.2.4, que vem com os seguintes pacotes:

Adreno Profiler - software de checagem de desempenho de aplicativos para
o Zeebo, auxiliando na identificação de possíveis gargalos na renderização;
OpenGL ES Extension for BREW 1.5.3 - Pacote que possibilita utilizar o OpenGL ES
dentro de aplicativos em BREW para renderização 3D no Zeebo;
Samples - exemplos de como implementar algumas técnicas básicas em 3D usando
BREW e a extensão OpenGL ES;
Zeebo Driver - hmmm USB device drivers, meu Zeebo ainda não chegou para tentar
fazer uns testes com esse driver =( ;
Zeebo SDK Installer - Instalador do simulador da plataforma Zeebo;

Não é necessário fazer o download dos outros arquivos descritos no site, logo que são os
mesmos já descritos acima.


De posse dos arquivos acima, começaremos a instalação do ambiente de desenvolvimento
de jogos. Basicamente, a sequência de instalação é a mesma sequência de download
descrita acima, com excessão do Zeebo SDK, que tem vários instaladores dentro do seu
arquivo zip.
Detalhando, a ordem completa de instalação é a seguinte:

1 - Visual C++ 2008 Express;
2 - BREW SDK 4.0.2;
3 - BREW Tools 1.1.1;

À partir daqui, os pacotes indicados devem ser extraidos do pacote Zeebo SDK 1.2.4 para
serem instalados:

4 - Adreno Profiler;
5 - OpenGL ES Extension for BREW 1.5.3;

Quando for instalar a extensão OpenGL ES, ele pedirá que seja informado o diretório de
instalação. Instale no diretório raiz da instalação do BREW SDK (ex. C:\Arquivos de
Programas\BREW SDK 4.0.2 SP06\ )

6 - Zeebo SDK Installer;

O instalador do simulador do Zeebo automaticamente detectará onde fica o diretório do SDK
da BREW e vai adicionar o simulador do Zeebo na lista de simuladores disponíveis para
desenvolvimento.

Ufa, com isso concluímos a instalação de todos os programas necessários para começar
a configurar o ambiente de desenvolvimento.
CONFIGURAR? AINDA?
Sim pequeno gafanhoto, temos fazer uma pausa agora e entender o que foi instalado,
por que foi instalado e para que serve cada uma dessas ferramentas.


3 - Um pouco sobre BREW e suas ferramentas

BREW (Binary Runtime Environment for Wireless) é uma plataforma aberta desenvolvida pela empresa Qualcomm
para criação e distribuição de aplicações para telefones celulares.
A distribuição das aplicações é realizada através de um aplicativo da Qualcomm chamado BREW Shop.
Este aplicativo vem pré-instalado em todos os aparelhos que suportam esta tecnologia, e permite a compra e download
das aplicações aprovadas pela operadora para uso de seus clientes.
Para criação de aplicações é utilizada a linguagem de programação C/C++ e um framework disponibilizado pela Qualcomm,
que possibilita o acesso às principais funções de um aparelho celular.
Para rodar suas aplicações nos celulares é necessário o desenvolvedor se registrar como tal no site da Qualcomm,
esse registro custa 400 dólares e dá direito a 100 builds de programa.

fonte wikipedia: http://pt.wikipedia.org/wiki/Brew

Todo aplicativo criado para BREW deve passar por um teste de compatibilidade da Qualcomm para poder ser aprovado
e disponibilizado para venda. Para isso é necessário pagar 400 dólares, talvez algo aceitável se a Tec Toy aprovar
a distribuição de seu jogo na rede Zeebo.

É importante que fique claro que o SDK para ligar o Zeebo no pc e rodar os jogos desenvolvidos direto nele está disponível
somente para os programadores que pagarem os 400 dólares para a Qualcomm, portanto neste artigo este SDK não
será usado e nos limitaremos a usar o simulador por enquanto.

Ao instalar os SDKs da Qualcomm você instalou alguns programas que auxiliam no desenvolvimento dos aplicativos
usando BREW. Basicamente, um aplicativo que usa BREW é composto de um arquivo .mif e um arquivo binário
com o programa.
O arquivo .mif descreve o aplicativo, informando qual ícone deve ser usado para exibí-lo, qual o identificador da interface,
quais privilégios ele tem (se podemos acessar arquivos, rede, audio), etc.
Todo programa deve ter o mesmo nome de seu respectivo arquivo .mif e residir em um subdiretório com o mesmo nome, exemplo:

Código:


meu_game.mif
meu_game/meu_game.dll (no Windows nossos programas serão compilados como DLLs)
meu_game/meu_game.bid

Nesse caso, a nossa DLL irá declarar uma função que fará com que ela fique disponível para ser carregada toda vez que
rodarmos nosso programa. Todos os aplicativos e a biblioteca base do BREW funciona dessa forma.

Note que também temos um arquivo .bid, que nada mais é do que um arquivo texto com o código de identificação
do nosso aplicativo, que é único e é fornecido pela Qualcomm.
Como não pagamos ainda os 400 dólares, não temos como pedir para a Qualcomm nos fornecer este número, portanto
para fins de desenvolvimento nós criamos este arquivo na mão com um identificador genérico. O arquivo .bid deve conter o seguinte:

Código:


/*
===================================
          Arquivo BID

 Arquivo genérico com código de identificação de nosso jogo.
 Sempre que criar um novo programa incremente o
 número da identificação para evitar que mais
 de um jogo tenha o mesmo identificador, o que pode causar
 vários problemas se eles estiverem na mesma lista no simulador.

 ATENÇÃO:
 O Identificador deve iniciar com AEECLSID_ seguido do
 nome do programa.
===================================
*/
#ifndef AEECLSID_MeuGame

#define AEECLSID_MeuGame    0x00000001

#endif /* AEECLSID_***  */

Lembre-se de sempre incrementar este número para cada novo projeto, pois este número é usado para
criar uma lista de classes disponíveis no sistema, e sempre que algum programa precise carregar uma
instância de determinada classe, esta lista é consultada e a primeira ocorrência do código de identificação
compatível que for encontrado é usada, o que pode fazer seu programa nunca rodar e você não saberá o porquê.

Para criar o arquivo .mif, usaremos o programa BREW MIF Editor, que vem no pacote de ferramentas da BREW (BREW SDK Tools 1.1.1)


Clique no ícone em destaque para criar um novo arquivo .mif
Uma janela se abrirá pedindo que seja definido o class id do aplicativo. Como explicado previamente, vamos usar o trecho de código
acima para criar esse arquivo. Lembre-se que o nome do arquivo .mif deve ser igual ao nome do nosso aplicativo.

NOTA: Todo aplicativo que criarmos deve ter um nome iniciado por uma letra e não deve conter espaços.



Clicando na opção destacada (1) fará com que o botão "Browse for BID file..." fique habilitado, permitindo selecionar nosso
arquivo .bid



Agora podemos selecionar o ícone que será exibido no emulador para mostrar nosso aplicativo. Fazemos isso selecionando
a opção destacada na imagem acima, além de poder ajustar o tamanho do ícone na tabela abaixo do ícone.



Feito isso podemos clicar no botão compile, para gerar nosso arquivo .mif com as informações do nosso projeto.
Veja que existem outras abas que são bem interessantes, mas basicamente é isso que devemos informar para criar
o arquivo .mif

Um outro programa que usaremos é o editor de recursos BREW Resource Editor, que nos permite criar um arquivo binário
com todos os dados que usaremos nos nossos jogos. Um dos usos mais interessantes do editor é permitir a criação de textos
usados no jogo de uma mais organizada, facilitando a tradução do jogo para outros idiomas.

Um programa para criar imagens animadas também vem no pacote de ferramentas, e é o BREW Compressed Image Authoring Tool.
Com ele é possível agrupar um conjunto de imagens em sequência, definir a fatia de tempo que a imagem ficará exibida na tela e deixar
o programa agrupar tudo e compactar para usarmos nos jogos. Este programa eu ainda não usei, então não tenho muita coisa para
falar sobre ele.



4 - Configurando o ambiente de desenvolvimento

Vamos dar uma revisada geral no que aprendemos até agora e criar uma hierarquia de diretórios que facilite a criação e depuração
dos nossos programas.
Sabemos que todo aplicativo BREW deve ter um arquivo .mif para identificá-lo e que o aplicativo deve ficar numa subpasta com o mesmo
nome. Com base nisso podemos criar um diretório raiz para armazenar todos os arquivos .mif e criar uma pasta por projeto durante o
desenvolvimento:


Exemplo de hierarquia de diretórios para guardarmos nossos jogos

Quando criarmos nossos aplicativos no Visual C++ precisaremos de uma pasta para guardar nosso código fonte e os
arquivos de projeto. Para manter nossa organização, vamos criar uma pasta por jogo e armazenar o código fonte em uma
subpasta chamada src (abreviação de source).


Exemplo de hierarquia de diretórios para guardar nossos jogos e projetos.
Note que o diretório de armazenamento dos jogos compilados e os arquivos .mif foram um nível para dentro.

Basicamente teremos dois diretórios principais: jogos (1) e projetos (3).
O diretório jogos (1) irá armazenar os arquivos .mif, e os subdiretórios armazenarão os binários de cada jogo (2).
O diretório projetos (3) irá armazenar o arquivo Solution (que é quem agrupa todos os projetos) criado pelo Visual C++ e o
diretório de cada jogo armazenará o arquivo de projeto (que farão parte do Solution), também criado pelo Visual C++.
Dentro de cada diretório de projeto existe um diretório nomeado Src (4). Nesta pasta ficará o código fonte do jogo, e
cada jogo terá seu projeto e diretório Src.

Quando for gerada a DLL do nosso game, o projeto do VC++ já estará configurado para copiar a DLL atualizada para
a pasta jogos, facilitando os testes e mantendo a pasta dos nossos jogos sempre atualizada =).


5 - Criando o Solution no Visual C++ 2008 Express

O Visual C++ suporta abrir vários projetos ao mesmo tempo, mas apenas depurar um de cada vez. Isso é feito
através do que a Microsoft chama de Solution.

Crie um diretório base para guardar os games e os projetos e depois abra o Visual C++ 2008 Express.



Navegue no menu File -> New -> Project para criar um Solution



Selecione a opção CLR Empty Project

No exemplo acima eu criei um diretório base em C:\ com o nome de Jogos para Zeebo.
Nomeie o Solution como "projetos". O VC++ vai criar um diretório automaticamente para guardar o solution,
gerando assim o nosso subdiretório projetos.

Você verá o Solution chamado projetos e um projeto genérico com o mesmo nome. Remova
o projeto genérico, deixando apenas o Solution, clicando com o botão direito no projeto e escolhendo a opção Remove:



Dentro da pasta projetos, terá uma outra pasta chamada projetos. Remova-a pois ela não
será necessária.


6 - Como adicionar e configurar os projetos dentro do Solution criado

Estamos quase lá, só nos resta entender o que é necessário para criar um projeto e como
configurá-lo para rodar o simulador Zeebo!

Estas informações serão iguais para todos os projetos de jogos que você for adicionar ao Solution.

Clique com o botão direito no Solution e depois em Add -> New Project.



Normalmente o nome do projeto será o nome do game, mas isso pode ser mudado.

Agora com o projeto criado, vamos configurá-lo:

Clique com o botão direito em Source Files e selecione Add -> Existing Item.



Agora vá até o diretório do SDK do BREW e dentro da pasta sdk\src\ e selecione os arquivos
AEEAppGen.c, AEEModGen.c, EGL_1x.c, GLES_1x.c e GLES_ext.c.
Após confirmar, estes aquivos estarão incluídos no seu projeto.

Clique com o botão direito novamente no projeto mas agora selecione a opção Add -> New Item:



Atenção!
Apesar de selecionar criar um arquivo C++ (cpp), a extensão do arquivo deve ser .c para evitar eventuais
problemas na geração da DLL do game.

Após incluir este arquivo ao projeto, dê dois cliques nele para ele abrir na janela de edição de código.

Copie e cole o conteúdo abaixo para criar o esqueleto do nosso aplicativo:

Código:



#include <AEEShell.h>
#include <AEEModGen.h>
#include <AEEAppGen.h>

/*
   MUDE AQUI
   o nome game.bid para o nome do bid criado para este game
   o arquivo .bid deve ficar na pasta \Src também
*/
#include "game.bid"


/*
   Estrutura que define nosso jogo
   Todo o conteúdo do game deve vir aqui.

   ATENÇÃO: A variável AEEApplet deve ser sempre a primeira
   da estrutura!
*/
typedef struct
{
   AEEApplet a; /* <-- Deve ser sempre a primeira da estrutura do nosso game! */

   /* Add suas variáveis aqui */

}
Game;


/*
   Rotina de tratamento dos eventos do game.
   Todo game para BREW deve conter essa rotina para tratar
   os eventos gerados pelo sistema operacional, como
   tecla pressionada, tecla solta, etc.

   Se o evento for tratado, retorne TRUE para avisar
   o sistema operacional que você tratou o evento.
*/
boolean GAME_TrataEvento( Game* app, AEEEvent dEvento, uint16 wParam, uint32 dParam )
{
   switch( dEvento )
   {
      case EVT_APP_START:
      case EVT_APP_STOP:
      {
         return TRUE;
      }
      default:
      {
      }
   }
   return FALSE;
}


/*
   Rotina de criação do game.
   Todo game para BREW deve conter essa inicialização
*/
int AEEClsCreateInstance( AEECLSID dId, IShell* pIShell, IModule* pMod, void** ppObj )
{
   *ppObj = NULL;

   if( AEEApplet_New( sizeof( Game ), dId, pIShell, pMod, ( IApplet** )ppObj, ( AEEHANDLER )GAME_TrataEvento, NULL ) )
   {
      return AEE_SUCCESS;
   }
   return EFAILED;
}

Perceba que no começo do código eu inclui o game.bid, para saber qual é o ID do game que estamos criando.
O arquivo .mif deve ser criado como explicado anteriormente, apontando para este arquivo .bid

Agora vamos configurar o restante do projeto.
Clique com o botão direito no projeto e escolha Properties.



Na propriedade General, modifique o Output Directory para apontar para a pasta de jogos, igual
mostrado na figura acima. Aqui é a oportunidade de mudar o nome da pasta do jogo.
Você pode trocar o \$(ProjectName)\ para o nome da pasta do seu jogo. Se deixar como está,
o $(ProjectName) será substituído pelo nome do projeto, no caso irá virar "\Teste\"

Mude o tipo de aplicativo para DLL na opção Configuration Type.



Agora selecione a propriedade Debugging e na opção Command entre com o caminho para o Simulador
da BREW, que está na pasta do SDK da BREW \bin\Simulador.exe

Não esqueça de colocar aspas duplas no início e no fim do caminho para que os
espaços no nome dos diretórios sejam identificados como tal.
Como nós estamos criando uma DLL, não podemos executá-la normalmente como fazemos com um .EXE,
então precisamos iniciar o Simulador da BREW para ele carregar nosso jogo e simular seu funcionamento
como se estivesse no Zeebo (mais sobre isso depois).
Lembre-se de configurar o Working Directory para o diretório corrente do nosso jogo ( "." ).



Agora na propriedade C/C++, clique no botão "..." do item Additional Include Directories e entre com o caminho para as pastas \inc e \sdk\inc, localizados também no diretório do SDK da BREW.



Em Preprocessor, digite AEE_SIMULATOR no Preprocessor Definitions para avisar que
iremos compilar para rodar no Simulador.



Na propriedade Linker nós modificamos o diretório de onde será copiado a DLL do game,
apontando para a pasta de jogos.
Note no uso do \$(ProjectName)\$(ProjectName).dll
Lembre-se que a DLL do game deve ficar num subdiretório da pasta de jogos, pois no nível abaixo ficará o arquivo .mif


Feito isso pressione o botão OK e aperte F7 para gerar a DLL do nosso primeiro aplicativo em BREW.



Se ocorrer algum erro como o demonstrado acima, certifique-se de que você criou o arquivo bid
e colocou ele no diretório \Src.


Agora pressione F5 para executar o Simulador do Zeebo.



Por ser provavelmente a primeira vez que você irá executar o Simulador, ele exibirá um celular ao
invés de exibir o sistema Zeebo.
Para contornar isso, selecione a opção File -> Load Device no simulador e procure pelo local
de instalação do Zeebo Inc, provavelmente estará em arquivos de programas.



Vá em Zeebo SDK\BREW404 Devicepacks Folder\devicepacks\Zeebo_Device\ e você encontrará
um arquivo chamado GEC_Device.dpk.
Selecione este arquivo e o Simulador do Zeebo será iniciado.

Agora selecione a opção File do menu do Simulador e clique em Change Applet Dir.
Escolha o nosso diretório base dos jogos, que é a pasta onde está os arquivos .mif (no meu pc é
Jogos para Zeebo\jogos\ )

Se tudo correr bem até aqui, você verá o seu primeiro aplicativo logo no topo da tela do Simulador.
Para executá-lo, clique na tecla do Simulador com um círculo vermelho, mas nada aparecerá por enquanto, pois não
escrevemos nenhum código para exibir o nosso jogo na tela, tema que será abordado no próximo
tutorial específico para os programadores de plantão =).

Mario