Présentation du globe 3D World Wonders
Si vous avez consulté le site Google World Wonders récemment lancé sur un navigateur compatible avec WebGL, vous avez peut-être remarqué un globe rotatif en bas de l'écran. Cet article vous explique comment fonctionne le globe et comment nous l'avons conçu.
Pour vous donner un aperçu rapide, le globe World Wonders est une version fortement modifiée du globe WebGL de l'équipe Google Data Arts. Nous avons pris le globe d'origine, supprimé les éléments du graphique à barres, modifié les nuanceurs, ajouté des repères HTML cliquables et la géométrie des continents Natural Earth de la démo GlobeTweeter de Mozilla (un grand merci à Cédric Pinson !). Tout cela pour créer un joli globe animé qui correspond au jeu de couleurs du site et lui ajoute une touche de sophistication.
Le brief de conception du globe consistait à créer une carte animée esthétique avec des repères cliquables placés sur les sites inscrits au patrimoine mondial. En gardant cela à l'esprit, j'ai commencé à chercher une solution adaptée. La première chose qui m'est venue à l'esprit, c'est le globe WebGL créé par l'équipe Google Data Arts. C'est un globe, et il est plutôt sympa. De quoi d'autre avez-vous besoin ?
Configurer le globe WebGL
La première étape de la création du widget de globe a consisté à télécharger le WebGL Globe et à le rendre opérationnel. Le WebGL Globe est disponible en ligne sur Google Code. Il est facile à télécharger et à exécuter. Téléchargez et extrayez le fichier ZIP, accédez au répertoire et exécutez un serveur Web de base : python -m SimpleHTTPServer. (Notez que l'encodage UTF-8 n'est pas activé par défaut. Vous pouvez utiliser ceci.) Si vous accédez à http://localhost:8000/globe/globe.html, vous devriez voir le globe WebGL.
Une fois le WebGL Globe opérationnel, il était temps de supprimer toutes les parties inutiles. J'ai modifié le code HTML pour supprimer les éléments de l'interface utilisateur et j'ai supprimé les éléments de configuration du graphique à barres du globe de la fonction d'initialisation du globe. À la fin de ce processus, j'avais un globe WebGL très basique sur mon écran. Vous pouvez le faire tourner, ce qui est sympa, mais c'est à peu près tout.
Pour supprimer les éléments inutiles, j'ai supprimé tous les éléments d'interface utilisateur du fichier index.html du globe et j'ai modifié le script d'initialisation comme suit :
if(!Detector.webgl){
Detector.addGetWebGLMessage();
} else {
var container = document.getElementById('container');
var globe = new DAT.Globe(container);
globe.animate();
}
Ajouter la géométrie du continent
Nous voulions placer la caméra près de la surface du globe, mais lorsque nous avons testé le globe en zoomant, le manque de résolution des textures est devenu évident. En zoomant, la texture du globe WebGL devient pixélisée et floue. Nous aurions pu utiliser une image plus grande, mais cela aurait ralenti le téléchargement et l'exécution du globe. Nous avons donc opté pour une représentation vectorielle des masses terrestres et des frontières.
Pour la géométrie de la masse terrestre, j'ai utilisé la démo Open Source GlobeTweeter et j'ai chargé le modèle 3D dans Three.js. Une fois le modèle chargé et affiché, il était temps de commencer à peaufiner l'apparence du globe. Le premier problème était que le modèle de masse terrestre du globe n'était pas assez sphérique pour s'aligner sur le globe WebGL. J'ai donc fini par écrire un algorithme de division de maillage rapide qui a rendu le modèle de masse terrestre plus sphérique.
Avec un modèle de masse terrestre sphérique, j'ai pu le placer légèrement en décalage par rapport à la surface du globe, créant ainsi des continents flottants soulignés par une ligne noire de 2 px en dessous pour une sorte d'ombre. J'ai également testé des contours de couleur néon pour donner un aspect semblable à Tron.
Une fois le globe et les masses terrestres affichés, j'ai commencé à tester différentes apparences pour le globe. Comme nous voulions un look monochrome discret, j'ai opté pour un globe et des masses terrestres en niveaux de gris. En plus des contours néon mentionnés précédemment, j'ai essayé un globe sombre avec des masses terrestres sombres sur un fond clair, ce qui est plutôt sympa. Mais le contraste était trop faible pour être facilement lisible et cela ne correspondait pas à l'esprit du projet. J'ai donc abandonné cette idée.
Une autre idée que j'ai eue au début pour l'apparence du globe était de lui donner l'aspect de la porcelaine vernie. Je n'ai pas réussi à l'essayer, car je n'ai pas réussi à écrire un nuanceur pour obtenir l'aspect porcelaine (un éditeur de matériaux visuels serait utile). La chose la plus proche que j'ai essayée était ce globe blanc brillant avec des masses terrestres noires. C'est plutôt sympa, mais le contraste est trop élevé. Et ce n'est pas très joli. Encore un qui va finir à la casse.
Les nuanceurs des globes noir et blanc utilisent une sorte de rétroéclairage diffus factice. La luminosité du globe dépend de la distance entre la normale de la surface et le plan de l'écran. Ainsi, les pixels au milieu du globe qui pointent vers l'écran sont sombres, et les pixels sur les bords du globe sont clairs. Combiné à un arrière-plan clair, vous obtenez un look où le globe reflète l'arrière-plan lumineux diffus, créant un look de showroom élégant. Le globe noir utilise également la texture WebGL Globe comme carte de brillance, de sorte que les plateaux continentaux (zones d'eau peu profonde) paraissent brillants par rapport aux autres parties du globe.
Voici à quoi ressemble le nuanceur d'océan pour le globe noir. Un nuanceur de sommets très basique et un nuanceur de fragments un peu bricolé, mais qui donne un résultat plutôt sympa.
'ocean' : {
uniforms: {
'texture': { type: 't', value: 0, texture: null }
},
vertexShader: [
'varying vec3 vNormal;',
'varying vec2 vUv;',
'void main() {',
'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
'vNormal = normalize( normalMatrix * normal );',
'vUv = uv;',
'}'
].join('\n'),
fragmentShader: [
'uniform sampler2D texture;',
'varying vec3 vNormal;',
'varying vec2 vUv;',
'void main() {',
'vec3 diffuse = texture2D( texture, vUv ).xyz;',
'float intensity = pow(1.05 - dot( vNormal, vec3( 0.0, 0.0, 1.0 ) ), 4.0);',
'float i = 0.8-pow(clamp(dot( vNormal, vec3( 0, 0, 1.0 )), 0.0, 1.0), 1.5);',
'vec3 atmosphere = vec3( 1.0, 1.0, 1.0 ) * intensity;',
'float d = clamp(pow(max(0.0,(diffuse.r-0.062)*10.0), 2.0)*5.0, 0.0, 1.0);',
'gl_FragColor = vec4( (d*vec3(i)) + ((1.0-d)*diffuse) + atmosphere, 1.0 );',
'}'
].join('\n')
}
Nous avons finalement opté pour un globe sombre avec des masses terrestres gris clair éclairées par le haut. C'est celle qui correspondait le mieux au brief de conception, et elle était agréable et lisible. De plus, le fait que le globe soit un peu moins contrasté permet de faire ressortir les repères et le reste du contenu. La version ci-dessous utilise des océans complètement noirs, tandis que la version en production utilise des océans gris foncé et des repères légèrement différents.
Créer les repères avec CSS
En parlant de repères, une fois le globe et les masses terrestres fonctionnels, j'ai commencé à travailler sur les repères. J'ai décidé d'utiliser des éléments HTML de style CSS pour les repères, afin de faciliter leur création et leur mise en forme, et de pouvoir éventuellement les réutiliser dans la carte 2D sur laquelle l'équipe travaillait. À l'époque, je ne savais pas non plus comment rendre les repères WebGL cliquables et je ne voulais pas écrire de code supplémentaire pour charger/créer les modèles de repères. Avec le recul, les repères CSS fonctionnaient bien, mais avaient tendance à rencontrer occasionnellement des problèmes de performances lorsque les compositeurs et les moteurs de rendu des navigateurs étaient en période de transition. Du point de vue des performances, il aurait été préférable de créer les repères dans WebGL. En revanche, les repères CSS ont permis de gagner beaucoup de temps de développement.
Les repères CSS sont constitués de quelques divs positionnés de manière absolue avec la propriété CSS transform. L'arrière-plan des repères est un dégradé CSS, et la partie triangulaire du repère est un div pivoté. Les repères ont une petite ombre portée pour les faire ressortir de l'arrière-plan. Le plus gros problème avec les repères était de les rendre suffisamment performants. Aussi triste que cela puisse paraître, dessiner quelques dizaines de divs qui se déplacent et changent leur z-index à chaque frame est un bon moyen de déclencher toutes sortes de pièges de rendu du navigateur.
La synchronisation des repères avec la scène 3D n'est pas trop compliquée. Chaque repère est associé à un Object3D dans la scène Three.js, qui permet de suivre les repères. Pour obtenir les coordonnées d'espace à l'écran, je prends les matrices Three.js du globe et du repère, et je les multiplie par un vecteur nul. Cela me permet d'obtenir la position du repère dans la scène. Pour obtenir la position du repère à l'écran, je projette la position de la scène à travers la caméra. Le vecteur projeté obtenu contient les coordonnées de l'espace à l'écran pour le repère, prêtes à être utilisées dans le CSS.
var mat = new THREE.Matrix4();
var v = new THREE.Vector3();
for (var i=0; i<locations.length; i++) {
mat.copy(scene.matrix);
mat.multiplySelf(locations[i].point.matrix);
v.set(0,0,0);
mat.multiplyVector3(v);
projector.projectVector(v, camera);
var x = w * (v.x + 1) / 2; // Screen coords are between -1 .. 1, so we transform them to pixels.
var y = h - h * (v.y + 1) / 2; // The y coordinate is flipped in WebGL.
var z = v.z;
}
En fin de compte, l'approche la plus rapide consistait à utiliser des transformations CSS pour déplacer les repères, à ne pas utiliser de fondu d'opacité, car cela déclenchait un chemin lent sur Firefox, et à conserver tous les repères dans le DOM, sans les supprimer lorsqu'ils passaient derrière le globe. Nous avons également essayé d'utiliser des transformations 3D au lieu d'index Z, mais pour une raison quelconque, cela ne fonctionnait pas correctement dans l'application (alors que cela fonctionnait dans un scénario de test réduit, allez savoir pourquoi). Comme nous étions à quelques jours du lancement, nous avons dû laisser cette partie pour la maintenance post-lancement.
Lorsque vous cliquez sur un repère, il se développe pour afficher une liste de noms de lieux cliquables. Il s'agit d'un code HTML DOM normal, donc très facile à écrire. Tous les liens et le rendu du texte fonctionnent sans aucune intervention de notre part.
Réduire la taille du fichier
Une fois la démo fonctionnelle et connectée au reste du site World Wonders, il restait un problème majeur à résoudre. Le maillage au format JSON pour les masses terrestres du globe faisait environ 3 Mo. Ne convient pas à la page d'accueil d'un site vitrine. Heureusement, la compression du maillage avec gzip l'a réduit à 350 ko. Mais 350 ko, c'est encore un peu trop. Après quelques échanges d'e-mails, nous avons réussi à recruter Won Chun, qui avait travaillé sur la compression des énormes maillages de Google Body, pour nous aider à compresser le maillage. Il a compressé le maillage d'une grande liste plate de triangles fournis sous forme de coordonnées JSON en coordonnées 11 bits compressées avec des triangles indexés, et a réduit la taille du fichier à 95 Ko compressé au format gzip.
L'utilisation de maillages compressés permet non seulement d'économiser de la bande passante, mais aussi d'analyser les maillages plus rapidement. La conversion de 3 Mo de nombres sous forme de chaînes en nombres natifs demande beaucoup plus de travail que l'analyse de 100 ko de données binaires. La réduction de 250 Ko de la taille de la page est également très intéressante, car elle permet de réduire le temps de chargement initial à moins d'une seconde sur une connexion de 2 Mbit/s. Plus rapide et plus petit, c'est génial !
En même temps, je m'amusais à charger les fichiers de formes Natural Earth d'origine à partir desquels le maillage GlobeTweeter est dérivé. J'ai réussi à charger les fichiers de forme, mais pour les afficher sous forme de masses terrestres plates, il faut les trianguler (avec des trous pour les lacs, bien sûr). J'ai réussi à trianguler les formes à l'aide des utilitaires THREE.js, mais pas les trous. Les maillages obtenus avaient des bords très longs, ce qui nécessitait de les diviser en triangles plus petits. Pour faire court, je n'ai pas réussi à le faire fonctionner à temps, mais l'avantage est que le format Shapefile, encore plus compressé, vous aurait permis d'obtenir un modèle de masse terrestre de 8 ko. Tant pis, ce sera pour la prochaine fois.
Prochains ajouts
Il y a une chose qui pourrait être améliorée : rendre les animations des repères plus agréables. Maintenant, quand ils passent l'horizon, l'effet est un peu kitsch. De plus, il serait intéressant d'avoir une animation sympa pour l'ouverture du repère.
En termes de performances, il manque deux choses : l'optimisation de l'algorithme de division du maillage et l'accélération des marqueurs. À part ça, tout va bien. Hourra !
Résumé
Dans cet article, j'ai décrit comment nous avons créé le globe 3D pour le projet Google World Wonders. J'espère que vous avez apprécié les exemples et que vous allez essayer de créer votre propre widget de globe personnalisé.