Einführung in den 3D-Globus der Weltwunder
Wenn Sie die kürzlich eingeführte Website Google World Wonders in einem WebGL-fähigen Browser aufgerufen haben, ist Ihnen vielleicht ein schicker sich drehender Globus am unteren Bildschirmrand aufgefallen. In diesem Artikel erfahren Sie, wie der Globus funktioniert und was wir für seine Erstellung verwendet haben.
Der World Wonders-Globus ist eine stark angepasste Version des WebGL-Globus des Google Data Arts-Teams. Wir haben den ursprünglichen Globus genommen, die Balkendiagramme entfernt, die Shader geändert, schicke anklickbare HTML-Markierungen und die Natural Earth-Kontinentgeometrie aus der GlobeTweeter-Demo von Mozilla hinzugefügt (vielen Dank an Cedric Pinson!). So entsteht ein schöner animierter Globus, der zum Farbschema der Website passt und ihr eine zusätzliche Ebene der Raffinesse verleiht.
Die Designvorgabe für den Globus war eine ansprechende animierte Karte mit anklickbaren Markierungen auf den UNESCO-Welterbestätten. Vor diesem Hintergrund habe ich mich auf die Suche nach etwas Passendem gemacht. Als Erstes dachte ich an den WebGL Globe, der vom Google Data Arts Team entwickelt wurde. Es ist ein Globus und sieht cool aus. Was braucht man mehr?
WebGL-Globus einrichten
Der erste Schritt bei der Erstellung des Globus-Widgets bestand darin, den WebGL Globe herunterzuladen und zum Laufen zu bringen. Der WebGL Globe ist online auf Google Code verfügbar und kann einfach heruntergeladen und ausgeführt werden. Laden Sie die ZIP-Datei herunter, extrahieren Sie sie, wechseln Sie in das Verzeichnis und führen Sie einen einfachen Webserver aus: python -m SimpleHTTPServer. (Beachten Sie, dass UTF-8 standardmäßig nicht aktiviert ist. Sie können diese Option verwenden.) Wenn Sie jetzt http://localhost:8000/globe/globe.html aufrufen, sollte der WebGL Globe angezeigt werden.
Nachdem der WebGL Globe einsatzbereit war, mussten alle unnötigen Teile entfernt werden. Ich habe den HTML-Code bearbeitet, um die UI-Elemente zu entfernen, und die Einrichtung des Balkendiagramms aus der Initialisierungsfunktion des Globus entfernt. Am Ende dieses Prozesses hatte ich einen sehr einfachen WebGL Globe auf meinem Bildschirm. Du kannst es drehen und es sieht cool aus, aber das war es auch schon.
Um die unnötigen Elemente zu entfernen, habe ich alle UI-Elemente aus der Datei „index.html“ des Globus gelöscht und das Initialisierungsskript so bearbeitet:
if(!Detector.webgl){
Detector.addGetWebGLMessage();
} else {
var container = document.getElementById('container');
var globe = new DAT.Globe(container);
globe.animate();
}
Kontinentgeometrie hinzufügen
Wir wollten die Kamera nah an der Globusoberfläche haben, aber als wir den Globus herangezoomt haben, wurde die mangelnde Texturauflösung deutlich. Wenn Sie heranzoomen, wird die Textur des WebGL-Globus blockig und unscharf. Wir hätten ein größeres Bild verwenden können, aber dann würde der Globus langsamer heruntergeladen und ausgeführt werden. Deshalb haben wir uns für eine Vektordarstellung der Landmassen und Grenzen entschieden.
Für die Geometrie der Landmassen habe ich die Open-Source-Demo GlobeTweeter verwendet und das darin enthaltene 3D-Modell in Three.js geladen. Nachdem das Modell geladen und gerendert war, ging es darum, das Aussehen des Globus zu optimieren. Das erste Problem war, dass das Landmassenmodell des Globus nicht kugelförmig genug war, um bündig mit dem WebGL-Globus abzuschließen. Also habe ich einen schnellen Algorithmus zur Aufteilung des Meshs geschrieben, der das Landmassenmodell kugelförmiger machte.
Mit einem kugelförmigen Landmassenmodell konnte ich die Kontinente leicht versetzt zur Erdoberfläche platzieren. So entstanden schwebende Kontinente, die mit einer schwarzen 2-Pixel-Linie darunter umrandet waren, um eine Art Schatten zu erzeugen. Ich habe auch mit neonfarbenen Umrissen experimentiert, um einen Tron-ähnlichen Look zu erzielen.
Nachdem der Globus und die Landmassen gerendert waren, begann ich, mit verschiedenen Looks für den Globus zu experimentieren. Da wir einen dezenten, einfarbigen Look wollten, habe ich mich für einen Globus und Landmassen in Graustufen entschieden. Zusätzlich zu den oben genannten Neonumrissen habe ich einen dunklen Globus mit dunklen Landmassen auf einem hellen Hintergrund ausprobiert, was ziemlich cool aussieht. Aber der Kontrast war zu gering, um gut lesbar zu sein, und es passte nicht zum Stil des Projekts, also habe ich es verworfen.
Eine weitere Idee für den Globus war, ihn wie glasiertes Porzellan aussehen zu lassen. Das habe ich nicht ausprobiert, weil ich keinen Shader für den Porzellan-Look schreiben konnte (ein visueller Material-Editor wäre schön). Am ehesten kam dieser weiß leuchtende Globus mit schwarzen Landmassen an meine Vorstellung heran. Es ist ganz nett, aber der Kontrast ist zu hoch. Und es sieht nicht besonders gut aus. Also noch ein Gerät für den Schrottplatz.
Die Shader in den schwarz-weißen Kugeln verwenden eine Art künstliche diffuse Hintergrundbeleuchtung. Die Helligkeit des Globus hängt vom Abstand der Oberflächennormalen zur Bildschirmebene ab. Pixel in der Mitte der Kugel, die auf den Bildschirm zeigen, sind also dunkel und Pixel am Rand der Kugel sind hell. In Kombination mit einem hellen Hintergrund wird der diffuse helle Hintergrund auf dem Globus reflektiert, was einen edlen Showroom-Look erzeugt. Der schwarze Globus verwendet die WebGL Globe-Textur auch als Glanzkarte, sodass die Kontinentalschelfe (Flachwasserbereiche) im Vergleich zu den anderen Teilen des Globus glänzend aussehen.
So sieht der Ozean-Shader für den schwarzen Globus aus. Ein sehr einfacher Vertex-Shader und ein improvisierter Fragment-Shader, der nach ein paar Anpassungen ganz gut aussieht.
'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')
}
Am Ende haben wir uns für einen dunklen Globus mit hellgrauen Landmassen entschieden, der von oben beleuchtet wird. Es kam dem Design-Briefing am nächsten und war gut lesbar. Außerdem sorgt der geringe Kontrast des Globus dafür, dass die Markierungen und der Rest des Inhalts im Vergleich dazu besser zur Geltung kommen. In der Version unten sind die Ozeane komplett schwarz, während sie in der Produktionsversion dunkelgrau sind und etwas andere Markierungen haben.
Markierungen mit CSS erstellen
Apropos Markierungen: Nachdem der Globus und die Landmassen fertig waren, habe ich mit den Ortsmarkierungen begonnen. Ich habe mich für HTML-Elemente im CSS-Stil für die Markierungen entschieden, um sie einfacher erstellen und gestalten zu können und sie möglicherweise in der 2D-Karte wiederzuverwenden, an der das Team gerade arbeitete. Damals kannte ich auch keine einfache Möglichkeit, die WebGL-Markierungen anklickbar zu machen, und wollte keinen zusätzlichen Code zum Laden/Erstellen der Markierungsmodelle schreiben. Im Nachhinein betrachtet haben die CSS-Markierungen gut funktioniert, aber es kam gelegentlich zu Leistungsproblemen, wenn die Browser-Compositor und -Renderer in einer Phase der Veränderung waren. Aus Leistungssicht wäre es besser gewesen, die Markierungen in WebGL zu erstellen. Andererseits haben die CSS-Markierungen viel Entwicklungszeit gespart.
Die CSS-Markierungen bestehen aus mehreren Divs, die mit der CSS-Eigenschaft „transform“ absolut positioniert sind. Der Hintergrund der Markierungen ist ein CSS-Farbverlauf und der dreieckige Teil der Markierung ist ein gedrehtes div-Element. Die Markierungen haben einen kleinen Schlagschatten, um sie vom Hintergrund abzuheben. Das größte Problem bei den Markierungen war, dass sie nicht leistungsfähig genug waren. So traurig es auch klingen mag: Das Zeichnen von ein paar Dutzend Divs, die sich bewegen und ihren Z-Index bei jedem Frame ändern, ist eine ziemlich gute Möglichkeit, alle Arten von Browser-Rendering-Problemen auszulösen.
Die Synchronisierung der Markierungen mit der 3D-Szene ist nicht allzu kompliziert. Jede Markierung hat ein entsprechendes Object3D in der Three.js-Szene, das zum Verfolgen der Markierungen verwendet wird. Um die Bildschirmkoordinaten zu erhalten, nehme ich die Three.js-Matrizen für den Globus und die Markierung und multipliziere einen Nullvektor damit. Daraus erhalte ich die Szenenposition der Markierung. Um die Bildschirmposition der Markierung zu ermitteln, projiziere ich die Position in der Szene durch die Kamera. Der resultierende projizierte Vektor enthält die Bildschirmkoordinaten für die Markierung, die in CSS verwendet werden können.
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;
}
Letztendlich war der schnellste Ansatz, CSS-Transformationen zum Verschieben der Markierungen zu verwenden, keine Deckkraft-Überblendung zu verwenden, da dies in Firefox einen langsamen Pfad auslöste, und alle Markierungen im DOM zu belassen, anstatt sie zu entfernen, wenn sie sich hinter dem Globus befanden. Wir haben auch mit 3D-Transformationen anstelle von Z-Indizes experimentiert, aber aus irgendeinem Grund hat das in der App nicht richtig funktioniert (in einem reduzierten Testfall hat es aber funktioniert, wer weiß warum). Da wir zu diesem Zeitpunkt nur noch wenige Tage vom Launch entfernt waren, mussten wir diesen Teil auf die Wartung nach dem Launch verschieben.
Wenn Sie auf eine Markierung klicken, wird eine Liste mit anklickbaren Ortsnamen angezeigt. Das ist alles normaler HTML-DOM-Code, also war es sehr einfach zu schreiben. Alle Links und Texte werden ohne zusätzlichen Aufwand unsererseits gerendert.
Dateigröße reduzieren
Die Demo funktionierte und war mit dem Rest der World Wonders-Website verbunden, aber es gab noch ein großes Problem zu lösen. Das Mesh im JSON-Format für die Landmassen des Globus war etwa 3 MB groß. Nicht gut für die Startseite einer Showcase-Website. Durch die Komprimierung des Mesh mit gzip konnte die Größe auf 350 kB reduziert werden. Aber 350 kB sind immer noch etwas groß. Ein paar E-Mails später konnten wir Won Chun, der an der Komprimierung der riesigen Google Body-Meshes gearbeitet hatte, für die Komprimierung des Mesh gewinnen. Er komprimierte das Mesh von einer großen flachen Liste von Dreiecken, die als JSON-Koordinaten angegeben waren, zu komprimierten 11-Bit-Koordinaten mit indexierten Dreiecken und reduzierte die Dateigröße auf 95 kB (mit gzip komprimiert).
Die Verwendung komprimierter Meshes spart nicht nur Bandbreite, sondern die Meshes lassen sich auch schneller parsen. Die Umwandlung von 3 MB stringifizierten Zahlen in native Zahlen erfordert wesentlich mehr Arbeit als das Parsen von 100 kB Binärdaten. Die daraus resultierende Reduzierung der Seitengröße um 250 kB ist ebenfalls sehr praktisch, da die anfängliche Ladezeit bei einer Verbindung mit 2 Mbit/s unter einer Sekunde liegt. Schneller und kleiner – einfach genial!
Gleichzeitig habe ich mit dem Laden der ursprünglichen Natural Earth-Shapefiles herumgespielt, aus denen das GlobeTweeter-Mesh abgeleitet ist. Ich konnte die Shapefiles laden, aber um sie als flache Landmassen zu rendern, musste ich sie triangulieren (natürlich mit Löchern für Seen). Ich habe die Formen mit THREE.js-Dienstprogrammen trianguliert, aber nicht die Löcher. Die resultierenden Meshes hatten sehr lange Kanten, sodass das Mesh in kleinere Dreiecke aufgeteilt werden musste. Kurz gesagt, ich habe es nicht rechtzeitig zum Laufen gebracht, aber das Schöne war, dass das weiter komprimierte Shapefile-Format ein 8-kB-Landmassenmodell ergeben hätte. Vielleicht klappt es ja beim nächsten Mal.
Zukünftige Funktionen
Die Markierungsanimationen könnten noch etwas schöner sein. Wenn sie über den Horizont gehen, ist der Effekt ein bisschen kitschig. Außerdem wäre eine coole Animation für das Öffnen der Markierung schön.
In Bezug auf die Leistung fehlen zwei Dinge: die Optimierung des Algorithmus für die Mesh-Aufteilung und die Beschleunigung der Markierungen. Abgesehen davon ist alles prima. Hurra!
Zusammenfassung
In diesem Artikel habe ich beschrieben, wie wir den 3D-Globus für das Google World Wonders Project erstellt haben. Ich hoffe, die Beispiele haben Ihnen gefallen und Sie probieren aus, ein eigenes benutzerdefiniertes Globus-Widget zu erstellen.