Einführung
„Find Your Way to Oz“ ist ein neues Google Chrome Experiment, das von Disney ins Web gebracht wurde. Sie können eine interaktive Reise durch einen Zirkus in Kansas unternehmen, die Sie nach einem heftigen Sturm ins Land Oz führt.
Unser Ziel war es, die Vielfalt des Kinos mit den technischen Möglichkeiten des Browsers zu kombinieren, um ein unterhaltsames, immersives Erlebnis zu schaffen, mit dem Nutzer eine starke Verbindung aufbauen können.
Die Aufgabe ist etwas zu groß, um sie in diesem Artikel vollständig zu erfassen. Deshalb haben wir uns einige Kapitel der Technologiegeschichte herausgepickt, die wir für interessant halten. Dabei haben wir einige Tutorials mit steigendem Schwierigkeitsgrad erstellt.
Viele Menschen haben hart daran gearbeitet, dieses Erlebnis möglich zu machen – zu viele, um sie hier alle aufzulisten. Besuche die Website und sieh dir die Seite mit den Mitwirkenden im Menübereich an, um die ganze Geschichte zu erfahren.
So funktioniert's
„Find Your Way to Oz“ ist auf dem Computer eine reichhaltige, immersive Welt. Wir verwenden 3D und mehrere Ebenen von Effekten, die von der traditionellen Filmproduktion inspiriert sind, um eine nahezu realistische Szene zu erstellen. Die wichtigsten Technologien sind WebGL mit Three.js, benutzerdefinierte Shader und DOM-animierte Elemente mit CSS3-Funktionen. Außerdem wird die getUserMedia API (WebRTC) für interaktive Erlebnisse verwendet, mit denen Nutzer ihr Bild direkt über die Webcam hinzufügen können, und WebAudio für 3D-Sound.
Das Besondere an einer solchen technologischen Erfahrung ist jedoch, wie alles zusammenkommt. Das ist auch eine der größten Herausforderungen: Wie lassen sich visuelle Effekte und interaktive Elemente in einer Szene zu einem einheitlichen Ganzen zusammenfügen? Diese visuelle Komplexität war schwer zu handhaben: Es war schwierig, zu erkennen, in welcher Entwicklungsphase wir uns gerade befanden.
Um das Problem der miteinander verbundenen visuellen Effekte und der Optimierung zu lösen, haben wir ein Steuerfeld verwendet, das alle relevanten Einstellungen erfasst, die wir zu diesem Zeitpunkt überprüft haben. Die Szene konnte live im Browser angepasst werden, von der Helligkeit über die Tiefenschärfe bis hin zum Gammawert usw. Jeder konnte die Werte der wichtigen Parameter in der Demo anpassen und herausfinden, was am besten funktionierte.
Bevor wir unser Geheimnis verraten, möchten wir dich warnen, dass es zu Abstürzen kommen kann – so wie wenn du im Motor eines Autos herumstocherst. Achten Sie darauf, dass Sie keine wichtigen Inhalte geöffnet haben, rufen Sie die Haupt-URL der Website auf und hängen Sie ?debug=on an die Adresse an. Warten Sie, bis die Website geladen ist, und drücken Sie dann die Taste Ctrl-I. Rechts wird ein Drop-down-Menü angezeigt. Wenn Sie die Option „Kamerafahrt beenden“ deaktivieren, können Sie sich mit den Tasten A, W, S, D und der Maus frei im Raum bewegen.
Wir gehen hier nicht auf alle Einstellungen ein, aber wir empfehlen dir, zu experimentieren: Die Tasten zeigen in verschiedenen Szenen unterschiedliche Einstellungen an. In der letzten Sturmsequenz gibt es eine zusätzliche Taste: Ctrl-A. Damit können Sie die Animationswiedergabe ein- und ausschalten und herumfliegen. Wenn Sie in dieser Szene Esc drücken, um die Maussperre aufzuheben, und dann noch einmal Ctrl-I drücken, können Sie auf die Einstellungen für die Sturmszene zugreifen. Sehen Sie sich um und machen Sie ein paar schöne Postkartenaufnahmen wie die unten.
Um dies zu erreichen und sicherzustellen, dass es flexibel genug für unsere Anforderungen ist, haben wir eine wunderbare Bibliothek namens dat.gui verwendet (siehe hier für ein früheres Tutorial zur Verwendung). Wir konnten schnell ändern, welche Einstellungen den Besuchern der Website angezeigt wurden.
Ähnlich wie Matte Painting
In vielen klassischen Disney-Filmen und -Animationen wurden Szenen durch die Kombination verschiedener Ebenen erstellt. Es gab Ebenen mit Live-Action, Cell-Animation, sogar physische Sets und darüber Ebenen, die durch Malen auf Glas erstellt wurden: eine Technik namens Matte Painting.
In vielerlei Hinsicht ist die Struktur der von uns erstellten Umgebung ähnlich, auch wenn einige der „Ebenen“ weit mehr als statische Bilder sind. Tatsächlich beeinflussen sie das Aussehen von Dingen gemäß komplexeren Berechnungen. Dennoch haben wir es zumindest auf der übergeordneten Ebene mit Ansichten zu tun, die übereinander angeordnet sind. Oben sehen Sie eine UI-Ebene und darunter eine 3D-Szene, die aus verschiedenen Szenenkomponenten besteht.
Die oberste Schnittstellenebene wurde mit DOM und CSS 3 erstellt. Das bedeutet, dass die Interaktionen auf viele Arten unabhängig von der 3D-Umgebung bearbeitet werden konnten, wobei die Kommunikation zwischen den beiden gemäß einer ausgewählten Liste von Ereignissen erfolgte. Diese Kommunikation verwendet Backbone Router + onHashChange HTML5-Ereignis, das steuert, welcher Bereich ein- oder ausgeblendet werden soll. (Projektquelle: /develop/coffee/router/Router.coffee).
Anleitung: Sprite-Sheets und Retina-Unterstützung
Eine interessante Optimierungstechnik, die wir für die Benutzeroberfläche verwendet haben, bestand darin, die vielen Overlay-Bilder der Benutzeroberfläche in einem einzigen PNG zu kombinieren, um die Anzahl der Serveranfragen zu reduzieren. In diesem Projekt bestand die Benutzeroberfläche aus mehr als 70 Bildern (ohne 3D-Texturen), die alle im Voraus geladen wurden, um die Latenz der Website zu reduzieren. Hier sehen Sie das Live-Sprite-Sheet:
Normales Display: http://findyourwaytooz.com/img/home/interface_1x.png Retina-Display: http://findyourwaytooz.com/img/home/interface_2x.png
Hier sind einige Tipps, wie wir Sprite Sheets genutzt haben und wie Sie sie für Retina-Geräte verwenden können, um die Benutzeroberfläche so scharf und übersichtlich wie möglich zu gestalten.
Spritesheets erstellen
Zum Erstellen von SpriteSheets haben wir TexturePacker verwendet, das in jedem gewünschten Format ausgibt. In diesem Fall haben wir als EaselJS exportiert. Das ist sehr übersichtlich und hätte auch zum Erstellen animierter Sprites verwendet werden können.
Generiertes Sprite-Sheet verwenden
Nachdem Sie Ihr Sprite-Sheet erstellt haben, sollten Sie eine JSON-Datei wie diese sehen:
{
"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]
},
}
Wobei:
- „image“ bezieht sich auf die URL des Sprite-Sheets.
- „frames“ sind die Koordinaten der einzelnen UI-Elemente [x, y, Breite, Höhe]
- Animationen sind die Namen der einzelnen Assets
Beachten Sie, dass wir die hochauflösenden Bilder verwendet haben, um das Sprite-Sheet zu erstellen. Anschließend haben wir die normale Version erstellt, indem wir die Größe auf die Hälfte reduziert haben.
Zusammenfassung
Jetzt brauchen wir nur noch ein JavaScript-Snippet, um es zu verwenden.
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);
};
Und so würden Sie es verwenden:
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'));
Weitere Informationen zu variablen Pixeldichten finden Sie in diesem Artikel von Boris Smus.
Die 3D-Inhaltspipeline
Die Umgebung wird auf einer WebGL-Ebene eingerichtet. Wenn Sie über eine 3D-Szene nachdenken, ist eine der schwierigsten Fragen, wie Sie sicherstellen können, dass Sie Inhalte erstellen, die das maximale Ausdruckspotenzial aus Modellierung, Animation und Effekten herausholen. Im Mittelpunkt dieses Problems steht in vielerlei Hinsicht die Content-Pipeline: ein vereinbarter Prozess, der bei der Erstellung von Inhalten für die 3D-Szene befolgt werden muss.
Wir wollten eine beeindruckende Welt erschaffen. Dazu brauchten wir einen soliden Prozess, der es 3D-Künstlern ermöglicht, sie zu erstellen. Sie sollten in ihrer 3D-Modellierungs- und Animationssoftware so viel kreative Freiheit wie möglich haben und wir mussten die Ergebnisse über Code auf dem Bildschirm rendern.
Wir hatten schon länger an diesem Problem gearbeitet, denn jedes Mal, wenn wir in der Vergangenheit eine 3D-Website erstellt hatten, waren wir auf Einschränkungen bei den Tools gestoßen, die wir verwenden konnten. Wir hatten dieses Tool namens 3D Librarian entwickelt, ein internes Forschungsprojekt. Und es war fast bereit, für einen echten Job eingesetzt zu werden.
Dieses Tool hat eine gewisse Geschichte: Ursprünglich war es für Flash gedacht und ermöglichte es, eine große Maya-Szene als eine einzige komprimierte Datei zu importieren, die für das Entpacken zur Laufzeit optimiert war. Der Grund dafür war, dass die Szene effektiv in derselben Datenstruktur gepackt wurde, die während des Renderns und der Animation bearbeitet wird. Beim Laden der Datei ist nur sehr wenig Parsing erforderlich. Das Entpacken in Flash ging ziemlich schnell, da die Datei im AMF-Format vorlag, das Flash nativ entpacken konnte. Die Verwendung desselben Formats in WebGL erfordert etwas mehr Arbeit auf der CPU. Wir mussten sogar eine JavaScript-Ebene zum Entpacken der Daten erstellen, die diese Dateien dekomprimiert und die für WebGL erforderlichen Datenstrukturen neu erstellt. Das Entpacken der gesamten 3D-Szene ist ein Vorgang, der die CPU mäßig beansprucht. Das Entpacken von Szene 1 in Find Your Way To Oz dauert auf einem mittel- bis hochleistungsfähigen Computer etwa 2 Sekunden. Daher wird dies mithilfe der Web Workers-Technologie während der „Szeneneinrichtung“ (bevor die Szene tatsächlich gestartet wird) durchgeführt, damit die Nutzererfahrung nicht beeinträchtigt wird.
Mit diesem praktischen Tool können Sie den Großteil der 3D-Szene importieren: Modelle, Texturen, Bone-Animationen. Sie erstellen eine einzelne Bibliotheksdatei, die dann von der 3D-Engine geladen werden kann. Sie fügen alle Modelle, die Sie für Ihre Szene benötigen, in diese Bibliothek ein und können sie dann in Ihrer Szene platzieren.
Ein Problem war jedoch, dass wir es jetzt mit WebGL zu tun hatten, dem neuen Kind auf dem Block. Das war ein ziemlich harter Brocken, der den Standard für browserbasierte 3D-Erlebnisse setzte. Also haben wir eine Ad-hoc-JavaScript-Ebene erstellt, die die komprimierten 3D-Szenendateien von 3D Librarian in ein Format übersetzt, das WebGL versteht.
Tutorial: Es werde Wind
Ein wiederkehrendes Thema in „Find Your Way To Oz“ war der Wind. Ein Teil der Storyline ist so aufgebaut, dass der Wind immer stärker wird.
Die erste Szene des Karnevals ist relativ ruhig. In den verschiedenen Szenen erleben die Nutzer einen immer stärkeren Wind, der in der letzten Szene, dem Sturm, gipfelt.
Daher war es wichtig, einen immersiven Windeffekt zu erzeugen.
Dazu haben wir die drei Jahrmarktszenen mit weichen Objekten gefüllt, die vom Wind beeinflusst werden sollen, wie Zelte, Flaggen, die Oberfläche der Fotokabine und den Ballon selbst.
Desktop-Spiele werden heutzutage in der Regel auf einer zentralen Physik-Engine aufgebaut. Wenn also ein weiches Objekt in der 3D-Welt simuliert werden muss, wird eine vollständige Physiksimulation dafür ausgeführt, um ein glaubwürdiges Verhalten zu erzeugen.
In WebGL / JavaScript haben wir (noch) nicht die Möglichkeit, eine vollständige Physiksimulation auszuführen. In „Oz“ mussten wir also einen Weg finden, den Effekt von Wind zu erzeugen, ohne ihn tatsächlich zu simulieren.
Wir haben die Informationen zur „Windempfindlichkeit“ für jedes Objekt in das 3D-Modell selbst eingebettet. Jeder Scheitelpunkt des 3D-Modells hatte ein „Windattribut“, das angab, wie stark dieser Scheitelpunkt vom Wind beeinflusst werden sollte. Das ist die angegebene Windempfindlichkeit von 3D-Objekten. Dann mussten wir den Wind selbst erzeugen.
Dazu haben wir ein Bild mit Perlin-Rauschen generiert. Dieses Bild soll einen bestimmten „Windbereich“ abdecken. Stellen Sie sich also ein Bild mit wolkenähnlichem Rauschen vor, das über einen bestimmten rechteckigen Bereich der 3D-Szene gelegt wird. Jeder Pixel (Graustufenwert) dieses Bildes gibt an, wie stark der Wind zu einem bestimmten Zeitpunkt im „umgebenden“ 3D-Bereich ist.
Um den Windeffekt zu erzeugen, wird das Bild im Laufe der Zeit mit konstanter Geschwindigkeit in eine bestimmte Richtung bewegt, die Windrichtung. Damit der „windige Bereich“ nicht die gesamte Szene beeinflusst, wird das Windbild um die Ränder des betroffenen Bereichs gelegt.
Eine einfache Anleitung für 3D-Wind
Erstellen wir nun den Effekt von Wind in einer einfachen 3D-Szene in Three.js.
Wir werden Wind in einem einfachen „prozeduralen Grasfeld“ erzeugen.
Erstellen wir zuerst die Szene. Wir erstellen ein einfaches, flaches Gelände mit Textur. Und jeder Grashalm wird einfach durch einen umgedrehten 3D-Kegel dargestellt.
So erstellen Sie diese einfache Szene in Three.js mit CoffeeScript:
Zuerst richten wir Three.js ein und verbinden es mit der Kamera, dem Maus-Controller und einer Art Lichtquelle:
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()
Die Funktionsaufrufe initGrass und initTerrain füllen die Szene mit Gras und Gelände:
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
Hier erstellen wir ein Raster aus 15 × 15 Grasstücken. Wir fügen jeder Grasposition ein wenig Zufälligkeit hinzu, damit die Grashalme nicht wie Soldaten in einer Reihe stehen, was seltsam aussehen würde.
Dieses Gelände ist nur eine horizontale Ebene, die sich am Fuß der Grashalme befindet (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 )
Bisher haben wir nur eine Three.js-Szene erstellt und ein paar Grashalme aus prozedural generierten umgekehrten Kegeln sowie ein einfaches Gelände hinzugefügt.
Bisher nichts Besonderes.
Jetzt ist es an der Zeit, Wind hinzuzufügen. Zuerst möchten wir die Informationen zur Windempfindlichkeit in das 3D-Modell des Grases einbetten.
Wir werden diese Informationen als benutzerdefiniertes Attribut für jeden Vertex des 3D-Modells des Grases einbetten. Wir verwenden die Regel, dass das untere Ende des Grasmodells (die Spitze des Kegels) keine Empfindlichkeit hat, da es am Boden befestigt ist. Der obere Teil des Grasmodells (Basis des Kegels) hat die maximale Windempfindlichkeit, da er am weitesten vom Boden entfernt ist.
So wird die Funktion instanceGrass neu codiert, um dem 3D-Modell für Gras die Windempfindlichkeit als benutzerdefiniertes Attribut hinzuzufügen.
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
Wir verwenden jetzt ein benutzerdefiniertes Material, windMaterial, anstelle des zuvor verwendeten MeshPhongMaterial. WindMaterial umschließt den WindMeshShader, den wir uns gleich ansehen werden.
Der Code in instanceGrass durchläuft also alle Eckpunkte des Grasmodells und fügt für jeden Eckpunkt ein benutzerdefiniertes Eckpunktattribut namens windFactor hinzu. Dieser windFactor ist für das untere Ende des Grasmodells (wo es den Boden berühren soll) auf 0 gesetzt und hat für das obere Ende des Grasmodells den Wert 1.
Als Nächstes müssen wir den Wind hinzufügen. Wie bereits besprochen, verwenden wir dafür Perlin-Noise. Wir generieren prozedural eine Perlin-Rauschen-Textur.
Der Übersichtlichkeit halber weisen wir diese Textur dem Gelände selbst zu, anstelle der vorherigen grünen Textur. So können Sie sich leichter ein Bild davon machen, was mit dem Wind passiert.
Diese Perlin-Rauschen-Textur deckt also die Ausdehnung unseres Geländes räumlich ab und jedes Pixel der Textur gibt die Windintensität des Geländebereichs an, in den dieses Pixel fällt. Das Geländerechteck wird unser „Windbereich“.
Perlin-Rauschen wird prozedural über einen Shader namens NoiseShader generiert. Dieser Shader verwendet 3D-Simplex-Rauschalgorithmen von: https://github.com/ashima/webgl-noise . Die WebGL-Version wurde wortgetreu aus einem der Three.js-Beispiele von MrDoob übernommen: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.
NoiseShader verwendet die Parameter „time“, „scale“ und „offset“ als Uniforms und gibt eine schöne 2D-Verteilung von Perlin-Rauschen aus.
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) }
...
Wir verwenden diesen Shader, um unser Perlin-Rauschen in eine Textur zu rendern. Dies erfolgt in der Funktion 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 )
Mit dem obigen Code wird noiseMap als Three.js-Renderziel eingerichtet, mit dem NoiseShader ausgestattet und dann mit einer orthografischen Kamera gerendert, um perspektivische Verzerrungen zu vermeiden.
Wie bereits erwähnt, verwenden wir diese Textur jetzt auch als Hauptrenderingtextur für das Gelände. Dies ist für den Windeffekt selbst nicht unbedingt erforderlich. Aber es ist gut, sie zu haben, damit wir besser verstehen, was bei der Winderzeugung passiert.
Hier ist die überarbeitete Funktion initTerrain, die noiseMap als Textur verwendet:
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 )
Nachdem wir die Windtextur erstellt haben, sehen wir uns den WindMeshShader an, der für die Verformung der Grasmodelle durch den Wind verantwortlich ist.
Dazu haben wir den Standard-Shader „MeshPhongMaterial“ von Three.js geändert. Das ist eine gute, schnelle und einfache Möglichkeit, mit einem funktionierenden Shader zu beginnen, ohne bei null anfangen zu müssen.
Wir werden hier nicht den gesamten Shader-Code kopieren (Sie können ihn sich in der Quellcodedatei ansehen), da der größte Teil davon eine Kopie des MeshPhongMaterial-Shaders wäre. Sehen wir uns die geänderten, windbezogenen Teile im Vertex-Shader an.
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;
Dieser Shader berechnet zuerst die Textur-Lookup-Koordinate windUV basierend auf der horizontalen 2D-Position (xz) des Vertex. Diese UV-Koordinate wird verwendet, um die Windstärke vWindForce aus der Perlin-Noise-Windtextur abzurufen.
Dieser vWindForce-Wert wird mit dem oben beschriebenen benutzerdefinierten Attribut windFactor kombiniert, um zu berechnen, wie stark der Scheitelpunkt verformt werden muss. Außerdem gibt es einen globalen Parameter windScale, mit dem die Gesamtstärke des Winds gesteuert wird, und einen Vektor windDirection, der angibt, in welche Richtung die Windverformung erfolgen soll.
So entsteht eine windbasierte Verformung der Grashalme. Wir sind aber noch nicht fertig. Derzeit ist diese Verformung statisch und vermittelt nicht den Eindruck einer windigen Gegend.
Wie bereits erwähnt, müssen wir die Rauschtextur im Laufe der Zeit über den Windbereich verschieben, damit sich das Glas bewegen kann.
Dazu wird im Laufe der Zeit die Uniform vOffset verschoben, die an den NoiseShader übergeben wird. Dies ist ein vec2-Parameter, mit dem wir den Rausch-Offset in einer bestimmten Richtung (unserer Windrichtung) angeben können.
Das geschieht in der Funktion render, die bei jedem Frame aufgerufen wird:
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
...
Das wars auch schon! Wir haben gerade eine Szene mit „prozeduralem Gras“ erstellt, das vom Wind beeinflusst wird.
Staub wird hinzugefügt
Lassen Sie uns die Szene jetzt etwas aufpeppen. Fügen wir ein wenig Staub hinzu, der durch die Luft fliegt, um die Szene interessanter zu machen.
Staub wird schließlich vom Wind beeinflusst, also ist es nur logisch, dass in unserer Windszene Staub herumfliegt.
Staub wird in der Funktion initDust als Partikelsystem eingerichtet.
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
Hier werden 130 Staubpartikel erstellt. Jedes dieser Elemente wird mit einem speziellen WindParticleShader ausgestattet.
In jedem Frame bewegen wir die Partikel mithilfe von CoffeeScript ein wenig, unabhängig vom Wind. Hier ist der 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 )
Außerdem werden wir die Position der einzelnen Partikel entsprechend dem Wind verschieben. Dies geschieht im WindParticleShader. Insbesondere im Vertex-Shader.
Der Code für diesen Shader ist eine modifizierte Version von ParticleMaterial von Three.js. Der Kern sieht so aus:
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;
Dieser Vertex-Shader unterscheidet sich nicht wesentlich von dem, den wir für die windbasierte Verformung von Gras verwendet haben. Die Perlin-Rauschen-Textur wird als Eingabe verwendet und je nach Position des Staubs in der Welt wird ein vWindForce-Wert in der Rauschen-Textur gesucht. Anschließend wird dieser Wert verwendet, um die Position des Staubpartikels zu ändern.
Riders On The Storm
Die abenteuerlichste unserer WebGL-Szenen war wahrscheinlich die letzte Szene, die Sie sehen können, wenn Sie sich durch den Ballon in das Auge des Tornados klicken, um das Ende Ihrer Reise auf der Website und ein exklusives Video der bevorstehenden Veröffentlichung zu erreichen.
Als wir diese Szene erstellt haben, war uns klar, dass wir ein zentrales Element für die Erfahrung brauchten, das eine Wirkung erzielen würde. Der wirbelnde Tornado sollte im Mittelpunkt stehen und Ebenen mit anderen Inhalten sollten dieses Element einrahmen, um einen dramatischen Effekt zu erzielen. Dazu haben wir um diesen seltsamen Shader herum ein Filmstudio-Set gebaut.
Wir haben einen gemischten Ansatz verwendet, um das realistische Composite zu erstellen. Einige waren visuelle Tricks wie Lichtformen, um einen Lens-Flare-Effekt zu erzeugen, oder Regentropfen, die als Ebenen über der Szene animiert werden, die du gerade ansiehst. In anderen Fällen haben wir flache Oberflächen so gezeichnet, dass sie sich zu bewegen scheinen, wie die tief fliegenden Wolkenschichten, die sich gemäß einem Partikelsystemcode bewegen. Die Trümmerteile, die um den Tornado herumwirbeln, waren Ebenen in einer 3D-Szene, die so sortiert waren, dass sie sich vor und hinter dem Tornado bewegen.
Der Hauptgrund, warum wir die Szene so aufbauen mussten, war, dass wir genügend GPU-Leistung für den Tornado-Shader benötigten, um ihn mit den anderen Effekten in Einklang zu bringen. Anfangs hatten wir große Probleme mit der GPU-Auslastung, aber später wurde diese Szene optimiert und war dann weniger anspruchsvoll als die Hauptszenen.
Anleitung: Der Storm-Shader
Für die finale Sturmsequenz wurden viele verschiedene Techniken kombiniert. Das Herzstück dieser Arbeit war jedoch ein benutzerdefinierter GLSL-Shader, der wie ein Tornado aussieht. Wir haben viele verschiedene Techniken ausprobiert, von Vertex-Shadern, um interessante geometrische Strudel zu erzeugen, über partikelbasierte Animationen bis hin zu 3D-Animationen von verdrehten geometrischen Formen. Keiner der Effekte schien das Gefühl eines Tornados zu vermitteln oder erforderte zu viel Rechenleistung.
Die Antwort lieferte uns schließlich ein völlig anderes Projekt. Ein paralleles Projekt mit Spielen für die Wissenschaft zur Kartierung des Gehirns der Maus vom Max-Planck-Institut (brainflight.org) hatte interessante visuelle Effekte erzeugt. Wir hatten es geschafft, mit einem benutzerdefinierten volumetrischen Shader Filme vom Inneren eines Mausneurons zu erstellen.
Wir haben festgestellt, dass das Innere einer Gehirnzelle ein bisschen wie der Trichter eines Tornados aussieht. Da wir eine volumetrische Technik verwendeten, wussten wir, dass wir diesen Shader aus allen Richtungen im Raum betrachten konnten. Wir könnten das Rendering des Shaders so einstellen, dass es mit der Sturmszene kombiniert wird, insbesondere wenn es zwischen Wolkenschichten und einem dramatischen Hintergrund liegt.
Die Shader-Technik beinhaltet einen Trick, bei dem im Grunde ein einzelner GLSL-Shader verwendet wird, um ein ganzes Objekt mit einem vereinfachten Render-Algorithmus namens Raymarching-Rendering mit einem Distanzfeld zu rendern. Bei dieser Technik wird ein Pixel-Shader erstellt, der für jeden Punkt auf dem Bildschirm die kürzeste Entfernung zu einer Oberfläche schätzt.
Eine gute Referenz zum Algorithmus finden Sie in der Übersicht von iq: Rendering Worlds With Two Triangles - Iñigo Quilez. In der Shader-Galerie auf glsl.heroku.com finden Sie viele Beispiele für diese Technik, mit denen Sie experimentieren können.
Das Herzstück des Shaders beginnt mit der Hauptfunktion, die die Kameratransformationen einrichtet und eine Schleife startet, die wiederholt den Abstand zu einer Oberfläche auswertet. Der Aufruf „RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier )“ ist der Ort, an dem die eigentliche Raymarching-Berechnung stattfindet.
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
}
Die Idee ist, dass wir beim Vordringen in die Form des Tornados dem endgültigen Farbwert des Pixels regelmäßig Farbbeiträge sowie Beiträge zur Deckkraft entlang des Strahls hinzufügen. Dadurch entsteht eine weiche, vielschichtige Textur für den Tornado.
Der nächste Kernaspekt des Tornados ist die eigentliche Form, die durch die Zusammensetzung einer Reihe von Funktionen erstellt wird. Es beginnt mit einem Kegel, der mit Rauschen kombiniert wird, um eine organische, raue Kante zu erzeugen. Anschließend wird er entlang seiner Hauptachse verdreht und im Laufe der Zeit gedreht.
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;
}
Die Erstellung dieser Art von Shader ist kompliziert. Neben den Problemen, die mit der Abstraktion der von Ihnen erstellten Vorgänge verbunden sind, gibt es ernsthafte Probleme mit der Optimierung und der plattformübergreifenden Kompatibilität, die Sie verfolgen und lösen müssen, bevor Sie die Arbeit in der Produktion verwenden können.
Der erste Teil des Problems: die Optimierung dieses Shaders für unsere Szene. Um dieses Problem zu beheben, brauchten wir einen „sicheren“ Ansatz für den Fall, dass der Shader zu schwer ist. Dazu haben wir den Tornado-Shader mit einer anderen Auflösung als den Rest der Szene zusammengesetzt. Dies stammt aus der Datei stormTest.coffee (ja, das war ein Test!).
Wir beginnen mit einem renderTarget, das der Breite und Höhe der Szene entspricht, damit die Auflösung des Tornado-Shaders unabhängig von der Szene ist. Anschließend wird das Downsampling der Auflösung des Sturmeffekts dynamisch anhand der Framerate festgelegt.
...
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
Schließlich wird der Tornado mit einem vereinfachten sal2x-Algorithmus auf dem Bildschirm gerendert (um den blockigen Look zu vermeiden), @Zeile 1107 in stormTest.coffee. Das bedeutet, dass wir im schlimmsten Fall einen unschärferen Tornado haben, aber zumindest funktioniert es, ohne dass der Nutzer die Kontrolle verliert.
Der nächste Optimierungsschritt erfordert einen Blick auf den Algorithmus. Der wichtigste Rechenfaktor im Shader ist die Iteration, die für jedes Pixel ausgeführt wird, um die Entfernung der Oberflächenfunktion zu schätzen: die Anzahl der Iterationen der Raymarching-Schleife. Mit einer größeren Schrittgröße könnten wir eine Schätzung der Tornadooberfläche mit weniger Iterationen erhalten, während wir uns außerhalb der wolkenartigen Oberfläche befinden. Im Inneren würden wir die Schrittgröße verringern, um die Genauigkeit zu erhöhen und Werte zu mischen, um den Nebeleffekt zu erzeugen. Auch das Erstellen eines Begrenzungszylinders, um eine Tiefenschätzung für den geworfenen Strahl zu erhalten, hat zu einer guten Beschleunigung geführt.
Der nächste Teil des Problems bestand darin, sicherzustellen, dass dieser Shader auf verschiedenen Grafikkarten ausgeführt werden kann. Wir haben jedes Mal Tests durchgeführt und ein Gespür für die Art von Kompatibilitätsproblemen entwickelt, die auftreten können. Der Grund dafür, dass wir nicht viel besser als die Intuition waren, ist, dass wir nicht immer gute Debugging-Informationen zu den Fehlern erhalten konnten. Ein typisches Szenario ist ein GPU-Fehler mit wenig weiteren Informationen oder sogar ein Systemabsturz.
Kompatibilitätsprobleme zwischen Videoboards hatten ähnliche Lösungen: Achten Sie darauf, dass statische Konstanten mit dem genauen Datentyp eingegeben werden, wie definiert, z. B. 0.0 für Float und 0 für Int. Seien Sie vorsichtig, wenn Sie längere Funktionen schreiben. Es ist besser, die Dinge in mehrere einfachere Funktionen und Zwischenvariablen aufzuteilen, da die Compiler bestimmte Fälle nicht richtig zu verarbeiten schienen. Achten Sie darauf, dass alle Texturen eine Zweierpotenz haben, nicht zu groß sind und dass Sie beim Suchen von Texturdaten in einer Schleife vorsichtig sind.
Die größten Kompatibilitätsprobleme hatten wir mit dem Lichteffekt für den Sturm. Wir haben eine vorgefertigte Textur verwendet, die um den Tornado gewickelt ist, damit wir die Wirbel einfärben können. Der Effekt war wunderschön und es war einfach, den Tornado in die Farben der Szene einzufügen, aber es dauerte lange, bis er auf anderen Plattformen lief.
Die mobile Website
Die mobile Version konnte nicht einfach eine direkte Übersetzung der Desktopversion sein, da die Technologie- und Verarbeitungsanforderungen zu hoch waren. Wir mussten etwas Neues entwickeln, das speziell auf mobile Nutzer ausgerichtet ist.
Wir dachten, es wäre cool, die Carnival Photo-Booth vom Desktop als mobile Webanwendung zu haben, die die mobile Kamera des Nutzers verwendet. So etwas hatten wir bis dahin noch nicht gesehen.
Für den besonderen Touch haben wir 3D-Transformationen in CSS3 programmiert. Durch die Verknüpfung mit dem Gyroskop und dem Beschleunigungsmesser konnten wir dem Erlebnis viel Tiefe verleihen. Die Website reagiert darauf, wie du dein Smartphone hältst, bewegst und ansiehst.
Beim Verfassen dieses Artikels dachten wir, es wäre sinnvoll, Ihnen einige Tipps zu geben, wie Sie den Entwicklungsprozess für Mobilgeräte reibungslos gestalten können. Und los gehts! Sehen Sie sich an, was Sie daraus lernen können.
Tipps und Tricks für Mobilgeräte
Preloader sind erforderlich und sollten nicht vermieden werden. Wir wissen, dass Letzteres manchmal passiert. Das liegt vor allem daran, dass Sie die Liste der vorab geladenen Elemente im Laufe des Projekts pflegen müssen. Außerdem ist nicht klar, wie der Ladefortschritt berechnet werden soll, wenn verschiedene Ressourcen gleichzeitig abgerufen werden. Hier kommt unsere benutzerdefinierte und sehr allgemeine abstrakte Klasse „Task“ ins Spiel. Die Hauptidee besteht darin, eine unendlich verschachtelte Struktur zu ermöglichen, in der eine Aufgabe eigene Unteraufgaben haben kann, die wiederum eigene Unteraufgaben haben können usw. Außerdem wird der Fortschritt jeder Aufgabe im Verhältnis zum Fortschritt ihrer Unteraufgaben (aber nicht zum Fortschritt der übergeordneten Aufgabe) berechnet. Da alle MainPreloadTask-, AssetPreloadTask- und TemplatePreFetchTask-Klassen von Task abgeleitet sind, haben wir eine Struktur erstellt, die so aussieht:
Dank dieses Ansatzes und der Task-Klasse können wir den globalen Fortschritt (MainPreloadTask), den Fortschritt von Assets (AssetPreloadTask) oder den Fortschritt beim Laden von Vorlagen (TemplatePreFetchTask) ganz einfach ermitteln. Sogar der Fortschritt einer bestimmten Datei. Sehen Sie sich dazu die Task-Klasse unter /m/javascripts/raw/util/Task.js und die tatsächlichen Task-Implementierungen unter /m/javascripts/preloading/task an. Hier ist ein Beispiel für die Einrichtung der Klasse /m/javascripts/preloading/task/MainPreloadTask.js, die als ultimativer Preloading-Wrapper dient:
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);
}
}
})
]);
In der Klasse „/m/javascripts/preloading/task/subtask/AssetPreloadTask.js“ ist neben der Kommunikation mit „MainPreloadTask“ (über die gemeinsame Task-Implementierung) auch zu beachten, wie wir plattformabhängige Assets laden. Im Grunde haben wir vier Arten von Bildern. Mobilgeräte Standard (.ext, wobei ext die Dateiendung ist, normalerweise .png oder .jpg), Mobilgeräte Retina (-2x.ext), Tablet Standard (-tab.ext) und Tablet Retina (-tab-2x.ext). Anstatt die Erkennung in „MainPreloadTask“ durchzuführen und vier Asset-Arrays hartzucodieren, geben wir einfach den Namen und die Erweiterung des vorab zu ladenden Assets an und ob das Asset plattformabhängig ist (responsive = true / false). Anschließend generiert der AssetPreloadTask den Dateinamen für uns:
resolveAssetUrl : function(assetName, extension, responsive) {
return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' + extension;
}
Weiter unten in der Klassenkette sieht der eigentliche Code, der das Asset-Preloading durchführt, so aus (/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);
}
Anleitung: HTML5 Photo Booth (iOS6/Android)
Bei der Entwicklung von OZ Mobile haben wir festgestellt, dass wir viel Zeit mit der Fotobox verbracht haben, anstatt zu arbeiten :D Das lag einfach daran, dass es Spaß macht. Deshalb haben wir eine Demo für Sie erstellt, mit der Sie experimentieren können.
Hier können Sie sich eine Live-Demo ansehen (auf Ihrem iPhone oder Android-Smartphone):
http://u9html5rocks.appspot.com/demos/mobile_photo_booth
Für die Einrichtung benötigen Sie eine kostenlose Google App Engine-Anwendungsinstanz, auf der Sie das Backend ausführen können. Der Frontend-Code ist nicht komplex, aber es gibt ein paar mögliche Fallstricke. Sehen wir uns diese Grundsätze einmal an:
- Zulässiger Bilddateityp
Wir möchten, dass Nutzer nur Bilder hochladen können (da es sich um eine Fotobox und nicht um eine Videobox handelt). Theoretisch können Sie den Filter einfach so in HTML angeben:
input id="fileInput" class="fileInput" type="file" name="file" accept="image/*"Das scheint jedoch nur unter iOS zu funktionieren. Daher müssen wir eine zusätzliche Prüfung mit dem regulären Ausdruck hinzufügen, sobald eine Datei ausgewählt wurde:
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();
}
}
});
- Upload oder Dateiauswahl abbrechen Eine weitere Unstimmigkeit, die uns während des Entwicklungsprozesses aufgefallen ist, ist die Art und Weise, wie verschiedene Geräte eine abgebrochene Dateiauswahl melden. iOS-Smartphones und -Tablets tun nichts, sie melden überhaupt nichts. In diesem Fall ist also keine besondere Aktion erforderlich. Android-Smartphones lösen die Funktion „add()“ jedoch trotzdem aus, auch wenn keine Datei ausgewählt ist. So können Sie das berücksichtigen:
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();
}
}
Der Rest funktioniert plattformübergreifend ziemlich reibungslos. Spaß haben
Fazit
Angesichts der enormen Größe von „Find Your Way To Oz“ und der Vielzahl der beteiligten Technologien konnten wir in diesem Artikel nur einige der von uns verwendeten Ansätze behandeln.
Wenn Sie sich für das gesamte Projekt interessieren, können Sie sich den vollständigen Quellcode von Find Your Way To Oz unter diesem Link ansehen.
Gutschriften
Hier findest du die vollständige Liste der Mitwirkenden.
Verweise
- CoffeeScript – http://coffeescript.org/
- Backbone.js – http://backbonejs.org/
- Three.js – http://mrdoob.github.com/three.js/
- Max-Planck-Institut (brainflight.org) – http://brainflight.org/