Criação do globo 3D das Maravilhas do Mundo

Ilmari Heikkinen

Introdução ao globo 3D das Maravilhas do Mundo

Se você acessou o site Maravilhas do Mundo do Google, lançado recentemente, em um navegador compatível com WebGL, talvez tenha visto um globo giratório na parte de baixo da tela. Neste artigo, explicamos como o globo funciona e o que usamos para criá-lo.

Para dar uma visão geral rápida, o globo do World Wonders é uma versão bastante modificada do WebGL Globe da equipe de artes de dados do Google. Pegamos o globo original, removemos as partes do gráfico de barras, mudamos os sombreadores, adicionamos marcadores HTML clicáveis e a geometria de continente do Natural Earth da demonstração do GlobeTweeter da Mozilla (um grande agradecimento a Cedric Pinson!). Tudo para criar um belo globo animado que combina com o esquema de cores do site e adiciona uma camada extra de sofisticação.

O objetivo do design do globo era ter um mapa animado bonito com marcadores clicáveis colocados sobre os sítios do Patrimônio Mundial. Com isso em mente, comecei a procurar algo adequado. A primeira coisa que veio à mente foi o WebGL Globe, criado pela equipe de artes de dados do Google. É um globo e é legal. O que mais você precisa, hein?

Como configurar o globo WebGL

A primeira etapa para criar o widget de globo foi fazer o download do WebGL Globe e colocá-lo em funcionamento. O WebGL Globe está on-line no Google Code, e é simples de baixar e executar. Faça o download e extraia o arquivo ZIP, use o comando cd para acessá-lo e execute um servidor da Web básico: python -m SimpleHTTPServer. (Observação: o UTF-8 não está ativado por padrão. Use este link.) Agora, se você acessar http://localhost:8000/globe/globe.html, vai ver o WebGL Globe.

Com o WebGL Globe em funcionamento, era hora de cortar todas as partes desnecessárias. Editei o HTML para remover as partes da interface e as configurações do gráfico de barras do globo da função de inicialização do globo. No final desse processo, eu tinha um WebGL Globe muito simples na tela. Você pode girá-lo e ele parece legal, mas é só isso.

Para remover o que não era necessário, excluí todos os elementos da interface do index.html do globo e editei o script de inicialização para que ficasse assim:

if(!Detector.webgl){
  Detector.addGetWebGLMessage();
} else {
  var container = document.getElementById('container');
  var globe = new DAT.Globe(container);
  globe.animate();
}

Adicionar a geometria do continente

Queríamos que a câmera ficasse perto da superfície do globo, mas, quando testamos o globo com zoom, a falta de resolução da textura ficou evidente. Com o zoom, a textura do WebGL Globe fica pixelada e desfocada. Poderíamos ter usado uma imagem maior, mas isso deixaria o download e a execução do globo mais lentos. Por isso, optamos por uma representação vetorial das massas de terra e das fronteiras.

Para a geometria da massa de terra, usei a demonstração de código aberto do GlobeTweeter e carreguei o modelo 3D no Three.js. Com o modelo carregado e renderizado, era hora de começar a polir o visual do globo. O primeiro problema foi que o modelo de massa de terra do globo não era esférico o suficiente para ficar nivelado com o WebGL Globe. Por isso, escrevi um algoritmo rápido de divisão de malha que tornou o modelo de massa de terra mais esférico.

Com um modelo de massa de terra esférica, consegui posicioná-lo um pouco deslocado da superfície do globo, criando continentes flutuantes delineados com uma linha preta de 2 px abaixo deles para criar uma espécie de sombra. Também testei contornos em neon para criar um visual parecido com o do filme Tron.

Com o globo e as massas de terra renderizados, comecei a testar diferentes visuais para o globo. Como queríamos um visual monocromático discreto, usei um globo e massas de terra em escala de cinza. Além dos contornos neon mencionados, testei um globo escuro com massas terrestres escuras em um fundo claro, o que ficou bem legal. Mas o contraste era muito baixo para facilitar a leitura e não combinava com o estilo do projeto, então descartei essa ideia.

Outra ideia inicial que tive para o visual do globo foi fazer com que ele parecesse porcelana vitrificada. Não consegui testar esse recurso porque não consegui escrever um sombreador para criar o visual de porcelana (um editor de material visual seria bom). O mais próximo que tentei foi este globo branco brilhante com massas de terra pretas. É legal, mas tem muito contraste. E não parece muito legal. Então, mais um para o ferro-velho.

Os sombreadores nos globos em preto e branco usam uma espécie de iluminação difusa falsa. A luminosidade do globo depende da distância da superfície normal ao plano da tela. Assim, os pixels no meio do globo que estão apontando para a tela ficam escuros, e os pixels nas bordas do globo ficam claros. Combinado com um fundo claro, o globo reflete o fundo brilhante difuso, criando um visual de showroom elegante. O globo preto também usa a textura do WebGL Globe como um mapa de brilho, para que as plataformas continentais (áreas de águas rasas) pareçam brilhantes em comparação com as outras partes do globo.

Veja como é o sombreador do oceano para o globo preto. Um sombreador de vértice muito básico e um sombreador de fragmento improvisado do tipo "ah, isso parece legal, ajuste, ajuste".

    'ocean' : {
      uniforms: {
        'texture': { type: 't', value: 0, texture: null }
      },
      vertexShader: [
        'varying vec3 vNormal;',
        'varying vec2 vUv;',
        'void main() {',
          'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
          'vNormal = normalize( normalMatrix * normal );',
          'vUv = uv;',
        '}'
      ].join('\n'),
      fragmentShader: [
        'uniform sampler2D texture;',
        'varying vec3 vNormal;',
        'varying vec2 vUv;',
        'void main() {',
          'vec3 diffuse = texture2D( texture, vUv ).xyz;',
          'float intensity = pow(1.05 - dot( vNormal, vec3( 0.0, 0.0, 1.0 ) ), 4.0);',
          'float i = 0.8-pow(clamp(dot( vNormal, vec3( 0, 0, 1.0 )), 0.0, 1.0), 1.5);',
          'vec3 atmosphere = vec3( 1.0, 1.0, 1.0 ) * intensity;',
          'float d = clamp(pow(max(0.0,(diffuse.r-0.062)*10.0), 2.0)*5.0, 0.0, 1.0);',
          'gl_FragColor = vec4( (d*vec3(i)) + ((1.0-d)*diffuse) + atmosphere, 1.0 );',
        '}'
      ].join('\n')
    }

No final, escolhemos um globo escuro com massas de terra cinza-claro iluminadas por cima. Era o mais próximo do briefing de design e tinha uma aparência agradável e legível. Além disso, o contraste mais baixo do globo faz com que os marcadores e o restante do conteúdo se destaquem mais. A versão abaixo usa oceanos completamente pretos, enquanto a versão de produção tem oceanos cinza-escuros e marcadores um pouco diferentes.

Como criar os marcadores com CSS

Por falar em marcadores, com o globo e as massas de terra funcionando, comecei a trabalhar nos marcadores de local. Decidi usar elementos HTML no estilo CSS para os marcadores, para facilitar a criação e a estilização deles e, possivelmente, reutilizá-los no mapa 2D em que a equipe estava trabalhando. Na época, eu também não sabia como tornar os marcadores WebGL clicáveis e não queria escrever código extra para carregar/criar os modelos de marcador. Em retrospecto, os marcadores CSS funcionavam bem, mas tinham uma tendência de, ocasionalmente, apresentar problemas de desempenho quando os compositores e renderizadores do navegador estavam em períodos de fluxo. Do ponto de vista da performance, fazer os marcadores em WebGL teria sido uma opção melhor. Por outro lado, os marcadores CSS economizaram bastante tempo de desenvolvimento.

Os marcadores CSS consistem em algumas divs posicionadas de forma absoluta com a propriedade de transformação CSS. O plano de fundo dos marcadores é um gradiente CSS, e a parte triangular do marcador é uma div girada. Os marcadores têm uma pequena sombra projetada para se destacarem do plano de fundo. O maior problema com os marcadores era fazer com que eles tivessem um desempenho bom o suficiente. Por mais triste que pareça, desenhar algumas dezenas de divs que se movem e mudam o z-index em cada frame é uma ótima maneira de acionar todos os tipos de armadilhas de renderização do navegador.

A forma como os marcadores são sincronizados com a cena em 3D não é muito complicada. Cada marcador tem um Object3D correspondente na cena do Three.js, que é usado para rastrear os marcadores. Para conseguir as coordenadas do espaço da tela, pego as matrizes do Three.js para o globo e o marcador e multiplico um vetor zero por elas. Com isso, recebo a posição da cena do marcador. Para ver a posição do marcador na tela, projeto a posição da cena pela câmera. O vetor projetado resultante tem as coordenadas de espaço de tela para o marcador, prontas para uso em CSS.

var mat = new THREE.Matrix4();
var v = new THREE.Vector3();

for (var i=0; i<locations.length; i++) {
  mat.copy(scene.matrix);
  mat.multiplySelf(locations[i].point.matrix);
  v.set(0,0,0);
  mat.multiplyVector3(v);
  projector.projectVector(v, camera);
  var x = w * (v.x + 1) / 2; // Screen coords are between -1 .. 1, so we transform them to pixels.
  var y = h - h * (v.y + 1) / 2; // The y coordinate is flipped in WebGL.
  var z = v.z;
}

No final, a abordagem mais rápida foi usar transformações de CSS para mover os marcadores, não usar o esmaecimento de opacidade, já que isso estava acionando um caminho lento no Firefox, e manter todos os marcadores no DOM, sem removê-los quando eles passavam por trás do globo. Também testamos o uso de transformações 3D em vez de z-indexes, mas, por algum motivo, isso não funcionou direito no app (embora tenha funcionado em um caso de teste reduzido, vai entender). Como estávamos a poucos dias do lançamento, tivemos que deixar essa parte para a manutenção pós-lançamento.

Quando você clica em um marcador, ele se expande em uma lista de nomes de lugares clicáveis. Isso é tudo normal do DOM HTML, então foi muito fácil de escrever. Todos os links e a renderização de texto funcionam sem nenhum trabalho extra da nossa parte.

Como reduzir o tamanho do arquivo

Com a demonstração funcionando e conectada ao restante do site Maravilhas do Mundo, ainda havia um grande problema a ser resolvido. A malha em formato JSON para as massas de terra do globo tinha cerca de 3 MB. Não é bom para a primeira página de um site de apresentação. A boa notícia é que a compactação da malha com gzip reduziu o tamanho para 350 kB. Mas 350 kB ainda é um pouco grande. Depois de alguns e-mails, conseguimos recrutar Won Chun, que trabalhou na compactação das enormes malhas do Google Body, para nos ajudar a compactar a malha. Ele comprimiu a malha de uma grande lista simples de triângulos fornecidos como coordenadas JSON para coordenadas compactadas de 11 bits com triângulos indexados e reduziu o tamanho do arquivo para 95 kB compactado com gzip.

O uso de malhas compactadas não apenas economiza largura de banda, mas também acelera a análise das malhas. Transformar 3 MB de números em string em números nativos dá muito mais trabalho do que analisar 100 kB de dados binários. A redução de 250 kB no tamanho da página também é muito útil, já que o tempo de carregamento inicial fica abaixo de um segundo em uma conexão de 2 Mbps. Mais rápido e menor, que maravilha!

Ao mesmo tempo, eu estava brincando com o carregamento dos shapefiles originais do Natural Earth, que são a base da malha do GlobeTweeter. Consegui carregar os shapefiles, mas para renderizá-los como massas de terra planas, é preciso triangulá-los (com buracos para lagos, é claro). Consegui triangular as formas usando os utilitários do THREE.js, mas não os furos. As malhas resultantes tinham bordas muito longas, o que exigia a divisão da malha em triângulos menores. Resumindo, não consegui fazer funcionar a tempo, mas o legal é que o formato Shapefile mais compactado teria gerado um modelo de massa de terra de 8 kB. Ah, talvez na próxima.

Trabalhos futuros

Uma coisa que poderia ser melhorada é a animação dos marcadores. Agora, quando eles passam pelo horizonte, o efeito é um pouco brega. Além disso, seria legal ter uma animação bacana para a abertura do marcador.

Em termos de desempenho, as duas coisas que faltam são otimizar o algoritmo de divisão de malha e acelerar os marcadores. Fora isso, está tudo ótimo. Viva!

Resumo

Neste artigo, descrevi como criamos o globo 3D para o projeto Maravilhas do Mundo do Google. Espero que você tenha gostado dos exemplos e que tente criar seu próprio widget de globo personalizado.

Referências