Caso de éxito: Find Your Way to Oz

Introducción

“Find Your Way to Oz” es un nuevo experimento de Google Chrome que Disney llevó a la Web. Te permite realizar un viaje interactivo por un circo de Kansas, que te lleva a la tierra de Oz después de que te arrastra una tormenta masiva.

Nuestro objetivo era combinar la riqueza del cine con las capacidades técnicas del navegador para crear una experiencia divertida y envolvente con la que los usuarios puedan establecer una conexión sólida.

El trabajo es demasiado grande para capturarlo en su totalidad en este artículo, por lo que nos sumergimos y extrajimos algunos capítulos de la historia de la tecnología que creemos que son interesantes. En el proceso, extrajimos algunos instructivos específicos de dificultad creciente.

Muchas personas trabajaron arduamente para hacer posible esta experiencia, demasiadas para mencionarlas aquí. Visita el sitio para consultar la página de créditos en la sección del menú y conocer la historia completa.

¿Qué ocurre detrás de escena?

En computadoras de escritorio, Find Your Way to Oz es un mundo inmersivo enriquecido. Usamos 3D y varias capas de efectos tradicionales inspirados en el cine que se combinan para crear una escena casi realista. Las tecnologías más destacadas son WebGL con Three.js, sombreadores personalizados y elementos animados del DOM con funciones de CSS3. Además, la API de getUserMedia (WebRTC) para experiencias interactivas que permiten al usuario agregar su imagen directamente desde la cámara web y WebAudio para sonido 3D.

Pero la magia de una experiencia tecnológica como esta es cómo se integra todo. Este también es uno de los principales desafíos: ¿cómo combinar efectos visuales y elementos interactivos en una escena para crear un todo coherente? Esta complejidad visual era difícil de administrar, lo que dificultaba saber en qué etapa del desarrollo nos encontrábamos en un momento dado.

Para abordar el problema de los efectos visuales interconectados y la optimización, usamos mucho un panel de control que capturaba todos los parámetros de configuración relevantes que estábamos revisando en ese momento. La escena se podía ajustar en vivo en el navegador para cualquier aspecto, desde el brillo hasta la profundidad de campo, la gamma, etcétera. Cualquier persona podía intentar ajustar los valores de los parámetros significativos en la experiencia y participar en el descubrimiento de lo que funcionaba mejor.

Antes de compartir nuestro secreto, queremos advertirte que podría fallar, tal como si estuvieras hurgando en el motor de un automóvil. Asegúrate de no tener nada importante activado, visita la URL principal del sitio y agrega ?debug=on a la dirección. Espera a que se cargue el sitio y, una vez que estés dentro, presiona la tecla Ctrl-I. Verás que aparece un menú desplegable en el lado derecho. Si desmarcas la opción "Salir de la ruta de la cámara", puedes usar las teclas A, W, S, D y el mouse para moverte libremente por el espacio.

Ruta de la cámara.

No revisaremos todos los parámetros de configuración aquí, pero te recomendamos que experimentes: las teclas revelan diferentes parámetros de configuración en distintas escenas. En la secuencia final de la tormenta, hay una tecla adicional: Ctrl-A, con la que puedes activar o desactivar la reproducción de la animación y volar. En esta escena, si presionas Esc (para salir de la funcionalidad de bloqueo del mouse) y vuelves a presionar Ctrl-I, puedes acceder a la configuración específica de la escena de tormenta. Echa un vistazo y captura algunas vistas de postal agradables como la que se muestra a continuación.

Escena de tormenta

Para lograrlo y asegurarnos de que fuera lo suficientemente flexible para nuestras necesidades, usamos una biblioteca encantadora llamada dat.gui (consulta aquí un instructivo anterior sobre cómo usarla). Nos permitió cambiar rápidamente los parámetros de configuración que se mostraban a los visitantes del sitio.

Un poco como una pintura mate

En muchas películas y animaciones clásicas de Disney, crear escenas significaba combinar diferentes capas. Había capas de acción en vivo, animación de celdas, incluso decorados físicos y, sobre todo, capas creadas pintando sobre vidrio: una técnica llamada pintura mate.

En muchos sentidos, la estructura de la experiencia que creamos es similar, aunque algunas de las “capas” son mucho más que imágenes estáticas. De hecho, afectan la forma en que se ven los elementos según cálculos más complejos. Sin embargo, al menos a nivel general, estamos lidiando con vistas compuestas una encima de la otra. En la parte superior, se ve una capa de IU con una escena en 3D debajo, que, a su vez, está compuesta por diferentes componentes de escena.

La capa superior de la interfaz se creó con DOM y CSS 3, lo que significa que la edición de las interacciones se puede realizar de muchas maneras, independientemente de la experiencia en 3D, con comunicación entre ambas según una lista selecta de eventos. Esta comunicación usa Backbone Router + el evento onHashChange de HTML5 que controla qué área debe animarse para entrar o salir. (fuente del proyecto: /develop/coffee/router/Router.coffee).

Instructivo: Hojas de objetos y compatibilidad con Retina

Una técnica de optimización divertida que usamos para la interfaz fue combinar las muchas imágenes de superposición de la interfaz en un solo PNG para reducir las solicitudes al servidor. En este proyecto, la interfaz se compuso de más de 70 imágenes (sin contar las texturas 3D) cargadas por adelantado para reducir la latencia del sitio web. Puedes ver la hoja de objeto en vivo aquí:

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

Aquí tienes algunas sugerencias sobre cómo aprovechamos el uso de las hojas de objetos, cómo usarlas para dispositivos con pantalla Retina y cómo lograr que la interfaz sea lo más nítida y prolija posible.

Cómo crear hojas de sprites

Para crear SpriteSheets, usamos TexturePacker, que genera el resultado en cualquier formato que necesites. En este caso, exportamos como EaselJS, que es muy limpio y también se podría haber usado para crear sprites animados.

Cómo usar la hoja de objeto generada

Una vez que hayas creado tu hoja de objeto, deberías ver un archivo 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]
   },
}

Donde:

  • image hace referencia a la URL de la hoja de objeto.
  • frames son las coordenadas de cada elemento de la IU [x, y, width, height]
  • animations son los nombres de cada recurso.

Ten en cuenta que usamos las imágenes de alta densidad para crear la hoja de objeto y, luego, creamos la versión normal simplemente cambiando su tamaño a la mitad.

Resumen

Ahora que todo está listo, solo necesitamos un fragmento de JavaScript para usarlo.

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);
};

Y así es como lo usarías:

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 comprender un poco más sobre las densidades de píxeles variables, puedes leer este artículo de Boris Smus.

La canalización de contenido 3D

La experiencia del entorno se configura en una capa de WebGL. Cuando piensas en una escena en 3D, una de las preguntas más difíciles es cómo te asegurarás de poder crear contenido que permita el máximo potencial expresivo desde los lados del modelado, la animación y los efectos. En muchos sentidos, el núcleo de este problema es la canalización de contenido: un proceso acordado que se debe seguir para crear contenido para la escena en 3D.

Queríamos crear un mundo que inspirara asombro, por lo que necesitábamos un proceso sólido que permitiera a los artistas de 3D crearlo. Necesitaban tener la mayor libertad expresiva posible en su software de animación y modelado 3D, y nosotros debíamos renderizarlo en pantalla a través de código.

Habíamos estado trabajando en este tipo de problema durante algún tiempo porque cada vez que creábamos un sitio en 3D en el pasado, encontrábamos limitaciones en las herramientas que podíamos usar. Así que creamos esta herramienta, llamada 3D Librarian, como parte de una investigación interna. Y estaba casi listo para aplicarse a un trabajo real.

Esta herramienta tiene su historia: originalmente era para Flash y te permitía importar una gran escena de Maya como un solo archivo comprimido que estaba optimizado para desempaquetar el tiempo de ejecución. La razón por la que era óptimo era porque empaquetaba de manera eficaz la escena en básicamente la misma estructura de datos que se manipula durante la renderización y la animación. Se debe realizar muy poco análisis del archivo cuando se carga. La descompresión en Flash era bastante rápida porque el archivo estaba en formato AMF, que Flash podía descomprimir de forma nativa. Usar el mismo formato en WebGL requiere un poco más de trabajo en la CPU. De hecho, tuvimos que volver a crear una capa de código de JavaScript para desempaquetar datos, que básicamente descomprimiría esos archivos y volvería a crear las estructuras de datos necesarias para que WebGL funcione. Desempaquetar toda la escena en 3D es una operación que requiere un uso moderado de la CPU: desempaquetar la escena 1 en Find Your Way To Oz requiere alrededor de 2 segundos en una máquina de gama media a alta. Por lo tanto, esto se hace con la tecnología de Web Workers, en el momento de la “configuración de la escena” (antes de que se inicie la escena), para no interrumpir la experiencia del usuario.

Esta práctica herramienta puede importar la mayor parte de la escena en 3D: modelos, texturas y animaciones de huesos. Creas un solo archivo de biblioteca, que luego puede cargar el motor 3D. Colocas todos los modelos que necesitas en tu escena dentro de esta biblioteca y, listo, los generas en tu escena.

Sin embargo, tuvimos un problema: ahora estábamos lidiando con WebGL, el nuevo chico del barrio. Este era un niño bastante rudo: estaba estableciendo el estándar para las experiencias en 3D basadas en el navegador. Por lo tanto, creamos una capa de JavaScript ad hoc que tomara los archivos de escenas en 3D comprimidos de 3D Librarian y los tradujera correctamente a un formato que WebGL pudiera entender.

Instructivo: Que se haga el viento

Un tema recurrente en “Find Your Way To Oz” era el viento. Un hilo de la historia está estructurado para ser un crescendo de viento.

La primera escena del carnaval es relativamente tranquila. A medida que avanza por las distintas escenas, el usuario experimenta un viento cada vez más fuerte, que culmina en la escena final, la tormenta.

Por lo tanto, era importante proporcionar un efecto de viento envolvente.

Para crear esto, completamos las 3 escenas de carnaval con objetos que eran suaves y, por lo tanto, se suponía que se verían afectados por el viento, como carpas, banderas, la superficie de la cabina de fotos y el globo en sí.

Paño suave

En la actualidad, los juegos para computadoras de escritorio suelen crearse en torno a un motor de física principal. Por lo tanto, cuando se necesita simular un objeto blando en el mundo 3D, se ejecuta una simulación física completa para él, lo que crea un comportamiento blando creíble.

En WebGL / JavaScript, no tenemos (todavía) el lujo de ejecutar una simulación de física completa. Así que en Oz tuvimos que encontrar una forma de crear el efecto del viento sin simularlo realmente.

Incorporamos la información de la “sensibilidad al viento” de cada objeto en el propio modelo 3D. Cada vértice del modelo 3D tenía un "atributo de viento" que especificaba cuánto debía verse afectado ese vértice por el viento. Por lo tanto, esto especifica la sensibilidad al viento de los objetos 3D. Luego, tuvimos que crear el viento en sí.

Para ello, generamos una imagen que contiene ruido de Perlin. Esta imagen está diseñada para cubrir una cierta “área de viento”. Por lo tanto, una buena manera de pensar en ella es imaginar una imagen de ruido similar a una nube que se coloca sobre un área rectangular determinada de la escena en 3D. Cada píxel, valor de nivel de gris, de esta imagen especifica qué tan fuerte es el viento en un momento determinado en el área 3D que lo rodea.

Para producir el efecto del viento, la imagen se mueve, en el tiempo, a una velocidad constante, en una dirección específica: la dirección del viento. Para asegurarnos de que el “área de viento” no afecte todo lo que hay en la escena, envolvemos la imagen del viento alrededor de los bordes, confinada al área de efecto.

Instructivo sencillo sobre el viento en 3D

Ahora, creemos el efecto del viento en una escena sencilla en 3D en Three.js.

Crearemos viento en un “campo de pasto procedimental” simple.

Primero, crearemos la escena. Vamos a tener un terreno plano, simple y con textura. Y, luego, cada brizna de pasto se representará simplemente con un cono 3D invertido.

Terreno cubierto de pasto
Terreno cubierto de pasto

A continuación, se muestra cómo crear esta escena simple en Three.js con CoffeeScript.

Primero, configuraremos Three.js y lo conectaremos con la cámara, el controlador del mouse y un poco de luz:

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()

Las llamadas a funciones initGrass e initTerrain propagan la escena con pasto y 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

Aquí creamos una cuadrícula de 15 por 15 bits de césped. Agregamos un poco de aleatorización a cada posición del pasto para que no se alineen como soldados, lo que se vería extraño.

Este terreno es solo un plano horizontal, ubicado en la base de los trozos de pasto (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 )

Hasta ahora, lo que hicimos fue simplemente crear una escena de Three.js y agregar algunos trozos de pasto, hechos de conos invertidos generados de forma procedimental, y un terreno simple.

Hasta ahora, no hay nada sofisticado.

Ahora, es momento de comenzar a agregar viento. Primero, queremos incorporar la información de sensibilidad al viento en el modelo 3D del pasto.

Incorporaremos esta información como un atributo personalizado para cada vértice del modelo 3D de pasto. Y usaremos la regla de que el extremo inferior del modelo de pasto (la punta del cono) tiene sensibilidad cero, ya que está unido al suelo. La parte superior del modelo de pasto (la base del cono) tiene la máxima sensibilidad al viento, ya que es la parte que está más alejada del suelo.

Así es como se vuelve a codificar la función instanceGrass para agregar la sensibilidad al viento como un atributo personalizado para el modelo 3D de pasto.

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

Ahora, usamos un material personalizado, windMaterial, en lugar del MeshPhongMaterial que usamos antes. WindMaterial une el WindMeshShader que veremos en un minuto.

Por lo tanto, el código de instanceGrass recorre todos los vértices del modelo de pasto y, para cada vértice, agrega un atributo de vértice personalizado, llamado windFactor. Este windFactor se establece en 0 para el extremo inferior del modelo de pasto (donde se supone que toca el terreno) y tiene un valor de 1 para el extremo superior del modelo de pasto.

El otro ingrediente que necesitamos es agregar el viento real a nuestra escena. Como ya se mencionó, usaremos el ruido de Perlin para esto. Generaremos de forma procedimental una textura de ruido de Perlin.

Para mayor claridad, asignaremos esta textura al terreno, en lugar de la textura verde anterior que tenía. Esto facilitará que te hagas una idea de lo que está sucediendo con el viento.

Por lo tanto, esta textura de ruido de Perlin cubrirá espacialmente la extensión de nuestro terreno, y cada píxel de la textura especificará la intensidad del viento del área del terreno donde se encuentra ese píxel. El rectángulo de terreno será nuestra “área de viento”.

El ruido de Perlin se genera de forma procedimental a través de un sombreador, llamado NoiseShader. Este sombreador usa algoritmos de ruido simplex en 3D de https://github.com/ashima/webgl-noise . La versión de WebGL de este ejemplo se tomó textualmente de una de las muestras de Three.js de MrDoob, en http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader toma un conjunto de parámetros de tiempo, escala y desplazamiento, como uniformes, y genera una buena distribución 2D de ruido de 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) }

...

Usaremos este sombreador para renderizar nuestro ruido de Perlin en una textura. Esto se hace en la función 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 )

Lo que hace el código anterior es configurar noiseMap como un destino de renderización de Three.js, equiparlo con NoiseShader y, luego, renderizarlo con una cámara ortográfica para evitar distorsiones de perspectiva.

Como se mencionó, ahora usaremos esta textura también como la textura de renderización principal para el terreno. Esto no es realmente necesario para que funcione el efecto de viento en sí. Pero es bueno tenerlo para que podamos comprender mejor visualmente lo que está sucediendo con la generación eólica.

Aquí tienes la función initTerrain modificada, que usa 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 )

Ahora que tenemos nuestra textura de viento, veamos WindMeshShader, que se encarga de deformar los modelos de pasto según el viento.

Para crear este sombreador, partimos del sombreador MeshPhongMaterial estándar de Three.js y lo modificamos. Esta es una buena forma rápida y sencilla de comenzar con un sombreador que funcione, sin tener que empezar de cero.

No copiaremos todo el código del sombreador aquí (puedes verlo en el archivo de código fuente), ya que la mayor parte sería una réplica del sombreador MeshPhongMaterial. Pero veamos las partes modificadas relacionadas con el viento en el sombreador de vértices.

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;

Por lo tanto, lo que hace este sombreador es calcular primero la coordenada de búsqueda de textura windUV, según la posición 2D, xz (horizontal) del vértice. Esta coordenada UV se usa para buscar la fuerza del viento, vWindForce, en la textura del viento de ruido de Perlin.

Este valor vWindForce se compone con el atributo personalizado windFactor específico del vértice que se analizó anteriormente para calcular cuánta deformación necesita el vértice. También tenemos un parámetro global windScale para controlar la fuerza general del viento y un vector windDirection que especifica en qué dirección debe producirse la deformación del viento.

Esto crea una deformación basada en el viento de nuestras briznas de pasto. Sin embargo, aún no terminamos. Tal como está ahora, esta deformación es estática y no transmitirá el efecto de un área con viento.

Como mencionamos, necesitaremos deslizar la textura de ruido con el tiempo, por el área del viento, para que nuestro vidrio pueda ondularse.

Para ello, se desplaza con el tiempo el uniforme vOffset que se pasa al NoiseShader. Este es un parámetro vec2 que nos permitirá especificar el desplazamiento del ruido en una dirección determinada (la dirección del viento).

Esto se hace en la función render, a la que se llama en cada fotograma:

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
...

¡Y eso es todo! Acabamos de crear una escena con "pasto procedimental" afectado por el viento.

Agrega a la mezcla

Ahora, agreguemos un poco de emoción a nuestra escena. Agreguemos un poco de volando para que la escena sea más interesante.

Agregando
Agregar

Después de todo, se supone que el viento afecta al, por lo que tiene mucho sentido que haya volando en nuestra escena de viento.

El se configura en la función initDust como un 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

Aquí se crean 130 partículas de. Ten en cuenta que cada uno de ellos está equipado con un WindParticleShader especial.

Ahora, en cada fotograma, moveremos un poco las partículas con CoffeeScript, independientemente del viento. Este es el 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 )

Además, compensaremos la posición de cada partícula según el viento. Esto se hace en WindParticleShader. Específicamente, en el sombreador de vértices.

El código de este sombreador es una versión modificada de ParticleMaterial de Three.js, y su núcleo se ve de la siguiente manera:

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;

Este sombreador de vértices no es tan diferente del que teníamos para la deformación de la hierba basada en el viento. Toma la textura de ruido de Perlin como entrada y, según la posición de la partícula de en el mundo, busca un valor de vWindForce en la textura de ruido. Luego, usa este valor para modificar la posición de la partícula de.

Riders On The Storm

La más aventurera de nuestras escenas de WebGL probablemente fue la última, que puedes ver si haces clic en el globo para llegar al ojo del tornado y alcanzar el final de tu viaje en el sitio, y un video exclusivo del próximo lanzamiento.

Escena de paseo en globo

Cuando creamos esta escena, sabíamos que necesitábamos tener un elemento central para la experiencia que fuera impactante. El tornado giratorio sería el elemento central, y las capas de otro contenido moldearían este elemento para crear un efecto dramático. Para lograrlo, construimos lo que sería el equivalente de un set de estudio de cine alrededor de este extraño sombreador.

Usamos un enfoque mixto para crear la composición realista. Algunos eran trucos visuales, como formas de luz para crear un efecto de destello de lente o gotas de lluvia que se animan como capas sobre la escena que estás mirando. En otros casos, teníamos superficies planas dibujadas para que parecieran moverse, como las capas de nubes bajas que se mueven según un código de sistema de partículas. Mientras que los fragmentos de escombros que orbitaban alrededor del tornado eran capas de una escena en 3D ordenadas para moverse delante y detrás del tornado.

La razón principal por la que tuvimos que construir la escena de esta manera fue para asegurarnos de que tuviéramos suficiente GPU para manejar el sombreador de tornado en equilibrio con los otros efectos que estábamos aplicando. Al principio, tuvimos grandes problemas de balanceo de GPU, pero luego se optimizó esta escena y se volvió más liviana que las principales.

Instructivo: El sombreador de tormentas

Para crear la secuencia final de la tormenta, se combinaron muchas técnicas diferentes, pero la pieza central de este trabajo fue un sombreador GLSL personalizado que se parece a un tornado. Probamos muchas técnicas diferentes, desde sombreadores de vértices para crear remolinos geométricos interesantes hasta animaciones basadas en partículas y, incluso, animaciones en 3D de formas geométricas retorcidas. Ninguno de los efectos parecía recrear la sensación de un tornado o requería demasiado procesamiento.

Un proyecto completamente diferente nos proporcionó la respuesta. Un proyecto paralelo que involucraba juegos para la ciencia con el objetivo de mapear el cerebro de un ratón del Instituto Max Planck (brainflight.org) había generado efectos visuales interesantes. Logramos crear videos del interior de una neurona de ratón con un sombreador volumétrico personalizado.

Interior de una neurona de ratón con un sombreador volumétrico personalizado
Interior de una neurona de ratón con un sombreador volumétrico personalizado

Descubrimos que el interior de una célula cerebral se parecía un poco al embudo de un tornado. Y como estábamos usando una técnica volumétrica, sabíamos que podíamos ver este sombreador desde todas las direcciones en el espacio. Podríamos configurar la renderización del sombreador para que se combine con la escena de la tormenta, en especial si se intercala entre capas de nubes y sobre un fondo dramático.

La técnica de sombreador implica un truco que, básicamente, usa un solo sombreador GLSL para renderizar un objeto completo con un algoritmo de renderización simplificado llamado renderización de ray marching con un campo de distancia. En esta técnica, se crea un sombreador de píxeles que estima la distancia más cercana a una superficie para cada punto de la pantalla.

Puedes encontrar una buena referencia al algoritmo en la descripción general de iq: Rendering Worlds With Two Triangles - Iñigo Quilez. También puedes explorar la galería de sombreadores en glsl.heroku.com, donde encontrarás muchos ejemplos de esta técnica con los que puedes experimentar.

El núcleo del sombreador comienza con la función principal, que configura las transformaciones de la cámara y entra en un bucle que evalúa repetidamente la distancia a una superficie. La llamada RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) es donde se realiza el cálculo principal de 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
}

La idea es que, a medida que avanzamos en la forma del tornado, agregamos con regularidad contribuciones de color al valor de color final del píxel, así como contribuciones a la opacidad a lo largo del rayo. Esto crea una calidad suave y en capas para la textura del tornado.

El siguiente aspecto principal del tornado es la forma en sí, que se crea componiendo una serie de funciones. Para empezar, es un cono que se compone con ruido para crear un borde irregular orgánico y, luego, se retuerce a lo largo de su eje principal y se rota en el tiempo.

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;
}

El trabajo que implica crear este tipo de sombreador es complicado. Más allá de los problemas relacionados con la abstracción de las operaciones que estás creando, existen problemas graves de optimización y compatibilidad multiplataforma que debes rastrear y resolver antes de poder usar el trabajo en producción.

La primera parte del problema: optimizar este sombreador para nuestra escena. Para lidiar con esto, necesitábamos tener un enfoque “seguro” en caso de que el sombreador fuera demasiado pesado. Para ello, compusimos el sombreador del tornado con una resolución de muestreo diferente de la del resto de la escena. Esto es del archivo stormTest.coffee (sí, ¡esto fue una prueba!).

Comenzamos con un renderTarget que coincide con el ancho y la altura de la escena para que podamos tener independencia de la resolución del sombreador de tornado para la escena. Luego, decidimos la reducción de muestreo de la resolución del sombreador de tormenta de forma dinámica según la velocidad de fotogramas que obtenemos.

...
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 último, renderizamos el tornado en la pantalla con un algoritmo sal2x simplificado (para evitar el aspecto de bloques) en la línea 1107 de stormTest.coffee. Esto significa que, en el peor de los casos, terminamos con un tornado más borroso, pero al menos funciona sin quitarle el control al usuario.

El siguiente paso de optimización requiere profundizar en el algoritmo. El factor de procesamiento principal en el sombreador es la iteración que se realiza en cada píxel para intentar aproximar la distancia de la función de superficie: la cantidad de iteraciones del bucle de raymarching. Con un tamaño de paso más grande, podríamos obtener una estimación de la superficie del tornado con menos iteraciones mientras estuviéramos fuera de su superficie nubosa. Cuando estemos dentro, disminuiremos el tamaño del paso para obtener precisión y poder mezclar valores para crear el efecto de niebla. Además, crear un cilindro delimitador para obtener una estimación de la profundidad del rayo proyectado mejoró la velocidad.

La siguiente parte del problema era asegurarse de que este sombreador se ejecutara en diferentes tarjetas de video. Realizamos algunas pruebas cada vez y comenzamos a desarrollar una intuición sobre el tipo de problemas de compatibilidad que podríamos encontrar. La razón por la que no pudimos hacer mucho más que usar la intuición es que no siempre pudimos obtener buena información de depuración sobre los errores. Una situación típica es un error de GPU con poca información adicional o incluso una falla del sistema.

Los problemas de compatibilidad entre placas de video tenían soluciones similares: asegurarse de que las constantes estáticas se ingresen con el tipo de datos preciso según se define, p. ej.: 0.0 para float y 0 para int. Tener cuidado al escribir funciones más largas; es preferible dividir las cosas en varias funciones más simples y variables intermedias porque los compiladores parecían no manejar ciertos casos correctamente. Asegúrate de que todas las texturas sean una potencia de 2, que no sean demasiado grandes y, en cualquier caso, que se tenga “precaución” cuando se busquen datos de textura en un bucle.

Los mayores problemas de compatibilidad que tuvimos fueron con el efecto de iluminación de la tormenta. Usamos una textura prefabricada que envolvía el tornado para poder colorear sus ráfagas. Era un efecto magnífico y facilitaba la integración del tornado en los colores de la escena, pero tardaba mucho tiempo en ejecutarse en otras plataformas.

tornado

El sitio web para dispositivos móviles

La experiencia para dispositivos móviles no podía ser una traducción directa de la versión para computadoras, ya que los requisitos de tecnología y procesamiento eran demasiado pesados. Tuvimos que crear algo nuevo, que se orientara específicamente a los usuarios de dispositivos móviles.

Pensamos que sería genial tener la cabina de fotos de carnaval de la computadora de escritorio como una aplicación web para dispositivos móviles que use la cámara del dispositivo móvil del usuario. Algo que no habíamos visto hasta ahora.

Para darle un toque especial, programamos transformaciones en 3D en CSS3. Como lo vinculamos con el giroscopio y el acelerómetro, pudimos agregar mucha profundidad a la experiencia. El sitio responde a la forma en que sostienes, mueves y miras el teléfono.

Cuando escribimos este artículo, pensamos que sería útil darte algunas sugerencias para que el proceso de desarrollo para dispositivos móviles se ejecute sin problemas. ¡Aquí van! Adelante, descubre qué puedes aprender de ella.

Sugerencias y trucos para dispositivos móviles

El precargador es algo necesario, no algo que se deba evitar. Sabemos que, a veces, ocurre lo segundo. Esto se debe principalmente a que debes mantener la lista de elementos que precargas a medida que crece tu proyecto. Y lo que es peor, no queda muy claro cómo calcular el progreso de carga si extraes diferentes recursos, y muchos de ellos al mismo tiempo. Aquí es donde nuestra clase abstracta personalizada y muy genérica "Task" resulta útil. Su idea principal es permitir una estructura anidada sin fin en la que una tarea puede tener sus propias subtareas, que pueden tener las suyas, etc. Además, cada tarea calcula su progreso con respecto al progreso de sus subtareas (pero no al progreso de la tarea superior). Haciendo que MainPreloadTask, AssetPreloadTask y TemplatePreFetchTask deriven de Task, creamos una estructura que se ve de la siguiente manera:

Precargador

Gracias a este enfoque y a la clase Task, podemos conocer fácilmente el progreso global (MainPreloadTask), el progreso de los recursos (AssetPreloadTask) o el progreso de la carga de plantillas (TemplatePreFetchTask). Incluso el progreso de un archivo en particular. Para ver cómo se hace, consulta la clase Task en /m/javascripts/raw/util/Task.js y las implementaciones de tareas reales en /m/javascripts/preloading/task. A modo de ejemplo, este es un extracto de cómo configuramos la clase /m/javascripts/preloading/task/MainPreloadTask.js, que es nuestro wrapper de precarga 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);

      }
    }
  })
]);

En la clase /m/javascripts/preloading/task/subtask/AssetPreloadTask.js, además de observar cómo se comunica con MainPreloadTask (a través de la implementación de Task compartida), también vale la pena observar cómo cargamos los recursos que dependen de la plataforma. Básicamente, tenemos cuatro tipos de imágenes. Estándar para dispositivos móviles (.ext, donde ext es la extensión de archivo, por lo general, .png o .jpg), retina para dispositivos móviles (-2x.ext), estándar para tablets (-tab.ext) y retina para tablets (-tab-2x.ext). En lugar de realizar la detección en MainPreloadTask y codificar de forma fija cuatro arrays de recursos, solo indicamos el nombre y la extensión del recurso que se precargará y si el recurso depende de la plataforma (responsive = true / false). Luego, AssetPreloadTask generará el nombre del archivo por nosotros:

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

Más abajo en la cadena de clases, el código real que realiza la carga previa de recursos se ve de la siguiente manera (/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);
}

Instructivo: Cabina de fotos HTML5 (iOS6/Android)

Cuando desarrollamos OZ para dispositivos móviles, nos dimos cuenta de que pasábamos mucho tiempo jugando con la cabina de fotos en lugar de trabajar :D. Simplemente, era divertido. Por eso, creamos una demostración para que juegues.

Cabina de fotos móvil
Cabina de fotos móvil

Puedes ver una demostración en vivo aquí (ejecútala en tu iPhone o teléfono Android):

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

Para configurarlo, necesitas una instancia de aplicación gratuita de Google App Engine en la que puedas ejecutar el backend. El código de frontend no es complejo, pero hay un par de posibles problemas. Veámoslos a continuación:

  1. Tipo de archivo de imagen permitido Queremos que las personas solo puedan subir imágenes (ya que se trata de una cabina de fotos, no de video). En teoría, puedes especificar el filtro en HTML de la siguiente manera: input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" Sin embargo, parece que solo funciona en iOS, por lo que debemos agregar una verificación adicional con la RegExp una vez que se haya seleccionado un archivo:
   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. Cómo cancelar una carga o una selección de archivos Otra inconsistencia que notamos durante el proceso de desarrollo es cómo los diferentes dispositivos notifican una selección de archivos cancelada. Los teléfonos y las tablets iOS no hacen nada, no notifican en absoluto. Por lo tanto, no necesitamos ninguna acción especial para este caso. Sin embargo, los teléfonos Android activan la función add() de todos modos, incluso si no se selecciona ningún archivo. A continuación, te mostramos cómo hacerlo:
    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();            
    }
    }

El resto funciona bastante bien en todas las plataformas. Diviértete.

Conclusión

Dado el enorme tamaño de Find Your Way To Oz y la amplia combinación de diferentes tecnologías involucradas, en este artículo solo pudimos abarcar algunos de los enfoques que usamos.

Si quieres explorar todo el código fuente de Find Your Way To Oz, puedes hacerlo en este vínculo.

Créditos

Haz clic aquí para ver la lista completa de créditos

Referencias