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

Renderable एक 3D मॉडल होता है. इसमें वर्टेक्स, मटीरियल, स्ट्रक्चर वगैरह शामिल होते हैं. इसे Node से अटैच किया जा सकता है और किसी सीन के हिस्से के तौर पर रेंडर किया जा सकता है. इस पेज पर, Renderable बनाने और उनमें बदलाव करने का तरीका बताया गया है.

Android विजेट से बनाएं

स्टैंडर्ड Android विजेट से ViewRenderable बनाया जा सकता है. ये सीन में फ़्लैट कार्ड के तौर पर रेंडर होते हैं.

अनुरोध करने के लिए:

  1. res > लेआउट में लेआउट फ़ाइल बनाएं. उदाहरण के लिए:

    <TextView xmlns:android="http://schemas.android.com/apk/res/android"
   android:id="@+id/planetInfoCard"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_weight="1"
   android:background="@drawable/rounded_bg"
   android:gravity="center"
   android:orientation="vertical"
   android:padding="6dp"
   android:text="Test"
   android:textAlignment="center" />

  2. ViewRenderable बनाएं.

    ViewRenderable.builder()
    .setView(this, R.layout.test_view)
    .build()
    .thenAccept(renderable -> testViewRenderable = renderable);

    setView() का यह वर्शन, इनफ़्लेटेड लेआउट फ़ाइल का रिसॉर्स आईडी लेता है. प्रोग्राम के हिसाब से बनाए गए व्यू से रेंडर करने लायक बनाने के लिए, setView(View) को कॉल भी किया जा सकता है.

सीनफ़ॉर्म में build() के सभी तरीके CompletableFuture दिखाते हैं. ऑब्जेक्ट को एक अलग थ्रेड पर बनाया जाता है और कॉलबैक फ़ंक्शन मुख्य थ्रेड पर एक्ज़ीक्यूट होता है.

रेंडर करने लायक टूल का साइज़, View ऑब्जेक्ट के साइज़ के हिसाब से तय किया जाता है. डिफ़ॉल्ट रूप से, रेंडर के लिए हर 250dp व्यू के लिए एक 1 मीटर बन जाता है. व्यू का साइज़ तय करने का तरीका बदलने के लिए, setSizer(ViewSizer) का इस्तेमाल करें.

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

// update button text when the renderable's node is tapped
Button button = (Button) renderable.getView();
button.setOnClickListener((button) -> button.setText("clicked"));

3D एसेट से बनाएं

पाबंदी फ़ॉर्म, 3D एसेट फ़ाइलें (ओबीजे, एफ़बीएक्स, जीएलटीएफ़) को सीनफ़ॉर्म बाइनरी एसेट (एसएफ़बी) में बदलने के लिए, टूल और प्लग इन देता है. इन एसेट को ModelRenderable में बनाया जा सकता है.

ज़्यादा जानकारी के लिए, 3D एसेट इंपोर्ट करें और उनकी झलक देखें देखें.

रनटाइम पर आसान आकार बनाएं

क्यूब, गोले, और सिलेंडर जैसे सामान्य आकार, ShapeFactory और MaterialFactory का इस्तेमाल करके, बनाए जा सकने वाले ऑब्जेक्ट को आसान आकार और सामग्री से बनाए जा सकते हैं.

लाल रंग का गोला बनाने का तरीका यहां दिया गया है:

MaterialFactory.makeOpaqueWithColor(this, new Color(android.graphics.Color.RED))
        .thenAccept(
            material -> {
              redSphereRenderable =
                  ShapeFactory.makeSphere(0.1f, new Vector3(0.0f, 0.15f, 0.0f), material); });

रनटाइम पर 3D मॉडल लोड करें

glTF या glb फ़ाइलों के तौर पर सेव किए गए 3D मॉडल, बिना कन्वर्ज़न के रनटाइम के दौरान लोड किए जा सकते हैं. इससे, आपके ऐप्लिकेशन में रेंडर किए गए मॉडल की सुविधा बेहतर तरीके से काम करती है. हालांकि, रनटाइम के दौरान यह मॉडल पढ़ा जाता है और ऑप्टिमाइज़ेशन से फ़ायदा नहीं मिलता है, क्योंकि इसे बिल्ड टाइम कन्वर्ज़न के दौरान किया जाता है औरsfb. इस वजह से, हमारा सुझाव है कि आप अपने ऐप्लिकेशन और 3D मॉडल को कई तरह के डिवाइस और नेटवर्क स्थितियों से जांचें, ताकि आप यह पक्का कर सकें कि आपके उपयोगकर्ताओं को एक बेहतरीन अनुभव मिले.

रनटाइम एसेट लोडिंग का इस्तेमाल करने के लिए, आपको app/build.gradle में एसेट लाइब्रेरी में डिपेंडेंसी जोड़नी होगी:

  dependencies {
     implementation 'com.google.ar.sceneform:assets:1.15.0'
  }

RenderableSource क्लास, glTF फ़ाइल को लोड करने के लिए हैंडल करती है. साथ ही, यह ModelRenderable.Builder के लिए सोर्स ऑब्जेक्ट बनाती है, जो रेंडर करने लायक ऑब्जेक्ट बनाता है.

उदाहरण के लिए, इंटरनेट से कोई मॉडल लोड करने पर ऐसा दिखता है:

 private static final String GLTF_ASSET =
   "https://github.com/KhronosGroup/glTF-Sample-Models/raw/master/2.0/Duck/glTF/Duck.gltf";

 /* When you build a Renderable, Sceneform loads model and related resources
 * in the background while returning a CompletableFuture.
 * Call thenAccept(), handle(), or check isDone() before calling get().
 */
 ModelRenderable.builder()
    .setSource(this, RenderableSource.builder().setSource(
            this,
            Uri.parse(GLTF_ASSET),
            RenderableSource.SourceType.GLTF2)
            .setScale(0.5f)  // Scale the original model to 50%.
            .setRecenterMode(RenderableSource.RecenterMode.ROOT)
            .build())
    .setRegistryId(GLTF_ASSET)
    .build()
    .thenAccept(renderable -> duckRenderable = renderable)
    .exceptionally(
        throwable -> {
          Toast toast =
              Toast.makeText(this, "Unable to load renderable " +
              GLTF_ASSET, Toast.LENGTH_LONG);
          toast.setGravity(Gravity.CENTER, 0, 0);
          toast.show();
          return null;
        });

ध्यान दें: संसाधनों को दूर से ऐक्सेस करने के लिए, आपको अपने AndroidManifest.xml में इंटरनेट की अनुमति शामिल करनी होगी:

    <manifest …>
      <!-- Needed to load a glTF from the internet. -->
        <uses-permission android:name="android.permission.INTERNET"/>

    </manifest>

रनटाइम पर रेंडर करने लायक चीज़ें बदलें

अगर एक से ज़्यादा नोड, रेंडर करने लायक सेटिंग का इस्तेमाल करते हैं, तो उस रेंडर करने वाले डिवाइस में किए गए बदलाव सभी नोड पर लागू होते हैं. ऐसा न हो, इसके लिए makeCopy() को कॉल करके, एक अलग रेंडर करने लायक इंस्टेंस बनाएं. ध्यान दें कि यह रेंडर करने लायक हर कॉन्टेंट पर makeCopy() कॉल भी करता है.

blueSphereRenderable = redSphereRenderable.makeCopy();
blueSphereRenderable.getMaterial().setFloat3(
                  MaterialFactory.MATERIAL_COLOR, new Color(android.graphics.Color.BLUE));