Struct XrAndroidDepthTexture 

pub struct XrAndroidDepthTexture { /* private fields */ }

Main extension handler for Android depth texture functionality

This struct manages the XR_ANDROID_depth_texture extension, providing access to:

• Depth and confidence texture data from device sensors
• Multiple resolution options (quarter, half, full)
• Both raw and processed depth information
• Swapchain management for efficient rendering

###Examples

use stereokit_rust::tools::xr_android_depth_texture::*;

number_of_steps = 50;
test_steps!( // !!!! Get a proper main loop !!!!
    if iter == 10 {
        // Initialize extension and check system support
        if let Some(depth_ext) = XrAndroidDepthTexture::new() {
            // Check system support with logging
            match depth_ext.check_system_support(true) {
                Ok(_system_props) => {
                    stereokit_rust::system::Log::info("✅ System supports depth tracking");
                     
                    // Continue with depth texture operations...
                    let session = openxr_sys::Session::from_raw(
                        stereokit_rust::system::BackendOpenXR::session()
                    );
                     
                    // Create depth swapchain with smooth and raw depth images
                    let swapchain_info = create_depth_swapchain_info(
                        XR_DEPTH_RESOLUTION_HALF_ANDROID,
                        XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID
                            | XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID
                    );
                     
                    match depth_ext.create_depth_swapchain(session, &swapchain_info) {
                        Ok(swapchain) => {
                            stereokit_rust::system::Log::info("✅ Depth swapchain created!");
                             
                            // Enumerate swapchain images
                            if let Ok(images) = depth_ext.enumerate_depth_swapchain_images(swapchain) {
                                stereokit_rust::system::Log::info(
                                    format!("Found {} swapchain images", images.len())
                                );
                            }
                             
                            // Test image acquisition
                            if let Ok(index) = depth_ext.acquire_depth_swapchain_image(session, swapchain) {
                                stereokit_rust::system::Log::info(
                                    format!("Acquired image at index: {}", index)
                                );
                            }
                             
                            // Cleanup
                            let _ = depth_ext.destroy_depth_swapchain(swapchain);
                            stereokit_rust::system::Log::info("✅ Swapchain test completed!");
                        }
                        Err(e) => stereokit_rust::system::Log::err(format!("Swapchain creation failed: {}", e)),
                    }
                }
                Err(e) => stereokit_rust::system::Log::err(format!("System support check failed: {:?}", e)),
            }
        }
    }
);

Depth Resolution Enumeration Example

use stereokit_rust::tools::xr_android_depth_texture::*;

number_of_steps = 20;
test_steps!( // !!!! Get a proper main loop !!!!
    if iter == 5 {
        // Test depth resolution enumeration and analysis
        if let Some(depth_ext) = XrAndroidDepthTexture::new() {
            let session = openxr_sys::Session::from_raw(
                stereokit_rust::system::BackendOpenXR::session()
            );
             
            match depth_ext.enumerate_depth_resolutions(session) {
                Ok(resolutions) => {
                    stereokit_rust::system::Log::info(
                        format!("✅ Found {} supported depth resolutions", resolutions.len())
                    );
                     
                    for (i, resolution) in resolutions.iter().enumerate() {
                        let (width, height) = get_resolution_dimensions(*resolution);
                        let resolution_name = match *resolution {
                            XR_DEPTH_RESOLUTION_QUARTER_ANDROID => "Quarter",
                            XR_DEPTH_RESOLUTION_HALF_ANDROID => "Half",
                            XR_DEPTH_RESOLUTION_FULL_ANDROID => "Full",
                            _ => "Unknown",
                        };
                         
                        stereokit_rust::system::Log::info(format!(
                            "  Resolution {}: {} ({}x{}) - enum: {}",
                            i, resolution_name, width, height, resolution
                        ));
                    }
                     
                    stereokit_rust::system::Log::info("✅ Resolution enumeration completed!");
                }
                Err(e) => stereokit_rust::system::Log::err(
                    format!("Resolution enumeration failed: {}", e)
                ),
            }
        }
    }
);

Implementations

impl XrAndroidDepthTexture

pub fn new() -> Option<Self>

Create and initialize a new AndroidDepthTextureExtension instance

This method combines creation and initialization, checking extension availability and loading all necessary OpenXR functions for depth texture operations.

Returns

• Some(Self) if extension is available and initialization succeeds
• None if extension is not available or initialization fails

pub fn check_system_support( &self, with_log: bool, ) -> Result<SystemProperties, Result>

Check if the system supports depth tracking

Parameters

• with_log: If true, outputs system properties to diagnostic log

Returns

Ok(SystemProperties) with depth tracking properties if supported, or error on failure

pub fn enumerate_depth_resolutions( &self, session: Session, ) -> Result<Vec<DepthResolutionAndroid>, String>

Wrapper methods used by lib.rs Enumerate available depth resolutions supported by the device

Arguments

• session - The OpenXR session

Returns

Vector of supported depth resolution enum values

pub fn create_depth_swapchain( &self, session: Session, create_info: &DepthSwapchainCreateInfoAndroid, ) -> Result<Swapchain, String>

Create a depth swapchain for rendering depth textures

Arguments

• session - The OpenXR session
• create_info - Configuration for the depth swapchain

Returns

Handle to the created swapchain or error description

pub fn enumerate_depth_swapchain_images( &self, swapchain: Swapchain, ) -> Result<Vec<DepthSwapchainImageAndroid>, String>

Enumerate the images in a depth swapchain

Arguments

• swapchain - The depth swapchain to enumerate

Returns

Vector of depth swapchain images with texture handles

pub fn destroy_depth_swapchain( &self, swapchain: Swapchain, ) -> Result<(), String>

Destroy a previously created depth swapchain

Arguments

• swapchain - The depth swapchain to destroy

Returns

Ok(()) on success or error description on failure

pub fn acquire_depth_swapchain_image( &self, session: Session, swapchain: Swapchain, ) -> Result<u32, String>

Acquire an image from a depth swapchain

Arguments

• session - The OpenXR session
• swapchain - The depth swapchain to acquire from

Returns

Index of the acquired image or error description

Trait Implementations

impl Debug for XrAndroidDepthTexture

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for XrAndroidDepthTexture

fn default() -> Self

Returns the “default value” for a type.