مطالعه موردی - Find Your Way to Oz

مقدمه

«Find Your Way to Oz» یک Chrome Experiment جدید است که توسط Disney به وب آورده شده است. این آزمایش به شما امکان می‌دهد سفری تعاملی را در سیرک کانزاس تجربه کنید، که پس‌از گرفتار شدن در طوفانی عظیم، شما را به سرزمین اوز می‌برد.

هدف ما ترکیب غنای سینما با قابلیت‌های فنی مرورگر بود تا تجربه‌ای سرگرم‌کننده و همه‌جانبه ایجاد کنیم که کاربران بتوانند ارتباط قوی با آن برقرار کنند.

این کار کمی بزرگ‌تر از آن است که بتوان آن را به‌طور کامل در این مقاله گنجاند، بنابراین ما عمیق‌تر شده‌ایم و برخی‌از فصل‌های داستان فناوری را که فکر می‌کنیم جالب هستند، استخراج کرده‌ایم. درطول این مسیر، چند آموزش متمرکز با دشواری فزاینده استخراج کردیم.

افراد زیادی سخت تلاش کردند تا این تجربه را ممکن کنند: تعدادشان بیشتر از آن است که در اینجا فهرست شود. لطفاً به سایت مراجعه کنید تا صفحه اعتبارها را در بخش منو برای داستان کامل بررسی کنید.

نگاهی به زیر کاپوت

«Find Your Way to Oz» در رایانه دنیای غنی و فراگیری است. ما از سه‌بعدی و چندین لایه جلوه‌های الهام‌گرفته از فیلم‌سازی سنتی استفاده می‌کنیم که با ترکیب شدن، صحنه‌ای تقریباً واقع‌گرایانه ایجاد می‌کنند. برجسته‌ترین فناوری‌ها WebGL با Three.js، سایه‌زن‌های سفارشی ساخته‌شده، و عناصر پویانمایی‌شده DOM بااستفاده از ویژگی‌های CSS3 هستند. علاوه‌براین، getUserMedia API (WebRTC) برای تجربه‌های تعاملی که به کاربر اجازه می‌دهد تصویر خود را مستقیماً از وب‌کم و WebAudio برای صدای سه‌بعدی اضافه کند.

اما جادوی تجربه فناوری مانند این است که چگونه با هم جمع می‌شود. این یکی از چالش‌های اصلی نیز هست: چگونه جلوه‌های دیداری و عناصر تعاملی را در یک صحنه باهم ترکیب کنیم تا یک کل منسجم ایجاد شود؟ مدیریت این پیچیدگی بصری دشوار بود: تشخیص اینکه در هر زمان در چه مرحله‌ای از توسعه هستیم دشوار بود.

برای حل مشکل جلوه‌های بصری به‌هم‌پیوسته و بهینه‌سازی، از صفحه کنترلی استفاده کردیم که همه تنظیمات مربوطه را که در آن زمان درحال بررسی بودیم ضبط می‌کرد. صحنه را می‌توان به‌طور زنده در مرورگر برای هر چیزی از روشنایی گرفته تا عمق میدان، گاما و غیره تنظیم کرد… هر کسی می‌تواند مقادیر پارامترهای مهم را در تجربه تغییر دهد و در کشف آنچه بهترین نتیجه را دارد مشارکت کند.

قبل‌از اینکه رازمان را فاش کنیم، می‌خواهیم به شما هشدار دهیم که ممکن است ازکار بیفتد، درست مثل اینکه بخواهید در موتور خودرو دست‌کاری کنید. مطمئن شوید که چیز مهمی در آنجا ندارید و به نشانی وب اصلی سایت بروید و ?debug=on را به نشانی اضافه کنید. منتظر بمانید تا سایت بار شود و وقتی وارد شدید، کلید Ctrl-I را (فشار دهید؟) تا منو کرکره‌ای در سمت راست ظاهر شود. اگر علامت گزینه «خروج از مسیر دوربین» را بردارید، می‌توانید از کلیدهای A،‏ W،‏ S،‏ D و موشواره برای حرکت آزادانه در فضا استفاده کنید.

مسیر دوربین.

در اینجا همه تنظیمات را بررسی نمی‌کنیم، اما شما را تشویق می‌کنیم که آزمایش کنید: کلیدها تنظیمات مختلفی را در صحنه‌های مختلف نشان می‌دهند. در توالی طوفان نهایی، کلید دیگری وجود دارد: Ctrl-A که با آن می‌توانید بازپخش پویانمایی را روشن/خاموش کنید و پرواز کنید. در این صحنه، اگر Esc را فشار دهید (برای خروج از عملکرد قفل موشواره) و دوباره Ctrl-I را فشار دهید، می‌توانید به تنظیمات مختص صحنه طوفان دسترسی پیدا کنید. نگاهی به اطراف بیندازید و چند نمای کارت‌پستالی زیبا مانند تصویر زیر ثبت کنید.

منطقه توفان

برای انجام این کار و اطمینان از اینکه به‌اندازه کافی برای نیازهای ما انعطاف‌پذیر است، از کتابخانه دوست‌داشتنی‌ای به‌نام dat.gui استفاده کردیم (برای آموزش قبلی درباره نحوه استفاده از آن، اینجا را ببینید). این کار به ما امکان داد تا تنظیماتی را که درمعرض دید بازدیدکنندگان سایت قرار می‌گرفت به‌سرعت تغییر دهیم.

کمی شبیه نقاشی مات

در بسیاری‌از فیلم‌ها و پویانمایی‌های کلاسیک دیزنی، ایجاد صحنه‌ها به‌معنای ترکیب لایه‌های مختلف بود. لایه‌هایی از کنش زنده، پویانمایی سل، حتی مجموعه‌های فیزیکی و لایه‌های بالایی که با نقاشی روی شیشه ایجاد شده‌اند: تکنیکی به نام نقاشی مات.

ساختار تجربه‌ای که ایجاد کردیم از بسیاری جهات مشابه است؛ هرچند برخی‌از «لایه‌ها» بسیار فراتر از تصاویر ثابت هستند. درواقع، آن‌ها براساس محاسبات پیچیده‌تر بر نحوه نمایش چیزها تأثیر می‌گذارند. بااین‌حال، حداقل در سطح تصویر بزرگ، ما با نماهایی سروکار داریم که یکی روی دیگری ترکیب شده‌اند. در بالا، لایه میانای کاربری را می‌بینید که صحنه‌ای سه‌بعدی در زیر آن قرار دارد: این صحنه از مؤلفه‌های مختلفی تشکیل شده است.

لایه میانای بالایی بااستفاده از DOM و CSS 3 ایجاد شد، به این معنی که ویرایش تعاملات می‌توانست به روش‌های مختلفی مستقل از تجربه سه‌بعدی با ارتباط بین این دو براساس فهرست انتخابی از رویدادها انجام شود. این ارتباط از Backbone Router + رویداد onHashChange HTML5 استفاده می‌کند که کنترل می‌کند کدام ناحیه باید پویانمایی ورودی/خروجی داشته باشد. (منبع پروژه: /develop/coffee/router/Router.coffee).

آموزش گام‌به‌گام: Sprite Sheets و پشتیبانی از Retina

یکی از تکنیک‌های جالب بهینه‌سازی که برای رابط کاربری به آن تکیه کردیم، ترکیب تصاویر متعدد هم‌پوشانی رابط کاربری در یک فایل PNG واحد بود تا درخواست‌های سرور کاهش یابد. در این پروژه، میانای کاربری از بیش‌از ۷۰ تصویر (بدون احتساب بافت‌های سه‌بعدی) تشکیل شده بود که همگی ازقبل بار شده بودند تا تأخیر وب‌سایت کاهش یابد. می‌توانید برگه جن زنده را در اینجا ببینید:

نمایشگر معمولی - http://findyourwaytooz.com/img/home/interface_1x.png نمایشگر Retina - http://findyourwaytooz.com/img/home/interface_2x.png

در اینجا چند نکته درباره نحوه استفاده از Sprite Sheets و نحوه استفاده از آن‌ها برای دستگاه‌های رتینا و دریافت رابط کاربری تا حد امکان واضح و مرتب آورده شده است.

درحال ایجاد Spritesheets

برای ایجاد SpriteSheets از TexturePacker استفاده کردیم که خروجی را در هر قالبی که نیاز داشته باشید ارائه می‌دهد. در این مورد، ما به‌عنوان EaselJS صادر کرده‌ایم که واقعاً تمیز است و می‌توانست برای ایجاد جن‌های پویانمایی‌شده نیز استفاده شود.

استفاده از «برگه Sprite» تولیدشده

پس‌از ایجاد «برگه Sprite»، باید فایل 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]
   },
}

مکان:

  • تصویر به نشانی وب برگه اسپرایت اشاره دارد
  • قاب‌ها مختصات هر عنصر میانای کاربر هستند [x، y، عرض، ارتفاع]
  • پویانمایی‌ها نام هر دارایی است

توجه داشته باشید که ما از تصاویر با تراکم بالا برای ایجاد صفحه Sprite استفاده کرده‌ایم، سپس نسخه معمولی را فقط با تغییر اندازه آن به نصف اندازه آن ایجاد کرده‌ایم.

درحال جمع‌بندی کردن

اکنون که همه چیز آماده است، فقط به یک قطعه جاوا اسکریپت نیاز داریم تا از آن استفاده کنیم.

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

برای درک بیشتر درباره تراکم پیکسل متغیر، می‌توانید این مقاله نوشته بوریس اسموس را بخوانید.

روند پردازش محتوای سه‌بعدی

تجربه محیط در لایه WebGL راه‌اندازی شده است. وقتی به یک صحنه سه‌بعدی فکر می‌کنید، یکی از دشوارترین سؤالات این است که چگونه مطمئن شوید می‌توانید محتوایی ایجاد کنید که حداکثر پتانسیل بیانی را از جنبه‌های مدل‌سازی، پویانمایی و جلوه‌ها فراهم کند. در بسیاری از موارد، هسته اصلی این مشکل خط لوله محتوا است: فرایندی توافق‌شده برای دنبال کردن جهت ایجاد محتوا برای صحنه سه‌بعدی.

می‌خواستیم دنیایی الهام‌بخش و شگفت‌انگیز خلق کنیم؛ بنابراین به فرایندی محکم نیاز داشتیم که هنرمندان سه‌بعدی را قادر به خلق آن کند. آن‌ها باید تا حد امکان در نرم‌افزار مدل‌سازی و پویانمایی سه‌بعدی خود آزادی بیان داشته باشند؛ و ما باید آن را ازطریق کد روی صفحه‌نمایش ارائه دهیم.

مدتی بود که روی این نوع مشکل کار می‌کردیم زیرا در گذشته هر بار که یک سایت سه‌بعدی ایجاد می‌کردیم، محدودیت‌هایی در ابزارهایی که می‌توانستیم استفاده کنیم پیدا می‌کردیم. بنابراین ما این ابزار را ایجاد کردیم، به نام کتابدار سه‌بعدی: یک قطعه از تحقیقات داخلی. و تقریباً آماده بود که برای یک کار واقعی اعمال شود.

این ابزار تاریخچه‌ای داشت: در ابتدا برای Flash بود و به شما اجازه می‌داد یک صحنه بزرگ Maya را به‌عنوان یک فایل فشرده تکی وارد کنید که برای باز کردن زمان اجرا بهینه‌سازی شده بود. دلیل بهینه بودن آن این بود که به‌طور مؤثری صحنه را در همان ساختار داده‌ای که درطول رندر و پویانمایی دستکاری می‌شود بسته‌بندی می‌کرد. هنگام بار شدن فایل، تجزیه بسیار کمی باید انجام شود. باز کردن بسته در Flash بسیار سریع بود زیرا فایل در قالب AMF بود که Flash می‌توانست به‌طور بومی آن را باز کند. استفاده از همان قالب در WebGL به کار بیشتری در واحد پردازش مرکزی نیاز دارد. درواقع مجبور شدیم لایه کد جاوا اسکریپت باز کردن بسته داده را دوباره ایجاد کنیم که اساساً آن فایل‌ها را از حالت فشرده خارج می‌کند و ساختارهای داده موردنیاز برای کار کردن WebGL را دوباره ایجاد می‌کند. از حالت فشرده خارج کردن کل صحنه سه‌بعدی عملیاتی است که تا حدودی به پردازنده فشار می‌آورد: از حالت فشرده خارج کردن صحنه ۱ در Find Your Way To Oz در یک دستگاه متوسط تا پیشرفته حدود ۲ ثانیه طول می‌کشد. بنابراین، این کار بااستفاده از فناوری Web Workers در زمان «راه‌اندازی صحنه» (قبل‌از اینکه صحنه واقعاً راه‌اندازی شود) انجام می‌شود تا تجربه کاربر متوقف نشود.

این ابزار مفید می‌تواند بیشتر صحنه‌های سه‌بعدی را وارد کند: مدل‌ها، بافت‌ها، پویانمایی‌های استخوانی. یک فایل کتابخانه واحد ایجاد می‌کنید که سپس می‌تواند توسط موتور سه‌بعدی بار شود. همه مدل‌های موردنیازتان را در صحنه در این کتابخانه قرار می‌دهید و سپس آن‌ها را در صحنه خود ایجاد می‌کنید.

اما مشکلی که داشتیم این بود که اکنون با WebGL سروکار داشتیم: فناوری جدیدی که تازه وارد بازار شده بود. این یک بچه بسیار سخت بود: که استانداردی را برای تجربه‌های سه‌بعدی مبتنی بر مرورگر تعیین می‌کرد. بنابراین یک لایه جاوا اسکریپت موقت ایجاد کردیم که فایل‌های صحنه سه‌بعدی فشرده‌شده 3D Librarian را می‌گرفت و آن‌ها را به‌درستی به قالبی ترجمه می‌کرد که WebGL بتواند درک کند.

آموزش گام‌به‌گام: بگذارید باد بوزد

یک موضوع تکراری در «راه خود را به اوز پیدا کنید» باد بود. رشته‌ای از خط داستانی به‌گونه‌ای ساختار یافته است که اوج صدای باد را نشان دهد.

صحنه اول کارناوال نسبتاً آرام است. و با عبور از صحنه‌های مختلف، کاربر باد شدیدتری را تجربه می‌کند که در صحنه نهایی، یعنی طوفان، به اوج خود می‌رسد.

بنابراین، ارائه جلوه باد فراگیر مهم بود.

برای ایجاد این، ۳ صحنه کارناوال را با اشیایی که نرم بودند و بنابراین قرار بود تحت تأثیر باد قرار گیرند، مانند چادرها، پرچم‌ها، سطح اتاقک عکاسی، و خود بادکنک پر کردیم.

پارچه نرم.

بازی‌های رایانه این روزها معمولاً براساس یک موتور فیزیک اصلی ساخته می‌شوند. بنابراین وقتی لازم است یک شیء نرم در دنیای سه‌بعدی شبیه‌سازی شود، یک شبیه‌سازی فیزیکی کامل برای آن اجرا می‌شود و رفتار نرم باورپذیری ایجاد می‌کند.

در WebGL / جاوا اسکریپت (هنوز) این امکان را نداریم که شبیه‌سازی فیزیکی کاملی را اجرا کنیم. بنابراین در Oz باید راهی برای ایجاد اثر باد پیدا می‌کردیم، بدون اینکه واقعاً آن را شبیه‌سازی کنیم.

اطلاعات «حساسیت به باد» را برای هر شیء در خود مدل سه‌بعدی جاسازی کردیم. هر رأس مدل سه‌بعدی دارای یک «ویژگی باد» بود که مشخص می‌کرد آن رأس چقدر باید تحت تأثیر باد قرار گیرد. بنابراین، این حساسیت باد مشخص‌شده برای اشیاء سه‌بعدی است. سپس باید خود باد را ایجاد می‌کردیم.

این کار را با تولید تصویری حاوی نویز پرلین انجام دادیم. این تصویر برای پوشش دادن «منطقه باد» خاصی درنظر گرفته شده است. بنابراین، روش خوب برای فکر کردن درباره آن این است که تصویری از نویز ابرمانند را تصور کنید که روی منطقه مستطیلی خاصی از صحنه سه‌بعدی قرار گرفته است. هر پیکسل، مقدار سطح خاکستری، از این تصویر مشخص می‌کند که باد در یک لحظه خاص در ناحیه سه‌بعدی «اطراف آن» چقدر قوی است.

برای ایجاد جلوه باد، تصویر درطول زمان با سرعت ثابت در جهت خاصی حرکت می‌کند؛ جهت باد. و برای اطمینان از اینکه «منطقه بادخیز» بر همه چیز در صحنه تأثیر نمی‌گذارد، تصویر باد را دور لبه‌ها می‌پیچیم و آن را به منطقه تأثیر محدود می‌کنیم.

آموزش گام‌به‌گام ساده باد سه‌بعدی

اکنون بیایید جلوه باد را در یک صحنه سه‌بعدی ساده در Three.js ایجاد کنیم.

می‌خواهیم در یک «چمن‌زار رویه‌ای» ساده باد ایجاد کنیم.

بیایید ابتدا صحنه را ایجاد کنیم. ما یک زمین مسطح ساده و بافت‌دار خواهیم داشت. و سپس هر تکه چمن، به سادگی با یک مخروط سه‌بعدی وارونه نشان داده می‌شود.

زمین پوشیده از چمن
زمین پوشیده از چمن

در اینجا نحوه ایجاد این صحنه ساده در 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

در اینجا ما درحال ایجاد یک شبکه ۱۵ در ۱۵ از تکه‌های چمن هستیم. ما کمی تصادفی‌سازی به موقعیت هر چمن اضافه می‌کنیم تا مانند سربازان در یک خط قرار نگیرند، که عجیب به‌نظر می‌رسد.

این زمین فقط یک صفحه افقی است که در پایه تکه‌های چمن قرار گرفته است (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 ایجاد کرده‌ایم و چند تکه چمن، ساخته‌شده از مخروط‌های معکوس تولیدشده به‌صورت رویه‌ای، و یک زمین ساده اضافه کرده‌ایم.

تا اینجا چیز خاصی نیست.

اکنون زمان شروع اضافه کردن باد است. اولین کار این است که می‌خواهیم اطلاعات حساسیت به باد را در مدل سه‌بعدی چمن جاسازی کنیم.

ما این اطلاعات را به‌عنوان یک ویژگی سفارشی برای هر رأس مدل سه‌بعدی چمن جاسازی خواهیم کرد. و از این قانون استفاده می‌کنیم: انتهای پایینی مدل چمن (نوک مخروط) حساسیت صفر دارد، زیرا به زمین متصل است. قسمت بالایی مدل چمن (پایه مخروط) بیشترین حساسیت را به باد دارد، زیرا این قسمت دورترین بخش از زمین است.

در اینجا نحوه کدگذاری مجدد تابع instanceGrass برای افزودن حساسیت به باد به‌عنوان یک مشخصه سفارشی برای مدل سه‌بعدی چمن آورده شده است.

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 برای انتهای پایینی مدل چمن (جایی که قرار است با زمین تماس داشته باشد) روی ۰ تنظیم شده است و مقدار آن برای انتهای بالایی مدل چمن ۱ است.

عنصر دیگری که نیاز داریم اضافه کردن باد واقعی به صحنه است. همان‌طور که بحث شد، برای این کار از نویز پرلین استفاده خواهیم کرد. ما به‌صورت رویه‌ای یک بافت نویز پرلین تولید خواهیم کرد.

برای شفافیت بیشتر، این بافت را به‌جای بافت سبز قبلی به خود زمین اختصاص می‌دهیم. با این کار، راحت‌تر می‌توانید متوجه شوید که باد در چه وضعیتی است.

بنابراین، این بافت نوفه پرلین به‌طور فضایی گستره زمین ما را پوشش می‌دهد و هر پیکسل از بافت، شدت باد را در ناحیه‌ای از زمین که آن پیکسل قرار دارد مشخص می‌کند. مستطیل زمین «منطقه باد» ما خواهد بود.

نویز پرلین به‌صورت رویه‌ای ازطریق سایه‌زن، به‌نام NoiseShader، تولید می‌شود. این سایه‌زن از الگوریتم‌های خدشه‌داری سیمپلکس سه‌بعدی از https://github.com/ashima/webgl-noise استفاده می‌کند . نسخه WebGL این مورد به‌طور دقیق از یکی از نمونه‌های Three.js آقای Doob در http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html گرفته شده است.

NoiseShader زمان، مقیاس، و مجموعه‌ای از پارامترهای انحراف را به‌عنوان یونیفرم دریافت می‌کند و توزیع دوبعدی خوبی از نویز پرلین را در برونداد تحویل می‌دهد.

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

...

از این «سایه‌زن» برای رندر کردن «نویز پرلین» به بافت استفاده خواهیم کرد. این کار در تابع 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 بیندازیم که مسئول تغییر شکل مدل‌های چمن براساس باد است.

برای ایجاد این سایه‌زن، از سایه‌زن استاندارد Three.js MeshPhongMaterial شروع کردیم و آن را اصلاح کردیم. این روشی سریع و ساده برای شروع کار با سایه‌زنی است که کار می‌کند، بدون اینکه لازم باشد از ابتدا شروع کنید.

ما قصد نداریم کل کد سایه‌زن را در اینجا کپی کنیم (می‌توانید آن را در فایل کد منبع مشاهده کنید)، زیرا بیشتر آن تکراری از سایه‌زن MeshPhongMaterial خواهد بود. اما بیایید نگاهی به بخش‌های اصلاح‌شده مربوط به باد در 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 را براساس موقعیت دوبعدی، xz (افقی) رأس محاسبه می‌کند. این مختصات UV برای جستجوی نیروی باد، vWindForce، از بافت باد نویز پرلین استفاده می‌شود.

این مقدار vWindForce با مشخصه سفارشی windFactor مختص رأس که در بالا بحث شد ترکیب می‌شود تا میزان تغییر شکل موردنیاز رأس محاسبه شود. همچنین یک پارامتر سراسری windScale برای کنترل قدرت کلی باد و یک بردار windDirection داریم که مشخص می‌کند تغییر شکل باد باید در کدام جهت انجام شود.

بنابراین، این کار باعث تغییر شکل تکه‌های چمن ما براساس باد می‌شود. اما هنوز کارمان تمام نشده است. همان‌طور که اکنون است، این تغییر شکل ایستا است و تأثیر یک منطقه بادخیز را منتقل نمی‌کند.

همان‌طور که اشاره کردیم، باید بافت نویز را درطول زمان در سراسر ناحیه باد بلغزانیم تا شیشه ما بتواند موج بزند.

این کار با تغییر دادن vOffset یکنواختی که به NoiseShader ارسال می‌شود درطول زمان انجام می‌شود. این یک پارامتر vec2 است که به ما امکان می‌دهد افست نویز را در امتداد یک جهت خاص (جهت باد ما) مشخص کنیم.

این کار را در تابع پرداخت انجام می‌دهیم که در هر قاب فراخوانی می‌شود:

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

در اینجا ۱۳۰ ذره غبار ایجاد می‌شود. و توجه داشته باشید که هرکدام از آن‌ها به 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 انجام می‌شود. به‌ویژه در سایه‌زن رأس.

کد این سایه‌زن نسخه اصلاح‌شده‌ای از ParticleMaterial Three.js است و هسته آن به این شکل است:

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;

این سایه‌زن رأس تفاوت چندانی با آنچه برای تغییر شکل چمن براساس باد داشتیم ندارد. این بافت نویز پرلین را به‌عنوان ورودی می‌گیرد و بسته به موقعیت جهانی گردوغبار، مقدار vWindForce را در بافت نویز جستجو می‌کند. سپس از این مقدار برای تغییر موقعیت ذره غبار استفاده می‌کند.

Riders On The Storm

ماجراجویانه‌ترین صحنه WebGL ما احتمالاً آخرین صحنه بود که اگر با کلیک کردن ازطریق بالن به چشم گردباد بروید تا به پایان سفرتان در سایت برسید، می‌توانید آن را ببینید، و ویدیو انحصاری از انتشار آتی.

صحنه بالن‌سواری

وقتی این صحنه را ایجاد کردیم، می‌دانستیم که باید ویژگی اصلی‌ای برای این تجربه داشته باشیم که تأثیرگذار باشد. گردباد چرخان به‌عنوان مرکز اصلی عمل می‌کند و لایه‌های محتوای دیگر این ویژگی را در جای خود قالب‌بندی می‌کنند تا جلوه‌ای دراماتیک ایجاد کنند. برای رسیدن به این هدف، چیزی معادل یک استودیوی فیلم‌سازی در اطراف این سایه‌زن عجیب ساختیم.

برای ایجاد ترکیب واقع‌گرایانه از رویکردی ترکیبی استفاده کردیم. برخی‌از آن‌ها ترفندهای دیداری بودند، مثل شکل‌های نوری برای ایجاد جلوه درخشش لنز، یا قطرات باران که به‌صورت لایه‌هایی روی صحنه‌ای که به آن نگاه می‌کنید پویانمایی می‌شوند. در موارد دیگر، سطوح صافی را ترسیم کردیم که به‌نظر می‌رسید درحال حرکت هستند، مانند لایه‌های ابرهای کم‌ارتفاع که طبق کد سیستم ذرات حرکت می‌کنند. درحالی‌که تکه‌های آوار درحال چرخش در اطراف گردباد لایه‌هایی در یک صحنه سه‌بعدی بودند که برای حرکت در جلو و پشت گردباد مرتب شده بودند.

دلیل اصلی اینکه مجبور شدیم صحنه را به این شکل بسازیم این بود که مطمئن شویم واحد پردازش گرافیکی کافی برای مدیریت سایه‌زن گردباد در تعادل با سایر جلوه‌هایی که اعمال می‌کردیم داریم. در ابتدا مشکلات بزرگی در تعادل GPU داشتیم، اما بعداً این صحنه بهینه‌سازی شد و سبک‌تر از صحنه‌های اصلی شد.

آموزش گام‌به‌گام: سایه‌زن طوفان

برای ایجاد توالی طوفان نهایی، تکنیک‌های مختلفی باهم ترکیب شدند، اما محور اصلی این کار یک سایه‌زن GLSL سفارشی بود که شبیه گردباد است. ما تکنیک‌های مختلفی را امتحان کرده بودیم، از سایه‌زن‌های رأس برای ایجاد گرداب‌های هندسی جالب گرفته تا پویانمایی‌های مبتنی بر ذرات و حتی پویانمایی‌های سه‌بعدی از اشکال هندسی پیچ‌خورده. هیچ‌کدام از جلوه‌ها نتوانستند حس گردباد را بازآفرینی کنند یا ازنظر پردازش به تلاش زیادی نیاز داشتند.

درنهایت پروژه کاملاً متفاوتی پاسخ را به ما ارائه داد. پروژه‌ای موازی شامل بازی‌های علمی برای نقشه‌برداری از مغز موش از مؤسسه ماکس پلانک (brainflight.org) جلوه‌های بصری جالبی ایجاد کرده بود. ما موفق شده بودیم بااستفاده از یک سایه‌زن حجمی سفارشی، فیلم‌هایی از داخل نورون موش ایجاد کنیم.

داخل نورون موش بااستفاده از سایه‌زن حجمی سفارشی
داخل نورون موش بااستفاده از سایه‌زن حجمی سفارشی

متوجه شدیم که داخل سلول مغز کمی شبیه قیف گردباد است. و چون از تکنیک حجمی استفاده می‌کردیم می‌دانستیم که می‌توانیم این سایه‌زن را از همه جهات در فضا ببینیم. می‌توانیم رندر سایه‌زن را طوری تنظیم کنیم که با صحنه طوفان ترکیب شود، به‌ویژه اگر بین لایه‌های ابر و بالای پس‌زمینه‌ای دراماتیک قرار گیرد.

تکنیک سایه‌زن شامل ترفندی است که اساساً از یک سایه‌زن GLSL برای پردازش کل شیء با الگوریتم پردازش ساده‌شده‌ای به‌نام پردازش گام‌به‌گام پرتو با میدان فاصله استفاده می‌کند. در این تکنیک، یک سایه‌زن پیکسل ایجاد می‌شود که نزدیک‌ترین فاصله به سطح را برای هر نقطه روی صفحه تخمین می‌زند.

مرجع خوبی برای این الگوریتم را می‌توانید در نمای کلی iq پیدا کنید: Rendering Worlds With Two Triangles - Iñigo Quilez. همچنین با کاوش در گالری سایه‌زن‌ها در glsl.heroku.com، نمونه‌های زیادی از این تکنیک را می‌توان در آنجا یافت که می‌توان آن‌ها را آزمایش کرد.

قلب سایه‌زن با تابع اصلی شروع می‌شود، تبدیل‌های دوربین را تنظیم می‌کند و وارد حلقه‌ای می‌شود که به‌طور مکرر فاصله تا سطح را ارزیابی می‌کند. فراخوانی RaytraceFoggy( direction_vector, max_iterations, color, color_multiplier ) جایی است که محاسبه اصلی ردیابی پرتو انجام می‌شود.

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

کار مربوط به ایجاد این نوع سایه‌زن دشوار است. Beyond the issues involved with the abstraction of the operations you are creating there are serious optimisation and cross platform compatibility problems that you need to trace and solve before you can use the work in production.

بخش اول مشکل: بهینه‌سازی این سایه‌زن برای صحنه ما. برای مقابله با این مشکل، باید رویکردی «ایمن» اتخاذ می‌کردیم تا درصورت سنگین شدن سایه‌زن، مشکلی پیش نیاید. برای انجام این کار، سایه‌زن گردباد را با وضوح نمونه‌برداری‌شده متفاوتی نسبت به بقیه صحنه ترکیب کردیم. این از فایل 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 (برای جلوگیری از ظاهر بلوکی) در خط ۱۱۰۷ در stormTest.coffee روی صفحه‌نمایش رندر می‌کنیم. این یعنی در بدترین حالت، گردباد محوتری خواهیم داشت اما حداقل بدون اینکه کنترل را از کاربر بگیرد کار می‌کند.

مرحله بعدی بهینه‌سازی مستلزم بررسی دقیق الگوریتم است. عامل محاسباتی محرک در سایه‌زن، تکراری است که روی هر پیکسل انجام می‌شود تا فاصله تابع سطح را تخمین بزند: تعداد تکرارهای حلقه ردیابی پرتو. بااستفاده از اندازه گام بزرگ‌تر، می‌توانستیم تخمینی از سطح گردباد با تکرارهای کمتر به‌دست آوریم، درحالی‌که خارج از سطح ابری آن بودیم. وقتی داخل بودیم، اندازه گام را برای دقت بیشتر و برای اینکه بتوانیم مقادیر را برای ایجاد جلوه مه‌آلود ترکیب کنیم، کاهش می‌دادیم. همچنین ایجاد یک استوانه محدودکننده برای تخمین عمق پرتو تابیده‌شده سرعت را به‌خوبی افزایش داد.

بخش بعدی مشکل این بود که مطمئن شویم این سایه‌زن روی کارت‌های گرافیک مختلف اجرا می‌شود. هر بار آزمایش‌هایی انجام دادیم و شروع به ایجاد درکی شهودی از نوع مشکلات سازگاری کردیم که ممکن بود با آن‌ها مواجه شویم. دلیل اینکه نتوانستیم خیلی بهتر از شهود عمل کنیم این است که همیشه نمی‌توانستیم اطلاعات اشکال‌زدایی خوبی درباره خطاها دریافت کنیم. سناریوی معمول فقط یک خطای واحد پردازش گرافیکی است که اطلاعات بیشتری ارائه نمی‌دهد، یا حتی ازکارافتادن سیستم!

مشکلات سازگاری بین برد ویدیو راه‌حل‌های مشابهی داشتند: مطمئن شوید که ثابت‌های ایستا دقیقاً با نوع داده تعریف‌شده وارد شده‌اند، IE: 0.0 برای float و 0 برای int. هنگام نوشتن توابع طولانی‌تر دقت کنید؛ بهتر است موارد را به چندین تابع ساده‌تر و متغیرهای موقت تقسیم کنید زیرا به‌نظر می‌رسد کامپایلرها برخی موارد خاص را به‌درستی مدیریت نمی‌کنند. مطمئن شوید که بافت‌ها همگی توان ۲ باشند، خیلی بزرگ نباشند، و در هر صورت هنگام جستجوی داده‌های بافت در حلقه، «احتیاط» را رعایت کنید.

بزرگ‌ترین مشکلاتی که در سازگاری داشتیم مربوط به جلوه نورپردازی برای طوفان بود. از بافت ازپیش‌ساخته‌ای استفاده کردیم که دور گردباد پیچیده شده بود تا بتوانیم رشته‌های آن را رنگ کنیم. جلوه فوق‌العاده‌ای بود و باعث شد گردباد به‌راحتی با رنگ‌های صحنه ترکیب شود، اما تلاش برای اجرای آن در پلاتفرم‌های دیگر زمان زیادی برد.

پیچند

وب‌سایت تلفن همراه

تجربه تلفن همراه نمی‌توانست ترجمه مستقیم نسخه رایانه باشد زیرا فناوری و الزامات پردازش بسیار سنگین بود. ما باید چیز جدیدی می‌ساختیم که به‌طور خاص کاربران تلفن همراه را هدف قرار می‌داد.

فکر کردیم جالب می‌شود اگر «غرفه عکاسی کارناوال» را از رایانه به برنامه وب تلفن همراه منتقل کنیم تا از دوربین تلفن همراه کاربر استفاده کند. چیزی که تا آن زمان ندیده بودیم انجام شود.

برای افزودن چاشنی، تبدیل‌های سه‌بعدی را در CSS3 کدگذاری کردیم. با پیوند دادن آن به ژیروسکوپ و شتاب‌سنج، توانستیم عمق زیادی به این تجربه اضافه کنیم. این سایت به نحوه نگه داشتن، حرکت دادن، و نگاه کردن شما به تلفنتان پاسخ می‌دهد.

هنگام نوشتن این مقاله، فکر کردیم که خوب است چند نکته درباره نحوه اجرای روان فرایند توسعه تلفن همراه به شما ارائه دهیم. بفرمایید! ادامه دهید و ببینید چه چیزی می‌توانید از آن یاد بگیرید!

نکته‌ها و ترفندهای تلفن همراه

پیش‌بارگذار چیزی است که موردنیاز است، نه چیزی که باید از آن اجتناب شود. می‌دانیم که گاهی اوقات مورد دوم اتفاق می‌افتد. دلیل اصلی این است که با رشد پروژه، باید فهرست چیزهایی را که پیش‌بارگیری می‌کنید حفظ کنید. بدتر از آن، اگر منابع مختلفی را به‌طور هم‌زمان دریافت می‌کنید، نحوه محاسبه پیشرفت بارگیری چندان واضح نیست. اینجا است که کلاس انتزاعی سفارشی و بسیار عمومی ما «Task» مفید واقع می‌شود. ایده اصلی آن این است که ساختار تودرتوی بی‌پایانی را فراهم کند که در آن یک «تکلیف» می‌تواند «زیرتکلیف‌های» خودش را داشته باشد، که آن‌ها هم می‌توانند زیرتکلیف‌های خودشان را داشته باشند و غیره… علاوه‌براین، هر تکلیف پیشرفت خود را نسبت به پیشرفت زیرتکلیف‌هایش (اما نه نسبت به پیشرفت تکلیف اصلی) محاسبه می‌کند. با مشتق کردن همه MainPreloadTask،‏ AssetPreloadTask، و TemplatePreFetchTask از Task، ساختاری ایجاد کردیم که به این شکل است:

پیش‌بارکننده

به‌لطف این رویکرد و کلاس Task، به‌راحتی می‌توانیم از پیشرفت کلی (MainPreloadTask)، یا فقط پیشرفت دارایی‌ها (AssetPreloadTask)، یا پیشرفت بار کردن الگوها (TemplatePreFetchTask) مطلع شویم. حتی پیشرفت یک فایل خاص. برای دیدن نحوه انجام این کار، به کلاس Task در /m/javascripts/raw/util/Task.js و پیاده‌سازی‌های واقعی تکلیف در /m/javascripts/preloading/task نگاهی بیندازید. به‌عنوان مثال، این گزیده‌ای از نحوه راه‌اندازی کلاس /m/javascripts/preloading/task/MainPreloadTask.js است که پوشاننده پیش‌بارگیری نهایی ما است:

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 مشترک)، توجه به نحوه بارگیری دارایی‌های وابسته به پلاتفرم نیز ارزشمند است. اساساً چهار نوع تصویر داریم. استاندارد تلفن همراه (‎.ext، که ext پسوند فایل است، معمولاً ‎ .png یا ‎ .jpg)، رتینای تلفن همراه (‎-2x.ext)، استاندارد رایانه لوحی (‎-tab.ext)، و رتینای رایانه لوحی (‎-tab-2x.ext). به‌جای انجام تشخیص در MainPreloadTask و کدنویسی ثابت چهار آرایه دارایی، فقط نام و پسوند دارایی را برای پیش‌بارگیری و اینکه آیا دارایی وابسته به پلاتفرم است (واکنش‌گرا = درست / نادرست) می‌گوییم. سپس، 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 Photo Booth (iOS6/Android)

هنگام توسعه OZ mobile، متوجه شدیم که زمان زیادی را به‌جای کار کردن، صرف بازی با اتاقک عکاسی می‌کنیم :D دلیلش ساده بود، چون سرگرم‌کننده است. بنابراین یک نسخه نمایشی برای شما ساختیم تا با آن بازی کنید.

اتاقک عکاسی سیار
اتاقک عکاسی سیار

می‌توانید نسخه نمایشی زنده را در اینجا ببینید (آن را در iPhone یا تلفن Android خود اجرا کنید):

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

برای راه‌اندازی آن، به یک نمونه برنامه رایگان Google App Engine نیاز دارید که بتوانید باطن را در آن اجرا کنید. کد فرانت‌اند پیچیده نیست اما چند نکته ظریف وجود دارد که باید به آن‌ها توجه کرد. بیایید اکنون آن‌ها را بررسی کنیم:

  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 و ترکیب گسترده فناوری‌های مختلف درگیر، در این مقاله توانستیم تنها چند مورد از رویکردهایی را که استفاده کردیم پوشش دهیم.

اگر کنجکاو هستید که کل این مجموعه را کاوش کنید، می‌توانید کد منبع کامل «راه خود را به اوز پیدا کنید» را در این پیوند بررسی کنید.

دست‌اندرکاران

برای فهرست کامل دست‌اندرکاران، اینجا کلیک کنید

مرجع‌ها