Étude de cas - Trouvez le chemin vers Oz

Introduction

"Find Your Way to Oz" est une nouvelle expérience Google Chrome proposée sur le Web par Disney. Il vous permet de faire un voyage interactif dans un cirque du Kansas, qui vous mène au pays d'Oz après avoir été emporté par une énorme tempête.

Notre objectif était de combiner la richesse du cinéma avec les capacités techniques du navigateur pour créer une expérience amusante et immersive avec laquelle les utilisateurs peuvent établir un lien fort.

Le travail est un peu trop vaste pour être capturé dans son intégralité dans cet article, nous avons donc plongé et extrait quelques chapitres de l'histoire de la technologie qui nous semblent intéressants. Nous avons également extrait des tutoriels ciblés de difficulté croissante.

De nombreuses personnes ont travaillé dur pour rendre cette expérience possible, trop pour être listées ici. Pour en savoir plus, consultez le site et accédez à la page des crédits dans la section du menu.

Dans les coulisses

"Find Your Way to Oz" sur ordinateur est un monde immersif riche. Nous utilisons la 3D et plusieurs couches d'effets inspirés du cinéma traditionnel, qui se combinent pour créer une scène quasi réaliste. Les technologies les plus importantes sont WebGL avec Three.js, les nuanceurs personnalisés et les éléments animés DOM utilisant les fonctionnalités CSS3. En outre, l'API getUserMedia (WebRTC) permet de créer des expériences interactives où l'utilisateur peut ajouter son image directement depuis sa webcam, et l'API WebAudio permet d'ajouter du son 3D.

Mais la magie d'une expérience technologique comme celle-ci réside dans la façon dont elle est conçue. C'est aussi l'un des principaux défis : comment combiner des effets visuels et des éléments interactifs dans une même scène pour créer un ensemble cohérent ? Cette complexité visuelle était difficile à gérer, car il était difficile de savoir à quel stade de développement nous en étions à un moment donné.

Pour résoudre le problème des effets visuels interconnectés et de l'optimisation, nous avons largement utilisé un panneau de configuration qui capturait tous les paramètres pertinents que nous examinions à ce moment-là. La scène pouvait être ajustée en direct dans le navigateur, qu'il s'agisse de la luminosité, de la profondeur de champ, du gamma, etc. Tout le monde pouvait essayer de modifier les valeurs des paramètres importants de l'expérience et participer à la découverte de ce qui fonctionnait le mieux.

Avant de vous révéler notre secret, nous tenons à vous avertir que cela peut provoquer un plantage, tout comme si vous bricoliez le moteur d'une voiture. Assurez-vous de ne rien avoir d'important en cours, puis accédez à l'URL principale du site et ajoutez ?debug=on à l'adresse. Attendez que le site se charge, puis appuyez sur la touche Ctrl-I. Un menu déroulant s'affiche alors sur la droite. Si vous décochez l'option "Quitter le parcours de la caméra", vous pouvez utiliser les touches A, W, S et D, ainsi que la souris, pour vous déplacer librement dans l'espace.

Chemin de la caméra.

Nous n'allons pas passer en revue tous les paramètres ici, mais nous vous encourageons à faire des essais : les touches révèlent différents paramètres dans différentes scènes. Dans la séquence de tempête finale, une touche supplémentaire est disponible : Ctrl-A, qui vous permet d'activer ou de désactiver la lecture de l'animation et de vous déplacer. Dans cette scène, si vous appuyez sur Esc (pour quitter la fonctionnalité de verrouillage de la souris), puis de nouveau sur Ctrl-I, vous pouvez accéder aux paramètres spécifiques à la scène de tempête. Regardez autour de vous et capturez de belles vues dignes de cartes postales, comme celle ci-dessous.

Scène de tempête

Pour ce faire, et pour nous assurer qu'elle était suffisamment flexible pour répondre à nos besoins, nous avons utilisé une bibliothèque très pratique appelée dat.gui (cliquez ici pour consulter un ancien tutoriel sur son utilisation). Cela nous a permis de modifier rapidement les paramètres exposés aux visiteurs du site.

Un peu comme le matte painting

Dans de nombreux films et animations Disney classiques, la création de scènes impliquait de combiner différentes couches. Il y avait des couches de prises de vue réelles, d'animation sur celluloïd, voire de décors physiques, et par-dessus, des couches créées en peignant sur du verre : une technique appelée "matte painting".

À bien des égards, la structure de l'expérience que nous avons créée est similaire, même si certaines "couches" sont bien plus que des visuels statiques. En fait, ils affectent l'apparence des éléments en fonction de calculs plus complexes. Néanmoins, au moins au niveau global, nous avons affaire à des vues, composées les unes sur les autres. En haut, vous voyez une couche d'interface utilisateur, avec une scène 3D en dessous, elle-même composée de différents composants de scène.

La couche d'interface supérieure a été créée à l'aide de DOM et de CSS 3, ce qui signifie que les interactions peuvent être modifiées de différentes manières, indépendamment de l'expérience 3D, avec une communication entre les deux selon une liste d'événements sélectionnés. Cette communication utilise l'événement HTML5 Backbone Router + onHashChange, qui contrôle la zone à animer (entrée/sortie). (source du projet : /develop/coffee/router/Router.coffee).

Tutoriel : Feuilles de sprites et compatibilité avec Retina

Pour l'interface, nous avons utilisé une technique d'optimisation intéressante qui consistait à combiner les nombreuses images de superposition de l'interface en un seul fichier PNG afin de réduire les requêtes adressées au serveur. Dans ce projet, l'interface était composée de plus de 70 images (sans compter les textures 3D) chargées à l'avance pour réduire la latence du site Web. Vous pouvez voir la feuille de sprites en direct ici :

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

Voici quelques conseils pour utiliser les feuilles de sprites, les adapter aux appareils Retina et obtenir une interface aussi nette et précise que possible.

Créer des feuilles de sprites

Pour créer des SpriteSheets, nous avons utilisé TexturePacker, qui permet de générer des fichiers dans n'importe quel format. Dans ce cas, nous avons exporté au format EaselJS, qui est très propre et qui aurait également pu être utilisé pour créer des sprites animés.

Utiliser la feuille de sprites générée

Une fois que vous avez créé votre feuille de sprites, vous devriez voir un fichier JSON comme celui-ci :

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

Où :

  • "image" fait référence à l'URL de la feuille de sprites.
  • "frames" sont les coordonnées de chaque élément d'interface utilisateur [x, y, largeur, hauteur]
  • "animations" sont les noms de chaque asset

Notez que nous avons utilisé les images haute densité pour créer la feuille de sprites, puis nous avons créé la version normale en la redimensionnant à la moitié de sa taille.

Synthèse

Maintenant que tout est prêt, nous avons juste besoin d'un extrait de code JavaScript pour l'utiliser.

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

Voici comment l'utiliser :

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

Pour en savoir plus sur les densités de pixels variables, vous pouvez lire cet article de Boris Smus.

Le pipeline de contenu 3D

L'expérience d'environnement est configurée sur une couche WebGL. Lorsque vous pensez à une scène 3D, l'une des questions les plus délicates est de savoir comment vous allez vous assurer de pouvoir créer du contenu qui permet d'exploiter au maximum le potentiel d'expression de la modélisation, de l'animation et des effets. À bien des égards, le pipeline de contenu est au cœur de ce problème : il s'agit d'un processus convenu à suivre pour créer du contenu pour la scène 3D.

Nous voulions créer un monde impressionnant. Nous avions donc besoin d'un processus solide qui permettrait aux artistes 3D de le créer. Nous devions leur donner autant de liberté d'expression que possible dans leur logiciel de modélisation et d'animation 3D, et nous devions afficher le résultat à l'écran à l'aide de code.

Nous travaillions sur ce type de problème depuis un certain temps, car chaque fois que nous avions créé un site 3D par le passé, nous avions rencontré des limites dans les outils que nous pouvions utiliser. Nous avons donc créé un outil appelé "3D Librarian" dans le cadre d'une recherche interne. et qu'il était presque prêt à être appliqué à un vrai travail.

Cet outil a une histoire : à l'origine, il était destiné à Flash et permettait d'importer une grande scène Maya sous la forme d'un seul fichier compressé optimisé pour le décompresser au moment de l'exécution. La raison pour laquelle il était optimal est qu'il empaquetait efficacement la scène dans la même structure de données que celle manipulée lors du rendu et de l'animation. Le fichier nécessite très peu d'analyse lors de son chargement. Le décompactage dans Flash était assez rapide, car le fichier était au format AMF, que Flash pouvait décompacter de manière native. L'utilisation du même format dans WebGL nécessite un peu plus de travail sur le processeur. En fait, nous avons dû recréer une couche de code JavaScript de décompression des données, qui décompresserait essentiellement ces fichiers et recréerait les structures de données nécessaires au fonctionnement de WebGL. Le décompression de l'intégralité de la scène 3D est une opération légèrement gourmande en ressources CPU : la décompression de la scène 1 dans Find Your Way To Oz nécessite environ deux secondes sur une machine de milieu à haut de gamme. C'est pourquoi nous utilisons la technologie Web Workers au moment de la configuration de la scène (avant son lancement effectif), afin de ne pas interrompre l'expérience de l'utilisateur.

Cet outil pratique peut importer la plupart des scènes 3D : modèles, textures, animations d'os. Vous créez un seul fichier de bibliothèque, qui peut ensuite être chargé par le moteur 3D. Vous placez tous les modèles dont vous avez besoin dans votre scène dans cette bibliothèque, et voilà, vous les faites apparaître dans votre scène.

Cependant, nous avons rencontré un problème : nous devions désormais gérer WebGL, une technologie récente. C'était un défi de taille, qui a établi la norme pour les expériences 3D dans un navigateur. Nous avons donc créé une couche JavaScript ad hoc qui prend les fichiers de scène 3D compressés de 3D Librarian et les convertit correctement dans un format compréhensible par WebGL.

Tutoriel : Que le vent souffle

Le vent est un thème récurrent dans "Find Your Way To Oz". Un fil conducteur de l'histoire est structuré de manière à créer un crescendo de vent.

La première scène du carnaval est relativement calme. En parcourant les différentes scènes, l'utilisateur ressent un vent de plus en plus fort, qui culmine dans la scène finale, la tempête.

Il était donc important de proposer un effet de vent immersif.

Pour créer cet effet, nous avons ajouté aux trois scènes de fête foraine des objets souples, qui sont donc censés être affectés par le vent, comme des tentes, des drapeaux, la surface du photobooth et le ballon lui-même.

Chiffon doux.

De nos jours, les jeux pour ordinateur sont généralement conçus autour d'un moteur physique de base. Ainsi, lorsqu'un objet mou doit être simulé dans le monde 3D, une simulation physique complète est exécutée pour lui, ce qui crée un comportement mou réaliste.

En WebGL / JavaScript, nous n'avons pas (encore) le luxe d'exécuter une simulation physique complète. Pour "Le Monde fantastique d'Oz", nous avons donc dû trouver un moyen de créer l'effet du vent sans le simuler.

Nous avons intégré les informations de "sensibilité au vent" pour chaque objet dans le modèle 3D lui-même. Chaque sommet du modèle 3D avait un "attribut de vent" qui spécifiait dans quelle mesure ce sommet était censé être affecté par le vent. Cela permet de spécifier la sensibilité au vent des objets 3D. Ensuite, nous avons dû créer le vent lui-même.

Pour ce faire, nous avons généré une image contenant du bruit de Perlin. Cette image est destinée à couvrir une certaine "zone de vent". Pour mieux comprendre, imaginez une image de bruit de type nuage superposée à une certaine zone rectangulaire de la scène 3D. Chaque pixel (valeur de niveau de gris) de cette image spécifie la force du vent à un certain moment dans la zone 3D qui l'entoure.

Pour produire l'effet de vent, l'image est déplacée, dans le temps, à vitesse constante, dans une direction spécifique : la direction du vent. Pour que la "zone venteuse" n'affecte pas tout ce qui se trouve dans la scène, nous enveloppons l'image du vent autour des bords, en la limitant à la zone d'effet.

Tutoriel simple sur le vent en 3D

Créons maintenant l'effet du vent dans une scène 3D simple dans Three.js.

Nous allons créer du vent dans un simple "champ d'herbe procédural".

Commençons par créer la scène. Nous allons créer un terrain plat simple et texturé. Chaque brin d'herbe sera simplement représenté par un cône 3D inversé.

Terrain herbeux
Terrain herbeux

Voici comment créer cette scène simple dans Three.js à l'aide de CoffeeScript.

Tout d'abord, nous allons configurer Three.js et l'associer à la caméra, au contrôleur de souris et à une source de lumière :

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

Les appels de fonction initGrass et initTerrain remplissent la scène avec de l'herbe et du terrain, respectivement :

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

Ici, nous créons une grille de 15 par 15 brins d'herbe. Nous ajoutons un peu de randomisation à chaque position d'herbe, afin qu'elles ne s'alignent pas comme des soldats, ce qui serait étrange.

Ce terrain est simplement un plan horizontal, placé à la base des brins d'herbe (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 )

Jusqu'à présent, nous avons simplement créé une scène Three.js, et ajouté quelques brins d'herbe, constitués de cônes inversés générés de manière procédurale, et un terrain simple.

Rien d'extraordinaire jusqu'à présent.

Il est maintenant temps d'ajouter du vent. Tout d'abord, nous voulons intégrer les informations de sensibilité au vent dans le modèle 3D de l'herbe.

Nous allons intégrer ces informations en tant qu'attribut personnalisé pour chaque sommet du modèle 3D de l'herbe. Nous allons utiliser la règle suivante : l'extrémité inférieure du modèle d'herbe (la pointe du cône) a une sensibilité nulle, car elle est fixée au sol. La partie supérieure du modèle d'herbe (base du cône) présente une sensibilité maximale au vent, car c'est la partie la plus éloignée du sol.

Voici comment la fonction instanceGrass est recodée pour ajouter la sensibilité au vent en tant qu'attribut personnalisé pour le modèle 3D d'herbe.

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

Nous utilisons désormais un matériau personnalisé, windMaterial, au lieu du MeshPhongMaterial que nous utilisions précédemment. WindMaterial encapsule le WindMeshShader que nous allons voir dans un instant.

Le code de instanceGrass parcourt donc tous les sommets du modèle d'herbe et, pour chaque sommet, ajoute un attribut de sommet personnalisé appelé windFactor. Ce windFactor est défini sur 0 pour l'extrémité inférieure du modèle d'herbe (où il est censé toucher le terrain) et sur 1 pour l'extrémité supérieure du modèle d'herbe.

L'autre ingrédient dont nous avons besoin est d'ajouter le vent à notre scène. Comme nous l'avons vu, nous allons utiliser le bruit de Perlin pour cela. Nous allons générer de manière procédurale une texture de bruit de Perlin.

Pour plus de clarté, nous allons attribuer cette texture au terrain lui-même, à la place de la texture verte qu'il avait précédemment. Cela vous permettra de mieux comprendre ce qui se passe avec le vent.

Cette texture de bruit de Perlin couvrira donc spatialement l'extension de notre terrain, et chaque pixel de la texture spécifiera l'intensité du vent de la zone du terrain où ce pixel se trouve. Le rectangle de terrain sera notre "zone de vent".

Le bruit de Perlin est généré de manière procédurale via un nuanceur appelé NoiseShader. Ce nuanceur utilise des algorithmes de bruit simplex 3D provenant de https://github.com/ashima/webgl-noise . La version WebGL de cet exemple a été reprise textuellement de l'un des exemples Three.js de MrDoob, à l'adresse http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader utilise un ensemble de paramètres de temps, d'échelle et de décalage, en tant qu'uniformes, et génère une distribution 2D agréable du bruit 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) }

...

Nous allons utiliser ce nuanceur pour afficher notre bruit de Perlin sur une texture. Cette opération est effectuée dans la fonction 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 )

Le code ci-dessus configure noiseMap en tant que cible de rendu Three.js, l'équipe de NoiseShader, puis l'affiche avec une caméra orthographique afin d'éviter les distorsions de perspective.

Comme nous l'avons vu, nous allons maintenant utiliser cette texture comme texture de rendu principale pour le terrain. Cela n'est pas vraiment nécessaire pour que l'effet de vent fonctionne. Mais il est utile de l'avoir pour mieux comprendre visuellement ce qui se passe avec la production d'énergie éolienne.

Voici la fonction initTerrain retravaillée, qui utilise noiseMap comme texture :

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 )

Maintenant que notre texture de vent est en place, examinons WindMeshShader, qui est chargé de déformer les modèles d'herbe en fonction du vent.

Pour créer ce nuanceur, nous sommes partis du nuanceur MeshPhongMaterial standard de Three.js et l'avons modifié. C'est un bon moyen de créer rapidement un nuanceur fonctionnel sans avoir à partir de zéro.

Nous n'allons pas copier l'intégralité du code du nuanceur ici (n'hésitez pas à le consulter dans le fichier de code source), car la majeure partie serait une réplique du nuanceur MeshPhongMaterial. Mais examinons les parties modifiées liées au vent dans le nuanceur de sommets.

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;

Ce nuanceur calcule d'abord les coordonnées de recherche de texture windUV, en fonction de la position xz (horizontale) en 2D du sommet. Cette coordonnée UV est utilisée pour rechercher la force du vent, vWindForce, à partir de la texture du vent du bruit de Perlin.

Cette valeur vWindForce est combinée à l'attribut personnalisé windFactor spécifique au sommet, décrit ci-dessus, afin de calculer la déformation nécessaire du sommet. Nous avons également un paramètre global windScale pour contrôler l'intensité globale du vent, et un vecteur windDirection qui spécifie la direction dans laquelle la déformation du vent doit avoir lieu.

Cela crée donc une déformation de nos brins d'herbe en fonction du vent. Cependant, nous n'avons pas encore terminé. Pour l'instant, cette déformation est statique et ne donne pas l'impression d'une zone venteuse.

Comme nous l'avons mentionné, nous allons devoir faire glisser la texture de bruit au fil du temps, sur la zone du vent, pour que notre verre puisse onduler.

Pour ce faire, déplacez au fil du temps l'uniforme vOffset transmis au NoiseShader. Il s'agit d'un paramètre vec2 qui nous permettra de spécifier le décalage du bruit, dans une certaine direction (la direction du vent).

Pour ce faire, nous utilisons la fonction render, qui est appelée à chaque frame :

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

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

Et voilà ! Nous venons de créer une scène avec de l'herbe procédurale affectée par le vent.

Ajout de poussière au mélange

Maintenant, pimentons un peu notre scène. Ajoutons un peu de poussière en suspension pour rendre la scène plus intéressante.

Ajout de poussière…
Ajouter de la poussière

La poussière est censée être affectée par le vent. Il est donc tout à fait logique d'avoir de la poussière qui vole dans notre scène de vent.

La poussière est configurée dans la fonction initDust en tant que système de particules.

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

Ici, 130 particules de poussière sont créées. Notez que chacun d'eux est équipé d'un WindParticleShader spécial.

Maintenant, à chaque image, nous allons déplacer un peu les particules, en utilisant CoffeeScript, indépendamment du vent. Voici le code.

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 )

En outre, nous allons décaler la position de chaque particule en fonction du vent. Cela se fait dans WindParticleShader. Plus précisément, dans le nuanceur de sommets.

Le code de ce nuanceur est une version modifiée de ParticleMaterial de Three.js. Voici à quoi ressemble son cœur :

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;

Ce vertex shader n'est pas très différent de celui que nous avons utilisé pour la déformation de l'herbe par le vent. Il prend la texture de bruit de Perlin en entrée et, en fonction de la position de la poussière dans le monde, il recherche une valeur vWindForce dans la texture de bruit. Ensuite, elle utilise cette valeur pour modifier la position de la particule de poussière.

Riders On The Storm

La plus audacieuse de nos scènes WebGL était probablement la dernière, que vous pouvez voir si vous cliquez sur la montgolfière pour entrer dans l'œil de la tornade et atteindre la fin de votre voyage sur le site, ainsi qu'une vidéo exclusive de la prochaine sortie.

Scène de vol en montgolfière

Lorsque nous avons créé cette scène, nous savions que nous devions intégrer un élément central à l'expérience pour qu'elle soit marquante. La tornade tourbillonnante servirait de pièce maîtresse, et des couches d'autres contenus façonneraient cette fonctionnalité pour créer un effet spectaculaire. Pour y parvenir, nous avons construit l'équivalent d'un plateau de tournage autour de cet étrange nuanceur.

Nous avons utilisé une approche mixte pour créer l'image composite réaliste. Certains étaient des astuces visuelles, comme des formes lumineuses pour créer un effet de reflet d'objectif, ou des gouttes de pluie qui s'animent en couches au-dessus de la scène que vous regardez. Dans d'autres cas, nous avons dessiné des surfaces planes qui semblent se déplacer, comme les couches de nuages bas qui se déplacent selon un code de système de particules. Les débris en orbite autour de la tornade étaient des couches d'une scène 3D triées pour se déplacer devant et derrière la tornade.

La principale raison pour laquelle nous avons dû construire la scène de cette manière était de nous assurer que nous disposions d'un GPU suffisant pour gérer le nuanceur de tornade en équilibre avec les autres effets que nous appliquions. Au départ, nous avons rencontré d'importants problèmes d'équilibrage du GPU, mais nous avons ensuite optimisé cette scène, qui est devenue plus légère que les scènes principales.

Tutoriel : Le nuanceur de tempête

Pour créer la séquence finale de la tempête, de nombreuses techniques ont été combinées, mais la pièce maîtresse de ce travail était un nuanceur GLSL personnalisé qui ressemble à une tornade. Nous avons essayé de nombreuses techniques, des vertex shaders pour créer des tourbillons géométriques intéressants aux animations basées sur des particules, en passant par des animations 3D de formes géométriques torsadées. Aucun des effets ne semblait recréer la sensation d'une tornade ou nécessitait trop de traitement.

C'est un projet complètement différent qui nous a finalement fourni la réponse. Un projet parallèle impliquant des jeux scientifiques pour cartographier le cerveau de la souris de l'Institut Max Planck (brainflight.org) avait généré des effets visuels intéressants. Nous avions réussi à créer des vidéos de l'intérieur d'un neurone de souris à l'aide d'un nuanceur volumétrique personnalisé.

Intérieur d'un neurone de souris à l'aide d'un nuanceur volumétrique personnalisé
Intérieur d'un neurone de souris à l'aide d'un nuanceur volumétrique personnalisé

Nous avons découvert que l'intérieur d'une cellule cérébrale ressemblait un peu à l'entonnoir d'une tornade. Comme nous utilisions une technique volumétrique, nous savions que nous pourrions voir ce nuanceur dans toutes les directions de l'espace. Nous pourrions configurer le rendu du nuanceur pour qu'il se combine avec la scène de tempête, en particulier s'il est pris en sandwich entre des couches de nuages et un arrière-plan spectaculaire.

La technique du nuanceur implique une astuce qui utilise un seul nuanceur GLSL pour afficher un objet entier avec un algorithme de rendu simplifié appelé "rendu par ray marching" avec un champ de distance. Cette technique consiste à créer un nuanceur de pixels qui estime la distance la plus proche d'une surface pour chaque point de l'écran.

Vous trouverez une bonne référence à l'algorithme dans la présentation d'iq : Rendering Worlds With Two Triangles - Iñigo Quilez. En explorant la galerie de nuanceurs sur glsl.heroku.com, vous trouverez de nombreux exemples de cette technique que vous pourrez tester.

Le cœur du nuanceur commence par la fonction principale, qui configure les transformations de la caméra et entre dans une boucle qui évalue de manière répétée la distance jusqu'à une surface. L'appel RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) est l'endroit où s'effectue le calcul principal du 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
}

L'idée est qu'à mesure que nous avançons dans la forme de la tornade, nous ajoutons régulièrement des contributions de couleur à la valeur de couleur finale du pixel, ainsi que des contributions à l'opacité le long du rayon. Cela donne une texture douce et stratifiée à la tornade.

L'autre aspect essentiel de la tornade est sa forme, qui est créée en composant un certain nombre de fonctions. Il s'agit d'un cône au départ, qui est composé de bruit pour créer un bord rugueux organique, puis tordu le long de son axe principal et pivoté dans le temps.

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

La création de ce type de nuanceur est complexe. Au-delà des problèmes liés à l'abstraction des opérations que vous créez, il existe de sérieux problèmes d'optimisation et de compatibilité multiplateforme que vous devez identifier et résoudre avant de pouvoir utiliser le travail en production.

La première partie du problème : optimiser ce nuanceur pour notre scène. Pour y remédier, nous devions adopter une approche "sûre" au cas où le nuanceur serait trop lourd. Pour ce faire, nous avons composé le nuanceur de la tornade à une résolution d'échantillonnage différente de celle du reste de la scène. Il s'agit du fichier stormTest.coffee (oui, il s'agissait d'un test).

Nous commençons par un renderTarget qui correspond à la largeur et à la hauteur de la scène, afin que la résolution du nuanceur de tornade soit indépendante de la scène. Nous décidons ensuite du sous-échantillonnage de la résolution du nuanceur de tempête de manière dynamique en fonction de la fréquence d'images que nous obtenons.

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

Enfin, nous affichons la tornade à l'écran à l'aide d'un algorithme sal2x simplifié (pour éviter l'aspect pixélisé) à la ligne 1107 de stormTest.coffee. Cela signifie que, dans le pire des cas, la tornade sera plus floue, mais au moins, elle fonctionnera sans que l'utilisateur perde le contrôle.

L'étape d'optimisation suivante nécessite de se plonger dans l'algorithme. Le facteur de calcul déterminant dans le nuanceur est l'itération effectuée sur chaque pixel pour tenter d'approcher la distance de la fonction de surface : le nombre d'itérations de la boucle de raymarching. En utilisant une taille de pas plus grande, nous pourrions obtenir une estimation de la surface de la tornade avec moins d'itérations lorsque nous nous trouvons en dehors de sa surface nuageuse. À l'intérieur, nous réduisons la taille de pas pour plus de précision et pour pouvoir mélanger les valeurs afin de créer l'effet de brume. La création d'un cylindre de délimitation pour obtenir une estimation de la profondeur du rayon projeté a également permis d'accélérer le processus.

La deuxième partie du problème consistait à s'assurer que ce nuanceur fonctionnerait sur différentes cartes vidéo. Nous avons effectué des tests à chaque fois et avons commencé à développer une intuition pour le type de problèmes de compatibilité que nous pourrions rencontrer. Si nous n'avons pas pu faire beaucoup mieux que l'intuition, c'est parce que nous n'avons pas toujours pu obtenir de bonnes informations de débogage sur les erreurs. En général, vous obtenez simplement une erreur de GPU sans plus d'informations, voire un plantage du système.

Les problèmes de compatibilité entre les cartes vidéo ont des solutions similaires : assurez-vous que les constantes statiques sont saisies avec le type de données précis défini, par exemple : 0.0 pour float et 0 pour int. Faites attention lorsque vous écrivez des fonctions plus longues ; il est préférable de diviser les choses en plusieurs fonctions plus simples et variables intermédiaires, car les compilateurs ne semblent pas gérer correctement certains cas. Assurez-vous que les textures sont toutes une puissance de 2, qu'elles ne sont pas trop volumineuses et, dans tous les cas, faites preuve de prudence lorsque vous recherchez des données de texture dans une boucle.

Les plus gros problèmes de compatibilité que nous avons rencontrés concernaient l'effet d'éclairage de la tempête. Nous avons utilisé une texture prédéfinie enroulée autour de la tornade pour pouvoir colorer ses volutes. L'effet était magnifique et permettait d'intégrer facilement la tornade aux couleurs de la scène, mais il a fallu beaucoup de temps pour essayer de le faire fonctionner sur d'autres plates-formes.

tornade

Le site Web mobile

L'expérience mobile ne pouvait pas être une simple traduction de la version classique, car les exigences technologiques et de traitement étaient trop lourdes. Nous devions créer quelque chose de nouveau, ciblant spécifiquement les utilisateurs mobiles.

Nous avons pensé qu'il serait intéressant de proposer le photomaton du carnaval, disponible sur ordinateur, sous la forme d'une application Web mobile qui utiliserait l'appareil photo du mobile de l'utilisateur. C'est quelque chose que nous n'avions jamais vu auparavant.

Pour ajouter du piquant, nous avons codé des transformations 3D en CSS3. En l'associant au gyroscope et à l'accéléromètre, nous avons pu ajouter beaucoup de profondeur à l'expérience. Le site réagit à la façon dont vous tenez, déplacez et regardez votre téléphone.

En rédigeant cet article, nous avons pensé qu'il serait utile de vous donner quelques conseils pour que le processus de développement mobile se déroule sans accroc. C'est parti ! Allez-y et découvrez ce que vous pouvez en apprendre !

Conseils et astuces pour mobile

Le préchargeur est nécessaire et ne doit pas être évité. Nous savons que cela arrive parfois. Cela est principalement dû au fait que vous devez continuer à gérer la liste des éléments que vous préchargez à mesure que votre projet se développe. Pire encore, la façon de calculer la progression du chargement n'est pas très claire si vous extrayez différentes ressources, et plusieurs d'entre elles en même temps. C'est là que notre classe abstraite personnalisée et très générique "Task" s'avère utile. L'idée principale est de permettre une structure imbriquée à l'infini, dans laquelle une tâche peut avoir ses propres sous-tâches, qui peuvent avoir leurs propres sous-tâches, etc. De plus, chaque tâche calcule sa progression par rapport à celle de ses sous-tâches (mais pas par rapport à celle de la tâche parente). En faisant dériver toutes les tâches MainPreloadTask, AssetPreloadTask et TemplatePreFetchTask de Task, nous avons créé une structure qui ressemble à ceci :

Préchargeur

Grâce à cette approche et à la classe Task, nous pouvons facilement connaître la progression globale (MainPreloadTask), ou simplement la progression des éléments (AssetPreloadTask) ou du chargement des modèles (TemplatePreFetchTask). Même la progression d'un fichier particulier. Pour voir comment cela fonctionne, consultez la classe Task dans /m/javascripts/raw/util/Task.js et les implémentations de tâches réelles dans /m/javascripts/preloading/task. Voici un extrait de la configuration de la classe /m/javascripts/preloading/task/MainPreloadTask.js, qui est notre wrapper de préchargement ultime :

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

      }
    }
  })
]);

Dans la classe /m/javascripts/preloading/task/subtask/AssetPreloadTask.js, outre la façon dont elle communique avec MainPreloadTask (via l'implémentation de Task partagée), il est également intéressant de noter comment nous chargeons les éléments qui dépendent de la plate-forme. En gros, nous avons quatre types d'images. Standard pour mobile (.ext, où ext est l'extension de fichier, généralement .png ou .jpg), Retina pour mobile (-2x.ext), standard pour tablette (-tab.ext) et Retina pour tablette (-tab-2x.ext). Au lieu d'effectuer la détection dans MainPreloadTask et de coder en dur quatre tableaux d'assets, nous indiquons simplement le nom et l'extension de l'asset à précharger, et si l'asset dépend de la plate-forme (responsive = true / false). Ensuite, AssetPreloadTask génère le nom du fichier pour nous :

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

Plus bas dans la chaîne de classes, le code réel qui effectue le préchargement des éléments se présente comme suit (/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);
}

Tutoriel : Cabine photo HTML5 (iOS6/Android)

Lors du développement d'OZ mobile, nous avons constaté que nous passions beaucoup de temps à jouer avec le photomaton au lieu de travailler :D C'était tout simplement parce que c'était amusant. Nous avons donc créé une démo pour que vous puissiez l'essayer.

Photomaton mobile
Photomaton mobile

Vous pouvez voir une démonstration en direct ici (exécutez-la sur votre iPhone ou votre téléphone Android) :

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

Pour le configurer, vous avez besoin d'une instance d'application Google App Engine sans frais sur laquelle vous pouvez exécuter le backend. Le code de l'interface n'est pas complexe, mais il peut présenter quelques pièges. Passons-les en revue :

  1. Type de fichier image autorisé Nous voulons que les utilisateurs ne puissent importer que des images (puisqu'il s'agit d'un photomaton, pas d'un vidéomaton). En théorie, il vous suffit de spécifier le filtre en HTML, comme suit : input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" Cependant, cela ne semble fonctionner que sur iOS. Nous devons donc ajouter une vérification supplémentaire par rapport à l'expression régulière une fois qu'un fichier a été sélectionné :
   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. Annuler une importation ou une sélection de fichiers Une autre incohérence que nous avons remarquée lors du processus de développement est la façon dont les différents appareils signalent une sélection de fichiers annulée. Les téléphones et tablettes iOS ne font rien, ils n'envoient aucune notification. Nous n'avons donc pas besoin d'action spéciale pour ce cas. Toutefois, les téléphones Android déclenchent quand même la fonction add(), même si aucun fichier n'est sélectionné. Voici comment procéder :
    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();            
    }
    }

Le reste fonctionne plutôt bien sur toutes les plates-formes. Amusez-vous !

Conclusion

Compte tenu de la taille massive de Find Your Way To Oz et de la grande variété de technologies impliquées, nous n'avons pu aborder dans cet article que quelques-unes des approches que nous avons utilisées.

Si vous souhaitez explorer l'ensemble du projet, n'hésitez pas à consulter le code source complet de Find Your Way To Oz.

Crédits

Cliquez ici pour obtenir la liste complète des crédits.

Références