Wprowadzenie
„Find Your Way to Oz” to nowy eksperyment Chrome, który Disney udostępnił w internecie. Możesz wyruszyć w interaktywną podróż po cyrku w Kansas, która po przejściu potężnej burzy zaprowadzi Cię do krainy Oz.
Naszym celem było połączenie bogactwa kina z możliwościami technicznymi przeglądarki, aby stworzyć zabawne, wciągające doświadczenie, z którym użytkownicy mogą się silnie związać.
To zadanie jest zbyt duże, aby opisać je w całości w tym artykule, dlatego wybraliśmy kilka rozdziałów z historii technologii, które naszym zdaniem są interesujące. W trakcie tego procesu wyodrębniliśmy kilka samouczków o rosnącym poziomie trudności.
Wiele osób ciężko pracowało, aby umożliwić to doświadczenie – zbyt wiele, aby je tutaj wymienić. Odwiedź witrynę, aby zapoznać się z pełną historią na stronie z podziękowaniami w sekcji menu.
Jak to działa
Find Your Way to Oz na komputerze to bogaty, wciągający świat. Używamy technologii 3D i kilku warstw tradycyjnych efektów inspirowanych filmem, które łączą się, tworząc niemal realistyczną scenę. Najważniejsze technologie to WebGL z Three.js, niestandardowe shadery i animowane elementy DOM wykorzystujące funkcje CSS3. Oprócz tego interfejs API getUserMedia (WebRTC) do interaktywnych funkcji, który umożliwia użytkownikowi dodawanie obrazu bezpośrednio z kamery internetowej, oraz WebAudio do dźwięku 3D.
Jednak magia takiego rozwiązania technologicznego polega na tym, jak wszystkie te elementy ze sobą współgrają. To też jedno z głównych wyzwań: jak połączyć efekty wizualne i elementy interaktywne w jednej scenie, aby stworzyć spójną całość? Trudno było zarządzać tą złożonością wizualną, przez co niełatwo było określić, na jakim etapie rozwoju jesteśmy w danym momencie.
Aby rozwiązać problem wzajemnie powiązanych efektów wizualnych i optymalizacji, intensywnie korzystaliśmy z panelu sterowania, który rejestrował wszystkie istotne ustawienia, które w danym momencie sprawdzaliśmy. Scenę można było dostosować na żywo w przeglądarce pod kątem jasności, głębi ostrości, gamma itp. Każdy mógł spróbować dostosować wartości istotnych parametrów i odkryć, co sprawdza się najlepiej.
Zanim zdradzimy Ci nasz sekret, chcemy Cię ostrzec, że może to spowodować awarię, tak jakbyś grzebał(-a) w silniku samochodu. Upewnij się, że nie masz otwartych żadnych ważnych stron, i odwiedź główny adres URL witryny, dodając do niego ?debug=on. Poczekaj, aż strona się załaduje, a gdy już się otworzy, naciśnij klawisz Ctrl-I. Po prawej stronie pojawi się menu. Jeśli odznaczysz opcję „Wyjdź ze ścieżki kamery”, możesz używać klawiszy A, W, S, D i myszy, aby swobodnie poruszać się po przestrzeni.
Nie będziemy tu omawiać wszystkich ustawień, ale zachęcamy do eksperymentowania: klawisze ujawniają różne ustawienia w różnych scenach. W końcowej sekwencji burzy jest dodatkowy klawisz: Ctrl-A, za pomocą którego można przełączać odtwarzanie animacji i latać. Jeśli w tej scenie naciśniesz Esc (aby wyjść z funkcji blokady myszy), a następnie ponownie naciśniesz Ctrl-I, uzyskasz dostęp do ustawień, które są specyficzne dla sceny burzy. Rozejrzyj się i zrób kilka ładnych zdjęć, takich jak to poniżej.
Aby to osiągnąć i zapewnić wystarczającą elastyczność, użyliśmy świetnej biblioteki dat.gui (tutaj znajdziesz samouczek na temat jej używania). Dzięki temu mogliśmy szybko zmieniać ustawienia widoczne dla użytkowników witryny.
Trochę jak matte painting
W wielu klasycznych filmach i animacjach Disneya tworzenie scen polegało na łączeniu różnych warstw. Były tam warstwy akcji na żywo, animacji komórkowej, a nawet fizycznych scenografii, a na nich warstwy utworzone przez malowanie na szkle – technikę zwaną malowaniem matowym.
Pod wieloma względami struktura stworzonego przez nas doświadczenia jest podobna, mimo że niektóre „warstwy” to znacznie więcej niż statyczne obrazy. Wpływają one na wygląd obiektów zgodnie z bardziej złożonymi obliczeniami. Niemniej jednak, przynajmniej na poziomie ogólnym, mamy do czynienia z widokami, które są nakładane jeden na drugi. U góry znajduje się warstwa interfejsu, a pod nią scena 3D, która składa się z różnych komponentów.
Górna warstwa interfejsu została utworzona przy użyciu DOM i CSS 3, co oznacza, że interakcje można było edytować na wiele sposobów niezależnie od środowiska 3D, a komunikacja między nimi odbywała się zgodnie z wybraną listą zdarzeń. Ta komunikacja wykorzystuje Backbone Router i zdarzenie onHashChange HTML5, które kontroluje, który obszar powinien być animowany. (źródło projektu: /develop/coffee/router/Router.coffee).
Samouczek: arkusze sprite i obsługa wyświetlaczy Retina
Jedną z ciekawych technik optymalizacji, którą zastosowaliśmy w interfejsie, było połączenie wielu obrazów nakładki interfejsu w jeden plik PNG, aby zmniejszyć liczbę żądań do serwera. W tym projekcie interfejs składał się z ponad 70 obrazów (nie licząc tekstur 3D) wczytywanych od razu, aby skrócić czas oczekiwania na stronie. Arkusz sprite możesz zobaczyć tutaj:
Wyświetlacz normalny – http://findyourwaytooz.com/img/home/interface_1x.png Wyświetlacz Retina – http://findyourwaytooz.com/img/home/interface_2x.png
Oto kilka wskazówek, jak wykorzystaliśmy arkusze sprite i jak używać ich na urządzeniach z wyświetlaczem Retina, aby uzyskać jak najostrzejszy i najbardziej przejrzysty interfejs.
Tworzenie arkuszy duszków
Do tworzenia arkuszy duszków użyliśmy narzędzia TexturePacker, które generuje dane wyjściowe w dowolnym formacie. W tym przypadku wyeksportowaliśmy plik jako EaselJS, który jest bardzo przejrzysty i mógłby zostać użyty do utworzenia animowanych duszków.
Używanie wygenerowanego arkusza sprite
Po utworzeniu arkusza sprite powinien wyświetlić się plik JSON podobny do tego:
{
"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]
},
}
Gdzie:
- image odnosi się do adresu URL arkusza sprite,
- ramki to współrzędne każdego elementu interfejsu [x, y, szerokość, wysokość].
- animacje to nazwy poszczególnych zasobów.
Zwróć uwagę, że do utworzenia arkusza sprite użyliśmy obrazów o wysokiej gęstości, a następnie utworzyliśmy wersję normalną, zmniejszając ją o połowę.
Konkluzja
Teraz, gdy wszystko jest gotowe, potrzebujemy tylko fragmentu kodu JavaScript, aby go użyć.
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);
};
Możesz to zrobić w następujący sposób:
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'));
Aby dowiedzieć się więcej o zmiennej gęstości pikseli, przeczytaj ten artykuł Borisa Smusa.
Potok treści 3D
Środowisko jest skonfigurowane na warstwie WebGL. Gdy myślisz o scenie 3D, jednym z najtrudniejszych pytań jest to, jak upewnić się, że możesz tworzyć treści, które pozwalają na maksymalne wykorzystanie potencjału modelowania, animacji i efektów. W wielu przypadkach sednem tego problemu jest proces tworzenia treści: uzgodniony proces, który należy wykonać, aby utworzyć treści dla sceny 3D.
Chcieliśmy stworzyć zachwycający świat, więc potrzebowaliśmy solidnego procesu, który umożliwiłby grafikom 3D jego stworzenie. Musieliśmy zapewnić im jak największą swobodę ekspresji w oprogramowaniu do modelowania i animacji 3D, a następnie wyrenderować to na ekranie za pomocą kodu.
Pracowaliśmy nad tym problemem od dłuższego czasu, ponieważ za każdym razem, gdy tworzyliśmy witrynę 3D, napotykaliśmy ograniczenia w narzędziach, których mogliśmy użyć. Stworzyliśmy więc narzędzie o nazwie 3D Librarian, które było częścią wewnętrznych badań. I była już prawie gotowa do zastosowania w praktyce.
To narzędzie ma swoją historię: pierwotnie było przeznaczone do Flasha i umożliwiało importowanie dużej sceny z Maya jako pojedynczego skompresowanego pliku, który był zoptymalizowany pod kątem rozpakowywania w czasie działania. Było to optymalne rozwiązanie, ponieważ skutecznie pakowało scenę w zasadniczo tę samą strukturę danych, która jest przetwarzana podczas renderowania i animacji. Po wczytaniu pliku nie trzeba go prawie wcale analizować. Rozpakowywanie we Flashu było dość szybkie, ponieważ plik był w formacie AMF, który Flash mógł rozpakować natywnie. Użycie tego samego formatu w WebGL wymaga nieco więcej pracy procesora. Musieliśmy odtworzyć warstwę kodu JavaScriptu, która rozpakowywała dane, czyli dekompresowała pliki i odtwarzała struktury danych potrzebne do działania WebGL. Rozpakowanie całej sceny 3D jest operacją, która w niewielkim stopniu obciąża procesor: rozpakowanie sceny 1 w Find Your Way To Oz zajmuje około 2 sekund na komputerze średniej lub wysokiej klasy. Dlatego odbywa się to za pomocą technologii Web Workers w czasie „konfiguracji sceny” (zanim scena zostanie faktycznie uruchomiona), aby nie zakłócać działania aplikacji.
To przydatne narzędzie może importować większość sceny 3D: modele, tekstury, animacje kości. Tworzysz pojedynczy plik biblioteki, który może zostać wczytany przez silnik 3D. Wszystkie modele, których potrzebujesz w scenie, umieszczasz w tej bibliotece i po prostu dodajesz je do sceny.
Problem polegał jednak na tym, że mieliśmy do czynienia z WebGL, czyli nowym rozwiązaniem. To był trudny przeciwnik, który wyznaczał standardy dla środowisk 3D w przeglądarce. Dlatego stworzyliśmy doraźną warstwę JavaScript, która pobiera skompresowane pliki scen 3D z 3D Librarian i odpowiednio tłumaczy je na format zrozumiały dla WebGL.
Samouczek: Niech stanie się wiatr
Powtarzającym się motywem w „Find Your Way To Oz” był wiatr. Wątek fabuły jest skonstruowany tak, aby narastał jak wiatr.
Pierwsza scena karnawału jest stosunkowo spokojna. Przechodząc przez różne sceny, użytkownik doświadcza coraz silniejszego wiatru, który w ostatniej scenie osiąga siłę burzy.
Dlatego ważne było, aby zapewnić realistyczny efekt wiatru.
Aby to osiągnąć, wypełniliśmy 3 sceny karnawałowe obiektami, które były miękkie i miały reagować na wiatr, takimi jak namioty, flagi, powierzchnia budki fotograficznej i sam balon.
Gry na komputery są obecnie zwykle tworzone na bazie podstawowego silnika fizyki. Gdy więc trzeba zasymulować miękki obiekt w świecie 3D, uruchamiana jest pełna symulacja fizyki, która tworzy wiarygodne zachowanie miękkiego obiektu.
W WebGL / Javascript nie mamy (jeszcze) możliwości uruchomienia pełnej symulacji fizyki. W Oz musieliśmy więc znaleźć sposób na stworzenie efektu wiatru bez jego symulowania.
W samym modelu 3D umieściliśmy informacje o „wrażliwości na wiatr” każdego obiektu. Każdy wierzchołek modelu 3D miał „atrybut wiatru”, który określał, w jakim stopniu wiatr powinien wpływać na dany wierzchołek. To jest określona czułość obiektów 3D na wiatr. Następnie musieliśmy stworzyć sam wiatr.
Zrobiliśmy to, generując obraz zawierający szum Perlina. Ten obraz ma pokrywać określony „obszar wiatru”. Dobrym sposobem na wyobrażenie sobie tego jest obraz chmury przypominający szum, który jest nakładany na określony prostokątny obszar sceny 3D. Każdy piksel (wartość poziomu szarości) tego obrazu określa, jak silny jest wiatr w danym momencie w obszarze 3D „wokół niego”.
Aby uzyskać efekt wiatru, obraz jest przesuwany w czasie ze stałą szybkością w określonym kierunku – kierunku wiatru. Aby mieć pewność, że „obszar wietrzny” nie wpłynie na wszystko w scenie, zawijamy obraz wiatru wokół krawędzi, ograniczając go do obszaru efektu.
Prosty samouczek dotyczący wiatru 3D
Teraz utwórzmy efekt wiatru w prostej scenie 3D w Three.js.
Utworzymy wiatr na prostym „proceduralnym polu trawy”.
Najpierw utwórzmy scenę. Będziemy mieć prosty, płaski teren z teksturą. Każde źdźbło trawy będzie reprezentowane przez odwrócony stożek 3D.
Oto jak utworzyć tę prostą scenę w Three.js za pomocą CoffeeScript.
Najpierw skonfigurujemy Three.js i połączymy go z kamerą, kontrolerem myszy i jakimś oświetleniem:
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()
Wywołania funkcji initGrass i initTerrain wypełniają scenę odpowiednio trawą i terenem:
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
W tym przypadku tworzymy siatkę o wymiarach 15 na 15 pól trawy. Dodajemy trochę randomizacji do każdej pozycji trawy, aby nie układała się jak żołnierze, co wyglądałoby dziwnie.
Ten teren to tylko płaszczyzna pozioma umieszczona u podstawy źdźbeł trawy (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 )
Do tej pory utworzyliśmy scenę Three.js i dodaliśmy kilka kępek trawy, które składają się z proceduralnie wygenerowanych odwróconych stożków, oraz prosty teren.
Na razie nic nadzwyczajnego.
Teraz czas dodać wiatr. Najpierw chcemy umieścić informacje o wrażliwości na wiatr w modelu 3D trawy.
Te informacje umieścimy jako atrybut niestandardowy dla każdego wierzchołka modelu 3D trawy. Zastosujemy zasadę, że dolny koniec modelu trawy (czubek stożka) ma zerową czułość, ponieważ jest przymocowany do podłoża. Górna część modelu trawy (podstawa stożka) ma maksymalną czułość na wiatr, ponieważ jest to część najbardziej oddalona od ziemi.
Oto jak funkcja instanceGrass jest przekodowywana, aby dodać wrażliwość na wiatr jako atrybut niestandardowy modelu 3D trawy.
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
Teraz używamy niestandardowego materiału windMaterial zamiast MeshPhongMaterial, którego używaliśmy wcześniej. WindMaterial opakowuje WindMeshShader, który za chwilę zobaczymy.
Kod w instanceGrass przechodzi przez wszystkie wierzchołki modelu trawy i do każdego z nich dodaje niestandardowy atrybut wierzchołka o nazwie windFactor. Ten współczynnik windFactor jest ustawiony na 0 dla dolnego końca modelu trawy (gdzie ma dotykać terenu) i ma wartość 1 dla górnego końca modelu trawy.
Kolejnym elementem, który musimy dodać do sceny, jest wiatr. Jak już wspomnieliśmy, użyjemy do tego szumu Perlina. Wygenerujemy proceduralnie teksturę szumu Perlina.
Dla przejrzystości przypiszemy tę teksturę do samego terenu, zastępując nią poprzednią zieloną teksturę. Ułatwi to zrozumienie, co się dzieje z wiatrem.
Ta tekstura szumu Perlina będzie przestrzennie pokrywać rozszerzenie naszego terenu, a każdy piksel tekstury będzie określać intensywność wiatru na obszarze terenu, na który przypada dany piksel. Prostokąt terenu będzie naszym „obszarem wiatru”.
Szum Perlina jest generowany proceduralnie za pomocą cieniowania o nazwie NoiseShader. Ten program do cieniowania używa algorytmów szumu simpleksowego 3D z witryny https://github.com/ashima/webgl-noise . Wersja WebGL została zaczerpnięta dosłownie z jednego z przykładów Three.js autorstwa MrDooba, który można znaleźć na stronie http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.
NoiseShader przyjmuje czas, skalę i przesunięcie jako parametry typu uniform i generuje ładny dwuwymiarowy rozkład szumu Perlina.
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) }
...
Użyjemy tego shadera do renderowania szumu Perlina na teksturze. Odbywa się to w funkcji 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 )
Powyższy kod konfiguruje noiseMap jako cel renderowania Three.js, wyposaża go w NoiseShader, a następnie renderuje za pomocą kamery ortograficznej, aby uniknąć zniekształceń perspektywy.
Jak już wspomnieliśmy, użyjemy tej tekstury również jako głównej tekstury renderowania terenu. Nie jest to konieczne do działania efektu wiatru. ale warto je mieć, aby lepiej zrozumieć, co się dzieje z generowaniem energii wiatrowej.
Oto zmodyfikowana funkcja initTerrain, która używa mapy szumów jako tekstury:
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 )
Mamy już teksturę wiatru, więc przyjrzyjmy się WindMeshShader, który odpowiada za deformowanie modeli trawy pod wpływem wiatru.
Aby utworzyć ten obiekt cieniujący, zaczęliśmy od standardowego obiektu cieniującego Three.js MeshPhongMaterial i zmodyfikowaliśmy go. To dobry i szybki sposób na rozpoczęcie pracy z działającym cieniowaniem bez konieczności zaczynania od zera.
Nie będziemy tu kopiować całego kodu cieniowania (możesz go zobaczyć w pliku kodu źródłowego), ponieważ większość z niego byłaby repliką cieniowania MeshPhongMaterial. Przyjrzyjmy się jednak zmodyfikowanym, związanym z wiatrem częściom w 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;
Ten shader najpierw oblicza współrzędną wyszukiwania tekstury windUV na podstawie pozycji 2D, xz (poziomej) wierzchołka. Ta współrzędna UV służy do wyszukiwania siły wiatru, vWindForce, z tekstury wiatru z szumem Perlina.
Ta wartość vWindForce jest łączona z omówionym powyżej atrybutem niestandardowym windFactor, który jest powiązany z konkretnym wierzchołkiem, aby obliczyć, jak bardzo wierzchołek musi zostać zdeformowany. Mamy też globalny parametr windScale, który kontroluje ogólną siłę wiatru, oraz wektor windDirection, który określa kierunek, w którym ma nastąpić deformacja spowodowana wiatrem.
W ten sposób powstaje deformacja źdźbeł trawy pod wpływem wiatru. To jednak nie wszystko. Obecnie deformacja jest statyczna i nie oddaje efektu wietrznego obszaru.
Jak wspomnieliśmy, musimy przesuwać teksturę szumu w czasie na obszarze wiatru, aby trawa mogła się kołysać.
Odbywa się to przez zmianę w czasie wartości vOffset przekazywanej do NoiseShader. Jest to parametr vec2, który pozwoli nam określić przesunięcie szumu w określonym kierunku (kierunku wiatru).
Robimy to w funkcji render, która jest wywoływana w każdej klatce:
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
...
To wszystko. Właśnie utworzyliśmy scenę z „proceduralną trawą”, na którą wpływa wiatr.
Dodaję do miksu kurz
Teraz urozmaicimy nieco naszą scenę. Dodajmy trochę unoszącego się kurzu, aby scena była ciekawsza.
Wiatr powinien wpływać na kurz, więc to logiczne, że w scenie z wiatrem kurz będzie się unosił.
Kurz jest konfigurowany w funkcji initDust jako system cząsteczek.
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
W tym przypadku powstaje 130 cząsteczek kurzu. Zwróć uwagę, że każdy z nich jest wyposażony w specjalny WindParticleShader.
Teraz w każdej klatce będziemy nieco przesuwać cząsteczki, używając CoffeeScript, niezależnie od wiatru. Oto kod.
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 )
Oprócz tego przesuniemy pozycję każdej cząsteczki zgodnie z wiatrem. Odbywa się to w pliku WindParticleShader. Konkretnie w programie do cieniowania wierzchołków.
Kod tego shadera to zmodyfikowana wersja ParticleMaterial z Three.js. Oto jak wygląda jego główna część:
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;
Ten moduł cieniowania wierzchołków nie różni się zbytnio od tego, który wykorzystaliśmy do deformacji trawy pod wpływem wiatru. Jako dane wejściowe pobiera teksturę szumu Perlina i w zależności od pozycji kurzu w świecie gry wyszukuje wartość vWindForce w teksturze szumu. Następnie używa tej wartości do zmiany pozycji cząsteczki kurzu.
Riders On The Storm
Najbardziej odważną sceną WebGL była prawdopodobnie ostatnia scena, którą można zobaczyć, klikając balon i przechodząc do oka Huraganów, aby dotrzeć do końca podróży po witrynie i ekskluzywnego filmu o nadchodzącej premierze.
Gdy tworzyliśmy tę scenę, wiedzieliśmy, że potrzebujemy centralnego elementu, który będzie miał duży wpływ na wrażenia użytkowników. Wirujące tornado będzie głównym elementem, a warstwy innych treści będą go otaczać, tworząc dramatyczny efekt. Aby to osiągnąć, stworzyliśmy coś, co można porównać do planu filmowego, na którym umieściliśmy ten dziwny shader.
Aby stworzyć realistyczny obraz złożony, zastosowaliśmy podejście mieszane. Niektóre były sztuczkami wizualnymi, takimi jak kształty świetlne, które tworzyły efekt odblasku obiektywu, lub krople deszczu, które animowały się jako warstwy na oglądanej scenie. W innych przypadkach mieliśmy płaskie powierzchnie, które miały się poruszać, np. warstwy nisko latających chmur, które poruszały się zgodnie z kodem systemu cząsteczkowego. Z kolei fragmenty gruzu krążące wokół tornada były warstwami w scenie 3D, które zostały posortowane tak, aby poruszały się przed tornadem i za nim.
Głównym powodem, dla którego musieliśmy zbudować scenę w ten sposób, było zapewnienie wystarczającej mocy GPU do obsługi shadera tornada w równowadze z innymi efektami, które stosowaliśmy. Początkowo mieliśmy duże problemy z równoważeniem obciążenia GPU, ale później ta scena została zoptymalizowana i stała się lżejsza niż główne sceny.
Samouczek: cieniowanie burzy
Aby stworzyć końcową sekwencję burzy, połączono wiele różnych technik, ale najważniejszym elementem tej pracy był niestandardowy program do cieniowania GLSL, który wygląda jak tornado. Wypróbowaliśmy wiele różnych technik, od cieniowania wierzchołków, aby tworzyć ciekawe geometryczne wiry, po animacje oparte na cząsteczkach, a nawet animacje 3D skręconych kształtów geometrycznych. Żaden z efektów nie oddawał wrażenia tornada lub wymagał zbyt dużej mocy obliczeniowej.
Odpowiedź znaleźliśmy w zupełnie innym projekcie. Równoległy projekt obejmujący gry naukowe, którego celem było zmapowanie mózgu myszy, prowadzony przez Instytut Maxa Plancka (brainflight.org), wygenerował ciekawe efekty wizualne. Udało nam się stworzyć filmy przedstawiające wnętrze neuronu myszy za pomocą niestandardowego shadera wolumetrycznego.
Odkryliśmy, że wnętrze komórki mózgowej wygląda trochę jak lej tornada. Ponieważ użyliśmy techniki wolumetrycznej, wiedzieliśmy, że możemy wyświetlać ten obiekt cieniujący ze wszystkich kierunków w przestrzeni. Możemy ustawić renderowanie cieniowania, aby połączyć je ze sceną burzy, zwłaszcza jeśli jest ono umieszczone pod warstwami chmur i nad dramatycznym tłem.
Technika cieniowania polega na zastosowaniu sztuczki, która zasadniczo wykorzystuje pojedynczy program do cieniowania GLSL do renderowania całego obiektu za pomocą uproszczonego algorytmu renderowania zwanego renderowaniem ray marching z polem odległości. W tej technice tworzony jest cieniujący piksel, który szacuje najmniejszą odległość do powierzchni dla każdego punktu na ekranie.
Dobry opis algorytmu można znaleźć w artykule iq: Rendering Worlds With Two Triangles – Iñigo Quilez. Warto też przejrzeć galerię shaderów na glsl.heroku.com, gdzie można znaleźć wiele przykładów tej techniki, które można wypróbować.
Sercem cieniowania jest funkcja główna, która konfiguruje przekształcenia kamery i wchodzi w pętlę, która wielokrotnie ocenia odległość od powierzchni. Wywołanie RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) to miejsce, w którym odbywają się podstawowe obliczenia ray marchingu.
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
}
Chodzi o to, że gdy przesuwamy się w głąb kształtu Huraganów, regularnie dodajemy składowe koloru do ostatecznej wartości koloru piksela, a także składowe nieprzezroczystości wzdłuż promienia. Dzięki temu tekstura tornada jest warstwowa i miękka.
Kolejnym kluczowym aspektem tornada jest jego kształt, który powstaje przez złożenie kilku funkcji. Zaczyna się od stożka, który jest połączony z szumem, aby utworzyć organiczną, nieregularną krawędź, a następnie jest skręcany wzdłuż osi głównej i obracany w czasie.
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;
}
Praca nad stworzeniem takiego shadera jest trudna. Oprócz problemów związanych z abstrakcją tworzonych operacji występują poważne problemy z optymalizacją i zgodnością z różnymi platformami, które musisz prześledzić i rozwiązać, zanim będziesz mógł używać swojej pracy w środowisku produkcyjnym.
Pierwsza część problemu: optymalizacja tego cieniowania pod kątem naszej sceny. Aby sobie z tym poradzić, musieliśmy zastosować „bezpieczne” podejście na wypadek, gdyby cieniowanie było zbyt obciążające. Aby to zrobić, połączyliśmy cieniowanie tornada w innej rozdzielczości próbkowania niż reszta sceny. To jest fragment pliku stormTest.coffee (tak, to był test!).
Zaczynamy od renderTarget, który odpowiada szerokości i wysokości sceny, dzięki czemu możemy uniezależnić rozdzielczość tornado shader od sceny. Następnie decydujemy o downsamplingu rozdzielczości shadera burzy dynamicznie, w zależności od liczby klatek, którą uzyskujemy.
...
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
Na koniec renderujemy tornado na ekranie, używając uproszczonego algorytmu sal2x (aby uniknąć efektu pikselizacji) – wiersz 1107 w pliku stormTest.coffee. Oznacza to, że w najgorszym przypadku tornado będzie bardziej rozmyte, ale przynajmniej będzie działać bez odbierania użytkownikowi kontroli.
Kolejny krok optymalizacji wymaga zagłębienia się w algorytm. Głównym czynnikiem obliczeniowym w tym cieniowaniu jest iteracja wykonywana na każdym pikselu w celu oszacowania odległości funkcji powierzchni: liczba iteracji pętli raymarching. Używając większego rozmiaru kroku, możemy uzyskać oszacowanie powierzchni tornada przy mniejszej liczbie iteracji, gdy znajdujemy się poza jego chmurą. Wewnątrz zmniejszamy rozmiar kroku, aby uzyskać precyzję i móc mieszać wartości w celu uzyskania efektu mgły. Utworzenie cylindra ograniczającego w celu oszacowania głębokości rzutowanego promienia również pozwoliło znacznie przyspieszyć działanie.
Kolejnym problemem było zapewnienie, że ten cieniujący będzie działał na różnych kartach wideo. Za każdym razem przeprowadzaliśmy testy i zaczęliśmy intuicyjnie rozumieć, jakie problemy ze zgodnością możemy napotkać. Powodem, dla którego nie mogliśmy zrobić nic lepszego niż intuicja, było to, że nie zawsze mogliśmy uzyskać dobre informacje na potrzeby debugowania błędów. Typowy scenariusz to błąd GPU, który nie zawiera żadnych dodatkowych informacji, a nawet awaria systemu.
Problemy ze zgodnością między różnymi kartami graficznymi miały podobne rozwiązania: upewnij się, że stałe statyczne są wprowadzane z dokładnym typem danych, jak zdefiniowano, np. 0.0 dla float i 0 dla int. Zachowaj ostrożność podczas pisania dłuższych funkcji. Lepiej jest podzielić je na kilka prostszych funkcji i zmiennych tymczasowych, ponieważ kompilatory nie zawsze prawidłowo obsługują niektóre przypadki. Upewnij się, że wszystkie tekstury są potęgą liczby 2, nie są zbyt duże i zachowaj ostrożność podczas wyszukiwania danych tekstur w pętli.
Największe problemy ze zgodnością dotyczyły efektu oświetlenia podczas burzy. Użyliśmy gotowej tekstury owiniętej wokół tornada, aby móc pokolorować jego wiry. Efekt był świetny i ułatwił wtopienie tornada w kolory sceny, ale dostosowanie go do innych platform zajęło dużo czasu.
Witryna mobilna
Wersja mobilna nie mogła być bezpośrednim tłumaczeniem wersji komputerowej, ponieważ wymagania technologiczne i dotyczące przetwarzania były zbyt duże. Musieliśmy stworzyć coś nowego, co byłoby skierowane specjalnie do użytkowników urządzeń mobilnych.
Pomyśleliśmy, że fajnie byłoby mieć fotobudkę Carnival z komputera jako aplikację internetową na urządzenia mobilne, która korzystałaby z aparatu w telefonie użytkownika. Czegoś takiego jeszcze nie widzieliśmy.
Aby dodać smaku, zakodowaliśmy przekształcenia 3D w CSS3. Po połączeniu go z żyroskopem i akcelerometrem udało nam się znacznie zwiększyć głębię wrażeń. Witryna reaguje na sposób, w jaki trzymasz telefon, poruszasz nim i na niego patrzysz.
Podczas pisania tego artykułu pomyśleliśmy, że warto byłoby podać kilka wskazówek, jak sprawnie przeprowadzić proces tworzenia aplikacji mobilnej. Zaczynamy! Sprawdź, czego możesz się z niego dowiedzieć.
Porady i wskazówki dotyczące urządzeń mobilnych
Preloader jest potrzebny i nie należy go unikać. Wiemy, że czasem zdarza się ta druga sytuacja. Dzieje się tak głównie dlatego, że w miarę rozwoju projektu musisz stale aktualizować listę elementów, które wstępnie wczytujesz. Co gorsza, nie jest jasne, jak obliczyć postęp wczytywania, jeśli pobierasz różne zasoby, i to wiele jednocześnie. Tu właśnie przydaje się nasza niestandardowa i bardzo ogólna klasa abstrakcyjna „Task”. Jego główną ideą jest umożliwienie nieskończenie zagnieżdżonej struktury, w której zadanie może mieć własne podzadania, które mogą mieć swoje podzadania itd. Ponadto każde zadanie oblicza swój postęp w odniesieniu do postępu swoich podzadań (ale nie do postępu zadania nadrzędnego). Dzięki temu, że wszystkie klasy MainPreloadTask, AssetPreloadTask i TemplatePreFetchTask pochodzą od klasy Task, utworzyliśmy strukturę, która wygląda tak:
Dzięki takiemu podejściu i klasie Task możemy łatwo sprawdzić ogólny postęp (MainPreloadTask), postęp dotyczący zasobów (AssetPreloadTask) lub postęp wczytywania szablonów (TemplatePreFetchTask). Możesz nawet sprawdzić postęp przesyłania konkretnego pliku. Aby zobaczyć, jak to zrobić, zapoznaj się z klasą Task w pliku /m/javascripts/raw/util/Task.js i rzeczywistymi implementacjami zadań w folderze /m/javascripts/preloading/task. Oto przykład konfiguracji klasy /m/javascripts/preloading/task/MainPreloadTask.js, która jest naszym ostatecznym kodem do wstępnego wczytywania:
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);
}
}
})
]);
W klasie /m/javascripts/preloading/task/subtask/AssetPreloadTask.js warto zwrócić uwagę nie tylko na to, jak komunikuje się ona z MainPreloadTask (za pomocą wspólnej implementacji Task), ale też na to, jak wczytujemy zasoby zależne od platformy. Zasadniczo mamy 4 typy obrazów. Standardowy na urządzenia mobilne (.ext, gdzie ext to rozszerzenie pliku, zwykle .png lub .jpg), na urządzenia mobilne z wyświetlaczem Retina (-2x.ext), standardowy na tablety (-tab.ext) i na tablety z wyświetlaczem Retina (-tab-2x.ext). Zamiast wykrywać zasoby w MainPreloadTask i kodować na stałe 4 tablice zasobów, podajemy tylko nazwę i rozszerzenie zasobu do wstępnego wczytania oraz informację, czy zasób jest zależny od platformy (responsive = true / false). Następnie AssetPreloadTask wygeneruje dla nas nazwę pliku:
resolveAssetUrl : function(assetName, extension, responsive) {
return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' + extension;
}
Dalej w łańcuchu klas rzeczywisty kod, który wstępnie wczytuje zasoby, wygląda tak (/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);
}
Samouczek: budka fotograficzna HTML5 (iOS6/Android)
Podczas tworzenia OZ mobile odkryliśmy, że spędzamy dużo czasu na zabawie z budką fotograficzną zamiast na pracy :D. To po prostu świetna zabawa. Dlatego przygotowaliśmy wersję demonstracyjną, którą możesz wypróbować.
Wersję demonstracyjną możesz zobaczyć tutaj (uruchom ją na iPhonie lub telefonie z Androidem):
http://u9html5rocks.appspot.com/demos/mobile_photo_booth
Aby go skonfigurować, potrzebujesz bezpłatnej instancji aplikacji Google App Engine, w której możesz uruchomić backend. Kod frontendu nie jest skomplikowany, ale może zawierać kilka pułapek. Przyjrzyjmy się im:
- Dozwolony typ pliku graficznego
Chcemy, aby użytkownicy mogli przesyłać tylko obrazy (ponieważ jest to fotobudka, a nie wideobudka). Teoretycznie możesz po prostu określić filtr w kodzie HTML w ten sposób:
input id="fileInput" class="fileInput" type="file" name="file" accept="image/*"Wygląda jednak na to, że działa to tylko na iOS, więc po wybraniu pliku musimy dodać dodatkowe sprawdzenie pod kątem wyrażenia regularnego:
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();
}
}
});
- Anulowanie przesyłania lub wyboru pliku Inną niespójnością, którą zauważyliśmy podczas procesu tworzenia, jest sposób, w jaki różne urządzenia powiadamiają o anulowaniu wyboru pliku. Telefony i tablety z iOS nie robią nic, nie powiadamiają w ogóle. Nie musimy więc podejmować żadnych specjalnych działań w tym przypadku, ale telefony z Androidem i tak wywołują funkcję add(), nawet jeśli nie wybrano żadnego pliku. Oto jak to zrobić:
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();
}
}
Reszta działa dość płynnie na różnych platformach. Baw się dobrze!
Podsumowanie
Ze względu na ogromny rozmiar projektu Find Your Way To Oz i szeroki zakres różnych technologii, w tym artykule mogliśmy omówić tylko kilka z zastosowanych przez nas metod.
Jeśli chcesz poznać wszystkie szczegóły, możesz zajrzeć do pełnego kodu źródłowego Znajdź drogę do Oz pod tym linkiem.
Środki
Kliknij tutaj, aby zobaczyć pełną listę twórców.
Odniesienia
- CoffeeScript – http://coffeescript.org/
- Backbone.js – http://backbonejs.org/
- Three.js – http://mrdoob.github.com/three.js/
- Instytut Maxa Plancka (brainflight.org) – http://brainflight.org/