इकाइयां बनाना, उन्हें कंट्रोल करना, और मैनेज करना

Jetpack XR SDK टूल की मदद से, Entity इंस्टेंस बनाने, उन्हें कंट्रोल करने, और मैनेज करने के लिए, Jetpack SceneCore का इस्तेमाल किया जा सकता है. जैसे, 3D मॉडल, स्टीरियोस्कोपिक वीडियो, और PanelEntity.

Jetpack SceneCore, 3D डेवलपमेंट के लिए आर्किटेक्चर के दो सामान्य पैटर्न अपनाता है: सीन ग्राफ़ और इकाई-कॉम्पोनेंट सिस्टम (ईसीएस).

इकाइयां बनाने और उन्हें कंट्रोल करने के लिए, सीन ग्राफ़ का इस्तेमाल करना

3D स्पेस में ऑब्जेक्ट बनाने और उन्हें कंट्रोल करने के लिए, आपको सीन ग्राफ़ का ऐक्सेस पाने के लिए, Jetpack SceneCore के Session API का इस्तेमाल करना होगा. सीन ग्राफ़, उपयोगकर्ता की असल दुनिया के साथ अलाइन होता है. साथ ही, पैनल और 3D मॉडल जैसी 3D इकाइयों को हैरारकी वाले स्ट्रक्चर में व्यवस्थित करने और उन इकाइयों की स्थिति को बनाए रखने में मदद करता है.

सीन ग्राफ़ का ऐक्सेस मिलने के बाद, XR के लिए Jetpack Compose में मौजूद एपीआई का इस्तेमाल करके, सीन ग्राफ़ में स्पेसिएल यूज़र इंटरफ़ेस (उदाहरण के लिए, SpatialPanel और Orbiter) बनाया जा सकता है. 3D मॉडल जैसे 3D कॉन्टेंट के लिए, सीधे सेशन को ऐक्सेस किया जा सकता है. ज़्यादा जानने के लिए, इस पेज पर ActivitySpace के बारे में जानकारी देखें.

इकाई का कॉम्पोनेंट सिस्टम

इकाई-कॉम्पोनेंट सिस्टम, इनहेरिटेंस के बजाय कंपोज़िशन के सिद्धांत का पालन करता है. इकाइयों के व्यवहार को बेहतर बनाने के लिए, व्यवहार तय करने वाले कॉम्पोनेंट जोड़े जा सकते हैं. इससे, अलग-अलग तरह की इकाइयों पर एक जैसा व्यवहार लागू किया जा सकता है. ज़्यादा जानकारी के लिए, इस पेज पर इकाइयों के लिए सामान्य व्यवहार जोड़ना लेख पढ़ें.

ActivitySpace के बारे में जानकारी

हर Session में एक ActivitySpace होता है, जो Session के साथ अपने-आप बन जाता है. ActivitySpace, सीन ग्राफ़ में सबसे ऊपर वाला Entity होता है.

ActivitySpace, तीन डाइमेंशन वाले स्पेस को दिखाता है. इसमें राइट-हैंडड कोऑर्डिनेट सिस्टम (x-ऐक्सिस दाईं ओर, y-ऐक्सिस ऊपर, और z-ऐक्सिस ऑरिजिन के पीछे) और मीटर की इकाइयां होती हैं, जो असल दुनिया से मेल खाती हैं. ActivitySpace का ऑरिजिन कुछ हद तक मनमुताबिक होता है. ऐसा इसलिए, क्योंकि उपयोगकर्ता असल दुनिया में ActivitySpace की पोज़िशन को रीसेट कर सकते हैं. इसलिए, हमारा सुझाव है कि कॉन्टेंट को ऑरिजिन के बजाय, एक-दूसरे के हिसाब से पोज़िशन करें.

इकाइयों के साथ काम करना

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

ActivitySpace, सीन ग्राफ़ का टॉप-लेवल नोड है. इसलिए, डिफ़ॉल्ट रूप से, सभी नई इकाइयों को सीधे ActivitySpace में रखा जाता है. setParent या addChild को कॉल करके, सीन ग्राफ़ में इकाइयों को फिर से सेट किया जा सकता है.

इकाइयों के कुछ डिफ़ॉल्ट व्यवहार होते हैं, जो सभी इकाइयों के लिए एक जैसे होते हैं. जैसे, जगह बदलना, घुमाना या दिखना. GltfEntity जैसे कुछ खास Entity सबक्लास में, सबक्लास के साथ काम करने वाली अतिरिक्त कार्रवाइयां होती हैं.

इकाइयों में बदलाव करना

जब किसी Entity प्रॉपर्टी में बदलाव किया जाता है, जो बेस Entity क्लास से जुड़ी होती है, तो यह बदलाव उसके सभी चाइल्ड पर लागू हो जाएगा. उदाहरण के लिए, माता-पिता Entity के Pose में बदलाव करने पर, उनके सभी बच्चों के लिए एक ही बदलाव होता है. चाइल्ड Entity में बदलाव करने से, उसके पैरंट पर कोई असर नहीं पड़ता.

Pose, 3D स्पेस में इकाई की जगह और घुमाव को दिखाता है. जगह एक Vector3 है, जिसमें x, y, z संख्यात्मक पोज़िशन शामिल हैं. रोटेशन को Quaternion से दिखाया जाता है. Entity की स्थिति हमेशा अपनी पैरंट इकाई के हिसाब से होती है. दूसरे शब्दों में, जिस Entity की पोज़िशन (0, 0, 0) है उसे पैरंट इकाई के ऑरिजिन पर रखा जाएगा.

//place the entity forward 2 meters
val modelPosition = Vector3(0f, 0f, -2f)
//rotate the entity by 180 degrees on the up axis (upside-down)
val newOrientation = Quaternion.fromEulerAngles(0f, 0f, 180f)
//update the position and rotation on the entity
entity.setPose(Pose(newPosition, newOrientation))

अहम जानकारी: Entity की जगह के बारे में बात करते समय, याद रखें कि Entity को सीन ग्राफ़ में किसी खास जगह पर रखा जा सकता है. साथ ही, 3D स्पेस में भी इसकी एक जगह होती है.

किसी Entity की दिखने की सेटिंग बदलने के लिए, setHidden का इस्तेमाल करें.

//hide the entity
entity.setHidden(true)

Entity का साइज़ बदलने के लिए, उसका आकार बदले बिना, setScale का इस्तेमाल करें.

//double the size of the entity
entity.setScale(2f)

चेतावनी: Entity के स्केल से, उसके कोऑर्डिनेट सिस्टम की यूनिट पर असर पड़ता है. उदाहरण के लिए, स्केल को 2 पर सेट करने पर, इस इकाई की हर इकाई अब असल दुनिया में 1 मीटर के बजाय 2 मीटर के बराबर होगी. यह बदलाव, इकाई के सभी चाइल्ड एलिमेंट पर भी लागू होता है.

इकाइयों के लिए सामान्य व्यवहार जोड़ना

इकाइयों में सामान्य व्यवहार जोड़ने के लिए, इन कॉम्पोनेंट का इस्तेमाल किया जा सकता है:

• MovableComponent: उपयोगकर्ता को इकाइयों को एक से दूसरी जगह ले जाने की अनुमति देता है
• ResizableComponent: इससे उपयोगकर्ता को यूज़र इंटरफ़ेस (यूआई) के एक जैसे पैटर्न वाली इकाइयों का साइज़ बदलने की अनुमति मिलती है
• InteractableComponent: कस्टम इंटरैक्शन के लिए इनपुट इवेंट कैप्चर करने की सुविधा देता है

कॉम्पोनेंट को इंस्टैंशिएट करने के लिए, Session क्लास में कॉम्पोनेंट बनाने का सही तरीका अपनाना ज़रूरी है. उदाहरण के लिए, ResizableComponent बनाने के लिए, session.createResizableComponent() को कॉल करें.

झलक: फ़िलहाल, InteractableComponent को छोड़कर, कॉम्पोनेंट सिर्फ़ PanelEntity या उसके सबक्लास से अटैच किए जा सकते हैं. InteractableComponent का इस्तेमाल GltfEntity में किया जा सकता है.

Entity में किसी खास कॉम्पोनेंट के व्यवहार को जोड़ने के लिए, addComponent() का इस्तेमाल करें.

इकाई को उपयोगकर्ता के लिए मूव करने लायक बनाने के लिए, MovableComponent का इस्तेमाल करना

MovableComponent की मदद से, उपयोगकर्ता Entity को एक जगह से दूसरी जगह ले जा सकता है. यह भी तय किया जा सकता है कि इकाई को किसी तरह की सतह पर ऐंकर किया जा सकता है या नहीं. जैसे, हॉरिज़ॉन्टल या वर्टिकल सतहें या टेबल, दीवार या छत जैसी खास सिमेंटिक सतहें. ऐंकर के विकल्पों की जानकारी देने के लिए, MovableComponent बनाते समय AnchorPlacement का एक सेट तय करें.

यहां एक ऐसी इकाई का उदाहरण दिया गया है जिसे किसी भी वर्टिकल प्लैटफ़ॉर्म पर ले जाया और ऐंकर किया जा सकता है. साथ ही, इसे सिर्फ़ फ़्लोर और सीलिंग के हॉरिज़ॉन्टल प्लैटफ़ॉर्म पर ले जाया जा सकता है.

val anchorPlacement = AnchorPlacement.createForPlanes(
    planeTypeFilter = setOf(PlaneSemantic.FLOOR, PlaneSemantic.TABLE),
    planeSemanticFilter = setOf(PlaneType.VERTICAL))

val movableComponent = xrSession.createMovableComponent(
    systemMovable = false,
    scaleInZ = false,
    anchorPlacement = setOf(anchorPlacement)
)
entity.addComponent(movableComponent)

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

ResizableComponent का इस्तेमाल करके, इकाई को उपयोगकर्ता के हिसाब से बड़ा या छोटा किया जा सकता है

ResizableComponent की मदद से, उपयोगकर्ता किसी Entity का साइज़ बदल सकते हैं. ResizableComponent में विज़ुअल इंटरैक्शन के ऐसे संकेत शामिल होते हैं जिनसे उपयोगकर्ता को Entity का साइज़ बदलने का न्योता मिलता है. ResizeableComponent बनाते समय, ज़्यादा से ज़्यादा या कम से कम साइज़ (मीटर में) तय किया जा सकता है. आपके पास साइज़ बदलते समय, एक तय आसपेक्ट रेशियो तय करने का विकल्प भी होता है, ताकि चौड़ाई और ऊंचाई का अनुपात एक-दूसरे के हिसाब से बदल जाए.

यहां ResizableComponent का इस्तेमाल करके, फ़िक्स किए गए आसपेक्ट रेशियो का उदाहरण दिया गया है:

val resizableComponent = xrSession.createResizableComponent()
resizableComponent.minimumSize = Dimensions(177f, 100f, 1f )
resizableComponent.fixedAspectRatio = 16f / 9f //Specify a 16:9 aspect ratio
entity.addComponent(resizableComponent)

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

उपयोगकर्ता के इनपुट इवेंट कैप्चर करने के लिए, InteractableComponent का इस्तेमाल करना

InteractableComponent की मदद से, उपयोगकर्ता के इनपुट इवेंट कैप्चर किए जा सकते हैं. जैसे, जब उपयोगकर्ता किसी Entity पर इंटरैक्ट करता है या उस पर कर्सर घुमाता है. InteractableComponent बनाते समय, आपको इनपुट इवेंट पाने के लिए, InputEventListener तय करना होगा. जब उपयोगकर्ता कोई इनपुट ऐक्शन करता है, तो onInputEvent विधि को InputEvent पैरामीटर में दी गई खास इनपुट जानकारी के साथ कॉल किया जाएगा.

• InputEvent.action, इनपुट के टाइप की जानकारी देता है. जैसे, किसी इकाई पर हॉवर करना या टैप करना
• InputEvent.source से पता चलता है कि इनपुट कहां से आया है, जैसे कि हाथ या कंट्रोलर इनपुट
• InputEvent.pointerType से पता चलता है कि इनपुट, दाएं हाथ से मिला है या बाएं हाथ से

सभी InputEvent कॉन्स्टेंट की पूरी सूची के लिए, रेफ़रंस दस्तावेज़ देखें.

नीचे दिया गया कोड स्निपेट, InteractableComponent का इस्तेमाल करके किसी इकाई के साइज़ को बढ़ाने और घटाने का उदाहरण दिखाता है. इसके लिए, दाएं हाथ का इस्तेमाल किया जाता है और बाएं हाथ का इस्तेमाल किया जाता है.

private val executor by lazy { Executors.newSingleThreadExecutor() }
val interactableComponent = xrSession.createInteractableComponent(executor) {
    //when the user disengages with the entity with their hands
    if (it.source == InputEvent.SOURCE_HANDS && it.action == InputEvent.ACTION_UP) {
        // increase size with right hand and decrease with left
        if (it.pointerType == InputEvent.POINTER_TYPE_RIGHT){
            entity.setScale(1.5f)
        } else if (it.pointerType == InputEvent.POINTER_TYPE_LEFT){
            entity.setScale(0.5f)
        }
    }
}
entity.addComponent(interactableComponent)