XR_ANDROID_spatial_annotation_tracking

이름 문자열

XR_ANDROID_spatial_annotation_tracking

확장 프로그램 유형

인스턴스 확장 프로그램

등록된 내선 번호

795

버전

1

승인 상태

비준되지 않음

확장 프로그램 및 버전 종속 항목

XR_EXT_spatial_entity
및
XR_EXT_spatial_image_tracking

최종 수정일

2026-01-12

IP 상태

알려진 IP 소유권 주장이 없습니다.

도움을 주신 분들

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

개요

이 확장 프로그램은 XR_EXT_spatial_entity 확장 프로그램에 주석 추적 기능을 제공하여 장면의 다양한 주석을 추적합니다. 애플리케이션이 런타임 참조로 정의된 실제 또는 가상 객체에 오버레이를 배치할 수 있습니다.

이 확장 프로그램은 기본 주석 유형 'Quad'를 제공합니다. 이는 정확히 4개의 변이 있는 다각형, 즉 런타임 참조 내에서 일반화된 2D 경계 상자를 나타내는 볼록 사각형입니다. 추적된 쿼드 주석은 다음 구성요소가 있는 공간 항목으로 표현됩니다.

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

애플리케이션은 일반적으로 다음과 같은 패턴으로 공간 주석 추적 확장 프로그램을 사용할 수 있습니다.

  • 애플리케이션은 먼저 지정된 소스에서 런타임 참조를 기록하기 시작하는 XrSpatialReferenceCacheANDROID 핸들을 만듭니다.
  • 그런 다음 애플리케이션은 XrSpatialReferenceImageEXT의 런타임 참조를 캡처하고 참조 캐시의 기간 내에 참조 내에서 원하는 주석을 정의합니다.
  • 그런 다음 애플리케이션은 XrSpatialCapabilityConfigurationAnnotationTrackingANDROID에서 제공하는 XrSpatialReferenceImageEXT를 기반으로 XrSpatialContextEXT 핸들을 만듭니다.
  • 애플리케이션은 XrSpatialReferenceCacheANDROID 핸들을 폐기하여 런타임 참조 기록을 중지하고 메모리 사용량을 줄이거나 XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID 이벤트를 기다려 초기화 결과를 확인할 수 있습니다.
  • 그런 다음 애플리케이션은 XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID 이벤트를 가져와 주석의 초기화 결과를 확인합니다.
  • 초기화가 성공하면 애플리케이션은 XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT 이벤트를 가져와 주석을 추적할 수 있습니다.
  • 초기화에 실패하면 애플리케이션은 이벤트에서 반환된 오류 코드를 사용하여 실패 원인을 확인하고 기존 XrSpatialContextEXT 핸들을 삭제하여 새 주석을 시작할 수 있습니다.
  • 초기화 결과와 관계없이 애플리케이션은 이벤트를 수신한 후 이미지 버퍼를 해제하여 메모리 사용량을 줄일 수 있습니다.
  • 애플리케이션은 공간 엔티티 액세스 패턴에 따라 주석을 검색하고 쿼리합니다.
  • 애플리케이션은 유효한 XrSpatialReferenceCacheANDROID 기간 동안 새 참조 내에서 주석을 추적하기 위해 추가 XrSpatialContextEXT 핸들을 만들 수 있습니다.
  • 애플리케이션은 XrSpatialContextEXT 핸들을 소멸시켜 런타임에 감지 및 추적 가능한 주석 집합을 동적으로 줄일 수 있습니다.

런타임 지원

런타임은 다음 기능을 나열하여 xrEnumerateSpatialCapabilitiesEXT를 사용하는 주석 추적 기능에 대한 지원을 알려야 합니다(must).

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

런타임이 주석 추적 기능을 지원하는 경우:

xrEnumerateSpatialAnnotationReferenceSourcesANDROID 함수는 다음과 같이 정의됩니다.

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

파라미터 설명

  • instance은 XrInstance의 핸들입니다.
  • systemId는 참조 소스가 열거될 XrSystemId입니다.
  • capability는 참조 소스가 열거될 XrSpatialCapabilityEXT입니다.
  • sourceCapacityInput는 sources 배열의 용량입니다. 필요한 용량을 가져오라는 요청을 나타내려면 0으로 설정합니다.
  • sourceCountOutput는 소스 수 또는 sourceCapacityInput가 부족한 경우 필요한 용량입니다.
  • sources는 XrSpatialAnnotationReferenceSourceANDROID의 배열입니다. sourceCapacityInput가 0인 경우 NULL일 수 있습니다.
  • 필요한 sources 크기를 가져오는 방법에 관한 자세한 설명은 버퍼 크기 매개변수 섹션을 참고하세요.

애플리케이션은 xrEnumerateSpatialAnnotationReferenceSourcesANDROID를 사용하여 지정된 XrSystemId에서 지원하는 참조 소스 목록을 열거할 수 있습니다.

런타임은 instance에 확장 프로그램이 사용 설정되지 않은 참조 소스를 열거하면 안 됩니다(MUST).

올바른 사용 (암시적)

반품 코드

성공

  • XR_SUCCESS

실패

  • 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 열거형은 주석의 메타데이터를 제공하는 참조의 소스를 설명합니다.

enum의 의미는 다음과 같습니다.

enum 설명

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

참고 이미지는 Android 카메라 API에서 출력된 자르지 않은 이미지입니다(예: Camera2 CameraDevice와 연결된 ImageReader의 이미지 또는 CameraX와 연결된 ImageAnalysis의 ImageProxy). 일반적으로 전면을 향하는 RGB 카메라 중 하나입니다.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

참조 이미지는 Android MediaProjection API에서 출력된 자르지 않은 이미지입니다(예: MediaProjection 가상 디스플레이와 연결된 ImageReader의 이미지). 가상 콘텐츠와 실제 콘텐츠를 포함할 수 있습니다.

XrSystemSpatialAnnotationPropertiesANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다.
  • referenceCacheTimespan는 유효한 XrSpatialReferenceCacheANDROID 핸들의 시간 범위(초)를 나타냅니다.
  • maxReferencePixelWidth는 참고 이미지 가장자리의 최대 너비(픽셀)를 나타냅니다.
  • maxReferencePixelHeight는 참고 이미지 가장자리의 최대 높이(픽셀)를 나타냅니다.
  • maxReferenceCount은 동시에 할당할 최대 참고 이미지 수를 나타냅니다.
  • maxAnnotationCount은 동시에 추적할 주석의 최대 개수를 나타냅니다.

런타임이 주석 추적 기능을 지원하는 경우 애플리케이션은 xrGetSystemProperties를 호출할 때 XrSystemSpatialAnnotationPropertiesANDROID 구조를 XrSystemProperties에 연결하여 관련 시스템 속성을 검사할 수 있습니다.

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference의 XrSpatialReferenceImageEXT :: width가 maxReferencePixelWidth를 초과하는 경우 런타임은 xrCreateSpatialContextAsyncEXT를 호출할 때 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다(must).

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference의 XrSpatialReferenceImageEXT :: height가 maxReferencePixelHeight를 초과하는 경우 런타임은 xrCreateSpatialContextAsyncEXT를 호출할 때 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다(must).

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time가 XrSpatialReferenceCacheANDROID :: cache의 기간을 벗어나는 경우 런타임은 xrCreateSpatialContextAsyncEXT를 호출할 때 XR_ERROR_TIME_INVALID를 반환해야 합니다(must) . 애플리케이션은 XrSpatialReferenceCacheANDROID 기간 동안 새 참조를 사용하여 XrSpatialContextEXT 핸들을 다시 만들 수 있습니다.

할당된 참고 이미지 수가 maxReferenceCount개를 초과하는 경우 런타임은 XR_ERROR_LIMIT_REACHED를 반환하고 XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult를 통해 초기화 실패를 나타내야 합니다(MUST). 애플리케이션은 XrSpatialContextEXT 핸들을 폐기하고 대기 중인 초기화가 완료된 후 다시 시도할 수 있습니다.

활성 주석 수가 maxAnnotationCount를 초과하는 경우 런타임은 xrCreateSpatialContextAsyncEXT를 호출할 때 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다(must).

올바른 사용 (암시적)

런타임 참조 캐시

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

XrSpatialReferenceCacheANDROID 핸들은 지정된 소스에서 기록된 런타임 참조의 캐시를 나타냅니다.

xrCreateSpatialReferenceCacheAsyncANDROID 함수는 다음과 같이 정의됩니다.

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

파라미터 설명

  • session는 참조 캐시가 활성화되는 XrSession입니다.
  • createInfo는 참조 캐시 매개변수를 지정하는 데 사용되는 XrSpatialReferenceCacheCreateInfoANDROID에 대한 포인터입니다.
  • future은 XrFutureEXT의 출력 핸들에 대한 포인터입니다.

애플리케이션은 xrCreateSpatialReferenceCacheAsyncANDROID를 호출하여 XrSpatialReferenceCacheANDROID 핸들을 만들 수 있습니다. 런타임에서 추적 서비스를 초기화하는 데 시간이 걸릴 수 있습니다. 그러면 애플리케이션은 xrCreateSpatialReferenceCacheCompleteANDROID를 반복적으로 호출하여 이 비동기 작업의 완료를 확인할 수 있습니다.

XrSpatialReferenceCacheCreateInfoANDROID :: capability가 xrEnumerateSpatialCapabilitiesEXT에 의해 나열되지 않은 경우 런타임은 XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT를 반환해야 합니다(must).

런타임은 지정된 기능에 대해 XrSpatialReferenceCacheCreateInfoANDROID :: source가 xrEnumerateSpatialAnnotationReferenceSourcesANDROID에 의해 나열되지 않는 경우 XR_ERROR_FEATURE_UNSUPPORTED를 반환해야 합니다(must).

애플리케이션은 특정 기능의 소스당 하나의 핸들만 만들 수 있습니다. 그 외의 경우에는 런타임이 XR_ERROR_LIMIT_REACHED를 반환해야 합니다(MUST).

그러면 애플리케이션은 XrSpatialReferenceCacheANDROID 핸들의 기간 동안 런타임 참조를 캡처하여 새 XrSpatialContextEXT 핸들을 구성할 수 있습니다.

올바른 사용 (암시적)

반품 코드

성공

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

실패

  • 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 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다. 핵심 OpenXR 또는 이 확장 프로그램에는 이러한 구조가 정의되어 있지 않습니다.
  • capability는 참조 캐시가 생성되는 기능을 설명하는 XrSpatialCapabilityEXT입니다.
  • source은 참조 캐시의 소스를 설명하는 XrSpatialAnnotationReferenceSourceANDROID입니다.

XrSpatialReferenceCacheCreateInfoANDROID 구조는 XrSpatialReferenceCacheANDROID 핸들을 만드는 정보를 설명합니다.

올바른 사용 (암시적)

xrCreateSpatialReferenceCacheCompleteANDROID 함수는 다음과 같이 정의됩니다.

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

파라미터 설명

애플리케이션은 xrCreateSpatialReferenceCacheCompleteANDROID를 호출하여 xrCreateSpatialReferenceCacheAsyncANDROID에서 시작한 비동기 작업이 완료될 때까지 기다릴 수 있습니다.

future가 준비 상태가 아니면 런타임은 XR_ERROR_FUTURE_PENDING_EXT를 반환해야 합니다(MUST). future가 이미 완료되었거나 취소된 경우 런타임은 XR_ERROR_FUTURE_INVALID_EXT를 반환해야 합니다(MUST).

올바른 사용 (암시적)

반품 코드

성공

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

실패

  • 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 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다. 핵심 OpenXR 또는 이 확장 프로그램에는 이러한 구조가 정의되어 있지 않습니다.
  • futureResult는 참조 캐시 생성 작업의 XrResult입니다.
  • referenceCache는 작업이 성공한 경우 XrSpatialReferenceCacheANDROID 핸들입니다.

향후 반품 코드

futureResult 값:

성공

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

실패

  • 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가 성공 코드인 경우 런타임은 유효한 referenceCache 핸들을 반환해야 합니다(MUST). referenceCache가 유효한 경우 xrCreateSpatialReferenceCacheAsyncANDROID :: session의 전체 기간 내에서만 또는 애플리케이션이 xrDestroySpatialReferenceCacheANDROID로 핸들을 소멸시킬 때까지(둘 중 먼저 발생하는 시점) 유효한 상태로 유지됩니다.

referenceCache가 유효하면 XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan 내에 캐시를 기록합니다.

올바른 사용 (암시적)

xrDestroySpatialReferenceCacheANDROID 함수는 다음과 같이 정의됩니다.

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

파라미터 설명

애플리케이션은 공간 컨텍스트 생성이 완료되면 xrDestroySpatialReferenceCacheANDROID 함수를 호출하여 cacheHandle 핸들과 기본 리소스를 해제할 수 있습니다.

올바른 사용 (암시적)

스레드 안전

  • cacheHandle 및 모든 하위 핸들에 대한 액세스는 외부에서 동기화되어야 합니다(must).

반품 코드

성공

  • XR_SUCCESS

실패

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

구성

XrSpatialCapabilityConfigurationAnnotationTrackingANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다.
  • capability은 XrSpatialCapabilityEXT이며 XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID여야 합니다.
  • enabledComponentCount은 enabledComponents 배열의 요소 수를 설명하는 uint32_t입니다.
  • enabledComponents는 XrSpatialComponentTypeEXT 배열의 포인터입니다.
  • cache은 이전에 reference 구성의 런타임 참조를 기록하기 위해 생성된 XrSpatialReferenceCacheANDROID입니다.
  • time는 reference가 캡처되는 XrTime입니다.
  • reference는 다음 포인터에 주석이 연결된 XrSpatialReferenceImageEXT입니다.

애플리케이션은 XrSpatialContextCreateInfoEXT :: capabilityConfigs의 XrSpatialCapabilityConfigurationAnnotationTrackingANDROID 구조에 포인터를 추가하여 XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID 공간 기능을 사용 설정할 수 있습니다.

capability가 XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID가 아닌 경우 런타임은 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다(must).

reference에 주석이 포함되어 있지 않으면 런타임은 XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT를 반환해야 합니다(MUST).

주석 구성요소가 enabledComponents에 나열되어 있지만 해당 주석이 reference와 연결되어 있지 않은 경우 런타임은 XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT를 반환해야 합니다(MUST).

cache가 xrCreateSpatialContextAsyncEXT에 전달되는 동일한 XrSession에서 소유하지 않는 경우 런타임은 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다(must).

time가 cache의 기간을 벗어나는 경우 런타임은 XR_ERROR_TIME_INVALID를 반환해야 합니다(MUST).

올바른 사용 (암시적)

주석 추적 이벤트

XrEventDataSpatialAnnotationTrackingANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다.
  • spatialContext는 주석 추적을 활성화한 XrSpatialContextEXT입니다.
  • annotationIndex는 XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference와 연결된 주석 배열의 색인에 매핑됩니다.
  • initializationResult는 주석의 초기화 결과를 나타냅니다. XR_SUCCESS가 아닌 경우 애플리케이션은 XrSpatialContextEXT 핸들을 폐기하고 다시 만들어 주석을 다시 초기화하거나 spatialContext를 계속 사용하여 다른 주석을 추적할 수 있습니다.

올바른 사용 (암시적)

런타임은 각 주석의 초기화 완료를 나타내기 위해 XrEventDataSpatialAnnotationTrackingANDROID를 채워야 합니다(MUST). 초기화 결과와 관계없이 애플리케이션은 이벤트를 수신한 후 이미지 버퍼를 해제하여 메모리 사용량을 줄일 수 있습니다.

주석이 성공적으로 초기화되면 런타임은 initializationResult를 XR_SUCCESS로 채워야 합니다. 그러면 애플리케이션이 XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT 이벤트를 가져와 주석을 추적할 수 있습니다.

그렇지 않으면 런타임은 실패 이유를 나타내는 적절한 오류 코드로 initializationResult를 채워야 합니다(MUST). 애플리케이션은 XrSpatialContextEXT 핸들을 폐기하여 새 주석을 시작하거나 spatialContext를 계속 사용하여 다른 주석을 추적할 수 있습니다.

Quad 주석

런타임은 다음 구성요소 유형을 나열하여 xrEnumerateSpatialCapabilityComponentTypesEXT를 사용한 쿼드 주석 지원을 알려야 합니다(must).

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Quad 참조

XrSpatialAnnotationQuadReferenceANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다.
  • quadCount은 quads 배열의 요소 수를 설명하는 uint32_t입니다.
  • quads는 XrSpatialAnnotationQuadANDROID 배열을 가리키는 포인터입니다.

런타임이 쿼드 주석을 지원하는 경우 애플리케이션은 XrSpatialAnnotationQuadReferenceANDROID 구조를 XrSpatialReferenceImageEXT :: next에 연결하여 주석을 구성하고 XrSpatialContextEXT 핸들을 만들 때 XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference에서 참조를 설정할 수 있습니다.

quadCount가 0인 경우 런타임은 xrCreateSpatialContextAsyncEXT에서 XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT를 반환해야 합니다(must).

올바른 사용 (암시적)

  • XR_ANDROID_spatial_annotation_tracking 확장 프로그램은 XrSpatialAnnotationQuadReferenceANDROID를 사용하기 전에 사용 설정해야 합니다.
  • type은(는) XR_TYPE_SPATIAL_ANNOTATION_QUAD_REFERENCE_ANDROID여야 합니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 유효한 포인터여야 합니다.
  • quads는 유효한 quadCount XrSpatialAnnotationQuadANDROID 구조의 배열에 대한 포인터여야 합니다.
  • quadCount 매개변수는 0보다 커야 합니다.

XrSpatialAnnotationQuadANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • alignment은 쿼드의 XrSpatialAnnotationQuadAlignmentANDROID입니다.
  • upperLeft는 원점과 관련된 쿼드의 왼쪽 상단 좌표를 설명하는 XrVector2f입니다.
  • upperRight는 원점과 관련된 쿼드의 오른쪽 상단 좌표를 설명하는 XrVector2f입니다.
  • lowerRight는 원점과 관련된 쿼드의 오른쪽 하단 모서리 좌표를 설명하는 XrVector2f입니다.
  • lowerLeft은 원점과 관련된 쿼드의 왼쪽 하단 모서리 좌표를 설명하는 XrVector2f입니다.

2D 공간의 사각형은 시계 방향 순서의 볼록 사각형입니다. 4개 모서리의 값은 사각형이 연결된 원점 (0, 0)과 관련이 있습니다.

올바른 사용 (암시적)

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 열거형은 쿼드 주석의 정렬을 설명합니다.

enum의 의미는 다음과 같습니다.

enum 설명

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

주석 쿼드는 화면 평면과 평행하며, 평면 내 회전은 세계 중력에 고정된 상태로 유지됩니다. 출력은 일반적인 수직 경계 상자로 표시됩니다.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

주석 쿼드는 객체에 직접 고정되어 참고 이미지에 정의된 정렬과 일치합니다. 출력은 객체의 원근에 맞게 모양을 조정하는 볼록 사각형입니다.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

주석 쿼드는 추적된 타겟이 평면 객체 또는 표면이라고 가정할 때 기본 객체의 표면과 동일 평면에 있습니다. 출력은 객체의 물리적 기하학적 구조와 원활하게 정렬되어 특정 표면에 평평하게 놓이도록 원근을 조정합니다.

Quad 구성요소

XrSpatialAnnotationQuadDataANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

올바른 사용 (암시적)

XrSpatialComponentAnnotationQuadListANDROID 구조는 다음과 같이 정의됩니다.

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

회원 설명

  • type는 이 구조의 XrStructureType입니다.
  • next는 NULL 또는 구조 체인의 다음 구조에 대한 포인터입니다.
  • quadCount은 quads 배열의 요소 수를 설명하는 uint32_t입니다.
  • quads는 XrSpatialAnnotationQuadDataANDROID의 배열입니다.

애플리케이션은 XrSpatialComponentDataQueryConditionEXT :: componentTypes에 XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID를 추가하고 XrSpatialComponentDataQueryResultEXT의 다음 포인터 체인에 XrSpatialComponentAnnotationQuadListANDROID를 추가하여 XrSpatialSnapshotEXT에서 공간 요소의 쿼드 주석 구성요소를 쿼리할 수 있습니다.

XrSpatialComponentAnnotationQuadListANDROID가 XrSpatialComponentDataQueryResultEXT :: next의 다음 체인에 있지만 XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID가 XrSpatialComponentDataQueryConditionEXT :: componentTypes에 포함되지 않은 경우 런타임은 xrQuerySpatialComponentDataEXT에서 XR_ERROR_VALIDATION_FAILURE를 반환해야 합니다.

quadCount가 XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput보다 작은 경우 런타임은 xrQuerySpatialComponentDataEXT에서 XR_ERROR_SIZE_INSUFFICIENT를 반환해야 합니다(must).

올바른 사용 (암시적)

예제 코드

런타임 지원 확인

다음 예시 코드는 런타임이 주석 추적 기능을 지원하는지 확인하는 방법을 보여줍니다.

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;
}

쿼드 주석 구성

다음 코드 예시에서는 사분면 주석을 구성하는 방법을 보여줍니다.

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));
}

활성 주석 살펴보기

다음 코드 예는 주석을 검색하고 쿼리하는 방법을 보여줍니다.

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));

새 객체 유형

새 명령어

새로운 구조

새 enum

새 enum 상수

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • XrObjectType 확장:

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • XrSpatialCapabilityEXT 확장:

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • XrSpatialComponentTypeEXT 확장:

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

  • XrStructureType 확장:

    • 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

문제

버전 기록

  • 버전 1, 2025-09-17 (레바나 첸)

    • 초기 확장 프로그램 설명입니다.