事例紹介 - オズへの冒険: オズへの冒険

はじめに

「Find Your Way to Oz」は、ディズニーがウェブに提供する新しい Google Chrome Experiment です。カンザス州のサーカスをインタラクティブに旅するもので、巨大な嵐に巻き込まれた後にオズの国にたどり着きます。

私たちの目標は、映画の豊かさとブラウザの技術力を組み合わせて、ユーザーが強い絆を築くことができる、楽しく没入感のあるエクスペリエンスを作り出すことでした。

この仕事は、この記事で全体を捉えるには少し大きすぎるため、技術的なストーリーの中から興味深いと思われる章をいくつか取り上げています。その過程で、難易度が高くなるにつれて、いくつかのチュートリアルを抽出しました。

このエクスペリエンスを実現するために、多くの人々が尽力しました。その数は、ここに記載しきれないほどです。サイトにアクセスし、メニュー セクションのクレジット ページで詳細をご確認ください。

動作の仕組み

パソコン版の「Find Your Way to Oz」は、没入感の高い世界を体験できます。3D と、従来の映画制作にインスパイアされた複数のエフェクトを組み合わせて、ほぼリアルなシーンを作成しています。最も重要なテクノロジーは、Three.js を使用した WebGL、カスタムビルドのシェーダー、CSS3 機能を使用した DOM アニメーション要素です。さらに、インタラクティブなエクスペリエンスを実現する getUserMedia API(WebRTC)により、ユーザーはウェブカメラから直接画像を追加できます。また、WebAudio により 3D サウンドを実現できます。

しかし、このような技術体験の魔法は、それらがどのように組み合わされるかにあります。これは、主な課題の 1 つでもあります。つまり、視覚効果とインタラクティブ要素を 1 つのシーンに組み合わせて、一貫性のある全体像を作成するにはどうすればよいかということです。この視覚的な複雑さは管理が難しく、開発のどの段階にいるのかを把握することが困難でした。

相互に関連する視覚効果と最適化の問題に対処するため、Google は、その時点で確認していたすべての関連設定をキャプチャするコントロール パネルを多用しました。明るさ、被写界深度、ガンマなど、シーンのあらゆる要素をブラウザでリアルタイムに調整できます。誰でも、エクスペリエンスの重要なパラメータの値を微調整して、最適な設定を見つけることができます。

この秘密を共有する前に、車のエンジンをいじると故障する可能性があるのと同様に、この機能を使用するとクラッシュする可能性があることを警告しておきます。重要な作業を行っていないことを確認し、サイトのメイン URL にアクセスして、アドレスに ?debug=on を追加します。サイトが読み込まれるのを待ち、読み込まれたら Ctrl-I キーを押すと、右側にプルダウンが表示されます。[Exit camera path] オプションをオフにすると、A、W、S、D キーとマウスを使用して、空間内を自由に移動できます。

カメラパス。

ここではすべての設定を説明しませんが、いろいろ試してみることをおすすめします。キーを押すと、シーンごとに異なる設定が表示されます。最後の嵐のシーケンスには、追加のキー Ctrl-A があります。このキーを使用すると、アニメーションの再生を切り替えて飛び回ることができます。このシーンで Esc を押して(マウスロック機能を終了)、もう一度 Ctrl-I を押すと、ストームシーンに固有の設定にアクセスできます。周囲を見回して、以下のような素敵なポストカードの景色を撮影しましょう。

嵐のシーン

これを実現し、ニーズに十分対応できる柔軟性を確保するために、dat.gui という優れたライブラリを使用しました(使用方法に関する過去のチュートリアルについては、こちらをご覧ください)。これにより、サイトの訪問者に公開する設定をすばやく変更できるようになりました。

マットペインティング風

多くの古典的なディズニー映画やアニメーションでは、シーンを作成するためにさまざまなレイヤを組み合わせていました。実写、セルアニメーション、物理的なセット、そしてガラスに描かれたトップレイヤー(マットペインティングと呼ばれる技法)が重ねられていました。

私たちが作成したエクスペリエンスの構造は、多くの点で似ています。ただし、一部の「レイヤ」は静的なビジュアルをはるかに超えています。実際には、より複雑な計算に基づいて、ものの見え方に影響を与えます。それでも、少なくとも大まかなレベルでは、ビューを扱い、それらを重ねて合成しています。上部には UI レイヤがあり、その下に 3D シーンがあります。3D シーン自体は、さまざまなシーン コンポーネントで構成されています。

最上位のインターフェース レイヤは DOM と CSS 3 を使用して作成されているため、インタラクションの編集は、3D エクスペリエンスとは独立して、選択したイベントリストに従って 2 つのレイヤ間で通信しながら、さまざまな方法で行うことができます。この通信では、Backbone Router + onHashChange HTML5 イベントを使用して、アニメーションのイン/アウトを行う領域を制御します。(プロジェクト ソース: /develop/coffee/router/Router.coffee)。

チュートリアル: スプライト シートと Retina のサポート

インターフェースに採用した最適化手法の一つは、複数のインターフェース オーバーレイ画像を 1 つの 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 は、各 UI 要素の座標 [x, y, 幅, 高さ] です。
  • アニメーションは各アセットの名前です

高密度画像を使用してスプライト シートを作成し、そのサイズを半分に縮小して通常バージョンを作成しています。

まとめ

準備が整ったので、あとは 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'));

可変ピクセル密度について詳しくは、Boris Smus 氏によるこちらの記事をご覧ください。

3D コンテンツ パイプライン

環境エクスペリエンスは WebGL レイヤに設定されます。3D シーンを考えるときに最も難しい問題の 1 つは、モデリング、アニメーション、エフェクトの観点から、表現の可能性を最大限に引き出すクリエイター制作コンテンツをどのように作成するかということです。この問題の核心は、さまざまな意味でコンテンツ パイプラインにあります。コンテンツ パイプラインとは、3D シーンのコンテンツを作成するために従うべき、合意されたプロセスのことです。

私たちは、畏敬の念を抱かせるような世界を創り出したいと考えていました。そのためには、3D アーティストがそれを創り出すことができるような、しっかりとしたプロセスが必要でした。3D モデリングとアニメーションのソフトウェアで、できるだけ表現の自由度を高くする必要がありました。そして、それをコードで画面にレンダリングする必要がありました。

私たちは、以前からこの種の問題に取り組んでいました。過去に 3D サイトを作成するたびに、使用できるツールに制限があることがわかっていたからです。そこで、3D Librarian というツールを作成しました。これは内部研究の一環です。そして、実際の仕事に適用できる段階に近づいていました。

このツールには歴史があります。もともとは Flash 用で、大きな Maya シーンを、ランタイムの解凍用に最適化された 1 つの圧縮ファイルとして取り込むことができました。これが最適だった理由は、レンダリングとアニメーション中に操作される基本的に同じデータ構造にシーンを効果的にパックしたためです。読み込み時にファイルに対して行う必要がある解析はごくわずかです。Flash での解凍は非常に高速でした。ファイルが AMF 形式であったため、Flash でネイティブに解凍できたからです。WebGL で同じ形式を使用するには、CPU での処理が少し増えます。実際、JavaScript のデータ解凍レイヤのコードを再作成する必要がありました。これは、基本的にこれらのファイルを解凍し、WebGL の動作に必要なデータ構造を再作成するものです。3D シーン全体の展開は、CPU にやや負荷のかかる処理です。Find Your Way To Oz のシーン 1 を展開するには、中~ハイエンドのマシンで約 2 秒かかります。そのため、ユーザー エクスペリエンスが中断されないように、この処理は「シーン設定」時(シーンが実際に起動される前)に Web Workers テクノロジーを使用して行われます。

この便利なツールを使用すると、モデル、テクスチャ、ボーン アニメーションなど、3D シーンのほとんどをインポートできます。単一のライブラリ ファイルを作成すると、3D エンジンで読み込むことができます。シーンに必要なすべてのモデルをこのライブラリに詰め込み、シーンにスポーンします。

しかし、問題がありました。それは、新参者の WebGL を扱うことになったことです。これは、ブラウザベースの 3D エクスペリエンスの標準を確立した、かなり手ごわい相手でした。そこで、3D Librarian の圧縮された 3D シーンファイルを取得し、WebGL が理解できる形式に適切に変換するアドホックな JavaScript レイヤを作成しました。

チュートリアル: 風を起こす

「Find Your Way To Oz」で繰り返し登場するテーマは風です。ストーリーラインの流れは、風が徐々に強くなるように構成されています。

カーニバルの最初のシーンは比較的穏やかです。さまざまなシーンを体験するにつれて、ユーザーは徐々に強くなる風を体験し、最後のシーンである嵐に到達します。

そのため、没入感のある風の効果を提供することが重要でした。

これを作成するために、3 つのカーニバル シーンに、テント、フォトブースの表面の旗、風船自体など、柔らかく、風の影響を受けるはずのオブジェクトを配置しました。

柔らかい布

最近のデスクトップ ゲームは、通常、コア物理エンジンを中心に構築されています。そのため、3D の世界で柔らかいオブジェクトをシミュレートする必要がある場合は、完全な物理シミュレーションが実行され、リアルな柔らかい動作が作成されます。

WebGL / JavaScript では、本格的な物理シミュレーションを実行する余裕は(まだ)ありません。そこで、オズでは、実際にシミュレーションすることなく、風の効果を作り出す方法を見つける必要がありました。

各オブジェクトの「風に対する感度」に関する情報を 3D モデル自体に埋め込みました。3D モデルの各頂点には、その頂点が風の影響をどの程度受けるかを指定する「風属性」がありました。このため、3D オブジェクトの風に対する感度を指定しました。次に、風そのものを作成する必要がありました。

これは、パーリン ノイズを含む画像を生成することで行いました。この画像は、特定の「風の領域」をカバーすることを目的としています。そのため、3D シーンの特定の長方形の領域に、ノイズのような雲の画像が重ねられていると考えるとよいでしょう。この画像の各ピクセル(グレーレベル値)は、3D 領域の「周囲」の特定の瞬間における風の強さを指定します。

風の効果を出すために、画像は一定の速度で特定の方向(風の方向)に移動します。また、「風の強いエリア」がシーン内のすべてに影響を与えないように、風の画像をエッジに巻き付けて、効果の範囲を限定しています。

シンプルな 3D 風のチュートリアル

それでは、Three.js のシンプルな 3D シーンで風のエフェクトを作成しましょう。

シンプルな「プロシージャルな草原」に風を発生させます。

まず、シーンを作成しましょう。テクスチャを適用したシンプルな平坦な地形を作成します。そして、草の各部分は、逆さまの 3D 円錐で表されます。

草に覆われた地形
草に覆われた地形

CoffeeScript を使用して Three.js でこのシンプルなシーンを作成する方法は次のとおりです。

まず、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

以前に使用した MeshPhongMaterial の代わりに、カスタム マテリアル windMaterial を使用します。WindMaterial は、後ほど説明する WindMeshShader をラップします。

そのため、instanceGrass のコードは、草モデルのすべての頂点をループし、各頂点に windFactor というカスタム頂点属性を追加します。この windFactor は、草モデルの下端(地形に接する部分)では 0 に設定され、草モデルの上端では 1 に設定されます。

もう 1 つ必要なのは、シーンに実際の風を追加することです。前述のように、これにはパーリン ノイズを使用します。パーリン ノイズ テクスチャをプロシージャルに生成します。

わかりやすくするために、このテクスチャを地形自体に割り当て、以前の緑色のテクスチャを置き換えます。これにより、風の状況を把握しやすくなります。

このパーリン ノイズ テクスチャは、地形の範囲を空間的にカバーします。テクスチャの各ピクセルは、そのピクセルが配置される地形エリアの風の強さを指定します。地形の長方形は「風のエリア」になります。

パーリン ノイズは、NoiseShader と呼ばれるシェーダーを介して手続き的に生成されます。このシェーダーは、https://github.com/ashima/webgl-noise の 3D シンプレックス ノイズ アルゴリズムを使用しています。この WebGL バージョンは、MrDoob 氏の Three.js サンプルの 1 つ(http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html)からそのまま引用したものです。

NoiseShader は、時間、スケール、オフセットのパラメータ セットをユニフォームとして受け取り、Perlin ノイズの優れた 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 を装備して、遠近法の歪みを避けるために正投影カメラでレンダリングします。

前述のように、このテクスチャを地形のメインのレンダリング テクスチャとしても使用します。これは、風の効果自体を機能させるために必要なものではありません。しかし、風力発電の状況を視覚的に把握できるため、あると便利です。

以下は、noiseMap をテクスチャとして使用するように initTerrain 関数を書き換えたものです。

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 を見てみましょう。

このシェーダーを作成するために、標準の Three.js MeshPhongMaterial シェーダーをベースにして、それを変更しました。これは、ゼロから始めることなく、動作するシェーダーを簡単に作成できる方法です。

シェーダー コードのほとんどは 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;

このシェーダーは、まず、頂点の 2D、xz(水平)位置に基づいて windUV テクスチャ ルックアップ座標を計算します。この UV 座標は、パーリン ノイズの風テクスチャから風力 vWindForce を検索するために使用されます。

この vWindForce 値は、頂点固有の windFactor(前述のカスタム属性)と合成され、頂点に必要な変形量が計算されます。また、風の全体的な強さを制御するグローバルな windScale パラメータと、風による変形が発生する方向を指定する windDirection ベクトルもあります。

これにより、草のパーツが風によって変形します。しかし、まだ終わりではありません。現状では、この変形は静的であり、風の強いエリアの効果を伝えることはできません。

前述のとおり、ガラスを波打たせるには、風の領域全体でノイズ テクスチャを時間の経過とともにスライドさせる必要があります。

これは、NoiseShader に渡される vOffset ユニフォームを時間の経過とともにシフトすることで行われます。これは 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 で行われます。具体的には頂点シェーダーです。

このシェーダーのコードは、Three.js の ParticleMaterial を変更したものです。そのコア部分は次のようになります。

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;

この頂点シェーダーは、風による草の変形に使用したものとそれほど変わりません。Perlin ノイズ テクスチャを入力として受け取り、ダストのワールド位置に応じて、ノイズ テクスチャ内の vWindForce 値を検索します。次に、この値を使用して、ダスト パーティクルの位置を変更します。

Riders On The Storm

WebGL シーンの中で最も冒険的なのは、おそらく最後のシーンです。気球をクリックしてトルネードスの目に入ると、サイトの旅の終わりに到達し、近日公開予定の限定動画を見ることができます。

気球に乗っているシーン

このシーンを作成したとき、私たちは、インパクトのあるエクスペリエンスの中心となる機能が必要であることを認識していました。回転する竜巻をメインに据え、他のコンテンツのレイヤを重ねてこの機能を形作ることで、ドラマチックな効果を生み出すことができます。これを実現するために、この奇妙なシェーダーの周囲に映画スタジオのセットに相当するものを構築しました。

リアルな合成画像を作成するために、複数のアプローチを組み合わせて使用しました。レンズフレア効果を出すための光の形や、見ているシーンの上にレイヤーとしてアニメーション化される雨粒など、視覚的なトリックもありました。また、パーティクル システムのコードに従って移動する低空の雲のレイヤーのように、平らな面が移動しているように見えるように描画したケースもあります。竜巻の周りを回る破片は、3D シーンのレイヤとして、竜巻の前後に移動するように並べ替えられました。

このようにシーンを構築する必要があった主な理由は、適用する他のエフェクトとのバランスを保ちながら、トルネードスのシェーダーを処理するのに十分な GPU を確保するためでした。当初は GPU のバランス調整に大きな問題がありましたが、後にこのシーンは最適化され、メインシーンよりも軽くなりました。

チュートリアル: ストーム シェーダー

最終的な嵐のシーケンスを作成するために、さまざまな手法が組み合わされましたが、この作品の中心となったのは、竜巻のように見えるカスタム GLSL シェーダーでした。頂点シェーダーから興味深い幾何学的な渦巻きを作成する手法、パーティクル ベースのアニメーション、ねじれた幾何学的形状の 3D アニメーションなど、さまざまな手法を試しました。どのエフェクトも、竜巻の感覚を再現していないか、処理に過剰な負荷がかかるかのどちらかでした。

最終的に、まったく異なるプロジェクトが答えを導き出してくれました。マックス プランク研究所(brainflight.org)による、マウスの脳をマッピングするための科学ゲームに関する並行プロジェクトでは、興味深い視覚効果が生成されていました。カスタムのボリューメトリック シェーダーを使用して、マウスのニューロンの内部を撮影した動画を作成することができました。

カスタム ボリューム シェーダーを使用したマウスのニューロンの内部
カスタム ボリューム シェーダーを使用したマウスのニューロンの内部

脳細胞の内部は、竜巻の漏斗に少し似ていることがわかりました。また、ボリューメトリック手法を使用していたため、このシェーダーを空間内のあらゆる方向から見ることができることがわかっていました。シェーダーのレンダリングを、ストームのシーンと組み合わせるように設定できます。特に、雲のレイヤーの下、ドラマチックな背景の上に挟むように設定すると効果的です。

シェーダー手法には、基本的に単一の GLSL シェーダーを使用して、距離フィールドを使用したレイ マーチング レンダリングと呼ばれる簡素化されたレンダリング アルゴリズムでオブジェクト全体をレンダリングするトリックが含まれています。この手法では、画面上の各点について、サーフェスまでの最短距離を推定するピクセル シェーダーが作成されます。

このアルゴリズムの優れたリファレンスとして、iq による概要 Rendering Worlds With Two Triangles - Iñigo Quilez があります。また、glsl.heroku.com のシェーダー ギャラリーを探索すると、この手法の例が多数見つかり、試すことができます。

シェーダーの中心は main 関数から始まります。この関数は、カメラ変換を設定し、サーフェスまでの距離を繰り返し評価するループに入ります。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 アルゴリズムを使用して、竜巻を画面にレンダリングします(ブロック状の外観を避けるため)。stormTest.coffee の 1107 行目です。つまり、最悪の場合、竜巻がぼやけてしまいますが、少なくともユーザーからコントロールを奪うことなく動作します。

次の最適化ステップでは、アルゴリズムを詳しく調べる必要があります。シェーダーの主な計算要素は、サーフェス関数の距離を近似するために各ピクセルで実行される反復処理(レイマーチング ループの反復回数)です。ステップサイズを大きくすると、雲の表面の外側にいるときに、より少ない反復回数で竜巻の表面を推定できます。内部では、精度を高めるためにステップサイズを小さくし、値を混合して霧の効果を作成できるようにします。また、キャストされたレイの深度推定値を取得するために境界円柱を作成したことも、高速化に貢献しました。

問題の次の部分は、このシェーダーがさまざまなビデオカードで動作することを確認することでした。そのたびにテストを行い、発生する可能性のある互換性の問題の種類について、直感的に理解できるようになりました。直感に頼るしかなかったのは、エラーに関する適切なデバッグ情報を常に得られるとは限らなかったためです。一般的なシナリオは、GPU エラーが発生してそれ以上処理が進まない、またはシステムがクラッシュするというものです。

クロスビデオボードの互換性の問題にも同様の解決策がありました。静的定数が定義どおりの正確なデータ型で入力されていることを確認します。たとえば、float の場合は 0.0、int の場合は 0 です。長い関数を記述する場合は注意が必要です。コンパイラが特定のケースを正しく処理しないように見えるため、複数の単純な関数と中間変数に分割することをおすすめします。テクスチャがすべて 2 の累乗で、大きすぎないことを確認します。また、ループ内でテクスチャ データを検索する場合は、常に「注意」を払ってください。

互換性に関する最大の問題は、嵐のライティング効果でした。竜巻の周りにあらかじめ作成されたテクスチャを巻き付けて、竜巻のウィスプに色を付けられるようにしました。これは素晴らしいエフェクトで、トルネードスをシーンの色に簡単にブレンドできましたが、他のプラットフォームで実行できるようにするには長い時間がかかりました。

竜巻

モバイルウェブサイト

技術要件と処理要件が非常に厳しかったため、モバイル版は PC 版をそのまま移植したものにはできませんでした。モバイル ユーザーをターゲットにした新しいものを構築する必要がありました。

デスクトップ版の Carnival Photo-Booth を、ユーザーのモバイルカメラを使用するモバイルウェブ アプリケーションとして提供できれば素晴らしいと考えました。これは、これまで見たことがないものでした。

さらに、CSS3 で 3D 変換をコーディングして、ジャイロスコープと加速度計をリンクさせることで、エクスペリエンスに深みを加えることができました。このサイトは、スマートフォンの持ち方、動かし方、見方に反応します。

この記事では、モバイル開発プロセスをスムーズに進めるためのヒントをいくつかご紹介します。さあ、出発です。ぜひ、このツールから学べることを確認してください。

モバイルのヒントとコツ

プリローダーは必要なものであり、避けるべきものではありません。後者のような状況が発生することもあります。これは主に、プロジェクトの成長に合わせて、プリロードするもののリストを維持する必要があるためです。さらに悪いことに、複数の異なるリソースを同時に取得する場合、読み込みの進行状況をどのように計算すればよいかが明確ではありません。ここで、カスタムの非常に汎用的な抽象クラス「Task」が役立ちます。主なアイデアは、タスクが独自のサブタスクを持つことができる、無限にネストされた構造を可能にすることです。さらに、各タスクは、サブタスクの進行状況(親の進行状況ではなく)に関して進行状況を計算します。すべての MainPreloadTask、AssetPreloadTask、TemplatePreFetchTask を Task から派生させることで、次のような構造を作成しました。

プリローダー

このようなアプローチと Task クラスのおかげで、グローバルな進行状況(MainPreloadTask)、アセットのみの進行状況(AssetPreloadTask)、テンプレートの読み込みの進行状況(TemplatePreFetchTask)を簡単に把握できます。特定のファイルの進行状況も確認できます。その方法については、/m/javascripts/raw/util/Task.js の Task クラスと、/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 実装を介して)に加えて、プラットフォームに依存するアセットの読み込み方法にも注目してください。基本的に、画像には 4 つの種類があります。モバイル標準(.ext、ext はファイル拡張子、通常は .png または .jpg)、モバイル Retina(-2x.ext)、タブレット標準(-tab.ext)、タブレット Retina(-tab-2x.ext)。MainPreloadTask で検出を行い、4 つのアセット配列をハードコードする代わりに、プリロードするアセットの名前と拡張子、およびアセットがプラットフォームに依存するかどうか(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 でのみ機能するようです。そのため、ファイルが選択されたら、RegExp に対して追加のチェックを行う必要があります。
   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. アップロードまたはファイル選択のキャンセル 開発プロセス中に気づいたもう 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 のソースコード全体をご覧ください。

クレジット

クレジットの一覧はこちら

参照