Introduzione
"Find Your Way to Oz" è un nuovo Chrome Experiment di Google portato sul web da Disney. Ti consente di intraprendere un viaggio interattivo attraverso un circo del Kansas, che ti porta nella terra di Oz dopo essere stato travolto da una violenta tempesta.
Il nostro obiettivo era combinare la ricchezza del cinema con le funzionalità tecniche del browser per creare un'esperienza divertente e immersiva con cui gli utenti potessero creare un forte legame.
Il lavoro è un po' troppo grande per essere descritto nella sua interezza in questo articolo, quindi abbiamo approfondito ed estrapolato alcuni capitoli della storia della tecnologia che riteniamo interessanti. Durante il percorso abbiamo estratto alcuni tutorial mirati di difficoltà crescente.
Molte persone hanno lavorato duramente per rendere possibile questa esperienza: troppe per essere elencate qui. Visita il sito per consultare la pagina dei riconoscimenti nella sezione del menu per la storia completa.
Uno sguardo dietro le quinte
Find Your Way to Oz su computer è un mondo ricco e immersivo. Utilizziamo il 3D e diversi livelli di effetti tradizionali ispirati al cinema che si combinano per creare una scena quasi realistica. Le tecnologie più importanti sono WebGL con Three.js, shader personalizzati ed elementi animati DOM che utilizzano le funzionalità CSS3. Inoltre, l'API getUserMedia (WebRTC) per esperienze interattive che consentono all'utente di aggiungere la propria immagine direttamente dalla webcam e WebAudio per l'audio 3D.
Ma la magia di un'esperienza tecnologica come questa sta nel modo in cui si uniscono. Questa è anche una delle sfide principali: come unire effetti visivi ed elementi interattivi in un'unica scena per creare un insieme coerente? Questa complessità visiva era difficile da gestire, rendendo difficile capire in quale fase di sviluppo ci trovassimo in un determinato momento.
Per risolvere il problema degli effetti visivi e dell'ottimizzazione interconnessi, abbiamo fatto un uso massiccio di un pannello di controllo che acquisiva tutte le impostazioni pertinenti che stavamo esaminando in quel momento. La scena poteva essere modificata in tempo reale nel browser per qualsiasi aspetto, dalla luminosità alla profondità di campo, alla gamma e così via. Chiunque poteva provare a modificare i valori dei parametri significativi dell'esperienza e partecipare alla scoperta di ciò che funzionava meglio.
Prima di svelare il nostro segreto, vogliamo avvisarti che potrebbe verificarsi un arresto anomalo, proprio come se stessi armeggiando con il motore di un'auto. Assicurati di non avere nulla di importante in corso, visita l'URL principale del sito e aggiungi ?debug=on all'indirizzo. Attendi il caricamento del sito e, una volta all'interno, premi il tasto Ctrl-I per visualizzare un menu a discesa sul lato destro. Se deselezioni l'opzione "Esci dal percorso della videocamera", puoi utilizzare i tasti A, W, S, D e il mouse per spostarti liberamente nello spazio.
Non esamineremo tutte le impostazioni qui, ma ti invitiamo a sperimentare: i tasti mostrano impostazioni diverse in scene diverse. Nella sequenza finale della tempesta è presente un tasto aggiuntivo: Ctrl-A con cui puoi attivare/disattivare la riproduzione dell'animazione e volare. In questa scena, se premi Esc (per uscire dalla funzionalità di blocco del mouse) e premi di nuovo Ctrl-I, puoi accedere alle impostazioni specifiche della scena della tempesta. Dai un'occhiata in giro e scatta qualche bella foto da cartolina come quella qui sotto.
Per farlo e per assicurarci che fosse abbastanza flessibile per le nostre esigenze, abbiamo utilizzato una bella libreria chiamata dat.gui (vedi qui per un tutorial precedente su come utilizzarla). Ci ha permesso di modificare rapidamente le impostazioni esposte ai visitatori del sito.
Un po' come il matte painting
In molti film e animazioni Disney classici, la creazione di scene significava combinare diversi livelli. C'erano livelli di live action, animazione su celluloide, persino set fisici e, sopra, livelli creati dipingendo su vetro: una tecnica chiamata matte painting.
Per molti aspetti, la struttura dell'esperienza che abbiamo creato è simile, anche se alcuni degli "strati" sono molto più di semplici immagini statiche. In realtà, influiscono sull'aspetto degli elementi in base a calcoli più complessi. Tuttavia, almeno a livello generale, abbiamo a che fare con visualizzazioni, composte una sopra l'altra. In alto vedi un livello UI, con una scena 3D sottostante, composta a sua volta da diversi componenti della scena.
Il livello di interfaccia superiore è stato creato utilizzando DOM e CSS 3, il che significa che la modifica delle interazioni poteva essere eseguita in molti modi indipendentemente dall'esperienza 3D con la comunicazione tra i due in base a un elenco selezionato di eventi. Questa comunicazione utilizza l'evento HTML5 Backbone Router + onHashChange che controlla l'area da animare in entrata/uscita. (origine del progetto: /develop/coffee/router/Router.coffee).
Tutorial: Sprite Sheet e supporto per Retina
Una divertente tecnica di ottimizzazione su cui abbiamo fatto affidamento per l'interfaccia è stata quella di combinare le numerose immagini di overlay dell'interfaccia in un unico PNG per ridurre le richieste al server. In questo progetto l'interfaccia era composta da oltre 70 immagini (senza contare le texture 3D) caricate tutte in anticipo per ridurre la latenza del sito web. Puoi visualizzare lo sprite sheet attivo qui:
Display normale - http://findyourwaytooz.com/img/home/interface_1x.png Display Retina - http://findyourwaytooz.com/img/home/interface_2x.png
Ecco alcuni suggerimenti su come abbiamo sfruttato l'utilizzo degli Sprite Sheet e su come utilizzarli per i dispositivi Retina e ottenere un'interfaccia il più nitida e pulita possibile.
Creazione di fogli sprite
Per creare gli SpriteSheet abbiamo utilizzato TexturePacker, che genera l'output in qualsiasi formato necessario. In questo caso, abbiamo esportato come EaselJS, che è molto pulito e avrebbe potuto essere utilizzato anche per creare sprite animati.
Utilizzo dello Sprite Sheet generato
Una volta creato lo Sprite Sheet, dovresti vedere un file JSON simile al seguente:
{
"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]
},
}
Dove:
- image si riferisce all'URL dello sprite sheet
- "frames" sono le coordinate di ogni elemento UI [x, y, larghezza, altezza]
- animazioni sono i nomi di ogni asset
Tieni presente che abbiamo utilizzato le immagini ad alta densità per creare lo Sprite Sheet, poi abbiamo creato la versione normale ridimensionandola alla metà delle sue dimensioni.
Riepilogo
Ora che è tutto pronto, ci serve solo uno snippet JavaScript per utilizzarlo.
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);
};
Ecco come utilizzarlo:
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'));
Per saperne di più sulle densità di pixel variabili, puoi leggere questo articolo di Boris Smus.
La pipeline dei contenuti 3D
L'esperienza dell'ambiente è configurata su un livello WebGL. Quando pensi a una scena 3D, una delle domande più difficili è come assicurarti di poter creare contenuti che consentano il massimo potenziale espressivo dal punto di vista della modellazione, dell'animazione e degli effetti. Per molti aspetti, il fulcro di questo problema è la pipeline dei contenuti: un processo concordato da seguire per creare contenuti per la scena 3D.
Volevamo creare un mondo che lasciasse a bocca aperta, quindi avevamo bisogno di un processo solido che consentisse agli artisti 3D di crearlo. Dovevamo dare loro la massima libertà espressiva possibile nel software di modellazione e animazione 3D e noi dovevamo eseguire il rendering sullo schermo tramite il codice.
Stavamo lavorando a questo tipo di problema da un po' di tempo perché ogni volta che creavamo un sito 3D in passato avevamo riscontrato limitazioni negli strumenti che potevamo utilizzare. Abbiamo quindi creato questo strumento, chiamato 3D Librarian, un progetto di ricerca interno. ed era quasi pronto per essere applicato a un lavoro reale.
Questo strumento ha una certa storia: originariamente era per Flash e consentiva di importare una grande scena Maya come un unico file compresso ottimizzato per il runtime di decompressione. Il motivo per cui era ottimale era che racchiudeva efficacemente la scena praticamente nella stessa struttura di dati che viene manipolata durante il rendering e l'animazione. Il file richiede un'analisi minima quando viene caricato. La decompressione in Flash era piuttosto rapida perché il file era in formato AMF, che Flash poteva decomprimere in modo nativo. L'utilizzo dello stesso formato in WebGL richiede un po' più di lavoro sulla CPU. In effetti, abbiamo dovuto ricreare un livello di codice JavaScript per l'unboxing dei dati, che essenzialmente decomprime i file e ricrea le strutture di dati necessarie per il funzionamento di WebGL. La decompressione dell'intera scena 3D è un'operazione leggermente pesante per la CPU: la decompressione della scena 1 in Find Your Way To Oz richiede circa 2 secondi su una macchina di fascia medio-alta. Pertanto, questa operazione viene eseguita utilizzando la tecnologia Web Workers, al momento della "configurazione della scena" (prima che la scena venga effettivamente avviata), in modo da non bloccare l'esperienza per l'utente.
Questo pratico strumento può importare la maggior parte della scena 3D: modelli, texture, animazioni di scheletri. Puoi creare un singolo file di libreria, che può essere caricato dal motore 3D. Inserisci tutti i modelli di cui hai bisogno nella scena all'interno di questa libreria e, voilà, li generi nella scena.
Tuttavia, abbiamo riscontrato un problema: ora avevamo a che fare con WebGL, l'ultimo arrivato. Era un progetto piuttosto difficile: stava definendo lo standard per le esperienze 3D basate su browser. Abbiamo quindi creato un livello Javascript ad hoc che prendesse i file di scene 3D compressi di 3D Librarian e li traducesse correttamente in un formato comprensibile per WebGL.
Tutorial: Let There Be Wind
Un tema ricorrente in "Find Your Way To Oz" era il vento. Un filo della trama è strutturato in modo da essere un crescendo di vento.
La prima scena del carnevale è relativamente tranquilla. Passando attraverso le varie scene, l'utente sperimenta un vento progressivamente più forte, che culmina nella scena finale, la tempesta.
Per questo motivo, era importante fornire un effetto vento immersivo.
Per creare questo effetto, abbiamo inserito nelle tre scene del carnevale oggetti morbidi che dovrebbero essere influenzati dal vento, come tende, bandiere, la superficie della cabina fotografica e il palloncino stesso.
Oggi i giochi per computer sono generalmente basati su un motore fisico di base. Quindi, quando un oggetto morbido deve essere simulato nel mondo 3D, viene eseguita una simulazione fisica completa, creando un comportamento morbido credibile.
In WebGL / JavaScript non abbiamo (ancora) il lusso di eseguire una simulazione fisica completa. Quindi, in Oz abbiamo dovuto trovare un modo per creare l'effetto del vento, senza simularlo effettivamente.
Abbiamo incorporato le informazioni sulla "sensibilità al vento" per ogni oggetto nel modello 3D stesso. Ogni vertice del modello 3D aveva un "attributo vento" che specificava l'impatto del vento su quel vertice. Quindi, questa sensibilità al vento specificata degli oggetti 3D. Poi abbiamo dovuto creare il vento.
Per farlo, abbiamo generato un'immagine contenente il rumore di Perlin. Questa immagine ha lo scopo di coprire una determinata "area del vento". Un buon modo per pensarla è immaginare un'immagine di rumore simile a una nuvola che viene sovrapposta a una determinata area rettangolare della scena 3D. Ogni pixel, valore del livello di grigio, di questa immagine specifica l'intensità del vento in un determinato momento nell'area 3D "circostante".
Per produrre l'effetto del vento, l'immagine viene spostata nel tempo a velocità costante in una direzione specifica, ovvero la direzione del vento. Per assicurarci che l'area ventosa non influisca su tutto ciò che si trova nella scena, avvolgiamo l'immagine del vento attorno ai bordi, limitandola all'area di effetto.
Un semplice tutorial sul vento 3D
Ora creiamo l'effetto del vento in una semplice scena 3D in Three.js.
Creeremo il vento in un semplice "campo d'erba procedurale".
Per prima cosa, creiamo la scena. Avremo un terreno piatto semplice e con texture. Ogni ciuffo d'erba verrà rappresentato semplicemente con un cono 3D capovolto.
Ecco come creare questa semplice scena in Three.js utilizzando CoffeeScript.
Per prima cosa, configureremo Three.js e lo collegheremo alla videocamera, al controller del mouse e a una luce di qualche tipo:
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()
Le chiamate di funzione initGrass e initTerrain completano la scena rispettivamente con erba e terreno:
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
Qui stiamo creando una griglia di 15 x 15 bit di erba. Aggiungiamo un po' di randomizzazione a ogni posizione dell'erba, in modo che non si allinei come i soldati, il che sembrerebbe strano.
Questo terreno è solo un piano orizzontale, posizionato alla base dei fili d'erba (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 )
Quindi, quello che abbiamo fatto finora è semplicemente creare una scena Three.js e aggiungere alcuni ciuffi d'erba, fatti di coni invertiti generati in modo procedurale, e un terreno semplice.
Niente di speciale finora.
Ora è il momento di iniziare ad aggiungere il vento. Innanzitutto, vogliamo incorporare le informazioni sulla sensibilità al vento nel modello 3D dell'erba.
Incorporeremo queste informazioni come attributo personalizzato per ogni vertice del modello 3D dell'erba. Utilizzeremo la regola secondo cui l'estremità inferiore del modello di erba (la punta del cono) ha sensibilità zero, poiché è attaccata al terreno. La parte superiore del modello di erba (base del cono) ha la massima sensibilità al vento, in quanto è la parte più lontana dal suolo.
Ecco come viene ricodificata la funzione instanceGrass per aggiungere la sensibilità al vento come attributo personalizzato per il modello 3D dell'erba.
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
Ora utilizziamo un materiale personalizzato, windMaterial, anziché il MeshPhongMaterial utilizzato in precedenza. WindMaterial racchiude WindMeshShader, che vedremo tra un minuto.
Quindi, il codice in instanceGrass esegue un loop su tutti i vertici del modello di erba e, per ogni vertice, aggiunge un attributo di vertice personalizzato, chiamato windFactor. Questo windFactor è impostato su 0 per l'estremità inferiore del modello di erba (dove dovrebbe toccare il terreno) e su 1 per l'estremità superiore del modello di erba.
L'altro elemento di cui abbiamo bisogno è l'aggiunta del vento effettivo alla nostra scena. Come già detto, utilizzeremo il rumore di Perlin. Genereremo in modo procedurale una texture di rumore di Perlin.
Per maggiore chiarezza, assegneremo questa texture al terreno stesso, al posto della precedente texture verde. In questo modo sarà più facile farsi un'idea di cosa sta succedendo con il vento.
Quindi, questa texture di rumore di Perlin coprirà spazialmente l'estensione del nostro terreno e ogni pixel della texture specificherà l'intensità del vento dell'area del terreno in cui cade quel pixel. Il rettangolo del terreno sarà la nostra "area del vento".
Il rumore di Perlin viene generato in modo procedurale tramite uno shader, chiamato NoiseShader. Questo shader utilizza algoritmi di rumore simplex 3D di: https://github.com/ashima/webgl-noise . La versione WebGL di questo esempio è stata presa alla lettera da uno degli esempi di Three.js di MrDoob, all'indirizzo: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.
NoiseShader accetta un insieme di parametri di tempo, scala e offset, come uniform, e genera una bella distribuzione 2D del rumore di 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) }
...
Utilizzeremo questo shader per eseguire il rendering del nostro rumore di Perlin in una texture. Questa operazione viene eseguita nella funzione 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 )
Il codice riportato sopra configura noiseMap come target di rendering di Three.js, lo dota di NoiseShader e poi ne esegue il rendering con una fotocamera ortografica, in modo da evitare distorsioni prospettiche.
Come già detto, ora utilizzeremo questa texture anche come texture di rendering principale per il terreno. Questo non è strettamente necessario per il funzionamento dell'effetto vento. Tuttavia, è utile per comprendere meglio visivamente cosa sta succedendo con la generazione eolica.
Ecco la funzione initTerrain rielaborata, che utilizza noiseMap come 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 )
Ora che abbiamo la nostra texture del vento, diamo un'occhiata a WindMeshShader, che è responsabile della deformazione dei modelli di erba in base al vento.
Per creare questo shader, siamo partiti dallo shader MeshPhongMaterial standard di Three.js e lo abbiamo modificato. Questo è un buon modo, rapido e approssimativo, per iniziare a utilizzare uno shader funzionante, senza dover partire da zero.
Non copieremo l'intero codice dello shader qui (puoi consultarlo nel file del codice sorgente), perché la maggior parte sarebbe una replica dello shader MeshPhongMaterial. Ma diamo un'occhiata alle parti modificate relative al vento nel Vertex Shader.
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;
Quindi, questo shader calcola prima la coordinata di ricerca della texture windUV, in base alla posizione 2D, xz (orizzontale) del vertice. Questa coordinata UV viene utilizzata per cercare la forza del vento, vWindForce, dalla texture del vento con rumore di Perlin.
Questo valore vWindForce viene composto con l'attributo personalizzato windFactor specifico del vertice, descritto sopra, per calcolare la quantità di deformazione necessaria per il vertice. Abbiamo anche un parametro globale windScale per controllare la forza complessiva del vento e un vettore windDirection che specifica in quale direzione deve avvenire la deformazione del vento.
In questo modo, l'erba si deforma in base al vento. Tuttavia, non abbiamo ancora finito. Al momento, questa deformazione è statica e non trasmette l'effetto di un'area ventosa.
Come abbiamo accennato, dovremo far scorrere la texture del rumore nel tempo, nell'area del vento, in modo che il vetro possa ondeggiare.
Per farlo, nel tempo viene spostata la variabile uniforme vOffset passata a NoiseShader. Si tratta di un parametro vec2 che ci consentirà di specificare l'offset del rumore lungo una determinata direzione (la direzione del vento).
Lo facciamo nella funzione render, che viene chiamata a ogni 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
...
E questo è tutto. Abbiamo appena creato una scena con "erba procedurale" influenzata dal vento.
Aggiunta di polvere al mix
Ora rendiamo la nostra scena un po' più interessante. Aggiungiamo un po' di polvere volante per rendere la scena più interessante.
Dopotutto, la polvere dovrebbe essere influenzata dal vento, quindi è perfettamente logico che la polvere voli nella nostra scena con il vento.
La polvere viene configurata nella funzione initDust come sistema di particelle.
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
Qui vengono create 130 particelle di polvere. Tieni presente che ognuno di questi elementi è dotato di uno speciale WindParticleShader.
Ora, in ogni fotogramma, sposteremo un po' le particelle, utilizzando CoffeeScript, indipendentemente dal vento. Ecco il codice.
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 )
Inoltre, compenseremo la posizione di ogni particella in base al vento. Questa operazione viene eseguita in WindParticleShader. In particolare nel vertex shader.
Il codice di questo shader è una versione modificata di ParticleMaterial di Three.js. Ecco come appare il suo nucleo:
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;
Questo vertex shader non è molto diverso da quello che avevamo per la deformazione dell'erba basata sul vento. Utilizza la texture del rumore di Perlin come input e, a seconda della posizione della polvere nel mondo, cerca un valore vWindForce nella texture del rumore. Poi, utilizza questo valore per modificare la posizione della particella di polvere.
Riders On The Storm
La più avventurosa delle nostre scene WebGL è stata probabilmente l'ultima, che puoi vedere se fai clic sul palloncino per entrare nell'occhio del tornado e raggiungere la fine del tuo viaggio nel sito, oltre a un video esclusivo della prossima uscita.
Quando abbiamo creato questa scena, sapevamo che dovevamo avere un elemento centrale dell'esperienza che fosse di grande impatto. Il tornado rotante fungeva da elemento centrale e gli strati di altri contenuti avrebbero modellato questa funzionalità per creare un effetto drammatico. Per farlo, abbiamo costruito l'equivalente di un set cinematografico attorno a questo strano shader.
Abbiamo utilizzato un approccio misto per creare l'immagine composita realistica. Alcuni erano trucchi visivi, come forme di luce per creare un effetto di riflesso o gocce di pioggia che si animano come livelli sopra la scena che stai guardando. In altri casi, abbiamo disegnato superfici piane che sembravano muoversi, come gli strati di nuvole basse che si muovono in base a un codice del sistema di particelle. I detriti che orbitano attorno al tornado erano invece livelli di una scena 3D ordinati in modo da muoversi davanti e dietro il tornado.
Il motivo principale per cui abbiamo dovuto creare la scena in questo modo è stato quello di assicurarci di avere una GPU sufficiente per gestire lo shader del tornado in equilibrio con gli altri effetti che stavamo applicando. Inizialmente abbiamo avuto grossi problemi di bilanciamento della GPU, ma in seguito questa scena è stata ottimizzata ed è diventata più leggera delle scene principali.
Tutorial: lo shader della tempesta
Per creare la sequenza finale della tempesta sono state combinate molte tecniche diverse, ma il fulcro di questo lavoro è stato uno shader GLSL personalizzato che assomiglia a un tornado. Abbiamo provato molte tecniche diverse, dai vertex shader per creare interessanti vortici geometrici alle animazioni basate su particelle e persino alle animazioni 3D di forme geometriche contorte. Nessuno degli effetti sembrava ricreare la sensazione di un tornado o richiedeva troppa elaborazione.
La risposta è arrivata da un progetto completamente diverso. Un progetto parallelo che coinvolgeva giochi per la scienza per mappare il cervello del topo del Max Planck Institute (brainflight.org) aveva generato effetti visivi interessanti. Eravamo riusciti a creare filmati dell'interno di un neurone di topo utilizzando uno shader volumetrico personalizzato.
Abbiamo scoperto che l'interno di una cellula cerebrale assomiglia un po' all'imbuto di un tornado. E poiché stavamo utilizzando una tecnica volumetrica, sapevamo che potevamo visualizzare questo shader da tutte le direzioni nello spazio. Potremmo impostare il rendering dello shader in modo che si combini con la scena della tempesta, in particolare se inserito tra strati di nuvole e sopra uno sfondo drammatico.
La tecnica dello shader prevede un trucco che utilizza fondamentalmente un singolo shader GLSL per eseguire il rendering di un intero oggetto con un algoritmo di rendering semplificato chiamato rendering ray marching con un campo di distanza. In questa tecnica viene creato un pixel shader che stima la distanza più vicina a una superficie per ogni punto dello schermo.
Un buon riferimento all'algoritmo è disponibile nella panoramica di iq: Rendering Worlds With Two Triangles - Iñigo Quilez. Inoltre, esplorando la galleria di shader su glsl.heroku.com, puoi trovare molti esempi di questa tecnica con cui sperimentare.
Il cuore dello shader inizia con la funzione principale, che configura le trasformazioni della videocamera ed entra in un loop che valuta ripetutamente la distanza da una superficie. La chiamata RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) è il punto in cui avviene il calcolo principale del 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'idea è che, man mano che avanziamo nella forma del tornado, aggiungiamo regolarmente contributi di colore al valore di colore finale del pixel, nonché contributi all'opacità lungo il raggio. In questo modo, la texture del tornado assume una qualità morbida e stratificata.
Il successivo aspetto fondamentale del tornado è la forma vera e propria, che viene creata componendo una serie di funzioni. Si tratta di un cono, che viene combinato con il rumore per creare un bordo irregolare organico, quindi viene attorcigliato lungo il suo asse principale e ruotato nel tempo.
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;
}
Il lavoro necessario per creare questo tipo di shader è complicato. Oltre ai problemi legati all'astrazione delle operazioni che stai creando, ci sono seri problemi di ottimizzazione e compatibilità multipiattaforma che devi monitorare e risolvere prima di poter utilizzare il lavoro in produzione.
La prima parte del problema: ottimizzare questo shader per la nostra scena. Per risolvere questo problema, abbiamo dovuto adottare un approccio "sicuro" nel caso in cui lo shader fosse troppo pesante. Per farlo, abbiamo composto lo shader del tornado con una risoluzione di campionamento diversa rispetto al resto della scena. Questo è il file stormTest.coffee (sì, era un test!).
Iniziamo con un renderTarget che corrisponde alla larghezza e all'altezza della scena, in modo da poter avere un'indipendenza della risoluzione dello shader del tornado rispetto alla scena. Poi decidiamo il downsampling della risoluzione dello shader della tempesta in modo dinamico in base alla frequenza fotogrammi che otteniamo.
...
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
Infine, eseguiamo il rendering del tornado sullo schermo utilizzando un algoritmo sal2x semplificato (per evitare l'aspetto a blocchi) alla riga 1107 in stormTest.coffee. Ciò significa che, nel peggiore dei casi, il tornado sarà più sfocato, ma almeno funzionerà senza togliere il controllo all'utente.
Il passaggio di ottimizzazione successivo richiede un'analisi approfondita dell'algoritmo. Il fattore computazionale principale nello shader è l'iterazione eseguita su ogni pixel per cercare di approssimare la distanza della funzione di superficie: il numero di iterazioni del loop di raymarching. Utilizzando un passo più grande, potremmo ottenere una stima della superficie del tornado con meno iterazioni mentre ci troviamo al di fuori della sua superficie nuvolosa. All'interno, riduciamo le dimensioni del passo per ottenere precisione e per poter combinare i valori per creare l'effetto nebbia. Anche la creazione di un cilindro di delimitazione per ottenere una stima della profondità del raggio proiettato ha fornito una buona accelerazione.
La parte successiva del problema consisteva nel garantire che questo shader funzionasse su diverse schede video. Ogni volta abbiamo eseguito dei test e abbiamo iniziato a farci un'idea del tipo di problemi di compatibilità che avremmo potuto riscontrare. Il motivo per cui non potevamo fare molto meglio dell'intuizione è che non riuscivamo sempre a ottenere buone informazioni di debug sugli errori. Uno scenario tipico è un semplice errore della GPU con poche informazioni aggiuntive o persino un arresto anomalo del sistema.
I problemi di compatibilità tra le schede video avevano soluzioni simili: assicurati che le costanti statiche siano inserite con il tipo di dati preciso definito, ad esempio 0.0 per float e 0 per int. Fai attenzione quando scrivi funzioni più lunghe; è preferibile suddividere le cose in più funzioni più semplici e variabili provvisorie perché i compilatori sembravano non gestire correttamente alcuni casi. Assicurati che le texture siano tutte una potenza di 2, non troppo grandi e, in ogni caso, fai attenzione quando cerchi i dati delle texture in un loop.
I problemi di compatibilità più grandi che abbiamo riscontrato riguardavano l'effetto di illuminazione per la tempesta. Abbiamo utilizzato una texture predefinita avvolta attorno al tornado per poter colorare i suoi ciuffi. Era un effetto stupendo e rendeva facile fondere i Tornado con i colori della scena, ma ci è voluto molto tempo per cercare di farlo funzionare su altre piattaforme.
Il sito web mobile
L'esperienza mobile non poteva essere una traduzione diretta della versione desktop perché i requisiti tecnologici e di elaborazione erano troppo onerosi. Abbiamo dovuto creare qualcosa di nuovo, che si rivolgesse specificamente agli utenti mobile.
Abbiamo pensato che sarebbe stato bello avere la cabina fotografica di Carnival da computer come applicazione web mobile che utilizzasse la fotocamera mobile dell'utente. Qualcosa che non avevamo mai visto fare prima.
Per aggiungere un tocco di originalità, abbiamo codificato le trasformazioni 3D in CSS3. Avendolo collegato al giroscopio e all'accelerometro, siamo stati in grado di aggiungere molta profondità all'esperienza. Il sito risponde al modo in cui tieni, muovi e guardi lo smartphone.
Durante la stesura di questo articolo, abbiamo pensato che sarebbe stato utile darti alcuni suggerimenti su come gestire senza problemi il processo di sviluppo mobile. Ecco i risultati. Dai un'occhiata e scopri cosa puoi imparare.
Suggerimenti utili per i dispositivi mobili
Il precaricatore è un elemento necessario, non qualcosa da evitare. Sappiamo che a volte si verifica quest'ultimo caso. Questo è dovuto principalmente al fatto che devi continuare a gestire l'elenco di elementi da precaricare man mano che il progetto cresce. Inoltre, non è molto chiaro come calcolare l'avanzamento del caricamento se estrai risorse diverse, molte delle quali contemporaneamente. È qui che entra in gioco la nostra classe astratta personalizzata e molto generica "Task". L'idea principale è quella di consentire una struttura nidificata all'infinito in cui un'attività può avere le proprie sottoattività, che possono avere le proprie ecc… Inoltre, ogni attività calcola il proprio avanzamento rispetto all'avanzamento delle sue sottoattività (ma non all'avanzamento dell'attività principale). Facendo derivare tutte le classi MainPreloadTask, AssetPreloadTask e TemplatePreFetchTask da Task, abbiamo creato una struttura simile alla seguente:
Grazie a questo approccio e alla classe Task, possiamo conoscere facilmente l'avanzamento globale (MainPreloadTask), l'avanzamento degli asset (AssetPreloadTask) o l'avanzamento del caricamento dei modelli (TemplatePreFetchTask). Anche l'avanzamento di un file specifico. Per vedere come viene eseguita, dai un'occhiata alla classe Task in /m/javascripts/raw/util/Task.js e alle implementazioni effettive delle attività in /m/javascripts/preloading/task. Ad esempio, questo è un estratto di come abbiamo configurato la classe /m/javascripts/preloading/task/MainPreloadTask.js, che è il nostro wrapper di precaricamento definitivo:
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);
}
}
})
]);
Nella classe /m/javascripts/preloading/task/subtask/AssetPreloadTask.js, oltre a notare come comunica con MainPreloadTask (tramite l'implementazione condivisa di Task), vale la pena notare anche come carichiamo gli asset che dipendono dalla piattaforma. In pratica, abbiamo quattro tipi di immagini. Standard per dispositivi mobili (.ext, dove ext è l'estensione del file, in genere .png o .jpg), retina per dispositivi mobili (-2x.ext), standard per tablet (-tab.ext) e retina per tablet (-tab-2x.ext). Anziché eseguire il rilevamento in MainPreloadTask e impostare come hardcoded quattro array di asset, indichiamo semplicemente il nome e l'estensione dell'asset da precaricare e se l'asset dipende dalla piattaforma (responsive = true / false). Poi, AssetPreloadTask genererà il nome file per noi:
resolveAssetUrl : function(assetName, extension, responsive) {
return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' + extension;
}
Più in basso nella catena di classi, il codice effettivo che esegue il precaricamento degli asset è il seguente (/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);
}
Tutorial: HTML5 Photo Booth (iOS6/Android)
Durante lo sviluppo di OZ mobile, ci siamo resi conto che passavamo molto tempo a giocare con la cabina fotografica invece di lavorare :D Semplicemente perché era divertente. Per questo motivo, abbiamo creato una demo con cui puoi fare pratica.
Puoi vedere una demo dal vivo qui (eseguila sul tuo iPhone o smartphone Android):
http://u9html5rocks.appspot.com/demos/mobile_photo_booth
Per configurarlo, devi avere un'istanza dell'applicazione Google App Engine senza costi in cui puoi eseguire il backend. Il codice front-end non è complesso, ma ci sono un paio di possibili insidie. Vediamoli insieme:
- Tipo di file immagine consentito
Vogliamo che le persone possano caricare solo immagini (poiché si tratta di una cabina fotografica, non di una cabina video). In teoria, puoi semplicemente specificare il filtro in HTML, come segue:
input id="fileInput" class="fileInput" type="file" name="file" accept="image/*"Tuttavia, sembra che funzioni solo su iOS, quindi dobbiamo aggiungere un ulteriore controllo rispetto alla RegExp una volta selezionato un file:
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();
}
}
});
- Annullamento di un caricamento o della selezione di un file Un'altra incoerenza che abbiamo notato durante il processo di sviluppo è il modo in cui i diversi dispositivi notificano l'annullamento della selezione di un file. Gli smartphone e i tablet iOS non fanno nulla, non inviano alcuna notifica. Quindi non è necessaria alcuna azione speciale per questo caso, tuttavia gli smartphone Android attivano comunque la funzione add(), anche se non è selezionato alcun file. Ecco come fare:
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();
}
}
Il resto funziona in modo piuttosto fluido su tutte le piattaforme. Divertiti!
Conclusione
Considerate le enormi dimensioni di Find Your Way To Oz e l'ampio mix di tecnologie diverse coinvolte, in questo articolo abbiamo potuto trattare solo alcuni degli approcci che abbiamo utilizzato.
Se vuoi esplorare l'intero progetto, dai un'occhiata al codice sorgente completo di Find Your Way To Oz a questo link.
Crediti
Fai clic qui per l'elenco completo dei crediti
Riferimenti
- CoffeeScript - http://coffeescript.org/
- Backbone.js - http://backbonejs.org/
- Three.js - http://mrdoob.github.com/three.js/
- Max Planck Institute (brainflight.org) - http://brainflight.org/