Estudo de caso: Encontre seu caminho até Oz

Introdução

Find Your Way to Oz é um novo Chrome Experiment trazido para a Web pela Disney. Ele permite que você faça uma jornada interativa por um circo do Kansas, que leva você à terra de Oz depois de ser arrastado por uma tempestade enorme.

Nosso objetivo era combinar a riqueza do cinema com os recursos técnicos do navegador para criar uma experiência divertida e imersiva com que os usuários pudessem se conectar de verdade.

O trabalho é grande demais para ser capturado em sua totalidade neste artigo, então nos aprofundamos e extraímos alguns capítulos da história da tecnologia que achamos interessantes. Ao longo do caminho, extraímos alguns tutoriais focados de dificuldade crescente.

Muitas pessoas trabalharam duro para tornar essa experiência possível: são tantas que não cabem aqui. Acesse o site para conferir a página de créditos na seção do menu e saber mais.

Por trás das cenas

O Find Your Way to Oz para computadores é um mundo imersivo e rico. Usamos 3D e várias camadas de efeitos inspirados no cinema tradicional que se combinam para criar uma cena quase realista. As tecnologias mais importantes são WebGL com Three.js, sombreadores personalizados e elementos animados de DOM usando recursos de CSS3. Além disso, a API getUserMedia (WebRTC) para experiências interativas que permitem ao usuário adicionar a própria imagem diretamente da webcam e do WebAudio para som 3D.

Mas a mágica de uma experiência tecnológica como essa é como tudo se junta. Esse também é um dos principais desafios: como combinar efeitos visuais e elementos interativos em uma cena para criar um todo consistente? Essa complexidade visual era difícil de gerenciar, o que dificultava saber em que estágio de desenvolvimento estávamos em um determinado momento.

Para resolver o problema de efeitos visuais e otimização interconectados, usamos bastante um painel de controle que capturava todas as configurações relevantes que estávamos analisando naquele momento. A cena podia ser ajustada em tempo real no navegador, desde o brilho até a profundidade de campo, gama etc. Qualquer pessoa podia tentar ajustar os valores dos parâmetros significativos na experiência e participar da descoberta do que funcionava melhor.

Antes de compartilhar nosso segredo, queremos avisar que ele pode falhar, como se você estivesse mexendo no motor de um carro. Verifique se você não tem nada importante aberto, acesse o URL principal do site e adicione ?debug=on ao endereço. Aguarde o site carregar e, quando estiver dentro, pressione a tecla Ctrl-I. Um menu suspenso vai aparecer no lado direito. Se você desmarcar a opção "Sair do caminho da câmera", poderá usar as teclas A, W, S, D e o mouse para se mover livremente pelo espaço.

Caminho da câmera.

Não vamos falar sobre todas as configurações aqui, mas recomendamos que você faça testes: as teclas revelam configurações diferentes em cenas diferentes. Na sequência final da tempestade, há uma tecla adicional: Ctrl-A, que permite alternar a reprodução da animação e voar. Nessa cena, se você pressionar Esc (para sair da funcionalidade de bloqueio do mouse) e pressionar Ctrl-I novamente, poderá acessar as configurações específicas da cena de tempestade. Dê uma olhada ao redor e capture algumas vistas de cartão-postal, como a abaixo.

Cena de tempestade

Para que isso acontecesse e para garantir que fosse flexível o suficiente para nossas necessidades, usamos uma biblioteca incrível chamada dat.gui (confira aqui um tutorial sobre como usá-la). Com ele, conseguimos mudar rapidamente as configurações expostas aos visitantes do site.

Um pouco como pintura fosca

Em muitos filmes e animações clássicos da Disney, as cenas eram criadas combinando diferentes camadas. Havia camadas de live action, animação de células, até mesmo cenários físicos e camadas superiores criadas com pintura em vidro: uma técnica chamada pintura fosca.

Em muitos aspectos, a estrutura da experiência que criamos é semelhante, embora algumas das "camadas" sejam muito mais do que recursos visuais estáticos. Na verdade, eles afetam a aparência das coisas de acordo com cálculos mais complexos. No entanto, pelo menos no nível geral, estamos lidando com visualizações, compostas uma sobre a outra. Na parte de cima, há uma camada de interface, com uma cena 3D abaixo dela, que é composta por diferentes componentes.

A camada de interface superior foi criada usando DOM e CSS 3, o que significa que as interações podem ser editadas de várias maneiras, independentemente da experiência em 3D, com comunicação entre as duas de acordo com uma lista selecionada de eventos. Essa comunicação usa o evento Backbone Router + onHashChange HTML5, que controla qual área deve ser animada para dentro/fora. (origem do projeto: /develop/coffee/router/Router.coffee).

Tutorial: folhas de sprites e suporte para Retina

Uma técnica de otimização divertida que usamos para a interface foi combinar as várias imagens de sobreposição em um único PNG para reduzir as solicitações do servidor. Neste projeto, a interface foi composta por mais de 70 imagens (sem contar as texturas 3D) carregadas de uma só vez para reduzir a latência do site. Confira a folha de sprites ativa aqui:

Tela normal: http://findyourwaytooz.com/img/home/interface_1x.png Tela Retina: http://findyourwaytooz.com/img/home/interface_2x.png

Confira algumas dicas de como aproveitamos o uso de folhas de sprites e como usá-las em dispositivos Retina para deixar a interface o mais nítida e organizada possível.

Como criar spritesheets

Para criar SpriteSheets, usamos o TexturePacker, que gera resultados em qualquer formato que você precisar. Nesse caso, exportamos como EaselJS, que é muito limpo e também poderia ter sido usado para criar sprites animados.

Como usar a folha de sprites gerada

Depois de criar a folha de sprites, você verá um arquivo JSON como este:

{
   "images": ["interface_2x.png"],
   "frames": [
       [2, 1837, 88, 130],
       [2, 2, 1472, 112],
       [1008, 774, 70, 68],
       [562, 1960, 86, 86],
       [473, 1960, 86, 86]
   ],

   "animations": {
       "allow_web":[0],
       "bottomheader":[1],
       "button_close":[2],
       "button_facebook":[3],
       "button_google":[4]
   },
}

Em que:

  • image se refere ao URL da folha de sprites
  • frames são as coordenadas de cada elemento da interface [x, y, largura, altura]
  • animations são os nomes de cada recurso

Observe que usamos as imagens de alta densidade para criar a folha de sprites e, em seguida, criamos a versão normal, apenas redimensionando-a para metade do tamanho.

Reunindo tudo

Agora que está tudo pronto, só precisamos de um snippet de JavaScript para usá-lo.

var SSAsset = function (asset, div) {
  var css, x, y, w, h;

  // Divide the coordinates by 2 as retina devices have 2x density
  x = Math.round(asset.x / 2);
  y = Math.round(asset.y / 2);
  w = Math.round(asset.width / 2);
  h = Math.round(asset.height / 2);

  // Create an Object to store CSS attributes
  css = {
    width                : w,
    height               : h,
    'background-image'   : "url(" + asset.image_1x_url + ")",
    'background-size'    : "" + asset.fullSize[0] + "px " + asset.fullSize[1] + "px",
    'background-position': "-" + x + "px -" + y + "px"
  };

  // If retina devices

  if (window.devicePixelRatio === 2) {

    /*
    set -webkit-image-set
    for 1x and 2x
    All the calculations of X, Y, WIDTH and HEIGHT is taken care by the browser
    */

    css['background-image'] = "-webkit-image-set(url(" + asset.image_1x_url + ") 1x,";
    css['background-image'] += "url(" + asset.image_2x_url + ") 2x)";

  }

  // Set the CSS to the DIV
  div.css(css);
};

E é assim que você o usaria:

logo = new SSAsset(
{
  fullSize     : [1024, 1024],               // image 1x dimensions Array [x,y]
  x            : 1790,                       // asset x coordinate on SpriteSheet         
  y            : 603,                        // asset y coordinate on SpriteSheet
  width        : 122,                        // asset width
  height       : 150,                        // asset height
  image_1x_url : 'img/spritesheet_1x.png',   // background image 1x URL
  image_2x_url : 'img/spritesheet_2x.png'    // background image 2x URL
},$('#logo'));

Para entender um pouco mais sobre densidades de pixel variáveis, leia este artigo de Boris Smus.

Pipeline de conteúdo 3D

A experiência de ambiente é configurada em uma camada do WebGL. Quando você pensa em uma cena 3D, uma das perguntas mais difíceis é como garantir que você possa criar conteúdo que permita o máximo potencial expressivo dos lados de modelagem, animação e efeitos. Em muitos aspectos, o cerne desse problema é o pipeline de conteúdo: um processo acordado para criar conteúdo para a cena 3D.

Queríamos criar um mundo inspirador, então precisávamos de um processo sólido que permitisse aos artistas 3D criá-lo. Eles precisavam ter o máximo de liberdade expressiva possível no software de modelagem e animação 3D, e nós precisávamos renderizar isso na tela usando código.

Já estávamos trabalhando nesse tipo de problema há algum tempo, porque sempre que criávamos um site em 3D, encontrávamos limitações nas ferramentas que podíamos usar. Então criamos essa ferramenta, chamada 3D Librarian, uma pesquisa interna. E estava quase pronto para ser aplicado a um trabalho real.

Essa ferramenta tem uma história: originalmente, ela era para o Flash e permitia que você trouxesse uma grande cena do Maya como um único arquivo compactado otimizado para descompactar o ambiente de execução. O motivo de ser ideal é que ele empacotava a cena basicamente na mesma estrutura de dados que é manipulada durante a renderização e a animação. Há pouca análise que precisa ser feita no arquivo quando ele é carregado. A descompactação no Flash era bem rápida porque o arquivo estava no formato AMF, que o Flash podia descompactar de forma nativa. Usar o mesmo formato no WebGL exige um pouco mais de trabalho na CPU. Na verdade, tivemos que recriar uma camada de código JavaScript de descompactação de dados, que basicamente descompactaria esses arquivos e recriaria as estruturas de dados necessárias para o WebGL funcionar. Descompactar toda a cena 3D é uma operação que exige um pouco da CPU: descompactar a cena 1 em Find Your Way To Oz leva cerca de 2 segundos em uma máquina de médio a alto desempenho. Portanto, isso é feito usando a tecnologia Web Workers, no momento da "configuração da cena" (antes que a cena seja realmente iniciada), para não interromper a experiência do usuário.

Essa ferramenta útil pode importar a maior parte da cena 3D: modelos, texturas, animações de ossos. Você cria um único arquivo de biblioteca, que pode ser carregado pelo mecanismo 3D. Você coloca todos os modelos necessários na cena dentro dessa biblioteca e, pronto, eles aparecem na cena.

No entanto, um problema que tivemos foi que agora estávamos lidando com o WebGL: o novato no pedaço. Esse era um garoto bem difícil: ele estava definindo o padrão para experiências 3D baseadas em navegador. Por isso, criamos uma camada de JavaScript ad hoc que pegava os arquivos de cena 3D compactados do 3D Librarian e os traduzia para um formato que o WebGL entendesse.

Tutorial: Que haja vento

Um tema recorrente em "Find Your Way To Oz" era o vento. Um fio da história é estruturado para ser um crescendo de vento.

A primeira cena do carnaval é relativamente calma. Ao passar pelas várias cenas, o usuário sente um vento cada vez mais forte, culminando na cena final, a tempestade.

Por isso, era importante oferecer um efeito de vento imersivo.

Para criar isso, preenchemos as três cenas de carnaval com objetos macios que deveriam ser afetados pelo vento, como tendas, bandeiras, a superfície da cabine de fotos e o próprio balão.

Pano macio.

Hoje em dia, os jogos para computador geralmente são criados com base em um mecanismo de física principal. Assim, quando um objeto flexível precisa ser simulado no mundo 3D, uma simulação de física completa é executada para ele, criando um comportamento flexível realista.

No WebGL / Javascript, ainda não temos o luxo de executar uma simulação de física completa. Então, em Oz, tivemos que encontrar uma maneira de criar o efeito do vento sem realmente simulá-lo.

Incorporamos as informações de "sensibilidade ao vento" de cada objeto no próprio modelo 3D. Cada vértice do modelo 3D tinha um "Atributo de vento" que especificava o quanto esse vértice deveria ser afetado pelo vento. Portanto, essa sensibilidade ao vento especificada de objetos 3D. Depois, precisamos criar o vento em si.

Para isso, geramos uma imagem com ruído de Perlin. Essa imagem deve cobrir uma determinada "área de vento". Portanto, uma boa maneira de pensar sobre isso é imaginar uma imagem de ruído semelhante a uma nuvem sendo colocada sobre uma determinada área retangular da cena 3D. Cada pixel, valor de nível de cinza, dessa imagem especifica a intensidade do vento em um determinado momento na área 3D "ao redor".

Para produzir o efeito de vento, a imagem é movida, ao longo do tempo, em velocidade constante, em uma direção específica: a direção do vento. Para garantir que a "área de vento" não afete tudo na cena, envolvemos a imagem do vento nas bordas, confinada à área de efeito.

Tutorial simples de vento em 3D

Agora vamos criar o efeito de vento em uma cena 3D simples no Three.js.

Vamos criar vento em um "campo de grama procedural" simples.

Primeiro, vamos criar a cena. Vamos ter um terreno plano simples e texturizado. E cada pedaço de grama será representado por um cone 3D invertido.

Terreno coberto de grama
Terreno gramado

Veja como criar essa cena simples em Three.js usando CoffeeScript.

Primeiro, vamos configurar o Three.js e conectá-lo à câmera, ao controlador do mouse e a alguma luz, de certa forma:

constructor: ->

   @clock =  new THREE.Clock()

   @container = document.createElement( 'div' );
   document.body.appendChild( @container );

   @renderer = new THREE.WebGLRenderer();
   @renderer.setSize( window.innerWidth, window.innerHeight );
   @renderer.setClearColorHex( 0x808080, 1 )
   @container.appendChild(@renderer.domElement);

   @camera = new THREE.PerspectiveCamera( 50, window.innerWidth / window.innerHeight, 1, 5000 );
   @camera.position.x = 5;
   @camera.position.y = 10;
   @camera.position.z = 40;

   @controls = new THREE.OrbitControls( @camera, @renderer.domElement );
   @controls.enabled = true

   @scene = new THREE.Scene();
   @scene.add( new THREE.AmbientLight 0xFFFFFF )

   directional = new THREE.DirectionalLight 0xFFFFFF
   directional.position.set( 10,10,10)
   @scene.add( directional )

   # Demo data
   @grassTex = THREE.ImageUtils.loadTexture("textures/grass.png");
   @initGrass()
   @initTerrain()

   # Stats
   @stats = new Stats();
   @stats.domElement.style.position = 'absolute';
   @stats.domElement.style.top = '0px';
   @container.appendChild( @stats.domElement );
   window.addEventListener( 'resize', @onWindowResize, false );
   @animate()

As chamadas de função initGrass e initTerrain preenchem a cena com grama e terreno, respectivamente:

initGrass:->
   mat = new THREE.MeshPhongMaterial( { map: @grassTex } )
   NUM = 15
   for i in [0..NUM] by 1
       for j in [0..NUM] by 1
           x = ((i/NUM) - 0.5) * 50 + THREE.Math.randFloat(-1,1)
           y = ((j/NUM) - 0.5) * 50 + THREE.Math.randFloat(-1,1)
           @scene.add( @instanceGrass( x, 2.5, y, 5.0, mat ) )

instanceGrass:(x,y,z,height,mat)->
   geometry = new THREE.CylinderGeometry( 0.9, 0.0, height, 3, 5 )
   mesh = new THREE.Mesh( geometry, mat )
   mesh.position.set( x, y, z )
   return mesh

Aqui, estamos criando uma grade de 15 por 15 bits de grama. Adicionamos um pouco de aleatoriedade a cada posição da grama para que ela não fique alinhada como soldados, o que pareceria estranho.

Esse terreno é apenas um plano horizontal, colocado na base dos pedaços de grama (y = 2,5).

initTerrain:->
  @plane = new THREE.Mesh( new THREE.PlaneGeometry(60, 60, 2, 2), new THREE.MeshPhongMaterial({ map: @grassTex }))
  @plane.rotation.x = -Math.PI/2
  @scene.add( @plane )

Até agora, criamos uma cena do Three.js e adicionamos alguns pedaços de grama, feitos de cones invertidos gerados de forma procedural, e um terreno simples.

Nada demais até aqui.

Agora, é hora de adicionar vento. Primeiro, queremos incorporar as informações de sensibilidade ao vento no modelo 3D da grama.

Vamos incorporar essas informações como um atributo personalizado para cada vértice do modelo 3D da grama. E vamos usar a regra de que a extremidade inferior do modelo de grama (ponta do cone) tem sensibilidade zero, já que está presa ao chão. A parte de cima do modelo de grama (base do cone) tem a sensibilidade máxima ao vento, já que é a parte mais distante do chão.

Veja como a função instanceGrass é recodificada para adicionar a sensibilidade ao vento como um atributo personalizado para o modelo 3D de grama.

instanceGrass:(x,y,z,height)->

  geometry = new THREE.CylinderGeometry( 0.9, 0.0, height, 3, 5 )

  for i in [0..geometry.vertices.length-1] by 1
      v = geometry.vertices[i]
      r = (v.y / height) + 0.5
      @windMaterial.attributes.windFactor.value[i] = r * r * r

  # Create mesh
  mesh = new THREE.Mesh( geometry, @windMaterial )
  mesh.position.set( x, y, z )
  return mesh

Agora usamos um material personalizado, windMaterial, em vez do MeshPhongMaterial que usamos anteriormente. WindMaterial envolve o WindMeshShader, que vamos ver em breve.

Portanto, o código em instanceGrass faz um loop por todos os vértices do modelo de grama e, para cada vértice, adiciona um atributo personalizado chamado windFactor. Esse windFactor é definido como 0 para a extremidade inferior do modelo de grama (onde ele deve tocar o terreno) e como 1 para a extremidade superior do modelo de grama.

O outro elemento que precisamos adicionar é o vento em si. Como discutido, vamos usar o ruído de Perlin para isso. Vamos gerar uma textura de ruído de Perlin de forma procedural.

Para maior clareza, vamos atribuir essa textura ao próprio terreno, no lugar da textura verde anterior. Isso vai facilitar a compreensão do que está acontecendo com o vento.

Assim, essa textura de ruído de Perlin vai cobrir espacialmente a extensão do terreno, e cada pixel da textura vai especificar a intensidade do vento da área do terreno em que esse pixel se encontra. O retângulo do terreno será nossa "área de vento".

O ruído de Perlin é gerado de forma procedural por um sombreador, chamado NoiseShader. Este sombreador usa algoritmos de ruído simplex 3D de: https://github.com/ashima/webgl-noise . A versão WebGL foi retirada literalmente de um dos exemplos de Three.js do MrDoob, em: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

O NoiseShader usa um conjunto de parâmetros de tempo, escala e deslocamento como uniformes e gera uma boa distribuição 2D de ruído Perlin.

class NoiseShader

  uniforms:     
    "fTime"  : { type: "f", value: 1 }
    "vScale"  : { type: "v2", value: new THREE.Vector2(1,1) }
    "vOffset"  : { type: "v2", value: new THREE.Vector2(1,1) }

...

Vamos usar esse sombreador para renderizar o ruído de Perlin em uma textura. Isso é feito na função initNoiseShader.

initNoiseShader:->
  @noiseMap  = new THREE.WebGLRenderTarget( 256, 256, { minFilter: THREE.LinearMipmapLinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat } );
  @noiseShader = new NoiseShader()
  @noiseShader.uniforms.vScale.value.set(0.3,0.3)
  @noiseScene = new THREE.Scene()
  @noiseCameraOrtho = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2,  window.innerHeight / 2, window.innerHeight / - 2, -10000, 10000 );
  @noiseCameraOrtho.position.z = 100
  @noiseScene.add( @noiseCameraOrtho )

  @noiseMaterial = new THREE.ShaderMaterial
      fragmentShader: @noiseShader.fragmentShader
      vertexShader: @noiseShader.vertexShader
      uniforms: @noiseShader.uniforms
      lights:false

  @noiseQuadTarget = new THREE.Mesh( new THREE.PlaneGeometry(window.innerWidth,window.innerHeight,100,100), @noiseMaterial )
  @noiseQuadTarget.position.z = -500
  @noiseScene.add( @noiseQuadTarget )

O código acima configura noiseMap como um destino de renderização do Three.js, o equipa com o NoiseShader e o renderiza com uma câmera ortográfica para evitar distorções de perspectiva.

Como discutido, agora vamos usar essa textura também como a principal textura de renderização do terreno. Isso não é realmente necessário para que o efeito de vento funcione. Mas é bom ter para entender melhor o que está acontecendo com a geração de energia eólica.

Confira a função initTerrain reformulada, usando noiseMap como textura:

initTerrain:->
  @plane = new THREE.Mesh( new THREE.PlaneGeometry(60, 60, 2, 2), new THREE.MeshPhongMaterial( { map: @noiseMap, lights: false } ) )
  @plane.rotation.x = -Math.PI/2
  @scene.add( @plane )

Agora que temos nossa textura de vento, vamos dar uma olhada no WindMeshShader, que é responsável por deformar os modelos de grama de acordo com o vento.

Para criar esse sombreador, começamos com o sombreador MeshPhongMaterial padrão do Three.js e o modificamos. Essa é uma boa maneira de começar com um sombreador que funciona, sem precisar começar do zero.

Não vamos copiar todo o código do sombreador aqui (fique à vontade para conferir o arquivo de código-fonte), porque a maior parte dele seria uma réplica do sombreador MeshPhongMaterial. Mas vamos dar uma olhada nas partes modificadas, relacionadas ao vento, no Vertex Shader.

vec4 wpos = modelMatrix * vec4( position, 1.0 );
vec4 wpos = modelMatrix * vec4( position, 1.0 );

wpos.z = -wpos.z;
vec2 totPos = wpos.xz - windMin;
vec2 windUV = totPos / windSize;
vWindForce = texture2D(tWindForce,windUV).x;

float windMod = ((1.0 - vWindForce)* windFactor ) * windScale;
vec4 pos = vec4(position , 1.0);
pos.x += windMod * windDirection.x;
pos.y += windMod * windDirection.y;
pos.z += windMod * windDirection.z;

mvPosition = modelViewMatrix *  pos;

O que esse sombreador faz é primeiro calcular a coordenada de pesquisa de textura windUV, com base na posição 2D, xz (horizontal) do vértice. Essa coordenada UV é usada para procurar a força do vento, vWindForce, na textura de vento de ruído de Perlin.

Esse valor vWindForce é composto com o atributo personalizado windFactor específico do vértice, discutido acima, para calcular o quanto o vértice precisa ser deformado. Também temos um parâmetro global windScale para controlar a força geral do vento e um vetor windDirection que especifica em qual direção a deformação do vento precisa ocorrer.

Isso cria uma deformação baseada no vento nas nossas folhas de grama. No entanto, ainda não terminamos. Como está agora, essa deformação é estática e não transmite o efeito de uma área com vento.

Como mencionamos, vamos precisar deslizar a textura de ruído ao longo do tempo, pela área do vento, para que o vidro possa ondular.

Para isso, mude ao longo do tempo o uniforme vOffset que é transmitido para o NoiseShader. Esse é um parâmetro vec2 que permite especificar o deslocamento de ruído em uma determinada direção (a direção do vento).

Fazemos isso na função render, que é chamada em cada frame:

render: =>
  delta = @clock.getDelta()

  if @windDirection
      @noiseShader.uniforms[ "fTime" ].value += delta * @noiseSpeed
      @noiseShader.uniforms[ "vOffset" ].value.x -= (delta * @noiseOffsetSpeed) * @windDirection.x
      @noiseShader.uniforms[ "vOffset" ].value.y += (delta * @noiseOffsetSpeed) * @windDirection.z
...

E é isso! Acabamos de criar uma cena com "grama procedural" afetada pelo vento.

Adicionando poeira à mistura

Agora vamos dar um toque especial à nossa cena. Vamos adicionar um pouco de poeira flutuando para deixar a cena mais interessante.

Adicionando poeira
Adicionar poeira

Afinal, a poeira é afetada pelo vento, então faz todo sentido que ela esteja voando na nossa cena de vento.

A poeira é configurada na função initDust como um sistema de partículas.

initDust:->
  for i in [0...5] by 1
      shader = new WindParticleShader()
      params = {}
      params.fragmentShader = shader.fragmentShader
      params.vertexShader   = shader.vertexShader
      params.uniforms       = shader.uniforms
      params.attributes     = { speed: { type: 'f', value: [] } }

      mat  = new THREE.ShaderMaterial(params)
      mat.map = shader.uniforms["map"].value = THREE.ImageUtils.loadCompressedTexture("textures/dust#{i}.dds")
      mat.size = shader.uniforms["size"].value = Math.random()
      mat.scale = shader.uniforms["scale"].value = 300.0
      mat.transparent = true
      mat.sizeAttenuation = true
      mat.blending = THREE.AdditiveBlending
      shader.uniforms["tWindForce"].value      = @noiseMap
      shader.uniforms[ "windMin" ].value       = new THREE.Vector2(-30,-30 )
      shader.uniforms[ "windSize" ].value      = new THREE.Vector2( 60, 60 )
      shader.uniforms[ "windDirection" ].value = @windDirection            

      geom = new THREE.Geometry()
      geom.vertices = []
      num = 130
      for k in [0...num] by 1

          setting = {}

          vert = new THREE.Vector3
          vert.x = setting.startX = THREE.Math.randFloat(@dustSystemMinX,@dustSystemMaxX)
          vert.y = setting.startY = THREE.Math.randFloat(@dustSystemMinY,@dustSystemMaxY)
          vert.z = setting.startZ = THREE.Math.randFloat(@dustSystemMinZ,@dustSystemMaxZ)

          setting.speed =  params.attributes.speed.value[k] = 1 + Math.random() * 10
          
          setting.sinX = Math.random()
          setting.sinXR = if Math.random() < 0.5 then 1 else -1
          setting.sinY = Math.random()
          setting.sinYR = if Math.random() < 0.5 then 1 else -1
          setting.sinZ = Math.random()
          setting.sinZR = if Math.random() < 0.5 then 1 else -1

          setting.rangeX = Math.random() * 5
          setting.rangeY = Math.random() * 5
          setting.rangeZ = Math.random() * 5

          setting.vert = vert
          geom.vertices.push vert
          @dustSettings.push setting

      particlesystem = new THREE.ParticleSystem( geom , mat )
      @dustSystems.push particlesystem
      @scene.add particlesystem

Aqui, 130 partículas de poeira são criadas. E cada uma delas é equipada com um WindParticleShader especial.

Agora, em cada frame, vamos mover um pouco as partículas usando o CoffeeScript, independentemente do vento. Veja o código:

moveDust:(delta)->

  for setting in @dustSettings

    vert = setting.vert
    setting.sinX = setting.sinX + (( 0.002 * setting.speed) * setting.sinXR)
    setting.sinY = setting.sinY + (( 0.002 * setting.speed) * setting.sinYR)
    setting.sinZ = setting.sinZ + (( 0.002 * setting.speed) * setting.sinZR) 

    vert.x = setting.startX + ( Math.sin(setting.sinX) * setting.rangeX )
    vert.y = setting.startY + ( Math.sin(setting.sinY) * setting.rangeY )
    vert.z = setting.startZ + ( Math.sin(setting.sinZ) * setting.rangeZ )

Além disso, vamos compensar cada posição de partícula de acordo com o vento. Isso é feito no WindParticleShader. Especificamente no sombreador de vértice.

O código desse sombreador é uma versão modificada do ParticleMaterial do Three.js. O núcleo dele é assim:

vec4 mvPosition;
vec4 wpos = modelMatrix * vec4( position, 1.0 );
wpos.z = -wpos.z;
vec2 totPos = wpos.xz - windMin;
vec2 windUV = totPos / windSize;
float vWindForce = texture2D(tWindForce,windUV).x;
float windMod = (1.0 - vWindForce) * windScale;
vec4 pos = vec4(position , 1.0);
pos.x += windMod * windDirection.x;
pos.y += windMod * windDirection.y;
pos.z += windMod * windDirection.z;

mvPosition = modelViewMatrix *  pos;

fSpeed = speed;
float fSize = size * (1.0 + sin(time * speed));

#ifdef USE_SIZEATTENUATION
    gl_PointSize = fSize * ( scale / length( mvPosition.xyz ) );
#else,
    gl_PointSize = fSize;
#endif

gl_Position = projectionMatrix * mvPosition;

Esse sombreador de vértice não é tão diferente do que tínhamos para a deformação da grama com base no vento. Ela usa a textura de ruído de Perlin como entrada e, dependendo da posição da poeira no mundo, procura um valor vWindForce na textura de ruído. Em seguida, ele usa esse valor para modificar a posição da partícula de poeira.

Riders On The Storm

A mais ousada das nossas cenas em WebGL provavelmente foi a última, que você pode ver se clicar no balão para entrar no olho da Maromba e chegar ao fim da sua jornada no site, além de um vídeo exclusivo do próximo lançamento.

Cena de passeio de balão

Quando criamos essa cena, sabíamos que precisávamos de um recurso central para a experiência que fosse impactante. O tornado giratório seria o elemento central, e camadas de outros conteúdos moldariam esse recurso para criar um efeito dramático. Para isso, criamos o que seria o equivalente a um estúdio de cinema em torno desse shader estranho.

Usamos uma abordagem mista para criar o composto realista. Alguns eram truques visuais, como formas de luz para criar um efeito de reflexo de lente ou gotas de chuva que se movem como camadas sobre a cena que você está vendo. Em outros casos, tínhamos superfícies planas desenhadas para parecer que se moviam, como as camadas de nuvens baixas que se moviam de acordo com um código de sistema de partículas. Enquanto os detritos que orbitam ao redor do tornado eram camadas em uma cena 3D classificadas para se mover na frente e atrás do tornado.

O principal motivo para criar a cena dessa forma foi garantir que tivéssemos GPU suficiente para lidar com o sombreador do tornado em equilíbrio com os outros efeitos que estávamos aplicando. No início, tivemos grandes problemas de balanceamento de GPU, mas depois essa cena foi otimizada e ficou mais leve do que as principais.

Tutorial: o sombreador de tempestade

Para criar a sequência final da tempestade, muitas técnicas diferentes foram combinadas, mas o elemento central desse trabalho foi um sombreador GLSL personalizado que se parece com um tornado. Tentamos várias técnicas diferentes, desde sombreadores de vértices para criar redemoinhos geométricos interessantes até animações baseadas em partículas e até animações 3D de formas geométricas distorcidas. Nenhum dos efeitos parecia recriar a sensação de um tornado ou exigia muito em termos de processamento.

Um projeto completamente diferente acabou por nos dar a resposta. Um projeto paralelo envolvendo jogos para a ciência para mapear o cérebro do camundongo do Max Planck Institute (brainflight.org) gerou efeitos visuais interessantes. Conseguimos criar vídeos do interior de um neurônio de camundongo usando um sombreador volumétrico personalizado.

Dentro de um neurônio de camundongo usando um sombreador volumétrico personalizado
Dentro de um neurônio de camundongo usando um sombreador volumétrico personalizado

Descobrimos que o interior de uma célula cerebral se parece um pouco com o funil de um tornado. E como estávamos usando uma técnica volumétrica, sabíamos que poderíamos ver esse sombreador de todas as direções no espaço. Podemos definir a renderização do sombreador para combinar com a cena da tempestade, principalmente se estiver entre camadas de nuvens e acima de um plano de fundo dramático.

A técnica de sombreador envolve um truque que basicamente usa um único sombreador GLSL para renderizar um objeto inteiro com um algoritmo de renderização simplificado chamado renderização de marcha de raios com um campo de distância. Nessa técnica, é criado um sombreador de pixel que estima a distância mais próxima de uma superfície para cada ponto na tela.

Uma boa referência ao algoritmo pode ser encontrada na visão geral de iq: Rendering Worlds With Two Triangles - Iñigo Quilez. Também é possível explorar a galeria de sombreadores em glsl.heroku.com, onde há muitos exemplos dessa técnica para testar.

O coração do sombreador começa com a função principal, que configura as transformações da câmera e entra em um loop que avalia repetidamente a distância até uma superfície. A chamada RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) é onde ocorre o cálculo principal do ray marching.

for(int i=0;i < number_of_steps;i++) // run the ray marching loop
{
  old_d=d;
  float shape_value=Shape(q); // find out the approximate distance to or density of the tornado cone
  float density=-shape_value;
  d=max(shape_value*step_scaling,0.0);// The max function clamps values smaller than 0 to 0

  float step_dist=d+extra_step; // The point is advanced by larger steps outside the tornado,
  //  allowing us to skip empty space quicker.

  if (density>0.0) {  // When density is positive, we are inside the cloud
    float brightness=exp(-0.6*density);  // Brightness decays exponentially inside the cloud

    // This function combines density layers to create a translucent fog
    FogStep(step_dist*0.2,clamp(density, 0.0,1.0)*vec3(1,1,1), vec3(1)*brightness, colour, multiplier); 
  }
  if(dist>max_dist || multiplier.x < 0.01) { return;  } // if we've gone too far stop, we are done
  dist+=step_dist; // add a new step in distance
  q=org+dist*dir; // trace its direction according to the ray casted
}

A ideia é que, à medida que avançamos na forma da Maromba, adicionamos regularmente contribuições de cor ao valor de cor final do pixel, bem como contribuições para a opacidade ao longo do raio. Isso cria uma qualidade suave em camadas para a textura do tornado.

O próximo aspecto principal do tornado é a forma em si, que é criada pela composição de várias funções. Para começar, é um cone composto por ruído para criar uma borda áspera orgânica, que é torcido ao longo do eixo principal e girado no tempo.

mat2 Spin(float angle){
  return mat2(cos(angle),-sin(angle),sin(angle),cos(angle)); // a rotation matrix
}

// This takes noise function and makes ridges at the points where that function crosses zero
float ridged(float f){ 
  return 1.0-2.0*abs(f);
}

// the isosurface shape function, the surface is at o(q)=0 
float Shape(vec3 q) 
{
    float t=time;

    if(q.z < 0.0) return length(q);

    vec3 spin_pos=vec3(Spin(t-sqrt(q.z))*q.xy,q.z-t*5.0); // spin the coordinates in time

    float zcurve=pow(q.z,1.5)*0.03; // a density function dependent on z-depth

    // the basic cloud of a cone is perturbed with a distortion that is dependent on its spin 
    float v=length(q.xy)-1.5-zcurve-clamp(zcurve*0.2,0.1,1.0)*snoise(spin_pos*vec3(0.1,0.1,0.1))*5.0; 

    // create ridges on the tornado
    v=v-ridged(snoise(vec3(Spin(t*1.5+0.1*q.z)*q.xy,q.z-t*4.0)*0.3))*1.2; 

    return v;
}

O trabalho envolvido na criação desse tipo de sombreador é complicado. Além dos problemas envolvidos na abstração das operações que você está criando, há problemas sérios de otimização e compatibilidade multiplataforma que você precisa rastrear e resolver antes de usar o trabalho em produção.

A primeira parte do problema: otimizar esse sombreador para nossa cena. Para lidar com isso, precisávamos de uma abordagem "segura" caso o sombreador fosse muito pesado. Para isso, compusemos o sombreador de tornado em uma resolução de amostragem diferente do restante da cena. Isso é do arquivo stormTest.coffee (sim, era um teste!).

Começamos com um renderTarget que corresponde à largura e altura da cena para que possamos ter independência de resolução do sombreador de tornado para a cena. Em seguida, decidimos a redução da resolução do sombreador de tempestade de forma dinâmica, dependendo da taxa de quadros que estamos recebendo.

...
Line 1383
@tornadoRT = new THREE.WebGLRenderTarget( @SCENE_WIDTH, @SCENE_HEIGHT, paramsN )

... 
Line 1403 
# Change settings based on FPS
if @fpsCount > 0
    if @fpsCur < 20
        @tornadoSamples = Math.min( @tornadoSamples + 1, @MAX_SAMPLES )
    if @fpsCur > 25
        @tornadoSamples = Math.max( @tornadoSamples - 1, @MIN_SAMPLES )
    @tornadoW = @SCENE_WIDTH  / @tornadoSamples // decide tornado resWt
    @tornadoH = @SCENE_HEIGHT / @tornadoSamples // decide tornado resHt

Por fim, renderizamos o tornado na tela usando um algoritmo sal2x simplificado (para evitar a aparência de blocos) na linha 1107 em stormTest.coffee. Isso significa que, no pior caso, o tornado fica mais desfocado, mas pelo menos funciona sem tirar o controle do usuário.

A próxima etapa de otimização exige uma análise detalhada do algoritmo. O fator computacional determinante no shader é a iteração realizada em cada pixel para tentar aproximar a distância da função de superfície: o número de iterações do loop de raymarching. Usando uma taxa de aprendizado maior, poderíamos obter uma estimativa da superfície do tornado com menos iterações enquanto estivéssemos fora da superfície nublada. Quando estivermos dentro, vamos diminuir a taxa de aprendizado para aumentar a precisão e poder misturar valores para criar o efeito de névoa. Além disso, criar um cilindro delimitador para estimar a profundidade do raio projetado acelerou bastante o processo.

A próxima parte do problema era garantir que esse sombreador funcionasse em diferentes placas de vídeo. Fizemos alguns testes em cada etapa e começamos a entender os tipos de problemas de compatibilidade que poderíamos encontrar. O motivo pelo qual não conseguimos fazer muito melhor do que a intuição é que nem sempre conseguimos boas informações de depuração sobre os erros. Um cenário típico é apenas um erro de GPU com poucas informações ou até mesmo uma falha no sistema.

Os problemas de compatibilidade entre placas de vídeo tinham soluções semelhantes: garantir que as constantes estáticas fossem inseridas com o tipo de dados preciso, conforme definido, ou seja, 0.0 para float e 0 para int. Tome cuidado ao escrever funções mais longas. É preferível dividir as coisas em várias funções mais simples e variáveis provisórias, porque os compiladores pareciam não lidar com certos casos corretamente. Verifique se todas as texturas são uma potência de 2, não são muito grandes e, em qualquer caso, tenha "cuidado" ao procurar dados de textura em um loop.

Os maiores problemas de compatibilidade que tivemos foram com o efeito de iluminação da tempestade. Usamos uma textura pré-fabricada em volta do tornado para colorir os fios. O efeito ficou lindo e facilitou a mesclagem do tornado com as cores da cena, mas levou muito tempo para funcionar em outras plataformas.

tornado

O site para dispositivos móveis

A experiência para dispositivos móveis não podia ser uma tradução direta da versão para computador porque os requisitos de tecnologia e processamento eram muito pesados. Precisávamos criar algo novo, que segmentasse especificamente o usuário de dispositivos móveis.

Pensamos que seria legal ter a cabine de fotos do Carnaval para computadores como um aplicativo da Web para dispositivos móveis que usaria a câmera do celular do usuário. Algo que não tínhamos visto até agora.

Para dar um toque especial, codificamos transformações em 3D no CSS3. Ao vincular o giroscópio e o acelerômetro, conseguimos adicionar muita profundidade à experiência. O site responde à forma como você segura, move e olha para o smartphone.

Ao escrever este artigo, pensamos que seria útil dar algumas dicas sobre como executar o processo de desenvolvimento para dispositivos móveis sem problemas. Lá vão eles! Aproveite para aprender com ele.

Dicas e sugestões para dispositivos móveis

O pré-carregador é algo necessário, não algo que deve ser evitado. Sabemos que, às vezes, isso acontece. Isso ocorre principalmente porque você precisa manter a lista de itens pré-carregados à medida que o projeto cresce. Pior ainda, não fica muito claro como calcular o progresso do carregamento se você estiver extraindo recursos diferentes, muitos deles ao mesmo tempo. É aqui que nossa classe abstrata personalizada e muito genérica "Task" é útil. A ideia principal é permitir uma estrutura aninhada infinitamente, em que uma tarefa pode ter as próprias subtarefas, que podem ter as próprias subtarefas etc. Além disso, cada tarefa calcula o progresso em relação ao progresso das subtarefas (mas não ao progresso da tarefa pai). Ao fazer com que MainPreloadTask, AssetPreloadTask e TemplatePreFetchTask derivem de Task, criamos uma estrutura como esta:

Pré-carregador

Graças a essa abordagem e à classe Task, podemos saber facilmente o progresso global (MainPreloadTask), o progresso dos recursos (AssetPreloadTask) ou o progresso do carregamento de modelos (TemplatePreFetchTask). Até mesmo o progresso de um arquivo específico. Para ver como isso é feito, consulte a classe Task em /m/javascripts/raw/util/Task.js e as implementações reais de tarefas em /m/javascripts/preloading/task. Por exemplo, este é um trecho de como configuramos a classe /m/javascripts/preloading/task/MainPreloadTask.js, que é nosso wrapper de pré-carregamento definitivo:

Package('preloading.task', [
  Import('util.Task'),
...

  Class('public MainPreloadTask extends Task', {

    _public: {
      
  MainPreloadTask : function() {
        
    var subtasks = [
      new AssetPreloadTask([
        {name: 'cutout/cutout-overlay-1', ext: 'png', type: ImagePreloader.TYPE_BACKGROUND, responsive: true},
        {name: 'journey/scene1', ext: 'jpg', type: ImagePreloader.TYPE_IMG, responsive: false}, ...
...
      ]),

      new TemplatePreFetchTask([
        'page.HomePage',
        'page.CutoutPage',
        'page.JourneyToOzPage1', ...
...
      ])
    ];
    
    this._super(subtasks);

      }
    }
  })
]);

Na classe /m/javascripts/preloading/task/subtask/AssetPreloadTask.js, além de observar como ela se comunica com MainPreloadTask (pela implementação compartilhada de Task), também vale a pena observar como carregamos recursos que dependem da plataforma. Basicamente, temos quatro tipos de imagens. Padrão para dispositivos móveis (.ext, em que ext é a extensão de arquivo, normalmente .png ou .jpg), retina para dispositivos móveis (-2x.ext), padrão para tablets (-tab.ext) e retina para tablets (-tab-2x.ext). Em vez de fazer a detecção na MainPreloadTask e codificar quatro matrizes de recursos, basta informar o nome e a extensão do recurso a ser pré-carregado e se ele depende da plataforma (responsivo = verdadeiro / falso). Em seguida, a AssetPreloadTask vai gerar o nome do arquivo para nós:

resolveAssetUrl : function(assetName, extension, responsive) {
  return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' +  extension;
}

Mais adiante na cadeia de classes, o código que faz o pré-carregamento de recursos é o seguinte (/m/javascripts/raw/util/ImagePreloader.js):

loadUrl : function(url, type, completeHandler) {
  if(type === ImagePreloader.TYPE_BACKGROUND) {
    var $bg = $('<div>').hide().css('background-image', 'url(' + url + ')');
    this.$preloadContainer.append($bg);
  } else {
    var $img= $('<img />').attr('src', url).hide();
    this.$preloadContainer.append($img);
  }

  var image = new Image();
  this.cache[this.generateKey(url)] = image;
  image.onload = completeHandler;
  image.src = url;
}

generateKey : function(url) {
  return encodeURIComponent(url);
}

Tutorial: cabine de fotos em HTML5 (iOS6/Android)

Ao desenvolver o OZ para dispositivos móveis, percebemos que passamos muito tempo brincando com a cabine de fotos em vez de trabalhar :D Isso porque é muito divertido. Por isso, criamos uma demonstração para você testar.

Cabine de fotos móvel
Cabine de fotos para dispositivos móveis

Confira uma demonstração ao vivo aqui (execute no seu iPhone ou smartphone Android):

http://u9html5rocks.appspot.com/demos/mobile_photo_booth

Para configurá-lo, você precisa de uma instância de aplicativo sem custo financeiro do Google App Engine em que possa executar o back-end. O código de front-end não é complexo, mas há algumas possíveis armadilhas. Vamos analisar cada uma delas:

  1. Tipo de arquivo de imagem permitido Queremos que as pessoas possam fazer upload apenas de imagens (já que é uma cabine de fotos, não de vídeo). Em teoria, basta especificar o filtro em HTML, da seguinte forma: input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" No entanto, isso parece funcionar apenas no iOS. Por isso, precisamos adicionar uma verificação extra em relação à RegExp depois que um arquivo for selecionado:
   this.$fileInput.fileupload({
          
   dataType: 'json',
   autoUpload : true,
   
   add : function(e, data) {
     if(!data.files[0].name.match(/(\.|\/)(gif|jpe?g|png)$/i)) {
      return self.onFileTypeNotSupported();
     }
   }
   });
  1. Como cancelar um upload ou uma seleção de arquivo Outra inconsistência que notamos durante o processo de desenvolvimento é como diferentes dispositivos notificam uma seleção de arquivo cancelada. Os smartphones e tablets iOS não fazem nada, não notificam de forma alguma. Portanto, não precisamos de nenhuma ação especial para esse caso. No entanto, os smartphones Android acionam a função add() de qualquer maneira, mesmo que nenhum arquivo seja selecionado. Veja como fazer isso:
    add : function(e, data) {

    if(data.files.length === 0 || (data.files[0].size === 0 && data.files[0].name === "" && data.files[0].fileName === "")) {
            
    return self.onNoFileSelected();

    } else if(data.files.length > 1) {

    return self.onMultipleFilesSelected();            
    }
    }

O restante funciona de maneira bastante tranquila em todas as plataformas. Divirta-se!

Conclusão

Devido ao tamanho enorme de Find Your Way To Oz e à grande combinação de tecnologias envolvidas, neste artigo, conseguimos abordar apenas algumas das abordagens que usamos.

Se você quiser saber mais, confira o código-fonte completo de Find Your Way To Oz neste link.

Créditos

Clique aqui para ver a lista completa de créditos.

Referências