XR_ANDROID_depth_texture

Stringa del nome

XR_ANDROID_depth_texture

Tipo di estensione

Estensione dell'istanza

Numero di interno registrato

703

Revisione

1

Stato di ratifica

Non ratificato

Dipendenze da estensioni e versioni

OpenXR 1.0

Data ultima modifica

2024-09-11

Stato IP

Nessuna rivendicazione di proprietà intellettuale nota.

Collaboratori

Sushant Kulkarni, Google
Cairn Overturf, Google
Spencer Quin, Google
Levana Chen, Google

Panoramica

Questa estensione consente all'applicazione di richiedere mappe di profondità dell'ambiente reale intorno al visore e di eseguire query sulle risoluzioni di profondità supportate al momento della creazione.

Questa estensione ha lo scopo di esporre la profondità grezza e uniforme per l'occlusione, i test di hit e altre attività specifiche che sfruttano la geometria accurata della scena, ad esempio il rilevamento di volti contraffatti.

Nota

Le mappe di profondità vengono generate dal runtime e condivise con l'applicazione utilizzando XrDepthSwapchainANDROID . Il runtime non deve modificare le risoluzioni delle immagini di profondità restituite tramite xrEnumerateDepthResolutionsANDROID per tutta la durata dell'applicazione.

Autorizzazioni

Questa estensione espone una texture di profondità con sottocampionamento per mitigare i problemi relativi alle informazioni che consentono l'identificazione personale (PII). Le applicazioni Android devono disporre dell'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE elencata nel loro manifest, in quanto questa estensione espone la geometria dell'ambiente. L'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE è considerata pericolosa. L'applicazione deve richiedere l'autorizzazione in fase di runtime per utilizzare queste funzioni:

(livello di protezione: pericoloso)

Ispezionare la funzionalità del sistema

La struttura XrSystemDepthTrackingPropertiesANDROID è definita come:

typedef struct XrSystemDepthTrackingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsDepthTracking;
} XrSystemDepthTrackingPropertiesANDROID;

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • supportsDepthTracking è un XrBool32 che indica se il sistema attuale supporta il monitoraggio della profondità.

Un'applicazione può verificare se il sistema è in grado di tracciare la profondità estendendo XrSystemProperties con la struttura XrSystemDepthTrackingPropertiesANDROID quando chiama xrGetSystemProperties .

Se e solo se un runtime restituisce XR_FALSE per supportsDepthTracking , il runtime deve restituire XR_ERROR_FEATURE_UNSUPPORTED da xrCreateDepthSwapchainANDROID .

Utilizzo valido (implicito)

Risoluzioni della profondità della query

La funzione xrEnumerateDepthResolutionsANDROID è definita come:

XrResult xrEnumerateDepthResolutionsANDROID(
    XrSession                                   session,
    uint32_t                                    resolutionCapacityInput,
    uint32_t*                                   resolutionCountOutput,
    XrDepthCameraResolutionANDROID*             resolutions);

Descrizioni dei parametri

  • session è l'XrSession che enumera le risoluzioni di profondità supportate.
  • resolutionCapacityInput è la capacità di resolutions o 0 per recuperare la capacità richiesta.
  • resolutionCountOutput è un puntatore al conteggio di uint64_t resolutions scritti o un puntatore alla capacità richiesta nel caso in cui resolutionCapacityInput sia insufficiente.
  • resolutions è un puntatore a un array di XrDepthCameraResolutionANDROID , ma can può essere NULL se resolutionCapacityInput è 0 .
  • Consulta la sezione Parametri delle dimensioni del buffer per una descrizione dettagliata del recupero delle dimensioni resolutions richieste.

xrEnumerateDepthResolutionsANDROID enumera le risoluzioni di profondità supportate dalla sessione corrente. Le risoluzioni di profondità devono essere in ordine dalla preferenza di runtime più alta a quella più bassa. L'applicazione deve utilizzare la preferenza più elevata che supporta per prestazioni e qualità ottimali.

I runtime devono sempre restituire contenuti del buffer identici da questa enumerazione per tutta la durata della sessione.

Utilizzo valido (implicito)

  • L'estensione XR_ANDROID_depth_texture deve essere attivata prima di chiamare xrEnumerateDepthResolutionsANDROID
  • session deve essere un handle XrSession valido
  • resolutionCountOutput deve essere un puntatore a un valore uint32_t
  • Se resolutionCapacityInput non è 0 , resolutions deve essere un puntatore a un array di valori resolutionCapacityInput XrDepthCameraResolutionANDROID

Codici di ritorno

Operazione riuscita

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Errore

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_VALIDATION_FAILURE

L'enumerazione XrDepthCameraResolutionANDROID descrive le risoluzioni di profondità supportate durante la creazione di un XrDepthSwapchainANDROID .

typedef enum XrDepthCameraResolutionANDROID {
    XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID = 0,
    XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID = 1,
    XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID = 2,
    XR_DEPTH_CAMERA_RESOLUTION_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrDepthCameraResolutionANDROID;

Descrizioni dell'enumerante

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID: la risoluzione delle immagini di profondità e confidenza è 80x80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID: la risoluzione delle immagini di profondità e confidenza è 160 x 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID: la risoluzione delle immagini di profondità e confidenza è 320 x 320.

Crea una swapchain di profondità

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Un XrDepthSwapchainANDROID è un handle di swapchain di profondità.

La funzione xrCreateDepthSwapchainANDROID è definita come:

XrResult xrCreateDepthSwapchainANDROID(
    XrSession                                   session,
    const XrDepthSwapchainCreateInfoANDROID*    createInfo,
    XrDepthSwapchainANDROID*                    swapchain);

Descrizioni dei parametri

L'applicazione può utilizzare la funzione xrCreateDepthSwapchainANDROID per creare una swapchain di profondità che gestisce sia le immagini di profondità che quelle di confidenza.

  • Il runtime deve restituire XR_ERROR_FEATURE_UNSUPPORTED se il sistema non supporta il monitoraggio della profondità.
  • Il runtime deve restituire XR_ERROR_PERMISSION_INSUFFICIENT se le autorizzazioni richieste non sono state concesse all'app chiamante.
  • Il runtime deve restituire XR_ERROR_VALIDATION_FAILURE se la risoluzione di profondità specificata in XrDepthSwapchainCreateInfoANDROID non è supportata.
  • Il runtime deve creare immagini di confidenza della profondità solo quando i bit corrispondenti sono impostati per createInfo al momento della creazione della swapchain.

L'handle della swapchain di profondità restituito può essere utilizzato successivamente nelle chiamate API. L'handle XrDepthSwapchainANDROID deve essere liberato tramite la funzione xrDestroyDepthSwapchainANDROID.

Utilizzo valido (implicito)

Codici di ritorno

Operazione riuscita

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Errore

  • 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_PERMISSION_INSUFFICIENT
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST

La struttura XrDepthSwapchainCreateInfoANDROID è definita come:

typedef struct XrDepthSwapchainCreateInfoANDROID {
    XrStructureType                       type;
    const void*                           next;
    XrDepthCameraResolutionANDROID        resolution;
    XrDepthSwapchainCreateFlagsANDROID    createFlags;
} XrDepthSwapchainCreateInfoANDROID;

Descrizioni dei membri

La struttura XrDepthSwapchainCreateInfoANDROID fornisce opzioni di creazione per XrDepthSwapchainANDROID quando viene passata a xrCreateDepthSwapchainANDROID .

Utilizzo valido (implicito)

XrDepthSwapchainCreateFlagsANDROID specifica le opzioni di creazione per XrDepthSwapchainANDROID .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

I bit validi per XrDepthSwapchainCreateFlagsANDROID sono definiti da XrDepthSwapchainCreateFlagBitsANDROID , che è specificato come:

// Flag bits for XrDepthSwapchainCreateFlagsANDROID
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID = 0x00000001;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID = 0x00000002;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID = 0x00000004;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID = 0x00000008;

Descrizioni dei flag

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID: indica che la swapchain fornirà immagini di profondità fluide.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID: indica che la swapchain fornirà immagini di confidenza della profondità fluide.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID: indica che la swapchain fornirà immagini di profondità non elaborate.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID: indica che la swapchain fornirà immagini di confidenza della profondità non elaborate.

La funzione xrDestroyDepthSwapchainANDROID è definita come:

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Descrizioni dei parametri

La funzione xrDestroyDepthSwapchainANDROID distrugge la swapchain di profondità. Dopo questa chiamata, il runtime potrebbe liberare tutta la memoria e le risorse correlate.

Utilizzo valido (implicito)

Thread Safety

  • L'accesso a swapchain e a tutti gli handle secondari deve essere sincronizzato esternamente

Codici di ritorno

Operazione riuscita

  • XR_SUCCESS

Errore

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Accedere alle texture di profondità

La funzione xrEnumerateDepthSwapchainImagesANDROID è definita come:

XrResult xrEnumerateDepthSwapchainImagesANDROID(
    XrDepthSwapchainANDROID                     depthSwapchain,
    uint32_t                                    depthImageCapacityInput,
    uint32_t*                                   depthImageCountOutput,
    XrDepthSwapchainImageANDROID*               depthImages);

Descrizioni dei parametri

  • depthSwapchain è XrDepthSwapchainANDROID da cui ottenere le immagini.
  • depthImageCapacityInput è la capacità dell'array depthImages o 0 per indicare una richiesta di recupero della capacità richiesta.
  • depthImageCountOutput è un puntatore al conteggio di depthImages scritti o un puntatore alla capacità richiesta nel caso in cui depthImageCapacityInput sia insufficiente.
  • depthImages è un puntatore a un array di strutture XrDepthSwapchainImageANDROID. Può essere NULL se depthImageCapacityInput è 0.
  • Consulta la sezione Parametri delle dimensioni del buffer per una descrizione dettagliata del recupero delle dimensioni depthImages richieste.

xrEnumerateDepthSwapchainImagesANDROID riempie un array di strutture XrDepthSwapchainImageANDROID. Le risorse devono essere costanti e valide per tutta la durata di XrDepthSwapchainANDROID . Questa funzione si comporta in modo analogo a xrEnumerateSwapchainImages .

Il runtime deve sempre restituire contenuti del buffer identici da questa enumerazione per tutta la durata della swapchain.

Utilizzo valido (implicito)

Codici di ritorno

Operazione riuscita

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Errore

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_VALIDATION_FAILURE

La struttura XrDepthSwapchainImageANDROID è definita come:

typedef struct XrDepthSwapchainImageANDROID {
    XrStructureType    type;
    void*              next;
    const float*       rawDepthImage;
    const uint8_t*     rawDepthConfidenceImage;
    const float*       smoothDepthImage;
    const uint8_t*     smoothDepthConfidenceImage;
} XrDepthSwapchainImageANDROID;

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • rawDepthImage è NULL o il puntatore alle immagini di profondità non elaborate per le visualizzazioni sinistra e destra allocate dal runtime. I valori sono espressi in metri. Valori speciali: 0.0 indica un pixel di profondità non valido o vuoto nella profondità grezza, Inf indica una profondità nota che è effettivamente infinitamente lontana,
  • rawDepthConfidenceImage è NULL o il puntatore alle immagini di confidenza della profondità grezza per le visualizzazioni sinistra e destra allocate dal runtime.
  • smoothDepthImage è NULL o il puntatore alle immagini di profondità uniformi per le visualizzazioni sinistra e destra allocate dal runtime. I valori sono espressi in metri. Valori speciali: 0.0 indica un pixel di profondità non valido o vuoto nella profondità uniforme, Inf indica una profondità nota che è effettivamente infinitamente lontana.
  • smoothDepthConfidenceImage è NULL o il puntatore alle immagini di confidenza della profondità uniforme per le visualizzazioni sinistra e destra allocate dal runtime.

I puntatori del buffer delle immagini saranno validi solo durante la durata della swapchain. Una volta distrutta la swapchain, i puntatori verranno considerati sospesi.

XrDepthSwapchainImageANDROID rappresenta le immagini di profondità di un XrDepthSwapchainANDROID leggibile , allocate come descritto in XrDepthSwapchainCreateInfoANDROID :: resolution e XrDepthSwapchainCreateInfoANDROID :: createFlags durante la chiamata a xrCreateDepthSwapchainANDROID . Per ogni immagine di profondità:

Utilizzo valido (implicito)

La funzione xrAcquireDepthSwapchainImagesANDROID è definita come:

XrResult xrAcquireDepthSwapchainImagesANDROID(
    XrDepthSwapchainANDROID                     depthSwapchain,
    const XrDepthAcquireInfoANDROID*            acquireInfo,
    XrDepthAcquireResultANDROID*                acquireResult);

Descrizioni dei parametri

Le applicazioni possono utilizzare la funzione xrAcquireDepthSwapchainImagesANDROID per acquisire l'ultimo indice di swapchain disponibile, ovvero XrDepthAcquireResultANDROID :: acquiredIndex , nell'array XrDepthSwapchainImageANDROID enumerato da xrEnumerateDepthSwapchainImagesANDROID. XrDepthAcquireResultANDROID restituito contiene anche altre informazioni, come il campo visivo e la posa, necessarie per interpretare i dati di profondità. È sicuro leggere dallo slot acquisito nell'array di immagini fino alla successiva chiamata a xrAcquireDepthSwapchainImagesANDROID .

In una sessione deve essere presente una sola chiamata a xrAcquireDepthSwapchainImagesANDROID tra ogni coppia di chiamate xrBeginFrame e xrEndFrame corrispondenti.

Utilizzo valido (implicito)

Codici di ritorno

Operazione riuscita

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Errore

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

La struttura XrDepthAcquireInfoANDROID è definita come:

typedef struct XrDepthAcquireInfoANDROID {
    XrStructureType    type;
    const void*        next;
    XrSpace            space;
    XrTime             displayTime;
} XrDepthAcquireInfoANDROID;

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • space è un XrSpace che definisce il sistema di riferimento della posa restituita in XrDepthAcquireResultANDROID :: views .
  • displayTime è un XrTime che specifica l'ora utilizzata per calcolare la posa per la posa restituita in XrDepthAcquireResultANDROID :: views . Le applicazioni devono superare il tempo di visualizzazione previsto per il frame corrente.

Utilizzo valido (implicito)

La struttura XrDepthAcquireResultANDROID è definita come:

typedef struct XrDepthAcquireResultANDROID {
    XrStructureType       type;
    const void*           next;
    uint32_t              acquiredIndex;
    XrTime                exposureTimestamp;
    XrDepthViewANDROID    views[2];
} XrDepthAcquireResultANDROID;

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • acquiredIndex è l'indice della texture acquisita nell'array XrDepthSwapchainImageANDROID enumerato da xrEnumerateDepthSwapchainImagesANDROID .
  • exposureTimestamp è XrTime che specifica l'ora in cui è stata acquisita la mappa di profondità.
  • views è un array di due XrDepthViewANDROID , uno per ogni occhio, dove l'indice 0 è l'occhio sinistro e l'indice 1 è l'occhio destro.

Utilizzo valido (implicito)

La struttura XrDepthViewANDROID è definita come:

typedef struct XrDepthViewANDROID {
    XrStructureType    type;
    const void*        next;
    XrFovf             fov;
    XrPosef            pose;
} XrDepthViewANDROID;

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • fov è un XrFovf che specifica il campo visivo utilizzato per generare questa visualizzazione. La visualizzazione non viene mai invertita orizzontalmente o verticalmente.
  • pose è un XrPosef che specifica la posa da cui è stata eseguita il rendering della mappa di profondità. Il sistema di riferimento è specificato in XrDepthAcquireInfoANDROID .

Utilizzo valido (implicito)

Codice di esempio per il monitoraggio della profondità

Il seguente codice di esempio mostra come acquisire immagini di profondità e utilizzare i valori di profondità per mappare le coordinate delle immagini di profondità nello spazio scenico.

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session; // previously initialized
XrSpace stageSpace; // space created for XR_REFERENCE_SPACE_TYPE_STAGE.

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateDepthSwapchainANDROID xrCreateDepthSwapchainANDROID; // previously initialized
PFN_xrDestroyDepthSwapchainANDROID xrDestroyDepthSwapchainANDROID; // previously initialized
PFN_xrEnumerateDepthSwapchainImagesANDROID xrEnumerateDepthSwapchainImagesANDROID; // previously initialized
PFN_xrEnumerateDepthResolutionsANDROID xrEnumerateDepthResolutionsANDROID; // previously initialized
PFN_xrAcquireDepthSwapchainImagesANDROID xrAcquireDepthSwapchainImagesANDROID; // previously initialized

float tanf(float);

// Inspect system capability
XrSystemProperties properties{XR_TYPE_SYSTEM_PROPERTIES};
XrSystemDepthTrackingPropertiesANDROID depthTrackingProperties{XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID};
properties.next = &depthTrackingProperties;
CHK_XR(xrGetSystemProperties(instance, systemId, &properties));
if (!depthTrackingProperties.supportsDepthTracking) {
  // depth tracking is not supported.
  return;
}

// Query the supported depth resolution.
XrDepthCameraResolutionANDROID supportedDepthResolution;
uint32_t supportedResolutionCount = 0;
CHK_XR(xrEnumerateDepthResolutionsANDROID(
    session, 1, &supportedResolutionCount, &supportedDepthResolution));

// Define metadata to access the raw and smooth depth along with confidences.
XrDepthSwapchainCreateInfoANDROID swapchainCreateInfo = {
  .type = XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID,
  .next = nullptr,
  // Use the resolution supported by the runtime.
  .resolution = supportedDepthResolution,
  .createFlags =
    XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID,
};

XrDepthSwapchainANDROID depthSwapchain;
CHK_XR(xrCreateDepthSwapchainANDROID(
    session, &swapchainCreateInfo, &depthSwapchain));

// Enumerate depth images.
uint32_t imageCountOutput = 0;
CHK_XR(xrEnumerateDepthSwapchainImagesANDROID(
    depthSwapchain, 0, &imageCountOutput, nullptr));
std::vector<XrDepthSwapchainImageANDROID> depthImages(imageCountOutput);
for (int i = 0; i < imageCountOutput; i++) {
  depthImages[i].type = XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID;
}
CHK_XR(xrEnumerateDepthSwapchainImagesANDROID(
  depthSwapchain, imageCountOutput, &imageCountOutput, depthImages.data()));

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

    XrFrameState frameState;  // previously returned from xrWaitFrame
    const XrTime time = frameState.predictedDisplayTime;

    XrDepthAcquireInfoANDROID acquireInfo = {
        .type = XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID,
        .space = stageSpace,
        .displayTime = time
    };
    XrDepthAcquireResultANDROID acquireResult = {
        .type = XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID,
    };
    CHK_XR(xrAcquireDepthSwapchainImagesANDROID(
        depthSwapchain, &acquireInfo, &acquireResult));

    // Each value in a depth image corresponds to a point in the real world.
    // The sample code below shows how to find the stageSpace position of
    // the point corresponding to a particular value in the depth image.

    // For this sample code, assume we are using a right handed coordinate system
    // with +X to the right, +Y up and -Z forward.

    XrDepthSwapchainImageANDROID *image =
        &depthImages[acquireResult.acquiredIndex];

    // Assume supported resolution is XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID.
    const int imageResolution = 160;
    int imageY = 80; // value in [0, imageResolution)
    int imageX = 80; // value in [0, imageResolution)

    // Get depth value from left eye.
    // A right depth value is obtained with the following expression:
    // depthR = image->rawDepthImage[imageResolution*imageResolution+i*imageResolution+j]
    float depthL = image->rawDepthImage[imageY*imageResolution + imageX];
    XrDepthViewANDROID viewL = acquireResult.views[0];

    float tanL = tanf(viewL.fov.angleLeft);
    float tanR = tanf(viewL.fov.angleRight);
    float tanU = tanf(viewL.fov.angleUp);
    float tanD = tanf(viewL.fov.angleDown);

    float s = (imageX + 0.5f) / (float)imageResolution;
    float t = (imageY + 0.5f) / (float)imageResolution;

    // Calculate the depth camera space position of the point
    // corresponding to this depth value.
    XrVector3f posInCameraSpace;
    posInCameraSpace.z = -depthL;
    posInCameraSpace.x = (tanL + (tanR - tanL)*s)*depthL;
    posInCameraSpace.y = (tanD + (tanU - tanD)*t)*depthL;

    XrPosef depthCameraPoseL = viewL.pose;
    // Transform posInCameraSpace by depthCameraPoseL

    // ...
    // Finish frame loop
    // ...
}

Nuovi tipi di oggetti

Nuovi comandi

Nuove strutture

Nuovi enum

Nuove maschere di bit

Nuove costanti enum

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Estensione di XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Estensione di XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Estensione di XrStructureType :

    • XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID
    • XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID
    • XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID
    • XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID
    • XR_TYPE_DEPTH_VIEW_ANDROID
    • XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID

Problemi

Cronologia delle versioni

  • Revisione 1, 09/09/2024 (Levana Chen)

    • Descrizione iniziale dell'estensione