Nghiên cứu điển hình – Tìm đường đến xứ Oz

Giới thiệu

"Find Your Way to Oz" là một Thử nghiệm mới của Google Chrome do Disney đưa lên web. Trò chơi này cho phép bạn tham gia vào một hành trình tương tác qua một rạp xiếc ở Kansas, đưa bạn đến vùng đất Oz sau khi bạn bị một cơn bão lớn cuốn đi.

Mục tiêu của chúng tôi là kết hợp sự phong phú của điện ảnh với các chức năng kỹ thuật của trình duyệt để tạo ra một trải nghiệm thú vị, sống động mà người dùng có thể kết nối mạnh mẽ.

Công việc này hơi quá lớn để có thể nắm bắt toàn bộ trong bài viết này, vì vậy, chúng tôi đã đi sâu và rút ra một số chương cho câu chuyện công nghệ mà chúng tôi cho là thú vị. Trong quá trình này, chúng tôi đã rút ra một số hướng dẫn tập trung có độ khó tăng dần.

Nhiều người đã nỗ lực để mang đến trải nghiệm này, nhiều đến mức không thể liệt kê hết tại đây. Vui lòng truy cập vào trang web để xem trang ghi nhận tác giả trong phần trình đơn để biết toàn bộ câu chuyện.

Cơ chế hoạt động

Find Your Way to Oz trên máy tính là một thế giới phong phú và sống động. Chúng tôi sử dụng công nghệ 3D và nhiều lớp hiệu ứng lấy cảm hứng từ kỹ thuật làm phim truyền thống để tạo nên một cảnh gần như chân thực. Các công nghệ nổi bật nhất là WebGL với Three.js, chương trình đổ bóng tuỳ chỉnh và các phần tử động DOM sử dụng các tính năng CSS3. Ngoài ra, getUserMedia API (WebRTC) cho trải nghiệm tương tác cho phép người dùng thêm hình ảnh của họ trực tiếp từ Webcam và WebAudio cho âm thanh 3D.

Nhưng điều kỳ diệu của một trải nghiệm công nghệ như thế này là cách mọi thứ kết hợp với nhau. Đây cũng là một trong những thách thức chính: làm thế nào để kết hợp hiệu ứng hình ảnh và các thành phần tương tác trong một cảnh để tạo nên một tổng thể nhất quán? Sự phức tạp về mặt hình ảnh này rất khó quản lý, khiến chúng tôi khó biết được mình đang ở giai đoạn nào trong quá trình phát triển tại bất kỳ thời điểm nào.

Để giải quyết vấn đề về hiệu ứng hình ảnh và tối ưu hoá có liên quan đến nhau, chúng tôi đã sử dụng rất nhiều bảng điều khiển để ghi lại tất cả các chế độ cài đặt liên quan mà chúng tôi đang xem xét tại thời điểm đó. Cảnh có thể được điều chỉnh trực tiếp trong trình duyệt cho mọi thứ, từ độ sáng đến độ sâu trường ảnh, gamma, v.v. Bất kỳ ai cũng có thể thử điều chỉnh giá trị của các tham số quan trọng trong trải nghiệm và tham gia khám phá xem điều gì hiệu quả nhất.

Trước khi chia sẻ bí mật, chúng tôi muốn cảnh báo bạn rằng bí mật này có thể gây ra sự cố, giống như khi bạn can thiệp vào động cơ ô tô. Đảm bảo rằng bạn không có nội dung quan trọng nào đang bật, sau đó truy cập vào URL chính của trang web và thêm ?debug=on vào địa chỉ. Chờ trang web tải xong và khi bạn đã vào trang web, hãy (nhấn?) phím Ctrl-I. Bạn sẽ thấy một trình đơn thả xuống xuất hiện ở bên phải. Nếu bỏ đánh dấu mục "Thoát khỏi đường dẫn camera", bạn có thể dùng các phím A, W, S, D và chuột để di chuyển tự do trong không gian.

Đường dẫn camera.

Chúng tôi sẽ không đi sâu vào tất cả các chế độ cài đặt ở đây, nhưng bạn nên thử nghiệm: các phím sẽ hiển thị các chế độ cài đặt khác nhau trong các cảnh khác nhau. Trong cảnh bão cuối cùng, có một phím bổ sung: Ctrl-A để bạn có thể bật/tắt chế độ phát ảnh động và bay xung quanh. Trong cảnh này, nếu nhấn Esc (để thoát khỏi chức năng khoá chuột) và nhấn lại Ctrl-I, bạn có thể truy cập vào các chế độ cài đặt dành riêng cho cảnh bão. Hãy quan sát xung quanh và chụp một số bức ảnh đẹp như bưu thiếp, chẳng hạn như bức ảnh dưới đây.

Cảnh bão

Để làm được điều này và đảm bảo tính linh hoạt phù hợp với nhu cầu, chúng tôi đã sử dụng một thư viện tuyệt vời có tên là dat.gui (xem tại đây để biết hướng dẫn trước đây về cách sử dụng thư viện này). Nhờ đó, chúng tôi có thể nhanh chóng thay đổi những chế độ cài đặt mà khách truy cập trang web nhìn thấy.

Hơi giống tranh mờ

Trong nhiều bộ phim và hoạt hình kinh điển của Disney, việc tạo cảnh đồng nghĩa với việc kết hợp nhiều lớp khác nhau. Có các lớp cảnh quay người thật, hoạt hình vẽ tay, thậm chí cả bối cảnh thực tế và các lớp trên cùng được tạo bằng cách vẽ trên kính: một kỹ thuật gọi là vẽ mờ.

Cấu trúc của trải nghiệm mà chúng tôi tạo ra cũng tương tự như vậy, mặc dù một số "lớp" không chỉ là hình ảnh tĩnh. Trên thực tế, chúng ảnh hưởng đến giao diện của mọi thứ theo các phép tính phức tạp hơn. Tuy nhiên, ít nhất là ở cấp độ tổng quan, chúng ta đang xử lý các khung hiển thị, được kết hợp chồng lên nhau. Ở trên cùng, bạn sẽ thấy một lớp giao diện người dùng, với cảnh 3D bên dưới: bản thân cảnh này được tạo từ nhiều thành phần cảnh khác nhau.

Lớp giao diện trên cùng được tạo bằng DOM và CSS 3, nghĩa là bạn có thể chỉnh sửa các hoạt động tương tác theo nhiều cách độc lập với trải nghiệm 3D, trong đó hoạt động giao tiếp giữa hai lớp này dựa trên một danh sách sự kiện được chọn. Quá trình giao tiếp này sử dụng Backbone Router + sự kiện onHashChange HTML5 để kiểm soát khu vực nào sẽ tạo ảnh động vào/ra. (nguồn dự án: /develop/coffee/router/Router.coffee).

Hướng dẫn: Tấm sprite và tính năng hỗ trợ Retina

Một kỹ thuật tối ưu hoá thú vị mà chúng tôi dựa vào cho giao diện là kết hợp nhiều hình ảnh lớp phủ giao diện trong một PNG duy nhất để giảm các yêu cầu của máy chủ. Trong dự án này, giao diện được tạo thành từ hơn 70 hình ảnh (không tính kết cấu 3D) được tải trước để giảm độ trễ của trang web. Bạn có thể xem tấm sprite đang hoạt động tại đây:

Màn hình thông thường – http://findyourwaytooz.com/img/home/interface_1x.png Màn hình Retina – http://findyourwaytooz.com/img/home/interface_2x.png

Sau đây là một số mẹo về cách chúng tôi tận dụng việc sử dụng Tấm sprite, cũng như cách sử dụng chúng cho các thiết bị Retina và làm cho giao diện sắc nét và gọn gàng nhất có thể.

Tạo Spritesheet

Để tạo SpriteSheet, chúng tôi đã sử dụng TexturePacker, công cụ này có thể xuất ra mọi định dạng bạn cần. Trong trường hợp này, chúng tôi đã xuất dưới dạng EaselJS, một định dạng thực sự gọn gàng và cũng có thể được dùng để tạo các sprite động.

Sử dụng Tấm sprite đã tạo

Sau khi tạo Tấm sprite, bạn sẽ thấy một tệp JSON như sau:

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

Trong trường hợp:

  • image là URL của tấm sprite
  • khung là toạ độ của từng phần tử trên giao diện người dùng [x, y, chiều rộng, chiều cao]
  • ảnh động là tên của từng thành phần

Lưu ý rằng chúng tôi đã sử dụng hình ảnh có mật độ cao để tạo Tấm sprite, sau đó chúng tôi đã tạo phiên bản thông thường chỉ bằng cách đổi kích thước thành một nửa kích thước của phiên bản đó.

Mối tương quan giữa các yếu tố

Giờ đây, khi đã thiết lập xong, chúng ta chỉ cần một đoạn mã JavaScript để sử dụng.

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

Và đây là cách bạn sử dụng:

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

Để hiểu thêm một chút về Mật độ pixel biến đổi, bạn có thể đọc bài viết này của Boris Smus.

Quy trình tạo nội dung 3D

Trải nghiệm môi trường được thiết lập trên một lớp WebGL. Khi nghĩ về một cảnh 3D, một trong những câu hỏi hóc búa nhất là làm thế nào để đảm bảo bạn có thể tạo nội dung cho phép thể hiện tối đa tiềm năng từ các khía cạnh mô hình, ảnh động và hiệu ứng. Về nhiều mặt, cốt lõi của vấn đề này là quy trình nội dung: một quy trình đã được thống nhất để tạo nội dung cho cảnh 3D.

Chúng tôi muốn tạo ra một thế giới đầy cảm hứng, vì vậy chúng tôi cần một quy trình vững chắc để các nghệ sĩ 3D có thể tạo ra thế giới đó. Họ cần được tự do thể hiện ý tưởng trong phần mềm tạo mô hình và ảnh động 3D; còn chúng tôi cần kết xuất hình ảnh đó trên màn hình thông qua mã.

Chúng tôi đã giải quyết vấn đề này trong một thời gian vì mỗi lần tạo trang web 3D trước đây, chúng tôi đều gặp phải những hạn chế trong các công cụ có thể sử dụng. Vì vậy, chúng tôi đã tạo ra công cụ này, gọi là 3D Librarian: một nghiên cứu nội bộ. Và giờ đây, mô hình này đã sẵn sàng để áp dụng vào một công việc thực tế.

Công cụ này có một số điểm đáng chú ý: ban đầu, công cụ này dành cho Flash và cho phép bạn đưa một cảnh Maya lớn vào dưới dạng một tệp nén duy nhất được tối ưu hoá để giải nén trong thời gian chạy. Lý do khiến định dạng này tối ưu là vì nó đóng gói cảnh một cách hiệu quả trong cùng một cấu trúc dữ liệu được thao tác trong quá trình kết xuất và tạo ảnh động. Có rất ít thao tác phân tích cú pháp cần thực hiện đối với tệp khi tải. Quá trình giải nén trong Flash diễn ra khá nhanh vì tệp ở định dạng AMF, nên Flash có thể giải nén ngay. Việc sử dụng cùng một định dạng trong WebGL đòi hỏi CPU phải xử lý nhiều hơn một chút. Trên thực tế, chúng tôi phải tạo lại một lớp mã Javascript giải nén dữ liệu, về cơ bản sẽ giải nén các tệp đó và tạo lại cấu trúc dữ liệu cần thiết để WebGL hoạt động. Việc giải nén toàn bộ cảnh 3D là một thao tác tương đối nặng đối với CPU: việc giải nén cảnh 1 trong Find Your Way To Oz (Tìm đường đến xứ Oz) mất khoảng 2 giây trên một máy tầm trung đến cao cấp. Do đó, việc này được thực hiện bằng công nghệ Web Workers, tại thời điểm "thiết lập cảnh" (trước khi cảnh thực sự được khởi chạy), để không làm gián đoạn trải nghiệm của người dùng.

Công cụ tiện dụng này có thể nhập hầu hết cảnh 3D: mô hình, kết cấu, ảnh động xương. Bạn tạo một tệp thư viện duy nhất, sau đó công cụ 3D có thể tải tệp này. Bạn đưa tất cả mô hình cần thiết vào cảnh trong thư viện này, sau đó tạo chúng trong cảnh.

Tuy nhiên, chúng tôi gặp phải một vấn đề là chúng tôi đang xử lý WebGL: một công nghệ mới. Đây là một đứa trẻ khá cứng đầu: nó đặt ra tiêu chuẩn cho trải nghiệm 3D trên trình duyệt. Vì vậy, chúng tôi đã tạo một lớp Javascript đặc biệt để lấy các tệp cảnh 3D nén của 3D Librarian và dịch chúng sang định dạng mà WebGL có thể hiểu được.

Hướng dẫn: Hãy để gió thổi

Gió là một chủ đề lặp lại trong "Find Your Way To Oz". Một mạch truyện được xây dựng để trở thành một cơn gió mạnh dần.

Cảnh đầu tiên của lễ hội tương đối yên bình. Và khi đi qua các cảnh khác nhau, người dùng sẽ trải nghiệm gió ngày càng mạnh, đỉnh điểm là cảnh cuối cùng, cơn bão.

Do đó, việc cung cấp hiệu ứng gió sống động là rất quan trọng.

Để tạo hiệu ứng này, chúng tôi đã đưa vào 3 cảnh lễ hội những vật thể mềm, tức là những vật thể chịu ảnh hưởng của gió, chẳng hạn như lều, cờ, bề mặt của buồng chụp ảnh và chính quả bóng bay.

Vải mềm.

Trò chơi trên máy tính ngày nay thường được xây dựng dựa trên một công cụ vật lý cốt lõi. Vì vậy, khi cần mô phỏng một vật thể mềm trong thế giới 3D, một mô phỏng vật lý đầy đủ sẽ được chạy cho vật thể đó, tạo ra hành vi mềm mại đáng tin cậy.

Trong WebGL / Javascript, chúng ta (chưa) có khả năng chạy một mô phỏng vật lý hoàn chỉnh. Vì vậy, trong Oz, chúng tôi phải tìm cách tạo ra hiệu ứng gió mà không thực sự mô phỏng nó.

Chúng tôi đã nhúng thông tin về "độ nhạy với gió" cho từng đối tượng trong chính mô hình 3D. Mỗi đỉnh của mô hình 3D có một "Thuộc tính gió" chỉ định mức độ ảnh hưởng của gió đối với đỉnh đó. Vì vậy, điều này chỉ định độ nhạy của gió đối với Đối tượng 3D. Sau đó, chúng tôi cần tạo ra gió.

Chúng tôi đã thực hiện việc này bằng cách tạo hình ảnh chứa Nhiễu Perlin. Hình ảnh này dùng để bao phủ một "vùng gió" nhất định. Vì vậy, cách tốt nhất để hình dung là tưởng tượng một bức ảnh có mây như tiếng ồn được đặt trên một vùng hình chữ nhật nhất định của cảnh 3D. Mỗi pixel, giá trị mức xám, của hình ảnh này chỉ định mức độ mạnh của gió tại một thời điểm nhất định trong khu vực 3D "xung quanh nó".

Để tạo hiệu ứng gió, hình ảnh sẽ được di chuyển theo thời gian, với tốc độ không đổi, theo một hướng cụ thể; hướng gió. Để đảm bảo "vùng có gió" không ảnh hưởng đến mọi thứ trong cảnh, chúng ta sẽ bao bọc hình ảnh gió quanh các cạnh, giới hạn trong vùng chịu ảnh hưởng.

Hướng dẫn đơn giản về gió 3D

Bây giờ, hãy tạo hiệu ứng gió trong một cảnh 3D đơn giản trong Three.js.

Chúng ta sẽ tạo gió trong một "cánh đồng cỏ theo quy trình" đơn giản.

Trước tiên, hãy tạo cảnh. Chúng ta sẽ có một địa hình phẳng, đơn giản và có hoạ tiết. Sau đó, mỗi ngọn cỏ sẽ được biểu diễn bằng một hình nón 3D lộn ngược.

Địa hình phủ đầy cỏ
Địa hình phủ đầy cỏ

Sau đây là cách tạo cảnh đơn giản này trong Three.js bằng CoffeeScript.

Trước tiên, chúng ta sẽ thiết lập Three.js và kết nối với Camera, Bộ điều khiển chuột và một số loại Ánh sáng:

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

Các lệnh gọi hàm initGrass và initTerrain sẽ lần lượt điền cỏ và địa hình vào cảnh:

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

Ở đây, chúng ta sẽ tạo một lưới gồm 15 x 15 ô cỏ. Chúng tôi thêm một chút sắp xếp ngẫu nhiên vào mỗi vị trí cỏ để chúng không xếp hàng như lính, điều này sẽ trông kỳ lạ.

Địa hình này chỉ là một mặt phẳng nằm ngang, được đặt ở chân các ngọn cỏ (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 )

Vậy là chúng ta đã tạo được một cảnh Three.js đơn giản, thêm một vài ngọn cỏ làm từ hình nón ngược được tạo theo quy trình và một địa hình đơn giản.

Chưa có gì đặc biệt.

Bây giờ, đã đến lúc bắt đầu thêm gió. Trước tiên, chúng ta muốn nhúng thông tin về độ nhạy của gió vào mô hình 3D của cỏ.

Chúng ta sẽ nhúng thông tin này dưới dạng thuộc tính tùy chỉnh cho mỗi đỉnh của mô hình 3D cỏ. Chúng ta sẽ sử dụng quy tắc: phần dưới cùng của mô hình cỏ (đỉnh của hình nón) có độ nhạy bằng 0 vì nó gắn liền với mặt đất. Phần trên cùng của mô hình cỏ (đáy hình nón) có độ nhạy gió tối đa, vì đây là phần xa mặt đất nhất.

Dưới đây là cách mã hoá lại hàm instanceGrass để thêm độ nhạy với gió làm thuộc tính tuỳ chỉnh cho mô hình 3D của cỏ.

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

Bây giờ, chúng ta sử dụng một chất liệu tuỳ chỉnh, windMaterial, thay vì MeshPhongMaterial mà chúng ta đã sử dụng trước đó. WindMaterial gói WindMeshShader mà chúng ta sẽ thấy trong giây lát.

Vì vậy, mã trong instanceGrass sẽ lặp qua tất cả các đỉnh của mô hình cỏ và đối với mỗi đỉnh, mã này sẽ thêm một thuộc tính đỉnh tuỳ chỉnh, được gọi là windFactor. windFactor này được đặt thành 0 cho phần cuối của mô hình cỏ (nơi cỏ tiếp xúc với địa hình) và có giá trị là 1 cho phần đầu của mô hình cỏ.

Thành phần khác mà chúng ta cần là thêm gió thực tế vào cảnh. Như đã thảo luận, chúng ta sẽ sử dụng nhiễu Perlin cho việc này. Chúng ta sẽ tạo một kết cấu nhiễu Perlin theo quy trình.

Để cho rõ ràng, chúng ta sẽ gán kết cấu này cho chính địa hình, thay cho kết cấu màu xanh lục trước đó. Điều này sẽ giúp bạn dễ dàng nắm bắt tình hình gió.

Vì vậy, kết cấu nhiễu Perlin này sẽ bao phủ không gian mở rộng của địa hình và mỗi pixel của kết cấu sẽ chỉ định cường độ gió của khu vực địa hình nơi pixel đó rơi xuống. Hình chữ nhật địa hình sẽ là "vùng gió" của chúng ta.

Nhiễu Perlin được tạo theo quy trình thông qua một chương trình đổ bóng, có tên là NoiseShader. Trình đổ bóng này sử dụng thuật toán nhiễu đơn giản 3D từ: https://github.com/ashima/webgl-noise . Phiên bản WebGL của mẫu này được lấy nguyên văn từ một trong các mẫu Three.js của MrDoob, tại: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader lấy một tập hợp tham số thời gian, tỷ lệ và độ lệch làm đồng nhất, đồng thời xuất ra một phân phối 2D đẹp mắt của nhiễu 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) }

...

Chúng ta sẽ sử dụng Chương trình đổ bóng này để kết xuất Nhiễu Perlin thành một hoạ tiết. Việc này được thực hiện trong hàm 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 )

Đoạn mã trên thiết lập noiseMap làm mục tiêu kết xuất Three.js, trang bị cho mục tiêu này NoiseShader, sau đó kết xuất bằng camera trực giao để tránh bị méo phối cảnh.

Như đã thảo luận, giờ đây, chúng ta cũng sẽ sử dụng kết cấu này làm kết cấu kết xuất chính cho địa hình. Điều này không thực sự cần thiết để hiệu ứng gió hoạt động. Nhưng có thì vẫn tốt hơn, để chúng ta có thể hiểu rõ hơn về những gì đang diễn ra với việc sản xuất điện gió.

Dưới đây là hàm initTerrain được làm lại, sử dụng noiseMap làm kết cấu:

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 )

Bây giờ, khi đã có kết cấu gió, hãy xem WindMeshShader, chịu trách nhiệm biến dạng các mô hình cỏ theo gió.

Để tạo chương trình đổ bóng này, chúng tôi bắt đầu từ chương trình đổ bóng MeshPhongMaterial tiêu chuẩn của Three.js và sửa đổi chương trình đó. Đây là một cách nhanh chóng và đơn giản để bắt đầu với một chương trình đổ bóng hoạt động mà không cần phải bắt đầu từ đầu.

Chúng ta sẽ không sao chép toàn bộ mã chương trình đổ bóng ở đây (vui lòng xem mã này trong tệp mã nguồn), vì hầu hết mã này sẽ là bản sao của chương trình đổ bóng MeshPhongMaterial. Nhưng hãy xem các phần đã sửa đổi, liên quan đến gió, trong 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;

Vì vậy, việc đầu tiên mà chương trình đổ bóng này làm là tính toán toạ độ tra cứu kết cấu windUV, dựa trên vị trí 2D, xz (ngang) của đỉnh. Toạ độ UV này được dùng để tra cứu lực gió, vWindForce, từ kết cấu gió nhiễu Perlin.

Giá trị vWindForce này được kết hợp với thuộc tính tùy chỉnh windFactor dành riêng cho đỉnh được thảo luận ở trên, để tính toán mức độ biến dạng mà đỉnh cần. Chúng ta cũng có một tham số windScale chung để kiểm soát cường độ tổng thể của gió và một vectơ windDirection chỉ định hướng mà biến dạng gió cần diễn ra.

Vì vậy, điều này tạo ra biến dạng dựa trên gió của các mảnh cỏ của chúng tôi. Tuy nhiên, chúng tôi vẫn chưa hoàn tất. Hiện tại, biến dạng này là tĩnh và sẽ không truyền tải hiệu ứng của một khu vực có gió.

Như đã đề cập, chúng ta cần trượt kết cấu nhiễu theo thời gian, trên vùng có gió, để kính có thể gợn sóng.

Bạn có thể thực hiện việc này bằng cách dịch chuyển theo thời gian, đồng nhất vOffset được truyền đến NoiseShader. Đây là tham số vec2, cho phép chúng ta chỉ định độ lệch nhiễu, dọc theo một hướng nhất định (hướng gió).

Chúng ta thực hiện việc này trong hàm render, được gọi ở mọi khung hình:

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

Vậy là xong! Chúng ta vừa tạo một cảnh có "cỏ theo quy trình" chịu ảnh hưởng của gió.

Thêm bụi vào hỗn hợp

Bây giờ, hãy làm cho cảnh của chúng ta thêm phần thú vị. Hãy thêm một chút bụi bay để cảnh quay trở nên thú vị hơn.

Đang thêm bụi
Thêm bụi

Bụi phải chịu tác động của gió, vì vậy, việc bụi bay xung quanh trong cảnh gió là hoàn toàn hợp lý.

Bụi được thiết lập trong hàm initDust dưới dạng một hệ thống hạt.

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

Ở đây, 130 hạt bụi được tạo ra. Và lưu ý rằng mỗi hạt đều được trang bị một WindParticleShader đặc biệt.

Bây giờ, ở mỗi khung hình, chúng ta sẽ di chuyển các hạt một chút, sử dụng CoffeeScript, độc lập với gió. Sau đây là mã.

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 )

Ngoài ra, chúng ta sẽ bù trừ vị trí của từng hạt theo gió. Việc này được thực hiện trong WindParticleShader. Cụ thể là trong chương trình đổ bóng đỉnh chóp (vertex).

Mã cho chương trình đổ bóng này là phiên bản sửa đổi của ParticleMaterial của Three.js và đây là giao diện cốt lõi của chương trình:

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;

Trình đổ bóng đỉnh này không khác nhiều so với trình đổ bóng mà chúng ta đã có cho biến dạng cỏ dựa trên gió. Hàm này lấy kết cấu nhiễu Perlin làm dữ liệu đầu vào và tuỳ thuộc vào vị trí của bụi trong thế giới, hàm này sẽ tra cứu giá trị vWindForce trong kết cấu nhiễu. Sau đó, trình phân tích cú pháp sẽ dùng giá trị này để sửa đổi vị trí của hạt bụi.

Riders On The Storm

Cảnh WebGL mạo hiểm nhất của chúng tôi có lẽ là cảnh cuối cùng. Bạn có thể thấy cảnh này nếu nhấp vào quả bóng bay để đi vào mắt bão và đến điểm cuối của hành trình trên trang web, cũng như xem video độc quyền về bản phát hành sắp tới.

Cảnh đi khinh khí cầu

Khi tạo cảnh này, chúng tôi biết rằng mình cần có một tính năng trung tâm để mang lại trải nghiệm ấn tượng. Cơn lốc xoáy quay tròn sẽ đóng vai trò là tâm điểm và các lớp nội dung khác sẽ định hình tính năng này để tạo hiệu ứng ấn tượng. Để làm được điều này, chúng tôi đã xây dựng một bối cảnh tương đương với phim trường xung quanh chương trình đổ bóng kỳ lạ này.

Chúng tôi đã sử dụng phương pháp kết hợp để tạo ra hình ảnh tổng hợp chân thực. Một số là thủ thuật hình ảnh như hình dạng ánh sáng để tạo hiệu ứng loá ống kính hoặc hạt mưa chuyển động dưới dạng các lớp trên cảnh bạn đang xem. Trong những trường hợp khác, chúng tôi có các bề mặt phẳng được vẽ để trông như đang di chuyển, chẳng hạn như các lớp mây bay thấp di chuyển theo mã hệ thống hạt. Trong khi đó, các mảnh vỡ quay quanh lốc xoáy là các lớp trong cảnh 3D được sắp xếp để di chuyển phía trước và phía sau lốc xoáy.

Lý do chính khiến chúng tôi phải xây dựng cảnh theo cách này là để đảm bảo có đủ GPU để xử lý chương trình đổ bóng lốc xoáy, cân bằng với các hiệu ứng khác mà chúng tôi đang áp dụng. Ban đầu, chúng tôi gặp vấn đề lớn về cân bằng GPU, nhưng sau đó cảnh này đã được tối ưu hoá và trở nên nhẹ hơn các cảnh chính.

Hướng dẫn: Trình đổ bóng bão

Để tạo ra cảnh bão cuối cùng, nhiều kỹ thuật khác nhau đã được kết hợp, nhưng trọng tâm của tác phẩm này là một chương trình đổ bóng GLSL tuỳ chỉnh trông giống như một cơn lốc xoáy. Chúng tôi đã thử nhiều kỹ thuật khác nhau, từ chương trình đổ bóng đỉnh để tạo ra các xoáy hình học thú vị cho đến ảnh động dựa trên hạt và thậm chí cả ảnh động 3D của các hình dạng hình học xoắn. Không có hiệu ứng nào tái tạo được cảm giác của một cơn lốc xoáy hoặc đòi hỏi quá nhiều về mặt xử lý.

Một dự án hoàn toàn khác cuối cùng đã cho chúng tôi câu trả lời. Một dự án song song liên quan đến trò chơi khoa học nhằm lập bản đồ não chuột của Viện Max Planck (brainflight.org) đã tạo ra các hiệu ứng hình ảnh thú vị. Chúng tôi đã tạo được video về bên trong nơ-ron của chuột bằng cách sử dụng chương trình đổ bóng thể tích tuỳ chỉnh.

Bên trong nơ-ron của chuột bằng cách sử dụng chương trình đổ bóng thể tích tuỳ chỉnh
Bên trong một nơ-ron của chuột bằng cách sử dụng chương trình đổ bóng thể tích tuỳ chỉnh

Chúng tôi nhận thấy bên trong tế bào não trông giống như phễu của một cơn lốc xoáy. Và vì đang sử dụng kỹ thuật thể tích, chúng tôi biết rằng chúng tôi có thể xem chương trình đổ bóng này từ mọi hướng trong không gian. Chúng ta có thể thiết lập chế độ kết xuất của chương trình đổ bóng để kết hợp với cảnh bão, đặc biệt là khi được kẹp giữa các lớp mây và phía trên một nền ấn tượng.

Kỹ thuật đổ bóng liên quan đến một thủ thuật về cơ bản sử dụng một chương trình đổ bóng GLSL duy nhất để kết xuất toàn bộ đối tượng bằng thuật toán kết xuất đơn giản hoá, được gọi là kết xuất hành trình tia với trường khoảng cách. Trong kỹ thuật này, một chương trình đổ bóng pixel được tạo ra để ước tính khoảng cách gần nhất đến một bề mặt cho mỗi điểm trên màn hình.

Bạn có thể tìm thấy thông tin tham khảo hữu ích về thuật toán này trong bài viết tổng quan của iq: Rendering Worlds With Two Triangles – Iñigo Quilez (Kết xuất thế giới bằng hai hình tam giác – Iñigo Quilez). Ngoài ra, khi khám phá thư viện chương trình đổ bóng trên glsl.heroku.com, bạn có thể tìm thấy nhiều ví dụ về kỹ thuật này để thử nghiệm.

Trọng tâm của chương trình đổ bóng bắt đầu bằng hàm chính, thiết lập các phép biến đổi camera và nhập một vòng lặp liên tục đánh giá khoảng cách đến một bề mặt. Lệnh gọi RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) là nơi diễn ra phép tính hành trình tia chính.

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
}

Ý tưởng là khi tiến vào hình dạng của lốc xoáy, chúng ta thường xuyên thêm các phần đóng góp về màu sắc vào giá trị màu cuối cùng của pixel, cũng như các phần đóng góp vào độ mờ dọc theo tia. Điều này tạo ra một kết cấu mềm mại nhiều lớp cho lốc xoáy.

Khía cạnh cốt lõi tiếp theo của lốc xoáy là hình dạng thực tế được tạo bằng cách kết hợp một số hàm. Ban đầu, đây là một hình nón, được kết hợp với nhiễu để tạo ra một cạnh thô tự nhiên, sau đó được xoắn dọc theo trục chính và xoay theo thời gian.

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

Công việc liên quan đến việc tạo loại chương trình đổ bóng này rất phức tạp. Ngoài các vấn đề liên quan đến việc trừu tượng hoá các thao tác bạn đang tạo, còn có các vấn đề nghiêm trọng về khả năng tối ưu hoá và khả năng tương thích trên nhiều nền tảng mà bạn cần theo dõi và giải quyết trước khi có thể sử dụng công việc trong môi trường thực tế.

Phần đầu tiên của vấn đề: tối ưu hoá chương trình đổ bóng này cho cảnh của chúng ta. Để giải quyết vấn đề này, chúng tôi cần có một phương pháp "an toàn" trong trường hợp chương trình đổ bóng quá nặng. Để làm được điều này, chúng tôi đã kết hợp chương trình đổ bóng lốc xoáy ở độ phân giải được lấy mẫu khác với phần còn lại của cảnh. Đây là từ tệp stormTest.coffee (vâng, đây là một thử nghiệm!).

Chúng ta bắt đầu bằng một renderTarget khớp với chiều rộng và chiều cao của cảnh để có thể có độ phân giải độc lập của chương trình đổ bóng lốc xoáy cho cảnh. Sau đó, chúng tôi quyết định giảm tần số lấy mẫu của độ phân giải của chương trình đổ bóng bão một cách linh động, tuỳ thuộc vào tốc độ khung hình mà chúng tôi nhận được.

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

Cuối cùng, chúng tôi kết xuất lốc xoáy lên màn hình bằng thuật toán sal2x đơn giản (để tránh giao diện khối) @line 1107 trong stormTest.coffee. Điều này có nghĩa là trong trường hợp xấu nhất, chúng ta sẽ có một cơn lốc xoáy mờ hơn, nhưng ít nhất thì nó vẫn hoạt động mà không làm mất quyền kiểm soát của người dùng.

Bước tối ưu hoá tiếp theo đòi hỏi bạn phải tìm hiểu sâu về thuật toán. Yếu tố tính toán thúc đẩy trong chương trình đổ bóng là phép lặp được thực hiện trên mỗi pixel để cố gắng ước chừng khoảng cách của hàm bề mặt: số lần lặp của vòng lặp raymarching. Bằng cách sử dụng kích cỡ bước lớn hơn, chúng ta có thể ước tính bề mặt lốc xoáy với ít vòng lặp hơn khi ở bên ngoài bề mặt mây của nó. Khi ở bên trong, chúng ta sẽ giảm kích cỡ bước để tăng độ chính xác và có thể kết hợp các giá trị để tạo hiệu ứng sương mù. Ngoài ra, việc tạo một hình trụ giới hạn để ước tính độ sâu cho tia được truyền cũng giúp tăng tốc độ đáng kể.

Phần tiếp theo của vấn đề là đảm bảo chương trình đổ bóng này sẽ chạy trên nhiều cạc video. Chúng tôi đã tiến hành một số thử nghiệm mỗi lần và bắt đầu xây dựng trực giác về loại vấn đề tương thích mà chúng tôi có thể gặp phải. Lý do chúng tôi không thể làm tốt hơn trực giác là vì không phải lúc nào chúng tôi cũng có thể nhận được thông tin gỡ lỗi chính xác về các lỗi. Một trường hợp điển hình là lỗi GPU mà không có thêm thông tin nào khác, hoặc thậm chí là sự cố hệ thống!

Các vấn đề về khả năng tương thích giữa các bo mạch video cũng có giải pháp tương tự: đảm bảo các hằng số tĩnh được nhập đúng kiểu dữ liệu như đã xác định, ví dụ: 0.0 cho số thực và 0 cho số nguyên. Hãy cẩn thận khi viết các hàm dài hơn; tốt hơn là nên chia nhỏ thành nhiều hàm đơn giản hơn và các biến tạm thời vì trình biên dịch dường như không xử lý đúng một số trường hợp. Đảm bảo tất cả hoạ tiết đều là luỹ thừa của 2, không quá lớn và trong mọi trường hợp, hãy "thận trọng" khi tra cứu dữ liệu hoạ tiết trong một vòng lặp.

Vấn đề lớn nhất mà chúng tôi gặp phải về khả năng tương thích là hiệu ứng ánh sáng cho cơn bão. Chúng tôi đã sử dụng một kết cấu tạo sẵn bao quanh lốc xoáy để có thể tô màu cho các dải mây. Đây là một hiệu ứng tuyệt đẹp và giúp dễ dàng kết hợp lốc xoáy vào màu sắc của cảnh, nhưng mất nhiều thời gian để thử chạy trên các nền tảng khác.

lốc xoáy

Trang web dành cho thiết bị di động

Trải nghiệm trên thiết bị di động không thể là bản dịch trực tiếp của phiên bản dành cho máy tính vì yêu cầu về công nghệ và xử lý quá nặng. Chúng tôi phải xây dựng một giải pháp mới, nhắm đến người dùng thiết bị di động nói riêng.

Chúng tôi nghĩ rằng sẽ rất thú vị nếu có Carnival Photo-Booth từ máy tính dưới dạng ứng dụng web dành cho thiết bị di động, sử dụng camera di động của người dùng. Điều mà chúng tôi chưa từng thấy trước đây.

Để tăng thêm phần thú vị, chúng tôi đã lập trình các phép biến đổi 3D trong CSS3. Khi liên kết với con quay hồi chuyển và gia tốc kế, chúng tôi có thể mang đến trải nghiệm có chiều sâu hơn. Trang web này phản hồi theo cách bạn cầm, di chuyển và nhìn vào điện thoại.

Khi viết bài viết này, chúng tôi nghĩ rằng bạn nên biết một số gợi ý về cách chạy quy trình phát triển thiết bị di động một cách suôn sẻ. Họ đây rồi! Hãy thử xem bạn có thể học được gì từ đó!

Mẹo và thủ thuật cho thiết bị di động

Trình tải trước là một thành phần cần thiết, không phải là thành phần nên tránh. Chúng tôi biết rằng đôi khi trường hợp thứ hai vẫn xảy ra. Điều này chủ yếu là do bạn cần duy trì danh sách những nội dung bạn tải trước khi dự án phát triển. Tệ hơn nữa, bạn không biết rõ cách tính tiến trình tải nếu đang lấy nhiều tài nguyên khác nhau cùng một lúc. Đây là lúc lớp trừu tượng "Task" (Tác vụ) chung và tuỳ chỉnh của chúng ta phát huy tác dụng. Ý tưởng chính của mô hình này là cho phép cấu trúc lồng nhau vô tận, trong đó một Nhiệm vụ có thể có các Nhiệm vụ phụ của riêng mình, các Nhiệm vụ phụ này có thể có các Nhiệm vụ phụ khác, v.v. Hơn nữa, mỗi nhiệm vụ sẽ tính toán tiến trình của mình dựa trên tiến trình của các nhiệm vụ phụ (nhưng không dựa trên tiến trình của nhiệm vụ mẹ). Khi cho tất cả MainPreloadTask, AssetPreloadTask và TemplatePreFetchTask kế thừa từ Task, chúng ta đã tạo ra một cấu trúc như sau:

Trình tải trước

Nhờ phương pháp này và lớp Task, chúng ta có thể dễ dàng biết được tiến trình chung (MainPreloadTask), hoặc chỉ tiến trình của thành phần (AssetPreloadTask), hoặc tiến trình tải mẫu (TemplatePreFetchTask). Thậm chí là tiến trình của một tệp cụ thể. Để xem cách thực hiện, hãy xem lớp Task tại /m/javascripts/raw/util/Task.js và các cách triển khai tác vụ thực tế tại /m/javascripts/preloading/task. Ví dụ: đây là một đoạn trích về cách chúng tôi thiết lập lớp /m/javascripts/preloading/task/MainPreloadTask.js, đây là trình bao bọc tải trước tối ưu của chúng tôi:

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

      }
    }
  })
]);

Trong lớp /m/javascripts/preloading/task/subtask/AssetPreloadTask.js, ngoài việc lưu ý cách lớp này giao tiếp với MainPreloadTask (thông qua việc triển khai Nhiệm vụ dùng chung), bạn cũng nên lưu ý cách chúng tôi tải các thành phần phụ thuộc vào nền tảng. Về cơ bản, chúng ta có 4 loại hình ảnh. Chuẩn cho thiết bị di động (.ext, trong đó ext là đuôi tệp, thường là .png hoặc .jpg), retina cho thiết bị di động (-2x.ext), chuẩn cho máy tính bảng (-tab.ext) và retina cho máy tính bảng (-tab-2x.ext). Thay vì thực hiện phát hiện trong MainPreloadTask và cố định giá trị trong mã cho 4 mảng thành phần, chúng ta chỉ cần cho biết tên và đuôi tệp của thành phần cần tải trước và liệu thành phần đó có phụ thuộc vào nền tảng hay không (responsive = true / false). Sau đó, AssetPreloadTask sẽ tạo tên tệp cho chúng ta:

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

Tiếp theo trong chuỗi lớp, mã thực tế thực hiện việc tải trước thành phần sẽ có dạng như sau (/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);
}

Hướng dẫn: Buồng chụp ảnh HTML5 (iOS6/Android)

Khi phát triển OZ Mobile, chúng tôi nhận ra rằng chúng tôi dành rất nhiều thời gian để chơi với buồng chụp ảnh thay vì làm việc :D Đơn giản là vì nó rất vui. Vì vậy, chúng tôi đã tạo một bản minh hoạ để bạn trải nghiệm.

Buồng chụp ảnh di động
Buồng chụp ảnh di động

Bạn có thể xem bản minh hoạ trực tiếp tại đây (chạy bản minh hoạ này trên iPhone hoặc điện thoại Android):

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

Để thiết lập, bạn cần có một phiên bản ứng dụng Google App Engine miễn phí để chạy phần phụ trợ. Mã giao diện người dùng không phức tạp nhưng có một số điểm cần lưu ý. Hãy cùng tìm hiểu ngay sau đây:

  1. Loại tệp hình ảnh được phép Chúng tôi muốn mọi người chỉ có thể tải hình ảnh lên (vì đây là buồng chụp ảnh, không phải buồng quay video). Về lý thuyết, bạn chỉ cần chỉ định bộ lọc trong HTML như sau: input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" Tuy nhiên, cách này dường như chỉ hoạt động trên iOS, vì vậy, chúng ta cần thêm một bước kiểm tra bổ sung đối với RegExp sau khi chọn một tệp:
   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. Huỷ tải lên hoặc huỷ chọn tệp Một điểm không nhất quán khác mà chúng tôi nhận thấy trong quá trình phát triển là cách các thiết bị khác nhau thông báo về việc huỷ chọn tệp. Điện thoại và máy tính bảng iOS không làm gì cả, không thông báo gì cả. Vì vậy, chúng ta không cần thực hiện bất kỳ hành động đặc biệt nào cho trường hợp này. Tuy nhiên, điện thoại Android vẫn kích hoạt hàm add() ngay cả khi không có tệp nào được chọn. Sau đây là cách đáp ứng yêu cầu này:
    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();            
    }
    }

Các tính năng còn lại hoạt động khá mượt mà trên các nền tảng. Chúc bạn sáng tạo vui!

Kết luận

Do quy mô khổng lồ của Find Your Way To Oz và sự kết hợp đa dạng của nhiều công nghệ khác nhau, trong bài viết này, chúng tôi chỉ có thể đề cập đến một vài phương pháp mà chúng tôi đã sử dụng.

Nếu bạn muốn khám phá toàn bộ, hãy xem toàn bộ mã nguồn của Find Your Way To Oz tại đường liên kết này.

Ghi công

Nhấp vào đây để xem danh sách đầy đủ những người tham gia thực hiện

Tài liệu tham khảo