XR_ANDROID_depth_texture

Name String

XR_ANDROID_depth_texture

Type d'extension

Extension d'instance

Numéro d'extension enregistré

703

Révision

1

État de la ratification

Non ratifié

Dépendances d'extension et de version

OpenXR 1.0

Date de dernière modification

2024-09-11

État de l'adresse IP

Aucune réclamation de propriété intellectuelle connue.

Participants

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

Présentation

Cette extension permet à l'application de demander des cartes de profondeur de l'environnement réel autour du casque et d'interroger les résolutions de profondeur compatibles lors de la création.

Cette extension est destinée à exposer la profondeur brute et lissée pour l'occlusion, les tests de positionnement et d'autres tâches spécifiques qui exploitent une géométrie de scène précise, par exemple la détection de visages contrefaits.

Remarque

Les cartes de profondeur sont générées par l'environnement d'exécution et partagées avec l'application à l'aide de XrDepthSwapchainANDROID . L'environnement d'exécution ne doit pas modifier les résolutions d'image de profondeur renvoyées via xrEnumerateDepthResolutionsANDROID pendant toute la durée de vie de l'application.

Autorisations

Cette extension expose une texture de profondeur sous-échantillonnée pour limiter les problèmes liés aux informations permettant d'identifier personnellement l'utilisateur. Les applications Android doivent inclure l'autorisation android.permission.SCENE_UNDERSTANDING_FINE dans leur fichier manifeste, car cette extension expose la géométrie de l'environnement. L'autorisation android.permission.SCENE_UNDERSTANDING_FINE est considérée comme dangereuse. L'application doit demander l'autorisation au moment de l'exécution pour utiliser ces fonctions :

(niveau de protection : dangereux)

Inspecter les capacités du système

La structure XrSystemDepthTrackingPropertiesANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • supportsDepthTracking est un XrBool32 indiquant si le système actuel est compatible avec le suivi de la profondeur.

Une application peut vérifier si le système est capable de suivre la profondeur en étendant XrSystemProperties avec la structure XrSystemDepthTrackingPropertiesANDROID lors de l'appel de xrGetSystemProperties .

Si et seulement si un environnement d'exécution renvoie XR_FALSE pour supportsDepthTracking , l'environnement d'exécution doit renvoyer XR_ERROR_FEATURE_UNSUPPORTED à partir de xrCreateDepthSwapchainANDROID .

Utilisation valide (implicite)

Résolutions de profondeur de requête

La fonction xrEnumerateDepthResolutionsANDROID est définie comme suit :

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

Description des paramètres

  • session est l'XrSession qui énumère les résolutions de profondeur compatibles.
  • resolutionCapacityInput est la capacité de resolutions , ou 0 pour récupérer la capacité requise.
  • resolutionCountOutput est un pointeur vers le nombre de uint64_t resolutions écrits, ou un pointeur vers la capacité requise si resolutionCapacityInput est insuffisant.
  • resolutions est un pointeur vers un tableau de XrDepthCameraResolutionANDROID , mais peut être NULL si resolutionCapacityInput est 0 .
  • Consultez la section Paramètres de taille de la mémoire tampon pour obtenir une description détaillée de la récupération de la taille resolutions requise.

xrEnumerateDepthResolutionsANDROID énumère les résolutions de profondeur compatibles avec la session en cours. Les résolutions de profondeur doivent être classées de la préférence d'exécution la plus élevée à la plus faible. L'application doit utiliser la préférence la plus élevée qu'elle accepte pour des performances et une qualité optimales.

Les environnements d'exécution doivent toujours renvoyer un contenu de tampon identique à partir de cette énumération pendant la durée de vie de la session.

Utilisation valide (implicite)

  • L'extension XR_ANDROID_depth_texture doit être activée avant d'appeler xrEnumerateDepthResolutionsANDROID.
  • session doit être un handle XrSession valide
  • resolutionCountOutput doit être un pointeur vers une valeur uint32_t
  • Si resolutionCapacityInput n'est pas 0 , resolutions doit être un pointeur vers un tableau de valeurs resolutionCapacityInput XrDepthCameraResolutionANDROID.

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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'énumération XrDepthCameraResolutionANDROID décrit les résolutions de profondeur compatibles lors de la création d'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;

Descriptions des énumérants

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID : la résolution des images de profondeur et de confiance est de 80 x 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID : la résolution des images de profondeur et de confiance est de 160 x 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID : la résolution des images de profondeur et de confiance est de 320 x 320.

Créer une chaîne d'échange de profondeur

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Un XrDepthSwapchainANDROID est un handle de swapchain de profondeur.

La fonction xrCreateDepthSwapchainANDROID est définie comme suit :

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

Description des paramètres

  • session est l'objet XrSession qui crée la chaîne d'échange de profondeur.
  • createInfo est un pointeur vers une structure XrDepthSwapchainCreateInfoANDROID contenant les paramètres à utiliser pour créer la swapchain.
  • swapchain est un pointeur vers un handle dans lequel l'objet XrDepthSwapchainANDROID créé est renvoyé.

L'application peut utiliser la fonction xrCreateDepthSwapchainANDROID pour créer une chaîne d'échange de profondeur qui gère à la fois les images de profondeur et de confiance.

  • L'environnement d'exécution doit renvoyer XR_ERROR_FEATURE_UNSUPPORTED si le système n'est pas compatible avec le suivi de la profondeur.
  • L'environnement d'exécution doit renvoyer XR_ERROR_PERMISSION_INSUFFICIENT si les autorisations requises n'ont pas été accordées à l'application appelante.
  • L'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE si la résolution de profondeur spécifiée dans XrDepthSwapchainCreateInfoANDROID n'est pas compatible.
  • L'environnement d'exécution ne doit créer des images de confiance de profondeur que lorsque les bits correspondants sont définis pour createInfo lors de la création de la swapchain.

Le handle de swapchain de profondeur renvoyé peut être utilisé ultérieurement dans les appels d'API. Le handle XrDepthSwapchainANDROID doit être libéré via la fonction xrDestroyDepthSwapchainANDROID.

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 structure XrDepthSwapchainCreateInfoANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • resolution est la XrDepthCameraResolutionANDROID avec laquelle les textures de profondeur et de confiance sont créées.
  • createFlags correspond à un ou plusieurs XrDepthSwapchainCreateFlagsANDROID .

La structure XrDepthSwapchainCreateInfoANDROID fournit des options de création pour XrDepthSwapchainANDROID lorsqu'elle est transmise à xrCreateDepthSwapchainANDROID .

Utilisation valide (implicite)

XrDepthSwapchainCreateFlagsANDROID spécifie les options de création pour XrDepthSwapchainANDROID .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

Les bits valides pour XrDepthSwapchainCreateFlagsANDROID sont définis par XrDepthSwapchainCreateFlagBitsANDROID , qui est spécifié comme suit :

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

Descriptions des flags

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID : indique que la chaîne d'échange fournira des images de profondeur lissées.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID : indique que la chaîne d'échange fournira des images de confiance de profondeur lissées.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID : indique que la chaîne d'échange fournira des images de profondeur brutes.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID : indique que la swapchain fournira des images de confiance de profondeur brutes.

La fonction xrDestroyDepthSwapchainANDROID est définie comme suit :

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Description des paramètres

La fonction xrDestroyDepthSwapchainANDROID détruit la chaîne d'échange de profondeur. Après cet appel, l'environnement d'exécution peut libérer l'ensemble de la mémoire et des ressources associées.

Utilisation valide (implicite)

Thread safety

  • L'accès à swapchain et à tous les handles enfants doit être synchronisé en externe.

Codes renvoyés

Opération réussie

  • XR_SUCCESS

Échec

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Accéder aux textures de profondeur

La fonction xrEnumerateDepthSwapchainImagesANDROID est définie comme suit :

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

Description des paramètres

  • depthSwapchain est l'élément XrDepthSwapchainANDROID à partir duquel obtenir des images.
  • depthImageCapacityInput est la capacité du tableau depthImages, ou 0 pour indiquer une requête de récupération de la capacité requise.
  • depthImageCountOutput est un pointeur vers le nombre de depthImages écrits, ou un pointeur vers la capacité requise si depthImageCapacityInput est insuffisant.
  • depthImages est un pointeur vers un tableau de structures XrDepthSwapchainImageANDROID. Il peut être NULL si depthImageCapacityInput est égal à 0.
  • Consultez la section Paramètres de taille de la mémoire tampon pour obtenir une description détaillée de la récupération de la taille depthImages requise.

xrEnumerateDepthSwapchainImagesANDROID remplit un tableau de structures XrDepthSwapchainImageANDROID. Les ressources doivent être constantes et valides pendant toute la durée de vie de XrDepthSwapchainANDROID . Cette fonction se comporte de manière analogue à xrEnumerateSwapchainImages .

L'environnement d'exécution doit toujours renvoyer un contenu de tampon identique à partir de cette énumération pendant toute la durée de vie de la chaîne d'échange.

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 structure XrDepthSwapchainImageANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • rawDepthImage est NULL ou le pointeur vers les images de profondeur brutes pour les vues gauche et droite allouées par l'environnement d'exécution. Les valeurs sont exprimées en mètres. Valeurs spéciales : 0.0 indique un pixel de profondeur non valide ou vide dans la profondeur brute, Inf indique une profondeur connue qui est effectivement infiniment éloignée,
  • rawDepthConfidenceImage est NULL ou le pointeur vers les images de confiance de profondeur brute pour les vues gauche et droite allouées par l'environnement d'exécution.
  • smoothDepthImage est NULL ou le pointeur vers les images de profondeur lissées pour les vues gauche et droite allouées par l'environnement d'exécution. Les valeurs sont exprimées en mètres. Valeurs spéciales : 0.0 indique un pixel de profondeur non valide ou vide dans la profondeur lissée, Inf indique une profondeur connue qui est effectivement infiniment éloignée.
  • smoothDepthConfidenceImage est NULL ou le pointeur vers les images de confiance de profondeur lissées pour les vues gauche et droite allouées par l'environnement d'exécution.

Les pointeurs de tampon d'image ne seront valides que pendant la durée de vie de la chaîne d'échange. Une fois la chaîne d'échange détruite, les pointeurs seront considérés comme non valides.

XrDepthSwapchainImageANDROID représente les images de profondeur d'un XrDepthSwapchainANDROID lisible, alloué comme décrit dans XrDepthSwapchainCreateInfoANDROID :: resolution et XrDepthSwapchainCreateInfoANDROID :: createFlags lors de l'appel de xrCreateDepthSwapchainANDROID . Pour chaque image de profondeur :

Utilisation valide (implicite)

La fonction xrAcquireDepthSwapchainImagesANDROID est définie comme suit :

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

Description des paramètres

Les applications peuvent utiliser la fonction xrAcquireDepthSwapchainImagesANDROID pour acquérir l'index d'image de swapchain le plus récent disponible, c'est-à-dire XrDepthAcquireResultANDROID :: acquiredIndex , dans le tableau XrDepthSwapchainImageANDROID énuméré par xrEnumerateDepthSwapchainImagesANDROID. Le XrDepthAcquireResultANDROID renvoyé contient également d'autres informations, telles que le champ de vision et la pose, qui sont nécessaires pour interpréter les données de profondeur. Vous pouvez lire l'emplacement acquis dans le tableau d'images en toute sécurité jusqu'au prochain appel de xrAcquireDepthSwapchainImagesANDROID .

Il ne doit pas y avoir plus d'un appel à xrAcquireDepthSwapchainImagesANDROID entre chaque paire d'appels xrBeginFrame et xrEndFrame correspondants dans une session.

  • L'environnement d'exécution peut se bloquer si les images de la chaîne d'échange acquises précédemment sont toujours utilisées par l'environnement d'exécution.
  • L'environnement d'exécution doit renvoyer XR_ERROR_CALL_ORDER_INVALID si xrAcquireDepthSwapchainImagesANDROID est appelé avant xrBeginFrame ou après xrEndFrame .
  • L'environnement d'exécution doit renvoyer XR_ERROR_LIMIT_REACHED si xrAcquireDepthSwapchainImagesANDROID est appelé plusieurs fois par frame, c'est-à-dire dans une session en cours d'exécution, après un appel à xrBeginFrame qui n'a pas de xrEndFrame associé.
  • L'environnement d'exécution peut renvoyer XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID si les données de profondeur de l'environnement ne sont pas encore disponibles. Dans ce cas, l'application doit appeler à nouveau xrAcquireDepthSwapchainImagesANDROID dans un frame ultérieur.

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 structure XrDepthAcquireInfoANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • space est un XrSpace définissant le cadre de référence de la pose renvoyée dans XrDepthAcquireResultANDROID :: views .
  • displayTime est un XrTime spécifiant l'heure utilisée pour calculer la pose de la pose renvoyée dans XrDepthAcquireResultANDROID :: views . Les applications doivent transmettre leur temps d'affichage prévu pour l'image actuelle.

Utilisation valide (implicite)

La structure XrDepthAcquireResultANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • acquiredIndex est l'index de la texture acquise dans le tableau XrDepthSwapchainImageANDROID énuméré par xrEnumerateDepthSwapchainImagesANDROID .
  • exposureTimestamp est le XrTime spécifiant l'heure à laquelle la carte de profondeur a été capturée.
  • views est un tableau de deux XrDepthViewANDROID , un pour chaque œil, où l'index 0 correspond à l'œil gauche et l'index 1 à l'œil droit.

Utilisation valide (implicite)

La structure XrDepthViewANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • fov est un XrFovf spécifiant le champ de vision utilisé pour générer cette vue. La vue n'est jamais retournée horizontalement ni verticalement.
  • pose est un XrPosef spécifiant la pose à partir de laquelle la carte de profondeur a été affichée. Le cadre de référence est spécifié dans XrDepthAcquireInfoANDROID .

Utilisation valide (implicite)

Exemple de code pour le suivi de la profondeur

L'exemple de code suivant montre comment acquérir des images de profondeur et utiliser des valeurs de profondeur pour mapper les coordonnées d'image de profondeur à l'espace de la scène.

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
    // ...
}

Nouveaux types d'objets

Nouvelles commandes

Nouvelles structures

Nouvelles énumérations

Nouveaux masques de bits

Nouvelles constantes d'énumération

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Extension de XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Extension de XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Extension de 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

Problèmes

Historique des versions

  • Révision 1, 09/09/2024 (Levana Chen)

    • Description initiale de l'extension