Baixe Apostila Framework XNA e outras Manuais, Projetos, Pesquisas em PDF para Desenvolvimento de Jogos Digitais, somente na Docsity!
Bruno Rabello^1
Edson Mattos^1
Bruno Evangelista^2
Esteban Clua^1
Resumo : Este tutorial cobre as características básicas sobre a plataforma de
desenvolvimento de games criada pela Microsoft chamado XNA (XNA’s Not Acronymed). Ela permite criar jogos para PCs com Windows e para o console Xbox 360. O XNA vem substituir o Managed DirectX, uma versão do DirectX para a plataforma dotNET. Todas as aplicações XNA são compiladas para código gerenciado (managed code, ou Microsoft Intermediate Language). Esse código é executado no Common Language Runtime (CLR), que é a máquina virtual da plataforma dotNET.
Abstract : This tutorial explore the basic characteristics for the game
development plataform developed by Microsoft, called XNA (XNA´s Not Acronymed). XNA allows the creation of PC games, for Windows plataform and XBOX 360, for a console plataform. XNA aims to substitute the DirectX Manager, a version of DirectX for a .NET plataform. All the applications made in XNA are compiled in a managed code. This code is executed at the Common Language Runtime (CLR), which is the virtual machine of the .NET plataform.
1 Instituto de Computação, Universidade Federal Fluminense 2 Instituto de Informática, Universidade Federal de Minas Gerais
1 Introdução
Em 2006 a Microsoft lançou uma plataforma inédita para desenvolvimento de games e aplicações de computação gráfica tempo real, denominado XNA - XNA’s Not Acronymed. Esta é a primeira API unificada para desenvolvimento em PCs e Consoles de Games.
Muitas empresas estão adotando esta plataforma para propósitos comerciais e muitos game engines tradicionais estão sendo portados para este ambiente. O sucesso da ferramenta pode ser comprovado pelo grande volume de fóruns, sites e comunidades que surgem espontaneamente pelo mundo. Além da sua grande qualidade técnica e a simplicidade da arquitetura proposta, o fato de possuir versões de distribuição gratuita garante que a enorme massa de desenvolvedores independentes voltem sua atenção para o XNA.
A confirmada capacidade de produzir aplicações sofisticadas em pouco tempo e com poucos recursos, torna o XNA também uma excelente plataforma para desenvolvimento de pesquisas, não apenas em entretenimento digital mas em outras áreas de interesse acadêmico, tais como inteligência Artificial, computação gráfica, redes e interface homem-máquina.
Em termos acadêmicos, acrescenta-se também ao seu potencial o fato de poder ser utilizado para ensino de diversas disciplinas de computação, o que pode ser comprovado ao observar diversas universidades prestigiosas ao redor de todo o mundo adotando esta estratégia.
O XNA vem substituir o Managed DirectX, uma versão do DirectX para a plataforma dotNET. Todas as aplicações XNA são compiladas para código gerenciado (managed code, ou Microsoft Intermediate Language). Esse código é executado no Common Language Runtime (CLR), que é a máquina virtual da plataforma dotNET.
2 Componentes do Microsoft XNA
O ambiente de desenvolvimento que o XNA provê envolve são os seguintes:
- Framework: XNA Framework, com as classes necessárias para se criar um jogo, que pode ser tanto 2D como 3D;
- Gerência de artefatos: XNA Content Pipeline, encarrega-se de gerenciar a conexão entre os recursos produzidos pelos artistas (modelos, texturas, sprites, etc.) e o código do programador;
- Integrated Development Environment (IDE): XNA Game Studio Express, baseado no Visual C# 2005 Express. (gratuito, versão para estudantes, hobbistas e desenvolvedores independentes) ou o XNA Game Studio Professional (para desenvolvedores profissionais);
- Loader: carrega o artefato compilado quando requisitado. O Content Pipeline é flexível o bastante para permitir que se escrevam Importers e Processors para qualquer tipo específico de arquivo não suportado pelo XNA. A sua API é bem documentada e encontra-se no help do XNA.
2.2 XNA Game Studio Express
IDE baseada no Visual C# 2005 Express. Mantém algumas facilidades do Visual C# 2005 como: syntax highlighting, tecnologia de code complete chamada IntelliSense, just-in time debugging, criação de starter kits (templates de projeto), interface agradável, intuitiva e fácil de usar.
O XNA Game Studio Express (XNA GSE) permite que se criem projetos de games tanto para Windows como para Xbox 360, com o mesmo código fonte, sem grandes alterações. Caso a escolha seja gerar código para Xbox 360, deve-se evitar a utilização de bibliotecas (DLL) com código não gerenciado (unmanaged code). Este console utiliza um sistema operacional específico para ele e um processador próprio, baseado no IBM Power PC com três cores. Assim, uma DLL compilada com código nativo não será entendida no ambiente do Xbox 360, causando erro.
3 Criando um Game simples: Sokoban 3D
Para introduzir ao uso do XNA, será criado um pequeno exemplo de uma versão 3D do jogo Sokoban. Com ele serão mostrados alguns passos na utilização da IDE, no uso de algumas classes do Framework e do Content Pipeline. Os passos básicos serão descritos de maneira genérica, para que possa ser utilizado em qualquer projeto.
3.1 Criação de um projeto no XNA Game Studio Express
A área de impressão é de 13cmX17cm sendo o tamanho da página definido como 16cm × 23cm. O texto deve ocupar a linha inteira e as figuras não podem ultrapassar as margens definidas. Procure preencher toda a área de impressão da página de modo não deixar mais do que 2 cm em branco no final de cada página. Faça seu maior esforço, movimentando figuras e texto, para completar cada página.
Ao criar um novo projeto, podem-se usar diversos templates, o que facilitarão no ajuste do ambiente para uma aplicação específica. Neste primeiro exemplo, inicia-se com o template do tipo “Windows Game” no MS XNA GSE. Para tal deve-se:
- Abrir o Game Studio Express;
- Clicar no menu File / New Project...
- Uma caixa de dialogo aparecerá
- Escolher a opção Windows Game no campo Templates;
- No campo Name, dar um nome para o projeto. No caso deste tutorial foi colocado “Sokoban3D”;
- Ao clicar em OK o projeto acaba de ser criado no local indicado no campo Location.
Nesta etapa, o XNA GSE estará configurado para iniciar o desenvolvimento da aplicação. Tanto o ambiente de desenvolvimento como uma série de arquivos foram criados. Estes servirão como ponto de partida para a criação do jogo. Os dois arquivos mais importantes são o Program.cs e o Game.cs.
3.2 Analisando as classes recém-criadas: Program e Game
namespace Sokoban3D { static class Program { static void Main(string[] args) { using (Game1 game = new Game1()) { game.Run(); } } } } A listagem acima mostra a classe Program, que representa o ponto de entrada da aplicação. Por se tratar de uma aplicação .net, o game precisa de uma classe que contenha o método Main, que será a primeira a ser chamada pelo sistema quando for carregado.
Nesta classe foi instanciado um objeto do tipo Game. Pode-se renomear a classe e seu arquivo para atender as nossas necessidades da aplicação. Mais adiante será mostrado como fazer isso usando os recursos do XNA GSE. A classe Game irá conter o código principal com a lógica e renderização da aplicação. A chamada ao método Run consiste na execução desta classe, implicando na execução do loop de um game, que estará desmembrado na implementação da classe Game.
Game1 é uma classe derivada de Game, pertencente ao XNA Framework. Em qualquer jogo implementado no XNA deve-se ter pelo menos uma classe derivada de Game no, pertencente ao Microsoft.Xna.Framework. Esta classe contém métodos que são chamados automaticamente pelo sistema, compondo o game loop. À partir da implementação
Figura 3: Escolhendo o novo nome da classe.
- Antes de efetivar o renomeio da classe, uma nova janela é exibida mostrando os lugares que a classe é referenciada ou usada, como ilustra a figura 6. Assim, é possível aplicar-se a modificação somente em partes do projeto. Neste caso deseja-se que todas as referências, tanto em Program como em Game1, as modificações sejam efetuadas.
Figura 4: Confirmando o renomeio da classe.
3.4 Entendendo a classe Game
A seguir, na listagem abaixo, apresenta-se detalhes da classe SokobanGame: namespace Sokoban3D { public class SokobanGame : Microsoft.Xna.Framework.Game { GraphicsDeviceManager graphics; ContentManager content;
public Game1() {
graphics = new GraphicsDeviceManager(this); content = new ContentManager(Services); }
protected override void Initialize() protected override void LoadGraphicsContent (bool loadAllContent) protected override void Update(GameTime gameTime) protected override void Draw(GameTime gameTime) protected override void UnloadGraphicsContent (bool unloadAllContent) } } Como já foi dito, SokobanGame sobrescreve alguns métodos presentes na classe Game. O XNA GSE criou stubs destes métodos automaticamente para poderem ser completados com o código apropriado para a aplicação específica. A seguir será explicado sobre o porquê desta classe ser a base de um game XNA.
3.4.1 Abstração do hardware gráfico
O atributo graphics presente em SokobanGame permite ter-se acesso ao hardware gráfico. É possível que se tenha mais de uma GPU presente no sistema, e a GraphicsDeviceManager, pertencente ao namespace Microsoft.Xna.Framework provê meios de se obter acesso a elas. Neste caso se está considerando apenas uma placa gráfica, portanto o atributo GraphicsDevice, pertencente à graphics, representa esta única GPU.
Através do atributo graphics se poderá obter informações relavantes para a aplicação, tais como o tamanho da janela, se a janela ela se encontra em full screen, qual suporte da GPU em relação à shading, etc.
3.4.2 Acesso aos artefatos
A manipulação das imagens, modelos e efeitos (Texture2D, Model e Effect, respectivamente) se dá utilizando-se o atributo content, presente em SokobanGame.
Pode-se carregar este tipo de conteúdo através do seu método Load. Por exemplo, para carregar um modelo 3D, deve-se seguir o procedimento abaixo:
Model myModel = this.content.Load(@"nome_do_modelo");
No Solution Explorer, clicar com o botão direito do mouse sobre o nome do projeto. Um menu pop-up aparecerá, como mostrado na figura 5. Escolher a opção Add / New Folder.
Figura 5: Criando uma nova pasta.
A nova pasta foi criada. Deve-se dar um nome à ela. Para tanto, Escolher Content, como mostrado na figura 6.
Figura 6: Dando nome à pasta.
3.5.2 Adicionando elementos para a pasta no projeto
Um game é composto por diversos elementos, além do seu código: texturas, sprites, modelos 3D, etc. Antes de usar estes elementos na programação da lógica do jogo, deve-se inseri-los numa pasta que contará estes dados. Para realizar esta tarefa, deve-se seguir o procedimento abaixo:
- No Solution Explorer, clicar com o botão direito do mouse sobre a pasta Content, conforme ilustrado na figura 7. Escolher Add / Existing Item...
Figura 7: Adicionando novos itens a pasta.
- Na caixa de diálogo que apareceu, escolher a opção Content Pipeline no campo Files of type. Selecionar o arquivo desejado e clicar no botão Add. O arquivo será adicionado ao projeto (O exemplo apresenta o arquivo GameThumbnail.png, mas ele não será usado efetivamente).
Figura 18: Adicionando a pasta de projeto um Item.
- Feito isto, o arquivo está pronto para ser usado via código, como na figura 9.
Figura 9: GameThumbnail.png no Solution Explorer.
compilada. Isso permite o uso de referências relativas ao arquivo. Colocar a opção “Copy If Newer”
- XNA Framework Content Pipeline Asset Name: o nome que servirá para referenciar ao artefato desde dentro da aplicação. Não precisa ser necessariamente o mesmo nome do arquivo, mas este é o nome que deve que ser usado quando for referenciado no código e não mais o nome do arquivo original.
- Content Importer e Content Processor: são os elementos dentro do Content Pipeline que manipularão o arquivo no momento do build. Para tipos de arquivos amplamente conhecidos, o XNA provê Importers e Processors default, mas é possível escrever para tipos desconhecidos. Não é do escopo deste tutorial tratar sobre este assunto, mas o XNA já possui diversas implementações prontas.
4 Usando Imagens, Modelos e Efeitos
Como foi apresentado na seção Importando artefatos no GSE, viu-se que é relativamente simples o processo de importar estes elementos. Agora será discutido como exibi-los numa aplicação. As duas seções a seguir mostram como carregar e exibir uma imagem 2D e um modelo 3D. Será visto que o modo de carregamento entre os dois é semelhante, porém o modo de desenhar é distintos para ambos.
4.1 Exibindo imagens 2D
Para exemplificar o processo de lidar com uma figura será usando um arquivo de imagem como mostrado na figura 12.
Figura 12: texturaCaixa.png
Considere-se que este arquivo já foi adicionada ao projeto e o nome que lhe foi atribuído é texturaCaixa, dentro de uma pasta chamada Content. Este processo adicionou um atributo ao SokobanGame,mas precisa ser criado um objeto que guardará uma referência para a imagem carregada, como pode ser visto na listagem abaixo
public class SokobanGame : Microsoft.Xna.Framework.Game { GraphicsDeviceManager graphics; ContentManager content;
//Novos atributos Texture2D imagem; SpriteBatch batch;
Além disso, colocou-se mais um atributo chamado batch, que serve para desenhar imagens 2D na tela. Para carregar a imagem e inicializar o modo de desenho na tela, será utilizado o método LoadGraphicsContent, da seguinte forma:
protected override void LoadGraphicsContent(bool loadAllContent) { if (loadAllContent) { batch = new SpriteBatch(graphics.GraphicsDevice); imagem = content.Load(@"Content\texturaCaixa"); } Foi criado um objeto do tipo SpriteBatch, pertencente ao namespace Microsoft.Xna.Framework.Graphics. Sua contrução requer que seja passado como parâmetro qual GPU ele deve usar para desenhar a imagem. No exemplo em questão há apenas um hardware dedicado, o que não traz maiores complicações. O próximo passo será desenhar a imagem na tela. Como é um código relativo à renderização, deverá estar inserido no método Draw, como mostra a listagem abaixo:
protected override void Draw(GameTime gameTime) { graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
// TODO: Add your drawing code here this.batch.Begin(); this.batch.Draw(this.imagem, Vector2.Zero, Color.White); this.batch.End(); }
Foram passados ao método Draw de batch um total de 3 parâmetros, a saber: a imagem a ser exibida, sua posição na tela e sua cor. No caso, Color.White significa que ela será desenhada em sua cor original. Pode-se desenhar quantas imagens se desejar, bem como adicionar várias linhas entre Begin e End para cada imagem em questão.
Matrix view = Matrix.Identity; Matrix projection = Matrix.Identity; Matrix world = Matrix.Identity;
A listagem acima mostra os atributos da classe SokobanGame, alguns já descritos, como graphics, content e sokoban além dos novos. A seguir a explicação sobre os 3 novos atributos: view, projection e cameraPosition. A matriz que foi chamada de view é responsável pela abstração da câmera no mundo 3D. Sua criação implica na definição da sua posição, direção do alvo e do up Vector, vetor que determina o eixo vertical da câmera. Já a matriz projection define o cone de visão da câmera (frustum). Os parâmetros passados são os seguintes: Near plane: distância entre a posição da câmera e a base menor do cone. Far plane: distância entre a câmera e a base maior do cone. Field of View: angulo de abertura do cone de visão Aspect Ratio: fator de escala Por último, deve-se definir a matriz que define as transformações que o modelo deve sofrer, como rotação, translação ou escala. Neste exemplo não será feita nenhuma alteração, pois será exibido com as configurações default. Por esta razão a matriz da listagem 7 recebe o valor de uma matriz identidade, ou seja, uma matriz que não influencia no cálculo das transformações. A figura 15 ilustra o conceito apresentado:
Figura 15: Cone de visão da camera (frustum).
Com isso já é possível carregar o modelo e definir valores às matrizes. A listagem a seguir mostra como definir isto no XNA.
protected override void LoadGraphicsContent(bool loadAllContent) { if (loadAllContent)
GraphicsDevice device = graphics.GraphicsDevice; sokoban = content.Load(@"Content\sokoban");
float fieldOfView = MathHelper.ToRadians(45); float aspectRatio = device.Viewport.Width / device.Viewport.Height; float nearPlane = 1.0f; float farPlane = 10000.0f;
cameraPosition = new Vector3(300.0f, 300.0f, 300.0f);
projection = Matrix.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlane, farPlane); view = Matrix.CreateLookAt(cameraPosition, Vector3.Zero, Vector3.Up); }
Neste caso, o modelo é composto por várias partes (cabeça, braços, corpos, pés). O conceito de modelo presente no XNA é um pouco diferente do que se costuma ver nos softwares de modelagem 3D, como Maya ou 3DS Max. Aqui, o modelo é o arquivo todo, e os modelos dentro do arquivo são os chamados de meshes, sendo que cada um tem seu nome, sua cor, texturas, etc.
Uma vez carregado o modelo, deseja-se efetivamente plotá-lo na tela. A listagem abaixo mostra como isto é realizado.
protected override void Draw(GameTime gameTime) { graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
foreach (ModelMesh mesh in this.sokoban.Meshes) { foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.View = this.view; effect.Projection = this.projection; effect.World = this.world; }
mesh.Draw(); }
Figura 17: Primeira tela.
Figura 18: Segunda tela. Figura 19: Terceira tela.
A idéia geral deste esquema é que cada tela terá sua própria classe, descrevendo o seu comportamento. Além disso, será criada uma classe abstrata que conterá propriedades e métodos comuns a todas elas. Mais adiante será explicado como fazer para saber qual é a tela atual. A estrutura proposta permite que se possam inserir mais telas, de maneira limpa e sem afetar as já existentes.
5.1 Criando e adicionando novas classes ao projeto
A seguir será criada uma classe abstrata chamada Screen, que posteriormente será adicionada ao projeto. Para isto deve-se seguir os seguintes passos:
- Clicar com o botão direito do mouse sobre o nome do projeto. Um menu pop-up aparecerá como na figura. Escolher Add / New Item...
Figura 20: Adicionando novas classes
- A figura 21 mostra a caixa de diálogo que pede para escolher o tipo de item que se deseja criar. Selecionar Class, dando o nome de Screen.cs e clicando logo em seguida em Add.
Figura 21: criando e nomeando uma nova classe
- A classe recém-criada foi adicionada ao Solution Explorer e seu código básico já inserido no XNA GSE. Deve-se defini-la como sendo abstrata e colocar os atributos e métodos que devem ser comuns a todas as telas. A listagem abaixo dá a idéia de como deve ficar a classe
abstract public class Screen { private SpriteBatch batch = null; private Game game = null; public Game GameInstance { get { return game; } } public SpriteBatch SpriteBatch { get { return batch; } }
