История успеха: Find Your Way to Oz

Введение

Find Your Way to Oz – это новый эксперимент Google Chrome, созданный компанией Disney. Вы можете совершить интерактивное путешествие по цирку в Канзасе, а затем, после того как вас унесет ураган, оказаться в стране Оз.

Мы хотели объединить богатство кинематографа с техническими возможностями браузера, чтобы создать увлекательный, захватывающий опыт, с которым пользователи могут установить прочную связь.

В этой статье мы не сможем рассказать обо всем, поэтому мы выбрали несколько интересных тем. Попутно мы извлекли несколько целенаправленных руководств возрастающей сложности.

Над этим проектом работало множество людей, и мы не можем перечислить их всех. Чтобы узнать больше, посетите сайт и откройте страницу с информацией об авторах в меню.

Как работает инструмент

Эксперимент Find Your Way to Oz для компьютеров – это богатый и захватывающий мир. Мы используем 3D и несколько слоев традиционных эффектов, вдохновленных кинематографом, которые в сочетании создают почти реалистичную сцену. Наиболее заметные технологии – WebGL с Three.js, настраиваемые шейдеры и анимированные элементы DOM с использованием функций CSS3. Кроме того, getUserMedia API (WebRTC) для интерактивных возможностей, позволяющих пользователю добавлять свое изображение непосредственно с веб-камеры, и WebAudio для 3D-звука.

Но магия таких технологий заключается в том, как они работают вместе. Это одна из главных сложностей: как объединить визуальные эффекты и интерактивные элементы в одной сцене, чтобы создать единое целое? Управлять такой сложной визуальной системой было непросто, и нам было трудно понять, на каком этапе разработки мы находимся в тот или иной момент.

Чтобы решить проблему взаимосвязанных визуальных эффектов и оптимизации, мы активно использовали панель управления, которая фиксировала все соответствующие настройки, которые мы рассматривали в тот момент времени. В браузере можно было в реальном времени настраивать яркость, глубину резкости, гамму и другие параметры. Любой желающий мог попробовать изменить значения важных параметров и поучаствовать в поиске наилучшего решения.

Прежде чем поделиться секретом, мы хотим предупредить вас, что это может привести к сбою, как если бы вы ковырялись в двигателе автомобиля. Убедитесь, что вы не выполняете никаких важных действий, перейдите на главную страницу сайта и добавьте к ее URL строку ?debug=on. Дождитесь загрузки сайта и нажмите клавишу Ctrl-I. Справа появится раскрывающийся список. Если вы снимете флажок "Выйти из траектории камеры", то сможете свободно перемещаться по пространству с помощью клавиш A, W, S, D и мыши.

Путь камеры.

Мы не будем описывать все настройки, но рекомендуем вам поэкспериментировать: клавиши открывают разные настройки в разных сценах. В финальной сцене с бурей есть дополнительная клавиша Ctrl-A, с помощью которой можно переключать воспроизведение анимации и летать. В этой сцене, если вы нажмете Esc (чтобы выйти из режима блокировки мыши) и снова нажмете Ctrl-I, вы сможете получить доступ к настройкам, которые относятся к сцене шторма. Осмотритесь и сделайте несколько красивых снимков, как на открытках.

Шторм

Чтобы реализовать это и обеспечить достаточную гибкость, мы использовали прекрасную библиотеку dat.gui (здесь можно найти руководство по ее использованию). Это позволило нам быстро изменить настройки, которые были доступны посетителям сайта.

Немного похоже на дорисовку

Во многих классических фильмах и анимациях Disney сцены создавались путем объединения разных слоев. В нем были слои с живыми актерами, рисованной анимацией, даже физическими декорациями и верхними слоями, созданными путем рисования на стекле – техника, называемая матовой живописью.

Во многом структура созданного нами опыта похожа, хотя некоторые "слои" представляют собой гораздо больше, чем статичные визуальные эффекты. На самом деле они влияют на то, как выглядят вещи, в соответствии с более сложными вычислениями. Тем не менее, по крайней мере на уровне общей картины, мы имеем дело с представлениями, наложенными друг на друга. Вверху находится слой пользовательского интерфейса, а под ним – 3D-сцена, состоящая из разных компонентов.

Верхний слой интерфейса был создан с помощью DOM и CSS 3, что позволило редактировать взаимодействия разными способами независимо от 3D-эффектов, при этом связь между ними осуществлялась в соответствии с выбранным списком событий. Для этого используется Backbone Router и событие onHashChange HTML5, которое определяет, какая область должна анимироваться. (исходный код проекта: /develop/coffee/router/Router.coffee).

Учебное пособие: таблицы спрайтов и поддержка Retina

Один из интересных методов оптимизации, который мы использовали для интерфейса, заключался в объединении множества изображений наложения интерфейса в один PNG-файл, чтобы уменьшить количество запросов к серверу. В этом проекте интерфейс состоял из более чем 70 изображений (не считая 3D-текстур), которые загружались заранее, чтобы сократить задержку на сайте. Посмотреть таблицу спрайтов можно здесь:

Обычный экран: http://findyourwaytooz.com/img/home/interface_1x.png Экран Retina: http://findyourwaytooz.com/img/home/interface_2x.png

Ниже приведены советы по использованию таблиц спрайтов, в том числе на устройствах с экраном Retina, для создания максимально четкого и аккуратного интерфейса.

Создание спрайтов

Для создания спрайтов мы использовали TexturePacker, который поддерживает вывод в любом формате. В данном случае мы экспортировали файл в формате EaselJS, который позволяет создавать анимированные спрайты.

Как использовать созданную таблицу спрайтов

После создания таблицы спрайтов вы должны увидеть JSON-файл, похожий на этот:

{
   "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]
   },
}

Где:

  • image – URL таблицы спрайтов;
  • frames – координаты каждого элемента интерфейса [x, y, width, height]
  • анимации – это названия каждого объекта.

Обратите внимание, что для создания таблицы спрайтов мы использовали изображения с высокой плотностью пикселей, а затем создали обычную версию, уменьшив ее размер вдвое.

Основные выводы

Теперь, когда все готово, нам нужен фрагмент кода JavaScript, чтобы использовать его.

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

Вот как это будет выглядеть:

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

Подробнее о переменной плотности пикселей читайте в статье Бориса Смуса.

Конвейер 3D-контента

Окружение настраивается на слое WebGL. При создании 3D-сцены один из самых сложных вопросов заключается в том, как обеспечить максимальный выразительный потенциал авторского контента с точки зрения моделирования, анимации и эффектов. Во многом суть этой проблемы заключается в конвейере контента: согласованном процессе создания контента для 3D-сцены.

Мы хотели создать впечатляющий мир, поэтому нам нужен был надежный процесс, который позволил бы 3D-художникам создать его. Им нужно было предоставить как можно больше свободы самовыражения в программном обеспечении для 3D-моделирования и анимации, а нам – отобразить это на экране с помощью кода.

Мы уже некоторое время работали над этой проблемой, потому что каждый раз, когда мы создавали 3D-сайт, мы сталкивались с ограничениями в инструментах, которые могли использовать. Мы создали инструмент под названием 3D Librarian, который использовали для внутренних исследований. и была готова к применению в реальной работе.

У этого инструмента есть своя история: изначально он был предназначен для Flash и позволял импортировать большую сцену Maya в виде одного сжатого файла, оптимизированного для распаковки во время выполнения. Причина, по которой он был оптимальным, заключалась в том, что он эффективно упаковывал сцену в ту же структуру данных, которая обрабатывается во время рендеринга и анимации. При загрузке файла требуется выполнить лишь небольшой синтаксический анализ. Распаковка во Flash происходила довольно быстро, потому что файл был в формате AMF, который Flash мог распаковывать нативно. Для использования того же формата в WebGL требуется немного больше работы на ЦП. Нам пришлось заново создать слой кода JavaScript для распаковки данных, который бы декомпрессировал эти файлы и воссоздавал структуры данных, необходимые для работы WebGL. Распаковка всей 3D-сцены – это операция, которая умеренно нагружает процессор. Распаковка сцены 1 в Find Your Way To Oz занимает около 2 секунд на компьютере средней или высокой мощности. Поэтому мы используем технологию Web Workers на этапе настройки сцены (до ее запуска), чтобы не задерживать показ.

Этот удобный инструмент позволяет импортировать большую часть 3D-сцены: модели, текстуры, анимацию костей. Вы создаете один файл библиотеки, который затем может быть загружен 3D-движком. Вы добавляете в эту библиотеку все нужные модели, а затем размещаете их в сцене.

Однако мы столкнулись с проблемой: нам пришлось иметь дело с WebGL – новой технологией, Это был довольно сложный проект, который задал стандарт для 3D-игр в браузере. Поэтому мы создали специальный слой JavaScript, который берет сжатые файлы 3D-сцен из 3D Librarian и преобразует их в формат, понятный WebGL.

Обучение: да будет ветер

Повторяющейся темой в «Найди свой путь в страну Оз» был ветер. Сюжетная линия построена так, чтобы ветер усиливался.

Первая сцена карнавала относительно спокойная. Проходя через различные сцены, пользователь испытывает все более сильный ветер, кульминацией которого является финальная сцена – шторм.

Поэтому было важно создать эффект ветра с эффектом присутствия.

Для этого мы добавили на три сцены карнавала объекты, которые должны реагировать на ветер, например палатки, флаги, поверхность фотобудки и сам воздушный шар.

Мягкая ткань.

В настоящее время игры для компьютеров обычно создаются на основе физического движка. Поэтому, когда в трехмерном мире нужно смоделировать мягкий объект, для него запускается полное физическое моделирование, создающее правдоподобное поведение мягкого тела.

В WebGL / Javascript мы (пока) не можем позволить себе запустить полноценную симуляцию физики. Поэтому в «Озе» нам пришлось найти способ создать эффект ветра, не симулируя его.

Мы встроили информацию о чувствительности к ветру для каждого объекта в саму 3D-модель. У каждой вершины 3D-модели был атрибут ветра, который определял, насколько сильно ветер должен влиять на эту вершину. Это заданная чувствительность 3D-объектов к ветру. Затем нам нужно было создать сам ветер.

Для этого мы сгенерировали изображение, содержащее шум Перлина. Это изображение должно покрывать определенную "область ветра". Так что хорошим способом подумать об этом будет представить себе изображение облака, похожего на шум, наложенное на определенную прямоугольную область 3D-сцены. Каждый пиксель (значение уровня серого) этого изображения определяет силу ветра в определенный момент в "окружающей его" трехмерной области.

Чтобы создать эффект ветра, изображение перемещается с постоянной скоростью в определенном направлении – направлении ветра. Чтобы ветер не влиял на все объекты в сцене, мы ограничиваем его область действия.

Простое руководство по 3D-ветру

Теперь давайте создадим эффект ветра в простой 3D-сцене в Three.js.

Мы создадим ветер на простом процедурном травяном поле.

Сначала создадим сцену. У нас будет простая плоская местность с текстурой. А каждая травинка будет представлена перевернутым 3D-конусом.

Трава
Травянистая местность

Вот как создать эту простую сцену в Three.js с помощью CoffeeScript.

Для начала мы настроим Three.js и подключим его к камере, контроллеру мыши и источнику света:

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

Вызовы функций initGrass и initTerrain заполняют сцену травой и рельефом соответственно:

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

Здесь мы создаем сетку из 15 на 15 кусочков травы. Мы добавляем немного случайности в положение каждой травинки, чтобы они не выстраивались в ряд, как солдаты, что выглядело бы странно.

Эта местность представляет собой горизонтальную плоскость, расположенную у основания травинок (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 )

Итак, мы создали сцену Three.js, добавили немного травы, состоящей из процедурно сгенерированных перевернутых конусов, и простую местность.

Пока ничего особенного.

Теперь пора добавить ветер. Для начала мы хотим встроить информацию о чувствительности к ветру в 3D-модель травы.

Мы собираемся встроить эту информацию в качестве настраиваемого атрибута для каждой вершины 3D-модели травы. И мы будем использовать правило, согласно которому нижний конец модели травы (кончик конуса) имеет нулевую чувствительность, поскольку он прикреплен к земле. Верхняя часть модели травы (основание конуса) имеет максимальную чувствительность к ветру, так как она находится дальше всего от земли.

Вот как перекодируется функция instanceGrass, чтобы добавить чувствительность к ветру в качестве настраиваемого атрибута для 3D-модели травы.

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

Теперь мы используем собственный материал windMaterial вместо MeshPhongMaterial, который использовался ранее. WindMaterial оборачивает WindMeshShader, который мы рассмотрим далее.

Поэтому код в instanceGrass перебирает все вершины модели травы и для каждой вершины добавляет настраиваемый атрибут вершины, называемый windFactor. Для windFactor задано значение 0 для нижнего конца модели травы (где она должна касаться земли) и значение 1 для верхнего конца модели травы.

Другой ингредиент, который нам нужен, – это добавить настоящий ветер в нашу сцену. Как мы уже говорили, для этого мы будем использовать шум Перлина. Мы процедурно сгенерируем текстуру шума Перлина.

Для наглядности мы назначим эту текстуру самой местности вместо предыдущей зеленой текстуры. Это позволит вам лучше понять, что происходит с ветром.

Таким образом, эта текстура шума Перлина будет пространственно покрывать расширение нашей местности, и каждый пиксель текстуры будет определять интенсивность ветра в области местности, на которую падает этот пиксель. Прямоугольник рельефа будет нашей «зоной ветра».

Шум Перлина генерируется процедурно с помощью шейдера NoiseShader. В этом шейдере используются алгоритмы симплексного шума из https://github.com/ashima/webgl-noise . Версия WebGL была дословно взята из одного из примеров Three.js от MrDoob: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader принимает время, масштаб и набор параметров смещения в качестве униформ и выводит хорошее 2D-распределение шума Перлина.

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

...

Мы будем использовать этот шейдер для рендеринга шума Перлина в текстуру. Это делается в функции 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 )

В приведенном выше коде noiseMap настраивается как цель рендеринга Three.js, оснащается NoiseShader, а затем рендерится с помощью ортографической камеры, чтобы избежать искажений перспективы.

Как мы уже говорили, теперь мы будем использовать эту текстуру в качестве основной текстуры рендеринга для ландшафта. Это не обязательно для работы эффекта ветра. Но это полезно, чтобы мы могли лучше визуально понять, что происходит с ветрогенерацией.

Вот переработанная функция initTerrain, использующая noiseMap в качестве текстуры:

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 )

Теперь, когда у нас есть текстура ветра, давайте посмотрим на WindMeshShader, который отвечает за деформацию моделей травы в соответствии с ветром.

Чтобы создать этот шейдер, мы взяли стандартный шейдер MeshPhongMaterial из Three.js и изменили его. Это хороший быстрый и грязный способ начать работу с шейдером, который работает, без необходимости начинать с нуля.

Мы не будем копировать сюда весь код шейдера (вы можете посмотреть его в файле исходного кода), потому что большая его часть будет репликой шейдера MeshPhongMaterial. Но давайте посмотрим на измененные части, связанные с ветром, в вершинном шейдере.

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;

Итак, этот шейдер сначала вычисляет координату поиска текстуры windUV на основе двумерного горизонтального положения вершины по осям X и Z. Эта UV-координата используется для поиска силы ветра, vWindForce, в текстуре ветра с шумом Перлина.

Это значение vWindForce объединяется с настраиваемым атрибутом windFactor, относящимся к вершине, чтобы рассчитать, насколько сильно должна деформироваться вершина. Также есть глобальный параметр windScale, который управляет общей силой ветра, и вектор windDirection, который указывает, в каком направлении должна происходить деформация ветра.

Так мы создаем деформацию травинок под воздействием ветра. Но это ещё не всё. Сейчас деформация статична и не передает эффект ветра.

Как мы уже упоминали, нам нужно будет со временем сдвинуть текстуру шума по области ветра, чтобы наше стекло могло колебаться.

Для этого со временем сдвигается переменная vOffset, которая передается в NoiseShader. Это параметр vec2, который позволит нам указать смещение шума в определенном направлении (направлении ветра).

Это делается в функции render, которая вызывается для каждого кадра:

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

Вот и всё! Мы только что создали сцену с "процедурной травой", на которую влияет ветер.

Добавление пыли в смесь

Теперь давайте немного оживим нашу сцену. Добавь немного летающей пыли, чтобы сделать сцену интереснее.

Добавление пыли
Добавление пыли

Ветер должен поднимать пыль, поэтому логично, что в нашей сцене с ветром летает пыль.

Пыль настраивается в функции initDust как система частиц.

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

Здесь создается 130 частиц пыли. Обратите внимание, что каждый из них оснащен специальным WindParticleShader.

Теперь в каждом кадре мы будем немного перемещать частицы с помощью CoffeeScript, независимо от ветра. Вот код.

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 )

Кроме того, мы собираемся сместить положение каждой частицы в соответствии с ветром. Это делается в WindParticleShader. В частности, в вершинном шейдере.

Код этого шейдера – модифицированная версия ParticleMaterial из Three.js. Вот как выглядит его основная часть:

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;

Этот вершинный шейдер не сильно отличается от того, что мы использовали для деформации травы под воздействием ветра. Она принимает текстуру шума Перлина в качестве входных данных и, в зависимости от положения пыли в мире, ищет значение vWindForce в текстуре шума. Затем оно использует это значение, чтобы изменить положение частицы пыли.

Riders On The Storm

Самой сложной сценой WebGL была, пожалуй, последняя. Чтобы увидеть ее, нужно было пройти сквозь воздушный шар в центр торнадо. Там зрителей ждало эксклюзивное видео о предстоящем релизе.

Сцена с полетом на воздушном шаре

Когда мы создавали эту сцену, мы знали, что нам нужен центральный элемент, который бы производил сильное впечатление. Вращающийся торнадо будет центральным элементом, а слои другого контента будут формировать эту функцию на месте, создавая драматический эффект. Для этого мы построили вокруг этого странного шейдера эквивалент съемочной площадки.

Чтобы создать реалистичный композит, мы использовали смешанный подход. Некоторые из них были визуальными трюками, такими как световые фигуры для создания эффекта блика объектива или капли дождя, которые анимируются в виде слоев поверх сцены, на которую вы смотрите. В других случаях мы рисовали плоские поверхности, которые должны были двигаться, например слои низколетящих облаков, перемещающиеся в соответствии с кодом системы частиц. а обломки, вращающиеся вокруг него, – слоями в 3D-сцене, которые перемещаются перед торнадо и за ним.

Основная причина, по которой нам пришлось построить сцену таким образом, заключалась в том, чтобы у нас было достаточно графического процессора для обработки шейдера торнадо в балансе с другими эффектами, которые мы применяли. Сначала у нас были большие проблемы с балансировкой графического процессора, но позже эта сцена была оптимизирована и стала легче, чем основные сцены.

Руководство: шейдер бури

Для создания финальной сцены шторма было использовано множество различных техник, но центральным элементом этой работы стал кастомный шейдер GLSL, похожий на торнадо. Мы перепробовали множество разных техник: от вершинных шейдеров для создания интересных геометрических водоворотов до анимации на основе частиц и даже 3D-анимации закрученных геометрических фигур. Ни один из них не создавал ощущения торнадо или требовал слишком много ресурсов.

Ответ на этот вопрос мы получили в ходе работы над совершенно другим проектом. Параллельный проект, в котором игры использовались для составления карты мозга мыши, проводился в Институте Макса Планка (brainflight.org). Он позволил получить интересные визуальные эффекты. Мы смогли создать видеоролики о том, что происходит внутри нейрона мыши, используя специальный объемный шейдер.

Нейрон мыши, визуализированный с помощью специального объемного шейдера
Нейрон мыши, созданный с помощью специального объемного шейдера

Мы обнаружили, что внутренняя часть клетки мозга немного похожа на воронку торнадо. А поскольку мы использовали объемную технику, мы знали, что можем просматривать этот шейдер со всех направлений в пространстве. Мы могли бы настроить рендеринг шейдера так, чтобы он сочетался со сценой шторма, особенно если он зажат под слоями облаков и над драматическим фоном.

Техника шейдеров включает в себя трюк, который в основном использует один шейдер GLSL для рендеринга всего объекта с помощью упрощенного алгоритма рендеринга, называемого рендерингом марша лучей с полем расстояния. В этой технике создается пиксельный шейдер, который оценивает ближайшее расстояние до поверхности для каждой точки на экране.

Хорошее описание алгоритма можно найти в обзоре iq: Rendering Worlds With Two Triangles – Iñigo Quilez. Также вы можете изучить галерею шейдеров на сайте glsl.heroku.com. Там есть много примеров использования этой техники, с которыми можно поэкспериментировать.

Основная функция шейдера настраивает преобразования камеры и запускает цикл, который многократно оценивает расстояние до поверхности. Вызов RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) – это место, где происходит основной расчет марширования лучей.

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
}

Идея в том, что по мере продвижения вглубь вихря мы регулярно добавляем цвет к конечному значению цвета пикселя, а также добавляем непрозрачность вдоль луча. Это создает многослойную мягкую текстуру Вихрей.

Следующий важный аспект торнадо – это его форма, которая создается путем объединения нескольких функций. Сначала создается конус, который затем смешивается с шумом, чтобы получить органичный неровный край. После этого конус закручивается вдоль своей главной оси и вращается во времени.

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

Создание такого шейдера – непростая задача. Помимо проблем, связанных с абстрагированием создаваемых вами операций, существуют серьезные проблемы с оптимизацией и кроссплатформенной совместимостью, которые вам необходимо отследить и решить, прежде чем вы сможете использовать работу в производстве.

Первая часть проблемы: оптимизация этого шейдера для нашей сцены. Чтобы справиться с этим, нам нужен был "безопасный" подход на случай, если шейдер окажется слишком тяжелым. Для этого мы скомпоновали шейдер торнадо с разрешением, отличным от разрешения остальной сцены. Это из файла stormTest.coffee (да, это был тест!).

Мы начинаем с renderTarget, который соответствует ширине и высоте сцены, чтобы мы могли иметь независимость разрешения шейдера торнадо от сцены. Затем мы динамически определяем уменьшение разрешения шейдера шторма в зависимости от частоты кадров.

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

Наконец, мы отрисовываем торнадо на экране, используя упрощенный алгоритм sal2x (чтобы избежать блочного вида) в строке 1107 в stormTest.coffee. Это означает, что в худшем случае мы получим более размытое торнадо, но, по крайней мере, оно будет работать, не лишая пользователя контроля.

Следующий шаг оптимизации требует погружения в алгоритм. Основной вычислительный фактор в шейдере – это итерация, которая выполняется для каждого пикселя, чтобы попытаться аппроксимировать расстояние до функции поверхности: количество итераций цикла трассировки лучей. Используя больший размер шага, мы могли бы получить оценку поверхности торнадо с меньшим количеством итераций, пока мы находились за пределами его облачной поверхности. Внутри мы уменьшаем размер шага для точности и чтобы иметь возможность смешивать значения для создания эффекта тумана. Также создание ограничивающего цилиндра для получения оценки глубины для отбрасываемого луча дало хорошее ускорение.

Следующая часть проблемы заключалась в том, чтобы обеспечить работу этого шейдера на разных видеокартах. Каждый раз мы проводили тестирование и начинали понимать, с какими проблемами совместимости мы можем столкнуться. Причина, по которой мы не могли сделать намного лучше, чем интуиция, заключалась в том, что мы не всегда могли получить хорошие сведения для отладки об ошибках. Обычно это просто ошибка графического процессора, о которой мало что известно, или даже сбой системы.

Проблемы с совместимостью между видеокартами решались аналогичным образом: нужно было убедиться, что статические константы вводятся с точным типом данных, как определено, например 0.0 для float и 0 для int. Будьте осторожны при написании длинных функций. Лучше разбить их на несколько более простых функций и промежуточных переменных, потому что компиляторы, похоже, не обрабатывают некоторые случаи правильно. Убедитесь, что все текстуры имеют размер, кратный двум, не слишком велики и в любом случае соблюдайте осторожность при поиске данных текстур в цикле.

Самые большие проблемы с совместимостью у нас возникли с эффектом молнии во время шторма. Мы использовали готовую текстуру, обернутую вокруг торнадо, чтобы раскрасить его струи. Это был великолепный эффект, который позволял легко вписать торнадо в цветовую гамму сцены, но на его адаптацию для других платформ ушло много времени.

торнадо

Мобильный сайт

Мобильная версия не могла быть точной копией версии для ПК, поскольку требования к технологиям и обработке данных были слишком высокими. Нам нужно было создать что-то новое, ориентированное именно на мобильных пользователей.

Мы решили, что было бы здорово сделать мобильное веб-приложение Carnival Photo-Booth, которое бы использовало камеру мобильного устройства. Такого мы ещё не видели.

Чтобы сделать игру интереснее, мы добавили 3D-преобразования в CSS3. Связав его с гироскопом и акселерометром, мы смогли добавить в игру много глубины. Сайт реагирует на то, как вы держите телефон, двигаете им и смотрите на него.

В этой статье мы дадим несколько советов о том, как сделать процесс разработки мобильных приложений более эффективным. Вот они! Посмотрите, что вы можете из него узнать.

Полезные советы по работе с мобильными устройствами

Предзагрузчик – это полезный инструмент, а не то, чего следует избегать. Мы знаем, что иногда случается последнее. В основном это связано с тем, что по мере роста проекта вам необходимо поддерживать список вещей, которые вы предварительно загружаете. Хуже того, не очень понятно, как рассчитывать прогресс загрузки, если вы извлекаете разные ресурсы, и многие из них одновременно. Здесь нам пригодится наш собственный и очень общий абстрактный класс Task. Основная идея заключается в том, чтобы разрешить бесконечно вложенную структуру, в которой у задачи могут быть свои подзадачи, у которых могут быть свои и т. д. Кроме того, каждая задача вычисляет свой прогресс по отношению к прогрессу своих подзадач (но не к прогрессу родительской задачи). Мы сделали так, чтобы все классы MainPreloadTask, AssetPreloadTask и TemplatePreFetchTask были производными от Task. В результате получилась следующая структура:

Предзагрузчик

Благодаря такому подходу и классу Task мы можем легко узнать общий прогресс (MainPreloadTask), прогресс загрузки объектов (AssetPreloadTask) или прогресс загрузки шаблонов (TemplatePreFetchTask). и даже ход загрузки отдельного файла. Чтобы узнать, как это делается, посмотрите класс Task в файле /m/javascripts/raw/util/Task.js и реализации задач в каталоге /m/javascripts/preloading/task. Ниже приведен фрагмент кода, в котором показано, как мы настраиваем класс /m/javascripts/preloading/task/MainPreloadTask.js, который является нашей основной оболочкой предварительной загрузки:

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

      }
    }
  })
]);

В классе /m/javascripts/preloading/task/subtask/AssetPreloadTask.js стоит обратить внимание не только на то, как он взаимодействует с MainPreloadTask (через общую реализацию Task), но и на то, как мы загружаем объекты, зависящие от платформы. В основном у нас есть четыре типа изображений. Стандартный для мобильных устройств (.ext, где ext – расширение имени файла, обычно .png или .jpg), для мобильных устройств с экраном Retina (-2x.ext), стандартный для планшетов (-tab.ext) и для планшетов с экраном Retina (-tab-2x.ext). Вместо того чтобы выполнять обнаружение в MainPreloadTask и задавать в коде четыре массива объектов, мы просто указываем название и расширение объекта, который нужно предварительно загрузить, и определяем, зависит ли объект от платформы (responsive = true / false). Затем AssetPreloadTask сгенерирует для нас название файла:

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

Далее в цепочке классов код, который выполняет предварительную загрузку объектов, выглядит следующим образом (/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);
}

Учебное пособие: фотобудка HTML5 (iOS6/Android)

Когда мы разрабатывали мобильную версию OZ, то поняли, что проводим много времени в фотобудке вместо того, чтобы работать. Это было очень весело. Поэтому мы создали демоверсию, чтобы вы могли попробовать.

Мобильная фотобудка
Мобильная фотобудка

Вы можете посмотреть демоверсию на своем телефоне iPhone или Android:

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

Для настройки вам понадобится бесплатный экземпляр приложения Google App Engine, в котором можно запустить серверную часть. Код интерфейса несложный, но есть несколько возможных подводных камней. Давайте рассмотрим их.

  1. Разрешенный тип графического файла Мы хотим, чтобы пользователи могли загружать только изображения (поскольку это фотобудка, а не видеокабина). Теоретически вы можете просто указать фильтр в HTML, как показано ниже. input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" Однако это работает только на iOS, поэтому после выбора файла нужно добавить дополнительную проверку на соответствие регулярному выражению:
   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. Отмена загрузки или выбора файла Ещё одно несоответствие, которое мы заметили в процессе разработки, – это то, как разные устройства уведомляют об отмене выбора файла. Телефоны и планшеты iOS не делают ничего, они вообще не уведомляют. Поэтому в данном случае нам не нужно никаких специальных действий, однако телефоны Android в любом случае запускают функцию add(), даже если файл не выбран. Вот как это сделать:
    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();            
    }
    }

В остальном все работает довольно гладко на разных платформах. Веселись!

Заключение

Учитывая огромный размер Find Your Way To Oz и широкий спектр задействованных технологий, в этой статье мы смогли охватить лишь некоторые из использованных нами подходов.

Если вы хотите узнать больше, ознакомьтесь с полным исходным кодом проекта Find Your Way To Oz.

Использованное ПО с открытым исходным кодом

Полный список авторов

Ссылки