XR_ANDROID_spatial_annotation_tracking

Name String

XR_ANDROID_spatial_annotation_tracking

Uzantı Türü

Örnek uzantısı

Kayıtlı Dahili Numara

795

Düzeltme

1

Onay Durumu

Onaylanmadı

Uzantı ve Sürüm Bağımlılıkları

XR_EXT_spatial_entity
ve
XR_EXT_spatial_image_tracking

Son Değiştirilme Tarihi

2026-01-12

IP Durumu

Bilinen bir fikri mülkiyet hak talebi yok.

Katkıda bulunanlar

Levana Chen, Google
Christopher Feil, Google
Martin Sundermeyer, Google
David Joseph Tan, Google
Jared Finder, Google
Nihav Jain, Google

Genel Bakış

Bu uzantı, sahnedeki çeşitli ek açıklamaları izlemek için XR_EXT_spatial_entity uzantısına ek açıklama izleme özelliği sağlar. Uygulamaların, çalışma zamanı referanslarıyla tanımlanan fiziksel veya sanal nesnelerin üzerine yer paylaşımları eklemesine olanak tanır.

Bu uzantı, tam olarak 4 kenarı olan bir çokgen (ör. dışbükey dörtgen) olan ve çalışma zamanı referansı içinde genelleştirilmiş bir 2D sınırlayıcı kutuyu temsil eden temel bir ek açıklama türü olan "Quad"ı sağlar. İzlenen bir dörtgen not, aşağıdaki bileşenlere sahip bir uzamsal varlık olarak temsil edilir:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Uygulamalar genellikle uzamsal ek açıklama izleme uzantısını aşağıdaki kalıplarda kullanabilir:

  • Uygulama, önce verilen kaynaktan çalışma zamanı referanslarını kaydetmeye başlayan bir XrSpatialReferenceCacheANDROID herkese açık anahtarı oluşturur.
  • Ardından uygulama, XrSpatialReferenceImageEXT'nin çalışma zamanı referansını yakalar ve referans önbelleğinin zaman aralığı boyunca referans içinde istenen bir ek açıklamayı tanımlar.
  • Uygulama daha sonra XrSpatialCapabilityConfigurationAnnotationTrackingANDROID tarafından sağlanan XrSpatialReferenceImageEXT'e göre bir XrSpatialContextEXT herkese açık anahtarı oluşturur.
  • Uygulama, bellek kullanımını azaltmak için çalışma zamanı referanslarını kaydetmeyi durdurmak üzere XrSpatialReferenceCacheANDROID herkese açık kullanıcı adını yok edebilir veya başlatma sonucunu onaylamak için XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID etkinliğini bekleyebilir.
  • Ardından uygulama, ek açıklamanın başlatma sonucunu onaylamak için XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID etkinliğini alır.
  • Başlatma işlemi başarılı olursa uygulama, notu izlemek için XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT etkinliğini çekebilir.
  • Başlatma başarısız olursa uygulama, etkinlikte döndürülen hata kodunu kullanarak hatanın nedenini belirleyebilir ve mevcut XrSpatialContextEXT herkese açık kullanıcı adını silerek yeni bir ek açıklama başlatabilir.
  • Başlatma sonucundan bağımsız olarak uygulama, etkinliği aldıktan sonra bellek kullanımını azaltmak için görüntü arabelleğini serbest bırakabilir.
  • Uygulama, ek açıklamaları mekansal varlık erişim kalıplarına göre keşfeder ve sorgular.
  • Uygulama, geçerli bir XrSpatialReferenceCacheANDROID süresi boyunca yeni bir referanstaki ek açıklamaları izlemek için ek XrSpatialContextEXT herkese açık kullanıcı adı oluşturabilir.
  • Uygulama, çalışma zamanında algılanabilir ve izlenebilir ek açıklama grubunu dinamik olarak azaltmak için XrSpatialContextEXT herkese açık anahtarlarını yok edebilir.

Çalışma Zamanı Desteği

Çalışma zamanı, aşağıdaki özelliği listeleyerek xrEnumerateSpatialCapabilitiesEXT kullanarak ek açıklama izleme özelliğini desteklediğini bildirmelidir:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Çalışma zamanı, ek açıklama izleme özelliğini desteklediğinde:

xrEnumerateSpatialAnnotationReferenceSourcesANDROID işlevi şu şekilde tanımlanır:

XrResult xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    XrSpatialCapabilityEXT                      capability,
    uint32_t                                    sourceCapacityInput,
    uint32_t*                                   sourceCountOutput,
    XrSpatialAnnotationReferenceSourceANDROID*  sources);

Parametre Açıklamaları

  • instance, bir XrInstance için herkese açık kullanıcı adıdır.
  • systemId, referans kaynakları numaralandırılacak XrSystemId değeridir.
  • capability, referans kaynakların numaralandırılacağı XrSpatialCapabilityEXT'tir.
  • sourceCapacityInput, sources dizisinin kapasitesidir veya gerekli kapasiteyi alma isteğini belirtmek için 0'dır.
  • sourceCountOutput, kaynak sayısı veya sourceCapacityInput yetersiz olduğunda gereken kapasitedir.
  • sources, XrSpatialAnnotationReferenceSourceANDROID dizisidir. sourceCapacityInput 0 ise NULL olabilir.
  • Gerekli sources boyutunu alma hakkında ayrıntılı açıklama için Arabellek Boyutu Parametreleri bölümüne bakın.

Uygulama, xrEnumerateSpatialAnnotationReferenceSourcesANDROID kullanarak belirli bir XrSystemId tarafından desteklenen referans kaynaklarının listesini sıralayabilir.

Çalışma zamanı, uzantısı instance için etkinleştirilmemiş referans kaynakları numaralandırmamalıdır.

Geçerli Kullanım (Dolaylı)

Dönüş Kodları

Başarılı

  • XR_SUCCESS

Hata

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_SYSTEM_INVALID
  • XR_ERROR_VALIDATION_FAILURE

typedef enum XrSpatialAnnotationReferenceSourceANDROID {
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID = 0,
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID = 1,
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSpatialAnnotationReferenceSourceANDROID;

XrSpatialAnnotationReferenceSourceANDROID numaralandırması, bir ek açıklamanın meta verilerini sağlayan referansın kaynağını açıklar.

Numaralandırmalar aşağıdaki anlamlara sahiptir:

Enum Açıklaması

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

Referans görsel, Android kamera API'sinden alınan kırpılmamış bir resim çıkışıdır (ör. Camera2 CameraDevice ile ilişkili bir ImageReader'dan alınan resim veya CameraX ile ilişkili bir ImageAnalysis'ten alınan ImageProxy). Bu genellikle ileriye bakan RGB kameralardan biridir.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

Referans görsel, Android MediaProjection API'den alınan kırpılmamış bir resim çıkışıdır (ör. MediaProjection sanal ekranıyla ilişkili bir ImageReader'dan alınan resim). Sanal ve gerçek içerikler barındırabilir.

XrSystemSpatialAnnotationPropertiesANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSystemSpatialAnnotationPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    uint32_t           referenceCacheTimespan;
    uint32_t           maxReferencePixelWidth;
    uint32_t           maxReferencePixelHeight;
    uint32_t           maxReferenceCount;
    uint32_t           maxAnnotationCount;
} XrSystemSpatialAnnotationPropertiesANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir.
  • referenceCacheTimespan, geçerli bir XrSpatialReferenceCacheANDROID tutma yerinin saniye cinsinden süresini gösterir.
  • maxReferencePixelWidth, referans görsellerin kenarının piksel cinsinden maksimum genişliğini gösterir.
  • maxReferencePixelHeight, referans görsellerin kenarının piksel cinsinden maksimum yüksekliğini gösterir.
  • maxReferenceCount, aynı anda tahsis edilecek maksimum referans görsel sayısını gösterir.
  • maxAnnotationCount, aynı anda izlenecek maksimum ek açıklama sayısını gösterir.

Çalışma zamanı, ek açıklama izleme özelliğini desteklediğinde uygulama, xrGetSystemProperties işlevini çağırırken XrSystemProperties'e bir XrSystemSpatialAnnotationPropertiesANDROID yapısı zincirleyerek ilgili sistem özelliklerini inceleyebilir.

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference içindeki XrSpatialReferenceImageEXT :: width, maxReferencePixelWidth değerini aşarsa çalışma zamanı, xrCreateSpatialContextAsyncEXT çağrılırken XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir.

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference içindeki XrSpatialReferenceImageEXT :: height, maxReferencePixelHeight değerini aşarsa çalışma zamanı, xrCreateSpatialContextAsyncEXT çağrılırken XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir.

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time, XrSpatialReferenceCacheANDROID :: cache zaman aralığının dışındaysa çalışma zamanı, xrCreateSpatialContextAsyncEXT çağrılırken XR_ERROR_TIME_INVALID değerini döndürmelidir . Uygulama, XrSpatialReferenceCacheANDROID süresi boyunca XrSpatialContextEXT herkese açık kullanıcı adını yeni bir referansla yeniden oluşturabilir (can).

Ayrılan referans görsellerin sayısı maxReferenceCount değerini aşarsa çalışma zamanı XR_ERROR_LIMIT_REACHED değerini döndürmeli ve XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult aracılığıyla başlatma hatasını belirtmelidir. Uygulama, XrSpatialContextEXT herkese açık anahtarını yok edebilir ve bekleyen başlatma işlemi tamamlandıktan sonra tekrar deneyebilir.

Etkin ek açıklamaların sayısı maxAnnotationCount değerini aşarsa çalışma zamanı, xrCreateSpatialContextAsyncEXT çağrılırken XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir .

Geçerli Kullanım (Dolaylı)

Çalışma zamanı referans önbelleği

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

XrSpatialReferenceCacheANDROID herkese açık kullanıcı adı, belirli bir kaynaktan kaydedilen çalışma zamanı referanslarının önbelleğini temsil eder.

xrCreateSpatialReferenceCacheAsyncANDROID işlevi şu şekilde tanımlanır:

XrResult xrCreateSpatialReferenceCacheAsyncANDROID(
    XrSession                                   session,
    const XrSpatialReferenceCacheCreateInfoANDROID* createInfo,
    XrFutureEXT*                                future);

Parametre Açıklamaları

  • session, referans önbelleğinin etkin olacağı bir XrSession'dır.
  • createInfo, referans önbellek parametrelerini belirtmek için kullanılan bir XrSpatialReferenceCacheCreateInfoANDROID işaretçisidir.
  • future, bir XrFutureEXT çıkış tutamacının işaretçisidir.

Uygulama, xrCreateSpatialReferenceCacheAsyncANDROID işlevini çağırarak XrSpatialReferenceCacheANDROID herkese açık kullanıcı adı oluşturabilir. Çalışma zamanının izleme hizmetlerini başlatması biraz zaman alabilir. Uygulama daha sonra bu eşzamansız işlemin tamamlanıp tamamlanmadığını kontrol etmek için xrCreateSpatialReferenceCacheCompleteANDROID'i tekrar tekrar çağırabilir.

XrSpatialReferenceCacheCreateInfoANDROID :: capability, xrEnumerateSpatialCapabilitiesEXT tarafından listelenmiyorsa çalışma zamanı XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT değerini döndürmelidir (must).

XrSpatialReferenceCacheCreateInfoANDROID :: source, belirtilen özellik için xrEnumerateSpatialAnnotationReferenceSourcesANDROID tarafından listelenmiyorsa çalışma zamanı XR_ERROR_FEATURE_UNSUPPORTED değerini döndürmelidir (must).

Uygulama, belirli bir özellik için kaynak başına yalnızca bir tutma yeri oluşturabilir. Aksi takdirde çalışma zamanı XR_ERROR_LIMIT_REACHED değerini döndürmelidir (must).

Uygulama daha sonra yeni bir XrSpatialContextEXT herkese açık kullanıcı adını yapılandırmak için XrSpatialReferenceCacheANDROID herkese açık kullanıcı adının zaman aralığı boyunca çalışma zamanı referanslarını yakalayabilir.

Geçerli Kullanım (Dolaylı)

Dönüş Kodları

Başarılı

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Hata

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

XrSpatialReferenceCacheCreateInfoANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialReferenceCacheCreateInfoANDROID {
    XrStructureType                              type;
    const void*                                  next;
    XrSpatialCapabilityEXT                       capability;
    XrSpatialAnnotationReferenceSourceANDROID    source;
} XrSpatialReferenceCacheCreateInfoANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir. Temel OpenXR'da veya bu uzantıda bu tür yapılar tanımlanmamıştır.
  • capability, referans önbelleğin hangi özellik için oluşturulduğunu açıklayan bir XrSpatialCapabilityEXT'dir.
  • source, referans önbelleğinin kaynağını açıklayan bir XrSpatialAnnotationReferenceSourceANDROID'dir.

XrSpatialReferenceCacheCreateInfoANDROID yapısı, XrSpatialReferenceCacheANDROID herkese açık kullanıcı adını oluşturmak için gereken bilgileri açıklar.

Geçerli Kullanım (Dolaylı)

xrCreateSpatialReferenceCacheCompleteANDROID işlevi şu şekilde tanımlanır:

XrResult xrCreateSpatialReferenceCacheCompleteANDROID(
    XrSession                                   session,
    XrFutureEXT                                 future,
    XrCreateSpatialReferenceCacheCompletionANDROID* completion);

Parametre Açıklamaları

Uygulama, xrCreateSpatialReferenceCacheAsyncANDROID tarafından başlatılan eşzamansız işlemin tamamlanmasını beklemek için xrCreateSpatialReferenceCacheCompleteANDROID'i çağırabilir.

future hazır durumda değilse çalışma zamanı XR_ERROR_FUTURE_PENDING_EXT değerini döndürmelidir (must). future zaten tamamlanmış veya iptal edilmişse çalışma zamanı XR_ERROR_FUTURE_INVALID_EXT değerini döndürmelidir (must).

Geçerli Kullanım (Dolaylı)

Dönüş Kodları

Başarılı

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Hata

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

XrCreateSpatialReferenceCacheCompletionANDROID yapısı şu şekilde tanımlanır:

typedef struct XrCreateSpatialReferenceCacheCompletionANDROID {
    XrStructureType                   type;
    void*                             next;
    XrResult                          futureResult;
    XrSpatialReferenceCacheANDROID    referenceCache;
} XrCreateSpatialReferenceCacheCompletionANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir. Temel OpenXR'da veya bu uzantıda bu tür yapılar tanımlanmamıştır.
  • futureResult, referans önbellek oluşturma işleminin XrResult değeridir.
  • İşlem başarılı olursa referenceCache, XrSpatialReferenceCacheANDROID herkese açık anahtarıdır.

Gelecekteki İade Kodları

futureResult değer:

Başarılı

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Hata

  • XR_ERROR_FEATURE_UNSUPPORTED
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED

futureResult bir başarı koduysa çalışma zamanı geçerli bir referenceCache tanıtıcısı döndürmelidir. referenceCache geçerliyse yalnızca xrCreateSpatialReferenceCacheAsyncANDROID :: session geçerlilik süresi boyunca veya uygulama, xrDestroySpatialReferenceCacheANDROID ile herkese açık anahtarı imha edene kadar (hangisi önce gerçekleşirse) geçerli kalır.

referenceCache geçerli olduğunda, XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan içindeki önbellekleri kaydeder.

Geçerli Kullanım (Dolaylı)

xrDestroySpatialReferenceCacheANDROID işlevi şu şekilde tanımlanır:

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Parametre Açıklamaları

Uygulama, uzamsal bağlam oluşturma işlemi tamamlandığında cacheHandle tutamacını ve temel kaynakları serbest bırakmak için xrDestroySpatialReferenceCacheANDROID işlevini çağırabilir.

Geçerli Kullanım (Dolaylı)

İleti Dizisi Güvenliği

  • cacheHandle ve tüm alt herkese açık kullanıcı adlarına erişim harici olarak senkronize edilmelidir.

Dönüş Kodları

Başarılı

  • XR_SUCCESS

Hata

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Yapılandırma

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialCapabilityConfigurationAnnotationTrackingANDROID {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
    XrSpatialReferenceCacheANDROID      cache;
    XrTime                              time;
    XrSpatialReferenceImageEXT          reference;
} XrSpatialCapabilityConfigurationAnnotationTrackingANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir.
  • capability, bir XrSpatialCapabilityEXT'tir ve XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID olmalıdır.
  • enabledComponentCount, enabledComponents dizisindeki öğe sayısını açıklayan bir uint32_t değeridir.
  • enabledComponents, XrSpatialComponentTypeEXT dizisine işaret eden bir göstergedir.
  • cache, reference yapılandırması için çalışma zamanı referanslarını kaydetmek üzere daha önce oluşturulmuş bir XrSpatialReferenceCacheANDROID'dir.
  • time, reference değerinin yakalandığı XrTime değeridir.
  • reference, sonraki işaretçisine zincirlenmiş ek açıklamalar içeren bir XrSpatialReferenceImageEXT'tir.

Uygulamalar, XrSpatialContextCreateInfoEXT :: capabilityConfigs içindeki XrSpatialCapabilityConfigurationAnnotationTrackingANDROID yapısına bir işaretçi ekleyerek XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID uzamsal özelliğini etkinleştirebilir.

capability, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID değilse çalışma zamanı XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir.

reference herhangi bir ek açıklama içermiyorsa çalışma zamanı XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT değerini döndürmelidir (must).

Ek açıklama bileşeni enabledComponents içinde listelenmişse ancak reference ile ilişkili ek açıklama yoksa çalışma zamanı XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT değerini döndürmelidir.

cache, xrCreateSpatialContextAsyncEXT'e iletilen aynı XrSession'a ait değilse çalışma zamanı XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir.

time, cache zaman aralığının dışındaysa çalışma zamanı XR_ERROR_TIME_INVALID değerini döndürmelidir (must).

Geçerli Kullanım (Dolaylı)

Ek Açıklama İzleme Etkinlikleri

XrEventDataSpatialAnnotationTrackingANDROID yapısı şu şekilde tanımlanır:

typedef struct XrEventDataSpatialAnnotationTrackingANDROID {
    XrStructureType        type;
    const void*            next;
    XrSpatialContextEXT    spatialContext;
    uint32_t               annotationIndex;
    XrResult               initializationResult;
} XrEventDataSpatialAnnotationTrackingANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir.
  • spatialContext, ek açıklama izlemeyi etkinleştiren XrSpatialContextEXT'tir.
  • annotationIndex, XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference ile ilişkili ek açıklama dizisindeki dizine eşlenir.
  • initializationResult, ek açıklamanın başlatma sonucunu gösterir. XR_SUCCESS değilse uygulama, notu yeniden başlatmak için XrSpatialContextEXT herkese açık anahtarını silip yeniden oluşturabilir veya diğer notları izlemek için spatialContext kullanmaya devam edebilir.

Geçerli Kullanım (Dolaylı)

Çalışma zamanı, başlatma işleminin tamamlandığını belirtmek için her ek açıklama için XrEventDataSpatialAnnotationTrackingANDROID'i doldurmalıdır. Başlatma sonucundan bağımsız olarak uygulama, etkinliği aldıktan sonra bellek kullanımını azaltmak için görüntü arabelleğini serbest bırakabilir.

Ek açıklama başarıyla başlatılırsa çalışma zamanı, initializationResult değerini XR_SUCCESS ile doldurmalıdır. Uygulama daha sonra ek açıklamayı izlemek için XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT etkinliğini çekebilir.

Aksi takdirde çalışma zamanı, hata nedenini belirtmek için initializationResult değerini uygun bir hata koduyla doldurmalıdır. Uygulama, yeni bir not eklemeye başlamak için XrSpatialContextEXT herkese açık anahtarını yok edebilir veya diğer notları izlemek için spatialContext kullanmaya devam edebilir.

Dörtlü Ek Açıklama

Çalışma zamanı, aşağıdaki bileşen türünü listeleyerek xrEnumerateSpatialCapabilityComponentTypesEXT kullanarak dörtlü ek açıklamalar için desteğini bildirmelidir:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Dörtlü Referans

XrSpatialAnnotationQuadReferenceANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialAnnotationQuadReferenceANDROID {
    XrStructureType                          type;
    const void*                              next;
    uint32_t                                 quadCount;
    const XrSpatialAnnotationQuadANDROID*    quads;
} XrSpatialAnnotationQuadReferenceANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir.
  • quadCount, quads dizisindeki öğe sayısını açıklayan bir uint32_t değeridir.
  • quads, XrSpatialAnnotationQuadANDROID dizisinin işaretçisidir.

Çalışma zamanı dörtgen ek açıklamaları desteklediğinde, bir uygulama XrSpatialAnnotationQuadReferenceANDROID yapısını XrSpatialReferenceImageEXT :: next'ya zincirleyerek ek açıklamaları yapılandırabilir ve XrSpatialContextEXT tutamacını oluştururken referansı XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference olarak ayarlayabilir.

quadCount 0 ise çalışma zamanı, xrCreateSpatialContextAsyncEXT'ten XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT değerini döndürmelidir.

Geçerli Kullanım (Dolaylı)

XrSpatialAnnotationQuadANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialAnnotationQuadANDROID {
    XrSpatialAnnotationQuadAlignmentANDROID    alignment;
    XrVector2f                                 upperLeft;
    XrVector2f                                 upperRight;
    XrVector2f                                 lowerRight;
    XrVector2f                                 lowerLeft;
} XrSpatialAnnotationQuadANDROID;

Üye Açıklamaları

  • alignment, dörtgenin XrSpatialAnnotationQuadAlignmentANDROID değeridir.
  • upperLeft, başlangıç noktasıyla ilgili dörtgenin sol üst köşesinin koordinatını açıklayan bir XrVector2f'dir.
  • upperRight, başlangıç noktasıyla ilgili olarak dörtgenin sağ üst köşesinin koordinatını açıklayan bir XrVector2f değeridir.
  • lowerRight, başlangıç noktasıyla ilgili olarak dörtgenin sağ alt köşesinin koordinatını açıklayan bir XrVector2f'dir.
  • lowerLeft, orijine göre dörtgenin sol alt köşesinin koordinatını açıklayan bir XrVector2f'dir.

2D uzaydaki bir dörtgen, saat yönünde sıralanmış dışbükey bir dörtgendir. 4 köşenin değeri, dörtgenin ilişkilendirildiği orijin (0, 0) ile ilgilidir.

Geçerli Kullanım (Dolaylı)

typedef enum XrSpatialAnnotationQuadAlignmentANDROID {
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID = 0,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID = 1,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID = 2,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSpatialAnnotationQuadAlignmentANDROID;

XrSpatialAnnotationQuadAlignmentANDROID sıralaması, dörtgen notun hizalamasını açıklar.

Numaralandırmalar aşağıdaki anlamlara sahiptir:

Enum Açıklaması

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

Ek açıklama dörtgeni, ekran düzlemine paraleldir ve düzlem içi dönüşü dünya yerçekimine kilitli kalır. Çıkış, normal ve dikey bir sınırlayıcı kutu olarak görünür.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

Not dörtgeni doğrudan nesneye sabitlenir ve referans resimde tanımlanan hizalamayla eşleşir. Çıkış, şeklini nesnenin perspektifine uyacak şekilde ayarlayan dışbükey bir dörtgendir.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

İzlenen hedefin düzlemsel bir nesne veya yüzey olduğu varsayıldığında, ek açıklama dörtgeni, temel nesnenin yüzeyiyle aynı düzlemdedir. Çıktı, nesnenin fiziksel geometrisiyle sorunsuz bir şekilde uyum sağlar ve perspektifini söz konusu yüzeye düz bir şekilde oturacak şekilde ayarlar.

Dörtlü Bileşenler

XrSpatialAnnotationQuadDataANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialAnnotationQuadDataANDROID {
    uint32_t                          annotationIndex;
    XrSpaceLocationData               origin;
    XrSpatialAnnotationQuadANDROID    quad;
} XrSpatialAnnotationQuadDataANDROID;

Üye Açıklamaları

Geçerli Kullanım (Dolaylı)

XrSpatialComponentAnnotationQuadListANDROID yapısı şu şekilde tanımlanır:

typedef struct XrSpatialComponentAnnotationQuadListANDROID {
    XrStructureType                        type;
    void*                                  next;
    uint32_t                               quadCount;
    XrSpatialAnnotationQuadDataANDROID*    quads;
} XrSpatialComponentAnnotationQuadListANDROID;

Üye Açıklamaları

  • type, bu yapının XrStructureType değeridir.
  • next, NULL veya bir yapı zincirindeki sonraki yapıya işaret eden bir göstergedir.
  • quadCount, quads dizisindeki öğe sayısını açıklayan bir uint32_t değeridir.
  • quads, XrSpatialAnnotationQuadDataANDROID dizisidir.

Uygulama, XrSpatialComponentDataQueryConditionEXT :: componentTypes içine XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID ekleyerek ve XrSpatialComponentDataQueryResultEXT'nin sonraki işaretçi zincirine XrSpatialComponentAnnotationQuadListANDROID ekleyerek XrSpatialSnapshotEXT'teki uzamsal varlıkların dörtlü ek açıklama bileşenini sorgulayabilir.

XrSpatialComponentAnnotationQuadListANDROID, XrSpatialComponentDataQueryResultEXT :: next öğesinin sonraki zincirindeyse ancak XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID, XrSpatialComponentDataQueryConditionEXT :: componentTypes öğesine dahil değilse çalışma zamanı, xrQuerySpatialComponentDataEXT öğesinden XR_ERROR_VALIDATION_FAILURE değerini döndürmelidir.

quadCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput değerinden küçükse çalışma zamanı, xrQuerySpatialComponentDataEXT'ten XR_ERROR_SIZE_INSUFFICIENT değerini döndürmelidir.

Geçerli Kullanım (Dolaylı)

Örnek Kod

Çalışma zamanı desteğini kontrol etme

Aşağıdaki örnek kodda, çalışma zamanının ek açıklama izleme özelliğini destekleyip desteklemediğinin nasıl kontrol edileceği gösterilmektedir.

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL

PFN_xrEnumerateSpatialCapabilitiesEXT xrEnumerateSpatialCapabilitiesEXT;
PFN_xrEnumerateSpatialAnnotationReferenceSourcesANDROID xrEnumerateSpatialAnnotationReferenceSourcesANDROID;
PFN_xrEnumerateSpatialReferenceImageFormatsEXT xrEnumerateSpatialReferenceImageFormatsEXT;
PFN_xrEnumerateSpatialCapabilityComponentTypesEXT xrEnumerateSpatialCapabilityComponentTypesEXT;

// Check spatial annotation tracking capability
uint32_t capabilityCount;
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, 0,
                                         &capabilityCount, nullptr));
std::vector<XrSpatialCapabilityEXT> capabilities(capabilityCount);
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, capabilityCount,
                                         &capabilityCount,
                                         capabilities.data()));
if (std::find(capabilities.begin(), capabilities.end(),
              XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID) ==
    capabilities.end()) {
  // System does not support spatial annotation tracking.
  return;
}

// Inspect system properties for annotation tracking variables
XrSystemSpatialAnnotationPropertiesANDROID annotationSystemProperties{
    XR_TYPE_SYSTEM_SPATIAL_ANNOTATION_PROPERTIES_ANDROID};
XrSystemProperties systemProperties{.type = XR_TYPE_SYSTEM_PROPERTIES,
                                    .next = &annotationSystemProperties,
                                    .systemId = systemId};
CHK_XR(xrGetSystemProperties(instance, systemId, &systemProperties));
if (annotationSystemProperties.maxAnnotationCount == 0) {
  // System does not support any active annotations.
  return;
}

// Enumerate supported reference sources
uint32_t sourceCountOutput = 0;
XrSpatialAnnotationReferenceSourceANDROID desiredSource =
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID;
CHK_XR(xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    0, &sourceCountOutput, nullptr));
std::vector<XrSpatialAnnotationReferenceSourceANDROID> sources(sourceCountOutput);
CHK_XR(xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    sourceCountOutput, &sourceCountOutput, sources.data()));
if (std::find(sources.begin(), sources.end(), desiredSource) == sources.end()) {
  // The desired source is not supported.
  return;
}

// Enumerate supported reference image formats, provided by XR_EXT_spatial_image_tracking.
uint32_t formatCountOutput = 0;
XrSpatialReferenceImageFormatEXT desiredFormat =
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT; // Or XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT for screenshot.
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID, 0,
    &formatCountOutput, nullptr));
std::vector<XrSpatialReferenceImageFormatEXT> formats(formatCountOutput);
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    formats.size(), &formatCountOutput, formats.data()));
if (std::find(formats.begin(), formats.end(), desiredFormat) == formats.end()) {
  // The desired format is not supported
  return;
}

// Enumerate supported components for annotation tracking capability.
XrSpatialCapabilityComponentTypesEXT capabilityComponentTypes{
    XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT};
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    &capabilityComponentTypes));
std::vector<XrSpatialComponentTypeEXT>
    annotationTypes(capabilityComponentTypes.componentTypeCountOutput);
capabilityComponentTypes.componentTypeCapacityInput = annotationTypes.size();
capabilityComponentTypes.componentTypes = annotationTypes.data();
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    &capabilityComponentTypes));

// Check supported annotation components.
XrSpatialComponentTypeEXT desiredComponent =
    XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID;
const auto supportedComponent = [&annotationTypes](
                                    XrSpatialComponentTypeEXT component) {
  return std::find(annotationTypes.begin(), annotationTypes.end(), component) !=
         annotationTypes.end();
};
if (!supportedComponent(desiredComponent)) {
  // The desired annotation is not supported.
  return;
}

Dörtgen notu yapılandırma

Aşağıdaki örnek kodda, dörtgen ek açıklamanın nasıl yapılandırılacağı gösterilmektedir.

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL

PFN_xrCreateSpatialReferenceCacheAsyncANDROID xrCreateSpatialReferenceCacheAsyncANDROID;
PFN_xrCreateSpatialReferenceCacheCompleteANDROID xrCreateSpatialReferenceCacheCompleteANDROID;
PFN_xrDestroySpatialReferenceCacheANDROID xrDestroySpatialReferenceCacheANDROID;
PFN_xrCreateSpatialContextAsyncEXT xrCreateSpatialContextAsyncEXT;
PFN_xrCreateSpatialContextCompleteEXT xrCreateSpatialContextCompleteEXT;
void (*waitUntilReady)(XrFutureEXT);

XrSpatialReferenceImageFormatEXT desiredFormat;
XrSpatialAnnotationReferenceSourceANDROID desiredSource;
XrSpatialComponentTypeEXT desiredComponent;

// Create and start reference cache to prepare for capturing reference images.
XrSpatialReferenceCacheANDROID referenceCache;
XrSpatialReferenceCacheCreateInfoANDROID cacheCreateInfo{
  .type = XR_TYPE_SPATIAL_REFERENCE_CACHE_CREATE_INFO_ANDROID,
  .next = nullptr,
  .capability = XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
  .source = desiredSource,
};
XrFutureEXT cacheFuture = XR_NULL_FUTURE_EXT;
CHK_XR(xrCreateSpatialReferenceCacheAsyncANDROID(session, &cacheCreateInfo, &cacheFuture));

waitUntilReady(cacheFuture);

XrCreateSpatialReferenceCacheCompletionANDROID cacheCompletion{
    XR_TYPE_CREATE_SPATIAL_REFERENCE_CACHE_COMPLETION_ANDROID};
CHK_XR(xrCreateSpatialReferenceCacheCompleteANDROID(session, cacheFuture,
                                                     &cacheCompletion));
if (cacheCompletion.futureResult != XR_SUCCESS) {
  // Error, reference cache creation failed
  return;
}

referenceCache = cacheCompletion.referenceCache;

// Create the reference image with quad annotations

//  YUV 4:2:0 Planar:
// ----------------------
// |     Y      |Cb |Cr |
// ----------------------
XrSpatialReferenceImagePlaneEXT cameraImagePlanes[3];
// for each plane (0=Y, 1=U(cb), 2=V(Cr)) return by Image#getPlanes().
for (int i = 0; i < 3; ++i) {
  cameraImagePlanes[i].buffer; // read from Plane#getBuffer().
  cameraImagePlanes[i].bufferSize; // set each buffer size. Y = width * height (bytes); U = Y / 4 (bytes); V = Y / 4 (bytes).
  cameraImagePlanes[i].rowStride; // read from Plane#getRowStride().
  cameraImagePlanes[i].pixelStride; // read from Plane#getPixelStride().
}
XrSpatialReferenceImageEXT referenceImage{
      XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT};
referenceImage.width = 640;
referenceImage.height = 480;
referenceImage.format = desiredFormat;
referenceImage.planeCount = 3;
referenceImage.planes = cameraImagePlanes;

XrSpatialAnnotationQuadANDROID
    quad; // quad coordinates within the reference image.
quad.alignment = XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID;
// Set unnormalized pixel coordinates of 4 corners.
quad.upperLeft = {0.0, 0.0};
quad.upperRight = {0.0, 100.0};
quad.lowerRight = {100.0, 100.0};
quad.lowerLeft = {0.0, 100.0};

XrSpatialAnnotationQuadReferenceANDROID quadReference{
    XR_TYPE_SPATIAL_ANNOTATION_QUAD_REFERENCE_ANDROID};
quadReference.quads = &quad;
quadReference.quadCount = 1;
referenceImage.next = &quadReference;

// Create the spatial context with annotation configuration.
XrSpatialContextEXT spatialContext{};
{
  const std::array<XrSpatialComponentTypeEXT, 1> enabledComponents = {
      desiredComponent,
  };

  // Configure annotation tracking
  XrSpatialCapabilityConfigurationAnnotationTrackingANDROID annotationConfig{
      XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANNOTATION_TRACKING_ANDROID};
  annotationConfig.capability =
      XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID;
  annotationConfig.enabledComponentCount = enabledComponents.size();
  annotationConfig.enabledComponents = enabledComponents.data();
  annotationConfig.cache = referenceCache;
  annotationConfig.time; // The time when this reference image is captured.
  annotationConfig.reference = referenceImage;

  std::vector<XrSpatialCapabilityConfigurationBaseHeaderEXT *>
      capabilityConfigs;
  capabilityConfigs.push_back(
      reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT *>(
          &annotationConfig));

  XrSpatialContextCreateInfoEXT spatialContextCreateInfo{
      XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
  spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
  spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();

  XrFutureEXT createContextFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialContextAsyncEXT(session, &spatialContextCreateInfo,
                                        &createContextFuture));

  waitUntilReady(createContextFuture);

  XrCreateSpatialContextCompletionEXT completion{
      XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialContextCompleteEXT(session, createContextFuture,
                                           &completion));
  if (completion.futureResult != XR_SUCCESS) {
    // Error, spatial context creation failed
    return;
  }

  spatialContext = completion.spatialContext;
  CHK_XR(xrDestroySpatialReferenceCacheANDROID(referenceCache));
}

Etkin notları keşfetme

Aşağıdaki örnek kodda, ek açıklamaların nasıl bulunacağı ve sorgulanacağı gösterilmektedir.

XrInstance instance;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL
XrSpatialContextEXT spatialContext; // previously created

PFN_xrCreateSpatialDiscoverySnapshotAsyncEXT xrCreateSpatialDiscoverySnapshotAsyncEXT;
PFN_xrCreateSpatialDiscoverySnapshotCompleteEXT xrCreateSpatialDiscoverySnapshotCompleteEXT;
PFN_xrQuerySpatialComponentDataEXT xrQuerySpatialComponentDataEXT;
PFN_xrDestroySpatialSnapshotEXT xrDestroySpatialSnapshotEXT;
PFN_xrPollEvent xrPollEvent;
PFN_xrDestroySpatialContextEXT xrDestroySpatialContextEXT;
void (*waitUntilReady)(XrFutureEXT);

XrSpatialComponentTypeEXT desiredComponent; // e.g. XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

auto discoverAnnotations = [&](XrSpatialContextEXT spatialContext, XrTime time,
                               XrSpace baseSpace) {
  std::array<XrSpatialComponentTypeEXT, 1> snapshotComponents{desiredComponent};
  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{
      XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  XrFutureEXT discoveryFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(
      spatialContext, &snapshotCreateInfo, &discoveryFuture));

  waitUntilReady(discoveryFuture);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{
      XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = baseSpace;
  completionInfo.time = time;
  completionInfo.future = discoveryFuture;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{
      XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(
      spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {
    // Query for desired annotation data, e.g. quad.
    XrSpatialComponentTypeEXT componentsToQuery[] = {
        XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID};
    XrSpatialComponentDataQueryConditionEXT queryCond{
        XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypeCount = 1;
    queryCond.componentTypes = componentsToQuery;
    XrSpatialComponentDataQueryResultEXT queryResult{
        XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond,
                                          &queryResult));

    std::vector<XrSpatialEntityIdEXT> entityIds(
        queryResult.entityIdCountOutput);
    std::vector<XrSpatialEntityTrackingStateEXT> entityStates(
        queryResult.entityStateCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialAnnotationQuadDataANDROID> quads(
        queryResult.entityIdCountOutput);
    XrSpatialComponentAnnotationQuadListANDROID quadList{
        XR_TYPE_SPATIAL_COMPONENT_ANNOTATION_QUAD_LIST_ANDROID};
    quadList.quadCount = quads.size();
    quadList.quads = quads.data();
    queryResult.next = &quadList;

    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond,
                                          &queryResult));

    for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
      if (entityStates[i] == XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT) {
        const XrSpatialAnnotationQuadDataANDROID &currentQuad = quads[i];
        // Rendering quad in the view.
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // For every frame in frame loop

  XrSpace space;           // Application's play space.
  XrFrameState frameState; // Previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;

  // Poll for the XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT event
  XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
  XrResult result = xrPollEvent(instance, &event);
  if (result == XR_SUCCESS) {
    switch (event.type) {
    case XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID: {
      const XrEventDataSpatialAnnotationTrackingANDROID &eventdata =
          *reinterpret_cast<XrEventDataSpatialAnnotationTrackingANDROID *>(
              &event);
      if (eventdata.initializationResult != XR_SUCCESS) {
        // handle initialization failure.
        // e.g. CHK_XR(xrDestroySpatialContextEXT(spatialContext));
      }
      break;
    }
    case XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT: {
      const XrEventDataSpatialDiscoveryRecommendedEXT &eventdata =
          *reinterpret_cast<XrEventDataSpatialDiscoveryRecommendedEXT *>(
              &event);
      // Discover spatial entities for the context that we received the
      // "discovery recommended" event for.
      //discoverSpatialEntities(eventdata.spatialContext, time, space);
      break;
    }
    }
  }

  // Finish frame loop
}

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

Yeni nesne türleri

Yeni Komutlar

Yeni Yapılar

Yeni Enum Veri Türleri

Yeni Enum Sabitleri

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • XrObjectType'i genişletme:

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • XrSpatialCapabilityEXT'yi genişletme:

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • XrSpatialComponentTypeEXT'yi genişletme:

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

  • XrStructureType'ı genişletme:

    • XR_TYPE_CREATE_SPATIAL_REFERENCE_CACHE_COMPLETION_ANDROID
    • XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID
    • XR_TYPE_SPATIAL_ANNOTATION_QUAD_REFERENCE_ANDROID
    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANNOTATION_TRACKING_ANDROID
    • XR_TYPE_SPATIAL_COMPONENT_ANNOTATION_QUAD_LIST_ANDROID
    • XR_TYPE_SPATIAL_REFERENCE_CACHE_CREATE_INFO_ANDROID
    • XR_TYPE_SYSTEM_SPATIAL_ANNOTATION_PROPERTIES_ANDROID

Sayılar

Sürüm Geçmişi

  • Düzeltme 1, 17.09.2025 (Levana Chen)

    • İlk uzantı açıklaması.