Estudos de shaders no Unity

Eu já mexi um pouco com shaders, tanto no Unity quanto em XNA, mas nunca tive um conhecimento muito grande sobre o assunto. Na semana passada eu encontrei um material bem bacana sobre shaders no Unity e decidi fazer as vídeo-aulas pra me aprofundar um pouco mais nessa área. São dez aulas de uns 15 ou 20 minutos que ensinam desde o básico de como os shaders funcionam dentro do Unity (que acaba sendo um pouco diferente por causa do ShaderLab) até como criar seus próprios efeitos.

Até aqui, eu fiz seis aulas. O mais interessante, pra mim, foi justamente a aula seis, que discute como criar seu próprio modelo de iluminação. Por padrão, o Unity suporta os modelos  de Lambert ou BlinnPhong. Com isso, ao escrever um shader você pode “herdar” de um destes dois modelos e basicamente escrever o pixel shader, deixando o Unity tomar conta do resto. Como isso deixa muita coisa escondida por trás dos panos, esse tutorial serve justamente pra entender como o shader funciona sem usar um modelo pronto. Acaba sendo uma ótima visão mais geral de como a coisa toda funciona. O resultado esta na imagem abaixo, à esquerda (é só um Phong bem simples).

Também consegui brincar um pouco carregando um mapa de especular separado pra complementar o quarto tutorial, que trata de adicionar este componente no modelo de iluminação. No vídeo, ele ensina a usar o alfa da própria textura difusa para definir onde o especular seria aplicado, mas eu adicionei um mapa de especular como um parâmetro extra e busquei nele essa informação do alfa. É uma alteração simples, mas já dá pra sentir um pouco como é fazer este tipo de alteração nos shaders.

Unity shaders

Pra programar, eu uso o Visual Studio 2012 e ele não tem um syntax highlighting para shaders. Pra solucionar isso, usei o NShader, mas como os shaders do Unity não estão diretamente em HLSL, CG ou GLSL, é preciso um passo extra pra fazer a coloração funcionar. A solução está aqui e consiste em alterar um arquivo do NShader pra ele passar a colorir arquivos com a extensão .shader também. Ainda estou procurando uma solução de auto-completar, mas por enquanto dá pra me virar bem sem isso.

Por fim, eu criei um repositório pra armazenar o resultado das aulas e os experimentos que eu fizer sobre isso. Quem tiver interesse, pode acessar aqui.

Game of Life no Unity

O Game of Life (não confundir com o Jogo da Vida de tabuleiro) é um sistema elaborado pelo matemático inglês John Horton Conway que simula a evolução de um conjunto de células (ou uma população) a partir de um estado inicial e um conjunto de regras. Ele é conhecido como um jogo de zero jogadores, já que a interação acontece só na criação da configuração inicial. Depois disso, resta observar a evolução das células.

Não vou entrar em muitos detalhes sobre seu histórico e aplicações, então pra quem quiser mais detalhes recomendo uma passada rápida pela Wikipédia, pois lá existe um material bem interessante sobre o tema e pode servir, no mínimo, como um bom ponto de partida.

O Game of Life parte de uma premissa bem simples. Células distribuídas em uma grade bidimensional podem estar vivas ou mortas e, a cada nova atualização, interagem com seus oito vizinhos (todos as células ao redor, incluindo diagonais) para determinar seu estado na próxima iteração. O interessante é que foi se descobrindo que certos padrões iniciais fazem com que a “população” se comporte de formas diferentes. Por exemplo, é possível criar populações iniciais que nunca morrem, que alternam entre diversos padrões e eventualmente voltam ao original, ou até mesmo que se deslocam pela grade em um padrão específico e previsível.

Mas como é feita a atualização das células? Bem, uma célula vive ou não na próxima geração dependendo do seu estado atual e da quantidade de vizinhos vivos. As regras são as seguintes:

  • Uma célula viva com menos de dois vizinhos morre por sub-população.
  • Uma célula viva com dois ou três vizinhos continua viva na próxima geração.
  • Uma célula viva com mais de três vizinhos morre por super-população.
  • Uma célula morta com exatos três vizinhos se torna viva na próxima geração, como resultado de reprodução.

Com essas simples quatro regras consegue-se fazer populações com comportamentos bem interessantes. No vídeo abaixo, eu configurei a cena com padrões osciladores (que trocam várias vezes de estado até voltar ao original) e fixos (que, mesmo respeitando as regras acima, nunca trocam de estado). Só uma observação: o vídeo na verdade vai até onze segundos. Por algum motivo o YouTube duplicou o vídeo, portanto depois de onze segundos é a mesma coisa repetida.

Essa implementação foi feita no Unity e quem quiser pode testar clicando aqui ou no link abaixo. Os controles são simples: com o mouse você liga/desliga as células e os botões no topo permitem avançar a geração um passo (step) ou em modo automático (play/stop) e o botão clear apaga todas as células de uma só vez.

Game of Life