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

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

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

מה תפַתחו

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

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

בסוף ה-Codelab הזה, המשחק שלך יוכל:

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

מה תלמדו

  • איך מגדירים פרויקט שמשתמש ב-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. נותנים לקובץ שם תיאורי ומיקום מתאים ולוחצים על יצירה.

התקנת ה-frameworks הנדרשות

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

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

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

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

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

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

  2. כדי להתקין את החבילה לתחילת הפעולה, פותחים את הקטע נכסים > ייבוא חבילה > חבילה מותאמת אישית... ופתיחה של starter-package.unitypackage.
  3. בחלון הקופץ, מוודאים שהכול מסומן.
  4. לוחצים על ייבוא.

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

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

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

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

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

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

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

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

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

תבנית צינור עיבוד הנתונים האוניברסלית לעיבוד נתונים (Universal Render Pipeline) מגיעה עם כמה אובייקטים של משחקים שלא תשתמשו בהם במדריך הזה.

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

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

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

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

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

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

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

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

אימות ההגדרה

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

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

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

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

הוספת רכיב ARPlaneManager

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

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

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

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

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

הוספת רכיב ARRaycastManager

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

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

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

הוספת רכיב DrivingSurfaceManager

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

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

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

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

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

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

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

4. ביצוע בדיקת פגיעה במטוסים שזוהו

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

צור רשת מכוונת

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

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

הוספת הרשת

  1. בחלונית פרויקט בתחתית המסך, עוברים אל נכסים > חבילה למתחילים.
  2. כדי להוסיף את Reticle Prefab לסצנה, גוררים אותו לחלונית ההיררכיה של הפרויקט.
  3. בוחרים את הרשת בהיררכיה.
  4. בכלי הבדיקה, לוחצים על הוספת רכיב. מוסיפים את הסקריפט ReticleBehaviour מחבילת ההתחלה. הסקריפט הזה מכיל תבניות סטנדרטיות לשליטה על הרשת.
  5. הסקריפט ReticleBehaviour תלוי ב-Driving Surface Manager שיצרת לפני כן, לכן יש להוסיף את התלות על ידי לחיצה על הבורר של Driving Surface Manager. לוחצים על הכרטיסייה סצנה ואז על 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. לוחצים על קובץ > בנייה והפעלה... כדי לבדוק את השינויים.
  2. כשמכוונים את המכשיר למטוס, הרשת אמורה לעקוב אחרי תנועות המצלמה.

יצירת מכונית

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

הוספת CarManager לסצנה

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

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

נהיגת מבחן

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

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

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

  1. צריך ליצור GameObject ריק חדש בהיררכיה.
  2. יש לשנות את השם שלו לשם Package Spawner.
  3. בוחרים את האובייקט שיצרתם. בחלונית היררכיה, לוחצים על הוספת רכיב כדי להוסיף אליו את הרכיב PackageSpawner.
  4. מגדירים את יחסי התלות של PackageSpawner על ידי לחיצה על הבורר בכל שדה:
    • טרום חבילה: בקטע נכסים, בוחרים באפשרות טרום חבילה.
    • drive-Surface Manager (ניהול משטח נהיגה) בScene (תרחיש), בוחרים באפשרות Travel Surface Manager (מנהל שטח נסיעה).

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

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

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

5. הגדרה של הערכת התאורה

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

הפעלה של הערכת התאורה

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

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

  1. בהיררכיה, בוחרים באובייקט 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 כדי למקם אובייקטים חדשים בסצנה הראשונה. כשיזוהה מטוס באזור הזה, העצם יתעדכן כדי להצמיד אותו למישור הזה.