מבוא
“Find Your Way to Oz” הוא Chrome Experiment חדש ב-Google Chrome שחברת Disney העלתה לאינטרנט. הוא מאפשר לכם לצאת למסע אינטראקטיבי בקרקס בקנזס, שמוביל אתכם לארץ עוץ אחרי שסופה ענקית סוחפת אתכם.
המטרה שלנו הייתה לשלב את העושר של הקולנוע עם היכולות הטכניות של הדפדפן כדי ליצור חוויה מהנה וסוחפת שהמשתמשים יכולים ליצור איתה קשר חזק.
העבודה הזו גדולה מדי בשביל לתאר אותה במלואה במאמר הזה, אז התעמקנו ושלפנו כמה פרקים מהסיפור הטכנולוגי שלדעתנו הם מעניינים. במהלך הפיתוח, יצרנו כמה מדריכים ממוקדים ברמות קושי שונות.
הרבה אנשים עבדו קשה כדי לאפשר את החוויה הזו – יותר מדי מכדי לפרט את כולם כאן. כדי לקרוא את הסיפור המלא, היכנסו לאתר ועיינו בדף הקרדיטים בקטע התפריט.
הצצה אל מאחורי הקלעים
המשחק Find Your Way to Oz במחשב הוא עולם עשיר וסוחף. אנחנו משתמשים בתלת-ממד ובכמה שכבות של אפקטים מסורתיים בהשראת עולם הקולנוע, שמשתלבים יחד כדי ליצור סצנה כמעט מציאותית. הטכנולוגיות הבולטות ביותר הן WebGL עם Three.js, הצללות בהתאמה אישית ורכיבי DOM מונפשים באמצעות תכונות CSS3. בנוסף, יש את getUserMedia API (WebRTC) לחוויות אינטראקטיביות שמאפשרות למשתמשים להוסיף את התמונה שלהם ישירות ממצלמת האינטרנט, ואת WebAudio לצליל תלת-ממדי.
אבל הקסם של חוויה טכנולוגית כזו הוא איך שהכל מתחבר. זה גם אחד האתגרים העיקריים: איך לשלב אפקטים חזותיים ורכיבים אינטראקטיביים בסצנה אחת כדי ליצור שלם עקבי? המורכבות החזותית הזו הקשתה על הניהול, והיה קשה לדעת באיזה שלב של הפיתוח אנחנו נמצאים בכל רגע נתון.
כדי לפתור את הבעיה של אפקטים חזותיים ואופטימיזציה שמקושרים זה לזה, השתמשנו הרבה בלוח בקרה שמתעד את כל ההגדרות הרלוונטיות שבדקנו באותו זמן. אפשר היה לשנות את הסצנה בזמן אמת בדפדפן, כולל הבהירות, עומק השדה, הגאמה וכו'. כל אחד יכול היה לנסות לשנות את הערכים של הפרמטרים המשמעותיים בחוויה, ולקחת חלק בגילוי של מה שעובד הכי טוב.
לפני שנשתף את הסוד שלנו, אנחנו רוצים להזהיר אתכם שהדפדפן עלול לקרוס, בדיוק כמו שהיה קורה אם הייתם מתעסקים עם מנוע של מכונית. מוודאים שאין לכם משהו חשוב לעשות, נכנסים לכתובת ה-URL הראשית של האתר ומוסיפים ?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).
מדריך: גיליונות ספרייט ותמיכה ב-Retina
טכניקת אופטימיזציה מעניינת אחת שהשתמשנו בה בממשק הייתה לשלב את התמונות הרבות של שכבות העל של הממשק בקובץ PNG אחד, כדי לצמצם את הבקשות לשרת. בפרויקט הזה, הממשק היה מורכב מיותר מ-70 תמונות (לא כולל טקסטורות תלת-ממדיות) שנטענו כולן מראש כדי להפחית את זמן האחזור של האתר. כאן אפשר לראות את גיליון ה-sprite הפעיל:
תצוגה רגילה – http://findyourwaytooz.com/img/home/interface_1x.png תצוגת Retina – http://findyourwaytooz.com/img/home/interface_2x.png
ריכזנו כאן כמה טיפים שיעזרו לכם להשתמש בגיליונות ספרייט, ואיך להשתמש בהם במכשירי רטינה כדי שהממשק יהיה חד ונקי ככל האפשר.
יצירת גיליונות ספרייט
כדי ליצור 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]
},
}
כאשר:
- image מתייחס לכתובת ה-URL של גיליון ה-sprite
- המסגרות הן הקואורדינטות של כל רכיב בממשק המשתמש [x, y, רוחב, גובה]
- האנימציות הן השמות של כל נכס
שימו לב שהשתמשנו בתמונות בצפיפות גבוהה כדי ליצור את גיליון ה-Sprite, ואז יצרנו את הגרסה הרגילה על ידי שינוי הגודל לחצי מהגודל המקורי.
אז מה זה אומר?
עכשיו, כשהכול מוכן, אנחנו צריכים רק קטע קוד של 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'));
כדי להבין קצת יותר על צפיפויות פיקסלים משתנות, אתם יכולים לקרוא את המאמר הזה של בוריס סמוס.
תהליך העבודה עם תוכן תלת-ממדי
חוויית הסביבה מוגדרת בשכבת WebGL. כשחושבים על סצנה תלת-ממדית, אחת השאלות הכי מסובכות היא איך לוודא שאפשר ליצור תוכן שמאפשר את פוטנציאל ההבעה המקסימלי מבחינת המודלים, האנימציה והאפקטים. במובנים רבים, הבעיה הזו נובעת מצינור עיבוד הנתונים של התוכן: תהליך מוסכם ליצירת תוכן לסצנה התלת-ממדית.
רצינו ליצור עולם מעורר השראה, ולכן היינו צריכים תהליך יציב שיאפשר לאומני תלת-ממד ליצור אותו. היינו צריכים לתת להם כמה שיותר חופש ביטוי בתוכנת האנימציה והמודלים התלת-ממדיים שלהם, והיינו צריכים לעבד את זה על המסך באמצעות קוד.
עבדנו על בעיה מהסוג הזה במשך זמן מה, כי בכל פעם שיצרנו אתר תלת-ממדי בעבר, נתקלנו במגבלות בכלים שבהם יכולנו להשתמש. אז יצרנו את הכלי הזה, שנקרא 3D Librarian: מחקר פנימי. והוא היה כמעט מוכן ליישום בעבודה אמיתית.
לכלי הזה יש היסטוריה: במקור הוא נועד ל-Flash, והוא אפשר להביא סצנה גדולה של Maya כקובץ דחוס אחד שעבר אופטימיזציה לפריקה בזמן ריצה. הסיבה לכך שהיא הייתה אופטימלית היא שהיא ארזה ביעילות את הסצנה באותו מבנה נתונים שבו מתבצעות מניפולציות במהלך הרינדור והאנימציה. צריך לבצע מעט מאוד ניתוח של הקובץ כשהוא נטען. פריקת הקבצים ב-Flash הייתה מהירה מאוד כי הקובץ היה בפורמט AMF, ש-Flash יכול לפרוק באופן מקורי. כדי להשתמש באותו פורמט ב-WebGL, נדרשת קצת יותר עבודה ב-CPU. למעשה, היינו צריכים ליצור מחדש שכבת קוד של פריקת נתונים ב-JavaScript, שתבצע דחיסה של הקבצים האלה ותיצור מחדש את מבני הנתונים הדרושים כדי ש-WebGL יפעל. פריקת הסצנה התלת-ממדית כולה היא פעולה שדורשת קצת יותר משאבים מהמעבד: פריקת סצנה 1 ב-Find Your Way To Oz דורשת כ-2 שניות במחשב ברמה בינונית עד גבוהה. לכן, הפעולה הזו מתבצעת באמצעות טכנולוגיית Web Workers, בזמן "הגדרת הסצנה" (לפני שהסצנה מופעלת בפועל), כדי לא להפריע לחוויית המשתמש.
הכלי השימושי הזה יכול לייבא את רוב הסצנה התלת-ממדית: מודלים, טקסטורות, אנימציות של עצמות. אתם יוצרים קובץ ספרייה אחד, ואז מנוע התלת-ממד יכול לטעון אותו. אתם מכניסים לספרייה הזו את כל המודלים שאתם צריכים בסצנה, וזהו, אתם יכולים להוסיף אותם לסצנה.
אבל הייתה לנו בעיה: עכשיו היינו צריכים להתמודד עם WebGL, טכנולוגיה חדשה יחסית. זה היה אתגר די קשה: זה היה הסטנדרט לחוויות תלת-ממדיות מבוססות-דפדפן. לכן יצרנו שכבת JavaScript אד-הוק שתיקח את קובצי הסצנות התלת-ממדיות הדחוסים של 3D Librarian, ותתרגם אותם בצורה נכונה לפורמט ש-WebGL יכול להבין.
מדריך: Let There Be Wind
מוטיב חוזר ב-"Find Your Way To Oz" היה רוח. חלק מהעלילה בנוי כקרשנדו של רוח.
הסצנה הראשונה של הקרנבל רגועה יחסית. בכל סצנה, המשתמש חווה רוח חזקה יותר, עד לסצנה האחרונה – הסערה.
לכן היה חשוב לספק אפקט רוח סוחף.
כדי ליצור את זה, הוספנו ל-3 סצנות הקרנבל אובייקטים רכים שאמורים להיות מושפעים מהרוח, כמו אוהלים, דגלים, המשטח של תא הצילום והבלון עצמו.
משחקים למחשב מבוססים בדרך כלל על מנוע פיזיקלי מרכזי. לכן, כשצריך לדמות אובייקט רך בעולם התלת-ממדי, מופעלת סימולציה פיזיקלית מלאה שיוצרת התנהגות אמינה של אובייקט רך.
ב-WebGL או ב-JavaScript עדיין אין לנו אפשרות להריץ סימולציה פיזיקלית מלאה. אז בארץ עוץ היינו צריכים למצוא דרך ליצור אפקט של רוח, בלי לדמות אותה בפועל.
הטמענו את המידע על "רגישות לרוח" של כל אובייקט במודל התלת-ממדי עצמו. לכל קודקוד של המודל התלת-ממדי היה "מאפיין רוח" שציין עד כמה הקודקוד הזה אמור להיות מושפע מהרוח. אז זה מציין את הרגישות לרוח של אובייקטים תלת-ממדיים. אחר כך היינו צריכים ליצור את הרוח עצמה.
עשינו את זה על ידי יצירת תמונה שמכילה רעש פרלין. התמונה הזו נועדה לכסות "אזור רוח" מסוים. דרך טובה לחשוב על זה היא לדמיין תמונה של רעש דמוי ענן שמונחת על אזור מלבני מסוים בסצנה התלת-ממדית. כל פיקסל, ערך רמת אפור, של התמונה הזו מציין את עוצמת הרוח ברגע מסוים באזור התלת-ממדי "שמקיף אותו".
כדי ליצור את אפקט הרוח, התמונה זזה לאורך זמן במהירות קבועה בכיוון מסוים – כיוון הרוח. כדי לוודא ש"אזור הרוח" לא משפיע על כל מה שמופיע בסצנה, אנחנו עוטפים את תמונת הרוח מסביב לקצוות, ומוגבלים לאזור ההשפעה.
מדריך פשוט ליצירת רוח בתלת-ממד
עכשיו ניצור אפקט של רוח בסצנה תלת-ממדית פשוטה ב-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
כאן אנחנו יוצרים רשת של 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, ולהוסיף כמה פיסות דשא, שעשויות מחרוטים הפוכים שנוצרו באופן פרוצדורלי, ושטח פשוט.
עד עכשיו לא עשינו שום דבר מיוחד.
עכשיו הגיע הזמן להוסיף רוח. קודם כל, אנחנו רוצים להטמיע את המידע על הרגישות לרוח במודל התלת-ממדי של הדשא.
אנחנו הולכים להטמיע את המידע הזה כמאפיין מותאם אישית, לכל קודקוד של המודל התלת-ממדי של הדשא. אנחנו נשתמש בכלל הבא: לקצה התחתון של מודל הדשא (קצה החרוט) יש רגישות אפס, כי הוא מחובר לקרקע. החלק העליון של מודל הדשא (בסיס החרוט) הוא בעל הרגישות המקסימלית לרוח, כי הוא החלק שהכי רחוק מהקרקע.
כך הפונקציה 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 מוגדר ל-0 בקצה התחתון של מודל הדשא (שם הוא אמור לגעת בקרקע), ול-1 בקצה העליון של מודל הדשא.
הרכיב השני שאנחנו צריכים הוא הרוח עצמה. כמו שדיברנו, אנחנו הולכים להשתמש ברעש פרלין בשביל זה. ניצור באופן פרוצדורלי טקסטורה של רעש פרלין.
כדי שהדברים יהיו ברורים, נקצה את הטקסטורה הזו לפני השטח עצמם, במקום הטקסטורה הירוקה הקודמת. כך יהיה קל יותר להבין מה קורה עם הרוח.
אז המרקם הזה של רעש פרלין יכסה את השטח של פני השטח שלנו, וכל פיקסל של המרקם יציין את עוצמת הרוח של אזור פני השטח שבו הפיקסל הזה נמצא. המלבן של פני השטח יהיה "אזור הרוח" שלנו.
רעש פרלין נוצר באופן פרוצדורלי באמצעות הצללה שנקראת NoiseShader. ההצללה הזו משתמשת באלגוריתמים של רעש סימפלקס תלת-ממדי מתוך: https://github.com/ashima/webgl-noise . גרסת ה-WebGL של הדוגמה הזו נלקחה מילה במילה מאחת מהדוגמאות של Three.js של MrDoob, בכתובת: 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) }
...
נשתמש ב-Shader הזה כדי לעבד את רעש פרלין לטקסטורה. הפעולה הזו מתבצעת בפונקציה 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 ושינינו אותה. זו דרך טובה ומהירה להתחיל לעבוד עם הצללה שפועלת, בלי להתחיל מאפס.
אנחנו לא נעתיק לכאן את כל קוד ה-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, על סמך המיקום הדו-ממדי, xz (אופקי) של הקודקוד. הקואורדינטה הזו משמשת לחיפוש עוצמת הרוח, vWindForce, ממרקם הרוח של רעש פרלין.
הערך של vWindForce משולב עם המאפיין המותאם אישית windFactor הספציפי לקודקוד שצוין למעלה, כדי לחשב את מידת העיוות שנדרשת לקודקוד. יש לנו גם פרמטר גלובלי של windScale, כדי לשלוט בעוצמה הכוללת של הרוח, ווקטור של windDirection, שמציין את הכיוון שבו צריך להתרחש העיוות של הרוח.
כך נוצר עיוות של פיסות הדשא בהתאם לרוח. אבל עדיין לא סיימנו. במצב הנוכחי, העיוות הזה הוא סטטי, והוא לא יעביר את האפקט של אזור עם רוח.
כמו שאמרנו, נצטרך להזיז את טקסטורת הרעש לאורך זמן, על פני אזור הרוח, כדי שהזכוכית שלנו תוכל להתנופף.
כדי לעשות את זה, משנים לאורך זמן את המשתנה האחיד vOffset שמועבר אל 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.
הקוד של ה-shader הזה הוא גרסה שונה של 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;
ה-vertex shader הזה לא שונה בהרבה ממה שהיה לנו לעיוות של הדשא על בסיס הרוח. הוא מקבל את המרקם של רעש פרלין כקלט, ובהתאם למיקום של האבק בעולם, הוא מחפש ערך של vWindForce במרקם הרעש. לאחר מכן, הוא משתמש בערך הזה כדי לשנות את המיקום של חלקיק האבק.
Riders On The Storm
הסצנה הנועזת ביותר של WebGL הייתה כנראה הסצנה האחרונה, שאפשר לראות אם לוחצים על הבלון לתוך עין הטורנדו כדי להגיע לסוף המסע באתר, וסרטון בלעדי של הגרסה הקרובה.
כשיצרנו את הסצנה הזו, ידענו שאנחנו צריכים להוסיף לחוויה תכונה מרכזית שתהיה משמעותית. הטורנדו המסתובב ישמש כמרכז, ושכבות של תוכן אחר יעצבו את התכונה הזו במקום כדי ליצור אפקט דרמטי. כדי להשיג את זה, בנינו את מה שהיה שווה ערך לסט של אולפן סרטים סביב ההצללה המוזרה הזו.
השתמשנו בגישה משולבת כדי ליצור את התמונה המורכבת הריאליסטית. חלק מהאפקטים היו טריקים חזותיים, כמו צורות של אור שיוצרות אפקט של הבהק עדשה, או טיפות גשם שמונפשות כשכבות מעל הסצנה שאתם מסתכלים עליה. במקרים אחרים, ציירנו משטחים שטוחים שנראים כאילו הם זזים, כמו שכבות של עננים נמוכים שזזים לפי קוד של מערכת חלקיקים. השברים שמסתובבים סביב הטורנדו הם שכבות בסצנה תלת-ממדית, שמוינו כך שהם ינועו לפני הטורנדו ומאחוריו.
הסיבה העיקרית לכך שהיינו צריכים לבנות את הסצנה בצורה הזו הייתה כדי לוודא שיש לנו מספיק GPU לטיפול בהצללת הטורנדו, באיזון עם האפקטים האחרים שהחלנו. בהתחלה היו לנו בעיות גדולות באיזון ה-GPU, אבל מאוחר יותר הסצנה הזו עברה אופטימיזציה והפכה לקלה יותר מהסצנות הראשיות.
מדריך: הצללה של סערה
כדי ליצור את רצף הסערה הסופי, שולבו טכניקות רבות ושונות, אבל החלק המרכזי של העבודה הזו היה הצללה מותאמת אישית של GLSL שנראית כמו טורנדו. ניסינו הרבה טכניקות שונות, החל מהצללות קודקודים (vertex shaders) כדי ליצור מערבולות גיאומטריות מעניינות, ועד לאנימציות מבוססות חלקיקים ואפילו אנימציות תלת-ממדיות של צורות גיאומטריות מעוותות. אף אחד מהאפקטים לא הצליח לשחזר את התחושה של טורנדו, או שהם דרשו יותר מדי עיבוד.
בסופו של דבר, פרויקט אחר לגמרי סיפק לנו את התשובה. פרויקט מקביל שכלל משחקים למטרות מדעיות למיפוי מוח של עכבר ממכון מקס פלאנק (brainflight.org) הניב אפקטים חזותיים מעניינים. הצלחנו ליצור סרטונים של החלק הפנימי של נוירון של עכבר באמצעות הצללה נפחית מותאמת אישית.
גילינו שהחלק הפנימי של תא מוח נראה קצת כמו משפך של טורנדו. ומכיוון שהשתמשנו בטכניקה נפחית, ידענו שנוכל לראות את ההצללה הזו מכל הכיוונים בחלל. אנחנו יכולים להגדיר את הרינדור של ה-shader כך שישתלב עם סצנת הסערה, במיוחד אם הוא נמצא בין שכבות של עננים ומעל רקע דרמטי.
טכניקת ההצללה כוללת טריק שבעצם משתמש בהצללת GLSL אחת כדי לעבד אובייקט שלם באמצעות אלגוריתם עיבוד פשוט שנקרא "עיבוד צעידת קרניים" (ray marching rendering) עם שדה מרחק. בשיטה הזו נוצר הצללת פיקסלים שמעריכה את המרחק הקרוב ביותר למשטח לכל נקודה במסך.
אפשר למצוא הסבר טוב על האלגוריתם בסקירה של iq: Rendering Worlds With Two Triangles - Iñigo Quilez. בנוסף, בגלריית ההצללות בכתובת glsl.heroku.com יש הרבה דוגמאות לטכניקה הזו שאפשר להתנסות בהן.
החלק המרכזי של ה-shader מתחיל בפונקציה הראשית, שמגדירה את הטרנספורמציות של המצלמה ונכנסת ללולאה שמעריכה שוב ושוב את המרחק למשטח. הקריאה לפונקציה 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 שתואם לרוחב ולגובה של הסצנה, כדי שנוכל להפריד בין הרזולוציה של ה-shader של הטורנדו לבין הסצנה. ואז אנחנו מחליטים על הפחתת הרזולוציה של הצללת הסערה באופן דינמי, בהתאם לקצב הפריימים שאנחנו מקבלים.
...
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 פשוט (כדי להימנע מהמראה המגושם) בשורה 1107 ב-stormTest.coffee. זה אומר שבמקרה הכי גרוע, הטורנדו יהיה מטושטש יותר, אבל לפחות הוא יפעל בלי לפגוע בשליטה של המשתמש.
השלב הבא באופטימיזציה דורש התעמקות באלגוריתם. הגורם החישובי העיקרי ב-shader הוא האיטרציה שמבוצעת בכל פיקסל כדי לנסות להעריך את המרחק של פונקציית פני השטח: מספר האיטרציות של לולאת ה-raymarching. אם נשתמש בגודל צעד גדול יותר, נוכל לקבל הערכה של פני השטח של הטורנדו עם פחות איטרציות כשאנחנו מחוץ לפני השטח המעוננים שלו. כשהיינו בפנים, הקטנו את גודל הצעד כדי לדייק וכדי שנוכל לערבב ערכים וליצור את אפקט הערפל. גם יצירת גליל תוחם כדי לקבל הערכת עומק לקרן המוטלת סיפקה האצה טובה.
החלק הבא של הבעיה היה לוודא שההצללה הזו תפעל בכרטיסי מסך שונים. בכל פעם ביצענו כמה בדיקות והתחלנו לפתח אינטואיציה לגבי סוג בעיות התאימות שבהן אנחנו עלולים להיתקל. הסיבה לכך שלא הצלחנו להגיע לתוצאות טובות יותר היא שלא תמיד הצלחנו לקבל מידע טוב על תוצאות ניפוי הבאגים של השגיאות. תרחיש אופייני הוא שגיאת GPU עם מעט מאוד מידע נוסף, או אפילו קריסה של המערכת.
לבעיות תאימות בין לוחות וידאו היו פתרונות דומים: לוודא שקבועים סטטיים מוזנים בסוג הנתונים המדויק כפי שהוגדר, למשל: 0.0 עבור float ו-0 עבור int. צריך להיזהר כשכותבים פונקציות ארוכות יותר; עדיף לפצל דברים למספר פונקציות פשוטות יותר ומשתני ביניים כי נראה שהקומפיילרים לא טיפלו במקרים מסוימים בצורה נכונה. חשוב לוודא שכל הטקסטורות הן בחזקה של 2, לא גדולות מדי, ובכל מקרה לנקוט "זהירות" כשמחפשים נתוני טקסטורה בלולאה.
הבעיות הכי גדולות שהיו לנו עם התאימות היו בגלל אפקט התאורה של הסערה. השתמשנו בטקסטורה מוכנה מראש שעטפה את הטורנדו כדי שנוכל לצבוע את השובלים שלו. זה היה אפקט מדהים, והיה קל לשלב את הטורנדו בצבעים של הסצנה, אבל לקח הרבה זמן לנסות להפעיל אותו בפלטפורמות אחרות.
האינטרנט לנייד
חוויית השימוש בנייד לא יכולה להיות תרגום ישיר של הגרסה למחשב, כי דרישות הטכנולוגיה והעיבוד פשוט כבדות מדי. היינו צריכים לבנות משהו חדש, שמטרגט משתמשים בנייד באופן ספציפי.
חשבנו שיהיה מגניב להפוך את תא הצילום של הקרנבל מהמחשב לאפליקציית אינטרנט לנייד, שתשתמש במצלמה של המשתמש. משהו שלא ראינו עד עכשיו.
כדי להוסיף קצת פלפל, תכנתנו טרנספורמציות תלת-ממדיות ב-CSS3. קישרנו את זה לגירוסקופ ולמד התאוצה, וכך הצלחנו להוסיף הרבה עומק לחוויה. האתר מגיב לאופן שבו אתם מחזיקים את הטלפון, מזיזים אותו ומסתכלים עליו.
כשכתבנו את המאמר הזה, חשבנו שכדאי לתת לכם כמה טיפים שיעזרו לכם להריץ את תהליך הפיתוח לנייד בצורה חלקה. הנה הם! כדאי לנסות ולראות מה אפשר ללמוד ממנו.
טיפים וטריקים לנייד
טעינה מראש היא פעולה נחוצה, ולא משהו שצריך להימנע ממנו. אנחנו יודעים שלפעמים זה קורה. הסיבה העיקרית לכך היא שצריך להמשיך לתחזק את רשימת הדברים שנטענים מראש ככל שהפרויקט גדל. בנוסף, לא ברור איך לחשב את התקדמות הטעינה אם אתם שולפים משאבים שונים, ורבים מהם בו-זמנית. כאן המחלקה המופשטת הכללית והמותאמת אישית שלנו, Task, יכולה לעזור. הרעיון העיקרי הוא לאפשר מבנה מקונן אינסופי שבו למשימה יכולות להיות משימות משנה משלה, שיכולות להיות להן וכו'… בנוסף, כל משימה מחשבת את ההתקדמות שלה ביחס להתקדמות של משימות המשנה שלה (אבל לא להתקדמות של ההורה). כדי שכל המשימות MainPreloadTask, AssetPreloadTask ו-TemplatePreFetchTask יתבססו על Task, יצרנו מבנה שנראה כך:
בזכות הגישה הזו והמחלקה 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 (דרך ההטמעה המשותפת של Task), כדאי גם לשים לב לאופן שבו אנחנו טוענים נכסים שתלויים בפלטפורמה. בעיקרון, יש לנו ארבעה סוגים של תמונות. תמונה רגילה לנייד (.ext, כאשר ext היא סיומת הקובץ, בדרך כלל .png או .jpg), תמונה לנייד עם מסך רטינה (-2x.ext), תמונה רגילה לטאבלט (-tab.ext) ותמונה לטאבלט עם מסך רטינה (-tab-2x.ext). במקום לבצע את הזיהוי ב-MainPreloadTask ולקודד באופן קשיח ארבעה מערכי נכסים, אנחנו פשוט מציינים את השם והסיומת של הנכס לטעינה מראש, ואם הנכס תלוי בפלטפורמה (responsive = true / false). לאחר מכן, 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 זה פשוט היה כיף. לכן הכנו גרסת הדגמה שתוכלו להתנסות בה.
אפשר לראות הדגמה בשידור חי כאן (צריך להפעיל אותה באייפון או בטלפון Android):
http://u9html5rocks.appspot.com/demos/mobile_photo_booth
כדי להגדיר את זה, צריך מכונה חינמית של אפליקציית Google App Engine שבה אפשר להריץ את הקצה העורפי. קוד החזית לא מורכב, אבל יש כמה דברים שצריך לשים לב אליהם. בואו נעבור עליהם עכשיו:
- סוג קובץ התמונה המותר
אנחנו רוצים שאנשים יוכלו להעלות רק תמונות (כי זה תא צילום, לא תא וידאו). תיאורטית, אפשר פשוט לציין את המסנן ב-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();
}
}
});
- ביטול של העלאה או של בחירת קובץ חוסר עקביות נוסף ששמנו לב אליו במהלך הפיתוח הוא האופן שבו מכשירים שונים מודיעים על ביטול של בחירת קובץ. טלפונים וטאבלטים עם 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 בקישור הזה.
זיכויים
כאן אפשר למצוא את רשימת הקרדיטים המלאה
קובצי עזר
- CoffeeScript – http://coffeescript.org/
- Backbone.js – http://backbonejs.org/
- Three.js – http://mrdoob.github.com/three.js/
- מכון מקס פלאנק (brainflight.org) – http://brainflight.org/