XR_ANDROID_depth_texture

Name String

XR_ANDROID_depth_texture

Erweiterungstyp

Instanzerweiterung

Registrierte Durchwahlnummer

703

Revision

1

Ratifikationsstatus

Nicht ratifiziert

Abhängigkeiten von Erweiterungen und Versionen

OpenXR 1.0

Datum der letzten Änderung

2024-09-11

IP-Status

Es sind keine Ansprüche wegen geistigen Eigentums bekannt.

Mitwirkende

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

Übersicht

Mit dieser Erweiterung kann die Anwendung Tiefenkarten der realen Umgebung um das Headset herum anfordern und unterstützte Tiefenauflösungen bei der Erstellung abfragen.

Diese Erweiterung soll rohe und geglättete Tiefe für Verdeckung, Trefferprüfung und andere spezifische Aufgaben bereitstellen, die eine genaue Szenengeometrie erfordern, z. B. die Erkennung gefälschter Gesichter.

Hinweis

Die Tiefenkarten werden von der Laufzeit generiert und über XrDepthSwapchainANDROID mit der Anwendung geteilt . Die Laufzeit darf die über xrEnumerateDepthResolutionsANDROID zurückgegebenen Tiefenbildauflösungen während des Lebenszyklus der Anwendung nicht ändern.

Berechtigungen

Diese Erweiterung stellt eine downsampled-Tiefentextur zur Verfügung, um Bedenken hinsichtlich personenidentifizierbarer Informationen zu minimieren. Android-Anwendungen müssen die Berechtigung „android.permission.SCENE_UNDERSTANDING_FINE“ in ihrem Manifest aufführen, da diese Erweiterung die Geometrie der Umgebung offenlegt. Die Berechtigung „android.permission.SCENE_UNDERSTANDING_FINE“ gilt als gefährliche Berechtigung. Die App muss die Berechtigung zur Laufzeit anfordern, um diese Funktionen zu verwenden:

(Schutzebene: gefährlich)

Systemfunktionen prüfen

Die Struktur XrSystemDepthTrackingPropertiesANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • supportsDepthTracking ist ein XrBool32-Wert, der angibt, ob das aktuelle System die Tiefenmessung unterstützt.

Eine Anwendung kann prüfen, ob das System Tiefenmessung unterstützt, indem sie die XrSystemProperties beim Aufrufen von xrGetSystemProperties mit der Struktur XrSystemDepthTrackingPropertiesANDROID erweitert .

Wenn und nur wenn eine Laufzeit XR_FALSE für supportsDepthTracking zurückgibt , muss die Laufzeit XR_ERROR_FEATURE_UNSUPPORTED von xrCreateDepthSwapchainANDROID zurückgeben .

Gültige Nutzung (implizit)

Lösungen für die Suchtiefe

Die Funktion xrEnumerateDepthResolutionsANDROID ist so definiert:

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

Parameterbeschreibungen

  • session ist die XrSession, in der die unterstützten Tiefenauflösungen aufgelistet werden.
  • resolutionCapacityInput ist die Kapazität von resolutions oder 0 , um die erforderliche Kapazität abzurufen.
  • resolutionCountOutput ist ein Zeiger auf die Anzahl der geschriebenen uint64_t resolutions oder ein Zeiger auf die erforderliche Kapazität, falls resolutionCapacityInput nicht ausreicht.
  • resolutions ist ein Zeiger auf ein Array von XrDepthCameraResolutionANDROID, kann aber NULL sein, wenn resolutionCapacityInput 0 ist.
  • Eine detaillierte Beschreibung zum Abrufen der erforderlichen resolutions-Größe finden Sie im Abschnitt Puffergrößenparameter.

xrEnumerateDepthResolutionsANDROID listet die von der aktuellen Sitzung unterstützten Tiefenauflösungen auf. Die Tiefenauflösungen sollten nach der Laufzeitpräferenz sortiert sein, von der höchsten zur niedrigsten. Die Anwendung sollte die höchste unterstützte Einstellung für optimale Leistung und Qualität verwenden.

Runtimes müssen für die gesamte Dauer der Sitzung immer identische Pufferinhalte aus dieser Aufzählung zurückgeben.

Gültige Nutzung (implizit)

  •  Die Erweiterung XR_ANDROID_depth_texture muss aktiviert sein, bevor xrEnumerateDepthResolutionsANDROID aufgerufen wird.
  • session muss ein gültiger XrSession-Handle sein
  • resolutionCountOutput muss ein Zeiger auf einen uint32_t-Wert sein.
  • Wenn resolutionCapacityInput nicht 0 ist , resolutions muss ein Zeiger auf ein Array von resolutionCapacityInput XrDepthCameraResolutionANDROID-Werten sein.

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Enumeration XrDepthCameraResolutionANDROID beschreibt die unterstützten Tiefenauflösungen beim Erstellen einer 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;

Beschreibungen der Aufzählungswerte

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID: Die Auflösung der Tiefen- und Konfidenzbilder beträgt 80 × 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID – Die Auflösung der Tiefen- und Vertrauensbilder beträgt 160 × 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID: Die Auflösung der Tiefen- und Vertrauenswürdigkeitsbilder beträgt 320 × 320.

Tiefen-Swapchain erstellen

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Ein XrDepthSwapchainANDROID ist ein Handle für eine Depth-Swapchain.

Die Funktion xrCreateDepthSwapchainANDROID ist so definiert:

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

Parameterbeschreibungen

Die Anwendung kann die Funktion xrCreateDepthSwapchainANDROID verwenden, um eine Depth-Swapchain zu erstellen, die sowohl Tiefen- als auch Vertrauensbilder verwaltet.

  • Die Laufzeit muss XR_ERROR_FEATURE_UNSUPPORTED zurückgeben, wenn das System keine Tiefenverfolgung unterstützt.
  • Die Laufzeit muss XR_ERROR_PERMISSION_INSUFFICIENT zurückgeben, wenn der Anruf-App die erforderlichen Berechtigungen nicht erteilt wurden.
  • Die Laufzeit muss XR_ERROR_VALIDATION_FAILURE zurückgeben, wenn die in XrDepthSwapchainCreateInfoANDROID angegebene Tiefenauflösung nicht unterstützt wird.
  • Die Laufzeit sollte nur dann Bilder mit Tiefenkonfidenz erstellen, wenn die entsprechenden Bits für createInfo beim Erstellen der Swapchain festgelegt sind.

Das zurückgegebene Handle für die Tiefen-Swapchain kann anschließend in API-Aufrufen verwendet werden. Das XrDepthSwapchainANDROID-Handle muss schließlich über die Funktion xrDestroyDepthSwapchainANDROID freigegeben werden.

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Struktur XrDepthSwapchainCreateInfoANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • resolution ist die XrDepthCameraResolutionANDROID, mit der die Tiefen- und Vertrauenswürdigkeitstexturen erstellt werden.
  • createFlags ist ein oder mehrere XrDepthSwapchainCreateFlagsANDROID .

Die Struktur XrDepthSwapchainCreateInfoANDROID bietet Erstellungsoptionen für die XrDepthSwapchainANDROID, wenn sie an xrCreateDepthSwapchainANDROID übergeben wird .

Gültige Nutzung (implizit)

Mit XrDepthSwapchainCreateFlagsANDROID werden Erstellungsoptionen für XrDepthSwapchainANDROID angegeben .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

Gültige Bits für XrDepthSwapchainCreateFlagsANDROID werden durch XrDepthSwapchainCreateFlagBitsANDROID definiert , das so angegeben wird:

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

Flag-Beschreibungen

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID: Gibt an, dass der Swapchain flüssige Tiefenbilder bereitstellt.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID: Gibt an, dass der Swapchain flüssige Bilder mit Tiefenkonfidenz bereitstellt.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID: Gibt an, dass der Swapchain Rohbilder mit Tiefeninformationen bereitstellt.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID: Gibt an, dass die Swapchain Rohdaten-Bilder für die Tiefenkonfidenz bereitstellt.

Die Funktion xrDestroyDepthSwapchainANDROID ist so definiert:

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Parameterbeschreibungen

Mit der Funktion xrDestroyDepthSwapchainANDROID wird die Depth-Swapchain zerstört. Nach diesem Aufruf kann die Laufzeit den gesamten zugehörigen Speicher und alle zugehörigen Ressourcen freigeben.

Gültige Nutzung (implizit)

Threadsicherheit

  • Der Zugriff auf swapchain und alle untergeordneten Handles muss extern synchronisiert werden.

Rückgabecodes

Erfolg

  • XR_SUCCESS

Fehler

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Tiefentexturen abrufen

Die Funktion xrEnumerateDepthSwapchainImagesANDROID ist so definiert:

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

Parameterbeschreibungen

  • depthSwapchain ist die XrDepthSwapchainANDROID, aus der Bilder abgerufen werden sollen.
  • depthImageCapacityInput ist die Kapazität des depthImages-Arrays oder 0, um eine Anfrage zum Abrufen der erforderlichen Kapazität anzugeben.
  • depthImageCountOutput ist ein Zeiger auf die Anzahl der geschriebenen depthImages oder ein Zeiger auf die erforderliche Kapazität, falls depthImageCapacityInput nicht ausreicht.
  • depthImages ist ein Zeiger auf ein Array von XrDepthSwapchainImageANDROID-Strukturen. Kann NULL sein, wenn depthImageCapacityInput = 0.
  • Eine detaillierte Beschreibung zum Abrufen der erforderlichen depthImages-Größe finden Sie im Abschnitt Puffergrößenparameter.

xrEnumerateDepthSwapchainImagesANDROID füllt ein Array von XrDepthSwapchainImageANDROID-Strukturen aus. Die Ressourcen müssen konstant und für die gesamte Lebensdauer von XrDepthSwapchainANDROID gültig sein . Diese Funktion verhält sich analog zu xrEnumerateSwapchainImages .

Die Laufzeit muss während der gesamten Lebensdauer der Swapchain immer identische Pufferinhalte aus dieser Aufzählung zurückgeben.

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Struktur XrDepthSwapchainImageANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • rawDepthImage ist NULL oder der Zeiger auf Rohbilder mit Tiefeninformationen für die linke und rechte Ansicht, die von der Laufzeit zugewiesen werden. Die Werte haben die Einheit Meter. Sonderwerte: 0.0 gibt einen ungültigen oder leeren Tiefenpixel in der Roh-Tiefe an, Inf gibt eine bekannte Tiefe an, die effektiv unendlich weit entfernt ist.
  • rawDepthConfidenceImage ist NULL oder der Zeiger auf Rohbilder für die Tiefenvertrauenswürdigkeit für die linke und rechte Ansicht, die von der Laufzeit zugewiesen werden.
  • smoothDepthImage ist NULL oder der Zeiger auf geglättete Tiefenbilder für die linke und rechte Ansicht, die von der Laufzeit zugewiesen werden. Die Werte haben die Einheit Meter. Sonderwerte: 0.0 gibt einen ungültigen oder leeren Tiefenpixel in der geglätteten Tiefe an, Inf gibt eine bekannte Tiefe an, die effektiv unendlich weit entfernt ist.
  • smoothDepthConfidenceImage ist NULL oder der Zeiger auf geglättete Bilder mit Tiefenvertrauen für die linke und rechte Ansicht, die von der Laufzeit zugewiesen werden.

Die Bildpuffer-Pointer sind nur während der Lebensdauer der Swapchain gültig. Sobald die Swapchain zerstört ist, gelten die Zeiger als „dangling“ (nicht mehr gültig).

XrDepthSwapchainImageANDROID stellt die Tiefenbilder aus einer lesbaren XrDepthSwapchainANDROID dar, die wie in XrDepthSwapchainCreateInfoANDROID :: resolution und XrDepthSwapchainCreateInfoANDROID :: createFlags beschrieben zugewiesen werden, während xrCreateDepthSwapchainANDROID aufgerufen wird . Für jedes Tiefenbild:

Gültige Nutzung (implizit)

Die Funktion xrAcquireDepthSwapchainImagesANDROID ist so definiert:

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

Parameterbeschreibungen

Anwendungen können die Funktion xrAcquireDepthSwapchainImagesANDROID verwenden, um den neuesten verfügbaren Swapchain-Image-Index, d.h. XrDepthAcquireResultANDROID :: acquiredIndex , in das Array XrDepthSwapchainImageANDROID abzurufen, das von xrEnumerateDepthSwapchainImagesANDROID aufgezählt wird . Das zurückgegebene XrDepthAcquireResultANDROID enthält auch andere Informationen wie das Sichtfeld und die Pose, die zum Interpretieren der Tiefendaten erforderlich sind. Es ist sicher, bis zum nächsten Aufruf von xrAcquireDepthSwapchainImagesANDROID aus dem erworbenen Slot im Bild-Array zu lesen .

Zwischen zwei entsprechenden xrBeginFrame- und xrEndFrame-Aufrufen in einer Sitzung darf es höchstens einen Aufruf von xrAcquireDepthSwapchainImagesANDROID geben.

  • Die Laufzeit kann blockieren, wenn zuvor abgerufene Swapchain-Bilder noch von der Laufzeit verwendet werden.
  • Die Laufzeit muss XR_ERROR_CALL_ORDER_INVALID zurückgeben, wenn xrAcquireDepthSwapchainImagesANDROID vor xrBeginFrame oder nach xrEndFrame aufgerufen wird .
  • Die Laufzeit muss XR_ERROR_LIMIT_REACHED zurückgeben, wenn xrAcquireDepthSwapchainImagesANDROID mehr als einmal pro Frame aufgerufen wird, d.h. in einer laufenden Sitzung nach einem Aufruf von xrBeginFrame, dem kein zugehöriges xrEndFrame folgt .
  • Die Laufzeit kann XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID zurückgeben, wenn noch keine Daten zur Umgebungstiefe verfügbar sind. In diesem Fall sollte die Anwendung in einem späteren Frame noch einmal xrAcquireDepthSwapchainImagesANDROID aufrufen.

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Struktur XrDepthAcquireInfoANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • space ist ein XrSpace, der den Referenzrahmen der zurückgegebenen Pose in XrDepthAcquireResultANDROID :: views definiert .
  • displayTime ist ein XrTime, der die Zeit angibt, die zum Berechnen der Pose für die zurückgegebene Pose in XrDepthAcquireResultANDROID :: views verwendet wird . Anwendungen sollten die vorhergesagte Anzeigezeit für den aktuellen Frame übergeben.

Gültige Nutzung (implizit)

Die Struktur XrDepthAcquireResultANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • acquiredIndex ist der Index der erfassten Textur im XrDepthSwapchainImageANDROID-Array, das von xrEnumerateDepthSwapchainImagesANDROID aufgezählt wird .
  • exposureTimestamp ist der XrTime-Wert, der den Zeitpunkt angibt, zu dem die Tiefenkarte aufgenommen wurde.
  • views ist ein Array mit zwei XrDepthViewANDROID, einem für jedes Auge. Index 0 ist das linke Auge und Index 1 das rechte Auge.

Gültige Nutzung (implizit)

Die Struktur XrDepthViewANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • fov ist ein XrFovf, das das Sichtfeld angibt, das zum Generieren dieser Ansicht verwendet wurde. Die Ansicht wird weder horizontal noch vertikal gespiegelt.
  • pose ist ein XrPosef, das die Pose angibt, aus der die Tiefenkarte gerendert wurde. Der Referenzrahmen wird in XrDepthAcquireInfoANDROID angegeben .

Gültige Nutzung (implizit)

Beispielcode für die Tiefenverfolgung

Der folgende Beispielcode zeigt, wie Sie Tiefenbilder erfassen und Tiefenwerte verwenden, um Tiefenbildkoordinaten dem Anzeigebereich zuzuordnen.

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

Neue Objekttypen

Neue Befehle

Neue Strukturen

Neue Enums

Neue Bitmasken

Neue Enum-Konstanten

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • XrObjectType erweitern :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • XrResult erweitern :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Erweitern von 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

Probleme

Versionsverlauf

  • Revision 1, 09.09.2024 (Levana Chen)

    • Erste Beschreibung der Erweiterung