केस स्टडी - ऑज़ तक पहुंचने का रास्ता ढूंढें

परिचय

“Find Your Way to Oz”, Google Chrome Experiment का एक नया प्रयोग है. इसे Disney ने वेब पर उपलब्ध कराया है. इसकी मदद से, कैनसस के एक सर्कस की इंटरैक्टिव यात्रा की जा सकती है. इसमें एक भयानक तूफ़ान आपको ओज़ की दुनिया में ले जाता है.

हमारा मकसद, सिनेमा की खूबसूरती को ब्राउज़र की तकनीकी क्षमताओं के साथ जोड़ना था, ताकि लोगों को एक मज़ेदार और दिलचस्प अनुभव दिया जा सके. इससे लोग खुद को इस अनुभव से जोड़ पाएंगे.

इस लेख में, इस काम के बारे में पूरी जानकारी देना थोड़ा मुश्किल है. इसलिए, हमने टेक्नोलॉजी की कहानी के कुछ ऐसे चैप्टर चुने हैं जो हमें दिलचस्प लगे. इस दौरान, हमने कुछ ऐसे ट्यूटोरियल बनाए जो आसान से मुश्किल की ओर बढ़ते हैं.

इस अनुभव को मुमकिन बनाने के लिए, कई लोगों ने कड़ी मेहनत की है. यहां उन सभी के नाम नहीं दिए जा सकते. पूरी कहानी जानने के लिए, कृपया साइट पर जाएं और मेन्यू सेक्शन में जाकर क्रेडिट पेज देखें.

टेस्टिंग प्रोसेस की एक झलक

डेस्कटॉप पर Find Your Way to Oz, एक बेहतरीन और इमर्सिव दुनिया है. हम 3D और फ़िल्म बनाने के पारंपरिक तरीकों से प्रेरित कई लेयर वाले इफ़ेक्ट इस्तेमाल करते हैं. इनसे एक ऐसा सीन तैयार होता है जो असल ज़िंदगी जैसा लगता है. सबसे अहम टेक्नोलॉजी में, Three.js के साथ WebGL, कस्टम बिल्ट शेडर, और CSS3 सुविधाओं का इस्तेमाल करके बनाए गए डीओएम ऐनिमेटेड एलिमेंट शामिल हैं. इसके अलावा, इंटरैक्टिव अनुभवों के लिए getUserMedia API (WebRTC) का इस्तेमाल किया जाता है. इससे उपयोगकर्ता, सीधे वेबकैम से अपनी इमेज जोड़ सकता है. साथ ही, 3D साउंड के लिए WebAudio का इस्तेमाल किया जाता है.

हालांकि, इस तरह की टेक्नोलॉजी का जादू यह है कि यह सब एक साथ कैसे काम करता है. यह भी एक मुख्य चुनौती है: विज़ुअल इफ़ेक्ट और इंटरैक्टिव एलिमेंट को एक ही सीन में कैसे ब्लेंड किया जाए, ताकि एक जैसा अनुभव मिल सके? इस विज़ुअल जटिलता को मैनेज करना मुश्किल था: इससे यह बताना मुश्किल हो जाता था कि हम किसी भी समय डेवलपमेंट के किस चरण में थे.

एक-दूसरे से जुड़े विज़ुअल इफ़ेक्ट और ऑप्टिमाइज़ेशन की समस्या को हल करने के लिए, हमने कंट्रोल पैनल का भरपूर इस्तेमाल किया. इससे हमें उन सभी ज़रूरी सेटिंग को कैप्चर करने में मदद मिली जिनकी हम उस समय समीक्षा कर रहे थे. ब्राउज़र में सीन को लाइव अडजस्ट किया जा सकता था. इसमें ब्राइटनेस, फ़ील्ड की गहराई, गामा वगैरह शामिल थे… कोई भी व्यक्ति, इस अनुभव में अहम पैरामीटर की वैल्यू में बदलाव करके देख सकता था और यह पता लगा सकता था कि कौनसी वैल्यू सबसे सही है.

अपना सीक्रेट शेयर करने से पहले, हम आपको चेतावनी देना चाहते हैं कि यह क्रैश हो सकता है. ठीक वैसे ही जैसे कार के इंजन में छेड़छाड़ करने पर होता है. पक्का करें कि आपके पास कोई ज़रूरी काम न हो. इसके बाद, साइट के मुख्य यूआरएल पर जाएं और पते में ?debug=on जोड़ें. साइट लोड होने का इंतज़ार करें. इसके बाद, Ctrl-I बटन दबाएं. आपको दाईं ओर एक ड्रॉपडाउन दिखेगा. अगर “कैमरा पाथ से बाहर निकलें” विकल्प से सही का निशान हटाया जाता है, तो स्पेस में आसानी से घूमने के लिए, A, W, S, D बटन और माउस का इस्तेमाल किया जा सकता है.

कैमरा पाथ.

हम यहां सभी सेटिंग के बारे में नहीं बताएंगे. हालांकि, हमारा सुझाव है कि आप एक्सपेरिमेंट करें: बटन से अलग-अलग सीन में अलग-अलग सेटिंग दिखती हैं. तूफ़ान के आखिरी सीक्वेंस में एक और बटन है: Ctrl-A. इसकी मदद से, ऐनिमेशन प्लेबैक को टॉगल किया जा सकता है और आस-पास घूमा जा सकता है. इस सीन में, अगर आपने Esc दबाया (माउस लॉक की सुविधा से बाहर निकलने के लिए) और फिर से Ctrl-I दबाया, तो आपको तूफ़ान वाले सीन से जुड़ी सेटिंग ऐक्सेस करने का विकल्प मिलेगा. आस-पास की जगहें देखें और नीचे दी गई इमेज की तरह, पोस्टकार्ड के लिए कुछ अच्छी इमेज कैप्चर करें.

तूफ़ान का सीन

ऐसा करने और यह पक्का करने के लिए कि यह हमारी ज़रूरतों के हिसाब से काफ़ी फ़्लेक्सिबल हो, हमने dat.gui नाम की एक बेहतरीन लाइब्रेरी का इस्तेमाल किया. इसे इस्तेमाल करने के तरीके के बारे में पिछला ट्यूटोरियल यहां देखें. इससे हमें साइट पर आने वाले लोगों को दिखने वाली सेटिंग में तुरंत बदलाव करने की सुविधा मिली.

मैट पेंटिंग जैसा

Disney की कई क्लासिक फ़िल्मों और ऐनिमेशन में सीन बनाने का मतलब, अलग-अलग लेयर को जोड़ना होता था. इसमें लाइव ऐक्शन, सेल ऐनिमेशन, और फ़िज़िकल सेट की लेयर थीं. साथ ही, कांच पर पेंटिंग करके बनाई गई लेयर भी थीं. इस तकनीक को मैट-पेंटिंग कहा जाता है.

हमने जो अनुभव तैयार किया है उसका स्ट्रक्चर कई मामलों में एक जैसा है. हालांकि, कुछ “लेयर” स्टैटिक विज़ुअल से कहीं ज़्यादा हैं. इनसे, ज़्यादा मुश्किल कंप्यूटेशन के हिसाब से चीज़ों के दिखने के तरीके पर असर पड़ता है. हालांकि, कम से कम बड़ी तस्वीर के लेवल पर, हम व्यू के साथ काम कर रहे हैं. ये व्यू, एक के ऊपर एक कंपोज़ किए गए हैं. सबसे ऊपर आपको एक यूज़र इंटरफ़ेस (यूआई) लेयर दिखती है. इसके नीचे एक 3D सीन होता है, जो अलग-अलग सीन कॉम्पोनेंट से बना होता है.

टॉप इंटरफ़ेस लेयर को डीओएम और सीएसएस 3 का इस्तेमाल करके बनाया गया था. इसका मतलब है कि इंटरैक्शन में बदलाव करने के कई तरीके थे. ये तरीके 3D अनुभव से अलग थे. साथ ही, दोनों के बीच कम्यूनिकेशन, इवेंट की चुनिंदा सूची के हिसाब से होता था. इस कम्यूनिकेशन में, Backbone Router + onHashChange HTML5 इवेंट का इस्तेमाल किया जाता है. इससे यह कंट्रोल किया जाता है कि किस हिस्से को ऐनिमेट करना है. (प्रोजेक्ट सोर्स: /develop/coffee/router/Router.coffee).

ट्यूटोरियल: स्प्राइट शीट और रेटिना डिसप्ले की सुविधा

इंटरफ़ेस को ऑप्टिमाइज़ करने के लिए, हमने एक मज़ेदार तकनीक का इस्तेमाल किया. इसमें हमने इंटरफ़ेस की कई ओवरले इमेज को एक PNG फ़ाइल में जोड़ दिया, ताकि सर्वर के अनुरोधों को कम किया जा सके. इस प्रोजेक्ट में, इंटरफ़ेस को 70 से ज़्यादा इमेज (3D टेक्सचर को छोड़कर) से बनाया गया था. इन इमेज को पहले ही लोड कर लिया गया था, ताकि वेबसाइट की इंतज़ार का समय कम किया जा सके. लाइव स्प्राइट शीट यहां देखी जा सकती है:

नॉर्मल डिसप्ले - http://findyourwaytooz.com/img/home/interface_1x.png रेटिना डिसप्ले - http://findyourwaytooz.com/img/home/interface_2x.png

यहां कुछ सलाह दी गई हैं कि हमने स्प्राइट शीट का इस्तेमाल कैसे किया. साथ ही, रेटिना डिवाइसों के लिए इनका इस्तेमाल कैसे किया जाए और इंटरफ़ेस को ज़्यादा से ज़्यादा साफ़ और बेहतर कैसे बनाया जाए.

स्प्राइटशीट बनाई जा रही हैं

स्प्राइटशीट बनाने के लिए, हमने 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, स्प्राइट शीट के यूआरएल के बारे में बताता है
  • फ़्रेम, हर यूज़र इंटरफ़ेस (यूआई) एलिमेंट के कोऑर्डिनेट होते हैं [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'));

वैरिएबल पिक्सल डेंसिटी के बारे में ज़्यादा जानने के लिए, बोरिस स्मस का यह लेख पढ़ें.

3D कॉन्टेंट पाइपलाइन

एनवायरमेंट का अनुभव, WebGL लेयर पर सेट अप किया गया है. 3D सीन के बारे में सोचते समय, सबसे मुश्किल सवालों में से एक यह होता है कि ऐसा कॉन्टेंट कैसे बनाया जाए जो मॉडलिंग, ऐनिमेशन, और इफ़ेक्ट के लिहाज़ से ज़्यादा से ज़्यादा असरदार हो. इस समस्या की मुख्य वजह कॉन्टेंट पाइपलाइन है: 3D सीन के लिए कॉन्टेंट बनाने की एक तय प्रोसेस.

हम एक ऐसी दुनिया बनाना चाहते थे जो लोगों को हैरान कर दे. इसलिए, हमें एक ऐसी प्रोसेस की ज़रूरत थी जिससे 3D आर्टिस्ट इसे बना सकें. उन्हें 3D मॉडलिंग और ऐनिमेशन सॉफ़्टवेयर में, अपनी क्रिएटिविटी दिखाने की ज़्यादा से ज़्यादा आज़ादी देनी होगी. साथ ही, हमें कोड के ज़रिए इसे स्क्रीन पर रेंडर करना होगा.

हम इस तरह की समस्या पर कुछ समय से काम कर रहे थे. ऐसा इसलिए, क्योंकि पहले जब भी हमने कोई 3D साइट बनाई, तो हमें उन टूल में कुछ सीमाएं मिलीं जिनका इस्तेमाल हम कर सकते थे. इसलिए, हमने 3D लाइब्रेरियन नाम का एक टूल बनाया. यह हमारी इंटरनल रिसर्च का हिस्सा था. यह मॉडल, असल काम के लिए इस्तेमाल किए जाने के लिए तैयार था.

इस टूल का अपना एक इतिहास है: शुरुआत में इसे Flash के लिए बनाया गया था. इसकी मदद से, Maya के बड़े सीन को कंप्रेस की गई एक फ़ाइल के तौर पर इंपोर्ट किया जा सकता था. इस फ़ाइल को रनटाइम के दौरान अनपैक करने के लिए ऑप्टिमाइज़ किया गया था. यह सबसे सही इसलिए था, क्योंकि इसने सीन को उसी डेटा स्ट्रक्चर में पैक किया था जिसमें रेंडर और ऐनिमेशन के दौरान बदलाव किया जाता है. लोड होने पर, फ़ाइल को पार्स करने की बहुत कम ज़रूरत होती है. Flash में अनपैक करना काफ़ी तेज़ था, क्योंकि फ़ाइल एएमएफ़ फ़ॉर्मैट में थी. Flash इसे नेटिव तौर पर अनपैक कर सकता था. WebGL में इसी फ़ॉर्मैट का इस्तेमाल करने के लिए, सीपीयू पर थोड़ा ज़्यादा काम करना पड़ता है. हमें डेटा-अनपैक JavaScript लेयर का कोड फिर से बनाना पड़ा. इससे उन फ़ाइलों को डिकंप्रेस किया जा सकेगा और WebGL के काम करने के लिए ज़रूरी डेटा स्ट्रक्चर फिर से बनाए जा सकेंगे. पूरे 3D सीन को अनपैक करने के लिए, सीपीयू पर थोड़ा ज़्यादा लोड पड़ता है: Find Your Way To Oz में सीन 1 को अनपैक करने के लिए, मिड से हाई एंड मशीन पर करीब दो सेकंड लगते हैं. इसलिए, इसे वेब वर्कर्स टेक्नोलॉजी का इस्तेमाल करके, ”सीन सेटअप” के समय (सीन को असल में लॉन्च करने से पहले) किया जाता है. इससे उपयोगकर्ता को बेहतर अनुभव मिलता है.

इस टूल की मदद से, ज़्यादातर 3D सीन इंपोर्ट किए जा सकते हैं. जैसे, मॉडल, टेक्सचर, और बोन ऐनिमेशन. एक लाइब्रेरी फ़ाइल बनाएं, जिसे 3D इंजन लोड कर सके. इस लाइब्रेरी में, अपने सीन के लिए ज़रूरी सभी मॉडल जोड़ें और उन्हें अपने सीन में इस्तेमाल करें.

हालांकि, हमें एक समस्या का सामना करना पड़ा. वह यह कि अब हमें WebGL के साथ काम करना था, जो कि एक नई टेक्नोलॉजी थी. यह एक मुश्किल काम था: इससे ब्राउज़र पर आधारित 3D अनुभवों के लिए स्टैंडर्ड सेट हो रहा था. इसलिए, हमने एक ऐड हॉक JavaScript लेयर बनाई, जो 3D लाइब्रेरियन की कंप्रेस की गई 3D सीन फ़ाइलों को लेगी और उन्हें सही तरीके से ऐसे फ़ॉर्मैट में ट्रांसलेट करेगी जिसे WebGL समझ सके.

ट्यूटोरियल: हवा का रुख़

“Find Your Way To Oz” में हवा एक बार-बार दिखने वाली थीम थी. कहानी का एक हिस्सा, हवा की आवाज़ को धीरे-धीरे तेज़ करने के लिए बनाया गया है.

कार्निवल का पहला सीन काफ़ी शांत है. अलग-अलग सीन से गुज़रते हुए, उपयोगकर्ता को हवा की रफ़्तार धीरे-धीरे तेज़ होती हुई महसूस होती है. आखिर में, तूफ़ान का सीन आता है.

इसलिए, हवा का शानदार इफ़ेक्ट देना ज़रूरी था.

इसे बनाने के लिए, हमने कार्निवल के तीन सीन में ऐसी चीज़ें शामिल कीं जो हवा से हिलती-डुलती हैं. जैसे, टेंट, फ़ोटो बूथ की सतह पर लगे झंडे, और गुब्बारा.

मुलायम कपड़ा.

डेस्कटॉप गेम, आम तौर पर कोर फ़िज़िक्स इंजन के आधार पर बनाए जाते हैं. इसलिए, जब 3D दुनिया में किसी सॉफ़्ट-ऑब्जेक्ट को सिम्युलेट करना होता है, तो उसके लिए पूरा फ़िज़िक्स सिम्युलेशन चलाया जाता है. इससे सॉफ़्ट-ऑब्जेक्ट का व्यवहार असल जैसा लगता है.

WebGL / Javascript में, हमारे पास अब तक फ़िज़िक्स सिम्युलेशन को पूरी तरह से चलाने की सुविधा नहीं है. इसलिए, Oz में हमें हवा का असर दिखाने का तरीका ढूंढना पड़ा. इसके लिए, हमें हवा को सिम्युलेट करने की ज़रूरत नहीं पड़ी.

हमने 3D मॉडल में मौजूद हर ऑब्जेक्ट के लिए, “हवा की संवेदनशीलता” की जानकारी को एम्बेड किया है. 3D मॉडल के हर वर्टेक्स में एक "विंड एट्रिब्यूट" था. इससे यह पता चलता था कि उस वर्टेक्स पर हवा का कितना असर पड़ेगा. इसलिए, इससे 3D ऑब्जेक्ट पर हवा के असर की जानकारी मिलती है. इसके बाद, हमें हवा का इफ़ेक्ट बनाना था.

हमने पर्लिन नॉइज़ वाली एक इमेज जनरेट करके ऐसा किया. इस इमेज का मकसद, “हवा के असर वाले इलाके” को कवर करना है. इसलिए, इसके बारे में सोचने का एक अच्छा तरीका यह है कि 3D सीन के किसी रेक्टैंगल इलाके पर, बादल जैसी इमेज की कल्पना की जाए. इस इमेज का हर पिक्सल, ग्रे लेवल वैल्यू, यह बताता है कि 3D एरिया में किसी खास समय पर हवा कितनी तेज़ है.

हवा का इफ़ेक्ट दिखाने के लिए, इमेज को समय के साथ एक ही स्पीड से किसी खास दिशा में मूव किया जाता है. यह दिशा हवा की दिशा होती है. साथ ही, यह पक्का करने के लिए कि “तेज़ हवा वाले इलाके” का असर सीन में मौजूद हर चीज़ पर न पड़े, हम हवा की इमेज को किनारों पर रैप करते हैं. इससे हवा का असर सिर्फ़ तय किए गए इलाके पर पड़ता है.

हवा का 3D इफ़ेक्ट बनाने का आसान ट्यूटोरियल

चलिए, अब Three.js में एक आसान 3D सीन में हवा का इफ़ेक्ट बनाते हैं.

हम एक सामान्य ”प्रोसीजरल ग्रास फ़ील्ड” में हवा बनाएंगे.

सबसे पहले, पॉडकास्ट की प्लेलिस्ट बनाएं. हम एक आसान, टेक्स्चर वाला फ़्लैट इलाका बनाने जा रहे हैं. इसके बाद, घास के हर हिस्से को उल्टे 3D कोन से दिखाया जाएगा.

घास से भरा इलाका
घास से भरा इलाका

CoffeeScript का इस्तेमाल करके, Three.js में यह आसान सीन बनाने का तरीका यहां बताया गया है.

सबसे पहले, हम 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 बाई 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 सीन बनाया है. साथ ही, इसमें कुछ घास जोड़ी है. यह घास, प्रोसीजरल तरीके से जनरेट किए गए उल्टे शंकु और एक सामान्य इलाके से बनी है.

अभी तक कुछ खास नहीं है.

अब हवा जोड़ने का समय आ गया है. सबसे पहले, हमें घास के 3D मॉडल में हवा की संवेदनशीलता की जानकारी को एम्बेड करना होगा.

हम इस जानकारी को कस्टम एट्रिब्यूट के तौर पर एम्बेड करेंगे. ऐसा घास के 3D मॉडल के हर वर्टेक्स के लिए किया जाएगा. हम इस नियम का इस्तेमाल करेंगे: घास के मॉडल के निचले हिस्से (कोन के सिरे) की संवेदनशीलता शून्य होती है, क्योंकि यह ज़मीन से जुड़ा होता है. घास के मॉडल के सबसे ऊपरी हिस्से (कोन का बेस) में हवा की संवेदनशीलता सबसे ज़्यादा होती है, क्योंकि यह हिस्सा ज़मीन से सबसे दूर होता है.

यहां बताया गया है कि instanceGrass फ़ंक्शन को फिर से कैसे कोड किया जाता है, ताकि घास के 3D मॉडल के लिए कस्टम एट्रिब्यूट के तौर पर, हवा की संवेदनशीलता को जोड़ा जा सके.

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

अब हम पहले इस्तेमाल किए गए MeshPhongMaterial के बजाय, कस्टम मटीरियल windMaterial का इस्तेमाल करते हैं. WindMaterial, WindMeshShader को रैप करता है. इसके बारे में हम कुछ ही देर में जानेंगे.

इसलिए, instanceGrass में मौजूद कोड, घास के मॉडल के सभी वर्टेक्स को लूप करता है. साथ ही, हर वर्टेक्स के लिए, windFactor नाम का एक कस्टम वर्टेक्स एट्रिब्यूट जोड़ता है. इस windFactor को घास के मॉडल के निचले हिस्से (जहां यह ज़मीन को छूता है) के लिए 0 पर सेट किया गया है. साथ ही, घास के मॉडल के ऊपरी हिस्से के लिए इसकी वैल्यू 1 है.

हमें एक और एलिमेंट की ज़रूरत है. वह है, सीन में हवा का इफ़ेक्ट जोड़ना. जैसा कि हमने पहले बताया था, इसके लिए हम पर्लिन नॉइज़ का इस्तेमाल करेंगे. हम प्रोसीजरल तरीके से पर्लिन नॉइज़ टेक्सचर जनरेट करेंगे.

चीज़ों को साफ़ तौर पर दिखाने के लिए, हम इस टेक्सचर को टेरेन पर असाइन करेंगे. इससे पहले, इस पर हरे रंग का टेक्सचर था. इससे आपको हवा की स्थिति के बारे में आसानी से जानकारी मिल जाएगी.

इसलिए, यह पर्लिन नॉइज़ टेक्सचर, हमारे इलाके के एक्सटेंशन को कवर करेगा. साथ ही, टेक्सचर का हर पिक्सल, उस इलाके की हवा की तीव्रता के बारे में बताएगा जहां वह पिक्सल मौजूद है. टेरेन रेक्टैंगल, हमारा “हवा का इलाका” होगा.

पर्लिन नॉइज़ को NoiseShader नाम के शेडर की मदद से, प्रोसीजरल तरीके से जनरेट किया जाता है. यह शेडर, https://github.com/ashima/webgl-noise से 3d सिंप्लेक्स नॉइज़ एल्गोरिदम का इस्तेमाल करता है . इसका WebGL वर्शन, MrDoob के Three.js सैंपल में से एक से लिया गया है. यह यहां उपलब्ध है: http://mrdoob.github.com/three.js/examples/webgl_terrain_dynamic.html.

NoiseShader, यूनिफ़ॉर्म के तौर पर समय, स्केल, और ऑफ़सेट पैरामीटर का सेट लेता है. साथ ही, पर्लिन नॉइज़ का एक अच्छा 2D डिस्ट्रिब्यूशन आउटपुट करता है.

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 शेडर का प्रतिरूप होगा. हालांकि, आइए वर्टेक्स शेडर में हवा से जुड़े, बदले गए हिस्सों को देखते हैं.

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;

इसलिए, यह शेडर सबसे पहले वर्टेक्स की 2D, xz (हॉरिज़ॉन्टल) पोज़िशन के आधार पर, windUV टेक्सचर लुकअप कोऑर्डिनेट का हिसाब लगाता है. इस यूवी कोऑर्डिनेट का इस्तेमाल, पर्लिन नॉइज़ विंड टेक्सचर से हवा की ताकत, vWindForce को देखने के लिए किया जाता है.

vWindForce की इस वैल्यू को, वर्टेक्स के हिसाब से windFactor के साथ कंपोज़िट किया जाता है. यह कस्टम एट्रिब्यूट है, जिसके बारे में ऊपर बताया गया है. इससे यह पता चलता है कि वर्टेक्स को कितना डिफ़ॉर्मेशन चाहिए. हमारे पास हवा की कुल ताकत को कंट्रोल करने के लिए, एक ग्लोबल windScale पैरामीटर भी है. साथ ही, एक windDirection वेक्टर भी है, जो यह बताता है कि हवा की वजह से होने वाले बदलाव किस दिशा में होने चाहिए.

इस वजह से, घास के टुकड़ों में हवा के हिसाब से बदलाव होता है. हालांकि, अभी हमारा काम पूरा नहीं हुआ है. फ़िलहाल, यह डिफ़ॉर्मेशन स्टैटिक है. इससे तेज़ हवा वाले इलाके का असर नहीं दिखेगा.

जैसा कि हमने बताया था, हमें समय के साथ हवा के पूरे इलाके में नॉइज़ टेक्सचर को स्लाइड करना होगा, ताकि हमारा ग्लास हिल सके.

ऐसा करने के लिए, NoiseShader को पास किए गए vOffset यूनिफ़ॉर्म को समय के साथ शिफ़्ट किया जाता है. यह एक 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 में किया जाता है. खास तौर पर, वर्टेक्स शेडर में.

इस शेडर का कोड, 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;

यह वर्टेक्स शेडर, घास के हवा के हिसाब से डिफ़ॉर्मेशन के लिए इस्तेमाल किए गए शेडर से ज़्यादा अलग नहीं है. यह पर्लिन नॉइज़ टेक्सचर को इनपुट के तौर पर लेता है. साथ ही, धूल की पोज़िशन के आधार पर, नॉइज़ टेक्सचर में vWindForce वैल्यू को खोजता है. इसके बाद, यह इस वैल्यू का इस्तेमाल करके धूल के कण की पोज़िशन में बदलाव करता है.

Riders On The Storm

हमारे WebGL सीन में सबसे रोमांचक सीन शायद आखिरी सीन था. इसे देखने के लिए, गुब्बारे पर क्लिक करके बवंडर के बीच में जाएं. इससे आपको साइट पर अपनी यात्रा के आखिर में पहुंचने का मौका मिलेगा. साथ ही, आपको आने वाली रिलीज़ का खास वीडियो भी दिखेगा.

बलून राइड का सीन

जब हमने इस सीन को बनाया, तो हमें पता था कि हमें इस अनुभव के लिए एक मुख्य सुविधा की ज़रूरत होगी, जो असरदार हो. घूमता हुआ बवंडर, इस फ़िल्टर का मुख्य हिस्सा होगा. साथ ही, कॉन्टेंट की अन्य लेयर इस फ़िल्टर को और बेहतर बनाएंगी, ताकि एक ड्रमैटिक इफ़ेक्ट तैयार किया जा सके. इसके लिए, हमने इस अजीब शेडर के आस-पास एक फ़िल्म स्टूडियो सेट बनाया.

हमने असली जैसा दिखने वाला कंपोज़िट बनाने के लिए, कई तरीकों का इस्तेमाल किया. इनमें से कुछ विज़ुअल ट्रिक थीं, जैसे कि लेंस फ़्लेयर इफ़ेक्ट बनाने के लिए रोशनी के आकार या बारिश की बूंदें, जो आपके सामने मौजूद सीन के ऊपर लेयर के तौर पर ऐनिमेट होती हैं. अन्य मामलों में, हमने फ़्लैट सरफ़ेस को इस तरह से ड्रॉ किया कि वे हिलते-डुलते दिखें. जैसे, पार्टिकल सिस्टम कोड के हिसाब से, कम ऊंचाई पर उड़ने वाले बादलों की लेयर का हिलना-डुलना. वहीं, बवंडर के आस-पास घूम रहे मलबे के टुकड़ों को 3D सीन में लेयर के तौर पर रखा गया था. इन्हें बवंडर के आगे और पीछे घूमने के लिए क्रम से लगाया गया था.

हमें इस सीन को इस तरह से इसलिए बनाना पड़ा, ताकि हमारे पास बवंडर के शेडर को हैंडल करने के लिए ज़रूरत के मुताबिक जीपीयू हो. साथ ही, हम अन्य इफ़ेक्ट को भी बैलेंस कर सकें. शुरुआत में, हमें जीपीयू को बैलेंस करने में काफ़ी समस्याएं आईं. हालांकि, बाद में इस सीन को ऑप्टिमाइज़ किया गया और यह मुख्य सीन से हल्का हो गया.

ट्यूटोरियल: स्टॉर्म शेडर

तूफ़ान का फ़ाइनल सीक्वेंस बनाने के लिए, कई अलग-अलग तकनीकों का इस्तेमाल किया गया. हालांकि, इस काम का मुख्य हिस्सा एक कस्टम GLSL शेडर था, जो बवंडर जैसा दिखता है. हमने कई अलग-अलग तकनीकों का इस्तेमाल किया. जैसे, वर्टेक्स शेडर से दिलचस्प ज्यामितीय भंवर बनाना, पार्टिकल पर आधारित ऐनिमेशन बनाना, और मुड़ी हुई ज्यामितीय आकृतियों के 3D ऐनिमेशन बनाना. कोई भी इफ़ेक्ट, बवंडर का एहसास नहीं करा पा रहा था या उन्हें प्रोसेस करने में बहुत ज़्यादा समय लग रहा था.

आखिरकार, एक बिलकुल अलग प्रोजेक्ट से हमें जवाब मिला. मैक्स प्लैंक इंस्टिट्यूट (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;
}

इस तरह का शेडर बनाना मुश्किल काम है. ऑपरेशन के ऐब्स्ट्रैक्शन से जुड़ी समस्याओं के अलावा, ऑप्टिमाइज़ेशन और क्रॉस प्लैटफ़ॉर्म के साथ काम करने से जुड़ी गंभीर समस्याएं भी होती हैं. प्रोडक्शन में काम शुरू करने से पहले, आपको इन समस्याओं का पता लगाना और उन्हें हल करना होगा.

समस्या का पहला हिस्सा: इस शेडर को हमारे सीन के लिए ऑप्टिमाइज़ करना. इस समस्या से निपटने के लिए, हमें एक “सुरक्षित” तरीका अपनाना पड़ा, ताकि शेडर के बहुत ज़्यादा भारी होने पर भी कोई समस्या न हो. इसके लिए, हमने सीन के बाकी हिस्से की तुलना में, अलग सैंपल रिज़ॉल्यूशन पर टॉर्नेडो शेडर को कंपोज़िट किया. यह 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 में @line 1107 देखें. इसका मतलब है कि सबसे खराब स्थिति में, हमें ज़्यादा धुंधला बवंडर दिखेगा. हालांकि, कम से कम यह उपयोगकर्ता से कंट्रोल छीने बिना काम करता है.

ऑप्टिमाइज़ेशन के अगले चरण में, एल्गोरिदम को समझना ज़रूरी है. शेडर में कंप्यूटेशनल फ़ैक्टर, हर पिक्सल पर किया जाने वाला दोहराव है. इससे, सतह के फ़ंक्शन की दूरी का अनुमान लगाने की कोशिश की जाती है: रेमार्चिंग लूप के दोहराव की संख्या. स्टेप साइज़ को बड़ा करके, हम बवंडर की सतह का अनुमान कम बार दोहराकर लगा सकते थे. ऐसा तब होता, जब हम बवंडर की बादलों वाली सतह से बाहर होते. इसके बाद, हम स्टेप साइज़ को कम कर देंगे, ताकि सटीक तरीके से काम किया जा सके. साथ ही, धुंधला इफ़ेक्ट बनाने के लिए वैल्यू को मिक्स किया जा सके. साथ ही, कास्ट की गई रे की गहराई का अनुमान लगाने के लिए, बाउंडिंग सिलेंडर बनाने से स्पीड में काफ़ी बढ़ोतरी हुई.

इस समस्या का अगला हिस्सा यह था कि यह शेडर अलग-अलग वीडियो कार्ड पर काम करे. हमने हर बार कुछ टेस्ट किए और यह समझने की कोशिश की कि हमें किस तरह की समस्याएं आ सकती हैं. हम अनुमान लगाने से बेहतर कुछ नहीं कर पाए, क्योंकि हमें गड़बड़ियों को डीबग करने की अच्छी जानकारी हमेशा नहीं मिल पाती थी. आम तौर पर, जीपीयू में कोई गड़बड़ी होती है और उसे ठीक करने के लिए ज़्यादा कुछ नहीं किया जा सकता. इसके अलावा, सिस्टम क्रैश भी हो सकता है!

क्रॉस वीडियो बोर्ड के साथ काम करने से जुड़ी समस्याओं के समाधान भी एक जैसे थे: पक्का करें कि स्टैटिक कॉन्स्टेंट, तय किए गए सटीक डेटा टाइप के हों. जैसे: फ़्लोट के लिए 0.0 और इंट के लिए 0. लंबे फ़ंक्शन लिखते समय सावधानी बरतें. बेहतर होगा कि आप चीज़ों को कई आसान फ़ंक्शन और अंतरिम वैरिएबल में बांट लें, क्योंकि ऐसा लगता है कि कंपाइलर कुछ मामलों को सही तरीके से हैंडल नहीं करते. पक्का करें कि सभी टेक्सचर, 2 की पावर में हों और बहुत बड़े न हों. साथ ही, लूप में टेक्सचर डेटा देखते समय “सावधानी” बरतें.

हमें गेम को अलग-अलग डिवाइसों के साथ काम करने लायक बनाने में सबसे ज़्यादा समस्या, तूफ़ान के लिए लाइटिंग इफ़ेक्ट की वजह से हुई. हमने बवंडर के चारों ओर पहले से बने टेक्स्चर का इस्तेमाल किया, ताकि हम उसके धुएं को रंग दे सकें. यह एक शानदार इफ़ेक्ट था. इसकी मदद से, बवंडर को सीन के रंगों में आसानी से ब्लेंड किया जा सकता था. हालांकि, इसे अन्य प्लैटफ़ॉर्म पर चलाने में काफ़ी समय लगा.

बवंडर

मोबाइल वेब साइट

मोबाइल वर्शन को डेस्कटॉप वर्शन का सीधा अनुवाद नहीं बनाया जा सकता था, क्योंकि टेक्नोलॉजी और प्रोसेसिंग की ज़रूरतें बहुत ज़्यादा थीं. हमें कुछ नया बनाना था, जो खास तौर पर मोबाइल उपयोगकर्ताओं को टारगेट करे.

हमें लगा कि डेस्कटॉप पर मौजूद Carnival Photo-Booth को मोबाइल वेब ऐप्लिकेशन के तौर पर उपलब्ध कराना अच्छा रहेगा. यह ऐप्लिकेशन, उपयोगकर्ता के मोबाइल कैमरे का इस्तेमाल करेगा. हमने ऐसा पहले कभी नहीं देखा था.

इसे और मज़ेदार बनाने के लिए, हमने CSS3 में 3D ट्रांसफ़ॉर्मेशन को कोड किया. इसे जाइरोस्कोप और ऐक्सेलरोमीटर से लिंक करके, हम इस अनुभव को और बेहतर बना पाए. यह साइट, आपके फ़ोन को पकड़ने, उसे हिलाने-डुलाने, और उसे देखने के तरीके के हिसाब से काम करती है.

इस लेख को लिखते समय, हमने सोचा कि आपको मोबाइल डेवलपमेंट की प्रोसेस को आसानी से चलाने के बारे में कुछ सलाह देना फ़ायदेमंद होगा. ये रहे! आगे बढ़ें और देखें कि आपको इससे क्या सीखने को मिलता है!

मोबाइल से वीडियो बनाने के सुझाव और तरकीबें

प्रीलोडर एक ज़रूरी चीज़ है, इसे अनदेखा नहीं किया जाना चाहिए. हम जानते हैं कि कभी-कभी ऐसा होता है. ऐसा इसलिए है, क्योंकि प्रोजेक्ट के बढ़ने के साथ-साथ, आपको पहले से लोड की जाने वाली चीज़ों की सूची को अपडेट करते रहना होगा. इससे भी खराब बात यह है कि अगर एक ही समय पर कई अलग-अलग रिसॉर्स को पुल किया जा रहा है, तो लोडिंग की प्रोग्रेस को कैलकुलेट करने का तरीका साफ़ तौर पर नहीं बताया गया है. यहीं पर हमारी कस्टम और बहुत ही सामान्य ऐब्स्ट्रैक्ट क्लास 'Task' काम आती है. इसका मुख्य मकसद, नेस्ट किए गए स्ट्रक्चर को बिना किसी सीमा के इस्तेमाल करने की सुविधा देना है. इसमें किसी टास्क के अपने सब-टास्क हो सकते हैं. साथ ही, उन सब-टास्क के भी अपने सब-टास्क हो सकते हैं. इसके अलावा, हर टास्क अपनी प्रोग्रेस को अपने सब-टास्क की प्रोग्रेस के हिसाब से कैलकुलेट करता है. हालांकि, पैरंट टास्क की प्रोग्रेस के हिसाब से नहीं. सभी MainPreloadTask, AssetPreloadTask, और TemplatePreFetchTask को Task से डिराइव करके, हमने एक ऐसा स्ट्रक्चर बनाया जो इस तरह दिखता है:

प्रीलोडर

इस तरीके और टास्क क्लास की मदद से, हम ग्लोबल प्रोग्रेस (MainPreloadTask), ऐसेट की प्रोग्रेस (AssetPreloadTask) या टेंप्लेट लोड होने की प्रोग्रेस (TemplatePreFetchTask) को आसानी से जान सकते हैं. यहां तक कि किसी खास फ़ाइल के अपलोड होने की प्रोग्रेस भी देखी जा सकती है. यह कैसे किया जाता है, यह देखने के लिए /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 के साथ कैसे कम्यूनिकेट करता है (शेयर किए गए टास्क को लागू करने के ज़रिए), यह भी ध्यान देने वाली बात है कि हम प्लैटफ़ॉर्म पर निर्भर ऐसेट को कैसे लोड करते हैं. आम तौर पर, हमारे पास चार तरह की इमेज होती हैं. मोबाइल स्टैंडर्ड (.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 फ़ोटो बूथ (iOS6/Android)

OZ मोबाइल को डेवलप करते समय, हमें पता चला कि हम काम करने के बजाय, फ़ोटो बूथ के साथ खेलने में ज़्यादा समय बिताते हैं :D ऐसा इसलिए था, क्योंकि इसमें बहुत मज़ा आता है. इसलिए, हमने आपके लिए एक डेमो बनाया है, ताकि आप इसे आज़मा सकें.

मोबाइल फ़ोटो बूथ
मोबाइल फ़ोटो बूथ

यहां लाइव डेमो देखा जा सकता है. इसे अपने iPhone या Android फ़ोन पर चलाएं:

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

इसे सेट अप करने के लिए, आपको बिना किसी शुल्क के मिलने वाले Google App Engine ऐप्लिकेशन इंस्टेंस की ज़रूरत होगी. इसमें बैकएंड को चलाया जा सकता है. फ़्रंट एंड कोड जटिल नहीं है, लेकिन इसमें कुछ संभावित गड़बड़ियां हो सकती हैं. आइए, अब इनके बारे में जानते हैं:

  1. इमेज फ़ाइल का टाइप हम चाहते हैं कि लोग सिर्फ़ इमेज अपलोड कर सकें. ऐसा इसलिए, क्योंकि यह एक फ़ोटो बूथ है, न कि वीडियो बूथ. सिद्धांत के तौर पर, एचटीएमएल में फ़िल्टर को इस तरह से तय किया जा सकता है: 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 का पूरा सोर्स कोड देखें.

क्रेडिट

क्रेडिट की पूरी सूची देखने के लिए, यहां क्लिक करें

रेफ़रंस