2022 2DGameArtAnimationLightingforArtists Ebook USE 3 Trad

Machine Translated by Google
UNIDADE PARA JOGOS E-BOOK
2 DGAMEART ,
ANIMAÇÃO ,
EILUMINAÇÃO
PARAARTISTAS
Conteúdo
Introdução. ...
Projeto.configuração:.renderização.2D... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6
A.arte.para.o.seu.jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Escolha.a.perspectiva.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12
Projeções paralelas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12
Resolução.de.seus.ativos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
Nível.design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Boxe branco com sprites básicos. . . . . . . . . . . . . . . . . . . . .32
Animação 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
Perspectiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
.
Renovando a aparência dos personagens. . . . . . . . . . . . . . . . . . . . . . . . . . .55
Desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Regras gerais de animação 2D. . . . . . . . . . . . . . . . . . . . . . . .56
Criando o esqueleto. . . . . . . . . . . . . . . . . . . . . . . . . . . . .60
Geometria de Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
Pesos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
Peles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
2D.Luzes. ...
Forma livre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74
Paramétrico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74
Ponto/Local. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .75
Globalmente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .75
. . . . . . . . . . . . . . . . . . .80
Preparando sprites para iluminação 2D.
Técnicas normais de pintura de mapas.. . . . . . . . . . . . . . . . . . .80
Como pintar mapas normais em sprites. . . . . . . . . . . . . .82

Pintando o Mapa da Máscara. . . . . . . . . . . . . . . . . ... . . . . . . . .86
Configurando a luz de Fresnel.. . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
Mapa de blocos 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Forma de Sprite 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Importador de PSD 2D para personagens animados. . . . . . . . . . . .90
Efeitos visuais avançados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92
Propriedades do módulo principal.. . . . . . . . . . . . . . . . . . . . . . . . . .95
Emissão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Forma . ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Cor ao longo da vida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Tamanho ao longo da vida útil.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Rotação ao longo da vida útil. . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Barulho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
Renderizador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96
Partículas randomizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . .96
Usando o Shader Graph. . . . . . . . . . . . . . . . . . . . . . . . . . .97
Reflexões e refrações. . . . . . . . . . . . . . . . . . . . . . .105
Pós-processamento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110
Volumes locais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Florescer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Aberração cromática. . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Gradação de cores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Distorção da lente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
Vinheta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
Grão de filme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Projeção Panini. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Conclusão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Introdução
Os jogos 2D evocam nostalgia para as pessoas que cresceram jogando-os nas décadas de
1980 e 1990. Mas, como títulos feitos com Unity, como Cuphead, Hollow Knight, Among
Us, Skul: The Hero Slayer e a série Ori mostram, não há limite para o quão inovadores os
jogos 2D de hoje podem ser.
A evolução do hardware, gráficos e software de desenvolvimento de jogos torna possível

criar jogos 2D com luzes em tempo real, texturas de alta resolução e uma contagem de sprites
quase ilimitada. A planura dos gráficos 2D libera os artistas para criar arte fantástica e de
desenho animado que fica ótima em qualquer dispositivo.
Este é o nosso maior e mais abrangente guia de desenvolvimento de jogos 2D. Ele é destinado
a desenvolvedores e artistas com experiência intermediária em Unity que queiram fazer um
jogo 2D comercial, quer trabalhem de forma independente ou em equipe.
Este guia foi escrito com a colaboração de especialistas do Unity 2D para ajudar criadores
iniciantes a entender as principais decisões que devem tomar no início de um projeto e aproveitar
ao máximo o conjunto de ferramentas do Unity 2D.
Os tópicos abordados incluem a configuração do seu projeto, a transição entre o Unity e

seu software de criação de conteúdo digital (DCC), a criação de sprites e a classificação
de camadas para design de níveis, configuração de câmera, animação, luzes e efeitos
visuais, além de muitas dicas de otimização ao longo do caminho.
Mesmo que você seja novo no Unity, você encontrará muitas dicas e práticas úteis no
guia . No entanto, sugerimos que você comece com os tutoriais e cursos para iniciantes
disponíveis gratuitamente no Unity Learn . Esperamos que você aproveite este guia e desejamos
a você boa sorte com o desenvolvimento do seu jogo . O futuro é brilhante para criadores 2D .
Alguns belos jogos 2D feitos com Unity – no sentido horário a partir do canto superior esquerdo: Ori and the Will of the Wisps da Moon Studios, Cuphead do Studio
MDHR, MegaSphere da AK Games Hollow Knight da Team Cherry
© 2022 Tecnologias Unity 4.de.119.| unidade .com

Autor
Jarek Majewski é um artista 2D profissional e desenvolvedor Unity autodidata com amplas

habilidades de script em C#. Ele criou arte para jogos iOS, Xbox Indie Live e Nintendo Switch™. Seu
jogo Ultimate Action Hero, atualmente em desenvolvimento, ficou em segundo lugar no Unity
2D Challenge de 2019. Jarek foi o diretor de arte de Dragon Crashers, um projeto de demonstração 2D
desenvolvido em conjunto com especialistas em 2D da Unity. O projeto de demonstração usa os
recursos 2D disponíveis no Unity 2020 LTS.
Jarek trabalhou em estreita colaboração com vários especialistas e funcionários da Unity

para escrever este guia definitivo para a criação de jogos 2D.
Contribuidores da Unity
Eduardo Oriz liderou a produção deste guia. Ele é um gerente sênior de marketing
de conteúdo na Unity com muitos anos de experiência trabalhando com equipes de
desenvolvimento da Unity, incluindo a equipe de ferramentas 2D, e um amplo entendimento do
que a Unity oferece aos desenvolvedores e estúdios de jogos.
Rus Scammell é o gerente de produto da equipe de desenvolvimento 2D da Unity. Rus tem

mais de 15 anos de experiência em desenvolvimento de jogos e software. Ele usa seu amplo
conhecimento em tecnologia de jogos para garantir que as ferramentas e fluxos de trabalho
do Unity 2D sejam acessíveis a artistas, programadores e designers de jogos.
Andy Touch é um desenvolvedor sênior de conteúdo na Unity que trabalhou em muitos

projetos, incluindo Lost Crypt e Dragon Crashers. Desde que ele baixou o Unity, adicionou
física 3D a 100 cubos e os viu quicando, Andy ficou viciado em experimentar tecnologia de
jogos. Antes de entrar na Unity, Andy ensinou desenvolvimento de jogos para estudantes
universitários.
Por fim, agradecemos aos colaboradores que nos apoiaram, incluindo redatores, editores e
designers gráficos, além de inúmeros outros na Unity que ajudaram a produzir, refinar e
compartilhar este guia.
Observe que as dicas e fluxos de trabalho neste e-book são baseados no conjunto
de ferramentas 2D da versão Unity 2020 LTS, no entanto. do . . . usando novas versões
Unity, incluindo o Unity 2021 LTS.
*Nintendo Switch é uma marca comercial da Nintendo.

Configuração do projeto:.
Renderização 2D..
O Unity fornece três pipelines de renderização: o Built-In Render Pipeline e dois Scriptable
Render Pipelines (SRPs). Os dois SRPs são o Universal Render Pipeline (URP) e o High Definition
Render Pipeline (HDRP). O URP se aplica a todas as plataformas, enquanto o HDRP é projetado para ser
usado em jogos direcionados a PCs e consoles de ponta.
O URP é usado neste livro porque fornece um pipeline gráfico para Iluminação 2D, permitindo que
você crie luzes 2D e efeitos de iluminação, incluindo Freeform, Sprite, Spot e Global . O URP também
é compatível com o Shader Graph, efeitos de pós-processamento e o recurso de empilhamento
de câmeras.
Para usar o 2D Renderer, você primeiro precisa instalar o modelo 2D Project do Unity Hub e do
URP . O modelo 2D vem com várias configurações de projeto que são otimizadas para um jogo 2D:
— As imagens são importadas como Sprites e definidas para o modo Sprite
— A visualização da cena está definida como 2D
— A cena padrão não inclui uma luz
— A posição padrão da câmera é 0, 0, –10
— A câmera está configurada para Ortográfica
— Nas configurações da janela Iluminação :
— Toda a iluminação global está desabilitada
— O material do Skybox está definido como nenhum
— A fonte ambiente está definida como cor

A janela do Unity Hub
Escolha.pacotes.2D.do.Gerenciador.de.Pacotes
Se você já usou o Unity antes, sabe que muitos recursos estão disponíveis como
pacotes modulares . Você pode ver quais versões de cada pacote estão disponíveis
via Window.>.Package.Manager no Editor . Você pode instalar, remover, desabilitar ou
atualizar pacotes para cada projeto aqui também . Os pacotes incluídos no 2D
Template são 2D Animation, 2D Pixel Perfect, 2D PSD Importer e 2D SpriteShape .
Em seguida, você precisará instalar o URP por meio do Gerenciador de Pacotes.
Instalar URP a partir do Gerenciador de Pacotes

Criando um ativo URP
Criar.um.novo.URP.Asset
Para usar o URP, crie um ativo URP e atribua o ativo nas configurações de gráficos.
Clique com o botão direito do mouse na janela Projeto (ou clique no menu Ativos na Barra de
Ferramentas) e escolha Ativos.>.Criar.>.Renderização.>.Universal.Render.Pipeline.>.
Pipeline.Asset.(Forward.Renderer) .
Um Renderer Asset é criado ao mesmo tempo que um URP Asset, e você precisará substituí-
lo pelo 2D Renderer Asset. Para substituí-lo, clique com o botão direito na janela Project ou clique
no menu Assets, depois escolha Assets.>.Create.>.
Renderização.>.Universal.Render.Pipeline.>.2D.Renderer .
Atribuir.o.Renderizador.2D
Clique no Ativo URP e, no Inspetor, atribua o Ativo do Renderizador 2D ao Renderer.List. Clique

no botão circular na extremidade direita do campo para selecioná-lo na lista.
Definir um novo renderizador na visualização do Inspetor para o ativo URP

Agora que você tem o URP e os Assets do Renderizador 2D alinhados, atribua o

Renderizador 2D às Configurações do Pipeline de Renderização Scriptável no projeto. Abra
a janela Configurações do Projeto (Edit.>.Projects.Settings), vá para a seção Gráficos e atribua
o Asset do Pipeline aqui.
Atribuir os ativos do Universal Render Pipeline nas configurações do projeto
O 2D Renderer agora está configurado e pronto para uso. Você também pode ajustar
as configurações de renderização alternando para a categoria Qualidade em Configurações do projeto.
Leia mais sobre configurações de renderização aqui .
Observação: se você iniciar um novo projeto no Unity 2021 ou posterior, o modelo 2D,
chamado 2D (URP), vem com o Renderizador 2D já configurado, então você não precisará
concluir essas etapas.

A.arte.para.seu.jogo
Durante a fase de conceito de arte, você precisará tomar muitas decisões que
impactarão o lado técnico do seu projeto.
No design de jogos, é uma prática comum simular uma captura de tela ou uma série de imagens
para mostrar o estilo de arte, a ação e a IU do jogo. Os mockups são uma maneira rápida de
determinar se o conceito é viável e ter uma ideia de como o jogo final ficaria.
Você também pode explorar várias direções de arte com mockups de miniaturas simples.
Esses mockups teriam formas simplificadas e se concentrariam mais na aparência geral,
ângulo da câmera, tamanhos de objetos, paleta de cores e contraste. Usar miniaturas é uma
ótima maneira de apresentar diferentes abordagens à equipe para teste e iteração.
Testando ideias desenhando miniaturas simples
Algumas coisas a considerar ao fazer um mockup:
— Qual será o ângulo da câmera e a perspectiva do seu jogo?
— Qual será o tamanho do personagem do jogador em relação ao tamanho da tela

da sua plataforma alvo?
— Seu estilo de arte se encaixa na plataforma, tema e público-alvo? Para

por exemplo, esse estilo atrairá jogadores casuais, jogadores jovens, fãs de
estratégia e assim por diante?
— Como o estilo de arte se encaixa na abordagem gráfica geral?
— Se a jogabilidade exigir tempos de reação rápidos, então é uma boa ideia

tornar elementos como o personagem do jogador, inimigos e projéteis visíveis
contra o fundo à primeira vista.
— Os jogos para celular devem ser mais brilhantes e ter maior contraste para serem visíveis
na luz do sol e em telas menores.
— Qual é o tamanho, a posição e a visibilidade dos elementos da GUI?

Considerações técnicas
Há também questões técnicas importantes a serem consideradas na fase de mockup.

Isso inclui:
—. Animação:.Quais elementos você animará com animação esquelética? Quais terão

animação quadro a quadro ou serão animados com um shader?
—. Ambiente:.Você vai criá-lo com Tilemap ou Sprite Shapes? Ou você quer colocar sprites
de plataforma na cena manualmente? Você pode pintar seu mockup para imitar a
aparência dessas ferramentas para que você possa usar os mockups diretamente
no seu jogo.
—. Classificação:.Planeje sua classificação de sprites agrupando camadas de mockup

de forma similar a como você antecipa que a classificação será feita no Unity.
Pode levar algum tempo, mas você evitará ter que classificar potencialmente
milhares de sprites mais tarde na produção.
—. Iluminação:.Seus sprites serão iluminados com iluminação e sombras pintadas em

eles ou com iluminação em tempo real? Uma dica é pintar imagens sem iluminação
e, em seguida, adicionar sombras e luzes em camadas separadas no seu
software de edição de imagens. Dessa forma, você sempre pode mudar a aparência
da iluminação mais tarde na produção, se necessário.
Aproveite o tempo neste estágio para criar ativos que sejam o mais próximo possível do
que eles parecerão no jogo final. Isso permite que você passe do conceito para a
produção do jogo mais rapidamente.
Uma comparação entre a arte conceitual original e a versão final de Dragon Crashers. Você pode ler sobre o processo de criação da arte para a demo neste post do blog .

Escolha.o.
perspectiva.
Existem diferentes perspectivas, ou visualizações, disponíveis para um jogo 2D. O termo geral para
opções de perspectiva é projeção gráfica, que se refere a um método de projetar um mundo 3D em
um plano 2D. Você pode ver as diferentes perspectivas ilustradas aqui.
Imagem da Wikipédia
Projeções paralelas
Com esses tipos de projeções, as linhas que são paralelas no mundo 3D também são paralelas
quando projetadas em uma superfície 2D. Além disso, elas não têm pontos de fuga, o que
significa que os objetos têm o mesmo tamanho, não importa a distância da câmera. Isso é útil em
jogos porque você não precisa dimensionar seus ativos ou desenhá-los em tamanhos diferentes.
Este diagrama ilustra como a projeção ortográfica funciona. Note que todos os raios de projeção da câmera são paralelos entre
si e perpendiculares ao plano da imagem.

Na projeção ortogonal, os raios são perpendiculares (ortogonais) ao plano da imagem, enquanto na

projeção oblíqua, os raios cruzam o plano de projeção em um ângulo oblíquo para produzir a imagem
projetada.
Existem duas subcategorias de projeção ortográfica: primária e axonométrica.
Projeção primária
Na projeção primária, há uma dimensão perpendicular ao plano de visão.

Como todas as linhas nesta dimensão são paralelas, elas não são visíveis na projeção final.
Este tipo de projeção é o mais fácil de desenhar porque você precisa desenhar apenas duas
dimensões. Os jogos usarão um dos dois tipos de projeções primárias, vista lateral ou de cima
para baixo.
A visão lateral é usada em jogos de plataforma, atiradores e estilo Metroidvania. Os eixos X e Y do

mundo 3D são desenhados na tela com o eixo Z omitido.
Os artistas de jogos tendem a reduzir a escala de objetos distantes visíveis no fundo para fornecer
uma sensação de profundidade.
Perspectiva de vista lateral na

versão de 1991 de Sonic The Hedgehog
Ouriço™ da Sega
Na perspectiva de cima para baixo, a câmera aponta para baixo, perpendicular ao chão.
Não há muitos jogos top-down verdadeiros, e essa perspectiva é frequentemente confundida com
projeções ¾ ou isométricas. Top-down funciona melhor para jogos de tiro, mas não é a visão mais
interessante para ver personagens humanos.
Perspectiva de cima para baixo em Alien

Breed™ da Team17, lançado em 1992
para o Amiga

Projeção axonométrica
Na projeção axonométrica, o mundo 3D é girado em torno de um ou mais eixos para mostrar

vários lados dos objetos.
Existem três tipos principais de projeção axonométrica.
Projeção isométrica, dimétrica e trimétrica
Projeção isométrica: Esta projeção é a mais elegante das três opções.

O ângulo entre quaisquer dois dos três eixos de coordenadas é de 120 graus, e as linhas X e Y
estão cada uma em um ângulo de 30 graus em relação ao eixo horizontal.
A maioria dos jogos antigos chamados de isométricos são, na verdade, dimétricos. Ângulos de
projeção isométrica não ficam ótimos em pixel art, e é por isso que não há muitos jogos com
projeção isométrica verdadeira.
Dimetric.projection:.Esta perspectiva usa projeção onde dois ângulos são idênticos, com as
linhas X e Y anguladas em 26,6 graus. Dimetric tem sido a opção mais comum porque parecia
melhor no hardware mais antigo, onde as linhas formavam uma proporção de pixel clara de 2:1.
Você pode usar esta projeção para mostrar mais ou menos da superfície superior.

Projeção trimétrica: Com esta projeção, cada ângulo é diferente.
Projeção trimétrica em Crystal Castles da Atari, lançado

em 1983
Projeção de três quartos (¾)
Essa projeção é frequentemente confundida com top-down. Na projeção 3/4, a câmera

inclina-se levemente no eixo X para revelar uma visão parcial da frente de objetos e personagens.
¾ projeção em Bomberman World, lançado em 1991 pela

Hundson Soft
Projeção oblíqua
Na projeção oblíqua, os raios se cruzam com o plano de projeção em um ângulo

oblíquo para produzir a imagem projetada. A variante de projeção oblíqua mais
comum é a projeção de gabinete, que é frequentemente usada em jogos de beat 'em up.
Visão de projeção oblíqua em Streets of Rage: Mega Drive, lançado

em 1991 pela Sega

Projeção em perspectiva, onde os raios de projeção vêm do centro da câmera de projeção.
Projeção em perspectiva
A projeção em perspectiva usa pontos de fuga para replicar a maneira como objetos mais
distantes parecem menores. Um ponto de fuga é um ponto no plano de um desenho em
perspectiva onde as projeções bidimensionais ou desenhos de linhas mutuamente
paralelas no espaço tridimensional parecem convergir.
Dependendo do número de pontos de fuga, você pode ter perspectivas , dois- ou

de um a três pontos. Com o advento dos gráficos 3D, essas projeções são menos comuns
em jogos 2D, embora ainda funcionem bem para jogos de aventura ou jogos com fundos
estáticos.
Como você escolhe a perspectiva correta para seu projeto? A jogabilidade determina
o estilo de arte ou vice-versa? Na maioria dos casos, os desenvolvedores escolhem um
estilo de arte e projeção de câmera com base em suposições feitas quando a ideia para
seu jogo se cristaliza. Será uma decisão baseada em muitos critérios, incluindo:
— Jogabilidade e gênero
— Plataforma de destino
— Legibilidade da cena – por exemplo, escolher um ângulo de câmera mais alto para melhor
visibilidade do personagem e das unidades inimigas
— Orçamento – jogos isométricos e de cima para baixo podem exigir mais

animações de personagens para vários ângulos e codificação mais avançada
— Público-alvo
Você também pode basear seu jogo em um estilo de arte. Por exemplo, imagine um
jogo baseado em hieróglifos egípcios antigos. Neste caso, o tema da arte
determinará algumas regras de câmera e jogabilidade, a saber, que deve ser um jogo de
visão lateral com uma perspectiva primária.
Se você é novo no desenvolvimento 2D ou tem um orçamento apertado, é melhor escolher

uma das projeções primárias: top-down ou side-view . Elas são mais fáceis de desenhar
e codificar . Com apenas duas dimensões visíveis, você tem menos com o que se
preocupar, e é mais fácil configurar a classificação de sprites nessas visualizações .
Lembre-se, no final, sua projeção não precisa ser 100% precisa e seguir todas as regras
do mundo real rigorosamente, como é o caso no espaço 3D. O mais importante é
que ela precisa ter uma boa aparência e melhorar a jogabilidade.

Resolução.de.
seus.ativos
As ferramentas 2D do Unity evoluíram de um editor criado inicialmente para jogos
3D. Como resultado, há alguns recursos exclusivos. Por exemplo, sprites 2D na Cena
não estão vinculados firmemente à resolução da tela. Sprites no Unity são texturas
desenhadas em uma malha e são facilmente escaláveis. A câmera em jogos 2D
também é escalável e pode aumentar e diminuir o zoom conforme você quiser.
Portanto, criar conteúdo 2D no Unity requer uma abordagem diferente daquela de

trabalhar em softwares gráficos raster tradicionais, como Adobe Photoshop,
Affinity Photo by Serif, GIMP ou Krita. Nesses aplicativos convencionais, você tem
um tamanho de tela de documento específico disponível com uma resolução definida,
e todas as camadas são vinculadas a essa resolução. Há uma proporção de 1:1 entre o
tamanho do pixel de cada camada e o tamanho do pixel do documento.
Ao desenhar ativos de jogo, o tamanho do pixel é consistente, e a imagem parece ótima porque está sempre restrita à grade de
pixels. No entanto, no Unity, os sprites podem ter uma resolução diferente. O nível de zoom da câmera também afetará a aparência final.
No Unity, no entanto, a resolução da tela e dos ativos são independentes uma da

outra, então você precisa calcular a resolução dos seus sprites.
Comece com suas plataformas de destino porque os recursos do hardware

determinam a resolução máxima que você pode definir.
Para dispositivos móveis, a faixa de resolução é ampla, mas uma suposição

segura é 1920x1080, pois isso permitirá que você segmente dispositivos de baixo a alto padrão.
Para PCs, a maioria dos gamers de desktop usa full HD (1920x1080), enquanto
apenas 2% têm telas 4K, de acordo com uma pesquisa da Steam . Para laptops
especificamente, há muitos usuários que jogam em resoluções mais baixas, como 1366x768.
Você também pode considerar oferecer suporte a telas ultra-amplas, testando proporções
de tela como 21:9 para garantir que a câmera não exibirá áreas indesejadas do seu
nível.

Para consoles, 4K é mais comum devido à alta taxa de adoção de TVs 4K.
O Nintendo Switch oferece resolução de 1280x720 no modo portátil e até 1920x1080 quando conectado
a uma tela externa via HDMI.
Como você pode ver, o intervalo de resolução pode ser muito amplo. Se você está procurando suporte
para um dispositivo específico, este artigo abrangente pode ajudá-lo a encontrar a resolução alvo
adequada.
Para atingir Full HD ou 4K, tenha em mente algumas práticas recomendadas (essas regras não se
aplicam à pixel art):
— Pinte arte na mais alta resolução para seus dispositivos de destino
— Mantenha uma resolução para todos os ativos e reduza a escala posteriormente, se necessário, para
oferecer suporte a dispositivos de baixo custo
Não aumente a escala da arte raster porque isso pode resultar em pixelização e desfoque,
diminuindo a qualidade visual. Sempre comece com a resolução mais alta suportada e, em seguida, diminua
a escala da resolução da arte ao exportar de um aplicativo gráfico.
Você descobrirá mais sobre como fazer isso na seção sobre como trabalhar entre as ferramentas DCC
e o Unity, ou pode tentar usar o dimensionamento do Variant Sprite Atlas .
Um truque útil é desenhar sua arte com o dobro do tamanho que você precisa, e então escalá-la para
50% quando você exportar para o Unity. Essa técnica fará seus sprites parecerem polidos e nítidos, e as
linhas do pincel não parecerão tão tremidas. Não exagere nos detalhes, já que a arte será reduzida. Esse
é um bom truque para esconder as pequenas imperfeições resultantes de arte desenhada à mão. Claro, se
você quer um estilo visual desenhado à mão para seu jogo, então não tente isso.
Depois de escolher a resolução, teste a aparência da sua arte na visualização do jogo para ver como ela
aparecerá nos dispositivos de destino.
Para manter a simplicidade, calcule a resolução do sprite na visualização Ortográfica em vez de

perspectiva. Defina a escala deles como 1,1,1 e a profundidade Z como 0 para facilitar a visualização.
Você pode facilmente visualizar a aparência do jogo em diferentes proporções e resoluções na Visualização do jogo.

Use a grade e as unidades do Unity para manter o posicionamento e a aparência consistentes dos
seus sprites, bem como para calcular o zoom da câmera e os tamanhos dos objetos.
Uma unidade Unity é visualizada pela grade na visualização Scene . Suponha que 1 unidade Unity seja
igual a 1 metro . Defina seus tamanhos de base primeiro e mantenha-os consistentes em
seu jogo .
Grade do Unity na visualização de cena
Comece com o tamanho do seu personagem jogador. Mantenha a altura do personagem jogador entre 0,5
e 2 unidades. Se estiver usando Tilemap, defina o tamanho do tile para 1 unidade.
Personagens e objetos que são muito pequenos ou grandes em comparação com outros
elementos visuais em um jogo levarão a números de transformação estranhos e problemas com
cálculos de física.
Depois de estabelecer os tamanhos dos seus objetos base na cena principal (personagem
do jogador, inimigos, itens colecionáveis, perigos de nível), escolha seu nível de zoom definindo a
propriedade size da câmera ortográfica . Depois disso, verifique o valor do tamanho da câmera .
Quando você multiplica esse valor por 2, você obterá o tamanho vertical da câmera em unidades
Unity .
O tamanho da câmera ortográfica é expresso em unidades que expressam o tamanho vertical da câmera do centro para o topo.

Se o tamanho da câmera for igual a 5, sua altura será igual a 10 unidades. Por exemplo, se você almeja
resolução 4K, então a altura da tela (ou câmera) será 2160 pixels. Com um cálculo simples, você pode
determinar quantos pixels por unidade (PPU) sua arte precisa:
2160.:.10.=.216.
Resolução vertical máxima: (tamanho da câmera ortográfica * 2). = Sprites PPU
Então, cada sprite no seu jogo precisa ter em torno de 216 PPU para ter uma boa aparência em uma
resolução nativa de 4K.
Esse é um exemplo simples. Se você quiser que sua câmera faça zoom in e out, você precisará
levar isso em conta. Se você definir a porcentagem máxima de zoom para o tamanho 3 na visualização
Ortográfica, o PPU precisa ser 360 (2160 : (3 *2)) .
Configurando o PPU para um sprite
Se você estiver usando animação esquelética, defina a resolução dos sprites um pouco mais alta
do que o PPU sugerido. Fazer isso é necessário porque as malhas do esqueleto são rotacionadas,
esticadas e distorcidas, às vezes ao extremo, o que pode produzir resultados que parecem ruins.
Procure uma resolução menor quando a câmera estiver com zoom.
Dica:.Quando você define o valor PPU do seu jogo, aplique uma grade no seu software gráfico para
referência. Isso é útil ao usar Tilemap porque você terá o tamanho do tile em pixels e poderá ajustar a
uma grade.

Configurando a grade no Affinity Photo para corresponder ao PPU do seu jogo
Você não precisa ser rigoroso com esses números. Muitas vezes, você pode economizar memória
usando uma resolução de sprite um pouco menor do que a sugerida. Corte elementos que não
sejam essenciais, como sprites de fundo.
Além disso, teste seu jogo em dispositivos para verificar como ele se parece. Em muitos casos,
os benefícios de usar ativos de alta resolução não são aparentes. Em vez disso, você pode
alocar esse tempo de desenho e memória do dispositivo para outros elementos de jogo mais
essenciais, como os personagens principais, efeitos visuais ou IU. Em dispositivos móveis, o tamanho
do jogo é crucial, então verifique quais ativos podem ser reduzidos e tenha em mente as
limitações de memória. Leia mais sobre resolução de ativos 2D nesta postagem do blog.
Atlas de Sprites
O recurso Unity Sprite Atlas tem duas vantagens principais.
Pack.multiple.sprites.into.one.texture.to.reduce.draw.calls:.Cada malha com diferentes materiais ou

texturas é desenhada na tela separadamente. Cada sprite (que é uma malha) que você coloca na tela
adiciona ao tempo de renderização e pode reduzir a taxa de quadros de um jogo.
Use o Sprite Atlas para consolidar diversas texturas em uma única textura combinada.
O Unity pode então chamar essa única Texture para emitir uma única chamada de draw em vez
de várias. As Textures compactadas são acessadas todas de uma vez, resultando em menor sobrecarga
de desempenho.
Scale.down.sprites.depending.on.device.type:.No Unity, é eficiente dimensionar um Atlas de Sprites

inteiro em vez de sprites individuais e atribuir o atlas dimensionado a diferentes dispositivos.
Para construir um novo Sprite Atlas, clique com o botão direito na janela Project (ou selecione
o menu Assets na barra de ferramentas) e escolha Create.>.2D.>.Sprite.Atlas . Certifique-se de dar a
ele um nome descritivo . Então, na opção Objects for Packing, selecione os sprites que você quer
incluir, ou inclua a pasta inteira . A opção Include in Build deve ser marcada por padrão . Agora você
tem seu primeiro Sprite Atlas .

Um Atlas de Sprites em Unity
Atlas de Sprite Variante
Use um Variant Sprite Atlas para reduzir sprites para dispositivos específicos.
Crie um Master Sprite Atlas como acima, então altere seu Type para Variant no
Inspector (veja a imagem abaixo).
Um Variant Sprite Atlas não contém sprites em si. Ele depende de um Master
Sprite Atlas, que você pode escolher no campo Master Atlas. Dimensione este
atlas e todos os seus sprites escolhendo um valor no campo Scale Value, entre o intervalo de 0,1 a 1.

Configurando um Atlas de Sprite Variante
Em um projeto que inclui um Atlas de Sprite Mestre e um Atlas de Sprite Variante, se ambos tiverem
a opção Incluir na Construção marcada, a Textura usada pelos Sprites mútuos pode vir de
qualquer Atlas de Sprite (consulte o Cenário 3 na seção Resolvendo diferentes cenários do Atlas
de Sprite da documentação do Unity).
Para carregar automaticamente Texturas de Sprite do Atlas Variante em vez do Atlas Mestre,
habilite Incluir na Construção somente para o Atlas Variante e desabilite-o para o Atlas Mestre. A
construção então carrega automaticamente o Atlas Sprite Variante em vez do Atlas Mestre no tempo
de execução.
Desenho em aplicativos vetoriais
A arte criada em software baseado em vetores, como Adobe Illustrator ou Affinity Designer
pela Serif, não é limitada pela resolução. Esta é uma vantagem significativa porque você pode alterar o
tamanho dos seus ativos de arte a qualquer momento, sem se preocupar com configurações
de resolução incorretas.
Você ainda precisará exportar sua arte baseada em vetor para o Unity como um arquivo PNG . É o
mesmo fluxo de trabalho de exportação que para arte raster ou pixel .
Arte vetorial feita no Affinity Designer – o lado esquerdo desta ilustração mostra a visualização vetorial no aplicativo, e o lado direito
mostra a visualização em pixels após a exportação.

Trabalhando entre ferramentas DCC e Unity
Você faz um grande trabalho na sua arte antes de movê-la para o Unity. Você trabalha duro para
fazer todos os personagens, elementos, adereços e arte de fundo tão bonitos e fiéis à sua
visão quanto possível – então é natural que você queira colocar tudo no Unity o mais rápido
possível.
Evite exportar cada camada uma por uma como um arquivo PNG porque isso levará muito
tempo. Em vez disso, siga estas dicas para exportar seus sprites de jogo de forma eficiente de
diferentes softwares gráficos.
De.Adobe.Photoshop
Exporte e salve camadas como arquivos individuais usando uma variedade de formatos,
incluindo PSD, BMP, JPEG, PDF, Targa e TIFF. As camadas são nomeadas automaticamente
conforme são salvas – defina opções para controlar a geração de nomes.
Para exportar camadas como arquivos, faça o seguinte:
1. No menu, selecione Arquivo.>.Exportar.>.Exportar.Camadas.Para.Arquivos.
Preparando-se para exportar do Adobe Photoshop

2. Em Destino, na caixa de diálogo Exportar camadas para arquivos, clique em Procurar para
selecione um destino para os arquivos exportados. Por padrão, os arquivos gerados são salvos na
pasta de amostra como o arquivo de origem.
Caixa de diálogo Exportar camadas para arquivos
3. Se você quiser que seus sprites tenham um prefixo de nome de arquivo comum, insira-o no campo
de texto, por exemplo, tile_wood01 .png, tile_bricks01 .png e assim por diante.
4. Para exportar somente as camadas visíveis no painel Camadas, selecione Somente camadas visíveis.
5. Escolha PNG-24 como um Tipo de Arquivo. Você não precisa incluir um perfil ICC, então
desmarque isso.
6. Verifique as opções Transparência e Camadas de Corte nas opções PNG

seção e desmarque Entrelaçado.
7. Clique em Executar e, após uma breve espera, os sprites deverão ser exportados para a pasta
que você especificou.
8. Use estas etapas para exportar uma quantidade limitada de camadas rapidamente. Observe que todas
camadas são exportadas separadamente. Este método não leva em conta grupos de camadas,
então se você tem um personagem ou objeto que consiste em múltiplas camadas, mescle-as antes
de exportar.
Vamos ver como exportar sprites com múltiplas camadas do Photoshop . Requer mais configuração, mas
essa abordagem permite maior controle sobre as imagens exportadas .
Para começar, você precisará dos nomes das camadas ou grupos de camadas dos quais deseja
gerar sprites. Por exemplo, a imagem abaixo mostra um sprite de um barril consistindo de um
mapa normal e um mapa de máscara. Cada sprite está em uma pasta separada que foi salva como um
arquivo PNG.

Um sprite com um mapa normal e um mapa de máscara
Selecione File.>.Generate.>.Image.Assets no menu . O Photoshop criará uma pasta como um arquivo

PSD e exportará todas as camadas ou grupos salvos como arquivos PNG . Se você ainda não salvou
um arquivo PSD, ele criará uma pasta na sua área de trabalho .
Uma vantagem desse método é que se você alterar qualquer camada ou pasta marcada para exportação,
o recurso de imagem será exportado em segundo plano automaticamente.
Especifique a pasta para cada sprite adicionando seu nome e uma barra antes do nome da
camada. Neste caso, para agrupar todos os três sprites de barril em uma pasta, você adicionaria
“barrel/” antes dos nomes das camadas.
Exportando várias camadas do mesmo sprite do Photoshop
Para alterar o tamanho do sprite, adicione as dimensões especificadas ou a escala em porcentagem

antes do nome da camada, por exemplo, “50% barril/barril .png” ou “80 x 160 barril/
barrel .png” . Ao especificar dimensões, o Photoshop usará pixels como unidade padrão .

Exportando.de.Affinity.Photo.ou.Affinity.Designer
Tanto o Affinity Photo quanto o Affinity Designer fornecem um modo dedicado para
exportação, chamado Export Persona . Vamos ver os passos para usá-lo .
Mude para Export Persona clicando em seu ícone no canto superior esquerdo da barra de
ferramentas do aplicativo, conforme visto na imagem abaixo.
Exportar Persona no Affinity Photo
Para exportar um sprite, crie uma fatia de uma camada ou grupo de camadas . Mude para a aba Layers
à direita, selecione uma camada para exportar e clique no botão Create Slice .
Mude para a aba Fatias, selecione as fatias a serem exportadas e certifique-se de que a predefinição
Exportar esteja definida como PNG único para todas as fatias, conforme visto na imagem a seguir.
Defina a Exportação presente para PNG único no Affinity Photo

Clique em Export Slice e escolha uma pasta de destino quando solicitado. Você pode
economizar tempo exportando os sprites diretamente para a pasta Assets no seu projeto Unity.
Após escolher uma pasta de destino, a opção Contínuo fica disponível, o que permite
exportar fatias sempre que você alterar uma camada.
Para ter melhor controle sobre os sprites exportados, defina as opções de

exportação manualmente para cada emenda clicando no ícone de seta à esquerda do nome da fatia.
Definindo opções de exportação para sprites
Escolha uma subpasta para seu sprite na seção Path . Neste exemplo, todos os sprites
barrel estão na subpasta “barrel” . PNG é o formato de arquivo, e a escala de resolução é
definida em 1x, o que significa nenhuma escala, então os sprites são exportados em 100%
do seu tamanho . Você também pode gerar vários tamanhos de uma vez clicando no botão “+” .
Para jogos multiplataforma, escolha tamanhos adicionais para seus sprites que
podem ser usados ao construir seu projeto para outros dispositivos. Por exemplo,
escolha 2x para dimensionamento para obter sprites “Retina”.
Outro botão “+” na parte inferior da janela expandida permite que você adicione
formatos de arquivo adicionais se quiser exportar arquivos JPG junto com os sprites PNG.

Janela Opções de exportação em aplicativos Affinity Exportando sprites do Krita
Exportando.do.Krita
Certifique-se de salvar seu documento e selecione Tools.>.Scripts.>.Export.Layers ..Na

janela pop-up, selecione o diretório Initial . Este será o local para onde os
arquivos sprite serão exportados .
Em Opções de exportação, marque a opção Ajustar tamanho da exportação para o conteúdo da

camada . Isso cortará as camadas para o tamanho delas, não deixando pixels vazios de preenchimento .
Há algumas configurações opcionais:
— Agrupar como camada: Esta opção exportará grupos em vez de camadas

individuais, uma boa escolha para quando seus sprites consistem em
múltiplas camadas. Note que o exportador verificará apenas os grupos
mais altos na hierarquia, então seus sprites não podem ser agrupados em outro grupo.
— Ignorar camadas invisíveis: isso é útil quando você deseja excluir alguns
sprites da exportação desativando sua visibilidade.
Escolha PNG como extensão de imagem, clique em OK e os sprites serão

exportados para a pasta selecionada.

Importar arquivos PSD do Photoshop para o Unity
Exportar para o formato de arquivo PNG é o fluxo de trabalho mais conveniente para sprites, mas você
também pode importar arquivos PSD diretamente para o Unity. Por padrão, isso achatará as camadas
PSD em uma imagem.
Este método é conveniente para usar em sprites de arte de fundo. Edite e pinte camadas e,
quando você salvar o arquivo, as alterações ficarão instantaneamente visíveis no Editor. Então você
terá seu arquivo de origem PSD diretamente no projeto Unity, e o arquivo pode ser incluído no controle
de origem.
O pacote 2D PSD Importer da Unity oferece a opção de importar camadas como sprites separados.
Este pacote foi projetado para uso com animação 2D, mas você pode usá-lo para importar vários sprites
regulares contidos em um arquivo PSD. Você também pode fazer animações quadro a quadro. Saiba
mais sobre como usar este pacote na seção Animação 2D ou nesta postagem do blog.
Um arquivo multicamadas do Photoshop importado no Unity

Design de nível
Há muitas maneiras de criar protótipos de níveis, então escolha os métodos que melhor se
adaptam ao seu estilo criativo e fluxo de trabalho.
Esboçar ideias no papel provavelmente sempre será popular porque é simples, direto,
portátil e barato. Nos primeiros dias, também era uma necessidade comunicar a colocação
de peças e elementos do jogo para a equipe.
Jogos modernos como Hollow Knight usam papel para design de níveis e conceito de arte. Veja o
processo neste artigo do Rockpapershotgun
Essa foi a melhor maneira de criar níveis por muitos anos e ainda é muito útil.
No entanto, agora você pode testar ideias mais cedo e mais vigorosamente, esboçando-as
no Unity. Vamos dar uma olhada nas ferramentas disponíveis.
Boxe branco
White boxing, um termo bem conhecido do design de níveis 3D, envolve colocar cubos
brancos simples para testar ideias de design de níveis rapidamente. A razão pela qual os
designers usam white box é para mapear ideias para o fluxo do jogo sem nenhum detalhe que distraia.
Este método também pode ser aplicado a gráficos 2D usando figuras geométricas 2D ou
outras ferramentas de prototipagem.
No boxe branco, o foco deve estar apenas nas coisas com as quais o jogador irá interagir,
como o chão, inimigos, perigos de nível e pickups. Todas essas coisas podem ser
feitas a partir das formas mais simples, então codificadas por cores para distingui-las
mais facilmente. Por exemplo, inimigos e outros perigos podem ser coloridos de vermelho,
pickups de verde, interruptores de azul e assim por diante.
Comece com a camada de colisão/interação, que inclui o solo, as paredes e as plataformas

nas quais o jogador salta.

Boxe branco com sprites básicos
Comece com os ativos 2D padrão disponíveis no Unity, que vêm em formas geométricas
simples.
Clique com o botão direito na janela Project (ou clique no menu Assets na barra de ferramentas) e
escolha Assets.>.Create.>.2D.>.Sprites . Todas as formas vêm com formas de colisão
predefinidas, então você só precisa adicionar um componente Polygon Collider 2D a uma forma
de sprite para fazê-la ser afetada pela gravidade ou colisões .
Todos os sprites disponíveis no Sprite Creator
Os sprites selecionados serão criados na pasta que está aberta na janela Projeto.
Use formas diferentes para propósitos diferentes. Por exemplo, use uma cápsula para seu jogador,
círculos para pickups, hexágonos para inimigos e quadrados para o chão ou paredes. Tinja cada
categoria de sprite com uma cor diferente com a propriedade de cor disponível no Sprite Renderer.
Para que os sprites usem colisões de física 2D, adicione um componente Collider 2D
correspondente que corresponderá à forma geral do objeto junto com um Rigidbody 2D.
Escolha o tipo de corpo Dinâmico para que o corpo rígido reaja à gravidade, forças ou colisões.
Para posicionamento preciso, encaixe os sprites na grade mantendo Ctrl pressionado enquanto os
move. Isso os moverá em incrementos de 0,25 unidades.

Forma de Sprite 2D
2D Sprite Shape é uma ferramenta que permite que você crie caminhos e sprites de ladrilhos
ao longo deles. Esses caminhos funcionam de forma semelhante à conhecida ferramenta de
caneta usada em softwares gráficos. São curvas de Bézier que podem ser editadas
diretamente na cena e, opcionalmente, fechadas e preenchidas com textura de ladrilho.
Objetos de forma de sprite linear e contínuo
O Sprite Shape é um recurso de prototipagem útil no Unity porque torna mais eficiente a criação
e edição de novos formatos de sprite.
Se você escolher criar seu projeto 2D com o Template 2D, então o Sprite Shape é instalado por
padrão. Caso contrário, você pode instalá-lo usando o Package Manager.
Para criar uma nova forma de Sprite, clique no menu GameObject, 2D.Object.>.
Sprite.Shape e selecione Forma Aberta ou Forma Fechada.
Criando uma forma de sprite

Para modificar a forma do Sprite, selecione-o e clique no botão Editar no Inspetor.
Modificando uma forma de sprite na janela Inspetor
Clique com o botão esquerdo em qualquer parte do Sprite Shape para adicionar ou
excluir pontos com a tecla delete . Ao selecionar um ponto, você pode alterar seu modo
selecionando um dos três botões Tangent Mode:
—. Linear: Não cria curva, com linhas retas em ambos os lados dos pontos
—. Contínuo: Cria uma curva ao redor do ponto com alças voltadas para direções
opostas
—. Quebrado:.Cria uma curva ao redor do ponto com alças que podem se mover
independentemente

Você também pode selecionar como os cantos ao redor dos pontos ficam. A ferramenta de
encaixe é outra opção útil que encaixa os pontos na grade.
Adicione um Polygon Collider 2D Component para física. As propriedades padrão

devem ser suficientes para fins de prototipagem.
Adicionando um componente 2D do Polygon Collider
Seguindo esses passos, você pode criar Formas de Sprite que podem interagir umas
com as outras e ser facilmente modificadas através de seus Inspetores.
Mapas de blocos
O recurso Tilemap é ótimo para prototipagem rápida. O Tilemap oferece uma maneira
de criar um mundo de jogo usando pequenos sprites, chamados tiles, colocados em
uma grade. Em vez de dispor um mundo de jogo que é uma grande imagem, você pode
dividi-lo em pedaços semelhantes a tijolos que são repetidos por um nível inteiro.
Tilemaps podem ajudar a economizar memória e poder de CPU porque tiles que não
são visíveis na tela podem ser desabilitados. Uma ferramenta de pincel torna eficiente
pintá-los em uma grade, e eles também podem ser programados para usar algumas regras
de pintura. Eles vêm com geração automática de colisão para testes e edições eficientes.

Uma representação visual do background e dos sprite tiles de um jogo retrô de 8 bits que são carregados na VRAM. O console mantém os backgrounds
e sprites carregados em páginas separadas.
O Editor de Tilemap 2D é instalado com o Modelo de Projeto 2D ou a partir do

Gerenciador de Pacotes.
A instalação do pacote 2D Tilemap Extras fornece scripts de editor 2D e

Tilemap reutilizáveis que você pode usar em seus próprios projetos, e estes
também podem servir como base para criar pincéis e tiles personalizados.
Obtenha o pacote habilitando Preview Packages em Project Settings
(Edit.>.Project.Settings). No Package Manager, ative a opção Enable Preview
Packages localizada na caixa Advanced Settings.
Visualizar pacotes de pré-visualização no gerenciador de pacotes

Instale amostras, junto com o 2D Tilemap Extras para ver exemplos usando os scripts que
vêm com o pacote. Você pode ler mais sobre os Scriptable Brushes e Scriptable Tiles
incluídos no pacote na documentação do Unity.
Depois que ambos os pacotes estiverem instalados, abra a janela Tile Palette em Window.>.
2D.>.Paleta.de.Azulejos .
Esta janela conterá todos os blocos e ferramentas para ajudar você a pintar ou editar Tilemaps.
Janela de paleta de blocos com uma paleta carregada
Crie uma nova Paleta clicando no botão Criar Nova Paleta . Uma janela suspensa com opções
aparecerá . Dê um nome à paleta, defina suas opções, clique em Criar e salve-a em uma pasta
selecionada .
Criando uma nova paleta

Agora, adicione tiles à paleta. Arraste um sprite, textura ou Tile Asset para a janela
Palette. Use uma das Sprite Shapes simples que você criou anteriormente e
coloque-a na parte vazia da janela. Escolha um arquivo no qual criar o asset. Agora
você deve ver seu sprite na grade da paleta.
Arrastar um sprite para uma paleta cria um novo bloco.
Agora, crie um Tilemap para pintar os tiles. Clique no item de menu Gameobject.>.
2D.Objeto.>.Mapa de blocos.>.Retangular .
Criando um Tilemap

Você criou uma Grid e um Tilemap dentro dela. Renomeie o Tilemap para algo
mais descritivo. A Grid pode conter vários Tilemaps, e é possível ter várias Grids
por cena, por exemplo, com tamanhos de células diferentes.
Por enquanto, deixe todas as configurações padrão do componente Grid.
O Tilemap GameObject tem dois componentes: Tilemap e Tilemap Renderer.

Deixe as configurações como estão. Se precisar, altere as configurações da Camada de Classificação para
se adequarem à sua estrutura de camadas.
Componentes Tilemap e Tilemap Renderer
Com seu Tilemap e Tile em uma paleta, você está pronto para começar a pintar. Clique na
ferramenta pincel na barra de ferramentas da janela Palette e selecione um tile para pintar.
Tilemap com peças de espaço reservado pintadas

Em seguida, você pode criar um protótipo para um nível . Adicione um Tilemap Collider
2D ao Tilemap para física . Isso adicionará colisores a cada um dos tiles com base no
tipo de colisor definido no Tile Asset .
Adicione um Composite Collider 2D para combinar os colliders em um, resultando

em um comportamento de colisão mais suave com a geometria definida como Outline . Os
tiles se comportarão como um terreno contínuo em vez de tiles individuais . Esta
configuração também traz um ligeiro aumento de desempenho . No entanto, se você planeja
que seu jogo adicione ou remova tiles em tempo de execução, você pode querer manter um collider em cada tile .
Lembre-se de marcar a opção Usado por Composto no componente Collider

2D e definir o Tipo de Corpo Rígido 2D como estático para que ele não caia.
Componente Collider 2D em um Tilemap GameObject

Vamos dar uma olhada nas diferentes ferramentas da Paleta (os atalhos do teclado estão indicados entre colchetes).
Ferramentas da paleta de mosaicos
—. Seleção.(S): Clique para selecionar um bloco ou arraste para selecionar blocos dentro de
uma área retangular.
—. Mover.(M): Mover as peças selecionadas.
—. Pincel.(B): Pinte em um Tilemap ativo (selecione um do Tilemap ativo

suspenso) com o bloco e o pincel selecionados.
—. Preencher.Seleção.(U): Arraste para preencher uma área retangular usando um bloco selecionado.
—. Tile.Sampler.(I): Selecione um tile de um Tilemap e defina-o como ativo para pintar.
—. Borracha.(D): Exclui peças de um Tilemap.
—. Preencher.(G): Preencher uma área com um ladrilho (a área precisa ser delimitada com outros ladrilhos).
Com essas ferramentas sozinhas, você pode pintar e editar tiles de forma eficiente. Além disso, o
Tilemap Extras Asset fornece scripts úteis como Rule Tile.
Regra de ladrilho
Este é um bloco com script que reconhece o ambiente e seleciona a imagem apropriada,
por exemplo, um bloco de chão com grama na parte superior e uma sombra na parte inferior.
O pacote 2D Tilemap Extras vem com uma amostra de Dungeon Rule Tile localizada em
Assets.>.Samples.>.2D.Tilemaps.Extras.>.“version.number”.>.Dungeon.Rule.
Tile.>.Tiles . Arraste-o para a Paleta de Tiles para começar a pintar .
Rule Tile reconhece automaticamente onde estão os tiles adjacentes e onde deve haver bordas.
Ele escolhe o sprite apropriado para você, então você não precisa selecionar tiles diferentes para
pintar as bordas.
Pintura de Tilemaps

O recurso Rule Tile no Inspetor
O Rule Tile Inspector fornece uma lista de regras para qual sprite escolher com base nos tiles
adjacentes. Há uma matriz e um sprite no lado direito de cada regra.
O sprite será usado quando houver peças vizinhas em todos os lados para onde as setas verdes
estiverem apontando.
Saiba mais sobre o recurso Rule Tile aqui .
Este é apenas um exemplo de como usar o Rule Tile . Você também pode substituir os sprites que
vêm com este exemplo ou criar um novo Rule Tile que corresponda às necessidades do seu jogo .
Você pode encontrar modelos de Tilemap prontos que estão disponíveis na comunidade e
na Asset Store. Alguns bons para conferir incluem TileMap Auto Rule da Pandaroo, 2D PixelArt –
Isometric Blocks da Devil's Work.shop, e Pixel Art Platformer e Pixel Art Top Down da Cainos.
Saiba mais sobre as práticas recomendadas do Tilemap neste vídeo e sobre como otimizar o
desempenho do Tilemap neste artigo .

Design de níveis em forma de Sprite
O design baseado em grade ou ladrilho é bem adequado para um estilo visual 2D retrô,
especialmente quando você está usando pixel art. Também é ótimo para jogos de plataforma
horizontais de rolagem lateral, RPGs de cima para baixo e formas não orgânicas, como prédios e castelos.
O design baseado em grade torna a busca de caminhos e a criação de níveis

mais direta. A busca de caminhos é mais simples quando restrita a uma grade. Isso torna
mais fácil manter distâncias constantes ao projetar níveis. Se o salto do seu personagem for
de 3 unidades de altura, por exemplo, você pode planejar facilmente onde colocar plataformas,
e o jogador será capaz de estimar se ele pode fazer o salto ou não instantaneamente.
Tiles individuais podem ser animados, por exemplo, adicionando uma cachoeira, uma tocha
acesa, um ventilador giratório e assim por diante. Você pode fazer declives com Tilemaps, mas
eles serão superfícies retas com ângulos como 45 ou 26,5 graus.
Quando você quiser um estilo mais orgânico e menos baseado em blocos, use o 2D Sprite Shape .
Com esta configuração, você não está limitado a uma grade ou ângulo específico. Você pode
fazer qualquer forma que quiser usando curvas. Terrenos, colinas, campos gramados e superfícies
lisas são todos adequados para Sprite Shape, que empresta uma aparência moderna às
suas cenas em comparação ao estilo pixel-art mais nítido.
Ative a ferramenta de ajuste para definir qualquer ângulo ou curva facilmente e

posicionar elementos com precisão.
À esquerda, Skul: The Hero Slayer, da SouthPAW Games, é um jogo baseado em Tilemap, enquanto Oddmar, da Mobge LTD, à direita, é um
jogo baseado em spline.
Níveis e elementos criados com Tilemaps ou Sprite Shapes são fáceis de editar depois.
Dependendo do seu estilo visual, você pode usar ambos os sistemas no seu jogo.
Tanto Tilemaps quanto Sprite Shapes podem ser modificados durante o tempo de execução
para criar novas e empolgantes possibilidades de jogo. Por exemplo, Tilemaps podem ser
destrutivos, e Sprite Shape pode ser transformado – as possibilidades são infinitas. Leia mais
sobre as opções nos documentos Tilemap API e SpriteShape API .

Câmera ortográfica ou de perspectiva
Para a maioria dos jogos 2D, você vai querer configurar sua câmera para o modo ortográfico . É
a escolha padrão para projetos 2D porque as linhas de uma dimensão são paralelas, e você
trabalha apenas em duas dimensões . O modo ortográfico funciona para todos os estilos –
jogos de pixel art, quebra-cabeças, isométricos 2D, de cima para baixo, jogos de plataforma .
Embora jogos 2D não tenham profundidade real, a ilusão de profundidade pode ser criada
usando o efeito parallax . O efeito parallax rola múltiplas camadas no fundo e no primeiro
plano em velocidades diferentes quando a câmera se move .
A intenção é imitar a percepção de profundidade humana, em que objetos mais distantes
parecem se mover mais lentamente do que aqueles mais próximos de nós.
Em 2D, isso geralmente é feito com um script que move camadas com uma porcentagem da
velocidade de movimento da câmera. Requer alguma configuração manual para ajustar a velocidade
de cada camada de parallax.
Configuração de câmera de perspectiva em Tails of Iron por Oddbug Studio. Aprenda como eles criaram a iluminação em seu jogo com Unity .
Se o modo ortográfico é adequado para todos os estilos de jogos 2D, por que usar o
modo perspectiva?
Um motivo é que isso oferece acesso a efeitos de paralaxe prontos para uso, já que, como o nome
sugere, uma câmera Perspective usa um ponto de vista de perspectiva. Você não precisa usar
scripts para manipular a rolagem de camadas de paralaxe. Em vez disso, você posiciona elementos
mais distantes da câmera no eixo Z e os dimensiona para considerar a perspectiva com base em
sua distância relativa da câmera.

Sprites parallaxed não se movem com a câmera a cada quadro, então objetos de fundo
podem ser marcados como estáticos para loteamento. Adicionar alguns objetos 3D à sua cena
pode fornecer mais profundidade também.
O modo ortográfico com efeitos de paralaxe com script requer que você configure as
velocidades de rolagem em todas as camadas manualmente. O efeito de profundidade pode
quebrar se as camadas tiverem velocidades de rolagem incorretas, e editar um nível de paralaxe requer codificação adicional.
Suponha que você esteja fazendo um jogo estilo Metroidvania com cenas que incluem
múltiplos pontos de entrada. Neste caso, o efeito de paralaxe pode quebrar porque a câmera
pode começar em uma posição diferente no eixo X de onde você editou os elementos de
paralaxe.
Uma vez configurada, a câmera Perspective funcionará para efeitos de parallax. A única
desvantagem é que você precisa dimensionar sprites conforme os move ao longo do eixo Z.
Além disso, a abordagem permite que a cena seja dividida em cenas menores para
carregamento aditivo, como um sistema de sala que permite carregamento dinâmico do mundo.
A câmera que você escolher não impacta o processo de criação de arte, mas
determina como os níveis são configurados. E, se eles forem configurados corretamente,
a paralaxe ortográfica e de perspectiva parecerão as mesmas para o jogador.
Para resumir, um modo ortográfico é a melhor escolha na maioria dos casos, exceto
quando você estiver usando rolagem avançada e parallax . Nesse caso, vá com o
modo perspectiva .
Câmera em modo ortográfico em Dragon Crashers

Misturando 2D e 3D
Se o seu projeto usar o Built-In Render Pipeline ou o Universal Render Pipeline

(URP), é fácil misturar elementos 2D e 3D na mesma Scene . A renderização 2D
usa Sorting Layers e Sorting Groups para definir a ordem de renderização dos
elementos do jogo . Adicionar o componente Sorting Group a um 3D GameObject
permite que você integre facilmente objetos 3D e 2D no mesmo jogo . Você pode
fazê-los interagir uns com os outros usando um sistema de física comum (física
2D ou 3D, dependendo da melhor abordagem para o jogo) e misturando sistemas
de iluminação 2D e 3D por meio do recurso Camera Stacking no URP .
Introduzir ativos 3D no fundo de um jogo 2D pode adicionar uma boa profundidade a uma cena sem comprometer a
jogabilidade. As imagens de cima e do meio são do próximo jogo estilo Metroidvania Aeterna Noctis, da Aeternum
Game Studios S .L . A imagem de baixo é de Last Night da Odd Tales .

Empilhamento de câmeras
O Camera Stacking permite que você sobreponha saídas de câmera e as combine em

uma imagem final. Você pode combinar objetos 2D, 3D e UI com o Camera Stacking.
Pelo menos duas câmeras são necessárias na cena para empilhamento. Escolha qual
delas será a Base Camera para a imagem que você quer renderizar primeiro, e quaisquer
câmeras adicionais precisam ser definidas como Overlay.
Configurando o empilhamento de câmeras
A Base Camera precisa saber quais câmeras se sobrepõem no topo e em que ordem.
Para fazer isso, vá para a opção Stack e selecione uma câmera para sobrepor com o
botão +. Altere a ordem de renderização das Overlay Cameras conforme necessário,
arrastando-as para cima ou para baixo na lista.
Selecionando câmeras para serem renderizadas como sobreposições
Use camadas para definir quais objetos são renderizados por cada uma das câmeras. Por
padrão, as câmeras renderizam todas as camadas, mas você pode alterar isso
selecionando quais camadas são renderizadas pela câmera na opção Culling Mask em um componente Camera.
Escolhendo camadas para renderizar na opção Máscara de Culling da câmera
Agora, selecione os GameObjects que você quer que a câmera renderize, e altere a
camada deles para corresponder à definida anteriormente. Dessa forma, os objetos são
categorizados para serem renderizados por câmeras diferentes, como um fundo 3D e camadas de plataforma 2D.

Cinemachine para 2D
Depois de selecionar o tipo de câmera, você precisará configurá-la para acompanhar o gameplay.
O sistema Cinemachine da Unity fornece a funcionalidade para fazer isso e muito mais, como
confinar a câmera a limites de nível, configurar transições de câmera, ruído e assim por diante.
Esta seção destaca algumas das principais funcionalidades do Cinemachine para jogos 2D.
Para começar, instale o Cinemachine a partir do Gerenciador de Pacotes. Escolha a versão 2 .7 .1 ou

posterior.
O Cinemachine não cria novas câmeras Unity em uma cena. Em vez disso, quando uma nova Câmera
Virtual Cinemachine ou vcam é adicionada a uma cena, o CinemachineBrain
O componente é adicionado à câmera principal, junto com um novo GameObject com o nome padrão
CM vcam .
O Cinemachine Brain monitora todas as Câmeras Virtuais ativas na cena. Animar
as vcams com keyframes, misturam ou fazem transição suave entre as câmeras, ou criam uma
combinação das duas para animar uma câmera enquanto faz a transição para outra. Toda a animação
será processada pelo Cinemachine Brain e aplicada à câmera principal – pense nisso como um poderoso
sistema de animação que aciona sua câmera principal.
Para criar uma câmera virtual 2D, clique em Cinemachine.>.Create.2D.Camera . Isso criará uma
configuração de Câmera Virtual para um ambiente 2D . Se for sua primeira Câmera Virtual na cena, ela
também adicionará um Componente Brain Cinemachine à sua câmera principal .
Criando uma câmera virtual Cinemachine

O Cinemachine precisa de um objeto para seguir, então atribua um personagem de

jogador no campo Follow . Para garantir que você esteja operando em um plano 2D e que a
câmera não esteja girando ou inclinando, verifique se o campo Look At está vazio e Body
está definido como Framing Transposer . Por fim, defina as propriedades Lens para seus
projetos . Tenha em mente que algumas opções serão herdadas das propriedades da câmera principal .
Expanda o campo Propriedades do corpo para encontrar opções úteis para modificar como
a câmera virtual segue seu alvo, como deslocamento, amortecimento, zonas mortas e suaves.
Experimente essas opções durante o Modo de Reprodução, e as alterações serão salvas
se você marcar a opção Salvar durante a reprodução.
Há também uma extensão para a Câmera Virtual, a CinemachineConfiner2D, que, quando

ativada, limita a câmera de se mover para fora dos limites do Nível, garantindo que o
jogador verá apenas as partes que você quer que ele veja. Ela também garante que você
não precise projetar partes desnecessárias do nível.
Para adicionar CinemachineConfiner2D, selecione CinemachineConfiner2D no menu

suspenso Adicionar extensão.
Adicionando a extensão CinemachineConfiner2D
Cinemachine2DConfiner requer um Collider 2D (Composite ou Polygon) como um

Bounding Shape 2D . Crie um GameObject vazio e adicione um Composite Collider 2D
e um Box Collider 2D . Um RigidBody 2D será adicionado automaticamente; defina seu Body
Type como Static . Além disso, marque a opção Used by Composite no Box Collider 2D .
Agora, arraste este GameObject para o campo Bounding Shape 2D do script
CinemachineConfiner2D . Não se esqueça de editar o tamanho do Box Collider 2D para
que seja maior que o tamanho da câmera .
Agora o frustum da câmera não sai da caixa delimitadora do colisor. Para mais detalhes,
confira a documentação do Cinemachine Confiner 2D .

Ordem de sorteio
Em um jogo 2D, todos os sprites e objetos têm a mesma profundidade. Como você pode classificá-los para
que alguns apareçam na frente dos outros?
O Unity classifica os Renderers de acordo com uma ordem de prioridade que depende de seus tipos e usos.
Você pode especificar a ordem de renderização dos Renderers usando sua Render Queue . Em geral, há duas
filas principais: a fila Opaque e a fila Transparent .
Os renderizadores 2D estão principalmente na fila Transparente e incluem os tipos Sprite Renderer,
Tilemap Renderer e Sprite Shape Renderer .
Renderizadores 2D dentro da Transparent Queue geralmente seguem uma ordem de prioridade . Quando dois
ou mais objetos ocupam o mesmo espaço, o Unity percorre essa lista e verifica qual objeto deve ser
desenhado no topo . Quando há um empate, e ambos os objetos têm o mesmo valor, o próximo critério na
lista é avaliado . A ordem de prioridade é:
1. Camada de classificação e ordem na camada
2. Especificar fila de renderização

3. Distância até a câmera
4. Grupo de classificação
5. Material/Sombreador
Quando todos os valores acima são os mesmos para ambos os objetos e um desempate é necessário,
esse processo deve escolher qual deles renderizar em cima. Não é uma solução ideal, então certifique-
se de definir uma ordem de classificação distinta usando Sorting Layers e Sorting Groups.
Camadas de classificação
O critério de classificação mais importante é Sorting Layers . Todos os Renderizadores 2D têm essa opção,
e é a primeira coisa que você precisa configurar . Há uma camada de classificação padrão que você pode editar
abrindo Project Settings e especificando as opções Tags e Layers .
Editando a Camada de Classificação

Adicione, exclua ou altere a ordem arrastando a alça à esquerda das Camadas. Camadas
que estão mais altas na lista são renderizadas primeiro e aparecerão mais distantes da
câmera.
Planeje a estrutura das Camadas de Classificação, mesmo ao projetar um mockup para

organizar sua cena logo no início. Defina o grupo de classificação de um sprite assim que
colocá-lo na cena. Essas práticas ajudarão você a evitar uma situação mais tarde no
desenvolvimento do seu projeto quando você de repente perceber que precisa alterar as
configurações de classificação em potencialmente milhares de sprites.
Evite.criar.muitas.camadas.de.classificação
Luzes 2D dependem de Camadas de Classificação, então considere a iluminação ao definir a

estrutura de Camadas de Classificação. Saiba de antemão como você quer que as luzes se
comportem no seu jogo e quais grupos serão afetados por elas.
Por exemplo, se você estiver criando um jogo isométrico e planeja ter tochas que usam luzes
2D, as tochas afetarão todo o ambiente ou apenas as paredes?
Os personagens serão afetados ou serão desenhados na frente da luz? Você precisará de
uma Camada de Classificação apenas para os objetos que receberão luz? Tenha esses tipos de
perguntas em mente ao editar Camadas de Classificação e aprenda mais sobre o planejamento
de iluminação na seção Luzes 2D .
Tenha cuidado ao usar muitas Camadas de Classificação, o que pode fazer com que
você perca a supervisão de todos os detalhes. Quando precisar classificar renderizadores
mais, use Ordem na Camada. Isso permite que você classifique objetos que estão na mesma camada facilmente.
Transparência.Classificação.Modo.
Você pode querer uma visão 3D falsa no seu jogo, como uma projeção axonométrica ou oblíqua
para um jogo isométrico, de cima para baixo, com um pouco de ângulo, ou uma projeção de
gabinete em jogos de luta. Se for o caso, você precisará classificar os renderizadores de
forma personalizada por Distância até a Câmera (ponto 3 na lista de prioridades de classificação acima).
Escolha um eixo personalizado para classificar objetos. No caso de um jogo de cima

para baixo ou brawler, classifique objetos no eixo Y, então personagens mais altos serão
renderizados abaixo de outros personagens, dando a ilusão de que eles estão mais
distantes. Para editar esta opção, encontre o 2D Renderer Asset criado ao configurar o URP e
altere sua opção Transparency Sort Mode para Custom Axis, então defina seu valor
Transparency Sort Axis para 0, 1, 0.

Classificando sprites no eixo Y, o valor (X:0, Y:1) 1 diz ao Unity para seguir um vetor descendente (como em Vector2 .
para baixo) para os critérios de classificação. Os sprites no topo serão desenhados primeiro, e os de baixo
depois, tornando-os visíveis na frente.
Grupo de classificação
Mesmo se você seguir os passos anteriores e classificar no eixo Y, a aparência das partes do seu
personagem ainda poderá ser exibida incorretamente.
Partes dos caracteres que estão na mesma Camada de Classificação são misturadas entre dois caracteres.
Não é um bug. É assim que a classificação funciona. A classificação não sabe quais partes
pertencem a qual personagem se elas estão na mesma Camada de Classificação. Felizmente, o
Grupo de Classificação é o quarto critério na lista de prioridades de classificação. O Grupo de
Classificação é um componente que agrupa Renderizadores que compartilham uma raiz
comum para fins de classificação. Todos os Renderizadores dentro do mesmo Grupo de
Classificação compartilham a mesma Camada de Classificação, Ordem na Camada e Distância até a Câmera.

Ao usar personagens ou outros objetos que consistem em alguns sprites, coloque este script em seu
objeto Parent (o mais alto na hierarquia) e defina Sorting Layer e Order in Layer como em qualquer outro 2D
Renderer. Você pode ver um exemplo disto nesta sessão técnica do Unite Now .
Criando um Grupo de Classificação no GameObject pai para garantir que este objeto e seus objetos filhos sejam classificados
como um único elemento, evitando conflitos potenciais entre suas partes e outros sprites no jogo
O Grupo de Classificação faz com que os caracteres apareçam como deveriam.
Você também pode aninhar Grupos de Classificação. Se você tem armas consistindo de vários sprites que
você quer que sejam gerados aleatoriamente, coloque-os em Grupos de Classificação para que eles sejam
exibidos corretamente nas mãos dos personagens.
Dicas de otimização
— Considere usar Tilemaps quando sua cena consiste em muitos sprites. Isso
permite que você troque muitos Sprite Renderers (eles têm uma sobrecarga) por apenas um Tilemap
Renderer.
— Marque seus aceleradores de nível como estáticos para agrupamento.
— Coloque sprites que provavelmente estarão juntos na cena em um Atlas de Sprites.
— Simplifique as malhas dos sprites usando a opção Contorno Personalizado no Editor de Sprites.
— Cache a geometria do Sprite Shape habilitando a opção Cache Geometry (parece

quando o botão Editar Spline estiver ativado).

Animação 2D
A animação 2D pode ser a parte mais demorada e desafiadora do desenvolvimento de arte para um jogo.
Criar personagens animados impressionantes requer um conhecimento considerável de animação de
tempo, momentum, cinemática e muito mais. Polir cada quadro pode levar muito tempo, e armazenar e
exibir esses quadros requer muita memória.
Alterar o tempo ou qualquer parte de um personagem pode exigir que cada quadro seja redesenhado.
Historicamente, a animação 3D tem sido mais direta do que a 2D. Você cria um modelo 3D, monta-o
adicionando um esqueleto, configura pesos de ossos e o anima definindo quadros-chave entre os
quais o software interpola. Você faz ajustes editando os quadros-chave.
Felizmente, a Unity desenvolveu um conjunto de ferramentas que traz maior eficiência à animação
2D, de muitas maneiras imitando a facilidade direta do processo de animação 3D. O pacote 2D Animation
permite que você importe a arte do seu personagem diretamente do Photoshop para a Unity.
Projetar, importar e montar
O elemento mais vital em um jogo é o personagem do jogador, então reserve um tempo para pensar no
design do personagem. Há alguns aspectos importantes a serem considerados durante o planejamento.
Perspectiva
A perspectiva que você escolher impactará como os personagens do jogo se parecem e são
animados. Na maioria das visualizações de jogo, os personagens podem ser desenhados de perfil. Uma leve
rotação para uma visualização de ¾ permite que mais características faciais sejam mostradas.
Ao usar uma perspectiva isométrica ou ¾ de cima para baixo, você pode criar uma visão semelhante, mas
com uma câmera inclinada um pouco do topo para mostrar detalhes faciais. Nessa perspectiva, o
personagem será desenhado voltado para várias direções. Dependendo do resultado desejado e do
orçamento, você pode escolher entre uma das três opções comumente usadas:
— 4 direções
— 6 direções
— 8 direções
Diferentes maneiras de lidar com animações de personagens de cima para baixo

Não importa qual você escolher, você terá que decidir se as animações voltadas para a direita ou
para a esquerda terão que ser viradas para a direção oposta. Neste caso, você precisará desenhar
respectivamente:
— 3 direções: direita, cima, baixo
— 3 direções: direita, direita para cima, direita para baixo
— 5 direções: direita, direita-cima, cima, direita-baixo, baixo
Se as animações forem invertidas, as mãos do personagem serão invertidas para combinar . Se o

personagem estiver virado para a direita e segurar uma espada na mão direita e um escudo na esquerda,
quando o personagem for invertido para ficar virado para a esquerda, ambas as armas terão
trocado de mãos . Decida se aceita essa troca ou gasta mais tempo fazendo todas as animações
ficarem viradas na direção certa .
Se você estiver projetando um jogo tradicional de beat-'em-up de rolagem lateral, você pode simplesmente
usar uma direção de frente. Personagens se movendo para cima e para baixo parecerão estar dando
passos laterais.
No final das contas, cabe a você decidir se seu personagem ficará bem ou não no ambiente do jogo após
o teste. Sua visão é mais importante do que ter um ângulo de visão e perspectiva realistas.
Reskinning.personagens
Outro benefício do pacote 2D Animation é que vários personagens podem compartilhar o mesmo
esqueleto e animações. Depois de projetar, rigear e animar um personagem base, você pode simplesmente
trocar sua skin.
Economize tempo planejando com antecedência. Desenhe conceitos de todos os personagens que
compartilharão o mesmo esqueleto, então verifique se o esqueleto caberá em todos eles. Faça isso
desenhando um esqueleto em uma camada separada e sobrepondo-o em cada personagem.
Tenha em mente que a contagem de camadas deve ser a mesma para todos os personagens.
Observação: no Unity 2021 .1 e versões mais recentes, um novo recurso chamado Compartilhamento de esqueleto
simplifica esse processo.
Sobreposição de desenho de esqueleto em um aplicativo de edição de imagem

Desempenho
A animação 2D esquelética requer mais poder de processamento do que uma abordagem quadro a
quadro, que é essencialmente sprite swapping . Uma boa dica de desempenho é instalar os pacotes
Burst e Collections do Unity do Package Manager . Isso melhorará o desempenho do tempo de execução
da deformação do sprite animado .
Em seguida, determine os recursos necessários para suas plataformas de destino e quantos

personagens estarão na tela ao mesmo tempo.
Por exemplo, com um jogo de aventura onde haverá dois ou três personagens na tela, você
pode ser menos conservador com os detalhes do personagem. Você terá o luxo de fazer ossos e
camadas adicionais, bem como IK avançado – olhos móveis, dedos e muito mais.
No entanto, um RPG ou jogo de tiro para dispositivos móveis com grandes batalhas e mais de 10
personagens deve ter rigs mais simples. Seria razoável, por exemplo, ter um osso por membro em vez de
dois, ou ter uma troca de sprite de rosto inteiro em vez de ter olhos se movendo em uma camada
diferente.
Ao projetar a arte do jogo, tenha cuidado ao planejar com antecedência quantas camadas você precisará e
como os personagens serão animados, porque é quase impossível alterar esses elementos mais tarde na
produção.
Geral.2D.animação.regras
Aqui estão algumas boas regras a serem seguidas ao criar um personagem que será manipulado e
animado mais tarde.
Um exemplo de pose de
personagem neutra: Pernas e
braços podem estar em qualquer
posição, mas devem estar
esticados. Esticar membros
dobrados causará alongamento de pixel.

— Desenhe o personagem em uma posição neutra com braços e pernas esticados. Se as

partes do corpo forem desenhadas dobradas, isso pode causar problemas quando
você estiver animando.
— Deixe a resolução um pouco mais alta do que o PPU do seu jogo sugere. Embora a resolução
possa parecer boa em repouso, girar e esticar imagens pode causar pixelização.
— Se a Iluminação 2D for usada extensivamente no seu jogo e você quiser aproveitar ao máximo
os mapas normais, não pinte a luz e a sombra no seu sprite. Em vez disso, pinte algumas
sombras não direcionais. Essa técnica é chamada de oclusão de ambiente. Seu sprite
ficará melhor, mas evite usar qualquer luz direcional, como a luz do sol.
— As camadas das partes do corpo trocadas usando o recurso Sprite Swap devem ser
agrupados de acordo. Por exemplo, todas as camadas com posições de boca devem ser
colocadas em um grupo chamado “boca” no aplicativo de edição de imagem.
Agora que você sabe o que considerar durante o design, inicie seu aplicativo gráfico de
escolha e comece a pintar. Saiba mais sobre Sprite Swap visitando a página de documentação
aqui .
Importando um personagem para o Unity
Após concluído, seu personagem precisa ser importado para o Unity. A maneira mais rápida de
importar é por meio do 2D PSD Importer. Isso importará todas as camadas do personagem como
sprites e as colocará exatamente como foram pintadas no aplicativo.
Se você estiver usando o modelo de projeto 2D no Unity, o importador já deve estar instalado.
Se não estiver, instale-o usando o Package Manager.
O processo de exportação simplesmente requer que os arquivos sejam salvos no formato

PSB . Este é um formato semelhante ao PSD do Photoshop, mas o PSB permite tamanhos de
arquivo maiores . Se você estiver usando o Photoshop, selecione este formato na caixa de diálogo
Salvar . Se você estiver usando outro aplicativo, basta exportar o projeto como um arquivo
PSD e alterar a extensão do nome do arquivo para PSB antes de importar para o Unity .
Importar para o Unity é o mesmo que com outros ativos. Salve o arquivo na pasta Assets ou
arraste-o para a janela Project.
Quando um arquivo PSB importado é selecionado, ele mostrará opções semelhantes às

configurações de importação de sprites, mas com configurações adicionais para animação 2D e rigging.

O Inspetor de um personagem
As principais opções a serem definidas são:
— Importar oculto: esta opção importa todas as camadas de um arquivo PSB, incluindo
camadas ocultas.
— Mosaico: esta configuração só estará disponível se o Tipo de textura estiver definido como Múltiplo.
Ele cria sprites a partir de camadas importadas e os coloca em um atlas de texturas.
Deixe esta opção habilitada se você quiser manipular um personagem.
— Character Rig: Esta opção gera um Prefab de personagem com a mesma hierarquia de
camadas e posição do arquivo PSB. Isso deve estar em .
— Use Layer Grouping: Isso adiciona agrupamento de camadas do arquivo PSB. Ative-o para
agrupar partes de um personagem, como partes trocadas de sprites.
Após definir as opções, clique em Apply . Isso finaliza o personagem Prefab, que agora pode
ser arrastado para uma Scene .

Construindo um personagem
Para começar a montar um personagem, clique no botão Editor de Sprites no Inspetor para
acessar as Configurações de Importação de Sprites.
Como escolher ferramentas na janela do Sprite Editor
Selecione Editor de Skinning no menu suspenso no canto superior esquerdo da janela do

Editor de Sprites.
O Editor de Skinning com opções para animar um personagem

Nesta janela, você pode:
— Criar e editar ossos
— Criar e editar Geometria de Sprite
— Editar Influência dos ossos em sprites
— Crie categorias e rótulos para uso em skins e troca de sprites
Criando.o.esqueleto
Comece fazendo o esqueleto do personagem. Escolha o botão Create Bone e clique com o botão
esquerdo na área da janela principal. O primeiro clique criará um centro de osso, e o segundo marcará
a localização da ponta do osso. Esta ferramenta encadeia e aninha ossos uns dentro dos outros.
Se você quiser alterar o posicionamento do osso, pressione o botão direito do mouse e clique com o
botão esquerdo onde você quer que o novo osso seja localizado. Para controlar qual osso existente será
o pai dos ossos a serem criados, selecione o osso existente com o botão esquerdo do mouse e então crie
o novo osso.
Use o botão Edit Bone para refinar bones . O botão Split Bone permite que você divida bones em dois .
Esta é uma boa opção para fazer limbs . Se você fizer um osso da perna e clicar onde o joelho deveria
estar, o osso será dividido em coxa e panturrilha .
A aba Bone foi aberta para organizar os bones pai e filho

Você também pode reparentar e renomear bones na visualização de lista de bones. Para abrir essa
visualização, clique no botão Visibilidade à direita da barra superior e selecione a aba Bone. Para alterar
o pai do bone, basta arrastá-lo na visualização de lista. Você pode renomear bones clicando no nome
do bone ativo. Dar um nome aos bones ajudará você a encontrá-los mais tarde. Para verificar se a
hierarquia está correta, selecione o botão Preview Pose e teste algumas poses. Para redefinir as posições
dos bones, pressione o botão Reset Pose na barra de ferramentas.
Sprite.Geometria
Para atribuir sprites aos ossos, será necessário que a geometria deles seja criada.
Comece pressionando o botão Auto Geometry . Uma pequena janela pop-up será aberta, permitindo
que você defina como a geometria será criada .
É uma boa ideia definir todos os controles deslizantes como 0 para manter a geometria o mais simples possível.
Habilite a opção Pesos para vincular ossos aos sprites automaticamente. Clicar no botão Gerar para
todos os visíveis criará e definirá pesos de ossos para todos os sprites. Para fazer isso para
um sprite individual, basta clicar duas vezes no sprite. Isso é útil para ajustar a geometria de certos
sprites.
Geração automática de geometria de sprites

Para ir além dessa geometria gerada e ter controle total sobre vários vértices e
como a geometria se curva, a malha precisará ser editada manualmente. Use as
seguintes ferramentas:
— Criar vértice: Crie novos vértices (ou pontos), ou mova ou exclua aqueles
pontos
— Criar aresta: Cria arestas, entre dois pontos existentes ou por

criando um novo ponto usando o botão esquerdo do mouse; o botão direito do mouse
desmarca o ponto selecionado no momento e permite que você faça uma aresta entre outros
vértices
— Editar Geometria: Mover vértices
— Dividir aresta: divide uma aresta criando um vértice no meio
Use o mínimo de vértices possível. Menos vértices ajudarão você a economizar

em desempenho, já que cada posição de vértice precisa ser calculada com base na
rotação dos ossos. Menos vértices também resultam em uma curvatura de malha de melhor
aparência, já que é mais fácil definir pesos para menos pontos. Além disso, cada plataforma
de destino terá uma contagem de vértices de jogo ideal, então é sempre uma boa ideia otimizar a geometria.
Pesos
Depois que a geometria estiver boa e limpa para todos os seus sprites, é hora de
configurar os pesos . Os pesos definem a influência do osso em cada vértice de 0 a 1,
onde 0 significa que um osso não tem influência sobre o vértice e 1 significa que o vértice
se moverá como se estivesse colado ao osso . Bons pesos na malha podem permitir
uma curvatura de ótima aparência . Definir pesos incorretamente pode quebrar a ilusão do
jogo e distorcer seus sprites .
Para começar a configurar pesos, você precisa definir quais ossos afetarão um determinado
sprite . Clique no botão Bone Influence e selecione um sprite .
Definindo a influência do osso em um sprite

Na pequena janela pop-up, você pode definir quais ossos influenciam o sprite selecionado.
Defina apenas os ossos relevantes que precisam afetar o sprite e remova o resto.
A partir daqui, configure o peso usando o Pincel de Peso e o Controle Deslizante de Peso . O
Pincel de Peso adiciona rapidamente a influência do osso selecionado aos vértices pintando neles
com o mouse . O Controle Deslizante de Peso é mais preciso, permitindo que você selecione um ou
mais pontos e, em seguida, determine a influência exata de cada osso com um controle deslizante .
O pincel é útil para configuração rápida de peso, e o controle deslizante é útil para ajuste fino das áreas
onde os ossos se dobram, como cotovelos e joelhos .
Como posicionar vértices para obter a melhor aparência de flexão de membros
Dica: Ao trabalhar com cotovelos e joelhos, obtenha os melhores resultados alinhando os vértices
internos e externos a uma linha que passa pelo meio do ponto de flexão onde os dois ossos se
encontram . Essa linha deve cruzar os ossos em um ângulo de 45 graus . Esses vértices devem
ser influenciados apenas pelo osso superior . No entanto, cada personagem será diferente, então
sinta-se à vontade para mexer nos pesos e personalizar para obter os melhores resultados .
Para acelerar as coisas, abra o projeto Dragon Crashers e encontre os seguintes Prefabs de
personagens na seção de Prefabs e Variantes de Prefabs:
— Base_de_caracteres_pré-fabricada
— PV_Character_Witch (usa uma biblioteca de Sprites diferente para religação

automática)
— PV_Personagem_Cavaleiro
— PV_Personagem_Wolfman
— PV_Personagem_Esqueleto
Esses Prefabs são ótimos exemplos de animações compartilháveis entre personagens da mesma
estrutura.

Cinemática Inversa 2D
Você provavelmente não pensa nisso todos os dias, mas o movimento do corpo humano é muito
complexo. Se você quiser pegar um copo de água de uma mesa, sua mão deve se mover até o ponto no
espaço que o copo ocupa. Você faz tudo isso sem nem pensar em girar seu braço e antebraço,
enquanto seu cérebro processa esses cálculos em segundo plano.
Para animar o mesmo movimento em um jogo, a rotação do braço e do antebraço precisa ser animada
ao mesmo tempo. É uma tarefa desafiadora combinar as duas rotações enquanto faz um movimento
de mão crível. A ferramenta 2D Inverse Kinematics (2D IK) , que faz parte do pacote 2D Animation,
calcula as rotações e permite que uma cadeia de ossos as mova para posições-alvo.
Para começar, você primeiro precisará adicionar um IK Manager 2D no objeto no topo da hierarquia.
Este componente será responsável por gerenciar todos os IK Solvers
no personagem .
Componente 2D do Gerenciador IK
Clicar no botão + adicionará um novo solucionador. O solucionador calculará a rotação dos

ossos para corresponder à transformação alvo. Há três solucionadores disponíveis:
— Membro: Este é o solucionador padrão usado para pernas e braços, que pode resolver até dois
ossos e o Efetor.
— Cadeia (CCD) – Descida de Coordenadas Cíclica: Este solucionador se torna gradualmente mais
preciso quanto mais vezes o algoritmo é executado e é adequado para uma cadeia maior
de ossos.
— Cadeia (FABRIK) – Cinemática Inversa de Alcance para Frente e para Trás:

Assim como Chain (CCD), essa solução se torna mais precisa quanto mais vezes seu algoritmo
é executado. Ela se adapta rapidamente se os ossos forem manipulados em tempo real para
diferentes posições.
Em personagens humanoides, o Limb Solver é a melhor escolha porque é mais rápido e otimizado
para membros de dois ossos. Comece adicionando o Limb Solver à lista do IK Manager 2D, o que
criará um novo GameObject que incluirá o componente Limb Solver 2D. Renomeie este GameObject
para algo descritivo como “Leg R LimbSolver2D” ou “Arm L LimbSolver2D”.

Componente 2D do Limb Solver
Para funcionar, o solver precisa de dois GameObject Transforms: o Effector e o Target . O

Effector é colocado dentro do último osso de uma cadeia, por exemplo, o osso da ponta de um
dedo, e de lá, ele tentará alcançar a posição do Target .
Primeiro, crie o Effector . Ao criar um IK para uma perna, há dois ossos: a coxa e a
panturrilha (ou canela). Coloque o Effector como um filho do osso da panturrilha
selecionando-o e criando um novo Empty GameObject . Renomeie o GameObject como Leg
Effector e mova o Effector para a ponta do osso .
Adicione o Effector recém-criado ao campo Effector no Limb Solver 2D e pressione o botão

Create Target . Um GameObject alvo será criado dentro do objeto Limb Solver .
Agora, quando o objeto alvo se move, a perna o seguirá.
2D IK em ação: quando você move o GameObject Alvo, as rotações da coxa e da panturrilha serão calculadas automaticamente
para corresponder à posição do Alvo.
Repita todo o processo de adicionar IKs com os outros membros. IKs também podem ser
adicionados em ossos que não sejam membros, por exemplo, na cabeça e no pescoço, o
que permite que o personagem olhe ao redor para as coisas.
Depois que você dominar isso, há casos de uso mais avançados. Por exemplo, você pode
configurar IKs para fazer seu personagem mirar uma arma ou criar uma animação de
caminhada procedural.

Troca de Sprites e Skins
Nem tudo pode ser animado girando um osso. Às vezes, você precisa de outra expressão
facial ou pose de mão. Neste caso, você pode trocar um sprite por outro usando Sprite Swap.
Comece a usar o Sprite Swap atribuindo uma categoria e rótulo a cada um dos sprites do
personagem. A maneira mais rápida de atribuir aos sprites é pelo Skinning Editor. Pressione
o botão Visibility e vá para a aba Sprite, onde você encontrará uma lista de todos os sprites. Se
você colocou as camadas para swap em grupos separados antes de exportar para o PSB, elas
devem ser agrupadas agora. Isso é importante porque os sprites agrupados serão
adicionados ao Sprite Resolver para permitir o Sprite Swapping.
Atribuindo categoria e rótulo a cada sprite no Editor de Skinning (sprites com a mesma categoria podem ser usados e trocados em
Resolvedor de Sprites)
Selecione todos os sprites e grupos na lista e clique com o botão direito neles. Em seguida,
selecione as duas opções a seguir em ordem: Convert Layer to Category e Convert Group
to Category. Essas opções atribuirão uma Category e Label apropriados a cada sprite
automaticamente.
Os sprites que devem ser trocados estarão em uma categoria com base no nome do grupo.
Clique no botão Apply no topo. Um ativo Sprite Library será criado dentro do Prefab do personagem,
contendo todas as categorias e rótulos criados até agora.
Lembre-se deste recurso, pois ele será necessário mais tarde.
Se você der uma olhada nos sprites que estavam nos grupos, verá que agora há um sprite por
categoria, com o componente Sprite Resolver adicionado.

Componente Sprite Resolver
Os sprites que deveriam ser trocados foram adicionados ao Sprite Resolver, e agora você pode
implementar a troca de sprites clicando neles.
Use o Sprite Swap para animar expressões faciais, olhos e bocas, fazer animações sincronizadas
com os lábios, mudar gestos de mão e muito mais. O Sprite Swap também permite que equipamentos
de personagens, como chapéus e armaduras, sejam trocados.
Peles
Os ativos da Sprite Library permitem que você crie skins para seu personagem. Uma skin muda a
aparência do personagem enquanto retém suas animações, o que é uma grande economia de tempo,
de fato. Um personagem base pode ter todos os scripts, e qualquer mudança também será aplicada a
outros personagens.
Aqui está o fluxo de trabalho para configurar o suporte de skin nos personagens:
1. Finalize um personagem base: monte o Rig, configure IKs e Sprite Library. Crie um Prefab do
personagem. Você pode animar o personagem a qualquer momento.
2 . Vá para o Skinning Editor do personagem base e clique no botão Copy na barra de ferramentas .
Isso copiará bones e meshes com pesos .
3. Crie uma variante pré-fabricada deste personagem – este será o novo personagem
com um novo visual.
4. Importe o PSB do novo personagem e abra seu Editor de Skinning.
5. Cole o esqueleto copiado da etapa 2 clicando no botão Colar em

a barra de ferramentas . Certifique-se de que as opções Bones e Mesh estejam selecionadas na
janela pop-up e clique no botão Paste para confirmar .
6. Corrija a geometria para que ela se encaixe nos novos sprites. Verifique novamente os pesos.
7 . Pressione o botão Visibility e vá para a aba Sprite . Selecione todos os sprites e grupos na lista,
clique com o botão direito neles e selecione duas opções: Convert Layer to Category e Convert
Group to Category . Pressione o botão Apply no topo .
8. Vá para a variante Prefab criada na etapa 3. Vá para o componente Sprite Library e troque
o recurso Sprite Library por um novo personagem.
9. Para criar novos personagens, siga os passos 2 a 8.

Escolhendo o recurso da biblioteca Sprite no componente da biblioteca Sprite
Seguindo esse fluxo de trabalho, você terá um Prefab de personagem base. Outros personagens
serão Variants desse Prefab, então eles terão os mesmos componentes do Prefab base. Se
mudanças forem feitas no personagem base, por exemplo, adicionando ou mudando IKs ou Sorting Groups,
outros personagens herdarão essas mudanças.
Noções básicas de animação
Animações são muito importantes se você deseja criar personagens convincentes.
Criar uma ótima animação requer que você aprenda os princípios da animação e as ferramentas para
aplicá-los. Aprender os princípios básicos da animação é frequentemente negligenciado, mas seu jogo se
beneficiará muito se você gastar um pouco de tempo polindo o movimento do seu personagem.
Para criar sua primeira animação, abra uma janela de animação acessando Janela.>.
Animação.>.Animação .
A janela de animação

Selecione seu personagem . Clicar no botão Criar criará o primeiro Clipe de Animação, e você pode
começar dando um nome ao clipe . Um Clipe de Animação é como uma gravação linear de como a
posição, rotação, escala e outras propriedades de um objeto mudam ao longo do tempo . Ele também
cria um Controlador Animador, que se encarrega de todos os clipes de animação e mantém o controle
de qual clipe deve ser reproduzido e quando as animações devem mudar ou se misturar .
Comece a animar clicando no botão vermelho Record . Agora, todas as alterações feitas no personagem
serão gravadas em um clipe de animação .
Quando o botão Gravar é pressionado, cada alteração criará um quadro-chave na Linha do tempo da animação.
No lado direito da Visualização de Animação está a linha do tempo do clipe atual.

Os quadros-chave para cada propriedade animada aparecem nesta linha do tempo. A linha de
cabeçalho vertical branca mostra o quadro atual – certifique-se de que esteja no quadro 0. Pose
seu personagem como você quiser. Um ou mais quadros-chave serão criados na linha do tempo, e à
esquerda os nomes das propriedades animadas atuais serão mostrados.
Agora, mova a linha da cabeça alguns quadros para frente e mude a pose do personagem.
Um novo quadro-chave (ou quadros-chave) aparecerá.
Adicionar outro quadro-chave ao longo da Linha do tempo cria uma animação que interpolará os quadros-chave.
Ao pressionar o botão Play, você verá seu personagem se movendo . Você criou sua primeira
animação .

Animando.Sprite.Swap.–.expressões.faciais
A animação de troca de sprites funciona de forma semelhante, mas requer uma etapa
adicional ao definir quadros-chave.
Como animar o Sprite Resolver desabilitando a interpolação de quadros-chave
Defina os novos quadros-chave escolhendo um sprite no componente Sprite Resolver.

Por padrão, os valores entre quadros-chave são interpolados, o que significa que se você
quiser mudar do primeiro sprite na lista para o último em um quadro posterior, todos os
sprites entre eles serão mostrados. O Sprite Resolver usa números inteiros para definir o
índice de cada sprite, então a interpolação neste caso não é desejada.
Para evitar isso, selecione todos os keyframes contendo valores do Sprite Resolver,
clique com o botão direito e selecione Both Tangents – Constant . Agora, a linha do
tempo da animação irá “segurar” os valores após os keyframes, em vez de interpolá-los, e
a animação Sprite Swap deverá ser reproduzida corretamente .
Definindo tangentes constantes em quadros-chave do Sprite Resolver para que os valores não sejam interpolados

— Instale o pacote Burst para melhorar o desempenho da animação 2D.
— Ao fazer um esqueleto, evite usar mais ossos e sprites do que você

precisar .
— Simplifique as malhas de esqueleto usando o mínimo de vértices possível.
— Ative Culling nos animadores. Esta opção será desativada quando o

personagem animado estiver fora da tela para economizar desempenho.
— Evite usar animações esqueléticas para objetos ou personagens pequenos ou

em grande número, como pássaros de fundo, moscas ou pequenos animais.
Em vez disso, use técnicas diferentes, como animação quadro a quadro ou shaders.

2D.Luzes
O avançado sistema de iluminação dinâmica 2D do Unity , em conjunto com mapas normais e mapas
de máscara, faz seus personagens se destacarem com lindas silhuetas iluminadas e detalhes
claramente sombreados.
Ambientes iluminados são mais envolventes e críveis devido à sutileza

interações entre personagens, objetos e sistema de iluminação.
Luzes 2D podem ser parte integrante da jogabilidade. Por exemplo, você pode usá-las para criar
uma lanterna para o jogador, pois ela ilumina apenas parte de um corredor escuro como breu, ou
para mostrar o cone de visão de uma câmera de vigilância que o jogador precisa evitar.
A iluminação dinâmica pode mudar drasticamente o clima de um nível, realçar os detalhes da parede
iluminada por tochas de uma caverna, atuar como feixes de luz que passam por uma janela para
iluminar partículas de poeira cintilantes ou simplesmente ser animada para simular o ciclo do dia e da noite.
Vamos dar uma olhada na variedade de luzes 2D que você pode criar e como personalizá-las.
Imagem de Tails of Iron por Oddbug Studio
Uma imagem de Ultimate Action Hero, um jogo em desenvolvimento por Jarek Majewski.

Tipos e casos de uso
Para adicionar uma nova luz 2D, vá para GameObject.>.Light.>.2D e selecione um tipo de luz.
Adicionando uma luz 2D à cena
Existem cinco tipos de formas de luzes 2D.
Forma livre
Este tipo de luz tem um formato poligonal que pode ser editado de forma similar
ao Sprite Shape . Esta é uma boa ferramenta para iluminar eficientemente uma
grande parte do ambiente (como uma piscina de lava), simular formas de luz
(como raios de sol vindos de um buraco no teto) ou se conformar ao formato de
uma janela onde a luz é projetada .
Editando a luz 2D de forma livre

Sprite
Este formato permite o uso de qualquer sprite como textura de luz. Isso é útil se você
quiser um formato específico que seja impossível de ser alcançado com outros
tipos de luz. Alguns bons exemplos de texturas possíveis são reflexos de lente,
brilhos, biscoitos de luz, projeções de formas de luz como luzes de bola de discoteca
ou lâmpadas de bebê projetando estrelas contra a parede.
Sprite Light em ação
Paramétrico
Essas luzes podem ter o formato de um polígono de n lados. Esse é um tipo

específico de luz que pode ser usado em ambientes inorgânicos ou estilizados.
Em versões futuras do Unity, esses tipos de luz serão formas padrão dentro das
opções de luz Freeform.
Luzes paramétricas com 3, 5 e 8 lados

Ponto/Ponto
O formato desta luz pode ser um círculo ou um setor circular. Esta opção é boa
para holofotes ou para iluminar um ponto específico com fogos de tocha, velas,
luzes de carro, lanternas, luz volumétrica e assim por diante.
Luz pontual com arcos completos e parciais
Global
Uma Global Light não tem uma forma e, em vez disso, ilumina todos os objetos nas
camadas de classificação direcionadas. Apenas uma Global Light pode ser usada por
Blend Style (o método de interação entre a luz e os sprites) e por camada de classificação.
Use-a primeiro para adicionar uma luz de ambiente base.
Opção para Global Light

Como usar luzes 2D

As Luzes 2D funcionam com o Sprite Renderer, o Sprite Shape Renderer e o Tilemap Renderer.
Para se adequar ao fluxo de trabalho, elas usam as Camadas de Classificação. Cada luz pode afetar
uma ou mais camadas de classificação. Selecione quais camadas serão afetadas na lista suspensa
Camadas de Classificação de Destino.
Selecionando quais camadas de classificação devem ser afetadas pela luz 2D
Configurando luzes 2D em Tails of Iron por Oddbug Studio
Para controlar a ordem de renderização das luzes que estão na mesma Camada de Classificação, use
a opção Ordem das Luzes.
A opção Estilo de mesclagem permite que você selecione o estilo de mesclagem usado por esta Luz.
Diferentes estilos de blend podem ser personalizados no 2D Renderer Asset. Leia mais sobre
propriedades comuns usadas pelos diferentes tipos de Light aqui.
A opção Alpha Blend on Overlap mistura luzes sobrepostas em vez de multiplicar sua
intensidade. Esta opção pode transformar luz 2D em sombras. Basta definir a intensidade da luz abaixo
de 1 e escolher uma cor azul claro. Você também pode anexá-la a um personagem para projetar
uma sombra sutil.

Modos de sobreposição de luzes 2D
Usando Alpha Blend em Overlap para transformar luz 2D em sombra
Textura secundária (mapas de sprites)
Adicionando texturas secundárias aos sprites
Mapas normais e mapas de máscara são opcionais ao usar Luzes 2D, mas eles podem levar os
visuais do seu jogo a um nível totalmente novo se você tiver orçamento, tempo e recursos de
arte para isso. Personagens e o ambiente terão ainda mais
detalhes que reagem à luz, fazendo com que suas formas pareçam mais definidas e tridimensionais.

Cada ativo de sprite pode ter Texturas Secundárias opcionais atribuídas. Essas texturas podem
ser usadas por Materiais. Altere as Texturas Secundárias indo em Sprite.Editor.>.Secondary.Textures.
Por padrão, você pode atribuir dois tipos de texturas: mapa normal e mapa de máscara. O mapa normal
contém o ângulo de cada pixel no objeto, e o mapa de máscara pode ser usado para iluminação de borda
e muito mais. Você pode adicionar suas próprias texturas e referenciá-las pelo nome em shaders do Shader
Graph .
Adicionando texturas secundárias aos sprites
Há alguns bons motivos para atribuir texturas no nível do ativo em vez de no material.
Um benefício é que os renderizadores de sprites e outros renderizadores que usam sprites podem
compartilhar um material, mesmo quando os sprites e as texturas secundárias são diferentes.
Isso significa que eles podem ser agrupados para renderizar com mais eficiência.
Você precisará adicionar mapas normais e mapas de máscara a um material quando tiver um shader
de sprite. Cada sprite precisaria de seu próprio material com um sprite, mapa normal e mapa de
máscara. Isso rapidamente aumentaria para centenas de materiais no projeto. No entanto, ao definir
as texturas adicionais para cada sprite, você pode usar apenas um Material de Sprite. Um material
também significa uma chamada de desenho em vez de centenas.

Usar o Frame Debugger permite que você observe cada passo dado para renderizar um frame . Ter muitos Materials que não podem ser
agrupados prejudica o desempenho .
Mapas normais
Um mapa normal bem feito pode criar ou destruir a ilusão de um sprite ser 3D.
Cada pixel em um mapa normal armazena dados sobre os ângulos da textura principal.
Os canais vermelho, verde e azul (RGB) armazenam dados de ângulo para as
coordenadas X, Y e Z. Cada luz que usa um mapa normal tem uma direção, e pixels
em uma textura com um mapa normal são sombreados com base nessa direção e
na direção do pixel. Isso funciona da mesma forma que na vida real – se um pixel
estiver voltado para a direção da luz, ele será aceso, e se estiver voltado para longe, não receberá luz.
Agora, veja como os valores RGB afetam os ângulos de um mapa normal.
Um mapa normal

A imagem acima é um mapa normal em que os pixels estão voltados para a câmera.
Seus valores RGB são 127, 127 e 255, respectivamente. Cada canal de cor pode ter um valor de 0 a 255,
então 127 está próximo do meio. Para ficar de frente para a superfície à esquerda (-90 graus), o valor
de cor R precisa ser definido como 0. Para ficar de frente para a superfície à direita, defina R como 255.
Para ficar de frente para baixo ou para cima, defina o canal G como 0 ou 255, respectivamente.
Preparando.sprites.para.iluminação.2D
Tome nota do sprite de cor base . Se você planeja usar iluminação 2D

extensivamente em seu jogo e quer aproveitar ao máximo os mapas normais, não pinte a luz e a
sombra no sprite .
A iluminação 2D não fica boa em um sprite que já tem sombras pintadas.

Você também acabará fazendo o dobro de trabalho porque estará pintando a iluminação nos mapas
normais. Em vez disso, pinte algumas sombras não direcionais, e seu sprite ficará melhor, desde que
você evite qualquer luz direcional, como a do sol.
Com as Luzes 2D desativadas, o sprite tem as informações de cor (albedo), mas parece plano porque não contém informações de luz ou sombra.
Técnicas normais de pintura de mapas
Uma maneira de pintar um mapa normal é fazer desenhos do seu sprite que são iluminados de
ângulos diferentes, então combiná-los em uma textura. O sprite será iluminado com uma luz da direita
no canal R e uma luz do topo no canal G. No canal B, o sprite é iluminado pela frente, mas para
simplificar, você pode omitir esse canal ao usar um mapa normal com sprites 2D.
Isso ocorre porque a iluminação frontal em 2D não acrescenta muito ao sombreamento geral.
No entanto, essa abordagem pode levar tempo, pois você precisará pintar o sombreamento pelo
menos duas vezes para os eixos X e Y.

Como combinar duas imagens em tons de cinza sombreados (iluminadas de cima e da direita) em um mapa normal
Outra abordagem de pintura é usar um aplicativo gerador de mapa normal. Abra um sprite em um aplicativo
gerador e você pode gerar um mapa normal com apenas alguns cliques.
Os aplicativos geradores não levam em conta os ângulos do seu sprite, então evite usá-los no sprite inteiro.
Eles também não reconhecem os objetos. Em vez disso, eles estimam formas a partir das cores do sprite
ou adicionando um filtro geral semelhante ao chanfro ou relevo de aplicativos de edição de imagem ou uma
escultura em relevo. Eles não conseguem reconhecer os ângulos do rosto, por exemplo, mas tentam
adivinhar onde deve haver uma mudança em um ângulo. É uma limitação, mas eles ainda são úteis para gerar
os mapas normais de seções de sprite que são chanfradas, como correntes, cabos ou uma cauda de dragão,
e também normais de superfície para tijolos, pedras, madeira e outros.
Importe uma seção para o gerador de mapas normal, ajuste os valores, exporte e adicione você mesmo as
partes e os detalhes necessários.
Gerando fendas no mapa normal usando a ferramenta Emboss no Sprite Illuminator

Para a última técnica, o Unity oferece uma maneira de gerar mapas normais a partir de
um heightmap em tons de cinza. Esta é uma textura onde o preto representa a altura
mínima da superfície e o branco a altura máxima. Você precisa importar uma imagem como
um normal.map e marcar a opção Create from Grayscale. Esta técnica é útil para gerar
rapidamente mapas normais sem nunca sair do mecanismo.
Ao usar esse método, o controle deslizante Bumpiness aparecerá no Inspector . O Unity usa o
brilho do pixel e converte as diferenças de altura em ângulos normais do mapa, e esse
controle deslizante controla a inclinação desses ângulos . Um valor baixo de bumpiness
significa que mesmo um contraste acentuado no mapa de altura será traduzido em ângulos e
bumps mais suaves .
Convertendo textura em mapa normal usando a opção Criar a partir de escala de cinza
Como.pintar.mapas.normais.em.sprites
Para pintar um mapa normal, comece aprendendo quais cores usar para diferentes ângulos.
Primeiro, obtenha uma paleta de mapa normal para que você possa experimentar
as cores usadas para representar os ângulos da superfície. Encontre paletas online ou
simplesmente use a paleta de cores da imagem do capítulo de mapas normais. Não
importa como seu fluxo de trabalho de pintura se pareça, você só precisará copiar uma
paleta para seu aplicativo de pintura favorito e usar o seletor de cores para selecionar uma cor para pintar em seu mapa nor
As cores dos ângulos não precisam ser 100% precisas; alguns graus não farão
diferença. No entanto, certifique-se de manter a forma geral do sprite crível. Se você usar uma
cor de ângulo que não faça sentido no contexto, a forma inteira vai desmoronar quando acesa.
Pintar mapas normais pode ser complicado inicialmente porque requer uma boa imaginação
espacial. Um ótimo lugar para começar é com algo simples como os planos de base da cabeça.
Este modelo simplificado de uma cabeça humana tem uma aparência low-poly, e você pode
conferir este exemplo preparado aqui .
Ao pintar um mapa normal, tente imaginar as formas 3D básicas que são partes do seu
sprite, então visualize os ângulos de cada parte individual. Se você souber o ângulo, saberá
de qual parte do sprite da paleta amostrar a cor.

Como amostrar um ângulo de uma paleta de mapa normal.
Este exemplo está funcionando em uma superfície plana, mas o processo é similar quando você está
pintando com pincéis mais macios. Você pode misturar bordas duras para obter uma
aparência mais natural.
Alguns atalhos para observar: Quando há uma forma esférica, você pode colar a esfera normal da sua
paleta . Quando você tem uma forma cilíndrica, você pode pegar uma parte da esfera, colar e esticá-
la, ou fazer um gradiente .
Esteja ciente de que copiar e colar partes de mapas normais e girá-los quebra o sombreamento.
No entanto, isso também pode ser usado a seu favor. Por exemplo, quando você precisa de uma
forma esférica côncava, basta girar a esfera 180 graus para criar um buraco.
Para que um mapa normal seja exibido em um ou mais sprites, você precisa habilitar a função de
mapa normal nas luzes.
Configurações normais de suporte de mapa no 2D Light
Escolha o método de geração de mapas normais que funciona melhor para você. Provavelmente
haverá muitos ativos feitos para seu jogo, então foque nos objetos que serão mais visíveis e
simplifique as outras partes do jogo.

É assim que o mapa normal aparece em um sprite branco no mecanismo.
Algumas ferramentas que podem ajudar incluem:
— Pintor Normal
— Pincel Tangente Normal do Krita
— Iluminador Sprite
— Laigter
— Lâmpada Sprite
Adicionando iluminação de borda com Mask Maps
Rim lighting é um efeito usado para destacar os contornos de um personagem.

Ele simula a luz vinda de trás de um objeto e as propriedades naturais de
dispersão de luz. Isso é chamado de efeito Fresnel. Na vida real, mais luz é
refletida dos objetos quando o ângulo em que a luz atinge a superfície é mais amplo.
Ilustração do efeito Fresnel

É por isso que a água em um lago é mais reflexiva à distância, mas podemos ver nossos pés
na água quando olhamos para baixo. É também por isso que os objetos são mais reflexivos em
suas bordas.
Em gráficos 2D, você pode simular esse efeito usando uma textura adicional chamada Mask Map e
uma luz especial chamada Blend Style.
Blend Styles determinam a maneira como uma luz específica interage com sprites em uma
cena. Light Blend Styles estão localizados no ativo 2D Renderer.
Definindo opções de Light Blend Styles no ativo 2D Renderer Data
Em Light Bend Styles há quatro opções para diferentes estilos de mesclagem. Deixe a primeira
opção intocada porque é a padrão e, em vez disso, trabalhe na segunda opção.
Dê a ele um nome como “Rim Light” ou “Fresnel” ou o que funcionar para você. Defina o
canal Mask Texture como R – as luzes usarão a cor vermelha da nossa textura Mask Map. Por
fim, defina o Blend Mode como Additive. Isso fará com que as luzes sejam adicionadas sobre a
iluminação existente, aumentando o brilho.

Pintando.o.Mapa.da.Máscara
A luz Fresnel usa o canal vermelho do Mask Map, mas para simplificar, vamos pintar em
preto e branco. As partes que refletirão a luz serão brancas, e as partes não refletivas serão pretas.
O efeito Fresnel afeta as bordas dos objetos, então copie o sprite base, pinte-o de preto e, em
seguida, realce as bordas de branco. Ele deve começar a se assemelhar a um objeto que tem
uma luz brilhante brilhando atrás dele. Para acelerar as coisas, adicione um efeito Inner Glow no objeto
e pinte alguns detalhes em cima. Infelizmente, não há nenhum aplicativo que possa acelerar
esse processo, então você precisará confiar em suas habilidades de pintura aqui.
Mapa de máscara para um sprite de

cabeça de plano base
Configuração.Fresnel.luz
Para fazer com que a luz afete o Mapa de Máscara, altere seu Estilo de Mesclagem para o
criado anteriormente.
Alterando o estilo de mesclagem da luz para Rim Light

Editando formas no componente Shadow Caster 2D
As luzes Fresnel funcionam melhor com a opção Use Normal Maps habilitada e com
Distance definida para um valor baixo. Isso evita destacar o outro lado do objeto.
Adicionando sombras 2D com luzes 2D
Luzes 2D também podem projetar sombras em uma cena. Para um GameObject

projetar uma sombra de luz 2D, adicione um componente Shadow Caster 2D ao objeto.
Efeito de iluminação de borda em um sprite no Unity Editor
Use o editor de formas do Shadow Caster para editar sua geometria para que ela se ajuste
à silhueta do objeto. A luz também precisa ter algumas opções definidas para projetar uma sombra.
Opções de luzes 2D usadas ao usar sombras

Use a opção Shadow Intensity para ver a sombra . Esta configuração determina a opacidade da luz em
outros objetos que estão nas sombras . Quando definida como 1, a luz não iluminará nada na área de
sombra .
Você também pode tornar a área afetada pela luz visível usando a opção Volume.Opacity . A Shadow
Volume Intensity controla a opacidade do volume de luz na área de sombra .
Among Us por InnerSloth . Além de melhorar o lado visual dos jogos, as sombras também podem ser uma parte crucial da jogabilidade .
Como usar luzes 2D em diferentes renderizadores
Luzes 2D podem ser usadas junto com mapas normais e mapas de máscara em sprites, mas você
também pode usá-las em renderizadores diferentes. Vamos ver como.
2D.Mapa de blocos
Para usar 2D Lights em Tilemaps, atribua as texturas normal map e mask map aos sprites que são
usados como tiles usando o módulo Secondary Textures do Sprite Editor. As texturas secundárias
serão usadas automaticamente pelo sistema 2D Lights.
Tilemaps com mapas secundários

Luzes 2D com mapeamento normal e mapas de máscara no Tilemap 2D
2D.Sprite.Forma
O Sprite Shape Renderer usa dois materiais diferentes por objeto: um para Fill e
um para Edge . O Edge Material usa Secondary Maps do Sprite asset . Para a
área Fill, use a textura com o modo wrap definido como Repeat para tile em vez do
sprite . Você precisará criar um novo Fill material com Material Property Block
habilitado para definir texturas secundárias .
Exemplo de GameObjects de Sprite Shape usando mapas normais

Exemplo de GameObjects de Sprite Shape usando mapas normais
2D.PSD.Importador.para.personagens.animados
Definir texturas secundárias no importador PSD 2D funciona de forma semelhante, com uma
pequena diferença em relação aos mapas normais.
A maneira mais rápida de criar um mapa normal e um mapa de máscara para um personagem
importado em PSD 2D é trabalhar a partir de um arquivo .PSB de personagem base.
1. Conclua estas etapas para adicionar um mapa normal a um personagem animado:
2. Duplique o arquivo .PSB do caractere base. Renomeie o arquivo duplicado adicionando

um sufixo para seu nome, por exemplo: _normal
3. Abra este arquivo no seu editor de imagens preferido e pinte um mapa normal nele.
cada camada . Salve o arquivo .
4. Quando um PSB com um mapa normal é importado para o Unity, você precisará definir o
Texture Type para Sprite e ir para Advanced settings para desmarcar a opção
sRGB(Color Texture) . Um mapa normal não contém dados sRGB de cor, apenas valores de
ângulo.
5. Atribua este arquivo PSB como uma textura secundária do seu personagem base.
Para criar um mapa de máscara, repita o processo, dê ao arquivo duplicado outro sufixo e pule a
etapa 3.

Adicionando um mapa normal a um personagem animado
— Evite usar muitas luzes em uma cena.
— Use o mínimo possível de camadas de classificação e estilos de mesclagem de luz.
— Defina um valor menor para a Escala de Textura de Renderização em Estilos de Mesclagem de Luz de 2D
Ativos do renderizador.
— Ao usar mapas normais, defina a Qualidade de iluminação normal das luzes como Rápida
em vez de Preciso.
— Use sombras 2D apenas em algumas luzes.

Avançado.
efeitos visuais
Efeitos visuais (VFX) são a cereja do bolo de qualquer jogo de ótima aparência, e são vitais
para a experiência dos jogadores enquanto jogam. VFX comunicam eventos do jogo, como perigos
ambientais e zonas de cura, e recompensam visualmente o jogador por ações bem executadas,
como uma cena de ação culminando em uma grande explosão de fogo.
O Unity fornece muitas opções para adicionar VFX ao seu jogo. Você pode adicionar animações
quadro a quadro feitas em outro software, animar partículas ou adicionar shaders animados.
Animações quadro a quadro
A animação quadro a quadro (ou flipbook) permite que você adicione efeitos rapidamente no Unity.
Basta importar quadros como sprites e, em seguida, animar a Propriedade Sprite ao longo do tempo
na janela Animação. Você também pode selecionar e arrastar todos os sprites de quadro para a
Cena, o que os animará automaticamente.
Embora importar quadros seja rápido, desenhar cada quadro a ser animado não é, e esse processo
pode exigir muito mais tempo e habilidade do que você tem disponível. Para economizar tempo, você
pode exportar VFX como quadros de outros aplicativos.
Outro atalho que você pode usar é selecionar todos os ativos de quadro de animação da
visualização Project e arrastá-los para a visualização Hierarchy ou Scene . Um novo GameObject
será criado com uma animação que usa a sequência feita das imagens selecionadas anteriormente .
A técnica de animação flipbook é muito performática, então use-a quando quiser ter muitas instâncias
do efeito na tela. Lembre-se de que muitos quadros em alta resolução exigirão mais memória.

Animação quadro a quadro de uma chama
A animação quadro a quadro também pode ser usada em Sistemas de Partículas, onde é chamada
de Animação de Folha de Textura.
Configurando animação quadro a quadro no Particle System
As animações do Flipbook também podem ser usadas no Shader Graph animando a posição UV da
textura ao longo do tempo, o que cria a ilusão de quadros em movimento.
Animação de flipbook no Shader Graph

Partículas
O Particle System permite que você exiba e anime muitas imagens ou malhas
menores para obter um único efeito visual. Propriedades de partículas como
tamanho, velocidade, cor e rotação podem ser animadas ao longo do tempo usando
certas regras predefinidas e randomização. Isso permite que você crie efeitos
dinâmicos como fogo, explosões, fumaça, feitiços mágicos e assim por diante.
Você cria um novo Sistema de Partículas selecionando a opção de menu GameObject.>.

Efeitos.>.Sistema.de.Partículas .
Propriedades do sistema de partículas

Main.Module.propriedades
O Sistema de Partículas tem muitos módulos, mas vamos abordar alguns dos essenciais.
O primeiro módulo contém propriedades básicas das partículas:
— Duração: Quanto tempo o sistema irá funcionar
— Looping: Se todo o sistema ficará em loop para sempre
— Velocidade: A velocidade inicial das partículas
— Tamanho inicial: O tamanho inicial das partículas
— Cor: A cor inicial das partículas
— Gravidade: Força da gravidade aplicada às partículas
Emissão
Emission controla a taxa e o tempo das partículas emitidas, enquanto Rate controla quantas
partículas são emitidas por unidade de tempo. Você também pode criar rajadas de partículas,
especificando quantas gerar e quando.
Forma
Este módulo define o volume ou superfície da qual as partículas podem ser emitidas, e a direção em
que elas viajarão. A propriedade Shape define a forma do volume de emissão.
Cor.sobre.Vida.útil
Você pode controlar a cor e a opacidade das partículas ao longo de sua vida útil avaliando o gradiente .
À esquerda do gradiente está a cor inicial, e à direita está a cor que as partículas terão quando
morrerem .
Tamanho.Ao.Vida.Vida
Esta configuração define o tamanho de uma partícula ao longo do eixo horizontal de uma curva.
Rotação.Ao.Vida.Vida
A rotação ao longo da vida dá às partículas uma velocidade de rotação.
Barulho
Este módulo adicionará aleatoriedade ao movimento das partículas. É uma maneira muito rápida de adicionar
efeitos interessantes e de aparência complexa, como feitiços mágicos, energia de ficção científica, fogo
de exaustão, partículas de poeira e muito mais.

Renderizador
O módulo Renderer
O módulo Renderer, como visto acima, permite que você altere a aparência das partículas. Há muitas
configurações, mas a mais importante a ser alterada é a configuração Material, onde você pode adicionar
um novo material com uma textura.
Partículas randomizadas
Propriedade de partícula aleatória
A maioria das propriedades das partículas pode ser randomizada para obter uma aparência imprevisível
e natural.
O menu suspenso à direita da propriedade da partícula permite que você escolha entre diferentes
opções de randomização.
Os sistemas de partículas também podem ser aninhados uns dentro dos outros. O aninhamento faz com
que os sistemas sejam reproduzidos simultaneamente, o que permite que você alcance alguns efeitos muito complexos.
Por exemplo, para criar uma explosão, você pode combinar um sistema para fumaça, um para pequenas
faíscas e um para detritos voadores.
O Particle System é uma ferramenta muito poderosa que permite que você crie quase qualquer VFX para
seu jogo. Você pode até mesmo fazer seus efeitos brilharem usando o HDR unlit shader e o Bloom post-
processing. Teste cada propriedade, pois até mesmo as partículas mais simples farão seu jogo
parecer polido.
Para acelerar significativamente o processo de criação do seu jogo, verifique a Asset Store para obter
efeitos visuais de partículas pré-fabricados .

Gráfico de sombreamento
Outra maneira de fazer VFX é usando shaders . Shaders são um conjunto de instruções
para o processador gráfico, e eles podem, por exemplo, calcular cores de pixel ou
posições de vértices .
O Shader Graph permite que você crie shaders visualmente. Em vez de escrever código, você cria e
conecta nós em uma estrutura de gráfico. O Shader Graph fornece feedback instantâneo que reflete
suas alterações, e é simples o suficiente para usuários que são novos na criação de shaders.
Com o Shader Graph você pode:
— Deformar e animar UVs
— Alterar processualmente a aparência da superfície
— Filtros de imagem de anúncios semelhantes aos aplicativos de edição de imagens
— Alterar a superfície de um objeto com base em informações como localização mundial,

normais, distância da câmera e muito mais
— Ajuste os visuais do shader no contexto de uma cena expondo propriedades para

Inspetor de materiais
Usando o gráfico do shader
Para começar a usar o Shader Graph para 2D, vá para a janela Projeto, clique com o
botão direito e selecione Criar.>.Shader.>.Universal.Render.Pipeline.>.Sprite.Lit.Shader.
Gráfico (ou Sprite.Unlit.Shader.Graph).
Use Sprite Lit Shader quando quiser que seu sprite seja afetado por luzes, o que será o
caso para quase todos os personagens e objetos. Use Sprite Unlit para superfícies não
iluminadas ou emissivas, como fogo, fontes de luz, eletricidade, magias, hologramas ou
personagens especiais como fantasmas.
Para começar a criar um shader, nomeie o arquivo primeiro . Isso criará seu shader inicial .
Em seguida, clique duas vezes no arquivo para entrar no modo de edição.
A janela do Shader Graph

Isso abre a janela Shader Graph . Dentro da parte central, chamada Workspace, está o
Master Stack . Esta é a saída final do Shader Graph, que é responsável pela aparência final do
shader . Deve haver apenas um Master Stack por shader .
A pilha mestre contém dois contextos, que correspondem às funções de vértice e

fragmento (ou pixel).
À esquerda, você verá um Blackboard . Ele contém propriedades que serão visíveis no Inspector
e Keywords .
No canto superior direito há um Graph Inspector, que tem duas abas: Node settings, que permite
que você altere as configurações de um Node selecionado, e Graph Settings, que altera as
configurações de todo o gráfico. No Inspector, você pode alternar o modo Precision; é uma
boa ideia defini-lo como half.on low-end devices. Você também pode trocar o shader Material
entre aceso e apagado.
A visualização principal na parte inferior é onde você pode ver o shader final.
Os nós no Shader Graph são os blocos de construção que contêm entradas, efeitos e interações.
Um gráfico procede da esquerda para a direita, então os nós terão slots de entrada à esquerda e
saídas à direita.
Para adicionar um novo nó, clique com o botão direito em qualquer lugar do espaço de trabalho e escolha Criar.
Node do menu de contexto . Você verá uma lista de todos os nodes agrupados por tipo . Selecione
Input.>.Texture.>.Sample.Texture.2D .
Um exemplo de um nó de textura 2D

Conecte o slot RGBA(4) do nó Sample Texture 2D à Base Color(3) no slot de entrada do

Master Stack. Conecte o slot A(1) ao Alpha(1). Agora, o Fragment Context do Master Stack
usará a cor e o alfa da textura que você fornecer ao nó Sample Texture 2D.
Para referenciar essa textura de fora do shader, você precisa de uma propriedade .
As propriedades expostas serão mostradas na visualização Inspetor, onde você pode modificar os parâmetros que serão usados no Gráfico.
Clique no botão Mais localizado no Blackboard e selecione Texture 2D . Selecione a

propriedade recém-criada e as opções aparecerão no Graph Inspector . Você pode alterar o
nome da propriedade, mas o mais importante é a opção Reference – altere-a para
_MainTex .
Para a textura, use o sprite, que é definido em cada Sprite Renderer . O Sprite Renderer
verificará _MainTex.property no shader do Material atual e definirá sua textura de sprite
como a textura no shader . Por fim, arraste essa propriedade do Blackboard para o
workspace e conecte-a ao slot Texture(T2).input no nó Sample Texture 2D . Clique no
botão Save Asset na barra de ferramentas e o shader será compilado .
Você pode usar o Shader Graph como qualquer outro shader no Unity. Clique com o botão
direito na janela Project, escolha Create.>.Material,.e selecione seu shader na lista. Todas
as suas propriedades estarão disponíveis para personalização.
Você pode testar seu shader aplicando o material criado a um sprite. Claro, este é o shader
mais simples com apenas uma textura. Sinta-se à vontade para experimentar e testar o resto
dos nós. Ou talvez você possa tentar adicionar um mapa normal e um Mapa de Máscara
(Máscara de Sprite) a este shader? Dicas: O Tipo 2D de Textura de Amostra precisa ser
definido como Normal para exibir corretamente o mapa normal, e você pode verificar os
nomes de referência das texturas Mapa Normal e Mapa de Máscara na janela Texturas
Secundárias no Editor de Sprite. Boa sorte!

Texturas Secundárias para o sprite do barril. Você pode verificar seus nomes e adicionar suas próprias texturas que podem ser
referenciadas no Shader Graph por nome.
Deslocamento de vértice
O shader de deslocamento de vértice afeta as posições dos vértices em uma geometria

da malha. Você pode deslocar vértices de muitas maneiras, e a maneira mais simples é
aplicar um ruído de movimento. Este shader é bom para objetos ondulantes: folhagens,
cipós e cordas pendurados, bandeiras e assim por diante. Você pode encontrar um
exemplo deste arquivo Shader Graph no projeto Dragon Crashers, com o nome de arquivo ShaderGraph_Sprite_Lit_
Parte principal do shader Waving

Para obter a animação de onda, o Gradient Noise é usado como uma máscara de onda. Seu UV
Offset é animado pelo Time.node multiplicado por um Float chamado Speed . Todos eles
afetam a posição dos vértices no.Vertex Context .
O contexto de vértice no Shader Graph modifica a posição dos vértices e o mestre de fragmentos empilha as informações dos pixels.
O sprite que será afetado pelo shader Waving precisa ter uma contagem de vértices
suficiente, caso contrário a animação ficará áspera. Para editar os vértices, use Skinning
Editor Geometry tools.
Edição de vértices

Shader Cobweb em ação (clique para ver a animação).
Mapas de fluxo
Mapas de fluxo são texturas que armazenam informações direcionais. Você pode encontrar
um shader de mapa de fluxo na demonstração do Dragon Crashers, com o nome
ShaderGraph_Lava. O shader usa a textura do mapa de fluxo para controlar a direção
das coordenadas UV da textura principal. As cores vermelho e verde são usadas para
indicar a direção XY que os pixels seguem em cada quadro, fazendo com que os pixels da textura principal “fluam”
Abra o SubGraph FlowMap para saber como obter esse efeito.
Cores de textura do mapa de fluxo explicadas: A cor vermelha controla o movimento do pixel no eixo X, a cor verde determina no
eixo Y. O shader move os pixels da textura principal nas direções que são visualizadas pelas setas.

O mapa de fluxo pintado à mão dá ao fluxo de lava um efeito viscoso e caricatural, que combina com a direção de arte do projeto.
Algumas ferramentas que você pode usar para criar mapas de fluxo incluem o Flow Map Generator/Visualizer e o Flow map painter .
Animações de limite para animação de suporte fluido
Outra técnica de animação de shader que você pode tentar é chamada de

“animated alpha clipping”, que cria uma animação suave a partir de uma única
textura. Isso ocorre ao mostrar um intervalo específico de pixels em cada
quadro com base em seus valores alfa. A textura é de canal único, então o efeito
é simples de ser alcançado. Encontre um exemplo disso em Dragon Crashers com o nome ShaderGraph_Sprite_
LimiarAnim .
Recorte alfa animado
Para atingir esse efeito, um Smoothstep.node é usado. O canal vermelho da textura

é conectado ao slot In(1), e o Vertex Color alpha controla a avaliação da borda e
suavidade do efeito Smoothstep. O Vertex Color é controlado pela propriedade
Color do Sprite Renderer, então quando você altera a opacidade do sprite, a
textura é animada. Isso permite que o shader seja utilizável, mesmo em
partículas.

Se você usar o Affinity Photo, poderá pintar a textura desse shader em preto e branco e, em
seguida, visualizar a animação usando o Ajuste de Limite enquanto move o controle deslizante de valor.
Visualizando animação de limite no Affinity Photo
Textura usada para o efeito de lava e como ela fica no jogo (veja como ela fica animada aqui)
Este efeito atinge a aparência de fluidos ou respingos, sem a necessidade de animação quadro a
quadro. Você pode aprender mais sobre esta animação na postagem da comunidade Surface Tension .

Reflexões e refrações
Uma das técnicas 2D mais comuns lida com reflexões e refrações, como aquelas que você vê na água,
gelo, vidro ou ar quente. Para atingir esse efeito, outra câmera produz as partes que serão refletidas
ou refratadas em uma textura de renderização. Essa textura é então usada em um shader, distorcida e
ajustada conforme necessário e, finalmente, produzida na tela.
O processo de configuração para reflexos de água, criado com arquivos de shader de demonstração do Lost Crypt chamados ShaderGraph Water Unlit
Adicionando brilho ao redor das luzes
Para fazer os sprites brilharem com uma luz ofuscante, combine o shader de sprite aprimorado HDR
com o efeito de pós-processamento Bloom.
Shader HDR em Dragon Crashers (ShaderGraph_Sprite_Unlit_HDRTint)

Para fazer esse efeito de luz ofuscante, multiplique a textura por um nó Color que use HDR Color
Mode . No Material, aumente o valor HDR acima de 1, com o efeito de pós-processamento Bloom
habilitado na câmera principal .
Máscara de Sprite
Máscaras de Sprite são usadas para esconder ou revelar partes de um sprite ou grupo de
sprites. Por exemplo, você pode esconder parte de uma imagem para produzir um efeito de portal ou
fazer uma carta colecionável com um efeito 3D.
Para criar uma Máscara de Sprite, vá ao menu e selecione GameObject.>.2D.Object.

>.Sprite.Mask ..Em seguida, escolha um sprite para ser usado como uma forma de máscara. Tenha em
mente que o sprite da máscara em si não será visível. Defina as Camadas de Classificação nas quais a
máscara funcionará.
Efeito Portal criado com Sprite Mask e o Particle System
O sprite usado como imagem de máscara pode ser animado com a ferramenta de animação . Isso
permite que você crie alguns efeitos interessantes . Por exemplo, você pode fazer um portal aparecer,
então crescer mais ou mudar de forma .
Mask Sprites precisam ter sua Mask Interaction definida no Sprite Renderer para serem afetados por
uma Sprite Mask. No 2D Renderer do URP, o Depth/ Stencil Buffer deve estar habilitado.
Opção de buffer de profundidade/estêncil usada para mascaramento

Comparação de ferramentas
Animação esquelética 2D vs. animação quadro a quadro
Quadro por quadro esqueleto 2D.
Prós Contras Prós Contras
• Aparência artística • Custoso de fazer (tempo, • Fácil de configurar e • Algum custo de tempo de execução
habilidade) animar
• Pode animar • Animações como
tudo (rotação fácil de • Difícil de editar depois • Fácil de editar mais tarde girar em torno do eixo
personagem) Y é mais difícil
• Consome grandes • Tamanho de textura pequeno
• Baixo custo de tempo de execução quantidades de memória • Não funciona bem
• Pode suportar vários
com pixel art
• A animação irá personagens ou skins
sempre será limitado por esqueleto
aos quadros por
• Pode ser editado em
segundo que foi
tempo de execução para adicionar
criado para eles
roupas, armas,
precisam ser criados
animação IK e
manualmente se houver
breve
alterações na velocidade ou
na taxa de quadros da animação • A animação irá
são necessários seja sempre suave –
interpolação
• animações podem ser

misturado para criar
transições suaves
Use.quando.você: Use.quando.você:
• Quer uma ótima estética ou estilo específico • Não tem grandes habilidades de animação
• Foco em animação pixel art • Quer fazer animação rapidamente
• Quer uma animação simples de apenas alguns quadros • Quer várias skins ou personagens
• Quer um melhor controle de tempo de execução
• Quer economizar espaço de textura
Ambas as técnicas podem ser misturadas. O movimento dos membros pode ser controlado por ossos, mas
as expressões faciais podem ser controladas por trocas de sprites.

Shaders.animação.vs.clipes.de.animação.para.VFX.vs.Sistema.de.Partículas
Sombreadores Animação.clipes Sistema de Partículas

Prós Contras Prós Contras Prós Contras
• Conquistas • Tempo de execução • Parece ótimo • Tamanho da textura • Fácil de • Efeitos

efeitos não cálculo fazer e complexos
possível são difíceis • Artístico • Leva editar mais tarde
com outros controle sobre mais tempo • Requer

técnicas animação para criar • Pode muita
e seu individual randomizar partículas
• Processual quadros quadros para definir um que podem
efeitos visual único ser cansativo para
• Difícil de CPU
• Rápido personalizar
criação mais tarde
tempo
• Pequeno
tamanho da textura
Use.quando.você: Use.quando.você: Use.quando.você:
• Quer animação simples de apenas alguns • Bom para natural ou desenho animado • Bom para efeitos com um pouco de
quadros Bom para efeitos procurando animações (insetos, randomização como fogo, fluidos e
que de outra forma levaria muito tempo pássaros, efeitos de fumaça, etc.) magias
de espaço/memória quando feito
quadro a quadro • Custo de tempo de execução muito baixo
• Ótimo quando você precisa de

personalização
• Ótimo para aplicar efeitos em

materiais

Tilemaps.vs.Sprite.vs.Sprite.Forma
Mapas de blocos Sprites Sprite.Forma

Prós Contras Prós Contras Prós Contras
• Rápido • Difícil de • Ótimo para • Difícil de • Fácil edição de • Não permite

criação fazer colocando pintar ambos para pixel
processo para formas objetos vários formas perfeito
pintura, orgânicas manualmente sprites poligonais e
azulejos e quando orgânicas • colocação fácil
azulejos de régua constrangido • Não
para uma grade otimizado

• Preciso quando usado • Texturas podem
em seja repetitivo
• Bom para grandes números
otimizando
jogos
Use.quando.você:.. Use.quando.você:. Use.quando.você:.
• Bom para posicionamento preciso de • Bom para elementos adicionais, como um • Ótimo para formas de aparência orgânica
elementos de nível suplemento para Tilemaps e
Forma do Sprite • Edição de nível rápido
• A grade é boa para encontrar caminhos
• Muito versátil
— Tente manter uma contagem de quadros/tamanho de textura baixa ao usar quadro a quadro
animação .
— Com Object Pooling, você pode evitar instanciar e destruir ativos VFX. Basta ativar e
desativar GameObjects.
— No Shader Graph, use meia precisão sempre que possível.

Pós-processamento
Visão geral
O pós-processamento aprimora a aparência do seu jogo adicionando efeitos no quadro

de imagem final. Esses efeitos podem simular uma aparência de câmera de vídeo física
ou ser completamente estilizados. O URP inclui recursos de pós-processamento, então não
há necessidade de instalar um pacote separado, e a configuração dos efeitos é direta.
À esquerda está uma imagem de uma saída de câmera sem pós-processamento. À direita está a mesma imagem com pós-processamento adicionado. Os efeitos foram
exagerados para mostrar a diferença. Aplique efeitos de pós-processamento com cautela, especialmente em jogos para dispositivos móveis.
Para começar, selecione a câmera principal e selecione a opção Pós-processamento.
Habilitando o pós-processamento na câmera principal
O pós-processamento usa o sistema de Volume , então para adicionar um novo

Volume de pós-processamento, selecione GameObject.>.Volume.>.Global.Volume.
Definindo um perfil de volume

Agora, crie um Volume Profile clicando no botão New . O Volume Profile armazenará seus efeitos
de pós-processamento e pode ser facilmente compartilhado entre Volumes e Scenes .
Para começar a adicionar efeitos de pós-processamento, clique no botão Adicionar substituição

e selecione o efeito desejado na lista.
Selecionando o efeito de pós-processamento Bloom
Vamos escolher Bloom para começar.
Definindo propriedades do efeito Bloom

Para ajustar a propriedade do efeito, selecione a caixa de seleção adjacente.
Um lembrete rápido: certifique-se de que a camada GameObject do Volume Global

corresponda à camada selecionada na opção Mask na câmera principal.
Se tudo estiver funcionando corretamente, o efeito Bloom deverá estar visível na visualização do jogo.
Certifique-se de que a caixa de seleção Pós-processamento na câmera esteja habilitada e que a Camada do GameObject do Volume
esteja selecionada na lista suspensa Máscara de Volumes da câmera
O Volume Global foi usado, então os efeitos devem estar sempre visíveis quando o
objeto Volume estiver ativo na Cena.
Volumes Locais
Você pode adicionar efeitos de pós-processamento a um nível inteiro, mas também é

possível configurar efeitos para partes de um nível, como quando o jogador entra em um prédio.
Para fazer isso, outro Objeto de Volume deve ser criado com um Perfil de pós-
processamento diferente anexado.
O modo de volume precisa ser definido como local e, em seguida, adicione o 3D Box Collider ao

Adicionando um 3D Box Collider a um objeto de volume
Objeto de volume. O pós-processamento será aplicado quando a câmera entrar nos limites do Box
Collider, então certifique-se de que seu eixo Z seja grande o suficiente para conter o objeto da
câmera. Por padrão, o collider será muito pequeno, então verifique novamente o tamanho na Scene
view.
Aumentar o valor da Distância de mesclagem evitará que os efeitos sejam ativados abruptamente
quando a câmera entrar na zona de Volume.

Visão geral dos efeitos para gráficos 2D
O pós-processamento em URP tem muitos efeitos embutidos, e quase todos os efeitos podem ser
usados em um jogo 2D. Aqui está uma rápida visão geral dos efeitos.
Florescer
O efeito Bloom cria um brilho ao redor das áreas mais brilhantes da imagem, dando a impressão de que as partes são mais brilhantes
para simular como uma lente captura a luz. Para melhorar ainda mais a aparência, tente adicionar uma textura Lens Dirt, que simulará
as imperfeições em uma lente de câmera. Para melhor desempenho, desabilite a filtragem de alta qualidade, especialmente em dispositivos móveis.
Aberração cromática
Este efeito cria distorção de cor nas bordas de uma imagem. Isso simula lentes que separam as cores mais longe do centro.

Cor.Grading
Este é um grupo de efeitos em vez de um único. O propósito da gradação de cores é

alterar as cores de uma imagem para estilizar ou mudar o clima de uma cena.
A gradação de cores pode simular a hora do dia ou a temperatura de um ambiente
ajustando sua temperatura de cor. Esses efeitos têm o potencial de dar a um jogo
uma aparência bem distinta.
O URP usa os seguintes efeitos para controlar a gradação de cores.
Channel Mixer: Modifica a influência de cada canal de cor de entrada Ajustes de cor: ajusta o tom geral, o brilho e a imagem final Curvas de cor: permite ajustes precisos de cor e luminância em uma
contraste da imagem final renderizada imagem
Color Lookup: Uma maneira eficiente de gradação de cores usando um único

Lift Gamma Gain: executa gradação de cores de três vias Sombras Meio-tons Destaques: controla separadamente as sombras,
textura meios-tons e destaques de uma imagem
Tonalidade dividida: matiza diferentes áreas da imagem com Tonemapping: permite remapear os valores HDR de uma imagem para um
Balanço de branco: equilibra a temperatura da cor e também pode
base nos valores de luminância, adicionando toques de cores novo intervalo de valores resfriar ou aquecer o tom de uma imagem
diferentes a sombras, tons médios e realces

Lente.Distorção.
.
Isso criará um efeito de distorção de barril comumente visto em lentes grande-angulares do mundo real. Isso curva as linhas
retas em uma imagem para dentro, e será mais pronunciado próximo às bordas. Esse efeito pode ser usado para replicar uma
curvatura de TV CRT antiga ou adicionar um efeito de lente olho de peixe.
Vinheta
A vinheta escurece a imagem em direção às bordas, o que é outra propriedade real das lentes que chama a atenção para o centro da
imagem.

Filme.Grão
O Granulado de Filme aplica ruído sutil sobre a imagem, produzindo um efeito semelhante à estrutura de emulsão de um negativo de
filme e resultando em granulação visível em filmes analógicos.
Panini.Projeção
Projetado para ajudar a renderizar vistas em perspectiva com um campo de visão muito grande, o Panini Projection também pode ser
usado em 2D para estilizar a imagem com uma distorção cilíndrica.
— Use o mínimo possível de efeitos de pós-processamento.
— Use efeitos menos intensos, como Bloom, Aberração cromática, Gradação de cor,
Distorção de lente ou Vinheta, sempre que possível.
— Film Grain e Panini Projection são mais caros.
— Desabilitar filtragem de alta qualidade no Bloom

Conclusão
Você percorreu um longo caminho ao chegar ao final deste guia. Espero que os passos e o
conhecimento apresentados aqui ajudem você a começar sua jornada para criar belos jogos 2D no
Unity.
Ao longo dos anos, encontramos muitas pessoas que lutam com o desenvolvimento de jogos,
aquelas que parecem pensar que sempre há mais um passo para aprender ou um tutorial para
assistir antes que possam realmente começar. Mas a melhor maneira de aprender é fazendo. Então
comece agora.
Depois que você der o primeiro passo, sim, há uma boa chance de você encontrar alguns
obstáculos. Mas então você pode ter que mergulhar em um tutorial ou artigo técnico ou obter algumas
dicas boas de um colega desenvolvedor, e você estará de volta ao seu caminho novamente.
O desenvolvimento de jogos exige que você faça e aprenda. Sempre haverá um equilíbrio entre os dois.
Não é possível explorar todas as áreas do desenvolvimento de jogos 2D em apenas um e-book.

Mas esta é uma boa referência para manter por perto ao iniciar seu projeto e aprofundar seu
conhecimento dessas ferramentas. Há muitos recursos adicionais para desenvolvedores e artistas,
incluindo Unity Documentation, Unity Learn e o Unity Blog
Boa sorte!
– Jarek Majewski e a equipe Unity 2D

unidade .com

2022 2DGameArtAnimationLightingforArtists Ebook USE 3 Trad

Enviado por

Direitos autorais:

Formatos disponíveis

2022 2DGameArtAnimationLightingforArtists Ebook USE 3 Trad

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2022 2DGameArtAnimationLightingforArtists Ebook USE 3 Trad

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

UNIDADE PARA JOGOS E-BOOK

Projeções paralelas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12

Boxe branco com sprites básicos. . . . . . . . . . . . . . . . . . . . .32

Animação 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54

Regras gerais de animação 2D. . . . . . . . . . . . . . . . . . . . . . . .56

Criando o esqueleto. . . . . . . . . . . . . . . . . . . . . . . . . . . . .60

Geometria de Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61

Forma livre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73

Técnicas normais de pintura de mapas.. . . . . . . . . . . . . . . . . . .80

Como pintar mapas normais em sprites. . . . . . . . . . . . . .82

Pintando o Mapa da Máscara. . . . . . . . . . . . . . . . . ... . . . . . . . .86

Configurando a luz de Fresnel.. . . . . . . . . . . . . . . . . . . . . . . . . . . . .86

Mapa de blocos 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88

Forma de Sprite 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89

Importador de PSD 2D para personagens animados. . . . . . . . . . . .90

Efeitos visuais avançados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92

Propriedades do módulo principal.. . . . . . . . . . . . . . . . . . . . . . . . . .95

Forma . ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95

Cor ao longo da vida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95

Tamanho ao longo da vida útil.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95

Rotação ao longo da vida útil. . . . . . . . . . . . . . . . . . . . . . . . . . . .95

Partículas randomizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . .96

Usando o Shader Graph. . . . . . . . . . . . . . . . . . . . . . . . . . .97

Reflexões e refrações. . . . . . . . . . . . . . . . . . . . . . .105

Volumes locais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Aberração cromática. . . . . . . . . . . . . . . . . . . . . . . . . . . .114

Gradação de cores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

Distorção da lente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116

Grão de filme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Projeção Panini. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

A evolução do hardware, gráficos e software de desenvolvimento de jogos torna possível

Os tópicos abordados incluem a configuração do seu projeto, a transição entre o Unity e

© 2022 Tecnologias Unity 4.de.119.| unidade .com

Jarek Majewski é um artista 2D profissional e desenvolvedor Unity autodidata com amplas

Jarek trabalhou em estreita colaboração com vários especialistas e funcionários da Unity

Rus Scammell é o gerente de produto da equipe de desenvolvimento 2D da Unity. Rus tem

Andy Touch é um desenvolvedor sênior de conteúdo na Unity que trabalhou em muitos

*Nintendo Switch é uma marca comercial da Nintendo.

© 2022 Tecnologias Unity 5.de.119.| unidade .com

— As imagens são importadas como Sprites e definidas para o modo Sprite

— A visualização da cena está definida como 2D

— A cena padrão não inclui uma luz

— A posição padrão da câmera é 0, 0, –10

— A câmera está configurada para Ortográfica

— Nas configurações da janela Iluminação :

— Toda a iluminação global está desabilitada

— O material do Skybox está definido como nenhum

— A fonte ambiente está definida como cor

© 2022 Tecnologias Unity 6.de.119.| unidade .com

A janela do Unity Hub

Em seguida, você precisará instalar o URP por meio do Gerenciador de Pacotes.

Instalar URP a partir do Gerenciador de Pacotes

© 2022 Tecnologias Unity 7.de.119.| unidade .com

Criando um ativo URP

Clique no Ativo URP e, no Inspetor, atribua o Ativo do Renderizador 2D ao Renderer.List. Clique

Definir um novo renderizador na visualização do Inspetor para o ativo URP

© 2022 Tecnologias Unity 8.de.119.| unidade .com

Agora que você tem o URP e os Assets do Renderizador 2D alinhados, atribua o