กรณีศึกษา - ค้นหาหนทางสู่ออซ

บทนำ

"Find Your Way to Oz" เป็นการทดลองใหม่ของ Google Chrome ที่ Disney นำมาสู่เว็บ ซึ่งจะช่วยให้คุณได้เดินทางแบบอินเทอร์แอกทีฟผ่านคณะละครสัตว์ในแคนซัส ซึ่งจะนำคุณไปยังดินแดนแห่งออซหลังจากที่คุณถูกพายุลูกใหญ่พัดพาไป

เป้าหมายของเราคือการรวมความสมบูรณ์ของภาพยนตร์เข้ากับความสามารถทางเทคนิคของเบราว์เซอร์เพื่อสร้างประสบการณ์ที่สนุกสนานและสมจริงซึ่งผู้ใช้สามารถสร้างความสัมพันธ์ที่แน่นแฟ้นได้

งานนี้มีขนาดใหญ่เกินกว่าที่จะบันทึกทั้งหมดไว้ในบทความนี้ เราจึงเจาะลึกและดึงบางบทของเรื่องราวเทคโนโลยีที่เราคิดว่าน่าสนใจออกมา ในระหว่างนั้น เราได้แยกบทแนะนำที่เจาะจงบางส่วนซึ่งมีความยากเพิ่มขึ้น

มีผู้คนมากมายที่ทำงานอย่างหนักเพื่อสร้างประสบการณ์นี้ ซึ่งมีจำนวนมากเกินกว่าที่จะระบุไว้ที่นี่ได้ โปรดไปที่เว็บไซต์เพื่อดูหน้าเครดิตในส่วนเมนูเพื่อดูเรื่องราวทั้งหมด

ส่องเบื้องหลังการทำงาน

Find Your Way to Oz บนเดสก์ท็อปเป็นโลกที่สมจริงและสมบูรณ์แบบ เราใช้ 3 มิติและเอฟเฟกต์ที่ได้รับแรงบันดาลใจจากการสร้างภาพยนตร์แบบดั้งเดิมหลายชั้น ซึ่งรวมกันเพื่อสร้างฉากที่ใกล้เคียงกับความเป็นจริง เทคโนโลยีที่โดดเด่นที่สุดคือ WebGL ที่มี Three.js, ตัวปรับเฉดสีที่สร้างขึ้นเอง และองค์ประกอบภาพเคลื่อนไหว DOM ที่ใช้ฟีเจอร์ CSS3 นอกจากนี้ ยังมี getUserMedia API (WebRTC) สำหรับประสบการณ์แบบอินเทอร์แอกทีฟที่ช่วยให้ผู้ใช้เพิ่มรูปภาพจากเว็บแคมได้โดยตรง และ WebAudio สำหรับเสียง 3 มิติ

แต่ความมหัศจรรย์ของประสบการณ์ทางเทคโนโลยีเช่นนี้คือการที่ทุกอย่างมาผสมผสานกันได้อย่างไร ซึ่งนี่ก็เป็นหนึ่งในความท้าทายหลักด้วย นั่นคือจะผสมผสานวิชวลเอฟเฟกต์และองค์ประกอบแบบอินเทอร์แอกทีฟเข้าด้วยกันในฉากเดียวเพื่อสร้างภาพรวมที่สอดคล้องกันได้อย่างไร ความซับซ้อนของภาพนี้จัดการได้ยาก ทำให้ยากที่จะบอกว่าเราอยู่ในขั้นตอนใดของการพัฒนาในแต่ละช่วงเวลา

เพื่อแก้ปัญหาเกี่ยวกับเอฟเฟกต์ภาพที่เชื่อมโยงกันและการเพิ่มประสิทธิภาพ เราจึงใช้แผงควบคุมอย่างหนักหน่วงเพื่อบันทึกการตั้งค่าที่เกี่ยวข้องทั้งหมดที่เรากำลังตรวจสอบอยู่ในขณะนั้น ฉากสามารถปรับเปลี่ยนได้แบบสดๆ ในเบราว์เซอร์ ไม่ว่าจะเป็นความสว่าง ระยะชัดลึก แกมมา ฯลฯ ทุกคนสามารถลองปรับแต่งค่าของพารามิเตอร์ที่สำคัญในประสบการณ์นี้และมีส่วนร่วมในการค้นพบสิ่งที่ได้ผลดีที่สุด

ก่อนที่เราจะแชร์ความลับ เราขอเตือนคุณว่าระบบอาจขัดข้องได้ เช่นเดียวกับกรณีที่คุณเข้าไปยุ่งกับเครื่องยนต์ของรถยนต์ ตรวจสอบว่าคุณไม่มีสิ่งสำคัญใดๆ ที่เปิดอยู่ จากนั้นไปที่ URL หลักของเว็บไซต์และเพิ่ม ?debug=on ต่อท้ายที่อยู่ รอให้เว็บไซต์โหลด และเมื่อคุณเข้าไปข้างในแล้ว ให้กดแป้น Ctrl-I แล้วคุณจะเห็นเมนูแบบเลื่อนลงปรากฏขึ้นทางด้านขวามือ หากยกเลิกการเลือกตัวเลือก "ออกจากเส้นทางกล้อง" คุณจะใช้ปุ่ม A, W, S, D และเมาส์เพื่อเคลื่อนที่ไปรอบๆ พื้นที่ได้อย่างอิสระ

เส้นทางของกล้อง

เราจะไม่พูดถึงการตั้งค่าทั้งหมดที่นี่ แต่ขอแนะนำให้คุณลองทดสอบดู โดยแป้นต่างๆ จะแสดงการตั้งค่าที่แตกต่างกันในฉากต่างๆ ในลำดับพายุสุดท้ายจะมีคีย์เพิ่มเติมคือ Ctrl-A ซึ่งคุณสามารถสลับการเล่นภาพเคลื่อนไหวและบินไปรอบๆ ได้ ในฉากนี้ หากคุณกด Esc (เพื่อออกจากฟังก์ชันการล็อกเมาส์) และกด Ctrl-I อีกครั้ง คุณจะเข้าถึงการตั้งค่าเฉพาะสำหรับฉากพายุได้ ลองมองไปรอบๆ และถ่ายภาพวิวสวยๆ เหมือนภาพด้านล่างนี้

ฉากพายุ

เราใช้ไลบรารีที่ยอดเยี่ยมชื่อ dat.gui (ดูที่นี่สำหรับบทแนะนำที่ผ่านมาเกี่ยวกับวิธีใช้) เพื่อให้สิ่งนี้เกิดขึ้นและเพื่อให้แน่ใจว่ามีความยืดหยุ่นเพียงพอสำหรับความต้องการของเรา ซึ่งช่วยให้เราเปลี่ยนการตั้งค่าที่แสดงต่อผู้เข้าชมเว็บไซต์ได้อย่างรวดเร็ว

คล้ายกับภาพวาดแบบ Matte Painting เล็กน้อย

ในภาพยนตร์และแอนิเมชันคลาสสิกของ Disney หลายเรื่อง การสร้างฉากหมายถึงการรวมเลเยอร์ต่างๆ เข้าด้วยกัน มีทั้งเลเยอร์ของไลฟ์แอ็กชัน เซลแอนิเมชัน หรือแม้แต่ฉากจริง และเลเยอร์ด้านบนที่สร้างขึ้นโดยการวาดภาพบนกระจก ซึ่งเป็นเทคนิคที่เรียกว่า Matte Painting

โครงสร้างของประสบการณ์ที่เราสร้างขึ้นนั้นคล้ายกันในหลายๆ ด้าน แม้ว่า "เลเยอร์" บางส่วนจะเป็นมากกว่าภาพนิ่งก็ตาม แต่ในความเป็นจริงแล้ว ฟิลเตอร์จะส่งผลต่อลักษณะของสิ่งต่างๆ ตามการคำนวณที่ซับซ้อนมากขึ้น อย่างไรก็ตาม อย่างน้อยในระดับภาพรวม เรากำลังจัดการกับมุมมองที่ซ้อนกันอยู่ ที่ด้านบน คุณจะเห็นเลเยอร์ UI โดยมีฉาก 3 มิติอยู่ด้านล่าง ซึ่งประกอบด้วยองค์ประกอบฉากต่างๆ

เลเยอร์อินเทอร์เฟซด้านบนสร้างขึ้นโดยใช้ DOM และ CSS 3 ซึ่งหมายความว่าการแก้ไขการโต้ตอบสามารถทำได้หลายวิธีโดยไม่ขึ้นอยู่กับประสบการณ์ 3 มิติที่มีการสื่อสารระหว่างทั้งสองตามรายการเหตุการณ์ที่เลือก การสื่อสารนี้ใช้ Backbone Router + เหตุการณ์ onHashChange HTML5 ซึ่งควบคุมพื้นที่ที่ควรเคลื่อนไหวเข้า/ออก (แหล่งที่มาของโปรเจ็กต์: /develop/coffee/router/Router.coffee)

บทแนะนำ: สไปรท์ชีตและการรองรับ Retina

เทคนิคการเพิ่มประสิทธิภาพที่สนุกสนานอย่างหนึ่งที่เราใช้สำหรับอินเทอร์เฟซคือการรวมรูปภาพโอเวอร์เลย์อินเทอร์เฟซจำนวนมากไว้ใน PNG เดียวเพื่อลดคำขอเซิร์ฟเวอร์ ในโปรเจ็กต์นี้ อินเทอร์เฟซประกอบด้วยรูปภาพมากกว่า 70 รูป (ไม่รวมพื้นผิว 3 มิติ) ที่โหลดไว้ล่วงหน้าทั้งหมดเพื่อลดเวลาในการตอบสนองของเว็บไซต์ คุณดูสไปรท์ชีตที่ใช้งานอยู่ได้ที่นี่

จอแสดงผลปกติ - http://findyourwaytooz.com/img/home/interface_1x.png จอแสดงผล Retina - http://findyourwaytooz.com/img/home/interface_2x.png

ต่อไปนี้เป็นเคล็ดลับบางส่วนเกี่ยวกับวิธีที่เราใช้ประโยชน์จากสไปรท์ชีต และวิธีใช้สไปรท์ชีตสำหรับอุปกรณ์ Retina และทำให้อินเทอร์เฟซคมชัดและเป็นระเบียบที่สุดเท่าที่จะเป็นไปได้

การสร้างสไปรท์ชีต

ในการสร้าง SpriteSheet เราใช้ TexturePacker ซึ่งแสดงผลในรูปแบบใดก็ได้ที่คุณต้องการ ในกรณีนี้ เราได้ส่งออกเป็น EaselJS ซึ่งเป็นโค้ดที่สะอาดมากและสามารถใช้สร้างสไปรท์แบบเคลื่อนไหวได้ด้วย

การใช้สไปรท์ชีตที่สร้างขึ้น

เมื่อสร้างสไปรท์ชีตแล้ว คุณควรเห็นไฟล์ JSON ดังนี้

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

สถานที่:

  • image หมายถึง URL ของสไปรท์ชีต
  • เฟรมคือพิกัดขององค์ประกอบ UI แต่ละรายการ [x, y, ความกว้าง, ความสูง]
  • ภาพเคลื่อนไหวคือชื่อของชิ้นงานแต่ละรายการ

โปรดทราบว่าเราได้ใช้รูปภาพที่มีความหนาแน่นสูงเพื่อสร้างสไปรท์ชีต จากนั้นจึงสร้างเวอร์ชันปกติโดยปรับขนาดให้เหลือครึ่งหนึ่งของขนาดเดิม

สรุป

เมื่อตั้งค่าทุกอย่างเรียบร้อยแล้ว เราก็แค่ต้องใช้ข้อมูลโค้ด JavaScript เพื่อใช้งาน

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

และนี่คือวิธีใช้

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

หากต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับความหนาแน่นของพิกเซลแบบแปรผัน โปรดอ่านบทความนี้โดย Boris Smus

ไปป์ไลน์เนื้อหา 3 มิติ

ประสบการณ์การใช้งานสภาพแวดล้อมได้รับการตั้งค่าในเลเยอร์ WebGL เมื่อนึกถึงฉาก 3 มิติ คำถามที่ยากที่สุดข้อหนึ่งคือคุณจะสร้างเนื้อหาที่ช่วยให้แสดงออกถึงศักยภาพสูงสุดจากด้านการสร้างโมเดล แอนิเมชัน และเอฟเฟกต์ได้อย่างไร ในหลายๆ ด้าน หัวใจสำคัญของปัญหานี้คือไปป์ไลน์เนื้อหา ซึ่งเป็นกระบวนการที่ตกลงกันไว้เพื่อสร้างเนื้อหาสำหรับฉาก 3 มิติ

เราต้องการสร้างโลกที่น่าตื่นตาตื่นใจ จึงต้องมีกระบวนการที่มั่นคงซึ่งจะช่วยให้ศิลปิน 3 มิติสร้างโลกดังกล่าวได้ เราต้องให้อิสระในการแสดงออกแก่ศิลปินมากที่สุดเท่าที่จะเป็นไปได้ในซอฟต์แวร์การสร้างโมเดล 3 มิติและแอนิเมชัน และเราต้องแสดงผลบนหน้าจอผ่านโค้ด

เราพยายามแก้ปัญหานี้มาสักพักแล้ว เพราะทุกครั้งที่เราสร้างเว็บไซต์ 3 มิติในอดีต เราพบข้อจำกัดในเครื่องมือที่ใช้ได้ เราจึงสร้างเครื่องมือนี้ขึ้นมาที่เรียกว่า 3D Librarian ซึ่งเป็นงานวิจัยภายใน และพร้อมที่จะนำไปใช้กับงานจริงแล้ว

เครื่องมือนี้มีประวัติมาบ้างแล้ว โดยเดิมทีมีไว้สำหรับ Flash และจะช่วยให้คุณนำฉาก Maya ขนาดใหญ่เข้ามาเป็นไฟล์บีบอัดไฟล์เดียวที่ได้รับการเพิ่มประสิทธิภาพสำหรับการแตกไฟล์รันไทม์ สาเหตุที่วิธีนี้เหมาะสมที่สุดก็เพราะสามารถจัดฉากได้อย่างมีประสิทธิภาพในโครงสร้างข้อมูลเดียวกันกับที่ใช้ในระหว่างการเรนเดอร์และสร้างภาพเคลื่อนไหว การแยกวิเคราะห์ที่ต้องทำกับไฟล์เมื่อโหลดมีน้อยมาก การแตกไฟล์ใน Flash นั้นค่อนข้างรวดเร็วเนื่องจากไฟล์อยู่ในรูปแบบ AMF ซึ่ง Flash สามารถแตกไฟล์ได้โดยตรง การใช้รูปแบบเดียวกันใน WebGL ต้องใช้ CPU มากขึ้นเล็กน้อย อันที่จริง เราต้องสร้างโค้ดเลเยอร์ JavaScript สำหรับการแตกข้อมูลขึ้นมาใหม่ ซึ่งจะคลายการบีบอัดไฟล์เหล่านั้นและสร้างโครงสร้างข้อมูลที่จำเป็นเพื่อให้ WebGL ทำงานได้ การแตกไฟล์ฉาก 3 มิติทั้งหมดเป็นการดำเนินการที่ใช้ CPU ค่อนข้างมาก โดยการแตกไฟล์ฉากที่ 1 ใน Find Your Way To Oz ใช้เวลาประมาณ 2 วินาทีในเครื่องระดับกลางถึงระดับสูง ดังนั้นจึงต้องดำเนินการโดยใช้เทคโนโลยี Web Workers ในช่วง "การตั้งค่าฉาก" (ก่อนที่จะเปิดฉากจริง) เพื่อไม่ให้ประสบการณ์ของผู้ใช้หยุดชะงัก

เครื่องมือที่มีประโยชน์นี้สามารถนำเข้าฉาก 3 มิติส่วนใหญ่ได้ ไม่ว่าจะเป็นโมเดล พื้นผิว หรือภาพเคลื่อนไหวของกระดูก คุณสร้างไฟล์ไลบรารีไฟล์เดียว ซึ่งจะโหลดโดยเครื่องมือ 3 มิติได้ คุณสามารถใส่โมเดลทั้งหมดที่ต้องการในฉากไว้ในคลังนี้ แล้วก็สร้างโมเดลเหล่านั้นในฉากได้เลย

ปัญหาที่เราพบคือเราต้องจัดการกับ WebGL ซึ่งเป็นเทคโนโลยีใหม่ นี่เป็นงานที่ยากมาก ซึ่งเป็นการสร้างมาตรฐานสำหรับประสบการณ์ 3 มิติบนเบราว์เซอร์ เราจึงสร้างเลเยอร์ JavaScript เฉพาะกิจที่จะนำไฟล์ฉาก 3 มิติที่บีบอัดของ 3D Librarian มาแปลเป็นรูปแบบที่ WebGL เข้าใจได้อย่างถูกต้อง

บทแนะนำ: Let There Be Wind

ธีมที่เกิดขึ้นซ้ำๆ ใน "Find Your Way To Oz" คือลม ชุดข้อความของเรื่องราวได้รับการจัดโครงสร้างให้เป็นเสียงลมที่ดังขึ้นเรื่อยๆ

ฉากแรกของงานคาร์นิวัลค่อนข้างสงบ และเมื่อผ่านฉากต่างๆ ผู้ใช้จะสัมผัสได้ถึงลมที่แรงขึ้นเรื่อยๆ จนถึงฉากสุดท้ายซึ่งเป็นพายุ

ดังนั้นการสร้างเอฟเฟกต์ลมที่สมจริงจึงเป็นสิ่งสำคัญ

ในการสร้างเอฟเฟกต์นี้ เราได้ใส่ฉากงานคาร์นิวัล 3 ฉากด้วยวัตถุที่มีความนุ่มนวล ซึ่งควรได้รับผลกระทบจากลม เช่น เต็นท์ ธง พื้นผิวของบูธถ่ายภาพ และลูกโป่ง

ผ้านุ่ม

ปัจจุบันเกมบนเดสก์ท็อปมักสร้างขึ้นโดยใช้เอนจินฟิสิกส์หลัก ดังนั้นเมื่อต้องจำลองวัตถุที่อ่อนนุ่มในโลก 3 มิติ ระบบจะเรียกใช้การจำลองฟิสิกส์แบบเต็มรูปแบบเพื่อสร้างพฤติกรรมที่อ่อนนุ่มที่น่าเชื่อถือ

ใน WebGL / Javascript เรายังไม่มีความสามารถในการเรียกใช้การจำลองฟิสิกส์แบบเต็มรูปแบบ ดังนั้นใน Oz เราจึงต้องหาวิธีสร้างเอฟเฟกต์ลมโดยไม่ต้องจำลองลมจริงๆ

เราฝังข้อมูล "ความไวต่อลม" ของวัตถุแต่ละชิ้นไว้ในโมเดล 3 มิติ จุดยอดแต่ละจุดของโมเดล 3 มิติมี "แอตทริบิวต์ลม" ที่ระบุว่าจุดยอดนั้นควรได้รับผลกระทบจากลมมากน้อยเพียงใด ดังนั้น ค่านี้จึงระบุความไวต่อลมของวัตถุ 3 มิติ จากนั้นเราต้องสร้างลมขึ้นมา

เราทำเช่นนี้โดยการสร้างรูปภาพที่มี Perlin Noise รูปภาพนี้มีไว้เพื่อครอบคลุม "พื้นที่ลม" บางส่วน ดังนั้น วิธีที่ดีในการคิดเกี่ยวกับเรื่องนี้คือการจินตนาการถึงภาพของเมฆที่มีสัญญาณรบกวนวางอยู่เหนือพื้นที่สี่เหลี่ยมผืนผ้าบางส่วนของฉาก 3 มิติ แต่ละพิกเซลซึ่งเป็นค่าระดับสีเทาของรูปภาพนี้จะระบุความแรงของลม ณ ช่วงเวลาหนึ่งในพื้นที่ 3 มิติ "รอบๆ"

ในการสร้างเอฟเฟกต์ลม ระบบจะย้ายรูปภาพตามเวลาด้วยความเร็วคงที่ในทิศทางที่เฉพาะเจาะจง ซึ่งก็คือทิศทางของลม และเพื่อให้แน่ใจว่า "พื้นที่ที่มีลมพัด" จะไม่ส่งผลต่อทุกอย่างในฉาก เราจึงพันภาพลมไว้รอบขอบ โดยจำกัดไว้เฉพาะพื้นที่ที่ได้รับผลกระทบ

บทแนะนำเกี่ยวกับลม 3 มิติแบบง่าย

ตอนนี้เรามาสร้างเอฟเฟกต์ลมในฉาก 3 มิติแบบง่ายๆ ใน Three.js กัน

เราจะสร้างลมใน "ทุ่งหญ้าที่สร้างขึ้นตามขั้นตอน" แบบง่ายๆ

ก่อนอื่น มาสร้างฉากกัน เราจะมีภูมิประเทศแบบเรียบง่ายที่มีพื้นผิว จากนั้นหญ้าแต่ละต้นจะแสดงเป็นรูปกรวย 3 มิติแบบกลับหัว

ภูมิประเทศที่เต็มไปด้วยหญ้า
ภูมิประเทศที่เต็มไปด้วยหญ้า

ต่อไปนี้เป็นวิธีสร้างฉากง่ายๆ นี้ใน Three.js โดยใช้ CoffeeScript

ก่อนอื่นเราจะตั้งค่า Three.js และเชื่อมต่อกับกล้อง ตัวควบคุมเมาส์ และแสงบางอย่าง:

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 และ initTerrain จะสร้างฉากด้วยหญ้าและภูมิประเทศตามลำดับ

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

ในที่นี้เราจะสร้างตารางกริดขนาด 15 x 15 บิตของหญ้า เราเพิ่มการสุ่มเล็กน้อยให้กับตำแหน่งของหญ้าแต่ละต้น เพื่อไม่ให้หญ้าเรียงกันเป็นแถวเหมือนทหาร ซึ่งจะดูแปลกตา

ภูมิประเทศนี้เป็นเพียงระนาบแนวนอนที่วางอยู่ที่ฐานของต้นหญ้า (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 )

สิ่งที่เราทำไปแล้วคือการสร้างฉาก Three.js และเพิ่มหญ้าเล็กน้อยที่สร้างขึ้นจากกรวยกลับหัวที่สร้างขึ้นตามขั้นตอน และภูมิประเทศที่เรียบง่าย

ยังไม่มีอะไรซับซ้อน

ตอนนี้ก็ถึงเวลาเริ่มเพิ่มลมแล้ว อันดับแรก เราต้องการฝังข้อมูลความไวต่อลมลงในโมเดล 3 มิติของหญ้า

เราจะฝังข้อมูลนี้เป็นแอตทริบิวต์ที่กำหนดเองสำหรับแต่ละจุดยอดของโมเดล 3 มิติของหญ้า และเราจะใช้กฎที่ว่า ปลายด้านล่างของโมเดลหญ้า (ปลายกรวย) มีความไวเป็นศูนย์ เนื่องจากติดอยู่กับพื้น ส่วนบนของโมเดลหญ้า (ฐานของกรวย) มีความไวต่อลมสูงสุด เนื่องจากเป็นส่วนที่อยู่ห่างจากพื้นดินมากที่สุด

ต่อไปนี้คือวิธีเขียนโค้ดฟังก์ชัน instanceGrass ใหม่เพื่อเพิ่มความไวต่อลมเป็นแอตทริบิวต์ที่กำหนดเองสำหรับโมเดล 3 มิติของหญ้า

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

ตอนนี้เราใช้วัสดุที่กำหนดเอง windMaterial แทน MeshPhongMaterial ที่ใช้ก่อนหน้านี้ WindMaterial จะรวม WindMeshShader ที่เราจะเห็นในอีกสักครู่

ดังนั้น โค้ดใน instanceGrass จะวนซ้ำผ่านจุดยอดทั้งหมดของโมเดลหญ้า และสำหรับจุดยอดแต่ละจุด จะเพิ่มแอตทริบิวต์จุดยอดที่กำหนดเองที่เรียกว่า windFactor windFactor นี้ตั้งค่าเป็น 0 สำหรับส่วนล่างของโมเดลหญ้า (ซึ่งควรจะสัมผัสกับภูมิประเทศ) และมีค่าเป็น 1 สำหรับส่วนบนของโมเดลหญ้า

องค์ประกอบอีกอย่างที่เราต้องมีคือการเพิ่มลมจริงๆ เข้าไปในฉาก ตามที่ได้พูดคุยกัน เราจะใช้ Perlin Noise สำหรับเรื่องนี้ เราจะสร้างพื้นผิว Perlin Noise ตามขั้นตอน

เพื่อความชัดเจน เราจะกำหนดพื้นผิวนี้ให้กับภูมิประเทศแทนพื้นผิวสีเขียวก่อนหน้านี้ ซึ่งจะช่วยให้คุณเข้าใจสถานการณ์ลมได้ง่ายขึ้น

ดังนั้น พื้นผิว Perlin Noise นี้จะครอบคลุมพื้นที่ส่วนขยายของภูมิประเทศ และแต่ละพิกเซลของพื้นผิวจะระบุความแรงของลมในพื้นที่ภูมิประเทศที่พิกเซลนั้นอยู่ สี่เหลี่ยมผืนผ้าของภูมิประเทศจะเป็น "พื้นที่ลม" ของเรา

Perlin Noise จะสร้างขึ้นตามขั้นตอนผ่านเฉดสีที่เรียกว่า NoiseShader เฉดสีนี้ใช้อัลกอริทึม Simplex Noise 3 มิติจาก https://github.com/ashima/webgl-noise เวอร์ชัน WebGL ของตัวอย่างนี้คัดลอกมาจากตัวอย่าง Three.js ของ MrDoob ที่ http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html

NoiseShader จะใช้ชุดพารามิเตอร์เวลา ขนาด และออฟเซ็ตเป็น Uniform และแสดงผลการกระจาย 2 มิติที่สวยงามของ Perlin Noise

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

...

เราจะใช้ Shader นี้เพื่อแสดงผล Perlin Noise เป็นพื้นผิว ซึ่งทำได้ในฟังก์ชัน 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 )

โค้ดด้านบนจะตั้งค่า noiseMap เป็นเป้าหมายการแสดงผล Three.js, ติดตั้ง NoiseShader แล้วแสดงผลด้วยกล้องออร์โธกราฟิกเพื่อหลีกเลี่ยงการบิดเบือนมุมมอง

ตามที่ได้พูดคุยกันไปแล้ว ตอนนี้เราจะใช้พื้นผิวนี้เป็นพื้นผิวการแสดงผลหลักสำหรับภูมิประเทศด้วย ซึ่งไม่จำเป็นสำหรับการทำงานของเอฟเฟกต์ลม แต่ก็เป็นเรื่องดีที่ได้เห็น เพื่อให้เราเข้าใจภาพรวมของการผลิตพลังงานลมได้ดีขึ้น

นี่คือฟังก์ชัน initTerrain ที่ปรับปรุงใหม่โดยใช้ noiseMap เป็นพื้นผิว

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 )

เมื่อเรามีพื้นผิวลมแล้ว มาดู WindMeshShader ซึ่งมีหน้าที่เปลี่ยนรูปโมเดลหญ้าตามลมกัน

ในการสร้างเฉดสีนี้ เราเริ่มจากเฉดสี MeshPhongMaterial ของ Three.js มาตรฐาน แล้วนำมาปรับแต่ง วิธีนี้เป็นวิธีที่รวดเร็วและง่ายดายในการเริ่มต้นใช้งานเฉดสีที่ใช้งานได้ โดยไม่ต้องเริ่มใหม่ตั้งแต่ต้น

เราจะไม่คัดลอกโค้ด Shader ทั้งหมดที่นี่ (คุณดูโค้ดดังกล่าวได้ในไฟล์ซอร์สโค้ด) เนื่องจากโค้ดส่วนใหญ่จะเป็นตัวจำลองของ MeshPhongMaterial Shader แต่มาดูส่วนที่เกี่ยวข้องกับลมซึ่งมีการแก้ไขใน 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;

ดังนั้น สิ่งที่ตัวปรับเฉดสีนี้ทำคือการคำนวณพิกัดการค้นหาพื้นผิว windUV ก่อน โดยอิงตามตำแหน่ง 2 มิติ xz (แนวนอน) ของจุดยอด พิกัด UV นี้ใช้เพื่อค้นหาแรงลม vWindForce จากพื้นผิวลมแบบ Perlin Noise

ค่า vWindForce นี้จะประกอบด้วยแอตทริบิวต์ที่กำหนดเอง windFactor เฉพาะจุดยอดที่กล่าวถึงข้างต้น เพื่อคำนวณว่าจุดยอดต้องมีการเปลี่ยนรูปมากน้อยเพียงใด นอกจากนี้ เรายังมีพารามิเตอร์ windScale ส่วนกลางเพื่อควบคุมความแรงโดยรวมของลม และเวกเตอร์ windDirection ที่ระบุทิศทางที่การเปลี่ยนรูปของลมต้องเกิดขึ้น

ซึ่งจะทำให้เกิดการเปลี่ยนรูปของต้นหญ้าตามลม อย่างไรก็ตาม เรายังไม่หยุดเพียงเท่านี้ ในตอนนี้ การเปลี่ยนรูปนี้เป็นแบบคงที่ และจะไม่สื่อถึงผลกระทบของพื้นที่ที่มีลมแรง

ดังที่ได้กล่าวไปแล้ว เราจะต้องเลื่อนพื้นผิวที่มีนอยส์เมื่อเวลาผ่านไปทั่วบริเวณที่มีลม เพื่อให้กระจกโบกสะบัดได้

ซึ่งทำได้โดยการเปลี่ยน vOffset Uniform ที่ส่งไปยัง NoiseShader เมื่อเวลาผ่านไป นี่คือพารามิเตอร์ vec2 ซึ่งจะช่วยให้เราสามารถระบุออฟเซ็ตของนอยส์ตามทิศทางที่กำหนด (ทิศทางลม)

เราจะทำเช่นนี้ในฟังก์ชัน render ซึ่งจะเรียกใช้ในทุกเฟรม

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

เพียงเท่านี้ก็เรียบร้อย เราเพิ่งสร้างฉากที่มี "หญ้าที่สร้างขึ้นตามขั้นตอน" ซึ่งได้รับผลกระทบจากลม

การเพิ่มฝุ่นลงในส่วนผสม

ตอนนี้เรามาเพิ่มสีสันให้ฉากกันสักหน่อย มาเพิ่มฝุ่นที่ลอยอยู่เล็กน้อยเพื่อให้ฉากดูน่าสนใจยิ่งขึ้น

กำลังเพิ่มฝุ่น
การเพิ่มฝุ่น

ฝุ่นควรได้รับผลกระทบจากลม ดังนั้นการมีฝุ่นลอยไปมาในฉากลมจึงสมเหตุสมผลอย่างยิ่ง

ฝุ่นจะได้รับการตั้งค่าในฟังก์ชัน initDust เป็นระบบอนุภาค

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

ในที่นี้จะมีการสร้างอนุภาคฝุ่น 130 รายการ และโปรดทราบว่าแต่ละรายการจะมี WindParticleShader พิเศษติดตั้งอยู่

ตอนนี้ ในแต่ละเฟรม เราจะเคลื่อนย้ายอนุภาคไปรอบๆ เล็กน้อยโดยใช้ CoffeeScript โดยไม่ขึ้นอยู่กับลม รหัสมีดังนี้

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 )

นอกจากนี้ เราจะชดเชยตำแหน่งของอนุภาคแต่ละตำแหน่งตามลมด้วย ซึ่งทำได้ใน WindParticleShader โดยเฉพาะใน Vertex Shader

โค้ดสำหรับตัวปรับเฉดสีนี้เป็นเวอร์ชันที่แก้ไขแล้วของ Three.js ParticleMaterial และนี่คือลักษณะของแกนหลัก

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;

เวอร์เท็กซ์เชเดอร์นี้ไม่แตกต่างจากที่เราใช้สำหรับการเปลี่ยนรูปของหญ้าตามลมมากนัก โดยจะใช้พื้นผิวสัญญาณรบกวน Perlin เป็นอินพุต และค้นหาค่า vWindForce ในพื้นผิวสัญญาณรบกวนโดยขึ้นอยู่กับตำแหน่งของฝุ่นในโลก จากนั้นจะใช้ค่านี้เพื่อปรับเปลี่ยนตำแหน่งของอนุภาคฝุ่น

Riders On The Storm

ฉาก WebGL ที่น่าตื่นเต้นที่สุดน่าจะเป็นฉากสุดท้าย ซึ่งคุณจะเห็นได้หากคลิกผ่านบอลลูนเข้าไปในตาพายุทอร์นาโดเพื่อไปถึงจุดสิ้นสุดของการเดินทางในเว็บไซต์ และวิดีโอสุดพิเศษของภาพยนตร์ที่กำลังจะเข้าฉาย

ฉากการขึ้นบอลลูน

ตอนที่สร้างฉากนี้ เราทราบดีว่าต้องมีฟีเจอร์หลักสำหรับประสบการณ์การใช้งานที่จะสร้างความประทับใจ พายุทอร์นาโดที่หมุนวนจะทำหน้าที่เป็นจุดศูนย์กลาง และเลเยอร์ของเนื้อหาอื่นๆ จะหลอมรวมฟีเจอร์นี้เข้าด้วยกันเพื่อสร้างเอฟเฟกต์ที่น่าตื่นตาตื่นใจ เพื่อให้บรรลุเป้าหมายนี้ เราจึงสร้างสิ่งที่เทียบเท่ากับฉากในสตูดิโอภาพยนตร์รอบๆ ตัวปรับเฉดสีที่แปลกประหลาดนี้

เราใช้แนวทางแบบผสมผสานเพื่อสร้างภาพคอมโพสิตที่สมจริง บางอย่างเป็นลูกเล่นด้านภาพ เช่น รูปทรงแสงเพื่อสร้างเอฟเฟกต์แสงแฟลร์ หรือเม็ดฝนที่เคลื่อนไหวเป็นเลเยอร์ที่ด้านบนของฉากที่คุณกำลังดูอยู่ ในกรณีอื่นๆ เรามีพื้นผิวเรียบที่วาดให้ดูเหมือนเคลื่อนที่ไปรอบๆ เช่น ชั้นเมฆที่ลอยต่ำซึ่งเคลื่อนที่ตามโค้ดระบบอนุภาค ส่วนเศษซากที่โคจรรอบพายุทอร์นาโดเป็นเลเยอร์ในฉาก 3 มิติที่จัดเรียงให้เคลื่อนที่ไปด้านหน้าและด้านหลังพายุทอร์นาโด

สาเหตุหลักที่เราต้องสร้างฉากในลักษณะนี้ก็เพื่อให้แน่ใจว่าเรามี GPU เพียงพอที่จะจัดการกับตัวปรับเฉดสีทอร์นาโดให้สมดุลกับเอฟเฟกต์อื่นๆ ที่เราใช้ ตอนแรกเรามีปัญหาใหญ่เรื่องการปรับสมดุล GPU แต่ต่อมาฉากนี้ได้รับการเพิ่มประสิทธิภาพและเบากว่าฉากหลัก

บทแนะนำ: Storm Shader

มีการใช้เทคนิคต่างๆ มากมายร่วมกันเพื่อสร้างลำดับพายุสุดท้าย แต่หัวใจสำคัญของงานนี้คือตัวปรับเฉดสี GLSL ที่กำหนดเองซึ่งมีลักษณะเหมือนพายุทอร์นาโด เราได้ลองใช้เทคนิคต่างๆ มากมายตั้งแต่เวอร์เท็กซ์เชเดอร์เพื่อสร้างวังวนเรขาคณิตที่น่าสนใจ ไปจนถึงภาพเคลื่อนไหวที่อิงตามอนุภาค และแม้แต่ภาพเคลื่อนไหว 3 มิติของรูปทรงเรขาคณิตที่บิดเบี้ยว ไม่มีเอฟเฟกต์ใดที่ดูเหมือนจะสร้างความรู้สึกของพายุทอร์นาโดขึ้นมาใหม่ได้ หรือต้องใช้การประมวลผลมากเกินไป

ในที่สุด โปรเจ็กต์ที่แตกต่างไปโดยสิ้นเชิงก็ให้คำตอบแก่เรา โครงการคู่ขนานที่เกี่ยวข้องกับเกมเพื่อวิทยาศาสตร์ในการทำแผนที่สมองของหนูจาก Max Planck Institute (brainflight.org) ได้สร้างเอฟเฟกต์ภาพที่น่าสนใจ เราสามารถสร้างภาพยนตร์ภายในเซลล์ประสาทของหนูโดยใช้ตัวปรับแสงเงาเชิงปริมาตรที่กำหนดเอง

ภายในเซลล์ประสาทของหนูโดยใช้เฉดสีเชิงปริมาตรที่กำหนดเอง
ภายในเซลล์ประสาทของหนูโดยใช้ตัวปรับแสงเงาเชิงปริมาตรที่กำหนดเอง

เราพบว่าภายในเซลล์สมองมีลักษณะคล้ายกับกรวยของพายุทอร์นาโด และเนื่องจากเราใช้เทคนิคเชิงปริมาตร เราจึงรู้ว่าเราสามารถดูเฉดสีนี้ได้จากทุกทิศทางในพื้นที่ เราสามารถตั้งค่าการแสดงผลของเฉดสีให้รวมเข้ากับฉากพายุได้ โดยเฉพาะอย่างยิ่งหากอยู่ใต้ชั้นเมฆและเหนือพื้นหลังที่น่าตื่นตาตื่นใจ

เทคนิคเฉดสีเกี่ยวข้องกับกลเม็ดที่ใช้เฉดสี GLSL เดียวเพื่อแสดงผลออบเจ็กต์ทั้งหมดด้วยอัลกอริทึมการแสดงผลแบบง่ายที่เรียกว่าการแสดงผลแบบ Ray Marching ที่มีฟิลด์ระยะทาง ในเทคนิคนี้ ระบบจะสร้างพิกเซลเฉดเดอร์ซึ่งประมาณระยะทางที่ใกล้ที่สุดไปยังพื้นผิวสำหรับแต่ละจุดบนหน้าจอ

คุณสามารถดูข้อมูลอ้างอิงที่ดีเกี่ยวกับอัลกอริทึมได้ในภาพรวมโดย iq: Rendering Worlds With Two Triangles - Iñigo Quilez นอกจากนี้ คุณยังสำรวจแกลเลอรีของเฉดสีใน glsl.heroku.com ได้ด้วย ซึ่งมีตัวอย่างเทคนิคนี้มากมายที่สามารถนำไปทดลองใช้ได้

หัวใจสำคัญของเฉดเดอร์เริ่มต้นด้วยฟังก์ชันหลัก ซึ่งจะตั้งค่าการเปลี่ยนรูปแบบกล้องและเข้าสู่ลูปที่ประเมินระยะห่างจากพื้นผิวซ้ำๆ การเรียก RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) คือจุดที่เกิดการคำนวณ Ray Marching หลัก

for(int i=0;i < number_of_steps;i++) // run the ray marching loop
{
  old_d=d;
  float shape_value=Shape(q); // find out the approximate distance to or density of the tornado cone
  float density=-shape_value;
  d=max(shape_value*step_scaling,0.0);// The max function clamps values smaller than 0 to 0

  float step_dist=d+extra_step; // The point is advanced by larger steps outside the tornado,
  //  allowing us to skip empty space quicker.

  if (density>0.0) {  // When density is positive, we are inside the cloud
    float brightness=exp(-0.6*density);  // Brightness decays exponentially inside the cloud

    // This function combines density layers to create a translucent fog
    FogStep(step_dist*0.2,clamp(density, 0.0,1.0)*vec3(1,1,1), vec3(1)*brightness, colour, multiplier); 
  }
  if(dist>max_dist || multiplier.x < 0.01) { return;  } // if we've gone too far stop, we are done
  dist+=step_dist; // add a new step in distance
  q=org+dist*dir; // trace its direction according to the ray casted
}

แนวคิดก็คือเมื่อเราเคลื่อนที่เข้าไปในรูปร่างของพายุทอร์นาโด เราจะเพิ่มการมีส่วนร่วมของสีให้กับค่าสีสุดท้ายของพิกเซลเป็นประจำ รวมถึงการมีส่วนร่วมต่อความทึบแสงตามรังสี ซึ่งจะสร้างคุณภาพที่นุ่มนวลเป็นชั้นๆ ให้กับพื้นผิวของทอร์นาโด

ลักษณะหลักถัดไปของทอร์นาโดคือรูปร่างจริง ซึ่งสร้างขึ้นโดยการประกอบฟังก์ชันต่างๆ เข้าด้วยกัน โดยเริ่มจากรูปทรงกรวยที่ประกอบด้วยนอยส์เพื่อสร้างขอบขรุขระแบบออร์แกนิก จากนั้นจึงบิดไปตามแกนหลักและหมุนตามเวลา

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

งานที่เกี่ยวข้องกับการสร้างเฉดสีประเภทนี้เป็นเรื่องที่ยุ่งยาก นอกเหนือจากปัญหาที่เกี่ยวข้องกับนามธรรมของการดำเนินการที่คุณกำลังสร้างแล้ว ยังมีปัญหาด้านการเพิ่มประสิทธิภาพและความเข้ากันได้ข้ามแพลตฟอร์มที่ร้ายแรงซึ่งคุณต้องติดตามและแก้ไขก่อนจึงจะสามารถใช้ผลงานในเวอร์ชันที่ใช้งานจริงได้

ส่วนแรกของปัญหาคือการเพิ่มประสิทธิภาพเฉดสีนี้สำหรับฉากของเรา ในการจัดการกับปัญหานี้ เราจำเป็นต้องมีแนวทางที่ "ปลอดภัย" ในกรณีที่ตัวปรับเฉดสีมีขนาดใหญ่เกินไป โดยเราได้จัดองค์ประกอบของตัวปรับแสงเงาพายุทอร์นาโดที่ความละเอียดตัวอย่างที่แตกต่างจากส่วนอื่นๆ ของฉาก ซึ่งมาจากไฟล์ stormTest.coffee (ใช่แล้ว นี่เป็นการทดสอบ)

เราเริ่มต้นด้วย renderTarget ที่ตรงกับความกว้างและความสูงของฉาก เพื่อให้เราสามารถแยกความละเอียดของตัวปรับเฉดสีทอร์นาโดออกจากฉากได้ จากนั้นเราจะตัดสินใจลดความละเอียดของตัวปรับแสงเงาพายุแบบไดนามิกโดยขึ้นอยู่กับอัตราเฟรมที่เราได้รับ

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

สุดท้าย เราจะแสดงผลทอร์นาโดบนหน้าจอโดยใช้อัลกอริทึม sal2x แบบง่าย (เพื่อหลีกเลี่ยงลักษณะที่เป็นบล็อก) @line 1107 ใน stormTest.coffee ซึ่งหมายความว่าในกรณีที่แย่ที่สุด เราจะได้ภาพทอร์นาโดที่เบลอมากขึ้น แต่อย่างน้อยก็ทำงานได้โดยไม่แย่งการควบคุมจากผู้ใช้

ขั้นตอนการเพิ่มประสิทธิภาพถัดไปต้องเจาะลึกอัลกอริทึม ปัจจัยการคำนวณที่ขับเคลื่อนในเฉดสีคือการทำซ้ำที่ดำเนินการกับแต่ละพิกเซลเพื่อพยายามประมาณระยะทางของฟังก์ชันพื้นผิว ซึ่งก็คือจำนวนการทำซ้ำของลูป Raymarching การใช้ขนาดขั้นที่ใหญ่ขึ้นช่วยให้เราประมาณพื้นผิวของทอร์นาโดได้โดยใช้การทำซ้ำน้อยลงขณะอยู่นอกพื้นผิวที่มีเมฆ เมื่ออยู่ด้านใน เราจะลดขนาดขั้นบันไดเพื่อความแม่นยำและเพื่อให้สามารถผสมค่าต่างๆ เพื่อสร้างเอฟเฟกต์หมอกได้ นอกจากนี้ การสร้างทรงกระบอกล้อมรอบเพื่อประมาณความลึกของรังสีที่ฉายยังช่วยเพิ่มความเร็วได้ดีอีกด้วย

ส่วนถัดไปของปัญหาคือการตรวจสอบว่าเฉดสีนี้จะทำงานบนการ์ดวิดีโอต่างๆ ได้ เราทำการทดสอบทุกครั้งและเริ่มสร้างสัญชาตญาณเกี่ยวกับประเภทของปัญหาด้านความเข้ากันได้ที่เราอาจพบ เหตุผลที่เราไม่สามารถทำได้ดีกว่าการใช้สัญชาตญาณคือเราไม่สามารถรับข้อมูลการแก้ไขข้อบกพร่องที่ดีเกี่ยวกับข้อผิดพลาดได้เสมอไป สถานการณ์ที่พบบ่อยคือข้อผิดพลาดของ GPU ที่มีข้อมูลเพิ่มเติมเพียงเล็กน้อย หรือแม้แต่ระบบขัดข้อง

ปัญหาความเข้ากันได้ของบอร์ดวิดีโอแบบข้ามมีวิธีแก้ไขที่คล้ายกัน นั่นคือตรวจสอบว่าได้ป้อนค่าคงที่แบบคงที่ของประเภทข้อมูลที่ถูกต้องตามที่กำหนดไว้ เช่น 0.0 สำหรับ Float และ 0 สำหรับ Int โปรดระมัดระวังเมื่อเขียนฟังก์ชันที่ยาวขึ้น ควรแยกสิ่งต่างๆ ออกเป็นฟังก์ชันที่ง่ายขึ้นหลายๆ ฟังก์ชันและตัวแปรชั่วคราว เนื่องจากคอมไพเลอร์ดูเหมือนจะไม่จัดการบางกรณีอย่างถูกต้อง ตรวจสอบว่าพื้นผิวทั้งหมดเป็นเลขยกกำลัง 2 ไม่ใหญ่เกินไป และใช้ "ความระมัดระวัง" ในทุกกรณีเมื่อค้นหาข้อมูลพื้นผิวในลูป

ปัญหาใหญ่ที่สุดที่เราพบเกี่ยวกับความเข้ากันได้คือเอฟเฟกต์แสงสำหรับพายุ เราใช้พื้นผิวที่สร้างไว้ล่วงหน้าเพื่อห่อหุ้มพายุทอร์นาโดเพื่อให้เราสามารถลงสีให้กับพายุได้ ซึ่งเป็นเอฟเฟกต์ที่สวยงามและทำให้ผสมผสานทอร์นาโดเข้ากับสีของฉากได้ง่าย แต่ใช้เวลานานในการพยายามทำให้ทำงานบนแพลตฟอร์มอื่นๆ

ทอร์นาโด

เว็บบนมือถือ

ประสบการณ์การใช้งานบนอุปกรณ์เคลื่อนที่ไม่สามารถแปลจากเวอร์ชันเดสก์ท็อปได้โดยตรง เนื่องจากข้อกำหนดด้านเทคโนโลยีและการประมวลผลนั้นหนักเกินไป เราจึงต้องสร้างสิ่งใหม่ที่กำหนดเป้าหมายไปยังผู้ใช้อุปกรณ์เคลื่อนที่โดยเฉพาะ

เราคิดว่าคงจะดีไม่น้อยหากมี Carnival Photo-Booth จากเดสก์ท็อปเป็นเว็บแอปพลิเคชันบนอุปกรณ์เคลื่อนที่ซึ่งจะใช้กล้องบนอุปกรณ์เคลื่อนที่ของผู้ใช้ ซึ่งเป็นสิ่งที่เราไม่เคยเห็นมาก่อน

เราได้เขียนโค้ดการเปลี่ยนรูปแบบ 3 มิติใน CSS3 เพื่อเพิ่มสีสัน การเชื่อมโยงกับเครื่องวัดการหมุนและตัวตรวจวัดความเร่งช่วยให้เราเพิ่มความลึกซึ้งให้กับประสบการณ์ได้มาก เว็บไซต์จะตอบสนองต่อวิธีที่คุณถือ ขยับ และมองโทรศัพท์

เมื่อเขียนบทความนี้ เราคิดว่าควรให้คำแนะนำเกี่ยวกับวิธีดำเนินกระบวนการพัฒนาแอปบนอุปกรณ์เคลื่อนที่อย่างราบรื่น เริ่มเลย ลองดูว่าคุณจะเรียนรู้อะไรจากข้อมูลนี้ได้บ้าง

กลเม็ดเคล็ดลับสำหรับอุปกรณ์เคลื่อนที่

Preloader เป็นสิ่งที่จำเป็น ไม่ใช่สิ่งที่ควรหลีกเลี่ยง เราทราบดีว่าบางครั้งอาจเกิดกรณีหลังขึ้น สาเหตุหลักคือคุณต้องคอยดูแลรักษารายการสิ่งต่างๆ ที่คุณโหลดไว้ล่วงหน้าเมื่อโปรเจ็กต์เติบโตขึ้น ที่แย่ไปกว่านั้นคือ วิธีคำนวณความคืบหน้าในการโหลดไม่ชัดเจนนักหากคุณดึงทรัพยากรที่แตกต่างกันและดึงทรัพยากรจำนวนมากพร้อมกัน นี่คือจุดที่คลาส Abstract "Task" ที่กำหนดเองและเป็นแบบทั่วไปจะมีประโยชน์ แนวคิดหลักคือการอนุญาตให้มีโครงสร้างที่ซ้อนกันอย่างไม่มีที่สิ้นสุด โดยที่งานหนึ่งๆ สามารถมีงานย่อยของตัวเอง ซึ่งสามารถมีงานย่อยของตัวเองได้อีก เป็นต้น นอกจากนี้ งานแต่ละงานจะคำนวณความคืบหน้าโดยอิงตามความคืบหน้าของงานย่อย (แต่ไม่ใช่งานหลัก) การทำให้ MainPreloadTask, AssetPreloadTask และ TemplatePreFetchTask ทั้งหมดมาจาก Task ทำให้เราสร้างโครงสร้างที่มีลักษณะดังนี้

ตัวโหลดล่วงหน้า

แนวทางดังกล่าวและคลาส Task ช่วยให้เราทราบความคืบหน้าโดยรวม (MainPreloadTask) หรือความคืบหน้าของชิ้นงาน (AssetPreloadTask) หรือความคืบหน้าของการโหลดเทมเพลต (TemplatePreFetchTask) ได้อย่างง่ายดาย รวมถึงความคืบหน้าของไฟล์ที่เฉพาะเจาะจง หากต้องการดูวิธีการทำงาน ให้ดูคลาส Task ที่ /m/javascripts/raw/util/Task.js และการใช้งาน Task จริงที่ /m/javascripts/preloading/task ตัวอย่างเช่น ข้อมูลต่อไปนี้เป็นข้อมูลที่ดึงมาจากวิธีที่เราตั้งค่าคลาส /m/javascripts/preloading/task/MainPreloadTask.js ซึ่งเป็น Wrapper การโหลดล่วงหน้าขั้นสูงสุดของเรา

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 นอกเหนือจากการสังเกตวิธีที่คลาสนี้สื่อสารกับ MainPreloadTask (ผ่านการใช้งาน Task ที่แชร์) แล้ว ยังควรสังเกตวิธีที่เราโหลดเนื้อหาที่ขึ้นอยู่กับแพลตฟอร์มด้วย โดยทั่วไปแล้ว เรามีรูปภาพ 4 ประเภท มาตรฐานอุปกรณ์เคลื่อนที่ (.ext โดยที่ ext คือนามสกุลไฟล์ ซึ่งโดยทั่วไปคือ .png หรือ .jpg), อุปกรณ์เคลื่อนที่ที่มีจอแสดงผล Retina (-2x.ext), มาตรฐานแท็บเล็ต (-tab.ext) และแท็บเล็ตที่มีจอแสดงผล Retina (-tab-2x.ext) แทนที่จะทำการตรวจจับใน MainPreloadTask และฮาร์ดโค้ดอาร์เรย์ชิ้นงาน 4 รายการ เราเพียงแค่ระบุชื่อและนามสกุลของชิ้นงานที่จะโหลดล่วงหน้า และระบุว่าชิ้นงานขึ้นอยู่กับแพลตฟอร์มหรือไม่ (ปรับเปลี่ยนตามอุปกรณ์ = จริงหรือหลอก) จากนั้น AssetPreloadTask จะสร้างชื่อไฟล์ให้เรา ดังนี้

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

โค้ดจริงที่ทำการโหลดเนื้อหาล่วงหน้าจะอยู่ถัดลงไปในเชนคลาส (/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);
}

บทแนะนำ: บูธถ่ายภาพ HTML5 (iOS6/Android)

ตอนที่พัฒนา OZ เวอร์ชันมือถือ เราพบว่าเราใช้เวลาเล่นกับบูธถ่ายรูปเยอะมากแทนที่จะทำงาน :D นั่นเป็นเพราะมันสนุกมาก เราจึงสร้างเดโมให้คุณได้ลองเล่น

บูธถ่ายรูปนอกสถานที่
บูธถ่ายภาพเคลื่อนที่

คุณดูการสาธิตแบบสดได้ที่นี่ (เรียกใช้บน iPhone หรือโทรศัพท์ Android)

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

หากต้องการตั้งค่า คุณต้องมีอินสแตนซ์แอปพลิเคชัน Google App Engine ฟรีที่สามารถเรียกใช้แบ็กเอนด์ได้ โค้ดฟรอนท์เอนด์ไม่ซับซ้อน แต่มีข้อควรระวังอยู่ 2-3 ข้อ มาดูรายละเอียดกันเลย

  1. ประเภทไฟล์ภาพที่อนุญาต เราต้องการให้ผู้ใช้สามารถอัปโหลดรูปภาพเท่านั้น (เนื่องจากเป็นบูธถ่ายภาพ ไม่ใช่บูธวิดีโอ) ในทางทฤษฎี คุณสามารถระบุตัวกรองใน HTML ได้ดังนี้ input id="fileInput" class="fileInput" type="file" name="file" accept="image/*" อย่างไรก็ตาม วิธีนี้ดูเหมือนจะใช้ได้กับ iOS เท่านั้น ดังนั้นเราจึงต้องเพิ่มการตรวจสอบเพิ่มเติมกับ RegExp เมื่อเลือกไฟล์แล้ว
   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. การยกเลิกการอัปโหลดหรือการเลือกไฟล์ ความไม่สอดคล้องกันอีกอย่างหนึ่งที่เราสังเกตเห็นในระหว่างกระบวนการพัฒนาคือวิธีที่อุปกรณ์ต่างๆ แจ้งเตือนการเลือกไฟล์ที่ยกเลิก โทรศัพท์และแท็บเล็ต iOS ไม่ทำอะไรเลย และไม่แจ้งเตือนเลย ดังนั้นเราจึงไม่จำเป็นต้องดำเนินการใดๆ เป็นพิเศษสำหรับกรณีนี้ อย่างไรก็ตาม โทรศัพท์ Android จะเรียกใช้ฟังก์ชัน add() อยู่ดี แม้ว่าจะไม่ได้เลือกไฟล์ก็ตาม วิธีรองรับกรณีนี้มีดังนี้
    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();            
    }
    }

ส่วนที่เหลือทำงานได้ค่อนข้างราบรื่นในแพลตฟอร์มต่างๆ ขอให้สนุก!

บทสรุป

เนื่องจาก Find Your Way To Oz มีขนาดใหญ่มากและมีเทคโนโลยีที่เกี่ยวข้องมากมาย ในบทความนี้เราจึงพูดถึงแนวทางที่เราใช้ได้เพียงไม่กี่แนวทางเท่านั้น

หากคุณอยากสำรวจทุกอย่างแบบจัดเต็ม ก็สามารถดูซอร์สโค้ดทั้งหมดของ Find Your Way To Oz ได้ที่ลิงก์นี้

เครดิต

คลิกที่นี่เพื่อดูรายชื่อเครดิตทั้งหมด

ข้อมูลอ้างอิง