XR_ANDROID_trackables OpenXR एक्सटेंशन

Name String

XR_ANDROID_trackables

एक्सटेंशन टाइप

इंस्टेंस एक्सटेंशन

रजिस्टर किया गया एक्सटेंशन नंबर

456

बदलाव

1

एक्सटेंशन और वर्शन की डिपेंडेंसी

OpenXR 1.0

पिछली बार बदलाव करने की तारीख

2024-09-30

आईपी स्टेटस

आईपी पर कोई दावा नहीं किया गया है.

योगदान देने वाले

स्पेंसर क्विन, Google

निहाव जैन, Google

जॉन पर्सी, Google

जेरेड फ़ाइंडर, Google

लेवाना चेन, Google

केनी वर्कमेयर, Google

खास जानकारी

इस एक्सटेंशन की मदद से, ऐप्लिकेशन को ट्रैक किए जा सकने वाले आइटम को ऐक्सेस करने और उनसे जुड़े ऐंकर बनाने की सुविधा मिलती है.

यह एक्सटेंशन, प्लेन ट्रैकबल के बारे में बताता है. अन्य एक्सटेंशन, ट्रैक किए जा सकने वाले अन्य टाइप जोड़ सकते हैं. उदाहरण के लिए, XR_ANDROID_trackables_object ऑब्जेक्ट ट्रैक करने की सुविधा जोड़ता है और XR_ANDROID_depth_texture डेप्थ बफ़र जोड़ता है. इससे, एनवायरमेंट में किसी भी पॉइंट पर रे कास्टिंग की जा सकती है.

ट्रैक करने लायक आइटम, ऐसा आइटम होता है जिसे आस-पास के वातावरण में ट्रैक किया जाता है. इसके बारे में ज़्यादा जानने के लिए, XrTrackableTypeANDROID देखें:

  • कोई प्लैटफ़ॉर्म (जैसे, दीवार, फ़्लोर, सीलिंग, टेबल)
  • कोई ऑब्जेक्ट (जैसे, कीबोर्ड, माउस, लैपटॉप)

ट्रैक किया जा सकने वाला ट्रैकर बनाना

XrTrackableTrackerANDROID एक हैंडल है, जो एनवायरमेंट में किसी दिए गए XrTrackableTypeANDROID के ट्रैक किए जा सकने वाले आइटम को ढूंढने और अपडेट करने के लिए ज़रूरी संसाधनों को दिखाता है.

XR_DEFINE_HANDLE(XrTrackableTrackerANDROID)

xrCreateTrackableTrackerANDROID फ़ंक्शन को इस तरह से परिभाषित किया गया है: 

XrResult xrCreateTrackableTrackerANDROID(
    XrSession                                   session,
    const XrTrackableTrackerCreateInfoANDROID*  createInfo,
    XrTrackableTrackerANDROID*                  trackableTracker);

पैरामीटर की जानकारी

  • session वह XrSession है जो ट्रैकर बनाता है.
  • createInfo, XrTrackableTrackerCreateInfoANDROID स्ट्रक्चर का पॉइंटर है. इसमें ट्रैकर बनाने के लिए इस्तेमाल किए जाने वाले पैरामीटर होते हैं.
  • trackableTracker, ऐसे हैंडल का पॉइंटर है जिसमें बनाया गया XrTrackableTrackerANDROID दिखाया जाता है.

ऐप्लिकेशन, ट्रैक किया जा सकने वाला ट्रैकर बनाने के लिए, xrCreateTrackableTrackerANDROID फ़ंक्शन का इस्तेमाल कर सकता है.

  • अगर सिस्टम, बताए गए टाइप के ट्रैकेबल के साथ काम नहीं करता है, तो XR_ERROR_FEATURE_UNSUPPORTED दिखेगा.
  • अगर कॉल करने वाले ऐप्लिकेशन को ज़रूरी अनुमतियां नहीं दी गई हैं, तो XR_ERROR_PERMISSION_INSUFFICIENT दिखेगा.

ऐप्लिकेशन, एपीआई कॉल के बाद ट्रैकर हैंडल का इस्तेमाल कर सकता है. XrTrackableTrackerANDROID हैंडल को आखिर में, xrDestroyTrackableTrackerANDROID फ़ंक्शन का इस्तेमाल करके खाली करना ज़रूरी है.

मान्य इस्तेमाल (इंप्लिसिट)

रिटर्न कोड

सफलता

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

प्रोसेस पूरी नहीं हो सकी

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_FEATURE_UNSUPPORTED

XrTrackableTrackerCreateInfoANDROID स्ट्रक्चर को इस तरह से परिभाषित किया गया है: 

typedef struct XrTrackableTrackerCreateInfoANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackableTypeANDROID    trackableType;
} XrTrackableTrackerCreateInfoANDROID;

पैसे चुकाकर बने सदस्यों के ब्यौरे

  • type इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर तय नहीं किए गए हैं.
  • trackableType, XrTrackableTypeANDROID है, जिसे ट्रैकर ट्रैक करेगा.

XrTrackableTrackerCreateInfoANDROID स्ट्रक्चर, xrCreateTrackableTrackerANDROID को पास करने पर, XrTrackableTrackerANDROID बनाने के विकल्प उपलब्ध कराता है.

एक्सटेंशन में ऐसे स्ट्रक्चर तय किए जा सकते हैं जिन्हें next से अटैच किया जा सकता है. इससे ट्रैक किए जा सकने वाले ट्रैकर के लिए, अतिरिक्त कॉन्फ़िगरेशन की अनुमति मिलती है.

मान्य इस्तेमाल (इंप्लिसिट)

XrTrackableTypeANDROID एनम को इस तरह परिभाषित किया गया है: 

typedef enum XrTrackableTypeANDROID {
    XR_TRACKABLE_TYPE_NOT_VALID_ANDROID = 0,
    XR_TRACKABLE_TYPE_PLANE_ANDROID = 1,
    XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000,
    XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000
} XrTrackableTypeANDROID;

xrDestroyTrackableTrackerANDROID फ़ंक्शन को इस तरह से परिभाषित किया गया है: 

XrResult xrDestroyTrackableTrackerANDROID(
    XrTrackableTrackerANDROID                   trackableTracker);

पैरामीटर की जानकारी

xrDestroyTrackableTrackerANDROID फ़ंक्शन, ट्रैक किए जा सकने वाले ट्रैकर को मिटा देता है.

अगर XrTrackableTypeANDROID के साथ कोई दूसरा मान्य XrTrackableTrackerANDROID नहीं बनाया गया है, तो सिस्टम संसाधनों को बचाने के लिए, सिस्टम उस ट्रैक किए जा सकने वाले टाइप के लिए ज़रूरी ट्रैकिंग सेवाओं को बंद कर सकता है.

मान्य इस्तेमाल (इंप्लिसिट)

थ्रेड की सुरक्षा

  • trackableTracker और किसी भी चाइल्ड हैंडल का ऐक्सेस, बाहरी तौर पर सिंक होना ज़रूरी है

रिटर्न कोड

सफलता

  • XR_SUCCESS

प्रोसेस पूरी नहीं हो सकी

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

सभी ट्रैक किए जा सकने वाले आइटम पाना

XrTrackableANDROID एटम को इस तरह परिभाषित किया गया है:

XR_DEFINE_ATOM(XrTrackableANDROID)

XrTrackableANDROID का इस्तेमाल, ट्रैक किए जा सकने वाले किसी एक आइटम को दिखाने के लिए किया जाता है. यह सिर्फ़ उससे जुड़े XrTrackableTrackerANDROID के लाइफ़साइकल के दौरान मान्य होता है.

xrGetAllTrackablesANDROID फ़ंक्शन को इस तरह से परिभाषित किया गया है: 

XrResult xrGetAllTrackablesANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    uint32_t                                    trackableCapacityInput,
    uint32_t*                                   trackableCountOutput,
    XrTrackableANDROID*                         trackables);

पैरामीटर की जानकारी

  • trackableTracker वह XrTrackableTrackerANDROID है जिसकी क्वेरी की जानी है.

  • trackableCapacityInput, trackables कलेक्शन की क्षमता है या ज़रूरी क्षमता पाने के अनुरोध के लिए 0.

  • trackableCountOutput, लिखे गए trackables की संख्या का पॉइंटर है. इसके अलावा, अगर trackables की संख्या काफ़ी नहीं है, तो trackableCountOutput ज़रूरी क्षमता का पॉइंटर है.

  • trackables, XrTrackableANDROID के कलेक्शन का पॉइंटर है. अगर trackableCapacityInput 0 है, तो यह NULL हो सकता है.

  • ज़रूरी trackables साइज़ को वापस पाने के बारे में पूरी जानकारी के लिए, बफ़र साइज़ पैरामीटर सेक्शन देखें.

xrGetAllTrackablesANDROID, XrTrackableANDROID के ऐरे को भरता है. यह ऐरे, आस-पास मौजूद ट्रैक किए जा सकने वाले आइटम की जानकारी दिखाता है. रिटर्न किए गए trackables के XrTrackableTypeANDROID की वैल्यू, trackableTracker के XrTrackableTypeANDROID की वैल्यू से मेल खानी चाहिए.

ट्रैक किया जा सकने वाला विमान पाना

xrGetTrackablePlaneANDROID फ़ंक्शन को इस तरह से परिभाषित किया गया है:

XrResult xrGetTrackablePlaneANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    const XrTrackableGetInfoANDROID*            getInfo,
    XrTrackablePlaneANDROID*                    planeOutput);

पैरामीटर की जानकारी

  • trackableTracker वह XrTrackableTrackerANDROID है जिसकी क्वेरी की जानी है.

  • getInfo, XrTrackableGetInfoANDROID है. इसमें ट्रैक किए जा सकने वाले प्लेन की जानकारी होती है.

  • planeOutput, XrTrackablePlaneANDROID स्ट्रक्चर का पॉइंटर है. इसमें ट्रैक किया जा सकने वाला प्लेन दिखता है.

xrGetTrackablePlaneANDROID फ़ंक्शन, ट्रैक किए जा सकने वाले प्लेन के बारे में जानकारी दिखाता है. जैसे, उसकी ज्यामिति, ओरिएंटेशन, और ट्रैकिंग की स्थिति.

xrGetTrackablePlaneANDROID को कॉल करने के समय, प्लैन की जानकारी को हल किया जाता है और इसे बेस स्पेस के हिसाब से दिखाया जाता है. इसके लिए, XrTrackableGetInfoANDROID::time, XrTrackableGetInfoANDROID::baseSpace का इस्तेमाल किया जाता है.

मान्य इस्तेमाल (इंप्लिसिट)

रिटर्न कोड

सफलता

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

प्रोसेस पूरी नहीं हो सकी

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_TIME_INVALID

XrTrackableGetInfoANDROID स्ट्रक्चर को इस तरह परिभाषित किया गया है: 

typedef struct XrTrackableGetInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrTrackableANDROID    trackable;
    XrSpace               baseSpace;
    XrTime                time;
} XrTrackableGetInfoANDROID;

पैसे चुकाकर बने सदस्यों के ब्यौरे

  • type इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर तय नहीं किए गए हैं.
  • trackable वह XrTrackableANDROID प्लेन है जिसकी क्वेरी करनी है.
  • baseSpace time पर, प्लेन का पोज़ इस XrSpace के हिसाब से होगा.
  • time वह XrTime है जिस पर baseSpace के हिसाब से निर्देशांक का आकलन करना है.

XrTrackableGetInfoANDROID स्ट्रक्चर, xrGetTrackablePlaneANDROID को पास किए जाने पर क्वेरी के विकल्प उपलब्ध कराता है. trackable को trackableTracker से मैच करना चाहिए, जिसका इस्तेमाल xrGetTrackablePlaneANDROID में किया गया है.

अगर trackable का ट्रैक किया जा सकने वाला टाइप XR_TRACKABLE_TYPE_PLANE_ANDROID नहीं है, तो XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID दिखाया जाएगा.

मान्य इस्तेमाल (इंप्लिसिट)

XrTrackablePlaneANDROID स्ट्रक्चर को इस तरह परिभाषित किया गया है: 

typedef struct XrTrackablePlaneANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackingStateANDROID    trackingState;
    XrPosef                   centerPose;
    XrExtent2Df               extents;
    XrPlaneTypeANDROID        planeType;
    XrPlaneLabelANDROID       planeLabel;
    XrTrackableANDROID        subsumedByPlane;
    XrTime                    lastUpdatedTime;
    uint32_t                  vertexCapacityInput;
    uint32_t*                 vertexCountOutput;
    XrVector2f*               vertices;
} XrTrackablePlaneANDROID;

पैसे चुकाकर बने सदस्यों के ब्यौरे

  • type इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर तय नहीं किए गए हैं.
  • trackingState, हवाई जहाज़ का XrTrackingStateANDROID है.
  • centerPose एक XrPosef है, जो उससे जुड़े XrTrackableGetInfoANDROID::baseSpace के रेफ़रंस फ़्रेम में, प्लेन की पोज़िशन और ओरिएंटेशन तय करता है. यहां आइडेंटिटी ओरिएंटेशन, निर्देशांक ऐक्सिस को दिखाता है. इसमें +Y, प्लैन के नॉर्मल के समानांतर होता है.
  • extents, प्लेन का XrExtent2Df डाइमेंशन है.
  • planeType, XrPlaneTypeANDROID है, जिसे रनटाइम ने इस प्लेन के लिए तय किया है.
  • planeLabel, XrPlaneLabelANDROID है, जिसे रनटाइम ने इस प्लेन के लिए तय किया है.
  • subsumedByPlane, उस प्लेन का XrTrackableANDROID है जिसमें यह प्लेन शामिल है. अगर कोई प्लेन शामिल नहीं है, तो XR_NULL_TRACKABLE_ANDROID.
  • lastUpdatedTime, फ़्लाइट के आखिरी अपडेट का XrTime है.
  • vertexCapacityInput, vertices कलेक्शन की क्षमता है या ज़रूरी क्षमता पाने के अनुरोध के लिए 0.
  • vertexCountOutput, लिखे गए vertices की संख्या का पॉइंटर है. इसके अलावा, अगर vertices की संख्या काफ़ी नहीं है, तो vertexCountOutput ज़रूरी क्षमता का पॉइंटर होता है.
  • vertices, XrVector2f की कैटगरी के ऐरे का पॉइंटर है. अगर vertexCapacityInput 0 है, तो यह NULL हो सकता है. वर्टिक्स, घड़ी की विपरीत दिशा में होते हैं. पॉलीगॉन, अवतल हो सकता है. हालांकि, यह ज़रूरी है कि वह खुद को काटता न हो.
  • ज़रूरी vertices साइज़ को वापस पाने के बारे में पूरी जानकारी के लिए, बफ़र साइज़ पैरामीटर सेक्शन देखें.

मान्य इस्तेमाल (इंप्लिसिट)

  • XrTrackablePlaneANDROID का इस्तेमाल करने से पहले, XR_ANDROID_trackables एक्सटेंशन चालू होना ज़रूरी है
  • type होनी चाहिए XR_TYPE_TRACKABLE_PLANE_ANDROID
  • next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
  • trackingState XrTrackingStateANDROID की वैल्यू मान्य होनी चाहिए
  • planeType की वैल्यू, XrPlaneTypeANDROID की मान्य वैल्यू होनी चाहिए
  • planeLabel XrPlaneLabelANDROID की मान्य वैल्यू होनी ज़रूरी है
  • vertexCountOutput, uint32_t वैल्यू का पॉइंटर होना चाहिए
  • vertices को vertexCapacityInput XrVector2f स्ट्रक्चर के ऐरे का पॉइंटर होना ज़रूरी है
  • vertexCapacityInput पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

XrTrackingStateANDROID एनम, XrTrackableANDROID की ट्रैकिंग स्टेटस के बारे में बताता है. 

typedef enum XrTrackingStateANDROID {
    XR_TRACKING_STATE_PAUSED_ANDROID = 0,
    XR_TRACKING_STATE_STOPPED_ANDROID = 1,
    XR_TRACKING_STATE_TRACKING_ANDROID = 2
} XrTrackingStateANDROID;

XrTrackingStateANDROID

ब्यौरा

XR_TRACKING_STATE_PAUSED_ANDROID

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

XR_TRACKING_STATE_STOPPED_ANDROID

इस ट्रैक किए जा सकने वाले आइटम की ट्रैकिंग बंद कर दी गई है और इसे फिर से शुरू नहीं किया जाएगा.

XR_TRACKING_STATE_TRACKING_ANDROID

ऑब्जेक्ट को ट्रैक किया गया हो और उसकी पोज़िशन मौजूदा हो.

XrPlaneTypeANDROID एनम, XrTrackableANDROID हवाई जहाज़ का टाइप है. 

typedef enum XrPlaneTypeANDROID {
    XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID = 0,
    XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID = 1,
    XR_PLANE_TYPE_VERTICAL_ANDROID = 2,
    XR_PLANE_TYPE_ARBITRARY_ANDROID = 3
} XrPlaneTypeANDROID;

XrPlaneLabelANDROID एनम, XrTrackableANDROID प्लेन के लिए एक लेबल है. 

typedef enum XrPlaneLabelANDROID {
    XR_PLANE_LABEL_UNKNOWN_ANDROID = 0,
    XR_PLANE_LABEL_WALL_ANDROID = 1,
    XR_PLANE_LABEL_FLOOR_ANDROID = 2,
    XR_PLANE_LABEL_CEILING_ANDROID = 3,
    XR_PLANE_LABEL_TABLE_ANDROID = 4
} XrPlaneLabelANDROID;

ऐंकर स्पेस बनाना

XrResult xrCreateAnchorSpaceANDROID(
    XrSession                                   session,
    const XrAnchorSpaceCreateInfoANDROID*       createInfo,
    XrSpace*                                    anchorOutput);

पैरामीटर की जानकारी

  • session वह XrSession है जो ऐंकर स्पेस बनाता है.
  • createInfo, XrAnchorSpaceCreateInfoANDROID स्ट्रक्चर का पॉइंटर है. इसमें ऐसे पैरामीटर होते हैं जिनका इस्तेमाल ऐंकर स्पेस बनाने के लिए किया जाता है.
  • anchorOutput, उस हैंडल का पॉइंटर है जिसमें बनाया गया XrSpace दिखता है.

किसी भी समय, ऐंकर की पोज़िशन और दिशा, दोनों को ट्रैक किया जाता है या ट्रैक नहीं किया जाता. इसका मतलब है कि जब ऐप्लिकेशन anchorOutput के लिए xrLocateSpace या xrLocateSpaces को कॉल करता है, तो XR_SPACE_LOCATION_POSITION_TRACKED_BIT और XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT, दोनों को सेट करना ज़रूरी है या दोनों को हटाना ज़रूरी है.

ऐप्लिकेशन को xrDestroySpace का इस्तेमाल करके, आखिर में वापस किए गए XrSpace को खाली करना ज़रूरी है.

  • अगर सिस्टम में ऐंकर काम नहीं करते, तो XR_ERROR_FEATURE_UNSUPPORTED को दिखाना ज़रूरी है.
  • अगर किसी खास ऐंकर अटैचमेंट का इस्तेमाल नहीं किया जा सकता, तो XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID दिखाया जाना चाहिए.

मान्य इस्तेमाल (इंप्लिसिट)

  • xrCreateAnchorSpaceANDROID को कॉल करने से पहले, XR_ANDROID_trackables एक्सटेंशन चालू होना चाहिए
  • session यह एक मान्य XrSession हैंडल होना चाहिए
  • createInfo एक मान्य XrAnchorSpaceCreateInfoANDROID स्ट्रक्चर का पॉइंटर होना चाहिए
  • anchorOutput, XrSpace हैंडल का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

प्रोसेस पूरी नहीं हो सकी

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_POSE_INVALID
  • XR_ERROR_TIME_INVALID
  • XR_ERROR_OUT_OF_MEMORY

XrAnchorSpaceCreateInfoANDROID स्ट्रक्चर को इस तरह परिभाषित किया गया है: 

typedef struct XrAnchorSpaceCreateInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrSpace               space;
    XrTime                time;
    XrPosef               pose;
    XrTrackableANDROID    trackable;
} XrAnchorSpaceCreateInfoANDROID;

पैसे चुकाकर बने सदस्यों के ब्यौरे

  • type इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर तय नहीं किए गए हैं.
  • space वह XrSpace है जिस पर ऐंकर बनाया जाएगा.
  • time, ऐंकर क्रिएशन का XrTime है.
  • pose, ऐंकर का XrPosef है.
  • trackable वह XrTrackableANDROID है जिस पर ऐंकर अटैच किया जाएगा. स्पेस ऐंकर बनाने के लिए, XR_NULL_TRACKABLE_ANDROID हो सकता है.

मान्य इस्तेमाल (इंप्लिसिट)

सभी ट्रैक किए जा सकने वाले आइटम पाने के लिए कोड का उदाहरण

यहां दिए गए उदाहरण में, किसी खास तरह के सभी ट्रैक किए जा सकने वाले आइटम पाने का तरीका बताया गया है.

XrSession session; // previously initialized

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateTrackableTrackerANDROID xrCreateTrackableTrackerANDROID; // previously initialized
PFN_xrGetAllTrackablesANDROID xrGetAllTrackablesANDROID; // previously initialized
PFN_xrDestroyTrackableTrackerANDROID xrDestroyTrackableTrackerANDROID; // previously initialized

XrTrackableTrackerCreateInfoANDROID createInfo{XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID};
createInfo.trackableType = XR_TRACKABLE_TYPE_PLANE_ANDROID;
XrTrackableTrackerANDROID planeTrackableTracker;
XrResult result = xrCreateTrackableTrackerANDROID(
  session,
  &createInfo,
  &planeTrackableTracker);
if (result != XR_SUCCESS) { /* Handle failures. */ }

uint32_t trackableCountOutput = 0;
std::vector<XrTrackableANDROID> allPlaneTrackables;

// Query the number of trackables available.
result = xrGetAllTrackablesANDROID(
  planeTrackableTracker,
  0,
  &trackableCountOutput,
  nullptr
);

if (result == XR_SUCCESS) {
  allPlaneTrackables.resize(trackableCountOutput, XR_NULL_HANDLE);

  // Fetch the actual trackable handles in the appropriately resized array.
  result = xrGetAllTrackablesANDROID(
    planeTrackableTracker,
    trackableCountOutput,
    &trackableCountOutput,
    allPlaneTrackables.data());

  if (result == XR_SUCCESS) {
    for (XrTrackableANDROID trackable : allPlaneTrackables) {
      // You now have all trackables of the specified type.
    }
  }
}

// Release trackable tracker.
result = xrDestroyTrackableTrackerANDROID(planeTrackableTracker);

ट्रैक किए जा सकने वाले प्लेन की जानकारी पाने के लिए कोड का उदाहरण

यहां दिए गए उदाहरण में, हिट नतीजे XR_ANDROID_raycast या xrGetTrackablesANDROID से मिले मौजूदा XrTrackableANDROID से, ट्रैक किया जा सकने वाला प्लेन पाने का तरीका बताया गया है.

XrTrackableTrackerANDROID planeTracker; // previously created

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrGetTrackablePlaneANDROID xrGetTrackablePlaneANDROID; // previously initialized

XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

XrTrackableGetInfoANDROID planeGetInfo;
planeGetInfo.type = XR_TYPE_TRACKABLE_GET_INFO_ANDROID;
planeGetInfo.next = nullptr;
planeGetInfo.trackable = planeTrackable;
planeGetInfo.space = appSpace;
planeGetInfo.time = updateTime;

XrTrackablePlaneANDROID plane = { XR_TYPE_TRACKABLE_PLANE_ANDROID };
result = xrGetTrackablePlaneANDROID(
  planeTracker,
  &planeGetInfo,
  &plane
);

if (result == XR_SUCCESS) {
  // Plane tracking state, center pose, extents, type now available in plane.
}

ऐंकर स्पेस बनाने के लिए कोड का उदाहरण

यहां दिए गए उदाहरण में, ट्रैक किए जा सकने वाले आइटम से जुड़ा ऐंकर स्पेस बनाने का तरीका बताया गया है.

XrSession session; // Created at app startup.
XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

// Create an anchor at (2, 2, 2) world-coordinates.
XrAnchorSpaceCreateInfoANDROID spatialAnchorCreateInfo;
spatialAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
spatialAnchorCreateInfo.next = nullptr;
spatialAnchorCreateInfo.space = appSpace;
spatialAnchorCreateInfo.time = updateTime;
spatialAnchorCreateInfo.pose = { { 0, 0, 0, 1 }, { 2, 2, 2 } };

XrSpace spatialAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &spatialAnchorCreateInfo,
  &spatialAnchor
);

// Create an anchor attached to a trackable.
XrTrackablePlane plane = ...;
XrAnchorSpaceCreateInfoANDROID trackableAnchorCreateInfo;
trackableAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
trackableAnchorCreateInfo.next = nullptr;
trackableAnchorCreateInfo.space = appState;
trackableAnchorCreateInfo.pose = plane.centerPose;
trackableAnchorCreateInfo.trackable = planeTrackable;

XrSpace trackableAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &trackableAnchorCreateInfo,
  &trackableAnchor
);
while (true) {
  // app update loop
  // ...

  // Get the current location of the anchor's space w.r.t the world.
  XrSpaceLocation anchorLocation = { XR_TYPE_SPACE_LOCATION };
  result = xrLocateSpace(trackableAnchor, appSpace, updateTime, &anchorLocation);

  if (anchor.trackingState == XR_TRACKING_STATE_TRACKING_ANDROID) {
    // Update anchor pose.
    doDrawingForAnchor(anchorLocation.pose);
  } else {
    // ...
  }
}

// Cleanup - destroy the space, detatch the anchor so its no longer tracked by the
// runtime and then release all resources held by it.
xrDestroySpace(spatialAnchor);
xrDestroySpace(trackableAnchor);

नए बेस टाइप

नए ऑब्जेक्ट टाइप

नई Enum Constant

XrStructureType एनोटेशन को इनके साथ जोड़ा गया है:

  • XR_TYPE_TRACKABLE_GET_INFO_ANDROID
  • XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID
  • XR_TYPE_TRACKABLE_PLANE_ANDROID
  • XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID

XrObjectType एनोटेशन को इनके साथ जोड़ा गया है:

  • XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID

XrResult एनोटेशन को इनके साथ जोड़ा गया है:

  • XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID

नए Enums

नए स्ट्रक्चर

नए फ़ंक्शन

समस्याएं

वर्शन का इतिहास

  • पहला बदलाव, 27-09-2024 (केनी वर्कमेयर)
    • एक्सटेंशन का शुरुआती ब्यौरा.