Multi Plata Form A

Desenvolvimento
Multiplataforma para
Jogos
DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 1
Desenvolvimento Multiplataforma para Jogos
Aula 1:
Introdução ao Desenvolvimento de Jogos 3D e Matemática Vetorial
para Jogos 3D
Introdução ao Desenvolvimento de Jogos 3D
Jogos 3D são jogos que utilizam modelos tridimensionais para representar

elementos de jogo. Esses elementos podem ser cenários, personagens ou
objetos. Além disso, um jogo 3D possui vários módulos para fornecer mais
interação na sua jogabilidade: módulos de Inteligência Artificial,
Computação Gráfica, Redes de Computadores, Multimídia (desenho,
modelos 3D, sons etc.), Física, entre outros.
Matematicamente, um jogo 3D usa os três eixos do plano cartesiano para

representar o seu mundo do jogo, sendo os eixos x, y e z do monitor do
nosso computador, tv ou qualquer dispositivo capaz de reproduzir um jogo
3D.
Diversas habilidades em diferentes áreas do conhecimento, são necessárias

no momento do desenvolvimento de um jogo 3D. Nessa apostila, vamos
abordar os fundamentos da programação em um ambiente 3D, ou seja, a
programação simulando através de um plano cartesiano tridimensional, o
mundo de um jogo. Onde o eixo x é representado como a largura, o eixo y,
como a altura e o eixo z, como a profundidade. Na Figura 1, é possível
visualizar a representação gráfica de um plano cartesiano tridimensional.

Figura 1: Plano Cartesiano Tridimensional
Um tipo especial de ferramenta, conhecida como game engine (motor de

jogos), vem evoluindo com o passar dos anos, para auxiliar os
desenvolvedores a implementar os jogos. Uma game engine pode possuir
algumas características importantes, entre elas estão, um sistema de
renderização 3D com suporte a Shaders programáveis, um sistema de
simulação física, algoritmos de Inteligência Artificial, leitura e escrita de
objetos em disco, comunicação em rede, detecção de colisão e uma
interface amigável. Uma outra função da game engine é isolar o jogo do
hardware no qual ele está executando, dessa forma os programadores não
precisam se preocupar com os detalhes de baixo nível do hardware, apenas
com a lógica do jogo.
Nessa apostila vamos utilizar a engine Unity 3D para entender como essas
engines facilitam o desenvolvimento de jogos e como é a programação de
jogos 3D, ou seja, o que precisamos aprender, qual a linguagem vamos
utilizar e em que partes a programação será importante.
O desenvolvimento de um jogo é divido em várias fases, sendo elas:

mercado alvo, organização da equipe, prototipação, ciclo de
desenvolvimento, projeto do jogo (game design), regras básicas para um
bom jogo e o que os jogadores querem e esperam.

Equipe de desenvolvimento
Segundo Perucia, hoje em dia os jogos computadorizados são criados como
grandes produções de cinema, com orçamentos que facilmente chegam a
milhões de dólares. Para criar um jogo de última geração e que faça sucesso
é necessário de dois a três anos e uma equipe de cerca de 20 a 50 pessoas
com os seguintes perfis:
 Programadores: encarregados por desenvolver o software do jogo;

 Artistas (Design): encarregados pelo layout do jogo e protótipos;
 Projetistas de Níveis/Fases (Design): encarregados por elaborar as fases
dos jogos estruturando seus desafios e surpresas;
 Projetistas de Jogos: mais conhecidos como game design, são essenciais no
desenvolvimento do projeto, pois com sua visão ampla, precisam garantir que
o jogo desenvolvido esteja alinhado com o design documento;
 Planejador de Software (Software Planner): encarregado por dividir o
planejamento do jogo em um conjunto de requisitos técnicos e estimar tempo
e esforço;
 Arquiteto Chefe (Lead Architect): encarregado a trabalhar em conjunto
com planejador de software para separar as especificações em módulos e
elaborar a arquitetura do projeto.
 Gerente de Projetos: encarregado por balancear a carga gerada pelo
planejador de software e arquiteto chefe, produzindo um planejamento
eficiente e organizado.
 Músicos e Sonoplastas: geralmente pessoas que são da área de artes e
música e são responsáveis pelas trilhas sonoras, efeitos especiais e vozes de
personagens.
 Testadores: encarregados por jogar diversas vezes o jogo, com o objetivo de
encontrar erros e bugs.
Como pode ser verificado, a equipe de desenvolvimento de um jogo é

grande, pois diversas responsabilidades são encontradas, tornando,
assim, o seu desenvolvimento um pouco complexo. Também é possível
observar que diversas áreas do conhecimento se integram em único
ambiente, desde programadores a artistas.
Ciclo de desenvolvimento
Perucia, afirma que o ciclo de desenvolvimento começa com uma reunião
criativa em que as ideias do jogo são expostas e discutidas por todos. Nesse
momento é observado qual ideia tem maior originalidade, inovação, público
alvo, plataforma e possibilidade de mercado. Sendo este último um dos
mais importantes, a não ser que o jogo seja distribuído gratuitamente. São
necessárias diversas dessas reuniões até que se defina um projeto de jogo
para se investir. Escolhido o projeto inicia o processo de game design.
O game design é onde se encontra as características principais do jogo,

como jogabilidade (gameplay), controles, interfaces, personagens, armas,
golpes, inimigos, fases e todos os aspectos gerais do projeto. É nessa fase
que o design document é elaborado, esse documento tem o objetivo de
descrever todas as características citadas anteriormente. O design
document funciona basicamente como um roteiro de cinema a ser seguido
no desenvolvimento do jogo.
Com o design document pronto, o gerente de projeto tem a noção do

tamanho do projeto e de quanto tempo será necessário para concluí-lo.
Com isso os diretores de cada setor começam a definir metas e
cronogramas para os gerentes de projeto. Nesse momento com os
cronogramas e metas definidos os artistas começam a trabalhar na
concepção de personagens e identidades visuais do jogo e os
programadores começam a pensar e definir a modelagem do software.
Em alguns projetos de pequeno porte (como jogos puzzle, por exemplo), o

design document já é suficiente para que artistas e programadores

trabalhem no desenvolvimento do projeto. Entretanto, em projetos
maiores, onde se encontram muitos objetivos a serem desvendados e
missões a serem compridas são necessários planejamentos específicos
entre programadores e artistas, em cada fase e missão.
Com esse planejamento para projetos maiores é necessário elaborar o level

design. Cujo objetivo é elaborar um mapa geral com os desafios e missões
que cada jogador deve cumprir para vencer a fase. Esse documento serve
como referência para que os artistas trabalhem na criação dos cenários e
do visual de cada fase.
Antes de começar a parte de desenvolvimento os artistas, junto com os

programadores criam protótipos para testar como determinada mecânica
pode influenciar no estado do jogo e se ela irá ficar realmente interessante
na sua jogabilidade. Em outras palavras, como algumas ideias escritas no
game design irão ficar depois de implementadas.
As empresas acabam definindo metas e versões intermediárias, de acordo

com o tamanho do projeto e suas preferências. Com essas versões
intermediárias, que podem ser entregues a cada semana ou mês, os
gerentes de projeto podem ficar mais próximos dos prazos e metas e com
isso cobrar com mais rigor. Essas versões também são importantes para
detecção de bugs que surgem durante o desenvolvimento.
Em cada etapa novos protótipos são construídos e a jogabilidade testada.
Com isso, o desenvolvimento do projeto de jogo se torna constante, até

atingir a versão Beta. Nessa versão a maioria das fases precisam estar
implementadas. Quando essa versão é concluída, a fase de teste é ativada
com o objetivo de detectar bugs nos cenários e jogabilidade e refinar a
programação e a arte do jogo. No entanto, outro ponto observado são as

sugestões dos testadores, por meio das quais as mudanças importantes
podem acontecer.
É observado que no ciclo de desenvolvimento de um jogo a divisão de

etapas e a elaboração de documentos como, document design e level design
são muito importantes, pois assim os gerentes irão poder obter uma
visualização geral do projeto. Artistas e desenvolvedores terão uma maior
organização nas suas tarefas. Para isso a equipe necessita está em grande
sintonia para cumprir o cronograma elaborado pelo gerente de projeto.
Essa disciplina irá focar no desenvolvimento de jogos 2D, mais

especificamente na sua prototipação. Iremos entender como funcionam
esses tipos de jogos e como prototipá-los, pois o processo de
desenvolvimento de um jogo em um linguagem de programação com
bibliotecas e engines de jogos é bem mais complexo e demorado. É
necessário que se tenha uma etapa preliminar ao desenvolvimento, para
que possa testar o que está se propondo, como testes de usabilidade,
mecânica, entre outros.
Matemática Vetorial para Jogos

Neste item, serão apresentados alguns conceitos básicos sobre vetores,
estruturas muito importantes para o desenvolvimento de jogos digitais. Os
vetores podem ser utilizados para posicionar e movimentar os objetos dos
jogos, além de diversas outras situações.
O uso da geometria, trigonometria e física, podem resultar em cálculos,

onde seus resultados podem ser definidos em duas grandezas, escalares
e vetoriais.
Na grandeza escalar os valores desses cálculos são representados

utilizando um único valor numérico, dentro de uma escala qualquer

(temperatura, distância, massa, tempo, entre outros). Já na grandeza
vetorial, esses valores são representados em uma associação entre um
sentido ou direção e uma magnitude (representa a distância entre dois
pontos em um plano cartesiano), como, por exemplo, velocidade,
aceleração, força, deslocamento, empuxo etc. Na Figura 2, pode ser
visualizada a representação visual dos vetores.
Figura 2: Exemplo de vetores
Na Figura 2, podemos observar vários exemplos da utilidade de um vetor:

o primeiro vetor poderia representar a força aplicada algum objeto, ao
empurrar uma caixa ou uma pedra, o segundo vetor poderia representar a
força da gravidade e o terceiro a velocidade de algum objeto.
O entendimento da matemática vetorial é um ponto importante para uso

de uma game engine, principalmente em jogos que possuem seu espaço de
mundo, representado como um plano tridimensional.
A representação de vetor em um plano cartesiano tridimensional é feita por

uma tripla ordenada (x,y,z). Existe uma classe no C# do Unity que
representa um vetor, essa classe se chama Vector3D.
Adiante são abordadas algumas propriedades e operações com vetores:
Vetor Nulo
O vetor nulo possui o segmento nulo, ou seja, um vetor que possui seus
componentes zero.

Módulo ou Magnitude de um Vetor
O módulo e a magnitude de um vetor é utilizado quando é necessário
calcular a distância entre dois pontos. Por exemplo, se em um jogo, o player
precisa atirar um projétil em um inimigo, este deve ser capaz de “ver” o
inimigo para mirar nele. Podemos considerar o alcance da visão como a
distância entre o jogador e o inimigo.
O módulo ou magnitude é um número real não negativo que representa o

tamanho do vetor. Esse valor é calculado pela raiz quadrada da soma dos
quadrados dos componentes do vetor. Adiante é possível observar o cálculo
para o vetor B.
→= (3,4,5)
𝐵
| → | = √𝑥 2 + 𝑦 2 + 𝑧 2
𝐵
| → | = √32 + 42 + 52
𝐵
| → | = √9 + 16 + 25
𝐵
| → | = √9 + 16 + 25
𝐵
| → | = √50
𝐵
| → | = 7.07
𝐵
Vetor Unitário (Normalização) e Versor

O vetor unitário possui a magnitude igual a 1. A partir de um vetor V não
nulo, chama-se de versor o vetor unitário que possui a mesma direção e o
mesmo sentido. A Figura 3 exibe um vetor B e D, que é o versor de B.

→
𝐷
→
𝐵
y
Figura 3: Versor de um vetor
Para normalizar um vetor, precisamos dividi-lo pelo valor de sua magnitude.
Por exemplo, se possuirmos um vetor com coordenadas (3.0, 4.0, 5.0), sua
magnitude será 7.07, esse vetor normalizado será (3.0/7.07, 4/7.07,
5/7.07) = (0.42, 0.56, 0.70).
Soma de Vetores
Seja um vetor A (x1, y1, z1) e um vetor B (x2, y2, z2), a soma dos vetores
A e B é o vetor R (x1 + x2, y1+y2, z1+z2). Na Figura 4, pode ser visualizado
a operação de soma de vetores, representados em um plano cartesiano 2D.
Figura 4: Operação de Soma de Vetores
Na Figura 4, é possível visualizar que a soma do vetor u (1.46, 3.82) com

o vetor v (4.24, 1.24), resulta no vetor com w (5.7, 5.06). Também é
possível observar que o exemplo está sendo realizado em um plano
cartesiano 2D. A diferença entre o plano cartesiano 2D e 3D na operação
com vetores, é a adição da coordenada do eixo z em cada vetor.

Um dos exemplos da soma de vetores em jogos pode ser entendido no
contexto a seguir: imagine que um personagem pega um capacete e esse
capacete é um modelo 3D diferente do modelo do personagem e deve ser
posicionado na cabeça do personagem. Esse posicionamento é feito
colocando-se na posição do capacete a posição do modelo 3D do
personagem mais um deslocamento (que é a altura da cabeça do
personagem com relação ao capacete). Isso pode ser feito através da soma
de vetores.
Subtração de Vetores
Seja um vetor A (x1, y1, z1) e um vetor B (x2, y2, z2), a soma dos vetores
A e B é o vetor R (x1 - x2, y1 - y2, z1 - z2). Na Figura 5, pode ser visualizado
a operação de soma de vetores, representados em um plano cartesiano 2D.
Figura 5 – Operação de subtração de vetores
Na Figura 5, é possível visualizar que a subtração do vetor u (1, 3) com o

vetor v (3, 1), resulta no vetor com w (-2, 2). Também é possível observar
que o exemplo está sendo realizado em um plano cartesiano 2D. A diferença
entre o plano cartesiano 2D e 3D na operação com vetores, é a adição da
coordenada do eixo z em cada vetor.
Nos jogos, a subtração de dois vetores é muito utilizada para determinar

um vetor distância entre dois pontos. Como descrito no seguinte contexto:
se o inimigo quer perseguir o jogador, o sistema deve ser capaz de criar
um vetor que informe a direção e o sentido que o inimigo deverá percorrer.
Sabendo o vetor posição do jogador e o vetor posição do inimigo, é possível
calcular esse vetor, através da subtração dos dois.
Multiplicação por Escalar

A multiplicação de um vetor por um valor escalar muda o comprimento
(magnitude) do vetor. Se o valor do escalar for negativo mudará a direção
que o vetor aponta.
Aula 2:
Apresentação da Ferramenta e Composição de Cenas 3D
Apresentação da Ferramenta
Nessa apostila iremos utilizar a engine Unity 3D para desenvolver os jogos.

Essa engine possui um ambiente repleto de recursos para auxiliar o
desenvolvedor no desenvolvimento de um jogo. O seu download pode ser
realizado na página: https://unity3d.com/pt
É importante realizar o download da versão personal. Pois, nessa versão

não é preciso pagar nenhuma licença para usar a engine. No entanto, o seu
uso possui algumas limitações quanto a venda dos jogos e alguns recursos
mais avançados da ferramenta.
Algumas vantagens de usar o Unity 3D para o desenvolvimento de jogos:
 Possui uma documentação completa, repleta de manuais,

vídeos, tutoriais e fórum para dúvidas;

 Suporte para jogos 2D e 3D;
 Loja para compra e venda de assets (arquivos para jogos)
 Grande comunidade de pessoas que trabalham com a
ferramenta;
 Multiplataforma, ou seja, com um mesmo código você
desenvolve jogos para desktop, mobile, console e dispositivos
móveis.
Interface do Unity 3D
A Engine Unity possui uma interface simples, que facilita o desenvolvimento
de jogos. Sua área de trabalho é dividida em várias janelas chamadas
views, cada uma possui um objetivo especifico. Na Figura 6 a seguir, está
representado cada uma dessas janelas no editor de cenas do Unity 3D.
Figura 6: Área de Trabalho do Unity

Na Figura 6, é possível visualizar as seguintes janelas (views):
 Project View: nessa janela é possível organizar, manipular, criar e
buscar as pastas e arquivos (Assets) do projeto. São os arquivos que
estão salvo no disco rígido.
 Hierarchy View: exibe todos os elementos da cena que estiver
sendo editada. Também é possível organizar e visualizar a hierarquia
de composição entre os objetos que estão na cena. São os objetos
que estarão sendo manipulados em tempo de execução.
 Scene View: nessa janela é possível editar visualmente os elementos
da cena. Essa view pode ser alternada entre os modos 2D e 3D. Na
edição dos elementos é possível mudar a orientação e posicionamento
dos elementos através das operações de translação, rotação e escala.
 Game View: visualizar o jogo que está sendo desenvolvido de
maneira que ele estivesse já executando no dispositivo final.
 Inspector View: visualizar e editar os atributos dos componentes
dos objetos ou arquivos selecionados na área de trabalho.
 Console View: nessa janela é possível visualizar as mensagens de
erro que podem ocorrer durante a execução de um jogo.
Além das views, que estão distribuídas na área de trabalho do Unity 3D,
existe a barra de ferramentas que possui as funcionalidades básicas de
manipulação dos elementos e área de trabalho. Na Figura 7, é possível
visualizar a barra de ferramentas:
Figura 7: Barra de ferramentas do Unity
Na Figura 7, é possível observar que mais à esquerda da barra de

ferramentas estão as ferramentas de transformação, onde é possível
realizar a translação, rotação e escala dos objetos. No centro da barra de

ferramentas temos os botões de play, stop e debug, onde é possível dar o
“play”, para visualizar o jogo a partir da cena que está sendo editada, além
de também ser possível pausar e ver o jogo passo a passo. Mais à direita
da barra de ferramentas, temos os botões de visualizar dados sobre a sua
conta, visualizar as layers que compõem o projeto e visualizar e editar o
layout da área de trabalho da Unity.
É importante saber que o layout (forma que as views são distribuídas na

área de trabalho da unity), pode ser customizado e modificado para que se
adeque ao estilo de trabalho do desenvolvedor.
Composição de Cenas 3D
Neste item, iremos entender como as cenas 3D são compostas no Unity.
Vamos analisar com mais detalhes as Scenes, os GameObjects e os
Componentes com seus atributos.
O Unity organiza os arquivos em cenas (Scene). Cada cena, possui um

conjunto de objetos e seus componentes. As cenas podem ser salvas
tornando-se arquivos do projeto. Por exemplo, uma cena pode ser um
menu, um nível do jogo etc. Se o jogo possuir um menu e vários níveis,
cada um deles é representado como uma cena.
Na janela Hierarchy fica organizado todos os objetos de determinada cena.

No Unity, cada objeto é chamado de GameObject. Ele não faz nada por
conta própria. Para ser um personagem, um inimigo, uma parte do cenário,
um carro, uma luz, um efeito espacial etc. O GameObject precisa de
propriedades especiais que são fornecidas pelos componentes.
Para entender melhor a composição de uma cena 3D no Unity, vamos criar

um projeto. A versão utilizada para a criação de todos os exemplos dessa

apostila é o Unity 5.4.2f2. Na Figura 8, é possível visualizar a janela de login
do Unity 3D.
Figura 8: Janela de Login do Unity 3D
Na Figura 8, é possível visualizar que assim que o Unity é executado é

necessário realizar o login, ou escolher a opção de trabalhar off-line (Work
offline).
Depois que alguma das duas opções for escolhida é possível visualizar as
informações da janela de gerenciamento de projetos representada pela
Figura 9.

Figura 9: Janela de gerenciamento de projetos
Na Figura 9, pode ser visualizado a partir das numerações as seguintes

informações:
1. Os dados dos projetos criados recentemente
2. Um vídeo ensinando como começar no Unity 3D
3. O botão “New”, que é utilizado para criar um novo projeto.
4. O botão “Open”, que é utilizado para abrir um novo projeto.
5. O botão “My Account”, que é utilizado para visualização e
manipulação dos dados da conta do usuário.
Para criar um novo projeto é necessário apertar no botão “New”. Na Figura

10, pode ser visualizado a janela de criação de um novo projeto.

Figura 10: Janela de criação de um novo projeto
Na Figura 10, pode ser visualizado a partir das numerações as informações

básicas necessárias para criação de um projeto:
1. O nome do projeto
2. A localização no disco em que o projeto será salvo.
3. O modo de visualização do jogo, se vai ser, 3D ou 2D.
4. Adicionar os pacotes de arquivos (assets) padrão do unity 3D.
(Esses pacotes já possuem iluminação, personagens,
ambientes, veículos, árvores etc. Todos prontos para uso.)
5. Se você quer usar o analytics do Unity. Se deixar “On”, o Unity
tem acesso aos de sua manipulação com a ferramenta, como
logs e erros que ela pode gerar.
Depois que escolher o nome do projeto; onde ele será salvo; o modo de
visualização 3D e deixar o analytics como “OFF” é necessário apertar o
botão “Create project”. Na Figura 11, é possível visualizar como é área de
trabalho no layout padrão (Default) do Unity.

Figura 11: Área de trabalho com layout padrão (Default).
Na Figura 11, é possível visualizar como as janelas (views) estão

distribuídas na área de trabalho do Unity. Também é possível visualizar que
assim que um novo projeto é criado, ele não possui nenhum arquivo na
pasta assets da view Project e possui dois GameObjects na view Hierarchy,
que são o Main Camera (Câmera Principal) e o Directional Light (Luz
Direcional).
Para analisar uma composição de cena 3D, vamos criar uma nova pasta
chamada Scene, na pasta Assets da view Project. Nessa pasta nós iremos
salvar a nossa primeira Cena. Seu nome será “Main”.
Siga os passos adiante para criar a pasta e salvar a cena:
1. Apertar botão direito do mouse na pasta Assets -> Create ->
Folder;
2. Renomear a pasta para Scene;
3. Barra de menus -> File -> Save Scene -> Selecionar a pasta
Scene no seu projeto -> Colocar o nome da cena como Main.

Na Figura 12, é possível visualizar o projeto com a pasta criada e a cena
salva.
Figura 12: Projeto com pasta criada e cena salva
É sempre bom criar pastas dentro da pasta Assets, para subdividir seus
arquivos e não deixá-los todos misturados em uma única pasta. Isso ajuda
na organização e manipulação dos seus arquivos. Por exemplo, você pode
ter uma pasta para seus Sprites, Sons, Musicas, Modelos 3D, Texturas,
Materiais etc.
Para compor nossa cena “Main”, vamos criar um novo GameObject. Para
criar um GameObject você pode acessar o menu GameObject situado na
barra de menus, como pode ser visualizado na Figura 13.

Figura 13: Menu para criação de GameObjects na barra de menus
Como é possível observar na Figura 13, você pode criar diversos tipos de
GameObjects na sua cena. Lembrando que os GameObjects serão criados
na cena atual, ou seja, no caso do nosso exemplo a cena “Main”. Ainda
visualizando a Figura 13, é possível observar que é possível criar um
GameObject Vazio (Create Empty), Criar um filho de GameObject Vazio
(Create Empty Child), Criar um tipo de objeto 3D (3D Object), são
geralmente formas trigonométricas (cubos, planos, cilindros), como
também podem ser terrenos. Criar um tipo de objeto 2D (2D Object), Criar
um tipo de Luz (Light), um tipo Áudio (Audio), uma Interface de usuário
(UI), um Sistema de Partículas (Particle System) ou Câmera (Camera).
Todos eles são muito importantes e vamos falar um pouquinho no decorrer
do nosso curso.
Para compor nossa cena, vamos criar um Cubo, que é um tipo de objeto
3D. Para criá-lo, selecione o menu GameObject na barra de menus, 3D

Object -> Cube. Assim que o cubo for criado nossa área de trabalho irá ficar
parecida com a Figura 14.
Figura 14: Área de trabalho com o objeto 3D cubo criado
Na Figura 14, podem ser observados vários pontos importantes que

mudaram na nossa área de trabalho. Vamos analisar cada um deles.
 Na janela (view) Hierarchy, como visualizado na Figura 15, mais um

GameObject foi adicionado a nossa cena. O GameObject “Cube”.
Também é possível observar que no nome da cena “Main” apareceu
um asterisco (*). Toda vez que um asterisco (*) aparecer no nome
da cena, indica que a cena foi editada, mas não foi salva.

Figura 15: Janela (view) Hierarchy do Projeto
 Como pode ser observado na Figura 16, na janela (view) Scene

aparece um modelo 3D de um cubo. No objeto, é possível visualizar
o vetor com as posições x (de vermelho), y (de verde), z (de azul) do
objeto na cena (Plano cartesiano tridimensional). Para visualizar o
vetor de posição do objeto é necessário selecionar o objeto na janela
Hierarchy.
Figura 16: Janela (view) Scene do Projeto

 Já na janela (view) inspector, como visualizado na Figura 17, é
possível observar os atributos básicos do GameObject Cube e seus
componentes. É importante ressaltar que para ver os atributos e
componentes de um GameObject é necessário selecioná-lo na janela
Hierarchy.
Quando selecionamos o GameObject Cube, podemos visualizar na

janela (view) Inspector os seus atributos e componentes. Logo no
topo é possível observar o nome do GameObject, que no nosso caso
é Cube. Adiante temos o componente Transform. Esse componente é
básico a qualquer GameObject criado na Unity, ele define os vetores
de posição, rotação e escala de qualquer objeto 3D.
Outro componente que podemos visualizar é Box Collider. Esse
componente define uma caixa de colisão em um objeto para que ela
possa ser verificada no momento do jogo.
Figura 17: Cube selecionado na janela Hierarchy e componentes na janela Inpector

É importante compreender que o Unity possui uma programação orientada
a componentes, fazendo com que o desacoplamento e o seja maximizado
durante o desenvolvimento de um jogo.
Entre os principais componentes já disponibilizados no Unity estão:
 Collider e Collider2D: colisor que segue a forma física de um objeto

simples. Utilizado na detecção de colisão. As formas que um colisor
pode assumir são: Character Collider, Box Collider, Sphere Collider,
Capsule Collider, Mesh Collider, Wheel Collider e Terrain Collider. Para
acessar os tipos de colisores é necessário selecionar o objeto e na
janela (view) Inspector, apertar o botão “Add Component” e
selecionar Physics. Como pode ser visualizado na Figura 18.
Figura 18: Visualizando tipos de Collider
 Rigidybody e Rigidybody2D: O objeto que tiver esse componente

pode realizar uma simulação física 3D ou 2D. Com esse componente
o objeto passa a possuir, velocidade, massa, atrito, inercia e também
permite o objeto reagir a forças externas como gravidade.

 AudioSource: O objeto com esse componente pode emitir som. Com
ele possível manipular atributos do som, como, volume, repetição etc.
 Light: Como será visto mais adiante o objeto que possuir esse
componente pode ser uma fonte de luz. Com ele é possível manipular
alguns atributos da luz como, tipos da luz (Direcional, pontual, luz em
cone ou luz de área), alcance, a cor, a máscara etc.
 Renderer: Um objeto com esse componente pode ser desenhado na
tela.
 Camera: O objeto com esse componente será uma câmera no jogo.
A Câmera define o que o jogador poderá visualizar. Com esse
componente é manipular alguns atributos da câmera, como por
exemplo a projeção.
 Animator: Controla as animações dos objetos. Animações de objetos
da cena, animações da movimentação do personagem etc.
Dessa forma, é possível concluir, que cada projeto terá seus vários
GameObjects distribuídos na janela (view) hierarchy. Se um objeto for
selecionado na janela Hierarchy, todos os seus componentes e atributos
poderão ser visualizados e editados na janela Inspector. Já na janela Scene
poderá ser editado visualmente os objetos da cena.
Aula 3:
Iluminação, Configuração de Materiais e Texturas e Shaders
Iluminação
Tipos de Luzes que podem ser criadas dentro da Unity
 Luz Direcional (Directional Light): esse tipo luz simula a luz do

sol. Você pode rotacionar e conseguir efeitos de dia e noite no cena.

 Luz Pontual (Point Light): esse tipo de luz simula a luz de uma
lâmpada. Com esse tipo de luz você consegue irradiar luz para todas
as direções a partir de um range (limite).
 Luz em Cone (SpotLight): uma das funcionalidades dessa luz é a
de fornecer efeitos especiais. Como por exemplo luz indireta em
algum cômodo, a luz de uma lanterna, entre outros efeitos.
 Luz de área (Area Light): também serve para fornecer efeitos para
uma cena. No entanto, somente nos fornece o tipo de luz baked, que
será tratado mais à frente.
Geralmente todas essas luzes são usadas em conjunto, uma ajudando o

efeito da outra. Com isso, torna o cena um pouco mais realista.
Para criar qualquer uma dessas luzes é necessário acessar o menu

GameObject da barra de menus e selecionar no submenu o GameObject
Light, como pode ser visualizado na Figura 19.
Figura 19: Menu para criação de GameObject Light

Utilização das luzes no Unity
Luz Pontual (Point Light):
Na Figura 20, é possível visualizar a aplicação da luz pontual em uma cena

do Unity.
Figura 20: Uso da luz pontual em uma cena da Unity
Como pode ser visualizado na Figura 20, na janela (view) Hierarchy temos
uma câmera principal, um cubo, uma luz pontual e um plane. Também é
possível observar que a luz pontual ilumina apenas uma área da cena,
simulando a luz de uma lâmpada. As propriedades da luz podem ser
visualizadas no componente Light que está na janela Inspector. Lembrando
que os componentes da luz pontual somente vão aparecer na janela
Inspector se a luz pontual estiver selecionada.
Na Figura 21, pode ser visualizado com mais detalhes os atributos do

componente Light do GameObject Luz Pontual (Point Light).

Figura 21: Componente Light do GameObject Point Light
Na Figura 21, é possível visualizar que o componente Light possui vários

atributos, entre eles estão:
 Type: O tipo que luz que GameObject está simulando. No caso

da Figura 21, o GameObject está simulando a luz Pontual
(Point). Mas também é possível alterar o tipo de simulação por
esse atributo (Spot, Directional ou Area).
 Backing: Informa se os cálculos da iluminação vão ser
alterados em tempo de execução (Realtime). Se os cálculos não
vão ser alterados em tempo de execução (Baked) e será gerado
um mapa de luz (light mapping), ou se vai ter momentos que
os cálculos vão ser alterados em tempo de execução e
momentos que não vão ser alterados em tempo de execução
(Mixed).
 Range: Como se trata de uma luz pontual, é possível definir o
limite (range) que essa luz irá propagar no ambiente.
 Color: Mudar a cor da luz emitida.

 Intensity: A intensidade da emissão de luz.
 Shadow Type: Se os objetos terão sombra.
 Render Mode: A importância de renderização da sua luz no
ambiente. Pode ser, Auto (O computador define a importância),
Important (Todas as suas luzes serão renderizadas), Not
Important (Sua luz não terá um grau de importância para ser
renderizada, ou seja, tanto faz se ele for renderizada ou não).
 Culling Mask: É possível definir uma layer em determinado
objeto e dizer que ele não vai ser afetado pela luz do ambiente.
Luz Direcional (Directional Light)
Na Figura 22, é possível visualizar a aplicação da luz direcional em uma

cena do Unity.
Figura 22: Uso da luz direcional em uma cena da Unity

uma câmera principal, um cubo, uma luz direcional e um plane. Também é
possível observar que a luz direcional ilumina toda a cena, simulando a luz
do sol. As propriedades da luz podem ser visualizadas no componente Light
que está na janela (view) Inspector. Lembrando que os componentes da luz
pontual vão aparecer apenas na janela Inspector se a luz pontual estiver
selecionada.
Luz em Cone (Spotlight)

Na Figura 23, é possível visualizar a aplicação da luz em cone em uma cena
do Unity.
Figura 23: Uso da luz em cone em uma cena da Unity
uma câmera principal, um cubo, uma luz em cone e um plane. Também é
possível observar que a luz em cone ilumina uma área da cena, simulando
a iluminação de uma área em Cone. As propriedades da luz podem ser
visualizadas no componente Light que está na janela (view) Inspector.
Lembrando que os componentes da luz pontual só vão aparecer na janela
Inspector se a luz pontual estiver selecionada.
Luz em Área (Area light)
A luz em área é criada para dar um efeito mais realístico em algum

ambiente da cena que se está trabalhando. Ela funciona apenas em Baked,
ou seja, é necessário usar um Pré-cálculo para que ela exiba o efeito de
iluminação e crie um mapa de iluminação (light mapping) nos objetos da
cena. Outra coisa importante é que esse tipo de iluminação só funciona em
objetos que estão marcados como estáticos (static).
Para fazer esse Pré- Calculo é necessário acessar a janela (view) Lighting.
Para acessar essa janela, selecione a barra de menus -> Window ->
Lighting, como pode ser visualizado na Figura 24.

Figura 24: Acesso a janela (view) Lighting
Na Figura 25 é possível visualizar o efeito de uma luz em área.
Figura 25: Uso da luz em área em uma cena da Unity

Na Figura 25, é possível observar que a luz em área ilumina determina área
de uma cena. O limite dessa iluminação é definido pelos atributos width
(largura) e height (altura) do componente Light, vinculado ao GameObject
Area Light da cena.
Além disso, também é possível visualizar algumas informações

importantes, através dos números distribuídos na Figura 25:
1. A cena possui uma Câmera Principal (Main Camera), Cubo

(Cube), Plano (Plane) e Area Light (Luz de Área). Lembrando
que os GameObjects que irão refletir a luz precisam estar
definidos como estáticos (static). Para Definir um GameObject
como estático, selecione o GameObject e na janela (view)
Inspector, ao lado do nome do GameObject, selecione o
checkbox com o nome static, como pode ser visualizado na
Figura 26.
Figura 26: Exemplo de GameObject estático (static)
2. Os atributos width (largura) e height (altura) que irão definir o

limite ou alcance na cena do efeito de iluminação.
3. A aba da janela (view) Inspector, necessária para gerar o mapa
de luz (light mapping).
4. O botão Build da janela (view) Inspector para geração do mapa
de luz sobre os objetos estáticos da cena.
Com isso, é possível compreender que a criação e manipulação de luzes nos

projetos da Unity 3D não são tão complicados. Para usar as luzes de forma

básica não é necessário o uso de programação, pois o componente Light já
possui todos os atributos da luz definidos.
Configuração de Materiais, Texturas e Shaders
Material
Com o material é possível definir como a superfície de um objeto deve ser
renderizada. Incluindo referências a texturas, informações de tilling, cores
etc. É importante saber que as opções disponíveis para renderização de um
material dependem do Shader utilizado pelo material.
Shaders
São pequenos scripts que possuem os cálculos matemáticos e algoritmos
para determinar a cor de cada pixel do objeto representado, de acordo com
a luz e configuração do material.
Texturas
São imagens. Utilizadas em materiais, para que o Shader determine a cor
da superfície do objeto.
As texturas também podem representar outros aspectos da superfície de

um material, como, por exemplo, a sua refletividade ou deformações.
Depois de entender o conceito de Material, Textura e Shader. É importante

agora saber como usá-los.

Importando Texturas
Para importar as texturas, você pode ir na janela (view) Project, apertar o
botão direito do mouse na pasta Assets ou qualquer pasta que você criou e
acessar o Import New Asset. Como pode ser visualizado na Figura 27.
Figura 27: Importando Asset
Para importar as texturas também é possível abrir a pasta em que elas

estão salvas e arrastá-las para a pasta Assets ou qualquer outra pasta a
sua escolha da janela (view) Project.
No Unity, é recomendado que as dimensões das texturas sejam múltiplos

de potência de 2, para possuírem uma maior performance. Podem ser (256
x 128), (1024 x 512), entre outras.
Para aplicar os conceitos de Materiais, Texturas e Shaders, vamos criar um

novo Projeto no Unity.

Depois de criar um novo Projeto, é necessário criar três pastas. Essas
pastas irão dividir os assets do jogos e não irá deixar todos misturados em
uma única pasta. Uma terá o nome “Textures” para armazenar todas as
texturas. Uma terá o nome “Materials” para armazenar todos os materiais
e pôr fim a última pasta terá o nome “Scene” para armazenar as nossa
Cena. Depois de ter criado as pastas é importante salvar a cena que vamos
trabalhar na pasta “Scene” Como pode ser observado na Figura 28.
Figura 28: Projeto no Unity com as pastas criadas e a cena salva
É possível visualizar na Figura 28, que na pasta Assets da janela (view)

Project, temos nossas três pastas criadas e na pasta Scene temos a nossa
cena Main salva.
Depois de ter criado as pastas e salvo a cena, é importante importar nossas

texturas para que possamos trabalhar nos exemplos. Como pode ser
visualizado na Figura 29.

Figura 29: Importando textura para o Unity
Visualizando a Figura 29, é possível observar que para importar todos as

texturas de uma só vez para a pasta Textures do Unity é necessário
selecionar todas as texturas na pasta que está no computador e arrastar
para a pasta Textures que está dentro do Projeto do Unity. Depois que as
texturas foram soltas na pasta, o Unity irá abrir uma janela pedindo para
esperar, enquanto ele importa todas as texturas.
Depois que todas as texturas forem importadas pela Unity, a pasta Textures
irá receber todas as Texturas. Como pode ser visualizado na Figura 30.

Figura 30: Projeto com as texturas importadas
Na Figura 30, pode ser observado que todas as texturas estão importadas
dentro da pasta Textures. Você pode encontrar essas texturas de forma
gratuita na internet. O exemplo possui uma textura de aço, de uma grade,
de linhas, de madeira, de metal, de tijolo e de tijolo normalizado. Vamos
entender como aplicar cada uma delas.
Antes de entender a aplicação de cada uma das texturas, é importante

compreender os seus atributos. Para visualizar os atributos da textura,
selecione uma textura e veja a janela (view) Inpector. Como pode ser

Figura 31: Visualização dos atributos de uma textura
Na Figura 31, é possível observar que selecionando a textura tijolo na pasta

Textures a janela (view) Inspector exibe os atributos da textura. Entre os
atributos é possível visualizar:
 Texture Type: Esse atributo nos permite escolher o tipo
da textura. As imagens que importamos podem ser do
tipo Texture, ou seja, uma textura para um objeto 3D.
Podem ser do tipo Normal Map, ou seja, um mapeamento
de uma textura para deixá-la mais real. Podem ser do tipo
Sprite, ou seja, imagens usadas em jogos 2D para
representar objetos do jogo ou personagens. Podem ser
do tipo Cursor, ou seja, se essa imagem for representar
uma nova imagem para o cursor do mouse, entre outras.
 Alpha from Grayscal: Criar um canal alpha na imagem

com o GrayScal (Tons de Cinza da imagem) da imagem.

 Wrap Mode: É usado quando a textura é colocada em
um GameObject maior que ela. Esse atributo possui dois
valores, são eles: repeat, usado para repetir a textura e
completar o objeto e Clamp, usado para colocar a textura
em tamanho real na área do GameObject.
 Filter Mode: Controla como a textura será exibida depois

de aplicados várias transformações como escala. Esse
atributo possui três valores, são eles: Point, a textura será
bloqueada, Bilinear e Trilinear, a textura irá parecer
borrada.
 Aniso Level: Controla como a textura irá se comportar

com a mudança de ângulo da câmera.
 Default
o Max Size: Define o tamanho máximo que uma
textura irá possuir dentro do seu jogo. Se colocar
uma textura com valor maior do que esse atributo
o Unity converte para o tamanho máximo.
o Format: Define qual vai ser o formato da textura.
Dependendo do formato você pode consumir menos
espaço em memória.
Criando Material
Para criar um Material, acesse a pasta Assets ou a pasta Materials que
criamos no projeto, elas estão na janela (view) Project. Aperte o botão
direito do mouse -> Create -> Material. Como pode ser visualizado na
Figura 32.

Figura 32: Criando uma Material no Unity 3D
Coloque o nome do Material recém criado de Grade. Selecione o Material

com nome Grade e observe a janela (view) Inspector para visualizar as suas
propriedades. Como pode ser visualizado na Figura 33.
Figura 33: Janela (view) Inspector das propriedades do Material

Na Figura 33, é possível observar na janela (view) Inspector as seguintes
propriedades:
 Shader: Antes do Unity 5, para um objeto possuir vários
Shaders, era necessário criar vários materiais cada um com seu
shader e seus efeitos. A partir do Unity 5, é possível usar o
Standart Material que usa um shader com todas as
propriedades que você precisa para criar outro efeito no objeto
que o material esteja vinculado. Para usar o Standart Shader
selecione o material; acesse a janela (view) Inspector e na
propriedade Shader selecione Standart. Como pode ser
Figura 34: Shader Standart
 Rendering Mode: Visual de renderização do material.

o Opaque: Deixa o material com visual sólido e sem
transparência.
o Cutout: Mostrar parte do material ou deixá-lo totalmente
transparente.

o Fade: Deixa todo o material completamente
transparente. Usado muito para efeitos de fade-in e fade-
out.
o Transparent: Deixa o material transparente.
 Albedo: A textura principal do material. Controla qual vai ser a

forma visual do material e também controlar a cor dominante
do material.
 Metallic: Efeito metálico da textura do material.
 Normal Map: Deixa o visual da textura do material mais

realístico. Mas para isso é necessário o arquivo normal map da
textura.
 Height Map: Define o formato do objeto além do Nomal Map.

Mas para isso é necessário o arquivo height map da textura.
 Occlusion: Define qual partes do objeto são afetadas pela Luz

direcional do ambiente. Para isso é necessário criar uma
imagem com o tamanho da textura que estiver no albedo e
pintar de preto as partes que não vão receber a luz direcional e
de branco as partes que vão receber luz direcional.
 Emission: Define a quantidade de luz emitida pelo objeto, ou

seja, quanto o objeto brilha.

Para testar o efeito de transparência do objeto, siga os passos adiante:
1. Criar um novo projeto (Figura 35)

2. Crias as pastas Scene, Materials e Textures na pasta Assets da
janela (view) Project. É sempre importante mantes os arquivos
(assets) do projeto divididos em suas pastas. (Figura 35)
3. Salvar a cena na pasta Scene. (Figura 35)
4. Importar uma textura de grade em formato png na pasta
Textures. (Figura 35)
5. Criar um plano na posição (0,0,0) (Figura 35)
6. Criar um cubo na posição (0, 0.65, 0) (Figura 35)
7. Criar um novo material na pasta Material e colocar o nome dele
de grade. (Figura 35)
Figura 35: Projeto usando texturas
8. Vincule o material ao GameObject Cube. Para isso selecione o

Cube; acesse o componente Mesh Renderer na janela (view)
Inspector; acesse a propriedade Materials; acesse a
propriedade Element 0 e aperte o círculo ao lado; na janela que
abrir selecione o material Grade que foi criado. Como pode ser
Figura 36: Adicionando Material ao Objeto
9. Adicione a textura da Grade no material Grade. Para isso é

necessário selecionar o material Grade; e apertar no círculo
próximo ao nome albedo; selecionar na janela que abrir a
textura Grade; Como pode ser visualizado na Figura 37.

Figura 37: Adicionando textura no material
10. Selecione o Rendering Mode, “Transparent”. Como pode

ser visualizado na Figura 38.
Figura 38: Rendering Mode, “Transparent”

É possível visualizar na Figura 38, que o rendering mode está com o valor
transparente e o cubo na janela (view) Scene, está todo transparente e com
a textura de grade.
Aula 4:
Programação de Comportamentos Básicos
Criação de Scripts
Com os scripts, é possível criar os seus próprios comportamentos para os
GameObjects. Esses scripts podem ser escritos em C# e UnityScript que é
uma variação do Javascript. No entanto, ambos possuem a mesma
funcionalidade (fornece comportamento aos GameObjects). Nessa
disciplina vamos utilizar a linguagem C#, por possuir a vantagem da
programação Orientada a Objetos.
Geralmente os scripts podem ser criados para criar efeitos visuais, controlar
comportamentos físicos, implementar inteligência artificial e controlar a
movimentação de personagens.
Os scripts podem ser programados no Visual Studio ou no Mono Develop.

Nessa apostila vamos utilizar o Mono Develop, mas essa opção pode ser
alterada acessando a barra de menu -> Edit - > Preferences -> External
Tools. Na propriedade External Script Editor deve ter o valor Mono Develop
(build-in). Como pode ser visualizado na Figura 39.

Figura 39: Janela MonoDevelop Unity 3D
Para criar um Script é necessário acessar a barra de menu -> Assets ->
Create -> C# Script. Assim que o Script for criado, um nome deverá ser
associado a ele.
Para vincular o Script a um determinado objeto, siga os seguintes passos:

 Selecione o GameObject
 Vá na janela (view) Inspector
 Aperte o Botão Add Component
 Selecione Scripts
 Escolha o Script que você quer adicionar no GameObject e
selecione.

Esses passos podem ser visualizados na Figura 40:
Figura 40: Adicionando um Script em um GameObject
Estrutura de um Script C#
No Exemplo 1, adiante, pode ser visualizado a estrutura de um Script C#

no Unity.
using UnityEngine;
using System.Collections;
public class Movimentacao : MonoBehaviour {
// Use this for initialization
void Start () {
// Update is called once per frame

void Update () {
}
}
Exemplo 1: Estrutura básica de um Script C#
É possível visualizar nas duas primeiras linhas, que o Unity importa as

bibliotecas básicas.
Depois é possível visualizar a classe, e que ela estende de MonoBehavior

(public class Movimentacao : MonoBehaviour). Todo o Script que possui
uma classe que herda de MonoBehavior pode ser adicionado como
componente de um GameObject. Quando isso acontece uma nova instância
da classe é criada.
Existem dois métodos na classe, o método Updade, onde deve ser colocado
todo o código que será executado a cada frame, ou seja a cada atualização
da lógica do jogo. Nesse método é onde é criado os códigos para ações,
entrada do usuário, movimentação do personagem e dos objetos do jogo,
onde é tratado toda a lógica que ocorre durante o jogo. O Outro método é
o Start, esse método é chamado antes do jogo começar ou seja, antes do
método Updade começar a ser chamado. Nesse método deve ter todo tipo
inicialização do jogo.
Programação de Comportamentos Básicos
Translação (Mover)
O Exemplo 2, a seguir, ilustra como uma translação pode ser realizada no
Unity 3D.
using UnityEngine;
public class Transladar : MonoBehaviour {

public float velocidade;
void Start () {
this.velocidade = 2;
}

void Update () {
this.transform.Translate (0,0,velocidade*Time.deltaTime);
}
}
Exemplo 2: Translação de um Objeto
No Exemplo 2, é possível visualizar que foi criado um atributo velocidade

do tipo float (real), esse atributo irá armazenar a velocidade de translação
(Movimentação) do GameObject. Dentro do método Start o atributo
velocidade está recebendo o valor 2 (this.velocidade = 2;).
Outra maneira de atribuir um valor em uma variável pública (public) é

passando o valor pela janela (view) Inspector. Quando uma variável pública
é declarada em um Script e o Script for atribuído em um GameObject, essa
variável aparece como propriedade do Script na janela (view) Inspector.
Para isso, não é necessário atribuir um valor na variável dentro do método
Start. É importante saber que isso só pode ser realizado se o atributo estiver
declarado com o modificador de acesso public. Na Figura 41, pode ser
visualizado a propriedade velocidade no componente Script Transladar.

Figura 41: Propriedade velocidade no Script Transladar
No método Update está o cálculo de movimentação do objeto através do

método Translate do componente transform do GameObject
(this.transform.Translate (0,0,velocidade*Time.deltaTime);). É
importante observar que o transform no código, acessa o componente
Transform do GameObject que o Script estiver vinculado.
O método Translate no código, acessa as posições x, y, z, respectivamente,

da propriedade Position do componente. O que está sendo feito é: está
sendo colocado no x do Position o valor 0, o y do Position o valor 0 e o z do
Position está o valor da velocidade multiplicado pelo time.DeltaTime, que é
uma propriedade que regula o cálculo independente da taxa de atualização.
Se essa propriedade não for colocada, cada máquina com hardware
(processador, placa de vídeo, memória) diferente pode calcular a
movimentação de forma diferenciada.
Dessa forma o GameObject irá se movimentar para frente no eixo Z.

Rotação
O Exemplo 3, adiante, mostra como uma rotação pode ser realizada no
Unity 3D.
using UnityEngine;
public class Rotacao : MonoBehaviour {
public float velocidade;

void Start () {
this.velocidade = 2;
}

void Update () {
this.transform.Rotate (0,0,velocidade*Time.deltaTime);
}
}
Exemplo 3: Rotação de um Objeto
No Exemplo 3, é possível visualizar que foi criado um atributo velocidade

do tipo float (real), esse atributo irá armazenar a velocidade de rotação do
GameObject. Dentro do método Start o atributo velocidade está recebendo
o valor 2 (this.velocidade = 2;). No método Update está cálculo de rotação
do objeto através do método Rotate do componente transforme do
GameObject (this.transform.Rotate(0,0,velocidade*Time.deltaTime);).
É importante observar que o Rotate no código, acessa o componente
Transform do GameObject que o Script estiver vinculado.
O método Rotate no código, acessa as posições x, y, z, respectivamente,

da propriedade Rotation do componente. O que está sendo feito é: está
sendo colocado no x do Rotation o valor 0, o y do Rotation o valor 0 e o z
do Rotation está o valor da velocidade multiplicado pelo time.DeltaTime,
que é uma propriedade que regula o cálculo independente da taxa de
atualização. Se essa propriedade não for colocada, cada máquina com

hardware (processador, placa de vídeo, memória) diferente pode calcular a
movimentação de forma diferenciada.
Na Figura 42, é possível visualizar a atualização do cálculo de rotação no

componente transform do GameObject.
Figura 42: Rotacionando um Objeto
Na Figura 42, é possível visualizar que o único valor (x,y,z) que atualiza na
propriedade transform do GameObject é o z. Dessa forma o objeto irá
rotacionar apenas no eixo z.
Seguir
Para fazer um GameObject seguir outro GameObject é necessário utilizar a
subtração de vetores e a normalização, para que o perseguidor possua a
direção do alvo. Depois que o GameObject perseguidor obter a direção do
alvo é somente realizar o algoritmo de movimentação em direção ao alvo.
Como pode ser visualizado na Figura 43.
Figura 43: GameObject perseguindo outro

O Exemplo 4 abaixo, exemplifica como é código do GameObject
perseguidor:
using UnityEngine;
public class Perseguidor : MonoBehaviour {

public GameObject alvo;
public float speed;
void Start () {
alvo = GameObject.Find ("Alvo");
}

void Update () {
Vector3 direcao = alvo.transform.position - this.transform.p
osition;
Vector3 velocidade = direcao.normalized * speed;
this.transform.Translate (velocidade * Time.deltaTime);
}
}
Exemplo 4: Código GameObject Perseguidor
No Exemplo 4, é possível visualizar as seguintes informações:
1. A classe “Perseguidor” herda as características da Superclasse MonoBehavior

(public class Perseguidor : MonoBehaviour), dessa forma esse Script
poderá ser vinculado a qualquer GameObject do Unity.
2. Para encontrar o GameObject que será perseguido, no nosso caso o alvo, é

declarado um atributo do tipo GameObject e com o identificador alvo
(public GameObject alvo;).
3. No método Start é usado a método Find, do objeto GameObject para encontrar

o GameObject “Alvo” que é passado por parâmetro no método
(alvo = GameObject.Find ("Alvo");
). O método Find irá procurar algum GameObject com o nome “Alvo”, na janela
(view) Hierarchy do projeto Unity, se ele encontrar, atribui ele no atributo alvo.
4. No método Update é realizado a subtração de vetores para encontrar a direção

entre o GameObject perseguidor e o alvo
(Vector3 direcao = alvo.transform.position - this.transform.pos
ition;). Depois esse vetor é normalizado para que tenha magnitude 1, pois
queremos apenas a sua direção e não o seu tamanho. No momento do cálculo
de normalização, o vetor normalizado é multiplicado pela atributo speed, para
que seja definido a velocidade de movimentação
(Vector3 velocidade = direcao.normalized * speed;). Por fim, o
método Translate do componente transform é utilizado para que o GameObject
possa se mover em direção do alvo
(this.transform.Translate (velocidade * Time.deltaTime);).
Como o valor do atributo speed não está sendo atribuído dentro do

método Start e ele está sendo declarado com o modificador acesso public
é possível definir o seu valor pela janela (view) Inspector na propriedade
speed do componente do Script Perseguidor, como pode ser visualizado
na Figura 44. Lembrando que para acessar essa propriedade o Script
precisa está vinculado ao GameObject que será o perseguidor.
Figura 44: Atribuição dos atributos públicos do Script Perseguidor
Na Figura 44, é possível visualizar que o valor da propriedade speed é

2.
Para testar o comportamento perseguir, crie um projeto no Unity e siga

os seguintes passos.
1. Criar um GameObject plane (plano) na posição (0,0,0).
2. Criar um GameObject cube com o nome Perseguidor na posição
(-4, 0.5, 4.0).
3. Criar um GameObject cube com o nome Alvo na posição (4, 0.5,
4.0).
4. Alterar a posição da Main Camera para (0,3,-8) e a Rotação em
(13,0,0)
5. Criar um Script C# Perseguidor na pasta Assets da janela (view)
Project e colocar o código do Exemplo 4.
6. Apertar o play para visualizar o comportamento Perseguir na
janela (view) Game.
7. Se necessário, criar uma pasta Scene e salvar a cena do projeto
com o nome Main.
Na Figura 45, pode ser visualizado todos os passos realizados.
Perseguidor
Figura 45: Projeto exemplo do comportamento perseguir
Atirar
No comportamento atirar, iremos aprender a criar projéteis em tempo
de execução e movimentá-los no cenário. Para isso é necessário saber o
conceito de prefabs do Unity 3D.
Um prefab é um GameObject pré-fabricado, ou seja, é um GameObject

que é criado na janela (view) Hierarchy com todos os seus componentes
e depois salvos na janela (view) Project, para que se transforme em um

asset e seja chamado em tempo de execução no jogo através de Scripts.
Na Figura 46 é possível visualizar a criação de prefab.
Figura 46: Criando um prefab
É possível visualizar na Figura 46, que o GameObject “tiro” está na janela

(view) Hierarchy. Para criar o prefab “tiro”, basta arrastá-lo para pasta
Assets da janela (view) Project. Veja que, no caso da Figura 46, ele foi
arrastado para a pasta Prefabs, que está na pasta Assets da janela (view)
Project, e isso deixa o projeto mais organizado, pois todos os Assets, que
podem ser músicas, imagens, cenas, texturas, prefabs, entre outros, ficam
cada um na sua respectiva pasta.
Para exemplificar esse comportamento, será criado o Script do GameObject

atirador que pode ser visualizado no Exemplo 5 abaixo:
using UnityEngine;
public class Atirador : MonoBehaviour {

public Rigidbody prefabTiro;
public Transform localTiro;
public float speed;
void Start () {

void Update () {
if (Input.GetKeyDown (KeyCode.Space)) {
Rigidbody tiro = Instantiate (prefabTiro,localTiro.trans
form.position,Quaternion.identity) as Rigidbody;
tiro.velocity = this.transform.right * speed;
}
}
}
Exemplo 5: Código GameObject Atirador
No Exemplo 5 é possível visualizar as seguintes informações:
1. São declarados três atributos, um Rigidybody prefabTiro, um Transform

localTiro e um float speed.
a. O objeto do tipo Transform recebe o componente Transform de um

GameObject e permite o programador manipular suas propriedades no
código, ou seja, manipular o position, rotation e scale no código.
b. O objeto do tipo Rigidbody recebe o componente Rigidbody de um

GameObject e pode manipular os atributos do componente no código.
2. Para atirar é verificado se a tecla Espaço foi pressionada. Essa verificação é

realizada a partir do método GetKeyDown do objeto Input. Esse método recebe
o código da tecla que se deseja verificar
(Input.GetKeyDown (KeyCode.Space)).
3. Se a tecla for pressionada, é criado uma instância em tempo de execução de

um prefabTiro (bala) a partir do método Instantiate na posição de um
GameObject na Cena
(Instantiate (prefabTiro,localTiro.transform.position,Quaternio
n.identity) as Rigidbody;). O “as Rigidbody” significa que o objeto
retornado pelo Instatiate vai ser convertido em um Rigidbody. Depois um objeto
"tiro” do tipo Rigidbody recebe o componente Rigidybody do GameObject
Instanciado

(Rigidbody tiro = Instantiate (prefabTiro,localTiro.transform.p
osition,Quaternion.identity) as Rigidbody;).
4. Por fim, é atribuído à propriedade velocity do Rigidbody da bala o Vector3 Right

(1,0,0) multiplicado pelo atributo speed
(tiro.velocity = this.transform.right * speed;).
Também será criado o Script que será vinculado ao prefab que será o
projétil da bala. Esse Script pode ser visualizado no Exemplo 6 abaixo:
using UnityEngine;
public class Tiro : MonoBehaviour {

void Start () {

void Update () {
void OnBecameInvisible(){
Destroy (this.gameObject);
}
}
Exemplo 6: Código GameObject Tiro
No Exemplo 6 é possível visualizar as seguintes informações:
1. O método OnBecameInvisible, que destrói o GameObject que estiver com esse

Script vinculado a ele, assim que ele sair do campo de visão da MainCamera
(void OnBecameInvisible(){Destroy (this.gameObject);}).
Para testar o comportamento atirar, crie um projeto no Unity e siga os

seguintes passos:

1. Criar um GameObject plane (plano) na posição (0,0,0).
2. Criar um GameObject cube na posição (-4, 0.5, -4) e mudar o seu
nome para atirador.
3. Criar uma pasta chamada Prefabs, na pasta Assets da janela
(view) Project.
4. Criar uma pasta chamada Scene, na pasta Assets da janela (view)
Project.
5. Criar um GameObject Sphere com a escala (0.2, 0.2, 0.2) e mudar
o seu nome para tiro. Adicionar o componente Rigidbody e no
componente Rigidbody tirar a seleção da propriedade Use Gravity
(dessa forma o objeto não vai sofrer influência da gravidade),
como pode ser visualizado na Figura 47:
Figura 47: Propriedade Use Gravity não selecionada
6. Na pasta Assets, criar um Script C# chamado Atirador com o

código do Exemplo 5.
7. Na pasta Assets, criar um Script C# chamado Tiro com o código
do Exemplo 6. Como pode ser visualizado na Figura 48:

Figura 48: Scripts Atirador e Tiro
8. Vincular o Script Tiro com o GameObject tiro

9. Arrastar o GameObject tiro para a pasta Prefabs, como pode ser
Figura 49: Prefab tiro
10. Deletar o GameObject tiro da janela (view) Hierarchy, pois

agora ele será criado em tempo de execução.
11. Criar um GameObject filho para o GameObject Atirador, o nome
do GameObject Filho será localTiro e será posicionado um pouco
mais à direita do GameObject Atirador. O GameObject Filho ficará
vinculado ao GameObjet Atirador (GameObject pai). Para criar um
GameObject Filho selecione o Atirador e aperte o botão direto.
Como queremos apenas a posição do GameObject filho para

posicionar a saída das balas, selecione Create Empty. Como pode
ser visualizado na Figura 50.
Figura 50: Criando GameObject Filho para Atirador
12. Mudar o nome do GameObject filho criado para localTiro e

posicionar ele um pouco mais à direita do GameObject atirador.
Isso pode ser realizado selecionando o GameObject localTiro na
janela (view) Scene e arrastando ele para a direita, como pode ser
visualizado na Figura 51:

Figura 51: Criação do GameObject filho localTiro
13. Vincular o Script Atirador com o GameObject Atirador

14. Arrastar para a propriedade Prefab Tiro do componente Script
Atirador o prefab tiro que está na pasta Prefabs. Como pode ser
observado na Figura 52.
Figura 52: Arrastando prefab tiro para propriedade Prefab Tiro
15. Arrastar para a propriedade Local Tiro do componente Script

Atirador o prefab GameObject filho localTiro. Como pode ser
observado na Figura 53.
Figura 53: Arrastando GameObject filho localTiro para propriedade Local Tiro
16. Atribuir o valor 10 a propriedade Speed do Componente Script

Atirador.
17. Apertar o play e fique pressionando a tecla Espaço para
visualizar o comportamento Atirar na janela (view) Game.
18. Salvar a cena na pasta Scene com o nome Main.
Aula 5:
Formas de Interação
No Unity existem várias formas de se capturar a entrada do usuário, entre
elas estão: teclado, mouse, touch, joystick etc.
Entrada do Usuário por Teclado:

Para capturar as teclas digitadas pelo usuário no teclado, pode ser utilizado
os métodos estáticos GetKey, GetKeyDown e GetKeyUp presentes na classe
Input. Cada um desses métodos recebe o código da tecla como parâmetro.

 GetKey: retorna true enquanto a tecla estiver sendo pressionada
 GetKeyDown: retorna true se a tecla for pressionada no frame atual
 GetKeyUp: retorna true se a tecla foi solta durante o frame atual
No Exemplo 7 abaixo, pode ser visualizado o uso das funções para captura
de eventos do teclado:
using UnityEngine;
public class Teclado : MonoBehaviour {

void Start () {

void Update () {
if (Input.GetKey (KeyCode.A)) {
print ("A Tecla A está sendo pressionada");
}
if(Input.GetKeyDown(KeyCode.Space)){
print ("A tecla espaço foi pressisonada");
}
if(Input.GetKeyUp(KeyCode.Space)){
print ("A tecla espaço foi solta");
}
}
}
Exemplo 7: Uso das funções para captura de eventos do teclado
No exemplo 7, é possível visualizar que no método Update da classe

“Teclado” estão os métodos de captura de evento do teclado. Também é
possível observar que a partir da classe Keycode é possível obter todos os
códigos das teclas do teclado e esse código é passado por parâmetro nos
métodos.

Entrada do Usuário por Mouse:
Para o mouse a classe Input do Unity possui os métodos:
 mousePosition: para pegar a posição do mouse na tela;

 GetMouseButton: retorna true enquanto algum botão do mouse for
pressionado;
 GetMuseButtonDown: retorna true se algum botão do mouse for
pressionado durante o frame atual;
 GetMouseButtonUp: retorna true se algum botão do mouse for
solto durante o frame atual.
Os métodos GetMouseButton, GetMouseButtonDown e GetMouseButtonUp

recebem um inteiro como parâmetro para indicar qual botão do mouse deve
ser verificado. Se o valor 0 for passado como parâmetro está indicando o
botão esquerdo, se o valor for 1, o botão direito e se o valor passado for 2,
está indicando o botão central.
No Exemplo 8 abaixo, pode ser visualizado o uso das funções para captura
de eventos do mouse:
using UnityEngine;
public class Mouse : MonoBehaviour {

void Start () {
print (Input.mousePosition);
}

void Update () {
if (Input.GetMouseButton (0)) {
print ("Botão esquerdo está sendo clicado!");
}
if (Input.GetMouseButtonDown (1)) {
print ("Botão direito clicado!");
}
if (Input.GetMouseButtonUp (2)) {
print ("Botão do meio solto!");
}
}
}
Exemplo 8: Uso das funções para captura de eventos do mouse
No exemplo 8, é possível visualizar que no método Start da classe “Mouse”

está sendo impresso a posição do mouse, ou seja a posição somente será
impressa uma vez. Já no método Update da classe “Mouse” estão os
métodos de captura de evento do mouse.
Também é possível no Unity a detecção de entrada do usuário por Joysticks,

telas sensíveis ao toque (touch), por acelerômetro e giroscópio.
Para o teclado, mouse e joystick, o Unity fornece uma forma genérica de

acesso à entrada do usuário através do InputManager, que pode ser
acessado e configurado acessando a barra de menu -> Edit -> Project
Settings -> Input. A partir dessa janela é possível configurar os eixos (axis)
e botões (button) para serem usados no jogo. Como pode ser visualizado a
Figura 54.

Figura 54: InputManager Unity
Dessa forma um botão pode ser configurado para alguma tecla do teclado,
algum botão do joystick ou botão do mouse.
Para acessar os eixos e botões fornecidos pelo InputManager é necessário

usar os métodos GetAxis e GetButton. Com eles é possível capturar a
entrada do usuário independentemente do dispositivo que ele esteja
utilizando. Observando a Figura 54 é possível visualizar que vários eixos e
botões estão pré-configurados.

Aula 6:
Simulação Física 3D
Em um jogo 3D a detecção de colisão é fundamental. Com ela é possível

verificar se dois GameObjects estão colidindo, é possível controlar a
velocidade de um GameObject, é possível aplicar força em um GameObject,
é possível aplicar torque em um GameObject, entre outras coisas.
Geralmente a engine física está vincula a game engine, ou pode ser uma
biblioteca separada, que para ser utilizada precisa ser importada. No caso
do Unity 3D, a engine de física já está vinculada.
Para trabalhar com física no Unity 3D é importante conhecer o conceito de

corpo rígido. Um corpo rígido (rigidbody) não se deforma com o impacto.
Para simular um rigidbody no Unity 3D é necessário adicionar o componente
Rigidbody a o GameObject.
O componente Rigidbody possui várias propriedades, como pode ser

Figura 55: Componente Rigidbody
Na Figura 55, é possível visualizar as várias propriedades do componente

Rigidbody:
 Mass: Massa do objeto

 Drag: Resistência do Objeto. Quanto maior o valor da propriedade
Drag, maior a resistência do objeto. O objeto pode ficar mais devagar
(maior valor da propriedade Drag) ou mais rápido (menor valor de
propriedade Drag).
 Angular Drag: Controla a resistência da rotação do GameObject.

Quanto maior o valor da propriedade Angular Drag maior a
resistência.
 Use Gravity: Informa se o GameObject vai ser afetado pela

gravidade ou não. Se o checkbox estiver selecionado, o objeto será
afetado pela gravidade, se o checkbox não estiver selecionado, o
objeto não será afetado pela gravidade.
 Is Kinmatic: Informa se o objeto será afetado ou controlado pela

engine física. Se o checkbox estiver selecionado ele será um
GameObject estático e não será afetado pela engine física.
 Interpolate: Seleciona e controla o tipo de interpolação do

GameObject.
 Collision Detection: Controla o tipo de colisão do GameObject. O

padrão é o valor Discrete. O valor Continuos é usado quando um
GameObject com grande velocidade colide com um GameObject
estático. O valor Continuos Dynamic é usado quando um GameObject
com muita velocidade colide com o GameObject que também possui
rigidybody.
 Constraints: Com essa propriedade é possível congelar (manter) a

posição e a rotação em qualquer eixo do plano cartesiano.
Quando o GameObject estiver com o componente Rigidbody, não é

aconselhável move-lo através do componente Transform. Se um
GameObject com componente rigidybody for movimentado ou rotacionado
a partir dos métodos do componente Transform (Translate e Rotate), pode
acontecer comportamentos inesperados.
Colisões
As colisões são muito importantes em um jogo. Com ela é possível verificar
se dois GameObjects entraram em contato. Independente da forma do
GameObject, o que define sua forma são os colisores. Como pode ser
visualizado nas Figuras 56 e 57.
Figura 56: Collider Unity 3D
Figura 57: Tipos de Collider no Unity 3D
Na Figura 57, é possível visualizar que o unity possui vários tipos de collider,
para revestir o GameObject e detectar a colisão, são seles, Character
Collider, Box Collider, Sphere Collider, Capsule Collider, Mesh Collider,
Wheel Collider e Terrain Collider. Os colliders podem ser adicionados ao

GameObject a partir dos componentes. Como pode ser visualizado na
Figura 58.
Figura 58: Exemplo componente Box Collider
Para verificar a colisão entre dois GameObjects diferentes é verificar se os

colisores de cada GameObject estão em contato. No Unity 3D essa
verificação possui três estados. Como pode ser visualizado na Figura 59.
Figura 59: Estados que uma colisão pode possuir
Na Figura 59, é possível visualizar os estados que uma collider pode possuir
no momento de uma colisão.
 Enter: Esse estado verifica o momento da colisão entre dois

GameObjects

 Stay: Verifica se o GameObject continua em colisão com outro
GameObject
 Exit: Verifica quando a colisão acabou. Esse estado é atribuído

quando a colisão acaba.
Os três estados de uma colisão são verificados automaticamente pelo Unity

3D. No entanto, os Scripts podem manipular esses estados através dos
métodos, OnCollisionEnter, OnCollisionExit e OnCollisionEnter. Esses
métodos podem ser utilizados para verificar a colisão através do Script e se
necessário realizar alguma ação.
Os métodos recebem como parâmetro um objeto do tipo Collision, que

possui diversas informações sobre a colisão, como por exemplo: direção,
velocidade, com qual objeto ocorreu a colisão, entre outros. Também é
possível acessar os atributos do objeto que ocorreu a colisão.
No exemplo 9, é possível observar um exemplo de um código

implementando os métodos de detecção de colisão.
using UnityEngine;
public class Colisores : MonoBehaviour {

void Start () {

void Update () {
void OnCollisionEnter(Collision col){

print ("Enter");
}
void OnCollisionStay(Collision col){
print ("Stay");
}
void OnCollisionExit(Collision col){

print ("Exit");
}
Exemplo 9: Exemplo dos métodos de detecção de colisão.
No Exemplo 9, é possível visualizar que os três métodos de verificação de

colisão foram implementados na classe “Colisores”. Quando uma colisão
acontecer com o GameObject vinculado a esse Script os três estados
poderão ser verificados. Assim que a colisão acontecer o método
OnCollisionEnter será chamado e será impresso a mensagem “Enter”;
enquanto a colisão continuar, será impresso a mensagem “Stay” e se a
colisão encerrar e os dois objetos de separarem será impresso a mensagem
“Exit”.
Se a propriedade “Is Trigger” do componente Collider for selecionado, os

objetos que estiverem fazendo parte da colisão não sofrem efeito físico, ou
seja, os objetos passam direto um pelo outro, no entanto, continuam
detectando a sua colisão. Esses Colliders são chamados de Trigger
(gatilhos). Podem ser usados para detectar a colisão com armadilhas no
jogo.
Para detectar esse tipo de colisão gatilho o Unity 3D fornece três métodos,
são eles: OnTriggerEnter, OnTriggerStay e OnTriggerExit. Eles recebem
como parâmetro um objeto do tipo Collider, que também fornece
informações sobre as colisões, como, por exemplo, direção, velocidade,
com qual objeto ocorreu a colisão, entre outros. No Exemplo 10 é possível
visualizar um exemplo do código para verificação de colisão gatilho.
using UnityEngine;
public class Triggers : MonoBehaviour {

void Start () {

void Update () {
void OnTriggerEnter(Collider col){

print ("Enter");
}
}
Exemplo 10: Exemplo dos métodos de detecção de colisão gatilho.
No Exemplo 10, é possível visualizar o método OnTriggerEnter. Esse

método irá verificar o momento que o GameObject que estiver com esse
Script vinculado, realizar uma colisão gatilho com algum outro GameObject.
Assim que a colisão acontecer, o método OnTriggerEnter será chamado e a
mensagem “Enter” será impressa. Lembrando que os dois GameObjects
precisam estar, também, com os componentes Colliders. E o que for realizar
a colisão gatilho deve estar com o checkbox “Is Trigger” selecionado.
Adicionando Força
Para manipular cálculos de física, o Unity fornece um método chamado

FixedUpdate. O método FixedUpdate se assemelha ao método Update,
porém é executado a uma taxa constante, em sincronia com a engine física.
O método Update é executado a uma taxa variada a cada frame, o que, em
alguns casos, torna uma má opção para cálculos de física. Esse método
pode ser visualizado no Exemplo 11:
void FixedUpdate(){
}
Exemplo 11: Método FixedUpdate

Para adicionar força a um GameObject, a classe Rigidbody no Script fornece
um método chamado AddForce. Que recebe um vetor (Vector3) como
parâmetro para fornecer a magnitude e a direção da força. No Exemplo 12,
é possível visualizar o código para adicionar força a um GameObject.
using UnityEngine;
public class Fisica : MonoBehaviour {

void Start () {

void Update () {
void FixedUpdate(){
Vector3 forca = new Vector3 (0,10,0);
this.gameObject.GetComponent<Rigidbody> ().AddForce (forca);

}
}
Exemplo 12: Exemplo para adicionar força a uma GameObject
No Exemplo 12, é possível observar que dentro do método FixedUpdate

está sendo instanciado um vetor “forca” com direção e tamanho 10 no
eixo y (Vector3 forca = new Vector3 (0,10,0);). Depois, a partir do
método GetComponent<Rigidbody>, está sendo pego o componente
Rigidbody do GameObject que estiver vinculado ao Script e adicionando
uma força ao GameObject a partir do método AddForce, sendo passado
como parâmetro o vetor “forca” instanciado
(this.gameObject.GetComponent<Rigidbody> ().AddForce (forca);).

Adicionando Torque
Para adicionar torque a um GameObject, a classe Rigidbody no Script

fornece um método chamado AddTorque. Que recebe um vetor (Vector3)
como parâmetro para fornecer a magnitude e a direção do torque. No
Exemplo 13, é possível visualizar o código para adicionar torque a um
GameObject.
using UnityEngine;

void Start () {

void Update () {
void FixedUpdate(){
Vector3 torque = new Vector3 (0,10,0);
this.gameObject.GetComponent<Rigidbody> ().AddTorque (torque

);
}
}
Exemplo 13: Exemplo para adicionar torque a uma GameObject
No Exemplo 13, é possível observar que dentro do método FixedUpdate

está sendo instanciado um vetor “torque” com direção e tamanho 10 no
eixo y (Vector3 torque = new Vector3 (0,10,0);). Depois, a partir do
método GetComponent<Rigidbody>, está sendo pego o componente
Rigidbody do GameObject que estiver vinculado ao Script e adicionando
um torque ao GameObject a partir do método AddTorque, sendo passado
como parâmetro o vetor “torque” instanciado

(this.gameObject.GetComponent<Rigidbody> ().AddTorque (torque);
).
Controlando Velocidade
Para controlar a velocidade de um GameObject a partir do componente

Rigidbody é necessário acessar através de Script a propriedade velocity do
Rigidbody.
No Exemplo 14, é possível visualizar um código que controla a velocidade

de um GameObject.
using UnityEngine;
Vector3 forca;
public float speed;
void Start () {
forca = new Vector3 (0,100,0);
}

void Update () {
float h = Input.GetAxis ("Horizontal");
if (Input.GetKeyDown (KeyCode.Space)) {
this.gameObject.GetComponent<Rigidbody> ().AddForce (for
ca);
}
this.gameObject.GetComponent<Rigidbody> ().velocity = new Ve

ctor3 (speed * h,0,0);
}
}
Exemplo 14: Exemplo para controlar a velocidade do GameObject

No Exemplo 14 é possível visualizar várias informações:
 A declaração de um vetor com nome “forca” (Vector3) para armazenar a direção

e magnitude da força (Vector3 forca;).
 A declaração de um atributo do tipo real para armazenar a velocidade
(public float speed;).
 Dentro do método Start está sendo instanciado o vetor “forca”
(forca = new Vector3 (0,100,0);).
 Dentro do método Update está sendo pego o valor entre 1 e -1 gerado pelo
clique das teclas esquerda e direita do teclado
(float h = Input.GetAxis ("Horizontal");).
 Está sendo verificado se a tecla espaço está sendo pressionada
(Input.GetKeyDown (KeyCode.Space)).
 Se tecla espaço for pressionada, o componente Rigidbody do GameObject que
o Script estiver vinculado será usado para adicionar uma força no eixo y do
GameObject
(this.gameObject.GetComponent<Rigidbody> ().AddForce (forca);).
 Por fim, será alterado a cada frame o atributo velocity do componente
GameObject. O atributo velocity é um vetor que possui a direção e a magnitude
da velocidade do corpo rígido. A cada frame, o atributo velocity está sendo
alterado por um novo vetor a partir do valor pego pelo eixo x e multiplicado
pelo speed
(this.gameObject.GetComponent<Rigidbody> ().velocity = new Vect
or3 (speed * h,0,0);).
Aula 7:
Programação de Menus
Para programar Menus no Unity 3D é necessário entender sobre os

GameObjects de Interface de Usuário (UI). O Unity já fornece vários
GameObjects pré-prontos de UI. Entre eles estão: Text (texto), Image
(Imagem), Button (Botão), ScrollBar, Input Field, Canvas, entre outros.
Para exemplificar o uso de um Menu no Unity, vamos criar um exemplo com

uma cena chamada “Main” que possui dois botões (Start, Quit). No
momento em que o usuário aperta o botão Start, ele é direcionado para
outra cena chamada “Level1”. Se o botão “Quit” for pressionado ele encerra
a aplicação.

Para criar o exemplo, siga as Instruções abaixo:
 Crie um Projeto no Unity 3D.

 Crie uma pasta chamada Scene, na pasta Assets da janela (view) Project.
 Salve a cena com o nome “Main” na pasta Scene.
 Crie outra cena a partir da barra de menu -> File -> New Scene.
 Salve a outra cena na pasta Scene, com o nome “Level1”.
 Clique duas vezes na cena “Main” salva na pasta Scene.
 Adicione o GameObject Canvas na janela (view) Hierarchy. Para isso acesse a
barra de menu -> GameObject -> UI -> Canvas.
o O Canvas é um container que irá agrupar todos os GameObjects do tipo
UI. Nele é possível configurar algumas propriedades como posição dos
GameObjects e reconfiguração do tamanho dos GameObjects com
relação a mudança de resolução.
Na Figura 60, é possível visualizar a criação do GameObject Canvas.
Figura 60: Criação do GameObject Canvas
 Depois que o GameObject Canvas for criado é necessário criar os botões Start
e Quit. Para criar os botões, selecione o GameObject Canvas e aperte com o
botão direito -> UI -> Button. O botão será criado como GameObject filho do
Canvas, ou seja, irá ser adicionado dentro do Canvas.
 Crie dois botões como GameObject filho de Canvas. Mude seus nomes para
Start e Quit. Como pode ser visualizado na Figura 61.
Mudar o nome
Exemplo 61: Adicionando botões no canvas
 Mude o texto relativo a cada botão. Para isso, expanda o botão na janela (view)
Hierachy selecionando a setinha que está do lado de cada botão. Assim que a
setinha for selecionada será apresentado o GameObject Text. Selecione o
GameObject Text; acesse o componente Text (Script) e mude o nome dos
botões (Start e Quit).
 Crie um Script C# na pasta Assets, chamado “GerenciadorBotoes” e cole o
código do Exemplo 15.
using UnityEngine;
using UnityEngine.SceneManagement;
public class GerenciadorBotoes : MonoBehaviour {
public void botaoStart(){

SceneManager.LoadScene ("Level1");
}
public void botaoQuit(){

Application.Quit ();

}
}
Exemplo 15: Exemplo de controle dos botões
No Exemplo 15, é possível visualizar que uma nova classe foi importada
usando o using (using UnityEngine.SceneManagement;). A classe
SceneManager, possui a função de gerenciar as cenas e as transições entre
elas. No método botaoStart, a classe SceneManager usa o método
LoadScene para carregar uma nova cena. O método LoadScene possui como
parâmetro o nome da nova cena que será carregada
(SceneManager.LoadScene ("Level1");). No método botaoQuit é chamado o
método Quit da classe Application, que possui o objetivo de finalizar a
aplicação (Application.Quit ();).
 Voltando ao nosso projeto, vincule o Script do Exemplo 15 a Main Camera.
Como pode ser visualizado na Figura 62.
Figura 62: Vinculando o Script a Main Camera
 Selecione o botão Start e acesse o evento On Click () do componente Button

(Script) na janela Hierarchy. Como pode ser visualizado na Figura 63. O evento
OnClick() é chamado quando o botão é clicado.

Figura 63: Evento OnClick Button
 Aperte o botão “+” do evento OnClick e aperte o círculo do lado da caixa de

adicionar GameObject que irá aparecer. Na janela que abrir, selecione o
GameObject Main Camera que está com o Script “GerenciadorBotoes”. Como
pode ser visualizado na Figura 64.
Figura 64: Selecionar Main Camera
 Depois selecione o Script “GerenciadorBotoes” no lugar do No Function e

selecione o método botaoStart, para ser chamado quando o botão for
pressionado.
 Selecione o botão Quit e realize a mesma operação para adicionar uma ação no
botão. No entanto selecione o método botaoQuit. Como pode ser visualizado
na Figura 65.

Figura 65: Selecionando os métodos a partir da Main Camera
 Para testar a aplicação é necessário adicionar as cenas no build do projeto. Para

fazer isso selecione uma cena e acesse a barra de ferramenta de menu -> Build
Settings... e aperte o botão Add Open Scene. Fazer isso com as duas cenas.
Para deixar os botões independentes de resolução, é necessário usar a

ancora do Canvas. Todo o GameObject UI possui uma âncora no Canvas. A
âncora precisa ser colocada ao redor do GameObject UI. Como pode ser
Figura 66: Âncora com o botão start

Aula 8:
Animação 3D
Para manipular a animação de objetos 3D o Unity utiliza um sistema de

animação chamado Mechanim para controlar as animações. Essa
ferramenta utiliza o conceito de máquina de estados para controlar cada
animação (parado, correndo, andando, assobiando, entre outras) de um
GameObject.
Antes de começar a trabalhar com a animação de modelos 3D, é importante

conhecer alguns termos, entre eles estão:
 Humanoide
o É um modelo 3D que possui uma estrutura parecida com um humano,
ou seja, uma estrutura bípede que possui o corpo, braços, pernas e
cabeça. Como pode ser visualizado na Figura 67.
Figura 67: Estrutura Bípede
 Rigging
o É processo ou a definição de um esqueleto para um modelo 3D, depois
que o modelo 3D for modelado é necessário criar o seu rigging para que
ele seja animado. O esqueleto de um modelo 3D é criado em um
software especializado em modelagem 3D, como 3DSMax, Blender,
Maya, entre outros. Na Figura 68 é possível visualizar o rigging de um
objeto 3D.

Figura 68: Rigging de um objeto 3D
Para exemplificar a animação de um objeto 3D no unity3D vamos importar

alguns modelos 3D prontos feitos pela unity. Para isso, acesse no browser
o site da asset store do unity (https://www.assetstore.unity3d.com/en/) e
procure pelo asset “Mecanim Example Scenes”. Assim que aparecer aperte
no botão “Open in Unity”, para que os assets sejam importados para o Unity
3D. É importante que você tenha uma conta na Asset Store. Na Figura 69
é possível visualizar o asset.
Figura 69: Assets de modelos 3D criados pelo Unity
Assim que o botão for clicado, a asset store irá abrir na aplicação do Unity
3D. Assim que abrir no Unity, aperte o botão “Import”. Depois que os
arquivos forem importados no Unity 3D várias pastas irão aparecer na pasta
Assets da janela (view) Project. Como pode ser visualizado na Figura 70.

Figura 70: Assets de exemplos e modelos 3D importados
Para nosso exemplo vamos utilizar o modelo 3D de Teddy, que pode ser
encontrado acessando a pasta Characters -> Teddy. Dentro da pasta é
possível visualizar o modelo 3D de Teddy (Uso). Selecionando o modelo 3D
e visualizando a janela (view) Inspector é possível visualizar as
propriedades do modelo 3D. Como pode ser visualizado na Figura 71.

Figura 71: Propriedades de um modelo 3D
É possível visualizar na Figura 71 que as propriedades do modelo 3D é

dividido em três tipos, são eles: Model, Rig e Animations.
 Model: O modelo contém as propriedades de para ajustar escala, compressão,

mapas e normais e materiais do mesh do modelo.
 Rig: Controla as propriedades do Rigging do modelo 3D. Possui propriedades
como: Animation Type (None, Legacy, Generic e Humanoid)
o None: O modelo 3D não possui rigging.
o Legacy: Define que o modelo será animado usando um antigo sistema
de animação chamado Legacy.
o Generic: Define que o modelo possui um rigging, mas não é parecido
com um humano. Pode ser algum animal.
o Humanoid: Define que o modelo possui uma estrutura parecida com a
de um humano e possui um esqueleto que será usado para a animação.
No caso do nosso exemplo, Teddy possui um rigging humanoide.

 Animations: Controla a animação criada no software de modelagem 3D e foi
importada junto ao modelo 3D para a Unity.
Se Animations estiver selecionado é possível visualizar as propriedades da

animação. São elas:
 Import Animation: se essa propriedade estiver selecionada será possível
controlar as propriedades da animação.
 Anim. Compression: informa o tipo de compressão que o Unity irá utilizar
para comprimir a animação.
 Rotation Error, Position Error, Scale Error: é o limite de erro que pode
acontecer em cada animação.
Se Teddy estiver selecionado é possível visualizar uma propriedade

chamada Clips e dentro dela está a animação de Teddy (Take 001).
Apertando “play” na janela de visualização da animação é possível visualizar
que a animação da propriedade Clips possui um conjunto de animação e
não apenas uma. Como pode ser visualizado na Figura 72.
Figura 72: Animação Uso Teddy

Para separar as animações é necessário acessar a linha de tempo que
está logo abaixo da propriedade Clips. Como pode ser visualizado na
Figura 73.
Figura 73: Linha de Tempo da Animação
Para isso selecione a animação “Take 001” da janela Clips e posicione o

final da linha de tempo da animação no tempo 0:25. Como pode ser
Figura 74: Linha de tempo da animação com tempo final
Depois de colocar o final da linha de tempo na posição 0:25, aperte o

botão “+” da janela Clips, para que uma nova animação seja criada.
Mude o nome da animação para andando, pois esse intervalo de tempo
pertence a animação andando do modelo 3D. Como pode ser visualizado
na Figura 75:

Figura 75: Nova animação criada
Abaixo da linha de tempo possui uma propriedade “Loop Time”. A função

dessa propriedade é deixar a animação em loop enquanto estiver sendo
realizada. Selecione essa opção para deixar o personagem sempre
andando. Como pode ser visualizado na Figura 76, a seguir:
Figura 76: Propriedade Loop Time da animação
Com a animação “Andando” configurada, agora é necessário criar o controle

dessa animação no Mechanim. Para isso, é necessário criar na pasta Assets
da janela (view) Project um “Animator Controller”. Como pode ser

Figura 77: Criando Animator Controller
Depois de criar o Animator Controller arraste o modelo do urso Teddy para

a janela (view) scene e posicione ele nas coordenadas (0,0,0), com a
rotação (0,180,0). Para que ele fique de frente para a Main Camera do
projeto. Depois coloque o valor -3 no eixo z da Main Camera.
Arraste o Animator Controller para o Controller do componente Animator

que está na janela (view) Inspector do urso Teddy. Como pode ser

Figura 78: Posicionando o Animator Controller.
Quando o Animator Controller for posicionado, o modelo 3D poderá ser

controlado pela máquina de estados que será criada no Animator Controller
para fazer a transição de estados da animação.
Clicando duas vezes no Animator Controller é possível visualizar a janela de

controle de estados. Ela já possui três estados, Entry, Any State e Exit.
Agora é necessário arrastar a animação andando de Teddy, separada
anteriormente para dentro da janela (view) Animator que controla a
animação. Como pode ser visualizado na Figura 79.

Figura 79: Configurando o Animator Controller
Na Figura 79, é possível visualizar que a animação “Andando” criada e

arrastada para a janela (view) Animator é considerada como um estado.
Ou seja, ela faz parte dos estados de animação. Também é possível
visualizar que possui uma seta ligando o estado “Entry” e o estado
“Andando”, isso quer dizer que assim que o jogo começar a animação passa
do estado inicial para o estado andando. Any State, significa qualquer
estado e Exit significa que a máquina de estados deverá ser encerrada.
Para visualizar o urso Teddy mudando de animação, basta apertar o botão

play, na barra de configurações. Como pode ser visualizado na Figura 80.

Figura 80: Animação do Urso Teddy
É possível visualizar que enquanto o botão play estiver pressionado, o urso

Teddy irá mudar do seu estado “Entry” para Andando e continuará nesse
estado até o jogo acabar.
Dessa forma é possível compreender que, para controlar a animação de um

personagem 3D, é necessário criar vários estados, tais como Andando,
Parado, Pulando, Correndo, entre outros, e fazer a transição entre cada um
deles no jogo.
Referências
BLACKMAN, S. Beginning 3D game development with unity: all-in-one,
multi-platform game development. Apress, 2011.
GIBSON, J. Introduction to game design, prototyping, and

development: from concept to playable game-with unity and C#. Pearson
Education, 2014.

GOLDSTONE, W. Unity 3.x game development essentials. Packt
Publishing, 2011.

Multi Plata Form A

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Multi Plata Form A

Enviado por

Direitos autorais:

Formatos disponíveis

Desenvolvimento

Introdução ao Desenvolvimento de Jogos 3D

Jogos 3D são jogos que utilizam modelos tridimensionais para representar

Matematicamente, um jogo 3D usa os três eixos do plano cartesiano para

Diversas habilidades em diferentes áreas do conhecimento, são necessárias

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 2

Um tipo especial de ferramenta, conhecida como game engine (motor de

O desenvolvimento de um jogo é divido em várias fases, sendo elas:

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 3

 Programadores: encarregados por desenvolver o software do jogo;

Como pode ser verificado, a equipe de desenvolvimento de um jogo é

O game design é onde se encontra as características principais do jogo,

Com o design document pronto, o gerente de projeto tem a noção do

Em alguns projetos de pequeno porte (como jogos puzzle, por exemplo), o

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 5

Com esse planejamento para projetos maiores é necessário elaborar o level

Antes de começar a parte de desenvolvimento os artistas, junto com os

As empresas acabam definindo metas e versões intermediárias, de acordo

Em cada etapa novos protótipos são construídos e a jogabilidade testada.

Com isso, o desenvolvimento do projeto de jogo se torna constante, até

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 6

É observado que no ciclo de desenvolvimento de um jogo a divisão de

Essa disciplina irá focar no desenvolvimento de jogos 2D, mais

Matemática Vetorial para Jogos

O uso da geometria, trigonometria e física, podem resultar em cálculos,

Na grandeza escalar os valores desses cálculos são representados

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 7

Figura 2: Exemplo de vetores

Na Figura 2, podemos observar vários exemplos da utilidade de um vetor:

O entendimento da matemática vetorial é um ponto importante para uso

A representação de vetor em um plano cartesiano tridimensional é feita por

Adiante são abordadas algumas propriedades e operações com vetores:

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 8

O módulo ou magnitude é um número real não negativo que representa o

Vetor Unitário (Normalização) e Versor

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 9

Para normalizar um vetor, precisamos dividi-lo pelo valor de sua magnitude.

Figura 4: Operação de Soma de Vetores

Na Figura 4, é possível visualizar que a soma do vetor u (1.46, 3.82) com

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 10

Figura 5 – Operação de subtração de vetores

Na Figura 5, é possível visualizar que a subtração do vetor u (1, 3) com o

Nos jogos, a subtração de dois vetores é muito utilizada para determinar

Multiplicação por Escalar

Nessa apostila iremos utilizar a engine Unity 3D para desenvolver os jogos.

É importante realizar o download da versão personal. Pois, nessa versão

Algumas vantagens de usar o Unity 3D para o desenvolvimento de jogos:

 Possui uma documentação completa, repleta de manuais,

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 12

Figura 6: Área de Trabalho do Unity

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 13

Figura 7: Barra de ferramentas do Unity

Na Figura 7, é possível observar que mais à esquerda da barra de

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 14

É importante saber que o layout (forma que as views são distribuídas na

O Unity organiza os arquivos em cenas (Scene). Cada cena, possui um

Na janela Hierarchy fica organizado todos os objetos de determinada cena.

Para entender melhor a composição de uma cena 3D no Unity, vamos criar

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 15

Figura 8: Janela de Login do Unity 3D

Na Figura 8, é possível visualizar que assim que o Unity é executado é

DESENVOLVIMENTO MULTIPLATAFORMA DE JOGOS 16

Na Figura 9, pode ser visualizado a partir das numerações as seguintes

Para criar um novo projeto é necessário apertar no botão “New”. Na Figura