Apostila unity3dv033

Unity3D
Uma introdução
Autor: Thiago Campos Viana

Unity3D
Uma introdução

Copyright © 2009 Thiago Campos Viana

São Carlos, SP – Brasil

thiagocamposviana@gmail.com

Creative Commons Attribution 3.0 Unported

Você pode:

• copiar, distribuir, exibir e executar a obra.
• criar obras derivadas.

Sob as seguintes condições

Atribuição — Você deve dar crédito ao autor original, da forma especificada
pelo autor ou licenciante.

Compartilhamento pela mesma Licença — Se você alterar, transformar ou
criar algo em cima deste trabalho, você deve distribuir o trabalho resultante
somente com uma licença igual, similar ou com compatível com esta.

Para maiores informações acesse:

http://creativecommons.org/licenses/by-sa/3.0/legalcode

Conteúdo
Lista de Imagens ............................................................................................................... 3
Lista de códigos ................................................................................................................ 3
1 Introdução ...................................................................................................................... 3
1.1 O que é o Unity 3D ................................................................................................. 3
1.2 Unity3D no Brasil ................................................................................................... 4
1.3 Exemplos de jogos .................................................................................................. 5
1.4 Um aviso ................................................................................................................. 7
1.5 Programas auxiliares............................................................................................... 7
1.6 Instalando o Unity no Windows ............................................................................. 8
2 Principais conceitos ..................................................................................................... 17
2.1 O ambiente do Unity3D........................................................................................ 17
2.1.1 Visão de Projeto ......................................................................................... 18
2.1.2 Hierarquia .................................................................................................... 19
2.1.3 Menu de Topo ............................................................................................ 20
2.1.4 Visão da Cena ............................................................................................ 21
2.1.5 Posicionamento de objetos ...................................................................... 21
2.1.6 Scene Gizmo .............................................................................................. 22
2.1.7 Barra de controle da cena ........................................................................ 23
2.1.8 Visão de jogo .............................................................................................. 23
2.1.9 Play Mode ................................................................................................... 24
2.1.10 Barra de controle da visão de jogo ....................................................... 24
2.1.11 Inspetor ..................................................................................................... 25
2.1.12 Barra de Status ........................................................................................ 27
2.1.13 Console ..................................................................................................... 27
2.2. Sistema de coordenadas 3D ................................................................................. 28
2.2.1. O plano cartesiano ........................................................................................ 28
2.2.2. Coordenadas locais e globais ........................................................................ 29
2.2.3. Vetores .......................................................................................................... 30
2.2.4. Quaterniões e rotações .................................................................................. 31
2.2.5. Renderização ................................................................................................ 31
2.2.6. Câmeras ........................................................................................................ 31
2.2.7. Representação de formas .............................................................................. 32
2.2.8. Materiais ....................................................................................................... 32
2.3. Física.................................................................................................................... 32
2.3.1. Corpos rígidos .............................................................................................. 32
2.3.2. Detecção de colisão ...................................................................................... 33
2.3 Conclusão ............................................................................................................. 33
3 Introdução ao Java Script ............................................................................................ 34
3.1 Seu primeiro programa ......................................................................................... 34
3.2 Variáveis e tipos de dados .................................................................................... 39
3.3 Declaração de variáveis e palavras reservadas ..................................................... 42
3.4 Operadores ............................................................................................................ 43
3.5 Comandos condicionais ........................................................................................ 46
3.6 Objetos, propriedades e métodos .......................................................................... 50
3.7 Comentários .......................................................................................................... 52
3.8 Isso não é tudo ...................................................................................................... 53
4 Terrenos ....................................................................................................................... 54

1

4.1 Utilizando Terrenos .............................................................................................. 54
4.1.1 Criando um novo Terreno......................................................................... 54
4.1.2 Navegando pelo terreno ..................................................................................... 56
4.1.3 Editando o Terreno ............................................................................................ 56

2

Lista de Imagens
Imagem 1 - Super Vôlei Brasil (Aquiris) ..................................................................... 4
Imagem 2 - Rally Touareg (Edgy) ............................................................................... 5
Imagem 3 - Rexona Race............................................................................................. 5
Imagem 4 - Fusion Fall ( Web MMORPG ) ............................................................... 6
Imagem 5 - JumpStart para Nintendo Wii.................................................................. 6
Imagem 6 - Zombieville (iPhone) ................................................................................ 7
Imagem 7 - Tela inicial do Unity ................................................................................ 18
Imagem 8 - Menu de Topo ......................................................................................... 20
Imagem 9 - Visão da Cena......................................................................................... 21
Imagem 10 - Visão de jogo ........................................................................................ 23
Imagem 11 - Estatística do jogo ................................................................................ 24
Imagem 12 - Console .................................................................................................. 28

Lista de códigos
Código 1 - Script inicial ............................................................................................... 37
Código 2 – Exemplo Ola ............................................................................................. 37
Código 3 – Exemplo gira cubo................................................................................... 39
Código 4 – Exemplo declaração de variável ........................................................... 40
Código 5 – Exemplo string ......................................................................................... 41
Código 6 – Exemplo if ................................................................................................. 46
Código 7 – Exemplo else ............................................................................................ 48
Código 8 – Exemplo while .......................................................................................... 49
Código 9 – Exemplo for .............................................................................................. 49
Código 10 – Exemplo break ....................................................................................... 50

3

Capítulo 1: Introdução

Capítulo

1
1 Introdução

B
em vindo à área de desenvolvimento de jogos de jogos com o Unity3D!
Em primeiro lugar gostaria de me apresentar, meu nome é Thiago
Campos Viana (thiagocamposviana@gmail.com) e deixar claro que esta
apostila foi criada de um hobbista para hobbistas. Não sou um desenvolvedor
de jogos profissional, tenho mais experiência com desenvolvimento web, mais
especificamente com o CMS eZ publish, porém adoro a área de jogos e
gostaria de compartilhar o pouco que sei sobre esta ferramenta de
desenvolvimento que possui uma versão gratuita, a Unity3D, e como não se
encontra apostilas em português sobre esta ferramenta, resolvi criar esta
apostila.

A apostila tem como público alvo todas as pessoas interessadas em
desenvolvimento de jogos 3D sem muita experiência com programação ou
com o Unity3D, assim, ao final da apostila espera-se que você esteja
preparado para iniciar seu primeiro projeto de um jogo 3D. Tentarei evitar ao
máximo termos muitos técnicos, pois gostaria de ver adolescentes de todas as
classes econômicas criando jogos nessa ferramenta assim como eles criam
vídeos para o site youtube.com com o Windows Movie Maker, pois quando eu
comecei a usar a internet em 2002, antes de começar o curso de bacharelado
em informática na USP de São Carlos eu era um desses adolescentes. Apesar
de tudo, será necessário para quem deseja se aventurar na área de
desenvolvimento um conhecimento mínimo de inglês.

Então, sem mais delongas, vamos começar a falar de desenvolvimento de
jogos com o Unity3D.

1.1 O que é o Unity 3D

O Unity3D é um programa de desenvolvimento com todos os recursos
necessários para desenvolver qualquer tipo de jogo em 3D que você possa
imaginar. Ele possui uma versão gratuita, que pode ser encontrada no link
http://unity3d.com/unity/download/, com a maioria das funcionalidades que um
desenvolvedor amador necessita para criar seus jogos e publicá-los como
programa para Windows ou em uma página web. Estes jogos para sites
funcionam de um modo parecido com os jogos ou animações para sites criados
em Flash, ou seja, é necessário que a pessoa instale um plugin para que eles
funcionem.

3


Esse plugin é um programa que é encontrado no link
http://unity3d.com/webplayer/ e funciona parecido com o plugin do Flash, ou
seja, você consegue jogar através do seu navegador, Internet Explorer, Firefox,
entre outros.

1.2 Unity3D no Brasil

Algumas empresas brasileiras já estão utilizando esta ferramenta em seus
projetos, um exemplo é Aquiris, empresa do sul do país,
http://www.aquiris.com.br/, que criou o jogo Super Voleibol Brasil,
http://www.supervoleibrasil.com.br/, imagem1. Esse jogo foi patrocinado pela
Olympikus e pode ser jogado diretamente pelo navegador. Além desse jogo a
Aquiris já trabalhou desenvolvendo jogos e programas para Embraer, GM,
Coca-Cola, Kibon entre outros.

Imagem 1 - Super Vôlei Brasil (Aquiris)

A Edgy, http://www.edgy.com.br/, que é uma empresa paulista, também
trabalha com a ferramenta e já criou vários projetos para montadoras de
automóveis, entre elas Chevrolet, Volkswagen, Peugeot, além de empresas de
outros segmentos, como é o caso das Casas Bahia.
Um exemplo de jogo que a empresa criou é o Rally Toureg,
http://www.vwbr.com.br/rally/game/, imagem 2.

4


Imagem 2 - Rally Touareg (Edgy)

Além dessas empresas, existem mais, como é o caso da CuboCC
(http://www.cubo.cc) e seu jogo para a Rexona
(http://www.rexona.com.br/xrace, imagem 3) e a Quantix Games
http://www.quantixgames.com, a qual não consegui encontrar um jogo
desenvolvido por ela, mas em seu site encontra-se uma referência ao Unity3D.

Imagem 3 - Rexona Race

1.3 Exemplos de jogos

A versão gratuita do Unity3D tem como foco amadores e pequenas empresas
desenvolvedoras de jogos, sendo quase impossível para nós, amadores, ou
essas pequenas empresas criarem jogos como um World of Warcraft ou um
FarCry, mas existem grandes empresas utilizando o Unity que criaram jogos
impressionantes.

5


Um deles é o MMORPG mais conhecido desenvolvido com o Unity3D é o
Fusion Fall, http://www.fusionfall.com, da Cartoon Network, ele é um jogo para
web com visual de desenho animado, imagem 4. Para desenvolver esse tipo de
jogo é necessário utilizar a licença profissional, a qual não é gratuita, mas aqui
serve como exemplo de um jogo grande, para centenas de jogadores. Para
jogos com poucos jogadores, cerca de 12, a versão gratuita é suficiente.

Imagem 4 - Fusion Fall ( Web MMORPG )

Além disso, existem licenças do programas, não gratuitas, que permitem
desenvolver jogos para o vídeo Nintendo Wii, como é o caso do JumpStart
(http://jumpstart.com/), imagem 5, e para iPhone, Zombieville, imagem 6. O
jogo Zombieville é simplesmente um dos jogos mais vendidos para iPhone,
chegando a ficar no topo da lista de mais vendidos.

Existe um plano da empresa criar uma licença para que se possa publicar os
jogos também para o Xbox 360, assim, se você criar um jogo que faça
sucesso, você tem a possibilidade de publicar para diversas outras
plataformas.

Imagem 5 - JumpStart para Nintendo Wii

6


Imagem 6 - Zombieville (iPhone)

1.4 Um aviso

Os jogos apresentados neste capítulo foram desenvolvidos por profissionais
que trabalham neles durante muito tempo e já possuem uma grande
experiência na área de desenvolvimento de jogos. Quando você começar a
desenvolver, não fique frustrado se seu jogo não parecer tão bom ou não
conseguir criar uma funcionalidade parecida com as dos jogos citados, com o
tempo você aprenderá a desenvolver jogos cada vez melhores e quem sabe
um dia faça parte do time de desenvolvimento de um grande jogo.

Outra a coisa a ser lembrada é que a versão gratuita da engine não permite o
desenvolvimento de jogos para iPhone ou para o Nintendo Wii, apenas para
Windows, MAC e para internet, mas nada impede de você comprar uma licença
para desenvolver para essas plataformas após você desenvolver um jogo de
sucesso para Windows, por exemplo, e comprar essas licenças com o dinheiro
obtido para ganhar mais dinheiro. Mas isso não é um problema para aqueles
que desejam apenas desenvolver para Windows e tem o desenvolvimento de
jogos apenas como um hobby.

1.5 Programas auxiliares

Além do Unity3D existem outros programas auxiliares para o desenvolvimento
de um jogo, segue aqui uma lista desses programas, todos são gratuitos:

• Blender: Ferramenta para modelagem e animação de objetos 3D.

• Audacity: Editor de audio open source.

• Gimp: Editor de imagens.

7


• Inkscape: Para criação de desenhos.

• Melody Raiser: Programa de geração de música procedural.

• SFXR: Programa de geração de efeitos sonoros.

Não é o enfoque desta apostila detalhar o funcionamento desses programas,
você só precisa saber que eles serão necessários caso você queira criar seus
próprios modelos, animações, músicas e tudo mais.

1.6 Instalando o Unity no Windows

Baixe o Unity, http://unity3d.com/unity/download/, após terminar o download,
execute o instalador.

A seguinte tela irá aparecer:

Clique em “Next”.

8


Leia o acordo de licença e, se concordar, clique em “I Agree” para ir para a
próxima tela.

9


Clique em “Next”.

10


Escolha o local da instalação e clique em “Install”.

11


Aguarde a instalação finalizar.

Clique em “Finish”, o Unity será executado.

12


Clique em “Register”.

Selecione Internet Activation e clique em “Avançar”.

13


Espere o programa se conectar ao servidor e abrir seu navegador:

Clique na página que foi aberta pelo navegador em “Free”.

14


Pronto! Agora você poderá utilizar a versão gratuita do Unity por tempo
indeterminado, porém a versão pro por apenas 30 dias.

15


Clique em “Concluir”. E abra o Unity novamente.

No próximo capítulo farei uma breve introdução à interface do Unity, aos
principais conceitos envolvendo programação 3D e uma descrição das
principais palavras relacionadas a esse tipo de programação.

16

Capítulo 2: Principais conceitos

Capítulo

2
2 Principais conceitos

E ste capítulo apresenta uma breve introdução ao ambiente de
desenvolvimento do Unity3D assim como alguns dos vários conceitos
envolvidos na área de programação de jogos 3D. O objetivo deste
capítulo é tornar o leitor mais familiar com o uso do Unity3D e com os principais
termos encontrados na área, pois existem muitas pessoas com pouca
experiência na área e que costumam ficar confusas com eles. Boa parte do que
está neste capítulo está disponível na própria documentação do Unity, porém
em inglês.

2.1 O ambiente do Unity3D

Antes de continuar lendo este tutorial, recomendo que instale o programa do
Unity3D (http://unity3d.com/unity/download/) e execute. Para aqueles que estão
abrindo o programa pela primeira vez ele abrirá o projeto Tropical Paradise por
padrão, imagem 7.

17


Barra de Ferramentas / Menu

Hierarquia

Inspetor
Cena / Jogo

Projeto

Imagem 7 - Tela inicial do Unity

O Unity possibilita ao usuário escolher o lugar que cada elemento do programa
irá ficar, porém o Unity possui alguns layout pré-configurados, o layout usado
na imagem é o padrão, se o seu programa está configurado com um layout
diferente você pode mudá-lo na Barra de ferramentas-> Window->Layouts-
>Revert Factory Settings. Essa tela é composta dos seguintes elementos:

2.1.1 Visão de Projeto

Quando você cria um projeto no Unity, ele irá
criar uma pasta contendo todas as Assets
(scenes, scripts, modelos 3D, texturas, arquivos
de áudio, vídeo, imagens, etc) do projeto. Tudo o
que tem nessa pasta, é mostrado na visão de
projeto. Se você clicar com o botão do direito do
mouse em alguma dessas Assets, você poderá
escolher a opção Reveal in Explorer, que abrirá
a pasta que contém o arquivo.

Atenção: não mova os arquivos usando o
Explorer do Windows, use o editor do Unity, pois
isso pode causar problemas ao projeto.

Para adicionar novas Assets ao projeto, você
pode arrastar o arquivo do Windows para a visão

18


de projeto ou utilizar o comando na barra de ferramentas Assets -> Import
New Asset. O arquivo ficará pronto para ser usado no projeto.

As cenas do jogo também ficam nessa pasta. Cada cena representa um level
do jogo. O Unity carrega por padrão a cena Islands.unity, para criar uma nova
aperte ctrl+n ou vá na Barra de Ferramentas->File->New Scene. Para salvar a
cena aperte ctrl+s ou vá na Barra de Ferramentas->File->Save Scene.

Alguns Assets precisam ser criados
diretamente no editor do Unity, para fazer
isso, vá na visão do projeto e use o menu
Create, ou clique com o botão direito do
mouse->Create.

Mais tarde irei explicar o que é cada tipo de
Assets, por hora tente criar uma pasta, para
mudar o nome dela, a selecione com um
clique e aperte F2.

2.1.2 Hierarquia

A visão da hierarquia da cena mostra todos os
elementos presentes na cena, cada
GameObject. Alguns desses objetos são
instância diretas de Assets,m tais como
modelos do Blender, outros são Prefabs, ou
seja, objetos personalizados, uma mistura de
modelos com scripts e outras coisas, que irão
compor boa parte dos jogos do Unity.

Você pode clicar e arrastar objetos para
mudar a hierarquia deles, ou seja, organizá-
los como se fossem pastas, objetos que estão
dentro de outro objetos são filhos deste
objeto, o objeto que contém esses filhos é
chamado de pai. Um objeto filho herdará o
movimento, rotação e escala de seu pai.
Essa informação é muito importante, pois
você deverá ficar atento a este fato quando começar a programar seu jogo.

19


Você pode expandir ou contrair o objeto pai para ver quais são seus filhos sem
afetar com isso o jogo.

Dois objetos sem pais Um objeto sendo pai de outro

2.1.3 Menu de Topo

Imagem 8 - Menu de Topo

O menu de topo consiste em cinco controles básicos. Cada um relacionado a
partes diferente do editor.

Transform Tools – ferramenta utilizada na visão da cena.
Transform Gizmo Toggles -- afeta o que a visão da cena
mostra.
Play/Pause/Step Buttons -- used with the Game View
utilizado para executar/pausar/encerrar o jogo.
Layers Drop-down -- View controla quais objetos serão
mostrados na cena.
Layout Drop-down -- controla a disposição de todas as visões.

20


2.1.4 Visão da Cena

Imagem 9 - Visão da Cena

A visão da cena é o lugar onde você pode organizar a disposição dos objetos
na cena do jogo. Você pode selecionar e mudar de posição os jogadores, a
câmera, os inimigos e todos os outros GameObjects, além de poder mudar a
escala deles, ou seja, o tamanho desses objetos. Esse editor de cena é uma
das ferramentas mais importantes do Unity, então você deve aprender a mexer
com ele. Para selecionar um objeto basta clicar nele na visão de cena ou na
visão de hierarquia, para focar o objeto basta apertar a tecla “f” na visão de
cena.

2.1.5 Posicionamento de objetos

Ao selecionar algum objeto você pode utilizar a Transform Tools,
, para mudar sua posição (translate tool), rotação (rotate tool)
ou tamanho (scale tool).

21


2.1.6 Scene Gizmo

No canto superior direito da visão da cena está o Gizmo da cena.
Ela mostra a orientação da câmera da cena e possibilita você
mudar rapidamente a orientação da mesma, basta clicar em algum
de seus vértices ou no centro para habilitar uma visão em
perspectiva da cena, se segurar o shift enquanto clica no centro do
Gizmo, você habilita a visão isométrica.

Visão em perspectiva.

Visão isométrica. Os objetos não ficam menores com a distância aqui!
22


2.1.7 Barra de controle da cena

O primeiro menu drop-down é para escolher o modo de desenho. A mudança
no modo de desenho não terá efeitos no jogo quando ele for publicado.

Draw Mode drop-down

O Segundo é o modo de renderização. Também não terá efeito no jogo após
publicado.

Render Mode drop-down

Os outros dois botões são relacionados à iluminação da cena e o segundo a
apresentação de skybox, elementos da GUI e outras coisas na visão da cena.

2.1.8 Visão de jogo

Imagem 10 - Visão de jogo

23


A visão de jogo é renderizada através da câmera dentro do jogo. Ela
representa como seu jogo ficará quando for publicado.

2.1.9 Play Mode

Use estes botões par controlar a visão de jogo. Aperte o play para iniciar o
jogo, se apertar play novamente o jogo é encerrado, para pausar o jogo aperte
pause.

2.1.10 Barra de controle da visão de jogo

O primeiro menu drop-down controla a escala, o segundo maximize a tela
quando o jogo começar, o terceiro mostra os Gizmos da cena e o quarto as
estatísticas do jogo, tais como frame rate e número de polígonos na cena.

Imagem 11 - Estatística do jogo

24


2.1.11 Inspetor

Jogos feitos no Unity são compostos de
muitos GameObjects que contém
modelos, scripts, som, ou outros
elementos gráficos, tais como luz. O
inspetor mostra detalhadamente as
informações sobre o GameObject
selecionado, incluindo todos os
componentes pertencentes a este objeto.
Nessa visão você pode modificar os
valores das propriedades desses
componentes que o GameObject possui.

Toda propriedade mostrada no inspetor
pode ser modificada. Até variáveis de
scripts podem ser modificadas sem
modificar o script original. Você pode
mudar essas propriedades enquanto o
jogo está rodando para experimentar e
encontrar os valores ideais para essas
propriedades para seu jogo. Esta é uma
funcionalidade muito importante, pois na
maioria dos casos de desenvolvimento de
jogo não é possível modificar valores de
variáveis enquanto o jogo está em
execução.

25


Adicionando componentes através do menu de componentes

Clicando com o botão direito do mouse
no título do componente na visão do
inspetor, aparece uma lista de opções
onde você pode remover o componente
do GameObject.

26


Use o menu drop-down de Layer para
associar um layer de renderização a seu
GameObject. Utiliza o menu drop-down
de Tag para associar uma Tag a seu
GameObject. Você também pode mudar
o nome de seu GameObject através do
inspetor.

2.1.12 Barra de Status

A barra de status está no canto inferior da tela e ela mostra erros de
compilação e mensagens de debug. Se existe algum problema no seu jogo,
ficar de olho nessa barra é o melhor caminho, você pode dar um clique duplo
com o mouse para mostrar o console com as mensagens da barra de status.

2.1.13 Console

Se você der um clique duplo na barra de status ou escolhendo Barra de
Ferramentas->Window->Console, aparecerá o Console.

27


Imagem 12 - Console

O Console mostra mensagens de erros, warnings e textos de debug. Você
enviar suas próprias mensagens para o console utilizando Debug.Log() ou
Debug.Error() em seus código.

2.2. Sistema de coordenadas 3D
Nesta seção serão descritos alguns elementos do sistema de coordenadas 3D.

2.2.1. O plano cartesiano
Uma das formas de descrever a posição de um ponto no espaço é representá-lo em um
plano cartesiano. Para representar um ponto em duas dimensões, definimos o sistema de
coordenadas como sendo composto por dois eixos, x e y, dispostos ortogonalmente, que
dividem o plano em quatro quadrantes. O eixo x é denominado o eixo das abscissas e o
y o das ordenadas. Esses eixos são divididos em unidades contadas a partir do ponto de
origem do plano, o ponto de intersecção entre os dois eixos, que servem para nos dar
uma idéia de distância, o que chamamos de coordenadas, assim, um ponto nesse plano é
representado por um par de coordenadas, x e y, que representa a distância ao longo de
cada eixo a partir do ponto de origem.
A figura 1 mostra como representar um ponto P(4,6), em que P significa ponto e (4,6)
significa que o ponto está quatro unidades de distância em relação ao ponto de origem
do plano ao longo do eixo x, e seis unidades de distância em relação ao ponto de origem
do plano ao longo do eixo y.

28


O plano cartesiano 2D

Para representar o espaço em três dimensões, adicionamos o eixo z ao sistema de
coordenadas, esse eixo passa pelo ponto de origem do sistema de coordenadas e
representa a profundidade do ponto. A figura 2 mostra como representar o eixo z no
plano.

O plano cartesiano com os eixos x, y e z

2.2.2. Coordenadas locais e globais
Como foi visto na seção anterior, a posição de um ponto pode ser representado em
termos de três variáveis, x,y e z. Por ponto, podemos entender um objeto no espaço. A
posição global de um objeto no espaço é representada em relação à origem do plano. Às
vezes é necessário representar a posição de um objeto a outro, assim dizemos que todo
objeto tem seu próprio ponto de origem e quando desejamos representar a posição de
um objeto em relação a outro, dizemos que estamos utilizando coordenadas locais do
objeto de referência. A figura 3 mostra a diferença entre coordenadas locais e globais.

29


Coordenadas locais e globais

2.2.3. Vetores
Vetores são segmentos de reta usados para representar direção (reta suporte do
segmento orientado), intensidade (valor numérico) e sentido (orientação do segmento de
reta) no plano cartesiano. A figura 4 mostra a diferença entre ponto e vetor. Vetores,
assim como pontos, não se limitam as duas dimensões e podem ser representados no
espaço 3D. Através do uso de vetores é possível atribuir representar além da posição de
um objeto no espaço, a sua direção.

30


Diferença entre ponto e vetor

2.2.4. Quaterniões e rotações
Para realizar a rotação de objetos no espaço tridimensional são utilizados quaterniões.
Para representar a direção que um objeto aponta no espaço não basta apenas representar
sua posição, é necessário atribuir um ângulo a ela. Em jogos quando um objeto é criado,
é definida a sua posição e um ângulo inicial a ele. Quando desejamos fazer alguma
rotação nesse objeto, realizamos com base em sua posição e seu ângulo atual, ou seja,
em seu quaternião.

2.2.5. Renderização
Renderização é o ato de criar imagens 2D dada uma descrição geométrica de um mundo
tridimensional e uma câmera virtual que especifica a perspectiva que o mundo está
sendo visto.

2.2.6. Câmeras
Câmeras em jogos servem para representar o comportamento dos olhos em um sistema
em três dimensões. Através dela são determinados quais objetos devem aparecer na tela
e como eles devem ser mostrados. Elas podem ser posicionadas em qualquer lugar no
espaço, possuem uma direção e um campo de visão, ou Field of Vision (FoV). Esse
campo de visão pode ser interpretado como uma pirâmide invertida com origem no
ponto de origem da câmera e com direção determinada pela direção da câmera, assim,
os pontos mostrados na tela são os que estão dentro dessa pirâmide.
Quando limitamos a distância do campo de visão, estamos especificando uma distância
máxima que um objeto deve estar do ponto de origem da câmera para que ele seja
mostrado na tela, desde que ele esteja dentro do campo de visão da câmera. Também é
possível especificar uma distância mínima que os objetos deverão estar da câmera para
que eles sejam mostrados na tela.
As figuras 5 e 6 ilustram o funcionamento de uma câmera, tudo o que está dentro do
espaço delimitado pelo near plane e pelo far plane serão renderizados.

31


A câmera

Os objetos vermelhos não são renderizados

2.2.7. Representação de formas
Para representar formas em três dimensões são utilizados polígonos, em jogos
geralmente são utilizados triângulos, ou faces, que são representados por três pontos
interligados por vértices. A combinação de polígonos permite a construção de formas
mais complexas, conhecidas como Meshes. É através desses dados que são feitos os
cálculos de detecção de colisões entre um objeto e outro no espaço.

2.2.8. Materiais
Materiais servem para definir a aparência de um modelo após renderizados. Materiais
são cores ou texturas, que em conjunto com um script de renderização, conhecido como
shader, determina a aparência de um objeto quando visualizado na tela.

2.3. Física
Nesta seção serão descritos o que são corpos rígidos e detecção de colisão.

2.3.1. Corpos rígidos
Corpos rígidos são objetos que, durante o jogo, são afetados pelas leis da física, ou seja,
os motores de física realizam cálculos para tornar o movimento desses objetos realistas.
Corpos rígidos podem possuir as seguintes propriedades:
• Massa;

• Gravidade;

• Velocidade;

• Atrito.
32


2.3.2. Detecção de colisão
A detecção de colisões entre objetos durante o jogo também é de
responsabilidade do motor físico do jogo. Adicionando um elemento ao objeto
denominado collider, o objeto passa a se comportar de um modo diferente quando
algum objeto colide com ele, respondendo a colisão, normalmente alterando a
velocidade e direção de seu movimento.

2.3 Conclusão

Com as informações deste capítulo espera-se que o leitor se familiarize com a
interface do Unity e com algumas palavras e conceitos envolvendo
programação de jogos 3D.

Espera-se que o leitor teste o projeto de demonstração do Unity, ou seja, mude
a posição dos objetos, rode o jogo, mude as variáveis de alguns GameObjects
enquanto o jogo está rodando e perceba os resultados das mudanças, ou seja,
fuce bastante mesmo no Unity até se sentir a vontade com a interface. Tenta
entender o que cada visão representa e como funciona o mouse naquela visão
e o que seus botões fazem.

No próximo capítulo farei uma introdução a programação de jogos com o Unity
e o leitor criará seu primeiro programa.

33

Capítulo 3: Introdução ao Java Script

Capítulo

3 Introdução ao Java Script
3
O Unity permite aos desenvolvedores escolher entre três tipos de linguagem de
programação diferentes: Java Script, C# e Boo. Dentre estas, por ser a mais
simples, esta apostila adotou a linguagem Java Script para criar os códigos
responsáveis por controlar o funcionamento do jogo.

A partir deste ponto, assume-se que o leitor está familiarizado com a interface
do Unity.

3.1 Seu primeiro programa

Crie um novo projeto, Barra de Ferramentas->File->New Project.

Aparecerá uma caixa de dialogo onde você poderá escolher o local onde seu
projeto será criado em seu computador e os pacotes contendo um conjunto de
Assets a serem importados para o projeto durante a criação do projeto.

Cheque a opção Standard Assets.unityPackage, o local do seu projeto e o
nome dele e clique no botão Create.

Um projeto totalmente novo será criado, esse processo pode demorar um
pouco.

Você verá uma tela mais ou menos assim:

34


• Salve a cena, ctrl+s, escolhe um nome para ela, por exemplo, level1.
• Crie um Cubo, Barra de Ferramentas->GameObject->Create Other-
>Cube.
• Com o Cubo Selecionado aperte “f” na visão de cena.
• Selecione a câmera na visão de hierarquia e vá em Barra de
Ferramentas->GameObject->Move To View.

Você terá uma cena mais ou menos assim:

35


Mude a posição da câmera até que ela focalize o cubo, nesse caso clique na
translate tool e mude a posição da câmera pelo eixo z, azul, aperte o play para
ver como ficaria a cena durante o jogo.

Você pode mudar o layout clicando e arrastando a aba Game até a parte
inferior da visão de cena, faça isso até que o layout e a posição da câmera o do
cubo fique do seguinte modo:

Quando você apertar o play não verá apenas uma tela azul, verá um quadrado
preto no centro da tela. Isso significa que você já aprendeu o básico da
interface do Unity, agora estamos pronto para começar a aprender um pouco
de Java Script.

Na visão de projeto clique em Create->Java Script. Mude o nome do script,
selecionando-o e apertando F2, para “Ola”. Dê um duplo clique no script na
visão de projetos. Um editor de script será aberto e terá o seguinte conteúdo:

36


function Update () {

}

Código 1 - Script inicial

Mude o script e escreva o seguinte código:


print("Ola");

}

Código 2 – Exemplo Ola

Clique e arraste o script da visão de projeto para a visão de hierarquia no
objeto Cubo. Aperte o play.

Você verá na barra de status, na parte inferior, a seguinte mensagem: Ola

37


Aperte o play novamente para encerrar o jogo. Dê um duplo clique na barra de
status para abrir o console e confira que a mensagem foi exibida no console.
Isso significa que tudo funcionou, mas agora você deve estar se perguntando,
“Ok, mas o que aconteceu?”.

A primeira parte que consiste em posicionar a câmera para que ela focalize o
Cubo é intuitiva, funciona como na vida real, onde quando se deseja tirar uma
foto, é necessário posicionar a câmera em um determinado local e mirar ela em
um objeto para que este objeto apareça na foto. Foi o que fizemos. Você
poderia utilizar as outras ferramentas de posicionamento, tais como a rotate
tool para rotacionar a câmera em conjunto com a translate tool para que o
objeto fosse visto de um outro ângulo.

É necessário prestar atenção no campo de visão da câmera que é
representado na visão de cena como um campo com arestas brancas. Tudo o
que está dentro deste campo será renderizado na cena.

Na segunda parte criamos um Java Script e adicionamos a ele a um objeto,
assim o objeto passou a ter esse script como um de seus componentes. Esse
script tem uma função chamada Update() que é executada repetidamente e
automaticamente pelo Unity em intervalos curtos de tempo, várias vezes por
segundo, depende da quantidade frames por segundo do jogo, ela é executada
uma vez a cada frame.

38


Quando um script com essa função é colocado em um GameObject. Se você
colocar esse script em mais de um GameObject, cada GameObject executará
seu próprio script, executando a função Update() desse script.

Não são todas as funções que são executadas automaticamente, porém se
você colocar uma função em um script com o nome de Update(), essa função
será executada automaticamente pelo Unity. O comando print exibe um texto
no Console e na barra de status.

Antes de explicar detalhadamente como o Java Script funciona, vamos a mais
um teste, mude o código do script Ola para:


transform.Rotate(0, 5*Time.deltaTime, 0);

}

Código 3 – Exemplo gira cubo

Aperte play e perceba que o cubo começa a girar ao redor do eixo y! Ou seja, a
função transform.Rotate(0, 5*Time.deltaTime, 0) fez com que ao invés do
programa mostrar um texto na barra de status, faz o cubo girar. Agora é hora
de entender como funciona a linguagem de programação Java Script, que será
responsável por controlar todos os elementos dos jogos feitos com o Unity.

3.2 Variáveis e tipos de dados

Na escola aprendemos a representar valores através de variáveis,
principalmente nas aulas de matemática. Por exemplo, quando eu digo que um
número x vale 5 e digo que um número y é igual a x+1, sabemos que o se
substituirmos o x do x+1 por 5, que é o valor de x concluímos que y é igual a
5+1, ou seja, 6. Assim:

x=5;

y=x+1 => y=5+1 => y = 6;

Para declarar variáveis em Java Script, fazemos assim:

var x = 5;

var y = x+1;

Vá no script Ola e mude-o para:

39


var x = 5;


var y = x+1;

print(y);

}

Código 4 – Exemplo declaração de variável

Aperte o play e perceba que a barra de status mostra o valor 6.

Nesse caso, x e y são variáveis, ou seja, valores que podem sofrem alteração.
Se mudarmos o valor de x para 20 e se y é igual a x+1, então y passará a ser
21. Pois y é representado em função de x. Esse é um dos conceitos
fundamentais que você deve entender para começar a programar Java Script,
representar valores em forma de variáveis.

Agora selecione o Cubo na visão de
hierarquia e veja que a visão do inspetor
está diferente na parte que mostra o
script Ola.

Mude o valor de x no inspetor para 20 e
aperte play.

Perceba que a barra de status agora
mostra o valor 21. Se você abrir o script
Ola verá que ele está inalterado, x ainda
está com o valor 5, isso é por que o
inspetor permite você alterar valores de
variáveis de um script sem alterar o
script em si. Isso evita que você tenha
que reescrever o script toda vez que
você tiver que adicionar ele a um novo
GameObject e ter que mudar alguns
valores desse script.

Você pode alterar o valor de x enquanto
o jogo está rodando e ver o resultado,
isso permite você achar um bom valor
para a variável, porém valores alterados durante a execução do jogo serão
revertidos para o valor que estava antes da execução.

40


Voltemos a história de variáveis. Podemos dizer que x é uma variável do tipo
laranja e que y também é laranja, então x representa 5 laranjas e y 6 laranjas,
quando dizemos isso, estamos especificando um tipo para a variável x,
dizemos isso quando desejamos fazer alguma coisa com essas variáveis que
só podem ser feitas se elas forem de um tipo. Nesse caso desejamos fazer um
suco de laranja.

O Java Script possui uma série de tipos básicos e cada um serve para alguma
coisa, um deles é o tipo String que serve para trabalhar com palavras.

Por exemplo, para declarar uma variável do tipo String e atribuir a ela a
mensagem “Ola”, podemos fazer desse modo:

var mensagem:String = “Minha primeira string”;

Para fazer um teste vá no script Ola e altere-o para:

var mensagem:String = “Minha primeira string”;


print(mensagem);

}

Código 5 – Exemplo string

Aperte play e veja que o a função print exibe na barra de status o valor da
mensagem, ou seja, “Minha primeira string”.

Como você pode perceber, a função print serve para testar o programa, ela
poderá mostrar o valor de qualquer variável que você declarar. A seguir
veremos os tipos de variáveis que o Java Script possui, se quiser testar cada
tipo, basta alterar o código para que a função print imprima o valor de sua
variável, por exemplo, você pode usar print(n), onde n seria o nome da
variável do tipo número, você especificar outro nome para sua variável, mas
lembre-se de corrigir a função print.

O Java Script possui os seguintes tipos primitivos:

Tipo Descrição Exemplo
sbyte Inteiro de 8-bit com sinal. var n : sbyte = -2;
short Inteiro de 16-bit com sinal. var n : short = -2;
int Inteiro de 32-bit com sinal. var n : int = 2;
long Inteiro de 64-bit com sinal. var n : long = 2;
byte Inteiro de 8-bit sem sinal. var n : byte = 2;
41


ushort Inteiro de 16-bit sem sinal. var n : ushort = 2;
uint Inteiro de 32-bit sem sinal. var n : uint = 2;
ulong Inteiro de 64-bit sem sinal. var n : ulong = 2;
float Número decimal. var f : float = 2.0;
double Número decimal duas que pode ter um valor var f : double =
maior que o float, usado para números muito 2.0;
extensos.
boolean Represents a true / false value. Reprenseta var b : boolean =
verdadeiro (true) ou falso (falso), true;
char Um caracter. var c : char =
"c"[0];
String Representa um texto ou uma série de var s : String =
caracteres. "Hello, world";

Cada um deles serve para uma coisa. Você não precisa especificar o tipo de
sua variável, geralmente você só vai especificar quando você deseja restringir
certas operações para trabalham com um determinado tipo ou usar uma função
que trabalhará com uma característica que apenas aquele tipo possui, por
exemplo se você quer usar números inteiros em sua conta, você deverá usar o
tipo int ou algum outro que represente apenas número inteiros, como o short
que é para inteiros pequenos.

Além dos tipos primitivos definidos na própria linguagem do Java Script,
existem os tipos complexos, os quais fazem parte do Unity e você pode criar
seu próprio tipo de dado, o que chamamos de classes.

Um dos tipos complexos que você utilizará muito é o tipo Array, que representa
um conjunto de variáveis. Como nas matrizes e vetores das aulas de
matemática.

3.3 Declaração de variáveis e palavras reservadas

Para declarar uma variável é necessário escrever primeiro a palavra var e
depois o nome da variável, toda comando em um Java Script deve ser
encerrado com um ; (ponto e virgula), vamos declarar uma variável com o
nome de ano:

var ano;

Você pode atribuir um valor para uma variável em sua declaração:

var ano = 2009;

Também é possível especificar um tipo de uma variável em sua declaração
colocando : (dois pontos) e o nome do tipo depois do nome, por exemplo, como
ano é um número inteiro podemos declarar ele como sendo do tipo int assim:

var ano : int = 2009;

42


O primeiro caractere do nome de uma variável deve ser uma letra ou _
(underline), maiúscula ou minúscula, os demais caracteres podem ser
números, letras ou o caractere especial _ (underline). Exemplos de nomes
válidos para variáveis:

Homem, homem2, _homem, mul89_her, bola883, bola, b, c, iiio0__ou, etc

Exemplos de nomes inválidos para variáveis:

9homem, %idade, *ok, .ddd, &hoje

Uma variável também não pode ter os seguintes nomes pois são palavras
reservadas da linguagem Java Script:

• as • float • static
• boolean • for • string
• break • if • super
• byte • in • switch
• case • int • this
• char • long • true
• class • new • typeof
• continue • null • uint
• default • private • ulong
• double • protected • ushort
• else • public • virtual
• enum • return • void
• false • sbyte • while

Ou seja, também seria inválida a seguinte variável:

var continue;

Essas palavras reservadas são os tipos de variáveis e comandos que a
linguagem usa para especificar o que o programa deve fazer.

3.4 Operadores

Variáveis podem ser utilizadas para realizar operações, para isso existem os
operadores, os quais já vimos a alguns deles nas aulas de matemática e isso
facilita saber para que servem, um exemplo é o operador + que realiza adição:

var x = 2 + 4;

Nesse caso o operador + fará uma soma de 2 com 4, o que resulta em 6, e
esse será o valor de x. Também poderíamos fazer:

var n1 = 2;
var n2 = 4;
var x = n1 + n2;

43


O operador mais também tem uma função especial com variáveis do tipo string,
ele permite juntar duas strings em uma só:

var palavra = “Bom ” + “dia”

Faz com que a variável palavra tenha o valor de “Bom dia”. Também podemos
fazer:

var p1 = “Bom “;
var p2 = “dia”;
var palavra = p1 + p2;

A tabela a seguir contém os operadores existentes em Java Script e suas
aplicações:

Operador Função Exemplo Resultado
+ Concatena strings. var palavra = “Bom “ + “Bom dia”
“dia”;
+ Soma dois números. var total = 5 + 6; 11
- Subtrai o número da var total = 11 – 3; 8
esquerda pelo da
direita.
* Multiplica um número var total = 2*5; 10
pelo outro.
/ Divide o número da var total = 9 / 2; 4.5
esquerda pelo da
direita.
% Retorna o resto da var total = 9 % 2; 1
divisão.
++ Incrementa em 1 o var total = 2; 3
valor da variável. Pode total++;
ser usado a direita ou
a esquerda da
variável.
-- Decrementa em 1 o var total = 2; 1
valor da variável. Pode total--;
ser usado a direita ou
a esquerda da
variável.

Além dos operadores matemáticos, existem os operadores relacionais, que
retornam verdadeiro (true) ou falso (false), ou seja, retorna um valor booleano,
dependendo se a expressão é verdadeira ou não:

< Menor que. 4 < 5; true
> Maior que. 4 > 5; false
== Igual. 4 == 5; false

44


<= Menor ou igual. 4 <= 5; true
>= Maior ou igual. 4 >= 5; false
!= Diferente. 4 != 5 true

Também podemos combinar duas expressões relacionais através dos
operadores lógicos &&, que verifica se as duas expressões são verdadeiras, e
o || que verifica se uma das duas expressões é verdadeira.
Exemplos para o operador lógico E, &&:

Exemplo Resultado
4 < 5 && 4 > 5 É falso, pois se uma das expressões for falsa, o resultado
será falso, como 4 > 5 é falso, então essa expressão
retornaria false.
4 < 5 && 4 != 5 É verdadeiro, pois 4 é menor que 5 e 4 é diferente de 5.

Exemplos para o operador lógico OU, ||:

Exemplo Resultado
4 < 5 || 4 > 5 É verdadeiro, pois se uma das expressões for verdadeira,
o resultado será verdadeiro, e como 4 < 5 é verdadeiro,
essa expressão retornaria true.
4 > 5 || 4 == 5 É falso pois as duas expressões são falsas.

Por último existem os operadores de atribuição, que, como o próprio nome
sugere, são utilizados na atribuição de um valor a uma variável:

= Atribui um valor a uma var total = 6; “Bom dia”
variável.
+= Soma o valor atual da var total = 6; 11
variável com o valor de total +=6
atribuição.
-= Subtrai o valor atual da var total = 11; 8
variável com o valor de total -= 3;
atribuição.
*= Multiplica o valor atual var total = 2; 10
da variável pelo valor total *= 5;
de atribuição.
/= Divide o valor atual da var total = 9; 4.5
variável pelo valor de total /= 2;
atribuição.
%= Retorna o resto da var total = 9; 1
divisão do valor atual total %= 2;
da variável pelo valor
de atribuição.

45


3.5 Comandos condicionais

Existem alguns comandos em Java Script que controlam a execução de uma
parte do código de acordo com determinada condição. São os comandos
condicionais.

Comando if (se):

Executa um determinado conjunto de ações se uma determinada condição é
verdadeira. Ou seja, se (if) determinada condição é verdadeira, então realize
as seguintes ações.

Sintaxe:

if ( condição )
{

Ação1;
Ação2;
....
AçãoN;

}

Se deseja condicionar a execução de apenas uma ação ao comando if, não é
necessário colocar os {}:

if (condição) Ação;

Exemplo:

var x = 5;


if ( x==5 ){

print(“Verdade”);

}

}

Código 6 – Exemplo if

Comando else (senão):

46


Complemento do comando if, funciona como um senão, ou seja, quando
usamos o if, dizemos, Se (if) determinada condição é verdadeira, então, realize
um determinado conjunto de ações, senão (else), realize outro conjunto de
ações.

Sintaxe:

if ( condição )
{

Ação1;
Ação2;
....
AçãoN;

}

else

{

Ação1;
Ação2;
....
AçãoN;

}

Também é possível condicionar apenas uma ação a uma condição senão,
como no if:

if (condição) Ação;
else Ação2;

Exemplo

var x = 5;


if ( x>100 ){

print(“Verdade”);

47


}

else

{

print(“Mentira”);

}

}

Código 7 – Exemplo else

Comando while (enquanto):

Executa um conjunto de ações repetidamente enquanto uma determinada
condição for verdadeira.

Sintaxe:

while ( condição )
{

Ação1;
Ação2;
....
AçãoN;
}

Exemplo

var x = 0;


while ( x<100 ){

print(“x vale ”+x);

x++;

}

}

48


Código 8 – Exemplo while

Comando for (para):

Um while incorpado, declara a variável de controle, a condição de parada e o
como o incremento da variável de controle será feito tudo de uma vez.

Sintaxe:

for ( iniciaçãoDaVariável; condição; incrementoDaVariável )

{
Ação1;
Ação2;
....
AçãoN;

}

Exemplo:


for (var x=0; x < 100; x++ ){

print(“x vale ”+x);

}

}

Código 9 – Exemplo for

Comando break (interromper) e contine:

São utilizados dentro de um comando while ou for, o break quebra a repetição
e continue executando os códigos que estão depois do comando while ou for
em questão, e o continue volta imediatamente para o inicio da repetição.


for (var x=0; x < 100; x++ ){

print(x);

49


if ( x ==50) break;

}

}

Código 10 – Exemplo break

3.6 Objetos, propriedades e métodos

Todo jogo criado pelo Unity é composto por objetos, por hora basta saber que o
Unity cria objetos durante a execução do jogo, por exemplo, quando o jogo é
iniciado o Unity cria o objeto Time que possui informações sobre o tempo de
jogo. Modelos, a câmera, terrenos, etc. Também são considerados objetos,
como na vida real, dizemos que tudo que existe são objetos, incluindo nós
mesmos. Todo objeto tem propriedades, ou seja atributos, por exemplo, um
homem tem olhos. O objeto Time tem o atributo deltaTime que retorna a
diferença de tempo entre uma atualização e outra do programa.

Para fazer referencia a um determinado atributo de um objeto usamos a
seguinte sintaxe, objeto ponto atributo:

<Objeto>.<Atributo>;

No caso, para acessar o atributo deltaTime do objeto Time, faríamos:

Time.deltaTime;

Exemplo:

var x:float = 0;


x = Time.deltaTime;

print(x);

}


Objetos também possuem funções, ou métodos, que são acessados de
maneira similar aos atributos, ou seja, objeto ponto função():

50


<Objeto>.Função();

Na vida real, os seres vivos tem a função de se reproduzir entre outras. No
Unity, existe um objeto matemático que tem várias funções, entre elas uma de
retornar o valor da raiz quadrada de um número, o objeto é o Mathf e a função
é Sqrt que tem como parâmetro o número que desejamos saber a raiz
quadrada:

Exemplo para calcular a raiz quadrada de 10:

print(Mathf.Sqrt(10));

Para criar uma função usamos a seguinte sintaxe:

function NomeDaFunção( Parâmetros )
{
Ação1;
Ação2;
Ação3;
}

Por exemplo, para criar uma função que multiplica um número pelo outro e
imprime o valor na tela faríamos o seguinte:

function multiplica( numero1, numero2 )
{

var resultado = numero1 * numero2;
print(resultado);

}

Segue um exemplo de um script que cria e usa essa função:

function multiplica( numero1, numero2 )

{


print(resultado);

51


}


multiplica(10,20);

}


Você também pode utilizar funções para atribuir valores a variáveis, para isso
você deve especificar que tipo de dado a função retorna e especificar dentro
dela o valor retornado com um comando return, repare nas mudanças do
código 12 para o código 13:

function multiplica( numero1, numero2 ):float

{


return resultado;

}


var x = multiplica(6,7);

print(x);

}


3.7 Comentários

Existe duas formas de inserir comentários em seu código no Java Script, o
comentário de uma única linha que é precedido por //, exemplo:

52


// esse é um comentário de uma linha

Outra forma é o comentário de várias linhas que começa com /* e termina com
*/, exemplo:

/*
Este comentário tem várias linhas
A gente escreve, escreve, escreve
E quando vê já tem comentário suficiente
Encerra os comentários
*/

3.8 Isso não é tudo

Existem mais conceitos em Java Script que os apresentados nesse capítulo,
tais como criação de classes, modificadores de atributos, etc. Conforme a
complexidade de um jogo avança, será necessário o leitor pesquisar mais
sobre Java Script. Tentarei manter os exemplos desse livro o mais simples
possível para tornar fácil o entendimento de como a Unity funciona, espera-se
que o leitor se torne aos poucos mais e mais familiarizado com o Unity e com a
programação em Java Script. Espera-se que até o final da apostila o leitor se
torne apto a criar programas mais complexos, ou seja, que usem todos os
conceitos apresentados nesse capítulo.

53

Capítulo 4: Terrenos

Capítulo

4
4 Terrenos
Uma das vantagens de se utilizar um motor de jogo é a possibilidade de
realizar vários trabalhos com ferramentas gráficas, podendo visualizar o que
está fazendo. O editor de level do Unity possui uma ferramenta para edição de
terrenos que permite aos desenvolvedores paisagens ricas em detalhes de um
modo simples e rápido comparado com o uso de modeladores 3d, tais como
Blender e 3D Studio Max, para a realização dessa tarefa.

Esse capítulo é uma tradução da documentação do Unity da parte que explica
o processo de criação de terrenos.

4.1 Utilizando Terrenos
4.1.1 Criando um novo Terreno

Um novo terreno pode ser criado a partir da Barra de Ferramentas->Terrain-
>Create Terrain. Isto adicionará um Terreno para sua visão de projeto e para a
visão de hierarquia.

Seu novo terreno irá se parecer com a seguinte imagem:

54


Um novo terreno na visão da cena

Se você preferir um terreno com um tamanho diferente, vá em Barra de
Ferramentas->Terrain->Set Resolution

Alterando a resolução do terreno

Na imagem acima, existem variáveis que podem ser alteradas:

• Terrain Width: A largura do terreno.
• Terrain Height: A altura do terreno.
• Terrain Length: O comprimento do terreno.
• HeightMap Resolution: A resolução do HeightMap para o terreno
selecionado.
• Detail Resolution: A resolução do mapa que controla a grama e os
meshes de detalhes. Por questões de performance, quanto menor o
valor, melhor.
• Control Texture Resolution: The resolution of the splat map used to layer
the different textures painted onto the Terrain.
• Base Texture Resolution: A resolução da textura de composição usada
no lugar da divisão do mapa a certas distâncias.

55


4.1.2 Navegando pelo terreno

Terrenos funcionam um pouco diferente dos outros GameObjects. A coisa mais
notável é que não é possível mudar a posição dos terrenos pelo editor de cena.
Ao invés disso, você pode utilizar pincéis para pintar e manipular seu terreno.
Se você deseja mudar a posição do terreno, você o faz mudando os valores
das propriedades “Transform”, no inspetor, mas não é possível mudar sua
escala ou rotacioná-lo.

Quando o terreno estiver selecionado na visão de hierarquia, você pode apertar
a tecla “F” para centralizá-lo no editor da cena.

4.1.3 Editando o Terreno

Quando o terreno está selecionado, aparecerá no inspector as ferramentas de
edição de terreno.

A Ferramenta de Edição de Terrenos no Inspetor

56

Apostila unity3dv033

Mais conteúdo relacionado

Mais procurados (12)

Destaque (11)

Semelhante a Apostila unity3dv033 (20)

Apostila unity3dv033