יצירת משחק AR באמצעות AR Foundation של Unity's

יצירת משחק AR באמצעות AR Foundation של Unity

מידע על Codelab זה

subjectהעדכון האחרון: יוני 25, 2021
account_circleנכתב על ידי Dereck Bridie

1.‏ סקירה כללית

ARCore היא ה-framework של Google ליצירת חוויות של מציאות רבודה בסמארטפונים. אפשר להשתמש ב-AR Foundation של Unity כדי ליצור אפליקציות AR בפלטפורמות שונות.

מה תפַתחו

ב-Codelab הזה בונים משחק פשוט באמצעות AR Foundation. המטרה של המשחק היא לאסוף חבילות באמצעות רכב שאתם שולטים בו באמצעות המכשיר הנייד.

עם זאת, הדבר לא יקרה בעולם וירטואלי לחלוטין! תשלבו אטומים פיזיים וביטלים דיגיטליים כדי ליצור סוג חדש של חוויית שחקן על ידי יצירת משחק שמבין את הסביבה סביב השחקן.

בסיום הקודלאב הזה, המשחק יוכל:

  • זיהוי מטוסים בעולם האמיתי וסימון שלהם בשטח המשחק.
  • מטילים קרניים מראיית המצלמה ומזהים צמתים עם מטוסים.
  • תגובה לתנאי התאורה בעולם האמיתי כדי להוסיף למשחק ריאליזם.

מה תלמדו

  • איך מגדירים פרויקט שמשתמש ב-AR Foundation של Unity.
  • איך משתמשים ב-ARPlaneManager כדי להירשם למטוסים חדשים.
  • איך להשתמש ב-Raycast כדי למצוא צמתים עם גיאומטריה וירטואלית
  • איך משתמשים ב-ARLightEstimationData כדי להאיר את הסצנה.

מה נדרש

2.‏ הגדרת סביבת הפיתוח

בשלב הזה, תכשירו את הסביבה לפיתוח באמצעות AR Foundation של Unity.

מוודאים שהמכשיר תואם ל-AR

חוויות AR במכשירי Android מבוססות על ARCore, שזמין במכשירים נתמכים ב-ARCore. צריך לוודא שמכשיר הפיתוח תואם ל-AR. לחלופין, אפשר להשתמש במופע Android Emulator שתואם ל-AR שהוגדר כראוי.

הגדרת ניפוי באגים ב-USB במכשיר

כדי להריץ אפליקציות לניפוי באגים, צריך להפעיל את האפשרויות למפתחים במכשיר. אם עוד לא עשיתם זאת, תוכלו לקרוא את מסמכי התיעוד של Android בנושא הפעלת אפשרויות למפתחים וניפוי באגים ב-USB.

התקנה של Unity (2020.3 LTS)

מתקינים את Unity 2020 LTS בתחנת העבודה. ב-Codelab הזה, צילומי מסך מוצגים של ממשק המשתמש של Unity בגרסת LTS (LTS)2020.3. יכול להיות שגירסאות אחרות של Unity יפעלו, אבל יכול להיות שיידרשו שלבים נוספים. יכול להיות שהממשק ייראה שונה מצילומי המסך שמוצגים כאן.

יצירת פרויקט חדש

יוצרים פרויקט חדש באמצעות התבנית Universal Render Pipeline. נותנים לו שם תיאורי ומיקום מתאים, ולוחצים על יצירה.

התקנה של המסגרות הנדרשות

ניתן למצוא את היסודות של AR של Unity ב-Unity Package Manager.

  1. כדי לפתוח אותו, לוחצים על חלון > Package Manager

  1. בחלון הזה, מתקינים את החבילות שבהן תשתמשו ב-codelab הזה. כדי להציג את הגרסאות העדכניות ביותר של המסגרות האלה, מרחיבים את הרשומה שלהן באמצעות הסמל . מתקינים את הגרסאות העדכניות של כל אחת מה-frameworks:
    • קרן AR
    • פלאגין ARCore XR

לאחר יצירת החבילות, מנהל החבילות אמור להיראות כך:

התקנה של חבילת ההתחלה

בשביל ה-Codelab הזה, סיפקנו חבילה למתחילים שכוללת ערכות הרצה וסקריפטים שיזרזות חלקים מסוימים ב-Codelab, כדי שתהיה לך אפשרות להתמקד בשימוש ב-AR Foundation.

  1. כדי להתקין את חבילת ההתחלה, פותחים את Assets > Import Package > Custom Package… (נכסים > ייבוא חבילה > חבילה מותאמת אישית…) ופותחים את starter-package.unitypackage.
  2. בחלון הקופץ, מוודאים שהכול מסומן.
  3. לוחצים על ייבוא.

שינוי הגדרות ה-build

מכיוון שהאפליקציה תפעל ב-Android, צריך לשנות את פלטפורמת ה-build ל-Android:

  1. פותחים את File > Build Settings (קובץ > הגדרות build).
  2. בחלונית Platform, בוחרים באפשרות Android.
  3. אפשר להפעיל את Development Build ואת Script Debugging כדי לשמור מידע על תוצאות ניפוי הבאגים בזמן שהאפליקציה פועלת.
  4. לוחצים על החלפת פלטפורמה.

שינוי הגדרות הפרויקט

צריך להגדיר את AR Foundation לאתחול מערכות XR במהלך ההפעלה.

  1. פותחים את הקטע עריכה > Project Settings... ולוחצים על הקטע XR Plug-in Management.
  2. בכרטיסייה Android, מפעילים את ARCore.

  1. בחלונית הימנית, לוחצים על הקטע נגן.
  2. בכרטיסייה Android, בקטע Other Settings (הגדרות אחרות), מסירים את Vulkan מ-Graphics APIs (ממשקי API גרפיים).

  1. אפליקציות עם תמיכה ב-AR שמשתמשות ב-ARCore צריכות להיות ברמת API 24 ומעלה. גוללים למטה ומוצאים את האפשרות Minimum API Level (רמת API מינימלית). מגדירים את רמת ה-API המינימלית ל-24.

הוספת רכיבי הסצנה הנדרשים

התבנית של Universal Render Pipeline כוללת כמה אובייקטים של משחקים שלא נשתמש בהם במדריך הזה.

  1. מחיקת כל האובייקטים של המשחק ב-SampleScene.

  1. הוספת אובייקטים של AR Foundation. לוחצים לחיצה ימנית בחלונית Hierarchy. בתפריט הזה אפשר להוסיף:
  • XR‏ > AR Session: האובייקט הזה קובע את מחזור החיים של חוויית AR.
  • XR > המקור לסשן ב-AR: האובייקט הזה משנה קואורדינטות AR לקואורדינטות בעולם של Unity.
  • בהיר > תאורה כיוונית: מקור אור להאירת אובייקטים במשחק.

ההיררכיה אמורה להיראות כך:

  1. מרחיבים את AR Session Origin שיצרתם בהיררכיה ובוחרים באובייקט AR Camera. בכלי הבדיקה, משנים את התג ל-MainCamera.

הגדרת הרינדור

נדרש שינוי אחד לצינור עיבוד הנתונים האוניברסלי של Unity כדי שיהיה תואם ל-AR Foundation.

  1. בחלונית Project, עוברים אל Assets > Settings כדי למצוא את הנכס ForwardRenderer.

  1. בוחרים באפשרות ForwardRenderer.
  2. בחלונית Inspector, משתמשים באפשרות Add Renderer Feature (הוספת תכונה של עיבוד תמונה) כדי להוסיף AR Background Renderer Feature (תכונה של עיבוד תמונה ברקע של AR). הרכיב הזה יציג את פיד המצלמה בסצנה.

אימות ההגדרה

  1. צריך לוודא שהמכשיר מחובר ושניפוי הבאגים של ADB מופעל.
  2. לוחצים על קובץ > בנייה והפעלה... הפעולה הזו תגרום להעלאת האפליקציה למכשיר ולהפעלה שלה אחרי ההתקנה.
  3. פיד המצלמה אמור להופיע במסך המכשיר.

בשלב הבא תתחיל להוסיף פונקציונליות לאפליקציה.

3.‏ זיהוי מטוסים בעולם האמיתי

עכשיו, אחרי שמסיימים להגדיר סצנה בסיסית, אפשר להתחיל לפתח את המשחק. בשלב הזה תזהו מטוסים ותציירו אותם לסצנה.

הוספת רכיב ARPlaneManager

ARPlaneManager מזהה ARPlane, יוצר, מעדכן ומסיר אובייקטים במשחק כשההבנה של המכשיר לגבי הסביבה משתנה.

  1. בחלונית Hierarchy (היררכיה), יוצרים GameObject ריק.
  2. יש לשנות את השם שלו לשם Driving Surface Manager. הרכיב הזה יציג מטוסים עד שהשחקן יבחר מטוס.
  3. בוחרים את אובייקט המשחק החדש. בחלונית 'מפקח', לוחצים על הוספת רכיב כדי להוסיף מנהל מישור AR.

  1. מגדירים את ARPlaneManager על ידי הגדרת השדה Plane Prefab:
    1. לוחצים על הלחצן לצד None כדי להציג את החלון Select GameObject.
    2. בוחרים בכרטיסייה נכסים ומחפשים את מטוס שטח נהיגה.

ה-prefab הזה מחבילת ההתחלה מספק טקסטורה של רצפה מחוספסת שתשמש לקישוט המטוס.

  1. משנים את Detection Mode לערך Horizontal. כך ARPlaneManager יוגדר לספק רק מישורים אופקיים, אידיאליים לנהיגה.

הוספת רכיב ARRaycastManager

ARRaycastManager חושפת את הפונקציונליות של הפצת קרניים. בשלב הבא נשתמש באובייקט הזה כדי לספק את אמצעי הבקרה למשתמש.

  1. מוודאים שהאובייקט שנקרא Driving Surface Manager מסומן בחלונית Hierarchy (היררכיה).
  2. בכלי הבדיקה, לוחצים על הוספת רכיב כדי להוסיף רכיב ARRaycastManager לאובייקט המשחק.

לא נדרשת הגדרה נוספת לרכיב הזה.

הוספת רכיב DrivingSurfaceManager

DrivingSurfaceManager הוא סקריפט עזר מחבילת ההתחלה שמאפשר לבחור ARPlane. אחרי שבוחרים ARPlane, כל המטוסים האחרים מוסתרים ומטוסים חדשים יושבתו.

  1. צריך לוודא שהאובייקט שנקרא Driving Surface Manager נבחר בחלונית ההיררכיה.
  2. בכלי הבדיקה, לוחצים על הוספת רכיב כדי להוסיף רכיב DrivingSurfaceManager לאובייקט המשחק.

לא נדרשת הגדרה נוספת לרכיב הזה.

הפעלת האפליקציה

  1. לוחצים על קובץ > בנייה והפעלה... כדי לבדוק את השינויים.
  2. מכוונים את המכשיר למשטח אופקי בעולם האמיתי ומזיזים את המכשיר כדי לשפר את היכולת של ARCore להבין את העולם.

  1. כש-ARCore מזהה מישור, אתה אמור לראות טקסטורת עפר שמכסה משטחים בעולם האמיתי. ה-ARPlaneManager מייצר את ה-Plane Prefab הנתון לכל מישור שזוהה. ל-prefab של Driving Surface Plane יש רכיב ARPlaneMeshVisualizer שיוצר רשת ל-ARPlane נתון.

בשלב הבא, תשתמשו במטוס שזוהה כמגרש משחקים.

4.‏ ביצוע בדיקת התנגשות (hit test) מול מטוסים שזוהו

בשלב הקודם, תכנתם אפליקציה שיכולה לזהות מטוסים. המטוסים האלה באים לידי ביטוי בסצנת המשחק שלכם. עכשיו אפשר להוסיף אינטראקטיביות למישורים האלה על ידי יצירת רשת מכוונת ומכונית שנוסעת על פני המטוס שזוהה.

יצירת כוונן

כדי לשלוט באפליקציה הזו, השחקן צריך להפנות את הטלפון למשטח. כדי לספק משוב חזותי ברור לגבי המיקום המיועד, משתמשים ברשת המטרה.

כדי "להדביק" את כוורת הראייה הזו למשטח AR, משתמשים בבדיקת התאמה. בדיקת היטים היא טכניקה שמחשבת צמתים כששולחים קרן בכיוון נתון. תשתמשו בבדיקת התנגשות כדי לזהות צומת בכיוון של שדה הראייה של המצלמה.

הוספת רשת ליישור

  1. בחלונית פרויקט בתחתית המסך, עוברים אל נכסים > חבילה למתחילים.
  2. כדי להציב את Reticle Prefab בסצנה, גוררים אותו אל חלונית היררכיית הפרויקט.
  3. בוחרים את הרשת בהיררכיה.
  4. בחלונית הניפוי, לוחצים על Add Component (הוספת רכיב). מוסיפים את הסקריפט ReticleBehaviour מחבילת ההתחלה. הסקריפט הזה מכיל תבניות סטנדרטיות לשליטה על הרשת.
  5. הסקריפט ReticleBehaviour תלוי ב-Driving Surface Manager שיצרתם לפני כן, לכן יש להוסיף את התלות על ידי לחיצה על הבורר של Driving Surface Manager. בוחרים בכרטיסייה Scene ובוחרים באפשרות Driving Surface Manager.

עורכים את ReticleBehaviour

הסקריפט ReticleBehavior ימקם את הרשת במישור שנמצא במרכז אזור התצוגה של המכשיר.

  1. פותחים את הסקריפט ReticleBehaviour.cs בלחיצה כפולה על השדה Script.
  2. מאתרים את מרכז המסך באמצעות ViewToScreenPoint של המצלמה. עורכים את השיטה Update() כדי להוסיף את הפרטים הבאים:
var screenCenter = Camera.main.ViewportToScreenPoint(new Vector3(0.5f, 0.5f));
  1. משתמשים בנקודה הזו כדי לבצע קרני שמש. מוסיפים את הפרטים הבאים:
var hits = new List<ARRaycastHit>();
DrivingSurfaceManager.RaycastManager.Raycast(screenCenter, hits, TrackableType.PlaneWithinBounds);

המשתנה hits יכלול ערכים של ARRaycastHit שמתארים נקודות על אובייקטים שניתנים למעקב, שחתוכים על ידי ray.

  1. כדי לקבוע את נקודת הצטלבות האינטרסים, שולחים שאילתה לרשימת hits. נותנים עדיפות למטוס הנעול שמופיע ב-DrivingSurfaceManager, ואם הוא לא קיים, משתמשים במטוס הראשון שנמצא. צריך להוסיף את הטקסט הבא בסוף Update():
CurrentPlane = null;
ARRaycastHit? hit = null;
if (hits.Length > 0)
{
    // If you don't have a locked plane already...
    var lockedPlane = DrivingSurfaceManager.LockedPlane;
    hit = lockedPlane == null
        // ... use the first hit in `hits`.
        ? hits[0]
        // Otherwise use the locked plane, if it's there.
        : hits.SingleOrDefault(x => x.trackableId == lockedPlane.trackableId);
}
  1. אם hit מכיל תוצאה, מעבירים את הטרנספורמציה של GameObject הזה למיקום ההיט.
if (hit.HasValue)
{
    CurrentPlane = DrivingSurfaceManager.PlaneManager.GetPlane(hit.Value.trackableId);
    // Move this reticle to the location of the hit.
    transform.position = hit.Value.pose.position;
}
Child.SetActive(CurrentPlane != null);

בדיקת הרשת

  1. לוחצים על File (קובץ) > Build And Run (יצירה והרצה)… כדי לבדוק את השינויים.
  2. כשמכוונים את המכשיר למטוס, הרשת אמורה לעקוב אחרי תנועות המצלמה.

יצירת רכב

השחקן ישלוט ברכב צעצוע שייסע לכיוון המיקום של כוורת הראייה. מודל והתנהגות של המכונית הזו זמינים בחבילת ההתחלה.

הוספת CarManager לסצנה

  1. בקטע Hierarchy, יוצרים GameObject ריק חדש.
  2. משנים את השם שלו ל-Car Spawner.
  3. בוחרים את האובייקט שיצרתם. בחלונית Hierarchy, לוחצים על Add Component כדי להוסיף את הרכיב CarManager.
  4. מגדירים את יחסי התלות של CarManager על ידי לחיצה על הבורר בכל שדה:
    • טמפ' לרכב: בקטע נכסים, בוחרים באפשרות טרום רכב.
    • Reticle: בקטע Scene, בוחרים באפשרות Reticle Prefab.
    • מנהל משטח הנסיעה: בקטע סצנה, בוחרים באפשרות מנהל משטח הנסיעה.

ההתנהגות הזו של CarManager גורמת למכונית צעצוע במטוס שבו נמצא הרשת. אפשר לעיין בסקריפט CarBehaviour כדי ללמוד איך המכונית מתוכנתת.

נהיגת מבחן

  1. לוחצים על קובץ > בנייה והפעלה כדי לבדוק את השינויים.
  2. כשמקישים על מטוס, אמורה להופיע מכונית קטנה במיקום הזה. המכונית הזו תנוע אחרי כוורת הראייה.

הוספת רכיב המשחק

עכשיו השחקן יכול לשלוט בישות כלשהי בסצנה, צריך לתת לו יעד נסיעה.

  1. צריך ליצור GameObject ריק חדש בהיררכיה.
  2. משנים את השם שלו ל-Package Spawner.
  3. בוחרים את האובייקט שיצרתם. בחלונית Hierarchy, לוחצים על Add Component כדי להוסיף אליה את הרכיב PackageSpawner.
  4. מגדירים את יחסי התלות של PackageSpawner על ידי לחיצה על הבורר בכל שדה:
    • טרום חבילה: בקטע נכסים, בוחרים באפשרות טרום חבילה.
    • מנהל משטח הנסיעה בקטע סצנה, בוחרים באפשרות מנהל משטח הנסיעה.

ההתנהגות הזו של PackageSpawner גורמת ליצירת חבילה חדשה במיקום אקראי ב-ARPlane נעול, אם עדיין אין חבילה.

בדיקה של המשחק

  1. לוחצים על קובץ > בנייה והפעלה כדי לבדוק את השינויים. 2. אחרי שיוצרים מכונית, אמורה להגיע חבילה.
  2. נוסעים ברכב אל החבילה.
  3. תופיע הודעה חדשה במיקום אקראי.

5.‏ הגדרת התכונה &#39;הערכת תאורה&#39;

עכשיו, אחרי שהשלמתם את המשחק הבסיסי, תוכלו להוסיף קצת ריאליזם לסצנה של ה-AR. בשלב הזה, תשתמשו ב-Lighting Estimation API של ARCore כדי לזהות את התאורה הקיימת בעולם האמיתי על סמך הפריימים הנכנסים מהמצלמה. המידע הזה ישמש כדי להתאים את התאורה בסצנה כך שתתאים לתאורה בעולם האמיתי.

הפעלת אומדן התאורה

  1. בקטע היררכיה, מרחיבים את AR Session Origin ובוחרים את האובייקט AR Camera.
  2. בחלונית Inspector, מרחיבים את הסקריפט AR Camera Manager.
  3. משנים את השדה Lighting Estimation (הערכת התאורה) להכול.

שינוי של תאורת הכיוון

  1. בקטע Hierarchy, בוחרים באובייקט Directional Light.
  2. מוסיפים אליו את הרכיב LightEstimation. הרכיב הזה מחבילת התחלה מספק קוד לדוגמה להרשמה לשינויים בתאורה.
  3. בפונקציה FrameReceived(), מוסיפים:
ARLightEstimationData lightEstimation = args.lightEstimation;

if (lightEstimation.averageBrightness.HasValue)
    Light.intensity = lightEstimation.averageBrightness.Value;

if (lightEstimation.averageColorTemperature.HasValue)
    Light.colorTemperature = lightEstimation.averageColorTemperature.Value;

if (lightEstimation.colorCorrection.HasValue)
    Light.color = lightEstimation.colorCorrection.Value;

if (lightEstimation.mainLightDirection.HasValue)
    Light.transform.rotation = Quaternion.LookRotation(lightEstimation.mainLightDirection.Value);

if (lightEstimation.mainLightColor.HasValue)
    Light.color = lightEstimation.mainLightColor.Value;

if (lightEstimation.mainLightIntensityLumens.HasValue)
    Light.intensity = lightEstimation.averageMainLightBrightness.Value;

if (lightEstimation.ambientSphericalHarmonics.HasValue)
{
    RenderSettings.ambientMode = AmbientMode.Skybox;
    RenderSettings.ambientProbe = lightEstimation.ambientSphericalHarmonics.Value;
}

בדיקת השינויים

  1. לוחצים על קובץ > בנייה והפעלה כדי לבדוק את השינויים.
  2. כשאתם מביטים באובייקטים בסצנה, יכול להיות שתבחינו שהם צבעוניים בהתאם לתאורה בסביבה.
  3. אם אפשר, כדאי לנסות לשנות את התאורה. לדוגמה, אפשר לנסות לכבות את האורות בחדר שבו אתם נמצאים. אתם אמורים לראות שהתאורה על האובייקטים מותאמת לשינוי בתאורה בעולם האמיתי.

6.‏ סיכום

מזל טוב! הגעת לסוף שיעור ה-Codelab הזה ב-Unity AR Foundation.

מה נכלל

  • איך מגדירים פרויקט בסיסי באמצעות AR Foundation של Unity וצינור עיבוד הנתונים האוניברסלי.
  • איך משתמשים ב-ARPlaneManager כדי להירשם למטוסים חדשים.
  • איך להשתמש ב-Raycast כדי למצוא צמתים עם גיאומטריה וירטואלית.
  • איך להשתמש ב-ARLightEstimationData כדי להאיר את הסצנה.

השלבים הבאים

מטלות בונוס

אם היית רוצה להרחיב את הפעילות במשחק שיצרת כאן, אפשר לנסות את הרעיונות הבאים:

  • מוסיפים מונה למשחק על ידי שינוי של השדה TextMeshPro כאשר PackageManager יוצרת חבילה חדשה.
  • כדי לבדוק את נתוני הביצועים כשהמשחק פועל, מפעילים את שכבת-העל של הביצועים.
  • אפשר להשתמש ב-Resistent Raycasts כדי למקם אובייקטים חדשים בסצנה הראשונה. כשהמערכת תזהה מטוס באזור הזה, האובייקט יתעדכן ויוצמד למטוס.