सीनफ़ॉर्म के साथ शुरू करना

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

  • इस नमूने में Squareform और ARCore का इस्तेमाल किया जाता है.

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

  • यह नमूना ऐप्लिकेशन, AR ज़रूरी ऐप्लिकेशन के तौर पर लिखा गया है.

    AR वैकल्पिक बनाम AR ज़रूरी ऐप्लिकेशन के बारे में ज़्यादा जानने के लिए, ARCore चालू करना देखें.

अपने प्रोजेक्ट में सीनफ़ॉर्म का इस्तेमाल शुरू करने के लिए, आपको ये शर्तें पूरी करनी होंगी:

  1. उदाहरण के तौर पर दिए गए फ़ॉर्म को इंपोर्ट करना
  2. अपने प्रोजेक्ट और build.gradle की फ़ाइलें कॉन्फ़िगर करना
  3. अपना AndroidManifest.xml अपडेट करें
  4. रनटाइम में जांच करना और सीन व्यू बनाना
  5. रेंडर करने लायक बनाएं
  6. द सीन बनाना

अपने प्रोजेक्ट में सीनफ़ॉर्म प्लग इन इंपोर्ट करें

इंस्टॉल करने के बाद, सीनफ़ॉर्म प्लग इन की मदद से आप Android Studio में एआर (ऑगमेंटेड रिएलिटी) ऐप्लिकेशन के लिए सीनफ़ॉर्म SDK टूल में 3D एसेट इंपोर्ट कर सकते हैं, देख सकते हैं, और बना सकते हैं. इसके लिए, Android Studio 3.1 और इसके बाद के वर्शन ज़रूरी हैं.

प्लग इन इंस्टॉल करने के लिए:

  1. Android Studio में, प्लग इन सेटिंग खोलें:

    • Windows: फ़ाइल और gt; सेटिंग > प्लग इन और gt; ब्राउज़ करने की जगहें ब्राउज़ करें

    • macOS: Android Studio > प्राथमिकताएं > प्लग इन

  2. डेटा स्टोर करने की जगह ब्राउज़ करें पर क्लिक करें और Google के विज़ुअल फ़ॉर्म टूल (बीटा) इंस्टॉल करें.

अपने प्रोजेक्ट की build.gradle फ़ाइलें कॉन्फ़िगर करें

  1. पक्का करें कि आपके प्रोजेक्ट के #build.gradle में, Google का Maven का डेटा स्टोर करने की जगह शामिल है:

    allprojects {
        repositories {
            google()
            …
    
  2. नई ARCore और स्कीम UX डिपेंडेंसी जोड़ने के लिए, अपने ऐप्लिकेशन और # build.gradle को अपडेट करें. साथ ही, पक्का करें कि आपके प्रोजेक्ट की सेटिंग दोनों लाइब्रेरी के साथ काम करती हों.

    android {
        …
        defaultConfig {
            // Sceneform requires minSdkVersion >= 24.
            minSdkVersion 24
            …
        }
        // Sceneform libraries use language constructs from Java 8.
        // Add these compile options if targeting minSdkVersion < 26.
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    }
    
    dependencies {
        …
        // Provides ARCore Session and related resources.
        implementation 'com.google.ar:core:1.15.0'
    
        // Provides ArFragment, and other UX resources.
        implementation 'com.google.ar.sceneform.ux:sceneform-ux:1.15.0'
    
        // Alternatively, use ArSceneView without the UX dependency.
        implementation 'com.google.ar.sceneform:core:1.15.0'
    }
    

अपना AndroidManifest.xml अपडेट करें

अपने AndroidManifest.xml में बदलाव करके बताएं कि आपका ऐप्लिकेशन (AR वैकल्पिक) या इसके लिए (AR ज़रूरी है) ARCore और CAMERA के ऐक्सेस का इस्तेमाल करता है:

<!-- Both "AR Optional" and "AR Required" apps require CAMERA permission. -->
<uses-permission android:name="android.permission.CAMERA" />

<!-- Sceneform requires OpenGL ES 3.0 or later. -->
<uses-feature android:glEsVersion="0x00030000" android:required="true" />

<!-- Indicates that app requires ARCore ("AR Required"). Ensures the app is
     visible only in the Google Play Store on devices that support ARCore.
     For "AR Optional" apps remove this line. -->
<uses-feature android:name="android.hardware.camera.ar" />

<application>
    …
    <!-- Indicates that app requires ARCore ("AR Required"). Causes the Google
         Play Store to download and install Google Play Services for AR along
         with the app. For an "AR Optional" app, specify "optional" instead of
         "required".
    -->
    <meta-data android:name="com.google.ar.core" android:value="required" />
</application>

रनटाइम चेक करें और सीन व्यू बनाएं

सीनफ़ॉर्म का इस्तेमाल शुरू करने और सीन व्यू बनाने का सबसे आसान तरीका है, ArFragment का इस्तेमाल करना, जो ज़रूरी ARCore रनटाइम जांच के बाद, ARCore सेशन मैनेजमेंट को अपने-आप हैंडल करता है:

  1. एआर (ऑगमेंटेड रिएलिटी) के लिए Google Play सेवाएं के साथ काम करने वाले वर्शन को इंस्टॉल किया जाता है या नहीं, ताकि उपयोगकर्ता को ज़रूरत के मुताबिक इंस्टॉल या अपडेट करने के लिए कहा जा सके

  2. यह पता लगाता है कि ऐप्लिकेशन को कैमरे का ऐक्सेस है या नहीं. साथ ही, उपयोगकर्ता से अनुमति न मिलने पर, वह आपसे अनुमति भी मांगता है

अगर आपके ऐप्लिकेशन को अन्य अनुमतियों की ज़रूरत है या आपको यह कस्टमाइज़ करना है कि एआर सेशन कैसे बनाया जाए, तो आप ये कर सकते हैं:

  • अन्य अनुमतियों का अनुरोध करने के लिए, ArFragment की सब-क्लास बनाएं.

  • सीधे ArSceneView इस्तेमाल करें या बढ़ाएं. सोलर सिस्टम सैंपल में दिखाए गए तरीके से, ARCore सेशन को मैन्युअल तरीके से बनाने के लिए, आपके ऐप्लिकेशन को ARCore वर्शन की जांच करनी होगी और setupSession() को कॉल करना होगा.

जांच पूरी होने के बाद, ArFragment:

  1. ArSceneView, जिसे getArSceneView() से ऐक्सेस किया जा सकता हो, जो:

    • कैमरे की इमेज को सेशन से लेकर उसके प्लैटफ़ॉर्म पर रेंडर करता है

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

    • डिफ़ॉल्ट हाइलाइट Planes का पता लगाया गया PlaneRenderer

  2. ARCore Session, getSession() से ऐक्सेस किया जा सकता है

अपने ऐप्लिकेशन में ArFragment इस्तेमाल करने के लिए, उसे अपनी गतिविधि's लेआउट में जोड़ें, जैसा कि activity_ux.xml नमस्ते Hello नमूने में दिखाया गया है:

<fragment android:name="com.google.ar.sceneform.ux.ArFragment"
    android:id="@+id/ux_fragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

रेंडर करने लायक बनाएं

Renderable एक 3D मॉडल होता है. इसे स्क्रीन पर कहीं भी रखा जा सकता है. इसमें मेश, मटीरियल, और बनावट शामिल होती है.

रेंडर करने की सुविधा यहां से बनाई जा सकती है:

सैंपल ऐप्लिकेशन, 3D andy.obj एसेट फ़ाइल से रेंडर करने लायक बनाता है. इस एसेट को इंपोर्ट करने पर, प्लग इन लागू करने और इंपोर्ट किए गए मॉडल के लिए sceneform.asset() एंट्री जोड़ने के लिए, सीनफ़ॉर्म प्लग इन ऐप्लिकेशन's build.gradle को अपडेट करता है:

apply plugin: 'com.google.ar.sceneform.plugin'

sceneform.asset('sampledata/models/andy.obj', // 'Source Asset Path' specified during import.
                'default',                    // 'Material Path' specified during import.
                'sampledata/models/andy.sfa', // '.sfa Output Path' specified during import.
                'src/main/res/raw/andy')      // '.sfb Output Path' specified during import.

res/raw/andy संसाधन का इस्तेमाल ModelRenderable बनाने के लिए किया जाता है:

private ModelRenderable andyRenderable;

@Override
protected void onCreate(Bundle savedInstanceState) {
    …

    ModelRenderable.builder()
        .setSource(this, R.raw.andy)
        .build()
        .thenAccept(renderable -> andyRenderable = renderable)
        .exceptionally(
            throwable -> {
            Log.e(TAG, "Unable to load Renderable.", throwable);
            return null;
        });
}

सीन बनाएं

ARSceneView के साथ Scene जुड़ा हुआ है. सीन ट्री की तरह डेटा स्ट्रक्चर है, जिसमें Node को रेंडर किया जाता है. ये रेंडर किए जाने वाले वर्चुअल ऑब्जेक्ट हैं.

यहां ऐंडी रेंडर करने के लिए, सीधे रूट सीन नोड से जुड़ा गया है:

Node node = new Node();
node.setParent(arFragment.getArSceneView().getScene());
node.setRenderable(andyRenderable);

हर नोड में वह सारी जानकारी शामिल होती है जो इसे रेंडर करने के लिए ज़रूरी है (इसमें इसकी स्थिति, ओरिएंटेशन, और रेंडर करने लायक ऑब्जेक्ट भी शामिल है) और साथ ही, इससे इंटरैक्ट करने के लिए (इसमें इसका टक्कर का आकार और इवेंट लिसनर भी शामिल हैं) ज़रूरी है.

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

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