Unity' के एआर फ़ाउंडेशन का इस्तेमाल करके एआर गेम बनाएं

1. खास जानकारी

ARCore, Google का एक फ़्रेमवर्क है. इसकी मदद से, स्मार्टफ़ोन पर ऑगमेंटेड रिएलिटी (एआर) के अनुभव बनाए जाते हैं. क्रॉस-प्लैटफ़ॉर्म एआर ऐप्लिकेशन बनाने के लिए, Unity के AR Foundation का इस्तेमाल किया जा सकता है.

आपको क्या बनाना है

इस कोडलैब में, AR Foundation का इस्तेमाल करके एक सामान्य गेम बनाया जाएगा. इस गेम का मकसद, कार का इस्तेमाल करके पैकेज इकट्ठा करना है. कार को हैंडहेल्ड डिवाइस से कंट्रोल किया जाता है.

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

इस कोडलैब के आखिर तक, आपका गेम ये काम कर पाएगा:

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

आपको क्या सीखने को मिलेगा

  • Unity के AR Foundation का इस्तेमाल करने वाले प्रोजेक्ट को सेट अप करने का तरीका.
  • नए प्लान की सदस्यता लेने के लिए, ARPlaneManager का इस्तेमाल कैसे करें.
  • वर्चुअल ज्यामिति के साथ इंटरसेक्शन ढूंढने के लिए, Raycast का इस्तेमाल कैसे करें
  • अपने सीन में रोशनी करने के लिए, ARLightEstimationData का इस्तेमाल करने का तरीका.

आपको किन चीज़ों की ज़रूरत होगी

2. डेवलपमेंट एनवायरमेंट सेट अप करना

इस चरण में, आपको Unity के AR Foundation के साथ डेवलपमेंट के लिए अपना एनवायरमेंट तैयार करना होगा.

पक्का करें कि आपका डिवाइस एआर की सुविधा के साथ काम करता हो

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

अपने डिवाइस पर यूएसबी डीबगिंग सेट अप करना

डीबग ऐप्लिकेशन चलाने के लिए, आपको अपने डिवाइस पर डेवलपर के लिए सेटिंग और टूल चालू करने होंगे. अगर आपने अब तक ऐसा नहीं किया है, तो डेवलपर के विकल्प और यूएसबी डीबगिंग चालू करने के बारे में Android का दस्तावेज़ पढ़ें.

Unity (2020.3 LTS) इंस्टॉल करना

अपने वर्कस्टेशन पर, Unity 2020 LTS इंस्टॉल करें. इस कोडलैब में, Unity के यूज़र इंटरफ़ेस (यूआई) के स्क्रीनशॉट दिखाए गए हैं. ये स्क्रीनशॉट, 2020.3 (एलटीएस) वर्शन के हैं. Unity के अन्य वर्शन भी काम कर सकते हैं. हालांकि, इसके लिए आपको कुछ और चरण पूरे करने पड़ सकते हैं. यह यहां दिखाए गए स्क्रीनशॉट से अलग दिख सकता है.

नया प्रोजेक्ट बनाएं

यूनिवर्सल रेंडर पाइपलाइन टेंप्लेट का इस्तेमाल करके, एक नया प्रोजेक्ट बनाएं. इसे ऐसा नाम दें जिससे यह आसानी से पहचाना जा सके. साथ ही, इसे सही जगह पर सेव करें. इसके बाद, बनाएं पर क्लिक करें.

ज़रूरी फ़्रेमवर्क इंस्टॉल करना

Unity Package Manager में, Unity का AR Foundation उपलब्ध है.

  1. इसे खोलने के लिए, Window > Package Manager पर क्लिक करें.

  1. इस विंडो में, उन पैकेज को इंस्टॉल करें जिनका इस्तेमाल आपको इस कोडलैब में करना है. ► आइकॉन का इस्तेमाल करके, इन फ़्रेमवर्क की एंट्री को बड़ा करें और इनके नए वर्शन देखें. इन फ़्रेमवर्क के नए वर्शन इंस्टॉल करें:
    • AR Foundation
    • ARCore XR प्लगिन

बदलाव करने के बाद, आपका पैकेज मैनेजर कुछ ऐसा दिखना चाहिए:

स्टार्टर पैकेज इंस्टॉल करना

इस कोडलैब के लिए, हमने एक स्टार्टर पैकेज उपलब्ध कराया है. इसमें प्रीफ़ैब और स्क्रिप्ट शामिल हैं. इससे कोडलैब के कुछ हिस्सों को तेज़ी से पूरा करने में मदद मिलेगी, ताकि आप AR Foundation के इस्तेमाल पर फ़ोकस कर सकें.

  2. स्टार्टर पैकेज इंस्टॉल करने के लिए, ऐसेट > पैकेज इंपोर्ट करें > कस्टम पैकेज... खोलें और starter-package.unitypackage खोलें.
  3. पॉप-अप विंडो में, पक्का करें कि सभी आइटम चुने गए हों.
  4. इंपोर्ट करें पर क्लिक करें.

बिल्ड सेटिंग बदलना

ऐप्लिकेशन Android पर चलेगा. इसलिए, बिल्ड प्लैटफ़ॉर्म को Android पर बदलें:

  1. फ़ाइल > बिल्ड सेटिंग खोलें.
  2. प्लैटफ़ॉर्म पैनल में, Android चुनें.
  3. अगर आपको ऐप्लिकेशन के चलने के दौरान डीबग करने से जुड़ी जानकारी सेव रखनी है, तो डेवलपमेंट बिल्ड और स्क्रिप्ट डीबग करना को चालू करें. हालांकि, ऐसा करना ज़रूरी नहीं है.
  4. Switch Platform पर क्लिक करें.

प्रोजेक्ट की सेटिंग बदलना

स्टार्टअप पर XR सिस्टम को शुरू करने के लिए, AR Foundation को कॉन्फ़िगर करना ज़रूरी है.

  1. Edit > Project Settings... खोलें और XR Plug-in Management सेक्शन पर क्लिक करें.
  2. Android टैब में जाकर, ARCore को चालू करें.

  1. बाईं ओर मौजूद पैनल में, खिलाड़ी सेक्शन पर क्लिक करें.
  2. Android टैब में, अन्य सेटिंग में जाकर, ग्राफ़िक्स एपीआई से Vulkan को हटाएं.

  1. ARCore का इस्तेमाल करने वाले 'एआर की सुविधा ज़रूरी है' ऐप्लिकेशन के लिए, कम से कम एपीआई लेवल 24 होना ज़रूरी है. नीचे की ओर स्क्रोल करें और कम से कम एपीआई लेवल ढूंढें. कम से कम एपीआई लेवल को 24 पर सेट करें.

ज़रूरी सीन एलिमेंट जोड़ना

Universal Render Pipeline टेंप्लेट में कुछ ऐसे गेम ऑब्जेक्ट शामिल होते हैं जिनका इस्तेमाल इस ट्यूटोरियल में नहीं किया जाएगा.

  1. SampleScene में मौजूद सभी गेम ऑब्जेक्ट मिटाता है.

  1. AR Foundation ऑब्जेक्ट जोड़ें. क्रम वाले पैनल में राइट क्लिक करें. इस मेन्यू का इस्तेमाल करके ये चीज़ें जोड़ी जा सकती हैं:
  • XR > AR सेशन: यह ऑब्जेक्ट, एआर सेशन के लाइफ़साइकल को कंट्रोल करता है.
  • XR > AR Session Origin: यह ऑब्जेक्ट, एआर कोऑर्डिनेट को Unity वर्ल्ड कोऑर्डिनेट में बदलता है.
  • लाइट > डायरेक्शनल लाइट: इससे गेम ऑब्जेक्ट को रोशनी मिलती है.

आपकी क्रम-व्यवस्था ऐसी दिखनी चाहिए:

  1. आपने हाइरार्की में जो AR सेशन ओरिजिन बनाया है उसे बड़ा करें. इसके बाद, AR कैमरा ऑब्जेक्ट चुनें. Inspector में, इसके टैग को MainCamera में बदलें.

रेंडरिंग सेट अप करना

AR Foundation के साथ काम करने के लिए, Unity के यूनिवर्सल रेंडर पाइपलाइन में एक बदलाव करना ज़रूरी है.

  1. प्रोजेक्ट पैनल में, ऐसेट > सेटिंग पर जाकर ForwardRenderer ऐसेट ढूंढें.

  1. ForwardRenderer को चुनें.
  2. AR Background Renderer Feature जोड़ने के लिए, इंस्पेक्टर पैन में Add Renderer Feature का इस्तेमाल करें. यह कॉम्पोनेंट, आपके सीन में कैमरे का फ़ीड रेंडर करेगा.

सेटअप की पुष्टि करना

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

अगले चरण में, आपको अपने ऐप्लिकेशन में सुविधाएं जोड़ने का विकल्प मिलेगा.

3. असली दुनिया में मौजूद हवाई जहाज़ों का पता लगाना

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

ARPlaneManager कॉम्पोनेंट जोड़ना

ARPlaneManager, ARPlane का पता लगाता है. साथ ही, डिवाइस के एनवायरमेंट को समझने के तरीके में बदलाव होने पर, गेम ऑब्जेक्ट बनाता है, उन्हें अपडेट करता है, और उन्हें हटाता है.

  1. हायरार्की पैन का इस्तेमाल करके, एक खाली GameObject बनाएं.
  2. इसका नाम बदलकर Driving Surface Manager कर दो. यह कॉम्पोनेंट, तब तक विमानों को दिखाएगा, जब तक कि प्लेयर किसी एक को नहीं चुन लेता.
  3. नया गेम ऑब्जेक्ट चुनें. AR Plane Manager जोड़ने के लिए, Inspector पैनल में जाकर Add Component पर क्लिक करें.

  1. ARPlaneManager फ़ील्ड सेट करके, ARPlaneManager को कॉन्फ़िगर करें:
      Plane Prefab
    1. Select GameObject विंडो खोलने के लिए, None के बगल में मौजूद बटन पर क्लिक करें.
    2. ऐसेट टैब को चुनें और ड्राइविंग सर्फ़ेस प्लेन खोजें.

स्टार्टर पैकेज का यह प्रीफ़ैब, फ़्लोर का खुरदरा टेक्सचर देता है. इसका इस्तेमाल, प्लेन को सजाने के लिए किया जाएगा.

  1. Detection Mode को Horizontal में बदलें. इससे ARPlaneManager को सिर्फ़ हॉरिज़ॉन्टल प्लेन दिखाने के लिए कॉन्फ़िगर किया जाता है. ये प्लेन, ड्राइविंग के लिए सबसे सही होते हैं.

ARRaycastManager कॉम्पोनेंट जोड़ना

ARRaycastManager, रेकास्ट की सुविधा उपलब्ध कराता है. अगले चरण में, हम इस ऑब्जेक्ट का इस्तेमाल करके उपयोगकर्ता के लिए कंट्रोल उपलब्ध कराएंगे.

  1. पक्का करें कि हैरारकी पैनल में, Driving Surface Manager नाम का ऑब्जेक्ट चुना गया हो.
  2. अपने गेम ऑब्जेक्ट में ARRaycastManager कॉम्पोनेंट जोड़ने के लिए, इंस्पेक्टर में Add Component पर क्लिक करें.

इस कॉम्पोनेंट के लिए, किसी और कॉन्फ़िगरेशन की ज़रूरत नहीं है.

DrivingSurfaceManager कॉम्पोनेंट जोड़ना

DrivingSurfaceManager, स्टार्टर पैकेज की एक हेल्पर स्क्रिप्ट है. इसकी मदद से, ARPlane को चुना जा सकता है. ARPlane चुनने के बाद, अन्य सभी प्लेन छिप जाएंगे और नए प्लेन बंद हो जाएंगे.

  1. पक्का करें कि हैरारकी पैनल में, Driving Surface Manager नाम का ऑब्जेक्ट चुना गया हो.
  2. अपने गेम ऑब्जेक्ट में DrivingSurfaceManager कॉम्पोनेंट जोड़ने के लिए, इंस्पेक्टर में Add Component पर क्लिक करें.

इस कॉम्पोनेंट के लिए, किसी और कॉन्फ़िगरेशन की ज़रूरत नहीं है.

ऐप्लिकेशन चलाएं

  1. बदलावों की जांच करने के लिए, फ़ाइल > बनाएं और चलाएं... पर क्लिक करें.
  2. अपने डिवाइस को असल दुनिया की किसी हॉरिज़ॉन्टल सतह पर रखें. इसके बाद, डिवाइस को चारों ओर घुमाएं, ताकि ARCore को दुनिया के बारे में बेहतर तरीके से पता चल सके.

  1. जब ARCore किसी प्लेन का पता लगा लेता है, तब आपको असल दुनिया की सतहों पर मिट्टी का टेक्सचर दिखेगा. ARPlaneManager, पहचाने गए हर प्लेन के लिए दिए गए Plane Prefab को इंस्टैंशिएट करता है. Driving Surface Plane प्रीफ़ैब में एक ARPlaneMeshVisualizer कॉम्पोनेंट होता है. यह दिए गए ARPlane के लिए एक मेश बनाता है.

अगले चरण में, आपको पहचाने गए प्लेन को प्लेइंग फ़ील्ड के तौर पर इस्तेमाल करना होगा.

4. पहचाने गए हवाई जहाज़ों के ख़िलाफ़ हिट टेस्ट करना

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

निशाना लगाने वाला रेटिकल बनाना

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

इस रेटिकल को एआर प्लेन पर "चिपकाने" के लिए, हिट टेस्ट का इस्तेमाल करें. हिट टेस्ट एक ऐसी तकनीक है जो किसी दी गई दिशा में रे कास्ट करते समय इंटरसेक्शन का हिसाब लगाती है. कैमरे के व्यू की दिशा में किसी इंटरसेक्शन का पता लगाने के लिए, हिट टेस्ट का इस्तेमाल करें.

रेटिकल जोड़ना

  1. स्क्रीन पर सबसे नीचे मौजूद, प्रोजेक्ट पैन में, ऐसेट > स्टार्टर पैकेज पर जाएं.
  2. Reticle Prefab को सीन में रखने के लिए, उसे प्रोजेक्ट के Hierarchy pane में खींचें और छोड़ें.
  3. क्रम में मौजूद रेटिकल को चुनें.
  4. इंस्पेक्टर में, Add Component पर क्लिक करें. स्टार्टर पैकेज से ReticleBehaviour स्क्रिप्ट जोड़ें. इस स्क्रिप्ट में, रेटिकल को कंट्रोल करने के लिए कुछ बॉयलरप्लेट शामिल हैं.
  5. ReticleBehaviour स्क्रिप्ट, पहले से बनाई गई Driving Surface Manager पर निर्भर करती है. इसलिए, Driving Surface Manager चुनने वाले टूल पर क्लिक करके, निर्भरता जोड़ें. सीन टैब को चुनें. इसके बाद, Driving Surface Manager को चुनें.

ReticleBehaviour में बदलाव करना

ReticleBehavior स्क्रिप्ट, रेटिकल को डिवाइस के व्यूपोर्ट के बीच में मौजूद प्लैन पर रखेगी.

  1. Script फ़ील्ड पर दो बार क्लिक करके, ReticleBehaviour.cs स्क्रिप्ट खोलें.
  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. अपने डिवाइस को किसी हवाई जहाज़ की ओर पॉइंट करने पर, आपको दिखेगा कि रेटिकल, कैमरे की गतिविधियों को फ़ॉलो कर रहा है.

कार बनाएं

खिलाड़ी एक खिलौना कार को कंट्रोल करेगा, जो रेटिकल की जगह की ओर जाएगी. इस कार के मॉडल और इसके व्यवहार के बारे में जानकारी, स्टार्टर पैकेज में दी गई है.

अपने सीन में CarManager जोड़ना

  1. Hierarchy में, एक नया खाली GameObject बनाएं.
  2. इसका नाम बदलकर Car Spawner कर दो.
  3. आपने जो ऑब्जेक्ट बनाया है उसे चुनें. CarManager कॉम्पोनेंट जोड़ने के लिए, हायरार्की पैनल में, कॉम्पोनेंट जोड़ें पर क्लिक करें.
  4. हर फ़ील्ड के लिए, चुनने वाले टूल पर क्लिक करके CarManager की डिपेंडेंसी सेट अप करें:
    • कार प्रीफ़ैब: ऐसेट में जाकर, कार प्रीफ़ैब चुनें.
    • रेटिकल: सीन में जाकर, रेटिकल प्रीफ़ैब चुनें.
    • ड्राइविंग सर्फ़ेस मैनेजर: सीन में जाकर, ड्राइविंग सर्फ़ेस मैनेजर को चुनें.

इस CarManager के इस्तेमाल से, उस प्लेन पर एक खिलौना कार बन जाती है जिस पर रेटिकल मौजूद होता है. अगर आपको दिलचस्पी है, तो कार को प्रोग्राम करने का तरीका जानने के लिए CarBehaviour स्क्रिप्ट देखें.

टेस्ट ड्राइविंग

  1. किए गए बदलावों को आज़माने के लिए, फ़ाइल > बनाएं और चलाएं पर क्लिक करें.
  2. किसी हवाई जहाज़ पर टैप करने पर, आपको उस जगह पर एक छोटी कार दिखनी चाहिए. यह कार, रेटिकल को फ़ॉलो करेगी.

गेम एलिमेंट जोड़ना

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

  1. हायरार्की में एक नया खाली GameObject बनाएं.
  2. इसका नाम बदलकर Package Spawner कर दो.
  3. आपने जो ऑब्जेक्ट बनाया है उसे चुनें. हायरार्की पैनल में, PackageSpawner कॉम्पोनेंट जोड़ने के लिए, कॉम्पोनेंट जोड़ें पर क्लिक करें.
  4. हर फ़ील्ड के लिए, चुनने वाले टूल पर क्लिक करके PackageSpawner की डिपेंडेंसी सेट अप करें:
    • Package Prefab: Assets में जाकर, Package Prefab चुनें.
    • ड्राइविंग सर्फ़ेस मैनेजर सीन में जाकर, ड्राइविंग सर्फ़ेस मैनेजर को चुनें.

अगर कोई पैकेज पहले से मौजूद नहीं है, तो इस PackageSpawner के ज़रिए, लॉक किए गए ARPlane पर किसी भी जगह एक नया पैकेज बनाया जाता है.

गेम को टेस्ट करना

  1. किए गए बदलावों को आज़माने के लिए, फ़ाइल > बनाएं और चलाएं पर क्लिक करें. 2, कार बनाने के बाद, एक पैकेज दिखना चाहिए.
  2. अपनी कार को पैकेज की जगह पर ले जाएं.
  3. इसके बाद, आपको एक नया बटन किसी भी जगह पर दिखेगा.

5. रोशनी का अनुमान लगाने की सुविधा सेट अप करना

अब जब बुनियादी गेम पूरा हो गया है, तो अपने एआर सीन को और ज़्यादा असल जैसा बनाएं. इस चरण में, ARCore के Lighting Estimation API का इस्तेमाल करके, कैमरे से मिले फ़्रेम के आधार पर, आस-पास की रोशनी का पता लगाया जाएगा. इस जानकारी का इस्तेमाल, आपके सीन की लाइटिंग को असल दुनिया की लाइटिंग से मैच करने के लिए किया जाएगा.

लाइटिंग का अनुमान लगाने की सुविधा चालू करना

  1. Hierarchy में जाकर, AR Session Origin को बड़ा करें और AR Camera ऑब्जेक्ट को चुनें.
  2. Inspector में, AR Camera Manager स्क्रिप्ट को बड़ा करें.
  3. लाइटिंग का अनुमान फ़ील्ड को सब कुछ पर सेट करें.

डायरेक्शनल लाइट में बदलाव करना

  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. आखिर में खास जानकारी

बधाई हो! आपने Unity AR Foundation के इस कोडलैब को पूरा कर लिया है.

आपने क्या-क्या कवर किया है

  • Unity के AR Foundation और Universal Rendering Pipeline का इस्तेमाल करके, बुनियादी प्रोजेक्ट सेट अप करने का तरीका.
  • नए प्लान की सदस्यता लेने के लिए, ARPlaneManager का इस्तेमाल कैसे करें.
  • वर्चुअल ज्यामिति के साथ इंटरसेक्शन ढूंढने के लिए, Raycast का इस्तेमाल करने का तरीका.
  • अपने सीन में रोशनी करने के लिए, ARLightEstimationData का इस्तेमाल करने का तरीका.

अगले चरण

बोनस असाइनमेंट

अगर आपको यहाँ बनाए गए गेम को और बेहतर बनाना है, तो यहाँ दिए गए कुछ आइडिया आज़माएँ:

  • PackageManager के नए पैकेज को स्पॉन करने पर, TextMeshPro में बदलाव करके, अपने गेम में स्कोर काउंटर जोड़ें.
  • परफ़ॉर्मेंस ओवरले को चालू करके, गेम के चलने के दौरान परफ़ॉर्मेंस की जानकारी देखें.
  • अपने सीन में नए ऑब्जेक्ट सबसे पहले रखने के लिए, परसिस्टेंट रेकास्ट का इस्तेमाल करें. उस जगह पर कोई प्लैन दिखने पर, वह ऑब्जेक्ट उस प्लैन पर स्नैप हो जाएगा.