Örnek Olay - Oz'a Giden Yolu Bulun

Giriş

"Find Your Way to Oz", Disney tarafından web'e taşınan yeni bir Google Chrome Experiment'tır. Kansas'taki bir sirkte etkileşimli bir yolculuğa çıkmanızı sağlar. Bu yolculukta büyük bir fırtınaya kapılıp Oz diyarına gidersiniz.

Hedefimiz, sinemanın zenginliğini tarayıcının teknik özellikleriyle birleştirerek kullanıcıların güçlü bir bağ kurabileceği eğlenceli ve etkileyici bir deneyim oluşturmaktı.

Bu iş, bu makalede bütünüyle ele alınamayacak kadar büyük. Bu nedenle, teknoloji hikayesinin ilginç olduğunu düşündüğümüz bazı bölümlerini ele aldık. Bu süreçte, zorluk derecesi giderek artan bazı odaklanmış eğitimler hazırladık.

Bu deneyimi mümkün kılmak için çok sayıda kişi yoğun bir şekilde çalıştı. Bu kişilerin hepsini burada listelemek mümkün değil. Hikayenin tamamını öğrenmek için lütfen siteyi ziyaret edin ve menü bölümündeki katkıda bulunanlar sayfasını inceleyin.

Testlerin işleyiş şekli

Masaüstü için Find Your Way to Oz, zengin ve etkileyici bir dünyadır. Gerçekçi bir sahne oluşturmak için 3D ve geleneksel film yapımından ilham alan çeşitli efekt katmanları kullanıyoruz. En belirgin teknolojiler Three.js ile WebGL, özel olarak oluşturulmuş gölgelendiriciler ve CSS3 özelliklerini kullanan DOM animasyonlu öğelerdir. Ayrıca, kullanıcının resmini doğrudan web kamerasından eklemesine olanak tanıyan etkileşimli deneyimler için getUserMedia API (WebRTC) ve 3D ses için WebAudio kullanıldı.

Ancak bu tür bir teknolojik deneyimin büyüsü, tüm bu unsurların bir araya gelmesinde yatıyor. Bu aynı zamanda en büyük zorluklardan biridir: Görsel efektleri ve etkileşimli öğeleri tek bir sahnede birleştirerek tutarlı bir bütün nasıl oluşturulur? Bu görsel karmaşıklığı yönetmek zordu. Bu nedenle, herhangi bir zamanda geliştirme sürecinin hangi aşamasında olduğumuzu anlamak zorlaşıyordu.

Birbiriyle bağlantılı görsel efektler ve optimizasyon sorununu çözmek için, o anda incelediğimiz tüm ilgili ayarları yakalayacak bir denetim masasından yoğun bir şekilde yararlandık. Sahne; parlaklık, alan derinliği, gama vb. her şey için tarayıcıda canlı olarak ayarlanabiliyordu. Herkes deneyimdeki önemli parametrelerin değerlerini değiştirmeyi deneyebilir ve en iyi sonucu veren ayarları keşfetmeye katılabilirdi.

Sırrımızı paylaşmadan önce, bir araba motorunu kurcaladığınızda olabileceği gibi, bu işlemin de kilitlenmeye neden olabileceği konusunda sizi uyarmak istiyoruz. Önemli bir işlem yapmadığınızdan emin olun ve sitenin ana URL'sini ziyaret edip adresin sonuna ?debug=on ifadesini ekleyin. Sitenin yüklenmesini bekleyin ve siteye girdikten sonra Ctrl-I tuşuna basın. Sağ tarafta bir açılır liste görünür. "Kamera yolundan çık" seçeneğinin işaretini kaldırırsanız alanda serbestçe hareket etmek için A, W, S, D tuşlarını ve fareyi kullanabilirsiniz.

Kamera yolu.

Burada tüm ayarlara değinmeyeceğiz ancak denemeler yapmanızı öneririz. Tuşlar, farklı sahnelerde farklı ayarları gösterir. Son fırtına sekansında ek bir tuş vardır: Ctrl-A. Bu tuşla animasyon oynatmayı açıp kapatabilir ve etrafta uçabilirsiniz. Bu sahnede, Esc tuşuna basarak fare kilidi işlevinden çıkabilir ve tekrar Ctrl-I tuşuna basarak fırtına sahnesine özel ayarlara erişebilirsiniz. Etrafınıza bakın ve aşağıdaki gibi güzel kartpostal görünümleri yakalayın.

Fırtına sahnesi

Bunu gerçekleştirmek ve ihtiyaçlarımıza yeterince esnek olmasını sağlamak için dat.gui adlı güzel bir kitaplık kullandık (nasıl kullanılacağına dair geçmiş bir eğitim için buraya bakın). Bu sayede, site ziyaretçilerine gösterilen ayarları hızlıca değiştirebildik.

Mat Boyama Tarzında

Birçok klasik Disney filminde ve animasyonunda sahneler oluşturmak için farklı katmanlar birleştirilirdi. Canlı çekim, selüloit animasyon, hatta fiziksel setler ve en üstte cam üzerine boyama tekniğiyle oluşturulan katmanlar vardı. Bu tekniğe mat boyama denir.

Oluşturduğumuz deneyimin yapısı birçok açıdan benzer; "katmanlardan" bazıları statik görsellerden çok daha fazlası olsa bile. Aslında, daha karmaşık hesaplamalara göre nesnelerin görünümünü etkilerler. Yine de en azından büyük resim düzeyinde, üst üste birleştirilmiş görünümlerle ilgileniyoruz. Üstte bir kullanıcı arayüzü katmanı, altında ise farklı sahne bileşenlerinden oluşan bir 3D sahne gösteriliyor.

Üst arayüz katmanı, DOM ve CSS 3 kullanılarak oluşturuldu. Bu sayede, etkileşimler 3D deneyiminden bağımsız olarak birçok şekilde düzenlenebiliyor ve ikisi arasında belirli bir etkinlik listesine göre iletişim kurulabiliyor. Bu iletişimde, hangi alanın animasyonla gösterileceğini/gizleneceğini kontrol eden Backbone Router + onHashChange HTML5 etkinliği kullanılır. (proje kaynağı: /develop/coffee/router/Router.coffee).

Eğitim: Model Sayfaları ve Retina desteği

Arayüz için kullandığımız eğlenceli optimizasyon tekniklerinden biri, sunucu isteklerini azaltmak için birçok arayüz yer paylaşımı resmini tek bir PNG'de birleştirmekti. Bu projede arayüz, web sitesinin gecikmesini azaltmak için önceden yüklenen 70'ten fazla görselden (3D dokular hariç) oluşuyordu. Canlı model sayfasını burada görebilirsiniz:

Normal Ekran - http://findyourwaytooz.com/img/home/interface_1x.png Retina Ekran - http://findyourwaytooz.com/img/home/interface_2x.png

Aşağıda, model sayfalarından nasıl yararlandığımız ve bunları retina cihazlarda kullanıp arayüzü mümkün olduğunca net ve düzgün hale getirme konusunda bazı ipuçları verilmiştir.

Sprite sayfaları oluşturma

SpriteSheet'leri oluşturmak için ihtiyacınız olan her biçimde çıktı veren TexturePacker'ı kullandık. Bu örnekte, EaselJS olarak dışa aktardık. Bu, gerçekten temiz bir yöntemdir ve animasyonlu sprite'lar oluşturmak için de kullanılabilir.

Oluşturulan model sayfasını kullanma

Model Sayfanızı oluşturduktan sonra aşağıdaki gibi bir JSON dosyası görürsünüz:

{
   "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]
   },
}

Burada:

  • image, model sayfasının URL'sini ifade eder.
  • frames, her bir kullanıcı arayüzü öğesinin koordinatlarıdır [x, y, genişlik, yükseklik]
  • animasyonlar her öğenin adıdır

Model Sayfasını oluşturmak için yüksek yoğunluklu resimleri kullandığımızı, ardından normal sürümü yalnızca boyutunun yarısına yeniden boyutlandırarak oluşturduğumuzu unutmayın.

Konuyu toparlayacak olursak

Artık her şey hazır olduğuna göre, kullanmak için bir JavaScript snippet'ine ihtiyacımız var.

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);
};

Bu özelliği şu şekilde kullanabilirsiniz:

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'));

Değişken Piksel Yoğunlukları hakkında daha fazla bilgi edinmek için Boris Smus'un bu makalesini okuyabilirsiniz.

3D İçerik Ardışık Düzeni

Ortam deneyimi, WebGL katmanında oluşturulur. 3D sahne oluştururken en zor sorulardan biri, modelleme, animasyon ve efektler açısından maksimum ifade potansiyeli sağlayan içerikler oluşturabileceğinizden nasıl emin olacağınızdır. Bu sorunun temelinde, 3D sahne için içerik oluştururken izlenecek, üzerinde anlaşmaya varılmış bir süreç olan içerik ardışık düzeni yer alır.

Büyüleyici bir dünya yaratmak istiyorduk. Bu nedenle, 3D sanatçılarının bunu oluşturmasını sağlayacak sağlam bir sürece ihtiyacımız vardı. 3D modelleme ve animasyon yazılımlarında mümkün olduğunca fazla ifade özgürlüğü tanınması gerekiyordu. Biz de bunu kod aracılığıyla ekranda oluşturacaktık.

Geçmişte her 3D site oluşturduğumuzda kullanabileceğimiz araçlarda sınırlamalarla karşılaştığımız için bir süredir bu tür bir sorun üzerinde çalışıyorduk. Biz de 3D Librarian adında bir araç oluşturduk. Bu, şirket içi bir araştırma projesiydi. Gerçek bir işte uygulanmaya neredeyse hazırdı.

Bu aracın bir geçmişi vardı: Başlangıçta Flash için tasarlanmıştı ve büyük bir Maya sahnesini, çalışma zamanında açılmak üzere optimize edilmiş tek bir sıkıştırılmış dosya olarak içe aktarmanıza olanak tanıyordu. Bu yöntemin en iyi yöntem olmasının nedeni, sahneyi oluşturma ve animasyon sırasında kullanılan veri yapısıyla neredeyse aynı şekilde etkili bir şekilde paketlemesiydi. Dosya yüklendiğinde ayrıştırılması gereken çok az şey vardır. Flash'ta paket açma işlemi, dosya AMF biçiminde olduğu için oldukça hızlıydı. Flash, bu biçimdeki dosyaları yerel olarak açabiliyordu. WebGL'de aynı biçimi kullanmak için CPU'da biraz daha fazla işlem yapılması gerekir. Aslında, bu dosyaları açacak ve WebGL'nin çalışması için gereken veri yapılarını yeniden oluşturacak bir veri açma JavaScript kod katmanını yeniden oluşturmamız gerekti. 3D sahnenin tamamını açmak, CPU'yu biraz zorlayan bir işlemdir: Find Your Way To Oz'daki 1. sahneyi açmak, orta ila yüksek performanslı bir makinede yaklaşık 2 saniye sürer. Bu nedenle, kullanıcının deneyimini kesintiye uğratmamak için bu işlem, Web Workers teknolojisi kullanılarak "sahne kurulumu" sırasında (sahne gerçekten başlatılmadan önce) gerçekleştirilir.

Bu kullanışlı araç, 3D sahnenin çoğunu (modeller, dokular, kemik animasyonları) içe aktarabilir. 3D motoru tarafından yüklenebilecek tek bir kitaplık dosyası oluşturursunuz. Sahnenizde ihtiyaç duyduğunuz tüm modelleri bu kitaplığa ekleyip sahnenizde oluşturabilirsiniz.

Ancak bir sorunumuz vardı: Artık WebGL ile uğraşıyorduk. Bu, yeni bir teknolojiydi. Bu oldukça zor bir işti. Tarayıcı tabanlı 3D deneyimler için standartları belirliyordu. Bu nedenle, 3D Librarian'ın sıkıştırılmış 3D sahne dosyalarını alıp WebGL'nin anlayacağı bir biçime doğru şekilde çevirecek geçici bir JavaScript katmanı oluşturduk.

Eğitim: Rüzgar Olsun

"Find Your Way To Oz"da tekrarlanan bir tema rüzgardı. Hikayenin bir bölümü, rüzgarın şiddetini artıracak şekilde kurgulanmış.

Karnavalın ilk sahnesi nispeten sakin. Kullanıcı, çeşitli sahnelerden geçerken giderek daha güçlü bir rüzgar deneyimler ve son sahnede fırtınayla karşılaşır.

Bu nedenle, sürükleyici bir rüzgar efekti sağlamak önemliydi.

Bunu oluşturmak için 3 karnaval sahnesini yumuşak ve rüzgardan etkilenebilecek nesnelerle (ör. çadırlar, fotoğraf kabininin yüzeyindeki bayraklar ve balonun kendisi) doldurduk.

Yumuşak bez.

Masaüstü oyunları günümüzde genellikle temel bir fizik motoru etrafında oluşturulur. Bu nedenle, 3D dünyada yumuşak bir nesnenin simüle edilmesi gerektiğinde, bu nesne için tam bir fizik simülasyonu çalıştırılır ve inandırıcı bir yumuşak davranış oluşturulur.

WebGL / JavaScript'te henüz tam kapsamlı bir fizik simülasyonu çalıştırma imkanımız yok. Bu nedenle Oz'da rüzgarı simüle etmeden rüzgar etkisi yaratmanın bir yolunu bulmamız gerekiyordu.

Her nesnenin "rüzgar hassasiyeti" bilgisini 3D modelin içine yerleştirdik. 3D modelin her bir köşesinde, o köşenin rüzgardan ne kadar etkileneceğini belirten bir "Rüzgar Özelliği" vardı. Bu, 3D nesnelerin rüzgar hassasiyetini belirler. Ardından rüzgarı oluşturmamız gerekiyordu.

Bunu, Perlin gürültüsü içeren bir görüntü oluşturarak yaptık. Bu resim, belirli bir "rüzgar alanını" kapsayacak şekilde tasarlanmıştır. Bu nedenle, 3D sahnenin belirli bir dikdörtgen alanına yerleştirilen gürültü gibi bir bulut resmi hayal etmek iyi bir yöntemdir. Bu görüntünün her pikseli (gri seviye değeri), rüzgarın "çevresindeki" 3D alanda belirli bir anda ne kadar güçlü olduğunu belirtir.

Rüzgar efektini oluşturmak için resim, zaman içinde sabit bir hızda belirli bir yöne (rüzgarın yönüne) doğru hareket ettirilir. "Rüzgarlı alanın" sahnedeki her şeyi etkilememesi için rüzgar görüntüsünü kenarlara sararak etki alanıyla sınırlandırıyoruz.

Basit Bir 3D Rüzgar Eğitimi

Şimdi Three.js'de basit bir 3D sahnede rüzgar efekti oluşturalım.

Basit bir "prosedürel çim alan"da rüzgar oluşturacağız.

Önce sahneyi oluşturalım. Basit, dokulu ve düz bir arazi oluşturacağız. Ardından her bir çim parçası, ters çevrilmiş bir 3D koni ile temsil edilecek.

Çimlerle kaplı arazi
Çimlerle kaplı arazi

CoffeeScript kullanarak Three.js'te bu basit sahneyi nasıl oluşturacağınızı aşağıda bulabilirsiniz.

Öncelikle Three.js'yi kurup kamera, fare denetleyicisi ve ışıkla bağlayacağız:

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()

initGrass ve initTerrain işlev çağrıları, sahneyi sırasıyla çim ve araziyle doldurur:

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

Burada 15'e 15 çim parçalarından oluşan bir ızgara oluşturuyoruz. Her çim konumuna biraz rastgelelik ekleriz. Böylece çimler asker gibi dizilmez ve tuhaf bir görüntü oluşmaz.

Bu arazi, çim parçalarının tabanına (y = 2,5) yerleştirilmiş yatay bir düzlemdir.

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 )

Şimdiye kadar yaptığımız şey, basit bir Three.js sahnesi oluşturmak ve prosedürel olarak oluşturulmuş ters konilerden oluşan birkaç çim parçası ve basit bir arazi eklemek oldu.

Şu ana kadar her şey normal.

Şimdi rüzgar eklemeye başlayabilirsiniz. İlk olarak, rüzgar hassasiyeti bilgilerini çim 3D modeline yerleştirmek istiyoruz.

Bu bilgileri, çim 3D modelinin her bir köşesi için özel özellik olarak yerleştireceğiz. Çim modelinin alt ucu (koninin ucu) zemine bağlı olduğu için hassasiyetinin sıfır olduğu kuralını kullanacağız. Çim modelinin üst kısmı (koninin tabanı), zeminden en uzak kısım olduğu için rüzgara karşı maksimum hassasiyete sahiptir.

Çim 3D modeli için rüzgar hassasiyetini özel özellik olarak eklemek amacıyla instanceGrass işlevinin nasıl yeniden kodlandığını aşağıda görebilirsiniz.

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

Artık daha önce kullandığımız MeshPhongMaterial yerine özel bir malzeme olan windMaterial'ı kullanıyoruz. WindMaterial, birazdan göreceğimiz WindMeshShader'ı sarmalar.

Bu nedenle, instanceGrass içindeki kod, çim modelinin tüm köşeleri arasında döngü oluşturur ve her köşe için windFactor adlı özel bir köşe özelliği ekler. Bu windFactor, çim modelinin alt ucu (araziye dokunması gereken yer) için 0, çim modelinin üst ucu için ise 1 olarak ayarlanır.

İhtiyacımız olan diğer bileşen, sahnemize gerçek rüzgarı eklemek. Daha önce de belirttiğimiz gibi bunun için Perlin gürültüsünü kullanacağız. Prosedürel olarak bir Perlin gürültü dokusu oluşturacağız.

Daha net olması için bu dokuyu, önceki yeşil dokunun yerine arazinin kendisine atayacağız. Bu sayede rüzgarın durumunu daha kolay anlayabilirsiniz.

Bu Perlin gürültüsü dokusu, arazimizin uzantısını mekansal olarak kaplayacak ve dokunun her pikseli, o pikselin düştüğü arazi alanının rüzgar yoğunluğunu belirtecek. Arazi dikdörtgeni, "rüzgar alanımız" olacak.

Perlin gürültüsü, NoiseShader adlı bir gölgelendirici aracılığıyla prosedürel olarak oluşturulur. Bu gölgelendirici, https://github.com/ashima/webgl-noise adresindeki 3D simpleks gürültü algoritmalarını kullanır . Bunun WebGL sürümü, MrDoob'un Three.js örneklerinden birinden olduğu gibi alınmıştır: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader; zaman, ölçek ve ofset parametrelerini uniform olarak alır ve Perlin gürültüsünün güzel bir 2D dağılımını oluşturur.

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) }

...

Bu gölgelendiriciyi, Perlin gürültümüzü bir dokuya dönüştürmek için kullanacağız. Bu işlem, initNoiseShader işlevinde yapılır.

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 )

Yukarıdaki kod, noiseMap'i Three.js oluşturma hedefi olarak ayarlar, NoiseShader ile donatır ve ardından perspektif bozulmalarını önlemek için ortografik bir kamerayla oluşturur.

Daha önce de belirttiğimiz gibi, bu dokuyu arazinin ana oluşturma dokusu olarak da kullanacağız. Rüzgar efektinin çalışması için bu aslında gerekli değildir. Ancak rüzgar enerjisi üretiminde neler olduğunu görsel olarak daha iyi anlayabilmemiz için bu verilerin olması iyi olur.

noiseMap'i doku olarak kullanan, yeniden düzenlenmiş initTerrain işlevi:

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 )

Rüzgar dokumuzu yerleştirdiğimize göre şimdi çim modellerini rüzgara göre deforme etmekten sorumlu olan WindMeshShader'a göz atalım.

Bu gölgelendiriciyi oluşturmak için standart Three.js MeshPhongMaterial gölgelendiricisinden yola çıktık ve üzerinde değişiklikler yaptık. Bu, sıfırdan başlamak zorunda kalmadan çalışan bir gölgelendiriciyle başlamanın hızlı ve kolay bir yoludur.

Çoğu MeshPhongMaterial gölgelendiricisinin bir replikası olacağından gölgelendirici kodunun tamamını buraya kopyalamayacağız (kaynak kodu dosyasında inceleyebilirsiniz). Ancak Vertex Shader'da rüzgarla ilgili değiştirilen parçalara göz atalım.

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;

Bu gölgelendirici, ilk olarak tepe noktasının 2D, xz (yatay) konumuna göre windUV doku arama koordinatını hesaplar. Bu UV koordinatı, Perlin gürültüsü rüzgar dokusundan rüzgar kuvvetini (vWindForce) aramak için kullanılır.

Bu vWindForce değeri, tepe noktasının ne kadar deformasyona ihtiyacı olduğunu hesaplamak için yukarıda ele alınan özel özellik olan tepe noktasına özgü windFactor ile birleştirilir. Ayrıca rüzgarın genel gücünü kontrol etmek için global bir windScale parametremiz ve rüzgar deformasyonunun hangi yönde gerçekleşmesi gerektiğini belirten bir windDirection vektörümüz var.

Bu sayede çimlerimizin rüzgara göre şekil değiştirmesini sağlıyoruz. Ancak işimiz henüz bitmedi. Şu anki haliyle bu deformasyon statiktir ve rüzgarlı bir alanın etkisini yansıtmaz.

Daha önce de belirttiğimiz gibi, camımızın dalgalanabilmesi için gürültü dokusunu zaman içinde rüzgar alanının üzerine kaydırmamız gerekecek.

Bu işlem, NoiseShader'a iletilen vOffset uniform'u zaman içinde kaydırarak yapılır. Bu, belirli bir yönde (rüzgar yönümüz) gürültü ofsetini belirlememize olanak tanıyan bir vec2 parametresidir.

Bunu her karede çağrılan render işlevinde yaparız:

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
...

Hepsi bu kadar. Rüzgardan etkilenen "prosedürel çim" içeren bir sahne oluşturduk.

Karışıma toz ekleme

Şimdi sahnemizi biraz renklendirelim. Sahneyi daha ilginç hale getirmek için biraz uçuşan toz ekleyelim.

Toz ekleniyor
Toz ekleme

Toz, rüzgardan etkilenir. Bu nedenle, rüzgarlı sahnemizde tozların uçuşması son derece mantıklıdır.

Toz, initDust işlevinde parçacık sistemi olarak ayarlanır.

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

Burada 130 toz parçacığı oluşturulur. Her birinin özel bir WindParticleShader ile donatıldığını unutmayın.

Şimdi her karede, CoffeeScript kullanarak parçacıkları rüzgardan bağımsız olarak biraz hareket ettireceğiz. Kod burada.

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 )

Ayrıca her parçacığın konumunu rüzgara göre kaydıracağız. Bu işlem WindParticleShader'da yapılır. Özellikle de tepe gölgelendiricide.

Bu gölgelendiricinin kodu, Three.js ParticleMaterial'ın değiştirilmiş bir sürümüdür ve temel kısmı şu şekildedir:

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;

Bu vertex gölgelendirici, çimlerin rüzgara bağlı deformasyonu için kullandığımızdan çok farklı değil. Perlin gürültü dokusunu giriş olarak alır ve tozun dünya konumuna bağlı olarak gürültü dokusunda bir vWindForce değerini arar. Ardından, toz parçacığının konumunu değiştirmek için bu değeri kullanır.

Riders On The Storm

WebGL sahnelerimizden en maceralı olanı muhtemelen son sahneydi. Balonun içinden hortumun gözüne doğru tıklayarak sitedeki yolculuğunuzun sonuna ulaşabilir ve yakında çıkacak olan sürümün özel videosunu izleyebilirsiniz.

Balon gezisi sahnesi

Bu sahneyi oluştururken deneyimin etkili olması için merkezi bir özelliğe ihtiyacımız olduğunu biliyorduk. Dönen hortum, videonun odak noktası olacak ve diğer içerik katmanları bu özelliği şekillendirerek dramatik bir etki yaratacaktı. Bunu başarmak için bu tuhaf gölgelendiricinin etrafına bir film stüdyosu seti kurduk.

Gerçekçi bir kompozit oluşturmak için karma bir yaklaşım kullandık. Bazıları, mercek parlaması efekti oluşturmak için ışık şekilleri veya baktığınız sahnenin üzerinde katmanlar halinde canlandırılan yağmur damlaları gibi görsel hilelerdi. Diğer durumlarda, hareket ediyormuş gibi görünen düz yüzeyler çizdik. Örneğin, parçacık sistemi koduna göre hareket eden alçak uçuş bulut katmanları. Kasırganın etrafında dönen döküntü parçaları ise 3D sahnedeki katmanlar olarak kasırganın önünde ve arkasında hareket edecek şekilde sıralandı.

Sahneyi bu şekilde oluşturmamızın temel nedeni, uyguladığımız diğer efektlerle dengeli bir şekilde kasırga gölgelendiricisini işlemek için yeterli GPU'ya sahip olduğumuzdan emin olmaktı. Başlangıçta büyük GPU dengeleme sorunları yaşadık ancak daha sonra bu sahne optimize edildi ve ana sahnelerden daha hafif hale geldi.

Eğitim: Fırtına gölgelendiricisi

Son fırtına sekansını oluşturmak için birçok farklı teknik birleştirildi ancak bu çalışmanın en önemli parçası, kasırgaya benzeyen özel bir GLSL gölgelendiriciydi. İlginç geometrik girdaplar oluşturmak için vertex gölgelendiricilerden parçacık tabanlı animasyonlara ve hatta bükülmüş geometrik şekillerin 3D animasyonlarına kadar birçok farklı teknik denedik. Efektlerin hiçbiri hortum hissini tam olarak yansıtmıyordu veya çok fazla işlem gücü gerektiriyordu.

Aradığımız cevabı tamamen farklı bir projede bulduk. Max Planck Enstitüsü (brainflight.org) tarafından yürütülen ve farenin beyninin haritasını çıkarmak için bilimsel oyunlar içeren paralel bir proje, ilginç görsel efektler üretti. Özel bir hacimsel gölgelendirici kullanarak fare nöronunun içini gösteren filmler oluşturmayı başarmıştık.

Özel bir hacimsel gölgelendirici kullanılarak fare nöronunun içi
Özel bir hacimsel gölgelendirici kullanılarak fare nöronunun içinden görünüm

Beyin hücresinin içinin hortumun hunisine benzediğini gördük. Hacimsel bir teknik kullandığımız için bu gölgelendiriciyi uzayda her yönden görebileceğimizi biliyorduk. Gölgelendiricinin oluşturma işlemini, özellikle bulut katmanlarının altında ve dramatik bir arka planın üzerinde olacak şekilde fırtına sahnesiyle birleştirebiliriz.

Gölgelendirici tekniği, mesafe alanıyla ışın adımlama oluşturma adı verilen basitleştirilmiş bir oluşturma algoritmasıyla tüm nesneyi oluşturmak için temelde tek bir GLSL gölgelendirici kullanan bir hile içerir. Bu teknikte, ekrandaki her nokta için bir yüzeye en yakın mesafeyi tahmin eden bir piksel gölgelendirici oluşturulur.

Algoritmayla ilgili iyi bir referansı iq'nun şu genel bakışında bulabilirsiniz: Rendering Worlds With Two Triangles - Iñigo Quilez. glsl.heroku.com adresindeki gölgelendirici galerisini incelediğinizde, bu teknikle ilgili denemeler yapabileceğiniz birçok örnek bulabilirsiniz.

Gölgeleyicinin kalbi, ana işlevle başlar. Kamera dönüşümlerini ayarlar ve bir yüzeye olan mesafeyi tekrar tekrar değerlendiren bir döngüye girer. RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) çağrısı, temel ışın ilerleme hesaplamasının yapıldığı yerdir.

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
}

Buradaki amaç, hortumun şekline doğru ilerledikçe pikselin nihai renk değerine düzenli olarak renk katkıları ve ışın boyunca opaklık katkıları eklemektir. Bu sayede hortumun dokusuna katmanlı ve yumuşak bir görünüm kazandırılır.

Kasırganın bir sonraki temel özelliği, bir dizi işlevin birleştirilmesiyle oluşturulan şeklin kendisidir. Başlangıçta bir koni olan bu şekil, organik ve pürüzlü bir kenar oluşturmak için gürültüyle birleştirilir ve ardından ana ekseni boyunca bükülüp zaman içinde döndürülür.

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;
}

Bu tür bir gölgelendirici oluşturmak zorlu bir iştir. Oluşturduğunuz işlemlerin soyutlanmasıyla ilgili sorunların yanı sıra, çalışmayı üretimde kullanabilmeniz için izlemeniz ve çözmeniz gereken ciddi optimizasyon ve platformlar arası uyumluluk sorunları vardır.

Sorunun ilk kısmı: Bu gölgelendiriciyi sahnemiz için optimize etmek. Bu sorunu çözmek için gölgelendiricinin çok ağır olması ihtimaline karşı "güvenli" bir yaklaşım benimsememiz gerekiyordu. Bunun için, hortum gölgelendiricisini sahnenin geri kalanından farklı bir örneklenmiş çözünürlükte birleştirdik. Bu, stormTest.coffee dosyasından alınmıştır (evet, bu bir testti).

Sahne genişliği ve yüksekliğiyle eşleşen bir renderTarget ile başlarız. Böylece, hortum gölgelendiricinin çözünürlüğünü sahneden bağımsız hale getirebiliriz. Ardından, fırtına gölgelendiricisinin çözünürlüğünün alt örneklemesini, elde ettiğimiz kare hızına dinamik olarak bağlı olacak şekilde belirleriz.

...
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

Son olarak, stormTest.coffee'deki 1107. satırda basitleştirilmiş bir sal2x algoritması kullanarak hortumu ekrana oluşturuyoruz (bloklu görünümü önlemek için). Bu, en kötü durumda daha bulanık bir kasırga elde edeceğimiz ancak en azından kullanıcının kontrolünü elinden almadan çalışacağı anlamına gelir.

Bir sonraki optimizasyon adımında algoritmaya derinlemesine bakmak gerekir. Gölgelendiricideki hesaplama faktörü, yüzey işlevinin mesafesini tahmin etmek için her pikselde gerçekleştirilen yinelemedir (ışın izleme döngüsünün yineleme sayısı). Daha büyük bir adım boyutu kullanarak, bulutlu yüzeyinin dışındayken daha az iterasyonla bir hortum yüzeyi tahmini elde edebilirdik. İçeride, hassasiyet için ve puslu efekti oluşturmak üzere değerleri karıştırabilmek için adım boyutunu azaltırız. Ayrıca, yansıtılan ışın için derinlik tahmini elde etmek amacıyla sınırlayıcı bir silindir oluşturmak da iyi bir hız artışı sağladı.

Sorunun bir sonraki kısmı, bu gölgelendiricinin farklı video kartlarında çalışmasını sağlamaktı. Her seferinde bazı testler yaptık ve karşılaşabileceğimiz uyumluluk sorunlarının türü hakkında bir fikir edinmeye başladık. Sezgilerimizden daha iyi bir sonuç elde edemememizin nedeni, hatalarla ilgili her zaman iyi hata ayıklama bilgileri alamamamızdı. Tipik bir senaryoda, yalnızca bir GPU hatasıyla karşılaşırsınız ve daha fazla bilgi edinemezsiniz. Hatta sisteminiz çökebilir.

Video kartları arasındaki uyumluluk sorunlarının benzer çözümleri vardı: Statik sabitlerin, tanımlandığı şekilde tam veri türünde girildiğinden emin olun (ör. float için 0.0 ve int için 0). Daha uzun işlevler yazarken dikkatli olun. Derleyiciler belirli durumları doğru şekilde işlemiyor gibi göründüğünden, işlevleri birden fazla daha basit işleve ve ara değişkene bölmek tercih edilir. Dokuların tümünün 2'nin katı olduğundan, çok büyük olmadığından ve her durumda bir döngüde doku verilerini ararken "dikkatli" olduğunuzdan emin olun.

Uyumluluk konusunda yaşadığımız en büyük sorunlar, fırtınanın ışık efektinden kaynaklanıyordu. Kasırganın etrafına sarılmış hazır bir doku kullanarak kasırganın dumanlarını renklendirdik. Bu efekt, hortumu sahne renkleriyle harmanlamayı kolaylaştıran muhteşem bir efekt olsa da diğer platformlarda çalıştırılması uzun sürüyordu.

kasırga

Mobil Web Sitesi

Teknoloji ve işleme gereksinimleri çok ağır olduğu için mobil deneyim, masaüstü sürümünün doğrudan bir çevirisi olamazdı. Özellikle mobil kullanıcıları hedefleyen yeni bir şey oluşturmamız gerekiyordu.

Masaüstündeki Carnival Photo-Booth'u, kullanıcının mobil kamerasını kullanan bir mobil web uygulaması olarak sunmanın iyi bir fikir olacağını düşündük. Daha önce böyle bir şey görmemiştik.

Daha eğlenceli hale getirmek için CSS3'te 3D dönüşümler kodladık. Bunu jiroskop ve ivme ölçerle bağlayarak deneyime çok fazla derinlik katabildik. Site, telefonunuzu tutma, hareket ettirme ve bakma şeklinize yanıt verir.

Bu makaleyi yazarken, mobil geliştirme sürecini sorunsuz bir şekilde yürütme konusunda size bazı ipuçları vermenin faydalı olacağını düşündük. İşte başlıyorlar. Hemen inceleyip neler öğrenebileceğinizi görün.

Mobil cihazlar için ipuçları ve püf noktaları

Ön yükleyici, kaçınılması gereken değil, gerekli olan bir şeydir. Bazen ikinci durumun yaşandığını biliyoruz. Bunun temel nedeni, projeniz büyüdükçe önceden yüklediğiniz öğelerin listesini korumanız gerekmesidir. Daha da kötüsü, farklı kaynakları ve aynı anda birçok kaynağı çekiyorsanız yükleme ilerleme durumunu nasıl hesaplamanız gerektiği pek net değildir. İşte bu noktada, özel ve çok genel soyut sınıfımız "Task" devreye girer. Ana fikri, bir görevin kendi alt görevlerine sahip olabileceği ve bu alt görevlerin de kendi alt görevlerine sahip olabileceği sonsuz iç içe geçmiş bir yapıya izin vermektir. Ayrıca her görev, ilerleme durumunu alt görevlerinin ilerleme durumuna göre (ancak üst görevin ilerleme durumuna göre değil) hesaplar. Tüm MainPreloadTask, AssetPreloadTask ve TemplatePreFetchTask'leri Task'ten türeterek aşağıdaki gibi bir yapı oluşturduk:

Ön yükleyici

Bu yaklaşım ve Task sınıfı sayesinde genel ilerleme durumunu (MainPreloadTask), yalnızca öğelerin ilerleme durumunu (AssetPreloadTask) veya şablon yükleme işleminin ilerleme durumunu (TemplatePreFetchTask) kolayca öğrenebiliriz. Belirli bir dosyanın ilerleme durumunu bile görebilirsiniz. Bunun nasıl yapıldığını görmek için /m/javascripts/raw/util/Task.js adresindeki Task sınıfına ve /m/javascripts/preloading/task adresindeki gerçek görev uygulamalarına göz atın. Örnek olarak, nihai önceden yükleme sarmalayıcımız olan /m/javascripts/preloading/task/MainPreloadTask.js sınıfını nasıl oluşturduğumuzu gösteren bir alıntıyı aşağıda bulabilirsiniz:

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);

      }
    }
  })
]);

/m/javascripts/preloading/task/subtask/AssetPreloadTask.js sınıfında, MainPreloadTask ile nasıl iletişim kurduğunu (paylaşılan Task uygulaması aracılığıyla) belirtmenin yanı sıra platforma bağlı öğeleri nasıl yüklediğimizi de belirtmekte fayda var. Temel olarak dört tür görüntü vardır. Mobil standart (.ext, burada ext dosya uzantısıdır, genellikle .png veya .jpg), mobil retina (-2x.ext), tablet standart (-tab.ext) ve tablet retina (-tab-2x.ext). Algılama işlemini MainPreloadTask'te yapıp dört öğe dizisini sabit kodlamak yerine, önceden yüklenecek öğenin adını ve uzantısını, ayrıca öğenin platforma bağlı olup olmadığını (responsive = true / false) belirtiriz. Ardından AssetPreloadTask, dosya adını bizim için oluşturur:

resolveAssetUrl : function(assetName, extension, responsive) {
  return AssetPreloadTask.ASSETS_ROOT + assetName + (responsive === true ? ((Detection.getInstance().tablet ? '-tab' : '') + (Detection.getInstance().retina ? '-2x' : '')) : '') + '.' +  extension;
}

Sınıf zincirinin daha alt kısımlarında, öğe önceden yükleme işlemini gerçekleştiren gerçek kod aşağıdaki gibi görünür (/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);
}

Eğitim: HTML5 Fotoğraf Kabini (iOS6/Android)

OZ Mobile'ı geliştirirken çalışmak yerine fotoğraf kabiniyle oynayarak çok zaman harcadığımızı fark ettik :D Bunun nedeni, uygulamanın eğlenceli olmasıydı. Bu nedenle, denemeniz için bir demo hazırladık.

Mobil fotoğraf kabini
Mobil fotoğraf kabini

Canlı demoyu buradan görebilirsiniz (iPhone veya Android telefonunuzda çalıştırın):

http://u9html5rocks.appspot.com/demos/mobile_photo_booth

Arka ucu çalıştırabileceğiniz ücretsiz bir Google App Engine uygulama örneği oluşturmanız gerekir. Ön uç kodu karmaşık değildir ancak dikkat edilmesi gereken birkaç nokta vardır. Şimdi bunlara göz atalım:

  1. İzin verilen resim dosyası türü Kullanıcıların yalnızca resim yükleyebilmesini istiyoruz (video kabini değil, fotoğraf kabini olduğu için). Teorik olarak, filtreyi HTML'de aşağıdaki gibi belirtebilirsiniz: input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" Ancak bu yalnızca iOS'te çalışır. Bu nedenle, bir dosya seçildikten sonra RegExp'e ek bir kontrol eklememiz gerekir:
   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();
     }
   }
   });
  1. Yükleme veya dosya seçimini iptal etme Geliştirme sürecinde fark ettiğimiz bir diğer tutarsızlık, farklı cihazların iptal edilen dosya seçimini nasıl bildirdiğidir. iOS telefonlar ve tabletler hiçbir şey yapmaz, hiç bildirim göndermez. Bu nedenle, bu durum için özel bir işlem yapmamız gerekmez. Ancak Android telefonlar, dosya seçilmese bile add() işlevini tetikler. Bunu nasıl yapacağınız aşağıda açıklanmıştır:
    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();            
    }
    }

Diğer özellikler platformlar arasında sorunsuz çalışıyor. İyi eğlenceler!

Sonuç

Find Your Way To Oz'un devasa boyutu ve kullanılan farklı teknolojilerin geniş karışımı göz önüne alındığında, bu makalede kullandığımız yaklaşımlardan yalnızca birkaçını ele alabildik.

Her şeyi keşfetmek istiyorsanız bu bağlantıdan Oz'a Giden Yolu Bulun'un tam kaynak koduna göz atabilirsiniz.

Kredi

Katkıda bulunanların tam listesi için burayı tıklayın.

Referanslar