O documento é um guia básico sobre a Unity 3D, um motor de jogos que facilita o desenvolvimento de jogos para várias plataformas. Ele aborda a interface da Unity, incluindo a navegação, a organização de assets, a criação de cenas e gameobjects, além do uso de componentes e scripts. O conteúdo é dividido em tópicos que ensinam desde a importação de elementos até a publicação de builds.

1. 18/5/2011
Fonte: http://unity3d.com/support/documentation/Manual/User%20Guide.html
Jennifer de Sousa Freitas – GameDevelopers Brasil
#GDB MINICURSO UNITY 3D BÁSICO
Em parceria com:

2. 1
Conteúdo
1. Bom, o que é a Unity?...................................................................................................................................................3
1. Aprendendo a Interface............................................................................................................................................4
Primeira navegação.......................................................................................................................................................4
Project View (Visão do Projeto)....................................................................................................................................4
Hierarchy View (Visão da Hierarquia)...........................................................................................................................6
Parenting(Paternização)............................................................................................................................................6
ToolBar (Barra de Ferramentas) ...................................................................................................................................7
Scene View....................................................................................................................................................................7
Navegação da Scene View ........................................................................................................................................8
Posicionando GameObjects......................................................................................................................................9
Control Bar(Barra de controle) do Scene View.........................................................................................................9
Game View (Visão do Jogo).........................................................................................................................................10
Play Mode (Modo de execução) .............................................................................................................................10
Inspector(Inspetor) .....................................................................................................................................................11
Prefabs ....................................................................................................................................................................16
Outras Views...............................................................................................................................................................16
2. Fluxo de trabalho dos Assets. .................................................................................................................................17
Criar o Asset Bruto......................................................................................................................................................17
Importar......................................................................................................................................................................17
Import Settings............................................................................................................................................................17
Adicionando um Asset à cena.....................................................................................................................................17
Colocando Assets diferentes juntos............................................................................................................................17
Criando um Prefab......................................................................................................................................................17
Alterando Assets.........................................................................................................................................................18
Opcional – Adicionando rótulos a seus Assets............................................................................................................18
Notas:......................................................................................................................................................................18
3. Criando Scenes........................................................................................................................................................19
Instanciando Prefabs...................................................................................................................................................19
Adicionando Components e Scripts............................................................................................................................19
Colocando GameObjects.............................................................................................................................................19
Trabalhando com Câmeras .........................................................................................................................................19
Lights...........................................................................................................................................................................19

3. 2
4. GameObjects...........................................................................................................................................................20
O que são GameObjects..............................................................................................................................................20
O Relacionamento GameObject-Component.............................................................................................................20
O Component Transform ........................................................................................................................................20
Outros Components................................................................................................................................................21
Usando Components...............................................................................................................................................21
Adicionando Components.......................................................................................................................................22
Editando Components ............................................................................................................................................23
Testando Propriedades...........................................................................................................................................24
Removendo Components .......................................................................................................................................25
O relacionamento Component-Script.........................................................................................................................25
Usando Scripts ........................................................................................................................................................25
Criando novos Scripts..............................................................................................................................................25
Anexando Scripts a GameObjects...........................................................................................................................26
Manipulando do GameObject.................................................................................................................................28
O poder das variáveis..............................................................................................................................................28
Acessando outros Components ..............................................................................................................................29
Para onde ir a partir daqui......................................................................................................................................30
5. Publicando Builds(Construções) .............................................................................................................................31
6. Conclusão................................................................................................................................................................32

4. 3
1. Bom, o que é a Unity?
A Unity 3D é um motor de jogos (game engine) que possibilita o desenvolvimento de jogos. Assim como toda game
engine ou 3D engine, ela facilita o desenvolvimento de jogos pelo fato de o desenvolvedor não precisar programar
diretamente para DirectX ou OpenGL, pois ela já faz isso para você.
A Unity pode fazer jogos para produtos da Apple (Mac, IPhone, IPod, IPad), da Microsoft (Xbox, Windows), da Google
(Celulares com Android), da Sony (Playstation 3), da Nintendo (Wii) e para Navegadores Web (Internet Explorer,
Mozilla Firefox, Google Chrome, Opera e Safari).
Além dessa portabilidade, a Unity possui uma grande quantidade de ferramentas e é muito fácil de trabalhar com
ela, pois além de ser visual(não apenas baseada em código como a Irrlicht, por exemplo) a interface é bastante
amigável. Ela possui uma ferramenta de script baseada no Mono (ferramenta para desenvolver e executar aplicações
.NET cliente e servidor em diferentes plataformas), possibilitando a programação em C#, Javascript e Python.
A Unity também permite a criação de Shaders com a linguagem SharderLab,Cg da NVidia, GLSL para o OpenGL e
trabalha também com Shader Mode. O subsistema de simulação física é o PhysX, também da NVidia. Ela usa
também bibliotecas Direct X, Open GL para renderização 3D e OpenAL para áudio.
Outro ponto forte da Unity é a importação de arquivos. Ela importa em vários formatos, tanto 2D quanto 3D o que
exclui o trabalho de ter que exportar alguma arte antes de importar na Unity. Ela aceita os arquivos dos seguintes
programas:
Blender: .blend
Autodesk 3DS Max: .max
Autodesk Maya: .mb or .ma
Maxon CINEMA 4D: .c4d
Cheetah3D: .jas
Luxology Modo 3D: .lxo *a partir do modo 501
NewTek LightWave: é necessário exportar para .fbx utilizando o plugin para exportar para fbx do LightWave.
Unity também lê arquivos .FBX, .dae, .3DS, .dxf e .obj. também aceita o .collada. Para arquivos de textura (arquivos
2D) ele aceita os formatos: PSD, TIFF, JPG, TGA, PNG, GIF, BMP, IFF, PICT.
A Unity3D além dessas características é free apesar de ter a versão Pro que é um preço não tão fora da realidade.

5. 4
1. Aprendendo a Interface
Primeira navegação
Vamos começar aprendendo a interface da Unity. Se você não tiver aberto a Unity ainda, você pode encontra-la
dentro de Iniciar  Programas  Unity no Windows, ou Aplicações  Unity no Mac. O Editor da Unity irá
aparecer. Não tenha pressa para examinar a interface do Editor da Unity e se familiarizar com ela. A Janela Principal
do Editor é composta de várias abas chamadas de Views(Visões). Há vários tipos de Views na Unity, cada uma com
um propósito específico.
Project View (Visão do Projeto)

6. 5
Todo projeto Unity contém uma pasta de Assets (ativos). Os conteúdos dessa pasta são apresentados no Project
View. Este é onde você armazena todos os Assets que compõe seu jogo, como cenas, scripts, modelos 3D, texturas,
arquivos de áudio e Prefabs (Pré-fabricados). Se você clicar com o botão direito em qualquer Asset no Project View,
você pode escolher Reveal in Explorer – Mostrar no Explorer (Reveal in Finder – Mostrar no Localizador no Mac)
para realmente ver o asset mesmo em seu sistema de arquivos.
PS: Você nunca deve mover os assets do projeto através do Sistema Operacional, uma vez que irá quebrar todos os
metadados associados com o asset. Sempre use o Project View para organizar seus assets.
Para adicionar Assets para seu projeto, você pode arrastar qualquer arquivo de seu sistema operacional para dentro
do Project View, ou usar Assets  Import New Asset (Ativos  Importar Novo Ativo). Seu Asset agora está pronto
para ser utilizado em seu jogo.
Scenes (cenas) também são armazenados no Project View. Pense nelas como níveis individuais. Por exemplo, a
Islands Scene (cena da Ilha) é carregada por padrão quando a Unity é executada da primeira vez. Para criar uma nova
Scene, use Control – Ctrl– +N (Command+N no Mac). Para salvar a scene corrente dentro do Project View, use
Control – Ctrl– +S (Command+S no Mac).
Alguns Assets do jogo precisam ser criados de dentro da Unity. Para fazer isso, use a drop-down (caixa suspensa)
Create(Criar), ou botão direito  Create.
A caixa suspensa Create
Isso irá permitir que você adicione Scripts, Prefabs, ou Folders(pastas) para manter seu projeto organizado. Você
pode renomear qualquer Asset/Folder pressionando F2 no Windows, ou Enter no Mac, ou com dois cliques
espaçados no nome do Asset. Se você segurar a tecla Alt enquanto você expande ou contrai algum diretório, todos
os subdiretórios também serão expandidos ou contraídos.

7. 6
Hierarchy View (Visão da Hierarquia)
A Hierarchy contém todo GameObject (Objeto de jogo) na Scene corrente. Alguns desses são instâncias diretas de
arquivos de Assets como modelos 3D, e outros são instâncias de Prefabs – objetos customizados que irão compor
muito do seu jogo. Você pode selecionar e paternizar objetos na Hierarchy. Como objetos são adicionados e
removidos da Scene, eles irão aparecer e desaparecer da Hierachy também.
Parenting(Paternização)
Unity utiliza um conceito chamado Parenting. Para tornar um GameObject filho de outro, arraste o filho desejado
sobre o pai desejado na Hierarchy. O filho irá herdar o movimento e a rotação de seu pai. Você pode agora expandir
e contrair o pai para ver seus filhos na Hierarchy sem afetar seu jogo.
Dois objetos sem Pai
Um objeto Paternizado a outro

8. 7
ToolBar (Barra de Ferramentas)
A Barra de Ferramentas consiste em cinco controles básicos. Cada um refere-se a diferentes partes do Editor.
Ferramentas de Transformação: usadas com a Scene View.
Alternador de Gizmo de Transformação: afeta a tela no Scene View.
Botões Play/Pause/Step: utilizados com a Game View (Visão do jogo).
Caixa suspensa de camadas: controla quais objetos são mostrados na Scene View.
Caixa suspensa de Layout: Controles dispostos em todas as Views.
Scene View
The Scene View
A Scene View é sua caixa de areia interativa. Você irá utilizar a Scene View para selecionar e posicionar os
ambientes, o jogador, as câmeras, inimigos, e todos os outros GameObjects. Manobra e manipulação de objetos
dentro da Scene View são algumas das funções mais importantes da Unity, então é importante estar apto a fazê-los
rapidamente.

9. 8
Navegação da Scene View
Aqui está um breve resumo dos fundamentos de navegação da Scene View.
Segure o botão direito do mouse para entrar no modo Flythrough(Aéreo). Isso transforma seu mouse e as teclas
WASD (mais Q e E para cima e para baixo) em navegação rápida da visão de primeira pessoa.
Selecione qualquer GameObject e pressione a tecla F. Isso irá centralizar o ponto pivô (encontro dos eixos x, y, z no
centro do objeto) na Scene View.
Utilize as teclas de setas para mover em torno do plano X/Z.
Segure Alt e clique e arraste para girar a câmera em torno do pivô corrente.
Segure Alt e clique e arraste com o botão do meio para arrastar a Scene View em torno da câmera.
Segure Alt e clique e arraste com o botão direito para zoom na Scene View. É o mesmo que rolar a roda do mouse.
Você pode também achar utilidade na Hand Tool(Ferramenta Mão) (atalho Q), especialmente se você estiver
usando um mouse de um botão. Com a Hand Tool está selecionada,
Clique e arraste para arrastar em volta da câmera.
Segure Alt e clique e arraste para girar a câmera em torno do pivô corrente.
Segure Control – Ctrl (Command no Mac) e clique e arraste para zoom da câmera.
No canto superior direito do Scene View é o Scene Gizmo. Este mostra a atual orientação da câmera da Scene, e
permite que você modifique rapidamente o ângulo de visão.
Você pode clicar em qualquer um dos braços para encaixar a câmera da Scene para aquela direção e mudar ela para
o Isometric Mode (Modo Isométrico). Enquanto estiver no Isometric Mode, você pode clicar e arrastar com o botão
direito para girar, e Alt + clicar e arrastar para deslocar. Para sair desse modo, clique no meio do Scene Gizmo. Você
pode também utilizar Shift+Clicar no meio do Scene Gizmo a qualquer momento para alternar para o Isometric
Mode.

10. 9
Posicionando GameObjects
Aqui está um breve resumo dos fundamentos de posicionar GameObjects.
Quando você construir seus jogos, você irá colocar muitos objetos diferentes em seu game world(mundo do jogo).
Para fazer isso, utilize as Transform Tools na barra de ferramentas para mudar de posição, rotacionar e dimensionar
GameObjects individuais. Cada um tem um Gizmo correspondente que irá aparecer em torno do GameObject
selecionado na Scene View. Você pode usar o mouse e manipular qualquer eixo do Gizmo para alterar o componente
de Transformação do GameObject, ou você pode digitar os valores diretamente dentro dos campos numéricos do
componente de transformação no Inspector (Inspetor).
Control Bar(Barra de controle) do Scene View
A barra de controle do Scene View permite que você veja a Scene em vários modos de visão – Textured
(Texturizado), Wireframe (exibindo os polígonos dos modelos 3D), RGB (Cores RGB), Overdraw (Super desenhado), e
muitos outros. Ela também irá permitir que você veja (e ouça) em jogo, a iluminação, os elementos do jogo e som na
Scene View.

11. 10
Game View (Visão do Jogo)
O Game View é renderizado a partir da câmera do seu jogo. É a representação do seu jogo final, o jogo publicado.
Você irá precisar usar uma ou mais câmeras para controlar o que o jogador realmente está vendo quando eles estão
jogando seu jogo. Para falar mais sobre câmeras, ver o capítulo de câmeras.
Play Mode (Modo de execução)
Use os botões na barra de ferramentas para controlar o editor Play Mode e veja como seu jogo publicado irá
executar. Enquanto estiver no Play mode, algumas mudanças você pode fazer temporariamente, e serão reiniciadas
quando você sair do Play mode. O Editor UI irá escurecer para lembrar você disso.
Barra de controle Game View
A primeira caixa suspensa da barra de controle Game View é a Aspect drop-down (caixa suspensa de Aspecto). Aqui
você força a proporção da janela Game View para diferentes valores. Ele pode ser usado para testar como seu jogo
irá ser exibido em monitores de diferentes proporções.
Mais a direita é o alternador Maximize on Play (Maximizar durante o jogo). Enquanto estiver habilitado, o Game
View irá maximizar de 100% da sua janela do Editor para uma visualização legal em tela cheia quando você entrar
no Play mode.
Continuando a direita é o alternador Gizmos. Enquanto estiver habilitado, todos os Gizmos que aparecem na Scene
View irão também ser desenhados no Game View. Isso inclui Gizmos desenhados usando qualquer uma das funções
das classes de Gizmo.

12. 11
Finalmente nós temos o botão Stats(Estatísticas). Esse mostra a janela de estatísticas da renderização que é muito
útil para otimizar a performance dos gráficos.
Estatísticas da Game View de seu jogo
Inspector(Inspetor)

13. 12
Jogos na Unity são feitos de múltiplos GameObjects que contém meshes (malhas), scripts, sounds (sons), ou outro
elemento gráfico como Ligths(Luzes). O Inspector mostra informações detalhadas sobre o seu GameObject
selecionado no momento, incluindo todos os Components (Componentes) anexados a ele e suas propriedades.
Aqui, você pode mudar a funcionalidade dos GameObjects na sua Scene. Você pode mais sobre relacionamento
GameObject-Component, e é muito importante saber.
Qualquer propriedade que é mostrada no Inspector pode ser diretamente modificada. Mesmo variáveis de scripts
podem ser modificadas sem alteração do próprio script. Você pode usar o Inspector para mudar variáveis em tempo
de execução para experimentar e encontrar a jogabilidade ‘mágica’ do seu jogo. Em um script, se você define uma
variável pública de um tipo de objeto (como GameObject ou Transform), você pode arrastar e soltar um GameObject
ou Prefab dentro do Inspector para fazer a associação.

14. 13
Clique na interrogação do lado de qualquer nome de componente no Inspector para carregar sua página de
referência.
Adicionar Componentes a partir do menu Component
Você pode clicar no ícone da engrenagem pequena (ou botão direito no nome do componte) para apresentar um
menu de contexto para componente específico.

15. 14

16. 15
O Inspector irá também mostrar todo Import Settings (configuração de Importação) para o arquivo Asset
selecionado.
Clique em Apply (Aplicar) para reimportar seu Asset.

17. 16
Utilize a caixa suspensa Layer (Camada) para associar uma camada de renderização para o GameObject. Utilize a
caixa suspensa Tag para associar uma etiqueta a esse GameObject.
Prefabs
Se você tiver um Prefab selecionado, alguns botões adicionais estarão disponíveis no Inspector. Para mais
informações sobre Prefabs, vá até o capítulo de Prefabs.
Outras Views
As Views descritas acima aborda os conceitos básicos da Unity. As outras Views da Unity serão mostradas em
capítulos separados.

18. 17
2. Fluxo de trabalho dos Assets.
Aqui nós vamos explicar passo a passo como usar um Asset com a Unity. Esses passos são gerais e são apenas como
uma visão geral de ações básicas.
Criar o Asset Bruto
Use qualquer pacote de modelagem 3D suportado pela Unity (descritos no primeiro capítulo dessa apostila). Por
exemplo, você utilizará o 3D Max. Trabalhe com o Asset até você estar pronto para salvar.
Importar
Quando você salva um Asset inicialmente, você poderia salvar ele normalmente na pasta Assets na Pasta do seu
projeto. Quando você abre o projeto Unity, o Asset será detectado e importado dentro do projeto. Quando você
olhar na Project View, você verá o Asset localizado lá, exatamente onde você o salvou. Por favor, note que a Unity
usa o exportador FBX fornecido pelo seu pacote de modelagem para converter seus modelos para o formato FBX.
Você precisará ter o exportador FBX de seu pacote de modelagem disponível para Unity utilizar. Alternativamente,
você pode exportar como FBX de sua aplicação e salvar na pasta Projects.
Import Settings
Se você selecionar o Asset na Project View as Import Settings (Configurações de Importação) para esse Asset irão
aparecer no Inspector. As opções que serão mostradas irão mudar baseadas no tipo de Asset que está selecionado.
Adicionando um Asset à cena
Simplesmente clique e arraste o mesh (malha) do Project View para a Hierarchy ou Scene View para adicionar ele a
Scene. Quando você arrasta o mesh para a Scene, você está criando um GameObject (Objeto de Jogo) que tem um
Mesh Renderer Component (Componente de Renderização da Malha). Se você estiver trabalhando com uma
textura ou um arquivo de som, você terá que adicionar ele a um GameObject que já existe na Scene ou no Projeto.
Colocando Assets diferentes juntos
Aqui está uma breve descrição do relacionamento entre os Assets mais comuns.
Uma textura é aplicada a um Material.
Um material é aplicado a um GameObject (com um componente de Renderização da Malha).
Uma Animação é aplicada a um GameObject (com um componente de Animação).
Um arquivo de som é aplicado a um GameObject (com um Audio Source (Fonte de áudio)).
Criando um Prefab
Prefabs são uma coleção de GameObjects e Components que podem ser reutilizados em suas Scenes. Muitos
objetos idênticos podem ser criados a partir de um único Prefab, chamado instancing (instância). Pegue árvores
como exemplo. Criando um Prefab de árvore, permitirá que você instancie muitas árvores idênticas e colocar elas
em sua Scene. Porque as árvores estão todas ligadas ao Prefab, qualquer mudança que for feita no Prefab,
automaticamente será aplicado em todas as instâncias de árvores. Então, se você deseja mudar o mesh, o material,
ou qualquer outra coisa, basta você fazer a mudança apenas no Prefab e todas as outras árvores herdarão a

19. 18
mudança. Você também pode fazer mudanças em uma instância, e escolher GameObject -> Apply changes to
Prefab no menu principal. Isto pode te poupar muito tempo durante a configuração e alteração dos Assets.
Quando você tem um GameObject que contém múltiplos Components e uma Hierarchy de GameObjects filhos, você
pode fazer um Prefab de GameObject de nível superior (ou root – raiz), e reutilizar o conjunto completo de
GameObjects.
Para realmente criar um Prefab a partir de um GameObject da sua Scene, primeiro crie um novo Prefab em seu
Project View. Nomeie o novo Prefab como você desejar. Então, clique no GameObject na Scene que você deseja
transformar em Prefab. Arraste ele até o novo Prefab, e você poderá ver o texto do nome dos GameObjects mudar
para azul. Você tem agora um Prefab reutilizável.
Alterando Assets
Você importou, instanciou e ligou seu Asset a um Prefab. Agora, quando você quiser editar seu Asset fonte, apenas
dê duplo clique nele a partir do Project View. A aplicação adequada irá iniciar, e você poderá fazer qualquer
mudança que você quiser. Quando você estiver terminado de alterar ele, apenas o salve. Então, quando você
alternar para a Unity, a alteração será detectada, e o Asset será reimportado. A ligação do asset com o Prefab
também será mantida. Assim, o efeito que você verá é que seu Prefab será alterado. Isso é tudo que você precisa
saber sobre alteração de Assets. Apenas abra ele e salve.
Opcional – Adicionando rótulos a seus Assets
É sempre uma boa idéia adicionar rótulos a seus Assets se você deseja manter todos os seus assets organizados, com
isso você pode procurar pelos rótulos adicionados a cada asset no campo de pesquisa no Project View, ou no Object
Selector.
Passos para adicionar um rótulo a seu Asset
• Selecione o asset que você deseja adicionar o rótulo a ele (A partir da Project View)
• No Inspector clique no ícone “Add Label (Adicionar Rótulo) – – se você não tiver nenhum rótulo
associado a aquele Asset.
▪ Se você tiver um rótulo associado a um Asset então apenas clique onde o rótulo está.
• Comece escrevendo seus rótulos.
Notas:
Você pode ter mais de um rótulo para um para qualquer Asset.
Para separar/criar rótulos, apenas pressione espaço ou enter quando estiver escrevendo o nome do label do Asset.

20. 19
3. Criando Scenes
As Scenes contém os objetos de seu jogo. Elas podem ser usadas para criar um menu principal, fases individuais, e
qualquer outra coisa. Pense em cada um arquivo Scene como um único nível (fase). Em cada Scene, você irá colocar
seus ambientes, obstáculos e decorações, essencialmente desenhar e construir seu jogo em pedaços.
Instanciando Prefabs
Utilize o método descrito no capítulo anterior para criar um Prefab. Uma vez que você criou um Prefab, você pode
rápida e facilmente fazer cópias do Prefab, chamadas de uma Instância. Para criar uma instância de qualquer Prefab,
arraste o Prefab a partir do Project View para a Hierarchy ou Scene View. Agora você tem uma única instância de
seu Prefab para posicionar e ajustar como você desejar.
Adicionando Components e Scripts
Quando você tem um Prefab ou qualquer GameObject em destaque, você pode adicionar funcionalidades adicionais
a ele através do uso de Components. Scripts são um tipo de Component. Para adicionar um Component, apenas
destaque seu GameObject e selecione um Component a partir do menu Component. Você verá então o Component
aparecer na Inspector do GameObject. Scripts estão contidos também no menu Component por padrão.
Se ao adicionar um Component quebrar a conexão do GameObject com o Prefab, você pode sempre utilizar
GameObject  Apply Changes to Prefab (Aplicar alterações ao Prefab) do menu para restabelecer a conexão.
Colocando GameObjects
Uma vez que seu GameObject está na Scene, você pode usar as Transform Tools (Ferramentas de Transformação)
para posicionar ele onde quer que você queira. Adicionalmente, você pode utilizar os valores Transform no
Inspector para um ajuste fino de posicionamento e rotação.
Trabalhando com Câmeras
As Câmeras são os olhos do seu jogo. Tudo que o jogador verá quando estiver jogando é através de uma ou mais
câmeras. Você pode posicionar, girar, e adicionar um pai as câmeras assim como qualquer outro GameObject. Uma
câmera é apenas um GameObject com um Component de Câmera anexado a ele. Portanto ele pode fazer qualquer
coisa que um GameObject normal pode fazer, e então algumas funções específicas de câmera também. Há também
alguns scripts de câmera úteis que são instalados com o Pacote Standard Assets (Assets Padrão) quando você cria
um novo projeto. Você pode encontra-los em Components  Camera-Control do menu.
Lights
Exceto em alguns poucos casos, você sempre precisará adicionar Lights(Luzes) a sua Scene. Há três diferentes tipos
de Lights, e todas elas comportam um pouco diferente umas das outras. O que importa é que elas adicionem a
atmosfera e o ambiente ao seu jogo. Iluminações diferentes podem mudar completamente o humor do seu jogo, e a
utilização de Lights efetivamente será um assunto importante para aprender.

21. 20
4. GameObjects
GameObjects são os objetos mais importantes na Unity. É muito importante entender o que um GameObject é, e
como ele pode ser usado. Este capítulo vai explicar tudo isso para você.
O que são GameObjects
Cada objeto no seu jogo é um GameObject. No entanto, GameObjects não fazem nada sozinhos. Eles precisam de
propriedades especiais antes que eles possam se tornar um personagem, um ambiente, ou um efeito especial. Mas
cada um desses objetos faz muitas coisas diferentes. Se cada objeto é um GameObject, como podemos diferenciar
um objeto de power-up (adicionar poder) interativo de uma sala de estática? O que torna esses GameObjects
diferentes uns dos outros?
A resposta a esta pergunta é que GameObjects são recipientes. Eles são caixas vazias que pode conter diferentes
peças que compõem uma ilha com lightmap (mapa de luz) ou um carro com direção física. Assim para realmente
compreender GameObjects, você tem que entender essas peças; elas são chamadas de Components
(Componentes). Dependendo do tipo de objeto que você deseja criar, você irá adicionar diferentes combinações de
Components para o GameObject. Pense em um GameObject como uma panela vazia, e componentes como
diferentes ingredientes que compõem a sua receita de jogabilidade. Você também pode fazer seus próprios
Components usando Scripts.
O Relacionamento GameObject-Component
Conforme descrito anteriormente, um GameObject contém Components. Vamos explorar essa relação discutindo
um GameObject e seu Component mais comum - o Component Transform (Transformação). Com qualquer Scene
aberta na Unity, criar um novo GameObject (usando Shift-Control-N no Windows ou Shift-Command-N no Mac),
selecione-o e dê uma olhada no Inspector.
O Inspector de um GameObject vazio
Observe que um GameObject vazio ainda contém um nome, uma Tag (marca), e uma Layer (camada). Cada
GameObject também contém um Component Transform.
O Component Transform
É impossível criar um GameObject na Unity, sem um Component Transform. O Component Transform é um dos
componentes mais importantes, uma vez que todas as propriedades de transformação do GameObject são ativadas
pelo uso deste Component. Ele define a posição, rotação e escala do GameObject no mundo do jogo/Scene View. Se
um GameObject não tem um Component Transform, ele não seria nada mais do que algumas informações na
memória do computador. Ele efetivamente não existiria no mundo.
O Component Transform também permite um conceito chamado Paternidade, que é utilizado pelo do Unity Editor e
é uma parte critica do trabalho com GameObjects.

22. 21
Outros Components
O Component Transform costuma ser fundamental a todos os GameObjects, de modo que cada GameObject tem
um. Mas GameObjects podem conter outros componentes também.
A Câmera principal, adicionada a cada Scene por padrão.
Dando uma olhada no GameObject Main Camera (Câmera principal), podemos ver que ele contém uma coleção de
diferentes Components. Especificamente, um Component Camera, um GUILayer (Camada de interface com usuário),
uma Flare Layer (camada de reflexo), e um Audio Listener (ouvinte de áudio). Todos esses componentes fornecem
funcionalidades adicionais para o GameObject. Sem eles, não haveria nada de renderização dos gráficos do jogo para
a pessoa jogar! Rigidbodies (Corpos Rigidos), Colliders (colisores), Particles (partículas) e Audio (áudio) são todos os
diferentes Components (ou combinações dos mesmos) que podem ser adicionados a qualquer GameObject dado.
Usando Components
Os Components são as porcas e parafusos de objetos e comportamentos em um jogo. Eles são as peças funcionais
de cada GameObject.
O GameObject é um recipiente para muitos Components diferentes. Por padrão, todos os GameObjects
automaticamente têm um Component Transform. Isso ocorre porque o Transform determina onde o GameObject
está localizado, e como ele é girado e redimensionado. Sem um Component Transform, o GameObject não teria um
lugar no mundo. Tente criar um GameObject vazio agora como um exemplo. Clique no menu GameObject Create
Empty (Criar Vazio). Selecione o GameObject novo, e olhe para o Inspector.

23. 22
Até mesmo GameObjects vazios tem um Component Transform
Lembre-se que você sempre pode usar o Inspector para ver quais os Components estão ligados ao GameObject
selecionado. Como Components são adicionados e removidos, o Inspector vai sempre mostrar-lhe quais estão
anexados no momento. Você vai usar o Inspector para alterar todas as propriedades de qualquer componente
(incluindo scripts).
Adicionando Components
Você pode adicionar Components ao GameObject selecionado através do menu de Components. Vamos tentar isso
agora adicionando um Rigidbody ao GameObject vazio que acabamos de criar. Selecione-o e escolha
ComponentPhysicsRigidbody (Componente FísicaCorpo Rigido) no menu. Quando você o fizer, você vai
ver as propriedades do Rigidbody aparecem no Inspector. Se você pressionar Play enquanto o GameObject vazio
ainda está selecionado, você pode ter uma pequena surpresa. Experimente e observe como o Rigidbody tem
funcionalidade para o GameObject vazio. (O Component y do GameObject começa a diminuir. Isso ocorre porque o
engine física na Unity está fazendo o GameObject cair por causa da gravidade).
Um GameObject vazio com um Componente Rigidbody anexado
Você pode anexar qualquer número ou combinação de componentes a um GameObject único. Alguns Components
trabalham melhor em combinação com outros. Por exemplo, o Rigidbody funciona com qualquer Collider. O
Rigidbody controla a transformação através da engine física NVIDIA PhysX, e o Collider permite que o RigidBody
colida e interaja com outros colisores. Um outro exemplo de combinações de Components é um Particle System
(Sistema de partículas). Eles usam um Particle Emitter (Emissor de partículas), Particle Animator (Animador de
Partículas) e um Particle Renderer (Renderizador de partículas) para criar um grupo de partículas em movimento.
Se você quiser saber mais sobre como usar um Component específico, você pode ler sobre qualquer um deles na
Component Reference (Referência de Componentes) -
http://unity3d.com/support/documentation/Components/Components.html. Você também pode acessar a página
de referência para um Componente de Unity clicando no pequeno (?) no cabeçalho do Component no Inspector.

24. 23
Editando Components
Um dos grandes aspectos dos componentes é a flexibilidade. Quando você anexar um componente a um
GameObject, existem diferentes valores ou propriedades no Componente que podem ser ajustados no editor,
durante a construção de um jogo, ou por scripts durante a execução do jogo. Existem dois principais tipos de
propriedades: Valores e Referências.
Olhe a imagem abaixo. É um GameObject vazio, com um Audio Source (fonte de áudio). Todos os valores da fonte de
áudio no Inspector são os valores padrão.
Este Componente contém uma única propriedade Reference e sete propriedades Value. Audio Clip é a propriedade
Reference. Quando esta Audio Source (fonte de áudio) começa a tocar, ele tentará reproduzir o arquivo de áudio
que é referenciado na propriedade Audio Clip. Se nenhuma referência é feita, ocorrerá um erro porque não há

25. 24
nenhum áudio a ser tocado. Você deve fazer referência ao arquivo dentro do Inspector. Isso é tão fácil como arrastar
um arquivo de áudio do Project View para a propriedade Reference ou usando o Seletor de objeto.
Agora, um arquivo de efeito sonoro é referenciado na propriedade Audio Clip.
Os componentes podem incluir referências para qualquer outro tipo de Component, GameObjects, ou Asset.
O propriedades restantes no Audio Clip são todas as propriedades Value. Estes podem ser ajustados diretamente no
Inspector. As propriedades Value sobre o Audio Clip são todas alternáveis: valores numéricos, os campos drop-down,
mas as propriedades de valor também podem ser textos, cores, curvas, e outros tipos.
Testando Propriedades
Enquanto seu jogo está em modo de jogo, você está livre para alterar as propriedades no Inspetor de qualquer
GameObject. Por exemplo, você pode querer experimentar com diferentes alturas de salto. Se você criar uma
propriedade altura de salto em um script, você pode entrar em modo de jogo, alterar o valor e pressionar o botão de
salto para ver o que acontece. Então, sem sair do Play Mode você pode alterá-lo novamente e ver os resultados
dentro de segundos. Quando você sair do modo de jogo, suas propriedades voltarão aos valores pré-Play Mode, para

26. 25
você não perder nenhum trabalho. Esse fluxo de trabalho lhe dá um poder incrível para experimentar, ajustar e
aperfeiçoar o seu jogo sem investir muito tempo em ciclos de iteração. Experimente-o com qualquer propriedade
em Play Mode.
Removendo Components
Se você quiser remover um componente, opção - ou botão direito do mouse no seu cabeçalho no Inspector e
escolha Remover Componente. Ou você pode clicar no ícone das opções ao lado do ? no cabeçalho do componente.
Todos os valores da propriedade serão perdidos e isto não pode ser desfeito, portanto, tenha certeza absoluta de
que deseja remover o componente antes de o fazer.
O relacionamento Component-Script
Quando você cria um script e anexa-o a um GameObject, o script aparece no Inspector do GameObject apenas como
um componente. Isso ocorre porque os scripts se tornam componentes quando eles são salvos - um script é apenas
um tipo específico de Componente. Em termos técnicos, um script compila como um tipo de Componente, e é
tratado como qualquer outro componente da engine Unity. Então, basicamente, um script é um Componente que
você está criando para você mesmo. Você irá definir os seus membros para serem expostos no Inspector, e ele irá
executar qualquer funcionalidade que você escreveu.
Usando Scripts
Esta é uma breve introdução sobre como criar e utilizar scripts em um projeto. Scripts dentro da Unity são feitos
escrevendo simples scripts de comportamento em JavaScript, C #, ou Boo (Python). Você pode usar uma ou todas as
linguagens de script em um único projeto, não há nenhuma penalidade por usar mais de um.
Criando novos Scripts
Ao contrário de outros Assets, como mesh(malhas) ou textures (texturas), arquivos de script podem ser criados a
partir de dentro da Unity. Para criar um novo script, abrir AssetsCreateJavaScript (ou AssetsCreateC Sharp
Script ou AssetsCreateBoo Script) no menu principal. Isso irá criar um novo script chamado
NewBehaviourScript e colocá-lo na pasta selecionada no Project View. Se nenhuma pasta estiver selecionada no
Project View, o script será criado na raiz.

27. 26
Você pode editar o script clicando duas vezes sobre ele no Project View. Isso iniciará seu editor padrão selecionado
nas preferências da Unity. Você faz todo o seu script em um editor de texto externo, e não diretamente na Unity.
Para definir o editor de script padrão, alterar o item drop-down em UnityPreferencesExternal Script.
Estes são os conteúdos de um novo script de comportamento, vazio:
function Update () {
}
Um script novo e vazio não faz muito por conta própria, então vamos adicionar alguma funcionalidade. Altere o
script para ler o seguinte:
function Update () {
print("Hello World");
}
Quando executado, esse código irá imprimir "Hello World" para o console. Mas não há nada que faz com que o
código seja executado ainda. Temos que anexar o script a um GameObject ativo na Scene antes de ele ser
executado.
Anexando Scripts a GameObjects
Salve o Script acima e crie um novo objeto na Scene selecionando GameObject  Create Other  Cube. Isso irá
criar um novo GameObject chamado “Cube”(Cubo) na Scene atual.

28. 27
Agora arraste o Script do Project View para o Cubo (na Scene ou na Hierarchy View, não importa) Você também
pode selecionar o cubo e escolher ComponentScriptsNew Behaviour Script. Qualquer um desses métodos vão
anexar o Script ao Cubo. Todo Script que você criar vai aparecer no menu ComponentsScripts. Se você tiver
mudado o nome do seu Script, você verá aquele nome então.
Se você selecionar o Cubo e olhar para o Inspector, você verá que o seu Script está visível agora. Isso significa que
ele foi anexado.

29. 28
Pressione Play para testar sua criação. Você deveria ver o texto “Hello World” aparecendo ## dos botões
Play/Pause/Step. Saia do Play Mode quando você ver isso.
Manipulando do GameObject
Uma declaração print() pode ser muito útil ao depurar o script, mas não manipula o GameObject ao qual o Script é
anexado. Vamos mudar o script para adicionar algumas funcionalidades:
function Update () {
transform.Rotate(0, 5*Time.deltaTime, 0);
}
Se você é novo em fazer Scripts, está tudo bem se isso parece confuso. Estes são os conceitos importantes para
compreender:
1. function Update () {} é um recipiente de código que a Unity executa várias vezes por segundo (uma vez por
quadro).
2. transform é uma referência para o Component Transform do GameObject
3. Rotate() é uma função contida no Component Transform.
4. Os números entre as vírgulas representam os graus de rotação em torno de cada eixo do espaço 3D: X, Y e Z.
5. Time.deltaTime é um membro da classe Time que nivela o movimento ao longo de um segundo, então o
cubo vai girar na mesma velocidade, não importa quantos quadros por segundo a sua máquina está
renderizando. Portanto, 5 * Time.deltaTime significa 5 graus por segundo.
Com isso em mente, nós podemos ler esse código como “todo frame, gire o Component Transform do GameObject
um pequena quantidade que no caso é igual a cinco graus em volta do eixo Y a cada segundo.
Você pode acessar muitos Components diferentes da mesma maneira como já acessamos o Transform. Você tem
que adicionar componentes ao GameObject usando o menu Component.
O poder das variáveis
Nosso script até agora sempre roda o cubo 5 graus a cada segundo. Podemos querer que ele gire um número
diferente de graus por segundo. Poderíamos mudar o número e salvar, mas depois temos que esperar para o script
ser recompilado e temos que entrar no modo Play antes de vermos os resultados. Há uma maneira muito mais
rápida de fazê-lo. Podemos experimentar a velocidade de rotação em tempo real durante o modo de jogo, e é fácil
de fazer.
Em vez de digitar 5 para a função Rotate (), vamos declarar uma variável speed e usar isso na função. Alterar o script
com o seguinte código e salvá-lo:
var speed = 5.0;
function Update () {
transform.Rotate(0, speed*Time.deltaTime, 0);
}
Agora selecione o cubo e olhe para o Inspector. Observe como a nossa variável speed(velocidade) aparece.

30. 29
Esta variável agora pode ser modificada diretamente no Inspector, como renomear um arquivo no gerenciador de
arquivos. Selecione-o, pressione Enter e altere o valor. Você também pode usar o botão direito ou esquerdo do
mouse sobre o valor e arraste o mouse para cima ou para baixo. Você pode alterar a variável, a qualquer momento,
mesmo enquanto o jogo está sendo executado.
Clique em Play e tente modificar o valor da variável speed. A velocidade de rotação do cubo irá mudar
instantaneamente. Quando você sair do modo de jogo, você verá que suas alterações serão revertidas ao seu valor
antes de entrar no modo de jogo. Desta forma, você pode jogar, ajustar e experimentar para encontrar o melhor
valor, em seguida, aplicar esse valor permanente.
Usando este método de alterar o valor de uma variável no Inspector significa que você pode re-utilizar um script em
vários objetos, cada um com um valor variável diferente. Se você anexar o script para vários cubos, e mudar a speed
de cada cubo, todos eles vão girar em velocidades diferentes, apesar de usar o mesmo script.
Acessando outros Components
Ao escrever um componente de script, você pode acessar outros componentes do GameObject de dentro do script.
Usando membros GameObjects
Você pode acessar diretamente qualquer membro da classe GameObject. Se qualquer uma das classes indicadas
estão anexadas ao GameObject como um componente, você pode acessar o componente diretamente através do
script, basta digitar o nome do membro. Por exemplo, a digitar Transform é equivalente a gameObject.transform. O
gameObject é assumido pelo compilador, a menos que você especificamente referencie um GameObject diferente.
Digitando this estará acessando o componente de script que você está escrevendo. Digitando This.gameObject está
se referindo ao GameObject que o script está anexado. Você pode acessar o mesmo GameObject simplesmente
digitando gameObject. Logicamente, digitando this.transform é o mesmo que digitar Transform. Se você quiser
acessar um componente que não é incluído como membro GameObject, você tem que usar
gameObject.GetComponent ().
Há muitos Components que podem ser acessados diretamente em qualquer script. Por exemplo, se você quiser
acessar a função Translate do componente Transform, você pode escrever apenas transform.Translate () ou
gameObject.transform.Translate (). Isso funciona porque todos os scripts estão ligados a um GameObject. Então,
quando você escreve transformar você está implicitamente acessando o Component Transform do GameObject que
está ligado ao Script. Para ser mais explícito, você escreve gameObject.transform. Não há nenhuma vantagem em
um método sobre o outro, é tudo uma questão de preferência para o escritor.

31. 30
Usando GetComponent()
Há muitos componentes que não são referenciados diretamente como membros da classe GameObject. Então você
não pode acessá-los implicitamente, você tem que acessá-los explicitamente. Você pode fazer isso chamando o
GetComponent ("nome do Component") e armazenar uma referência para o resultado. Isso é muito comum quando
você quer fazer uma referência a outro script anexado ao GameObject.
Finja que você está escrevendo Script B e quer fazer uma referência a um script A, que é anexado ao mesmo
GameObject. Você teria que usar GetComponent () para fazer esta referência. Em Script B, você poderia
simplesmente escrever:
scriptA = GetComponent("ScriptA");
Então você iria conseguir acessar qualquer uma das variáveis do script A escrevendo scriptA.variableName no Script
B.
Para onde ir a partir daqui
Essa foi apenas uma breve introdução sobre como usar scripts dentro do Editor. Para mais exemplos, veja os
Tutorials que vêm com a Unity. Você também deve ler Scripting Overview dentro da Script Reference, que contém
uma introdução mais completa sobre scripts com a Unity mais indicações dentro da própria referência para
informações detalhadas. Se você estiver realmente perdido, não deixe de visitar o Unity Answers ou Unity Forums e
perguntar lá. Alguém está sempre disposto a ajudar.

32. 31
5. Publicando Builds(Construções)
Em qualquer momento enquanto você está criando seu jogo, você pode querer ver como ele parece quando você
construir e executar ele fora do editor como um jogo autônomo ou no WebPlayer. Essa sessão irá explicar como
acessar as Build Settings(Configurações de Construção) e como criar diferentes Builds de seus jogos.
File  Build Settings... é o item do menu para acessar a janela de configurações de Build. Ela mostra uma lista
editável de Scenes que serão incluídas quando você construir seu jogo.
A janela Build Settings
A primeira vez que você ver essa janela em um projeto, ela irá aparecer em vazia. Se você construir seu jogo
enquanto essa lista estiver vazia, apenas a Scene aberta no momento será incluída no Build. Se você desejar
construir rapidamente uma execução de teste com apenas um único arquivo Scene, bastar construir com a lista de
Scene vazia.
É fácil adicionar arquivos de Scene à lista para builds com mais de uma Scene. Há duas maneiras de adicionar elas. A
primeira maneira é clicar no botão Add current (Adicionar atual). Você verá a Scene aberta no momento aparecer
na lista. A segunda maneira é para adicionar arquivos de Scene é arrastar eles a partir do Project View para a lista.
Nesse ponto, observe que cada uma de suas Scenes tem um valor diferente de índice. Scene 0 é a primeira Scene
que será carregada quando você construir o jogo. Quando você desejar carregar uma nova Scene, utilize
Application.LoadLevel() dentro de seus scripts.

33. 32
Se você tiver adicionado mais de um arquivo de Scene e desejar reorganiza-los simplesmente clique e arraste para
cima ou para baixo de outras na lista até que você tenha colocado elas na ordem desejada.
Se você deseja remover uma Scene da lista, clique para destacar a Scene e pressione Delete. A Scene irá desaparecer
da lista e não será incluída no Build.
Quando você estiver pronto para publicar seu Build, selecione uma Platform (Plataforma) e assegure que a logo da
Unity ao lado da plataforma. Se não, então clique no botão Switch Platform (Alterar Plataforma) para deixar que a
Unity saiba para qual plataforma você quer construir. Finalmente pressione o botão Build (Construir). Você poderá
selecionar o nome e a localização do jogo usando uma janela de salvar arquivos padrão. Quando você clicar em Save
(Salvar) , Unity irá construir seu jogo prontamente. É muito simples. Se você não tem certeza onde você salvou o
jogo construído, considere que a Unity salvou ele dentro da pasta raiz de projetos. Você não pode salvar o Build
dentro da pasta Assets.
Habilitando o checkbox(caixa de seleção) Debug Build (Depurar Construção), qualquer executor autônomo irá
habilitar a funcionalidade Profiler. Além disso o jogo será construído com símbolos de depuração, de modo que você
pode usar perfis ou ferramentas de depuração de terceiros.
6. Conclusão
Essa apostila é apenas um resumo do conteúdo encontrado na própria documentação da Unity disponível no site:
http://unity3d.com/support/documentation/Manual/User%20Guide.html . Vários dos Tópicos citados na apostila e
que não estão nela, podem ser encontrados nesse link. A questão é que a documentação nesse site é em inglês, e o
que foi traduzido nessa apostila foram os tópicos Unity Básico e Usando Scripts. Que essa apostila ajude e qualquer
outra informação que não estiver aqui, basta acessar o User Guide no link acima.