From 8279b5fb275c81a43b48e3ffcbcbc5006c71e397 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Tue, 12 Sep 2023 23:57:39 +0200 Subject: [PATCH 1/7] Update OpenXR-SDK to 1.0.29 --- generator/src/main.rs | 44 +- openxr/src/generated.rs | 1489 ++++++- openxr/src/lib.rs | 2 +- sys/OpenXR-SDK | 2 +- sys/src/generated.rs | 8890 ++++++++++++++++++++++++++------------- sys/src/lib.rs | 15 + sys/src/platform.rs | 2 +- 7 files changed, 7319 insertions(+), 3125 deletions(-) diff --git a/generator/src/main.rs b/generator/src/main.rs index 13613a9c..155f51b1 100644 --- a/generator/src/main.rs +++ b/generator/src/main.rs @@ -78,6 +78,7 @@ impl Parser { extensions: IndexMap::new(), // TODO: Handle these extensions disabled_exts: [ + "XR_HTC_passthrough", "XR_MSFT_scene_understanding", "XR_MSFT_scene_understanding_serialization", ] @@ -312,16 +313,16 @@ impl Parser { if attr(attrs, "supported").map_or(false, |x| x == "disabled") { self.disabled_exts.insert(ext_name); } else { - let (tag, _) = split_ext_tag(&ext_name); - self.extensions - .get_mut(tag) - .unwrap() - .extensions - .push(Extension { + let (tag_name, _) = split_ext_tag(&ext_name); + if let Some(tag) = self.extensions.get_mut(tag_name) { + tag.extensions.push(Extension { name: ext_name, version: ext_version.unwrap(), commands, }); + } else { + eprintln!("ignoring extension with unlisted tag: {}", ext_name); + } } } @@ -546,6 +547,11 @@ impl Parser { } fn parse_struct(&mut self, attrs: &[OwnedAttribute]) { + const STRUCTS_BLACKLIST: [&str; 3] = [ + "XrCompositionLayerPassthroughHTC", + "XrPassthroughColorHTC", + "XrPassthroughHTC", + ]; let struct_name = attr(attrs, "name").unwrap(); let mut members = Vec::new(); let mut ty = None; @@ -579,10 +585,21 @@ impl Parser { _ => {} } } - let parent: Option = attr(attrs, "parentstruct").map(|x| x.into()); - if let Some(ref parent) = parent { + if STRUCTS_BLACKLIST.contains(&struct_name) { + return; + } + if let Some(structextends) = attr(attrs, "structextends") { + if STRUCTS_BLACKLIST.contains(&structextends) { + return; + } + } + let parent = attr(attrs, "parentstruct"); + if let Some(parent) = parent { + if STRUCTS_BLACKLIST.contains(&parent) { + return; + } self.base_headers - .entry(parent.clone()) + .entry(parent.into()) .or_insert_with(Vec::new) .push(struct_name.into()); } @@ -1098,6 +1115,8 @@ impl Parser { quote! { #[derive(Copy, Clone)] } } else if meta.has_pointer || meta.has_array { quote! { #[derive(Copy, Clone, Debug)] } + } else if meta.has_non_default { + quote! { #[derive(Copy, Clone, Debug, PartialEq)] } } else { quote! { #[derive(Copy, Clone, Debug, Default, PartialEq)] } }; @@ -1214,6 +1233,7 @@ impl Parser { /// Function pointer prototypes pub mod pfn { use super::*; + pub use crate::platform::EglGetProcAddressMNDX; pub type VoidFunction = unsafe extern "system" fn(); pub type DebugUtilsMessengerCallbackEXT = unsafe extern "system" fn( @@ -1601,10 +1621,14 @@ impl Parser { out.has_pointer |= member.ptr_depth != 0 || self.handles.contains(&member.ty); out.has_graphics |= member.ty == "XrSession" || member.ty == "XrSwapchain"; out.has_array |= member.static_array_len.is_some(); + out.has_non_default |= member.ty == "XrTime" || member.ty == "XrDuration"; if member.ty != name { if let Some(x) = self.structs.get(&member.ty) { out |= self.compute_meta(&member.ty, x); } + if self.enums.contains_key(&member.ty) { + out.has_non_default = true; + } } } out @@ -1984,6 +2008,7 @@ struct StructMeta { has_pointer: bool, has_array: bool, has_graphics: bool, + has_non_default: bool, } impl StructMeta { @@ -2026,6 +2051,7 @@ impl std::ops::BitOrAssign for StructMeta { self.has_pointer |= rhs.has_pointer; self.has_array |= rhs.has_array; self.has_graphics |= rhs.has_graphics; + self.has_non_default |= self.has_non_default; } } diff --git a/openxr/src/generated.rs b/openxr/src/generated.rs index b902957c..5ff260ff 100644 --- a/openxr/src/generated.rs +++ b/openxr/src/generated.rs @@ -7,30 +7,44 @@ pub use sys::platform::{ EGLenum, VkComponentSwizzle, VkFilter, VkSamplerAddressMode, VkSamplerMipmapMode, }; pub use sys::{ - ActionType, AndroidSurfaceSwapchainFlagsFB, AndroidThreadTypeKHR, BlendFactorFB, Color4f, - ColorSpaceFB, CompositionLayerFlags, CompositionLayerImageLayoutFlagsFB, + ActionType, AndroidSurfaceSwapchainFlagsFB, AndroidThreadTypeKHR, BlendFactorFB, BodyJointFB, + BodyJointLocationFB, BodyJointSetFB, BodySkeletonJointFB, Color4f, ColorSpaceFB, CompareOpFB, + CompositionLayerFlags, CompositionLayerImageLayoutFlagsFB, CompositionLayerSecureContentFlagsFB, CompositionLayerSettingsFlagsFB, CompositionLayerSpaceWarpInfoFlagsFB, DebugUtilsMessageSeverityFlagsEXT, DebugUtilsMessageTypeFlagsEXT, DigitalLensControlFlagsALMALENCE, EnvironmentBlendMode, - Extent2Df, Extent2Di, Extent3DfFB, EyeExpressionHTC, EyeVisibility, FacialTrackingTypeHTC, - FormFactor, FoveationDynamicFB, FoveationLevelFB, Fovf, HandEXT, HandForearmJointULTRALEAP, - HandJointEXT, HandJointLocationEXT, HandJointSetEXT, HandJointVelocityEXT, - HandJointsMotionRangeEXT, HandMeshVertexMSFT, HandPoseTypeMSFT, HandTrackingAimFlagsFB, + Extent2Df, Extent2Di, Extent3DfEXT, Extent3DfFB, ExternalCameraAttachedToDeviceOCULUS, + ExternalCameraExtrinsicsOCULUS, ExternalCameraIntrinsicsOCULUS, + ExternalCameraStatusFlagsOCULUS, EyeExpressionHTC, EyePositionFB, EyeVisibility, + FaceConfidenceFB, FaceExpressionFB, FaceExpressionSetFB, FacialTrackingTypeHTC, + ForceFeedbackCurlApplyLocationMNDX, ForceFeedbackCurlLocationMNDX, FormFactor, + FoveationConfigurationHTC, FoveationDynamicFB, FoveationDynamicFlagsHTC, + FoveationEyeTrackedProfileCreateFlagsMETA, FoveationEyeTrackedStateFlagsMETA, FoveationLevelFB, + FoveationLevelHTC, FoveationModeHTC, Fovf, FrameEndInfoFlagsML, + GlobalDimmerFrameEndInfoFlagsML, HandEXT, HandForearmJointULTRALEAP, HandJointEXT, + HandJointLocationEXT, HandJointSetEXT, HandJointVelocityEXT, HandJointsMotionRangeEXT, + HandMeshVertexMSFT, HandPoseTypeMSFT, HandTrackingAimFlagsFB, HandTrackingDataSourceEXT, InputSourceLocalizedNameFlags, InstanceCreateFlags, KeyboardTrackingFlagsFB, - KeyboardTrackingQueryFlagsFB, LipExpressionHTC, MeshComputeLodMSFT, ObjectType, Offset2Df, - Offset2Di, Offset3DfFB, OverlayMainSessionFlagsEXTX, OverlaySessionCreateFlagsEXTX, - PassthroughCapabilityFlagsFB, PassthroughFlagsFB, PassthroughLayerPurposeFB, - PassthroughStateChangedFlagsFB, PerfSettingsDomainEXT, PerfSettingsLevelEXT, - PerfSettingsNotificationLevelEXT, PerfSettingsSubDomainEXT, PerformanceMetricsCounterFlagsMETA, - PerformanceMetricsCounterUnitMETA, Posef, Quaternionf, Rect2Df, Rect2Di, Rect3DfFB, - ReferenceSpaceType, RenderModelFlagsFB, ReprojectionModeMSFT, SceneComponentTypeMSFT, - SceneComputeConsistencyMSFT, SceneComputeFeatureMSFT, SceneComputeStateMSFT, - SceneObjectTypeMSFT, ScenePlaneAlignmentTypeMSFT, SessionCreateFlags, SessionState, - SpaceComponentTypeFB, SpaceLocationFlags, SpacePersistenceModeFB, SpaceQueryActionFB, - SpaceStorageLocationFB, SpaceVelocityFlags, SpatialGraphNodeTypeMSFT, StructureType, - SwapchainCreateFlags, SwapchainCreateFoveationFlagsFB, SwapchainStateFoveationFlagsFB, - SwapchainUsageFlags, SystemGraphicsProperties, TriangleMeshFlagsFB, Vector2f, Vector3f, - Vector4f, Vector4sFB, ViewConfigurationType, ViewStateFlags, VisibilityMaskTypeKHR, + KeyboardTrackingQueryFlagsFB, LipExpressionHTC, LocalDimmingModeMETA, MeshComputeLodMSFT, + ObjectType, Offset2Df, Offset2Di, Offset3DfFB, OverlayMainSessionFlagsEXTX, + OverlaySessionCreateFlagsEXTX, PassthroughCapabilityFlagsFB, PassthroughColorLutChannelsMETA, + PassthroughFlagsFB, PassthroughFormHTC, PassthroughLayerPurposeFB, + PassthroughPreferenceFlagsMETA, PassthroughStateChangedFlagsFB, PerfSettingsDomainEXT, + PerfSettingsLevelEXT, PerfSettingsNotificationLevelEXT, PerfSettingsSubDomainEXT, + PerformanceMetricsCounterFlagsMETA, PerformanceMetricsCounterUnitMETA, + PlaneDetectionCapabilityFlagsEXT, PlaneDetectionStateEXT, PlaneDetectorFlagsEXT, + PlaneDetectorOrientationEXT, PlaneDetectorSemanticTypeEXT, Posef, Quaternionf, Rect2Df, + Rect2Di, Rect3DfFB, ReferenceSpaceType, RenderModelFlagsFB, ReprojectionModeMSFT, + SceneComponentTypeMSFT, SceneComputeConsistencyMSFT, SceneComputeFeatureMSFT, + SceneComputeStateMSFT, SceneObjectTypeMSFT, ScenePlaneAlignmentTypeMSFT, + SemanticLabelsSupportFlagsFB, SessionCreateFlags, SessionState, SpaceComponentTypeFB, + SpaceLocationFlags, SpacePersistenceModeFB, SpaceQueryActionFB, SpaceStorageLocationFB, + SpaceVelocityFlags, SpatialGraphNodeTypeMSFT, StructureType, SwapchainCreateFlags, + SwapchainCreateFoveationFlagsFB, SwapchainStateFoveationFlagsFB, SwapchainUsageFlags, + SystemGraphicsProperties, TrackingOptimizationSettingsDomainQCOM, + TrackingOptimizationSettingsHintQCOM, TriangleMeshFlagsFB, Vector2f, Vector3f, Vector4f, + Vector4sFB, ViewConfigurationType, ViewStateFlags, VirtualKeyboardInputSourceMETA, + VirtualKeyboardInputStateFlagsMETA, VirtualKeyboardLocationTypeMETA, VisibilityMaskTypeKHR, VulkanDeviceCreateFlagsKHR, VulkanInstanceCreateFlagsKHR, WindingOrderFB, }; #[doc = r" A subset of known extensions"] @@ -38,6 +52,7 @@ pub use sys::{ #[non_exhaustive] pub struct ExtensionSet { pub almalence_digital_lens_control: bool, + pub bd_controller_interaction: bool, pub epic_view_configuration_fov: bool, pub ext_performance_settings: bool, pub ext_thermal_query: bool, @@ -54,13 +69,18 @@ pub struct ExtensionSet { pub ext_hp_mixed_reality_controller: bool, pub ext_palm_pose: bool, pub ext_uuid: bool, - pub extx_overlay: bool, + pub ext_hand_interaction: bool, + pub ext_active_action_set_priority: bool, + pub ext_local_floor: bool, + pub ext_hand_tracking_data_source: bool, + pub ext_plane_detection: bool, pub fb_composition_layer_image_layout: bool, pub fb_composition_layer_alpha_blend: bool, #[cfg(target_os = "android")] pub fb_android_surface_swapchain_create: bool, pub fb_swapchain_update_state: bool, pub fb_composition_layer_secure_content: bool, + pub fb_body_tracking: bool, pub fb_display_refresh_rate: bool, pub fb_color_space: bool, pub fb_hand_tracking_mesh: bool, @@ -80,17 +100,28 @@ pub struct ExtensionSet { pub fb_swapchain_update_state_android_surface: bool, pub fb_swapchain_update_state_opengl_es: bool, pub fb_swapchain_update_state_vulkan: bool, + pub fb_touch_controller_pro: bool, + pub fb_spatial_entity_sharing: bool, pub fb_space_warp: bool, + pub fb_haptic_amplitude_envelope: bool, pub fb_scene: bool, + pub fb_scene_capture: bool, pub fb_spatial_entity_container: bool, + pub fb_face_tracking: bool, + pub fb_eye_tracking_social: bool, pub fb_passthrough_keyboard_hands: bool, pub fb_composition_layer_settings: bool, + pub fb_touch_controller_proximity: bool, + pub fb_haptic_pcm: bool, + pub fb_composition_layer_depth_test: bool, + pub fb_spatial_entity_storage_batch: bool, + pub fb_spatial_entity_user: bool, pub htc_vive_cosmos_controller_interaction: bool, pub htc_facial_tracking: bool, pub htc_vive_focus3_controller_interaction: bool, pub htc_hand_interaction: bool, pub htc_vive_wrist_tracker_interaction: bool, - pub htcx_vive_tracker_interaction: bool, + pub htc_foveation: bool, pub huawei_controller_interaction: bool, #[cfg(target_os = "android")] pub khr_android_thread_settings: bool, @@ -122,12 +153,20 @@ pub struct ExtensionSet { pub khr_composition_layer_equirect2: bool, pub khr_binding_modification: bool, pub khr_swapchain_usage_input_attachment_bit: bool, + pub meta_foveation_eye_tracked: bool, + pub meta_local_dimming: bool, + pub meta_passthrough_preferences: bool, + pub meta_virtual_keyboard: bool, pub meta_vulkan_swapchain_create_info: bool, pub meta_performance_metrics: bool, + pub meta_headset_id: bool, + pub meta_passthrough_color_lut: bool, pub ml_ml2_controller_interaction: bool, + pub ml_frame_end_info: bool, + pub ml_global_dimmer: bool, + pub ml_compat: bool, pub mnd_headless: bool, pub mnd_swapchain_usage_input_attachment_bit: bool, - pub mndx_egl_enable: bool, pub msft_unbounded_reference_space: bool, pub msft_spatial_anchor: bool, pub msft_spatial_graph_bridge: bool, @@ -145,6 +184,9 @@ pub struct ExtensionSet { #[cfg(target_os = "android")] pub oculus_android_session_state_enable: bool, pub oculus_audio_device_guid: bool, + pub oculus_external_camera: bool, + pub oppo_controller_interaction: bool, + pub qcom_tracking_optimization_settings: bool, pub ultraleap_hand_tracking_forearm: bool, pub valve_analog_threshold: bool, pub varjo_quad_views: bool, @@ -164,6 +206,9 @@ impl ExtensionSet { raw::DigitalLensControlALMALENCE::NAME => { out.almalence_digital_lens_control = true; } + raw::ControllerInteractionBD::NAME => { + out.bd_controller_interaction = true; + } raw::ViewConfigurationFovEPIC::NAME => { out.epic_view_configuration_fov = true; } @@ -210,8 +255,20 @@ impl ExtensionSet { raw::UuidEXT::NAME => { out.ext_uuid = true; } - raw::OverlayEXTX::NAME => { - out.extx_overlay = true; + raw::HandInteractionEXT::NAME => { + out.ext_hand_interaction = true; + } + raw::ActiveActionSetPriorityEXT::NAME => { + out.ext_active_action_set_priority = true; + } + raw::LocalFloorEXT::NAME => { + out.ext_local_floor = true; + } + raw::HandTrackingDataSourceEXT::NAME => { + out.ext_hand_tracking_data_source = true; + } + raw::PlaneDetectionEXT::NAME => { + out.ext_plane_detection = true; } raw::CompositionLayerImageLayoutFB::NAME => { out.fb_composition_layer_image_layout = true; @@ -229,6 +286,9 @@ impl ExtensionSet { raw::CompositionLayerSecureContentFB::NAME => { out.fb_composition_layer_secure_content = true; } + raw::BodyTrackingFB::NAME => { + out.fb_body_tracking = true; + } raw::DisplayRefreshRateFB::NAME => { out.fb_display_refresh_rate = true; } @@ -284,21 +344,54 @@ impl ExtensionSet { raw::SwapchainUpdateStateVulkanFB::NAME => { out.fb_swapchain_update_state_vulkan = true; } + raw::TouchControllerProFB::NAME => { + out.fb_touch_controller_pro = true; + } + raw::SpatialEntitySharingFB::NAME => { + out.fb_spatial_entity_sharing = true; + } raw::SpaceWarpFB::NAME => { out.fb_space_warp = true; } + raw::HapticAmplitudeEnvelopeFB::NAME => { + out.fb_haptic_amplitude_envelope = true; + } raw::SceneFB::NAME => { out.fb_scene = true; } + raw::SceneCaptureFB::NAME => { + out.fb_scene_capture = true; + } raw::SpatialEntityContainerFB::NAME => { out.fb_spatial_entity_container = true; } + raw::FaceTrackingFB::NAME => { + out.fb_face_tracking = true; + } + raw::EyeTrackingSocialFB::NAME => { + out.fb_eye_tracking_social = true; + } raw::PassthroughKeyboardHandsFB::NAME => { out.fb_passthrough_keyboard_hands = true; } raw::CompositionLayerSettingsFB::NAME => { out.fb_composition_layer_settings = true; } + raw::TouchControllerProximityFB::NAME => { + out.fb_touch_controller_proximity = true; + } + raw::HapticPcmFB::NAME => { + out.fb_haptic_pcm = true; + } + raw::CompositionLayerDepthTestFB::NAME => { + out.fb_composition_layer_depth_test = true; + } + raw::SpatialEntityStorageBatchFB::NAME => { + out.fb_spatial_entity_storage_batch = true; + } + raw::SpatialEntityUserFB::NAME => { + out.fb_spatial_entity_user = true; + } raw::ViveCosmosControllerInteractionHTC::NAME => { out.htc_vive_cosmos_controller_interaction = true; } @@ -314,8 +407,8 @@ impl ExtensionSet { raw::ViveWristTrackerInteractionHTC::NAME => { out.htc_vive_wrist_tracker_interaction = true; } - raw::ViveTrackerInteractionHTCX::NAME => { - out.htcx_vive_tracker_interaction = true; + raw::FoveationHTC::NAME => { + out.htc_foveation = true; } raw::ControllerInteractionHUAWEI::NAME => { out.huawei_controller_interaction = true; @@ -396,24 +489,48 @@ impl ExtensionSet { raw::SwapchainUsageInputAttachmentBitKHR::NAME => { out.khr_swapchain_usage_input_attachment_bit = true; } + raw::FoveationEyeTrackedMETA::NAME => { + out.meta_foveation_eye_tracked = true; + } + raw::LocalDimmingMETA::NAME => { + out.meta_local_dimming = true; + } + raw::PassthroughPreferencesMETA::NAME => { + out.meta_passthrough_preferences = true; + } + raw::VirtualKeyboardMETA::NAME => { + out.meta_virtual_keyboard = true; + } raw::VulkanSwapchainCreateInfoMETA::NAME => { out.meta_vulkan_swapchain_create_info = true; } raw::PerformanceMetricsMETA::NAME => { out.meta_performance_metrics = true; } + raw::HeadsetIdMETA::NAME => { + out.meta_headset_id = true; + } + raw::PassthroughColorLutMETA::NAME => { + out.meta_passthrough_color_lut = true; + } raw::Ml2ControllerInteractionML::NAME => { out.ml_ml2_controller_interaction = true; } + raw::FrameEndInfoML::NAME => { + out.ml_frame_end_info = true; + } + raw::GlobalDimmerML::NAME => { + out.ml_global_dimmer = true; + } + raw::CompatML::NAME => { + out.ml_compat = true; + } raw::HeadlessMND::NAME => { out.mnd_headless = true; } raw::SwapchainUsageInputAttachmentBitMND::NAME => { out.mnd_swapchain_usage_input_attachment_bit = true; } - raw::EglEnableMNDX::NAME => { - out.mndx_egl_enable = true; - } raw::UnboundedReferenceSpaceMSFT::NAME => { out.msft_unbounded_reference_space = true; } @@ -459,6 +576,15 @@ impl ExtensionSet { raw::AudioDeviceGuidOCULUS::NAME => { out.oculus_audio_device_guid = true; } + raw::ExternalCameraOCULUS::NAME => { + out.oculus_external_camera = true; + } + raw::ControllerInteractionOPPO::NAME => { + out.oppo_controller_interaction = true; + } + raw::TrackingOptimizationSettingsQCOM::NAME => { + out.qcom_tracking_optimization_settings = true; + } raw::HandTrackingForearmULTRALEAP::NAME => { out.ultraleap_hand_tracking_forearm = true; } @@ -499,6 +625,11 @@ impl ExtensionSet { out.push(raw::DigitalLensControlALMALENCE::NAME.into()); } } + { + if self.bd_controller_interaction { + out.push(raw::ControllerInteractionBD::NAME.into()); + } + } { if self.epic_view_configuration_fov { out.push(raw::ViewConfigurationFovEPIC::NAME.into()); @@ -576,8 +707,28 @@ impl ExtensionSet { } } { - if self.extx_overlay { - out.push(raw::OverlayEXTX::NAME.into()); + if self.ext_hand_interaction { + out.push(raw::HandInteractionEXT::NAME.into()); + } + } + { + if self.ext_active_action_set_priority { + out.push(raw::ActiveActionSetPriorityEXT::NAME.into()); + } + } + { + if self.ext_local_floor { + out.push(raw::LocalFloorEXT::NAME.into()); + } + } + { + if self.ext_hand_tracking_data_source { + out.push(raw::HandTrackingDataSourceEXT::NAME.into()); + } + } + { + if self.ext_plane_detection { + out.push(raw::PlaneDetectionEXT::NAME.into()); } } { @@ -606,6 +757,11 @@ impl ExtensionSet { out.push(raw::CompositionLayerSecureContentFB::NAME.into()); } } + { + if self.fb_body_tracking { + out.push(raw::BodyTrackingFB::NAME.into()); + } + } { if self.fb_display_refresh_rate { out.push(raw::DisplayRefreshRateFB::NAME.into()); @@ -697,21 +853,51 @@ impl ExtensionSet { out.push(raw::SwapchainUpdateStateVulkanFB::NAME.into()); } } + { + if self.fb_touch_controller_pro { + out.push(raw::TouchControllerProFB::NAME.into()); + } + } + { + if self.fb_spatial_entity_sharing { + out.push(raw::SpatialEntitySharingFB::NAME.into()); + } + } { if self.fb_space_warp { out.push(raw::SpaceWarpFB::NAME.into()); } } + { + if self.fb_haptic_amplitude_envelope { + out.push(raw::HapticAmplitudeEnvelopeFB::NAME.into()); + } + } { if self.fb_scene { out.push(raw::SceneFB::NAME.into()); } } + { + if self.fb_scene_capture { + out.push(raw::SceneCaptureFB::NAME.into()); + } + } { if self.fb_spatial_entity_container { out.push(raw::SpatialEntityContainerFB::NAME.into()); } } + { + if self.fb_face_tracking { + out.push(raw::FaceTrackingFB::NAME.into()); + } + } + { + if self.fb_eye_tracking_social { + out.push(raw::EyeTrackingSocialFB::NAME.into()); + } + } { if self.fb_passthrough_keyboard_hands { out.push(raw::PassthroughKeyboardHandsFB::NAME.into()); @@ -722,6 +908,31 @@ impl ExtensionSet { out.push(raw::CompositionLayerSettingsFB::NAME.into()); } } + { + if self.fb_touch_controller_proximity { + out.push(raw::TouchControllerProximityFB::NAME.into()); + } + } + { + if self.fb_haptic_pcm { + out.push(raw::HapticPcmFB::NAME.into()); + } + } + { + if self.fb_composition_layer_depth_test { + out.push(raw::CompositionLayerDepthTestFB::NAME.into()); + } + } + { + if self.fb_spatial_entity_storage_batch { + out.push(raw::SpatialEntityStorageBatchFB::NAME.into()); + } + } + { + if self.fb_spatial_entity_user { + out.push(raw::SpatialEntityUserFB::NAME.into()); + } + } { if self.htc_vive_cosmos_controller_interaction { out.push(raw::ViveCosmosControllerInteractionHTC::NAME.into()); @@ -748,8 +959,8 @@ impl ExtensionSet { } } { - if self.htcx_vive_tracker_interaction { - out.push(raw::ViveTrackerInteractionHTCX::NAME.into()); + if self.htc_foveation { + out.push(raw::FoveationHTC::NAME.into()); } } { @@ -879,6 +1090,26 @@ impl ExtensionSet { out.push(raw::SwapchainUsageInputAttachmentBitKHR::NAME.into()); } } + { + if self.meta_foveation_eye_tracked { + out.push(raw::FoveationEyeTrackedMETA::NAME.into()); + } + } + { + if self.meta_local_dimming { + out.push(raw::LocalDimmingMETA::NAME.into()); + } + } + { + if self.meta_passthrough_preferences { + out.push(raw::PassthroughPreferencesMETA::NAME.into()); + } + } + { + if self.meta_virtual_keyboard { + out.push(raw::VirtualKeyboardMETA::NAME.into()); + } + } { if self.meta_vulkan_swapchain_create_info { out.push(raw::VulkanSwapchainCreateInfoMETA::NAME.into()); @@ -889,11 +1120,36 @@ impl ExtensionSet { out.push(raw::PerformanceMetricsMETA::NAME.into()); } } + { + if self.meta_headset_id { + out.push(raw::HeadsetIdMETA::NAME.into()); + } + } + { + if self.meta_passthrough_color_lut { + out.push(raw::PassthroughColorLutMETA::NAME.into()); + } + } { if self.ml_ml2_controller_interaction { out.push(raw::Ml2ControllerInteractionML::NAME.into()); } } + { + if self.ml_frame_end_info { + out.push(raw::FrameEndInfoML::NAME.into()); + } + } + { + if self.ml_global_dimmer { + out.push(raw::GlobalDimmerML::NAME.into()); + } + } + { + if self.ml_compat { + out.push(raw::CompatML::NAME.into()); + } + } { if self.mnd_headless { out.push(raw::HeadlessMND::NAME.into()); @@ -904,11 +1160,6 @@ impl ExtensionSet { out.push(raw::SwapchainUsageInputAttachmentBitMND::NAME.into()); } } - { - if self.mndx_egl_enable { - out.push(raw::EglEnableMNDX::NAME.into()); - } - } { if self.msft_unbounded_reference_space { out.push(raw::UnboundedReferenceSpaceMSFT::NAME.into()); @@ -982,6 +1233,21 @@ impl ExtensionSet { out.push(raw::AudioDeviceGuidOCULUS::NAME.into()); } } + { + if self.oculus_external_camera { + out.push(raw::ExternalCameraOCULUS::NAME.into()); + } + } + { + if self.oppo_controller_interaction { + out.push(raw::ControllerInteractionOPPO::NAME.into()); + } + } + { + if self.qcom_tracking_optimization_settings { + out.push(raw::TrackingOptimizationSettingsQCOM::NAME.into()); + } + } { if self.ultraleap_hand_tracking_forearm { out.push(raw::HandTrackingForearmULTRALEAP::NAME.into()); @@ -1035,6 +1301,7 @@ impl ExtensionSet { #[derive(Default, Copy, Clone)] pub struct InstanceExtensions { pub almalence_digital_lens_control: Option, + pub bd_controller_interaction: Option, pub epic_view_configuration_fov: Option, pub ext_performance_settings: Option, pub ext_thermal_query: Option, @@ -1051,13 +1318,18 @@ pub struct InstanceExtensions { pub ext_hp_mixed_reality_controller: Option, pub ext_palm_pose: Option, pub ext_uuid: Option, - pub extx_overlay: Option, + pub ext_hand_interaction: Option, + pub ext_active_action_set_priority: Option, + pub ext_local_floor: Option, + pub ext_hand_tracking_data_source: Option, + pub ext_plane_detection: Option, pub fb_composition_layer_image_layout: Option, pub fb_composition_layer_alpha_blend: Option, #[cfg(target_os = "android")] pub fb_android_surface_swapchain_create: Option, pub fb_swapchain_update_state: Option, pub fb_composition_layer_secure_content: Option, + pub fb_body_tracking: Option, pub fb_display_refresh_rate: Option, pub fb_color_space: Option, pub fb_hand_tracking_mesh: Option, @@ -1078,17 +1350,28 @@ pub struct InstanceExtensions { Option, pub fb_swapchain_update_state_opengl_es: Option, pub fb_swapchain_update_state_vulkan: Option, + pub fb_touch_controller_pro: Option, + pub fb_spatial_entity_sharing: Option, pub fb_space_warp: Option, + pub fb_haptic_amplitude_envelope: Option, pub fb_scene: Option, + pub fb_scene_capture: Option, pub fb_spatial_entity_container: Option, + pub fb_face_tracking: Option, + pub fb_eye_tracking_social: Option, pub fb_passthrough_keyboard_hands: Option, pub fb_composition_layer_settings: Option, + pub fb_touch_controller_proximity: Option, + pub fb_haptic_pcm: Option, + pub fb_composition_layer_depth_test: Option, + pub fb_spatial_entity_storage_batch: Option, + pub fb_spatial_entity_user: Option, pub htc_vive_cosmos_controller_interaction: Option, pub htc_facial_tracking: Option, pub htc_vive_focus3_controller_interaction: Option, pub htc_hand_interaction: Option, pub htc_vive_wrist_tracker_interaction: Option, - pub htcx_vive_tracker_interaction: Option, + pub htc_foveation: Option, pub huawei_controller_interaction: Option, #[cfg(target_os = "android")] pub khr_android_thread_settings: Option, @@ -1121,12 +1404,20 @@ pub struct InstanceExtensions { pub khr_composition_layer_equirect2: Option, pub khr_binding_modification: Option, pub khr_swapchain_usage_input_attachment_bit: Option, + pub meta_foveation_eye_tracked: Option, + pub meta_local_dimming: Option, + pub meta_passthrough_preferences: Option, + pub meta_virtual_keyboard: Option, pub meta_vulkan_swapchain_create_info: Option, pub meta_performance_metrics: Option, + pub meta_headset_id: Option, + pub meta_passthrough_color_lut: Option, pub ml_ml2_controller_interaction: Option, + pub ml_frame_end_info: Option, + pub ml_global_dimmer: Option, + pub ml_compat: Option, pub mnd_headless: Option, pub mnd_swapchain_usage_input_attachment_bit: Option, - pub mndx_egl_enable: Option, pub msft_unbounded_reference_space: Option, pub msft_spatial_anchor: Option, pub msft_spatial_graph_bridge: Option, @@ -1144,6 +1435,9 @@ pub struct InstanceExtensions { #[cfg(target_os = "android")] pub oculus_android_session_state_enable: Option, pub oculus_audio_device_guid: Option, + pub oculus_external_camera: Option, + pub oppo_controller_interaction: Option, + pub qcom_tracking_optimization_settings: Option, pub ultraleap_hand_tracking_forearm: Option, pub valve_analog_threshold: Option, pub varjo_quad_views: Option, @@ -1170,6 +1464,11 @@ impl InstanceExtensions { } else { None }, + bd_controller_interaction: if required.bd_controller_interaction { + Some(raw::ControllerInteractionBD {}) + } else { + None + }, epic_view_configuration_fov: if required.epic_view_configuration_fov { Some(raw::ViewConfigurationFovEPIC {}) } else { @@ -1246,8 +1545,28 @@ impl InstanceExtensions { } else { None }, - extx_overlay: if required.extx_overlay { - Some(raw::OverlayEXTX {}) + ext_hand_interaction: if required.ext_hand_interaction { + Some(raw::HandInteractionEXT {}) + } else { + None + }, + ext_active_action_set_priority: if required.ext_active_action_set_priority { + Some(raw::ActiveActionSetPriorityEXT {}) + } else { + None + }, + ext_local_floor: if required.ext_local_floor { + Some(raw::LocalFloorEXT {}) + } else { + None + }, + ext_hand_tracking_data_source: if required.ext_hand_tracking_data_source { + Some(raw::HandTrackingDataSourceEXT {}) + } else { + None + }, + ext_plane_detection: if required.ext_plane_detection { + Some(raw::PlaneDetectionEXT::load(entry, instance)?) } else { None }, @@ -1277,6 +1596,11 @@ impl InstanceExtensions { } else { None }, + fb_body_tracking: if required.fb_body_tracking { + Some(raw::BodyTrackingFB::load(entry, instance)?) + } else { + None + }, fb_display_refresh_rate: if required.fb_display_refresh_rate { Some(raw::DisplayRefreshRateFB::load(entry, instance)?) } else { @@ -1370,21 +1694,51 @@ impl InstanceExtensions { } else { None }, + fb_touch_controller_pro: if required.fb_touch_controller_pro { + Some(raw::TouchControllerProFB {}) + } else { + None + }, + fb_spatial_entity_sharing: if required.fb_spatial_entity_sharing { + Some(raw::SpatialEntitySharingFB::load(entry, instance)?) + } else { + None + }, fb_space_warp: if required.fb_space_warp { Some(raw::SpaceWarpFB {}) } else { None }, + fb_haptic_amplitude_envelope: if required.fb_haptic_amplitude_envelope { + Some(raw::HapticAmplitudeEnvelopeFB {}) + } else { + None + }, fb_scene: if required.fb_scene { Some(raw::SceneFB::load(entry, instance)?) } else { None }, + fb_scene_capture: if required.fb_scene_capture { + Some(raw::SceneCaptureFB::load(entry, instance)?) + } else { + None + }, fb_spatial_entity_container: if required.fb_spatial_entity_container { Some(raw::SpatialEntityContainerFB::load(entry, instance)?) } else { None }, + fb_face_tracking: if required.fb_face_tracking { + Some(raw::FaceTrackingFB::load(entry, instance)?) + } else { + None + }, + fb_eye_tracking_social: if required.fb_eye_tracking_social { + Some(raw::EyeTrackingSocialFB::load(entry, instance)?) + } else { + None + }, fb_passthrough_keyboard_hands: if required.fb_passthrough_keyboard_hands { Some(raw::PassthroughKeyboardHandsFB::load(entry, instance)?) } else { @@ -1395,6 +1749,31 @@ impl InstanceExtensions { } else { None }, + fb_touch_controller_proximity: if required.fb_touch_controller_proximity { + Some(raw::TouchControllerProximityFB {}) + } else { + None + }, + fb_haptic_pcm: if required.fb_haptic_pcm { + Some(raw::HapticPcmFB::load(entry, instance)?) + } else { + None + }, + fb_composition_layer_depth_test: if required.fb_composition_layer_depth_test { + Some(raw::CompositionLayerDepthTestFB {}) + } else { + None + }, + fb_spatial_entity_storage_batch: if required.fb_spatial_entity_storage_batch { + Some(raw::SpatialEntityStorageBatchFB::load(entry, instance)?) + } else { + None + }, + fb_spatial_entity_user: if required.fb_spatial_entity_user { + Some(raw::SpatialEntityUserFB::load(entry, instance)?) + } else { + None + }, htc_vive_cosmos_controller_interaction: if required .htc_vive_cosmos_controller_interaction { @@ -1424,8 +1803,8 @@ impl InstanceExtensions { } else { None }, - htcx_vive_tracker_interaction: if required.htcx_vive_tracker_interaction { - Some(raw::ViveTrackerInteractionHTCX::load(entry, instance)?) + htc_foveation: if required.htc_foveation { + Some(raw::FoveationHTC::load(entry, instance)?) } else { None }, @@ -1564,6 +1943,26 @@ impl InstanceExtensions { } else { None }, + meta_foveation_eye_tracked: if required.meta_foveation_eye_tracked { + Some(raw::FoveationEyeTrackedMETA::load(entry, instance)?) + } else { + None + }, + meta_local_dimming: if required.meta_local_dimming { + Some(raw::LocalDimmingMETA {}) + } else { + None + }, + meta_passthrough_preferences: if required.meta_passthrough_preferences { + Some(raw::PassthroughPreferencesMETA::load(entry, instance)?) + } else { + None + }, + meta_virtual_keyboard: if required.meta_virtual_keyboard { + Some(raw::VirtualKeyboardMETA::load(entry, instance)?) + } else { + None + }, meta_vulkan_swapchain_create_info: if required.meta_vulkan_swapchain_create_info { Some(raw::VulkanSwapchainCreateInfoMETA {}) } else { @@ -1574,11 +1973,36 @@ impl InstanceExtensions { } else { None }, + meta_headset_id: if required.meta_headset_id { + Some(raw::HeadsetIdMETA {}) + } else { + None + }, + meta_passthrough_color_lut: if required.meta_passthrough_color_lut { + Some(raw::PassthroughColorLutMETA::load(entry, instance)?) + } else { + None + }, ml_ml2_controller_interaction: if required.ml_ml2_controller_interaction { Some(raw::Ml2ControllerInteractionML {}) } else { None }, + ml_frame_end_info: if required.ml_frame_end_info { + Some(raw::FrameEndInfoML {}) + } else { + None + }, + ml_global_dimmer: if required.ml_global_dimmer { + Some(raw::GlobalDimmerML {}) + } else { + None + }, + ml_compat: if required.ml_compat { + Some(raw::CompatML::load(entry, instance)?) + } else { + None + }, mnd_headless: if required.mnd_headless { Some(raw::HeadlessMND {}) } else { @@ -1591,11 +2015,6 @@ impl InstanceExtensions { } else { None }, - mndx_egl_enable: if required.mndx_egl_enable { - Some(raw::EglEnableMNDX {}) - } else { - None - }, msft_unbounded_reference_space: if required.msft_unbounded_reference_space { Some(raw::UnboundedReferenceSpaceMSFT {}) } else { @@ -1671,6 +2090,23 @@ impl InstanceExtensions { } else { None }, + oculus_external_camera: if required.oculus_external_camera { + Some(raw::ExternalCameraOCULUS::load(entry, instance)?) + } else { + None + }, + oppo_controller_interaction: if required.oppo_controller_interaction { + Some(raw::ControllerInteractionOPPO {}) + } else { + None + }, + qcom_tracking_optimization_settings: if required.qcom_tracking_optimization_settings { + Some(raw::TrackingOptimizationSettingsQCOM::load( + entry, instance, + )?) + } else { + None + }, ultraleap_hand_tracking_forearm: if required.ultraleap_hand_tracking_forearm { Some(raw::HandTrackingForearmULTRALEAP {}) } else { @@ -1732,9 +2168,17 @@ pub enum Event<'a> { SpaceQueryCompleteFB(SpaceQueryCompleteFB<'a>), SpaceSaveCompleteFB(SpaceSaveCompleteFB<'a>), SpaceEraseCompleteFB(SpaceEraseCompleteFB<'a>), + SpaceShareCompleteFB(SpaceShareCompleteFB<'a>), + SpaceListSaveCompleteFB(SpaceListSaveCompleteFB<'a>), + SceneCaptureCompleteFB(SceneCaptureCompleteFB<'a>), PassthroughStateChangedFB(PassthroughStateChangedFB<'a>), ViveTrackerConnectedHTCX(ViveTrackerConnectedHTCX<'a>), MarkerTrackingUpdateVARJO(MarkerTrackingUpdateVARJO<'a>), + VirtualKeyboardCommitTextMETA(VirtualKeyboardCommitTextMETA<'a>), + VirtualKeyboardBackspaceMETA(VirtualKeyboardBackspaceMETA<'a>), + VirtualKeyboardEnterMETA(VirtualKeyboardEnterMETA<'a>), + VirtualKeyboardShownMETA(VirtualKeyboardShownMETA<'a>), + VirtualKeyboardHiddenMETA(VirtualKeyboardHiddenMETA<'a>), } impl<'a> Event<'a> { #[doc = r" Decode an event"] @@ -1810,6 +2254,18 @@ impl<'a> Event<'a> { let typed = &*(raw as *const sys::EventDataSpaceEraseCompleteFB); Event::SpaceEraseCompleteFB(SpaceEraseCompleteFB::new(typed)) } + sys::StructureType::EVENT_DATA_SPACE_SHARE_COMPLETE_FB => { + let typed = &*(raw as *const sys::EventDataSpaceShareCompleteFB); + Event::SpaceShareCompleteFB(SpaceShareCompleteFB::new(typed)) + } + sys::StructureType::EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB => { + let typed = &*(raw as *const sys::EventDataSpaceListSaveCompleteFB); + Event::SpaceListSaveCompleteFB(SpaceListSaveCompleteFB::new(typed)) + } + sys::StructureType::EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB => { + let typed = &*(raw as *const sys::EventDataSceneCaptureCompleteFB); + Event::SceneCaptureCompleteFB(SceneCaptureCompleteFB::new(typed)) + } sys::StructureType::EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB => { let typed = &*(raw as *const sys::EventDataPassthroughStateChangedFB); Event::PassthroughStateChangedFB(PassthroughStateChangedFB::new(typed)) @@ -1822,6 +2278,26 @@ impl<'a> Event<'a> { let typed = &*(raw as *const sys::EventDataMarkerTrackingUpdateVARJO); Event::MarkerTrackingUpdateVARJO(MarkerTrackingUpdateVARJO::new(typed)) } + sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META => { + let typed = &*(raw as *const sys::EventDataVirtualKeyboardCommitTextMETA); + Event::VirtualKeyboardCommitTextMETA(VirtualKeyboardCommitTextMETA::new(typed)) + } + sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META => { + let typed = &*(raw as *const sys::EventDataVirtualKeyboardBackspaceMETA); + Event::VirtualKeyboardBackspaceMETA(VirtualKeyboardBackspaceMETA::new(typed)) + } + sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META => { + let typed = &*(raw as *const sys::EventDataVirtualKeyboardEnterMETA); + Event::VirtualKeyboardEnterMETA(VirtualKeyboardEnterMETA::new(typed)) + } + sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META => { + let typed = &*(raw as *const sys::EventDataVirtualKeyboardShownMETA); + Event::VirtualKeyboardShownMETA(VirtualKeyboardShownMETA::new(typed)) + } + sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META => { + let typed = &*(raw as *const sys::EventDataVirtualKeyboardHiddenMETA); + Event::VirtualKeyboardHiddenMETA(VirtualKeyboardHiddenMETA::new(typed)) + } _ => { return None; } @@ -2189,55 +2665,115 @@ impl<'a> SpaceEraseCompleteFB<'a> { } } #[derive(Copy, Clone)] -pub struct PassthroughStateChangedFB<'a>(&'a sys::EventDataPassthroughStateChangedFB); -impl<'a> PassthroughStateChangedFB<'a> { +pub struct SpaceShareCompleteFB<'a>(&'a sys::EventDataSpaceShareCompleteFB); +impl<'a> SpaceShareCompleteFB<'a> { #[inline] #[doc = r" # Safety"] #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] - #[doc = "[sys::EventDataPassthroughStateChangedFB]"] + #[doc = "[sys::EventDataSpaceShareCompleteFB]"] #[doc = r" for more information."] - pub unsafe fn new(inner: &'a sys::EventDataPassthroughStateChangedFB) -> Self { + pub unsafe fn new(inner: &'a sys::EventDataSpaceShareCompleteFB) -> Self { Self(inner) } #[inline] - pub fn flags(self) -> PassthroughStateChangedFlagsFB { - (self.0).flags + pub fn request_id(self) -> AsyncRequestIdFB { + (self.0).request_id + } + #[inline] + pub fn result(self) -> sys::Result { + (self.0).result } } #[derive(Copy, Clone)] -pub struct ViveTrackerConnectedHTCX<'a>(&'a sys::EventDataViveTrackerConnectedHTCX); -impl<'a> ViveTrackerConnectedHTCX<'a> { +pub struct SpaceListSaveCompleteFB<'a>(&'a sys::EventDataSpaceListSaveCompleteFB); +impl<'a> SpaceListSaveCompleteFB<'a> { #[inline] #[doc = r" # Safety"] #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] - #[doc = "[sys::EventDataViveTrackerConnectedHTCX]"] + #[doc = "[sys::EventDataSpaceListSaveCompleteFB]"] #[doc = r" for more information."] - pub unsafe fn new(inner: &'a sys::EventDataViveTrackerConnectedHTCX) -> Self { + pub unsafe fn new(inner: &'a sys::EventDataSpaceListSaveCompleteFB) -> Self { Self(inner) } #[inline] - pub fn paths(self) -> ViveTrackerPathsHTCX { - (*unsafe { self.0.paths.as_ref() }.unwrap()).into() + pub fn request_id(self) -> AsyncRequestIdFB { + (self.0).request_id + } + #[inline] + pub fn result(self) -> sys::Result { + (self.0).result } } #[derive(Copy, Clone)] -pub struct MarkerTrackingUpdateVARJO<'a>(&'a sys::EventDataMarkerTrackingUpdateVARJO); -impl<'a> MarkerTrackingUpdateVARJO<'a> { +pub struct SceneCaptureCompleteFB<'a>(&'a sys::EventDataSceneCaptureCompleteFB); +impl<'a> SceneCaptureCompleteFB<'a> { #[inline] #[doc = r" # Safety"] #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] - #[doc = "[sys::EventDataMarkerTrackingUpdateVARJO]"] + #[doc = "[sys::EventDataSceneCaptureCompleteFB]"] #[doc = r" for more information."] - pub unsafe fn new(inner: &'a sys::EventDataMarkerTrackingUpdateVARJO) -> Self { + pub unsafe fn new(inner: &'a sys::EventDataSceneCaptureCompleteFB) -> Self { Self(inner) } #[inline] - pub fn marker_id(self) -> u64 { - (self.0).marker_id + pub fn request_id(self) -> AsyncRequestIdFB { + (self.0).request_id } #[inline] - pub fn is_active(self) -> bool { - (self.0).is_active.into() + pub fn result(self) -> sys::Result { + (self.0).result + } +} +#[derive(Copy, Clone)] +pub struct PassthroughStateChangedFB<'a>(&'a sys::EventDataPassthroughStateChangedFB); +impl<'a> PassthroughStateChangedFB<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataPassthroughStateChangedFB]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataPassthroughStateChangedFB) -> Self { + Self(inner) + } + #[inline] + pub fn flags(self) -> PassthroughStateChangedFlagsFB { + (self.0).flags + } +} +#[derive(Copy, Clone)] +pub struct ViveTrackerConnectedHTCX<'a>(&'a sys::EventDataViveTrackerConnectedHTCX); +impl<'a> ViveTrackerConnectedHTCX<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataViveTrackerConnectedHTCX]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataViveTrackerConnectedHTCX) -> Self { + Self(inner) + } + #[inline] + pub fn paths(self) -> ViveTrackerPathsHTCX { + (*unsafe { self.0.paths.as_ref() }.unwrap()).into() + } +} +#[derive(Copy, Clone)] +pub struct MarkerTrackingUpdateVARJO<'a>(&'a sys::EventDataMarkerTrackingUpdateVARJO); +impl<'a> MarkerTrackingUpdateVARJO<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataMarkerTrackingUpdateVARJO]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataMarkerTrackingUpdateVARJO) -> Self { + Self(inner) + } + #[inline] + pub fn marker_id(self) -> u64 { + (self.0).marker_id + } + #[inline] + pub fn is_active(self) -> bool { + (self.0).is_active.into() } #[inline] pub fn is_predicted(self) -> bool { @@ -2248,6 +2784,90 @@ impl<'a> MarkerTrackingUpdateVARJO<'a> { (self.0).time } } +#[derive(Copy, Clone)] +pub struct VirtualKeyboardCommitTextMETA<'a>(&'a sys::EventDataVirtualKeyboardCommitTextMETA); +impl<'a> VirtualKeyboardCommitTextMETA<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataVirtualKeyboardCommitTextMETA]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardCommitTextMETA) -> Self { + Self(inner) + } + #[inline] + pub fn keyboard(self) -> sys::VirtualKeyboardMETA { + (self.0).keyboard + } + #[inline] + pub fn text(self) -> [c_char; MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META] { + (self.0).text + } +} +#[derive(Copy, Clone)] +pub struct VirtualKeyboardBackspaceMETA<'a>(&'a sys::EventDataVirtualKeyboardBackspaceMETA); +impl<'a> VirtualKeyboardBackspaceMETA<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataVirtualKeyboardBackspaceMETA]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardBackspaceMETA) -> Self { + Self(inner) + } + #[inline] + pub fn keyboard(self) -> sys::VirtualKeyboardMETA { + (self.0).keyboard + } +} +#[derive(Copy, Clone)] +pub struct VirtualKeyboardEnterMETA<'a>(&'a sys::EventDataVirtualKeyboardEnterMETA); +impl<'a> VirtualKeyboardEnterMETA<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataVirtualKeyboardEnterMETA]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardEnterMETA) -> Self { + Self(inner) + } + #[inline] + pub fn keyboard(self) -> sys::VirtualKeyboardMETA { + (self.0).keyboard + } +} +#[derive(Copy, Clone)] +pub struct VirtualKeyboardShownMETA<'a>(&'a sys::EventDataVirtualKeyboardShownMETA); +impl<'a> VirtualKeyboardShownMETA<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataVirtualKeyboardShownMETA]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardShownMETA) -> Self { + Self(inner) + } + #[inline] + pub fn keyboard(self) -> sys::VirtualKeyboardMETA { + (self.0).keyboard + } +} +#[derive(Copy, Clone)] +pub struct VirtualKeyboardHiddenMETA<'a>(&'a sys::EventDataVirtualKeyboardHiddenMETA); +impl<'a> VirtualKeyboardHiddenMETA<'a> { + #[inline] + #[doc = r" # Safety"] + #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"] + #[doc = "[sys::EventDataVirtualKeyboardHiddenMETA]"] + #[doc = r" for more information."] + pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardHiddenMETA) -> Self { + Self(inner) + } + #[inline] + pub fn keyboard(self) -> sys::VirtualKeyboardMETA { + (self.0).keyboard + } +} pub mod raw { use crate::{Entry, Result}; use std::{ffi::CStr, mem}; @@ -2571,6 +3191,12 @@ pub mod raw { } } #[derive(Copy, Clone)] + pub struct ControllerInteractionBD {} + impl ControllerInteractionBD { + pub const VERSION: u32 = sys::BD_controller_interaction_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::BD_CONTROLLER_INTERACTION_EXTENSION_NAME; + } + #[derive(Copy, Clone)] pub struct ViewConfigurationFovEPIC {} impl ViewConfigurationFovEPIC { pub const VERSION: u32 = sys::EPIC_view_configuration_fov_SPEC_VERSION; @@ -2806,10 +3432,74 @@ pub mod raw { pub const NAME: &'static [u8] = sys::EXT_UUID_EXTENSION_NAME; } #[derive(Copy, Clone)] - pub struct OverlayEXTX {} - impl OverlayEXTX { - pub const VERSION: u32 = sys::EXTX_overlay_SPEC_VERSION; - pub const NAME: &'static [u8] = sys::EXTX_OVERLAY_EXTENSION_NAME; + pub struct HandInteractionEXT {} + impl HandInteractionEXT { + pub const VERSION: u32 = sys::EXT_hand_interaction_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::EXT_HAND_INTERACTION_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct ActiveActionSetPriorityEXT {} + impl ActiveActionSetPriorityEXT { + pub const VERSION: u32 = sys::EXT_active_action_set_priority_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct LocalFloorEXT {} + impl LocalFloorEXT { + pub const VERSION: u32 = sys::EXT_local_floor_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::EXT_LOCAL_FLOOR_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct HandTrackingDataSourceEXT {} + impl HandTrackingDataSourceEXT { + pub const VERSION: u32 = sys::EXT_hand_tracking_data_source_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct PlaneDetectionEXT { + pub create_plane_detector: pfn::CreatePlaneDetectorEXT, + pub destroy_plane_detector: pfn::DestroyPlaneDetectorEXT, + pub begin_plane_detection: pfn::BeginPlaneDetectionEXT, + pub get_plane_detection_state: pfn::GetPlaneDetectionStateEXT, + pub get_plane_detections: pfn::GetPlaneDetectionsEXT, + pub get_plane_polygon_buffer: pfn::GetPlanePolygonBufferEXT, + } + impl PlaneDetectionEXT { + pub const VERSION: u32 = sys::EXT_plane_detection_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::EXT_PLANE_DETECTION_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_plane_detector: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreatePlaneDetectorEXT\0"), + )?), + destroy_plane_detector: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyPlaneDetectorEXT\0"), + )?), + begin_plane_detection: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrBeginPlaneDetectionEXT\0"), + )?), + get_plane_detection_state: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetPlaneDetectionStateEXT\0"), + )?), + get_plane_detections: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetPlaneDetectionsEXT\0"), + )?), + get_plane_polygon_buffer: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetPlanePolygonBufferEXT\0"), + )?), + }) + } } #[derive(Copy, Clone)] pub struct CompositionLayerImageLayoutFB {} @@ -2864,6 +3554,42 @@ pub mod raw { pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct BodyTrackingFB { + pub create_body_tracker: pfn::CreateBodyTrackerFB, + pub destroy_body_tracker: pfn::DestroyBodyTrackerFB, + pub locate_body_joints: pfn::LocateBodyJointsFB, + pub get_body_skeleton: pfn::GetBodySkeletonFB, + } + impl BodyTrackingFB { + pub const VERSION: u32 = sys::FB_body_tracking_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_BODY_TRACKING_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_body_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateBodyTrackerFB\0"), + )?), + destroy_body_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyBodyTrackerFB\0"), + )?), + locate_body_joints: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrLocateBodyJointsFB\0"), + )?), + get_body_skeleton: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetBodySkeletonFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct DisplayRefreshRateFB { pub enumerate_display_refresh_rates: pfn::EnumerateDisplayRefreshRatesFB, pub get_display_refresh_rate: pfn::GetDisplayRefreshRateFB, @@ -3307,12 +4033,45 @@ pub mod raw { pub const NAME: &'static [u8] = sys::FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct TouchControllerProFB {} + impl TouchControllerProFB { + pub const VERSION: u32 = sys::FB_touch_controller_pro_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct SpatialEntitySharingFB { + pub share_spaces: pfn::ShareSpacesFB, + } + impl SpatialEntitySharingFB { + pub const VERSION: u32 = sys::FB_spatial_entity_sharing_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + share_spaces: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrShareSpacesFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct SpaceWarpFB {} impl SpaceWarpFB { pub const VERSION: u32 = sys::FB_space_warp_SPEC_VERSION; pub const NAME: &'static [u8] = sys::FB_SPACE_WARP_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct HapticAmplitudeEnvelopeFB {} + impl HapticAmplitudeEnvelopeFB { + pub const VERSION: u32 = sys::FB_haptic_amplitude_envelope_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME; + } + #[derive(Copy, Clone)] pub struct SceneFB { pub get_space_bounding_box2_d: pfn::GetSpaceBoundingBox2DFB, pub get_space_bounding_box3_d: pfn::GetSpaceBoundingBox3DFB, @@ -3354,6 +4113,27 @@ pub mod raw { } } #[derive(Copy, Clone)] + pub struct SceneCaptureFB { + pub request_scene_capture: pfn::RequestSceneCaptureFB, + } + impl SceneCaptureFB { + pub const VERSION: u32 = sys::FB_scene_capture_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_SCENE_CAPTURE_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + request_scene_capture: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrRequestSceneCaptureFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct SpatialEntityContainerFB { pub get_space_container: pfn::GetSpaceContainerFB, } @@ -3375,6 +4155,68 @@ pub mod raw { } } #[derive(Copy, Clone)] + pub struct FaceTrackingFB { + pub create_face_tracker: pfn::CreateFaceTrackerFB, + pub destroy_face_tracker: pfn::DestroyFaceTrackerFB, + pub get_face_expression_weights: pfn::GetFaceExpressionWeightsFB, + } + impl FaceTrackingFB { + pub const VERSION: u32 = sys::FB_face_tracking_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_FACE_TRACKING_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_face_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateFaceTrackerFB\0"), + )?), + destroy_face_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyFaceTrackerFB\0"), + )?), + get_face_expression_weights: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetFaceExpressionWeightsFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct EyeTrackingSocialFB { + pub create_eye_tracker: pfn::CreateEyeTrackerFB, + pub destroy_eye_tracker: pfn::DestroyEyeTrackerFB, + pub get_eye_gazes: pfn::GetEyeGazesFB, + } + impl EyeTrackingSocialFB { + pub const VERSION: u32 = sys::FB_eye_tracking_social_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_eye_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateEyeTrackerFB\0"), + )?), + destroy_eye_tracker: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyEyeTrackerFB\0"), + )?), + get_eye_gazes: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetEyeGazesFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct PassthroughKeyboardHandsFB { pub passthrough_layer_set_keyboard_hands_intensity: pfn::PassthroughLayerSetKeyboardHandsIntensityFB, @@ -3407,6 +4249,91 @@ pub mod raw { pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct TouchControllerProximityFB {} + impl TouchControllerProximityFB { + pub const VERSION: u32 = sys::FB_touch_controller_proximity_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct HapticPcmFB { + pub get_device_sample_rate: pfn::GetDeviceSampleRateFB, + } + impl HapticPcmFB { + pub const VERSION: u32 = sys::FB_haptic_pcm_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_HAPTIC_PCM_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + get_device_sample_rate: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetDeviceSampleRateFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct CompositionLayerDepthTestFB {} + impl CompositionLayerDepthTestFB { + pub const VERSION: u32 = sys::FB_composition_layer_depth_test_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct SpatialEntityStorageBatchFB { + pub save_space_list: pfn::SaveSpaceListFB, + } + impl SpatialEntityStorageBatchFB { + pub const VERSION: u32 = sys::FB_spatial_entity_storage_batch_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + save_space_list: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrSaveSpaceListFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct SpatialEntityUserFB { + pub create_space_user: pfn::CreateSpaceUserFB, + pub get_space_user_id: pfn::GetSpaceUserIdFB, + pub destroy_space_user: pfn::DestroySpaceUserFB, + } + impl SpatialEntityUserFB { + pub const VERSION: u32 = sys::FB_spatial_entity_user_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_USER_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_space_user: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateSpaceUserFB\0"), + )?), + get_space_user_id: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceUserIdFB\0"), + )?), + destroy_space_user: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroySpaceUserFB\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct ViveCosmosControllerInteractionHTC {} impl ViveCosmosControllerInteractionHTC { pub const VERSION: u32 = sys::HTC_vive_cosmos_controller_interaction_SPEC_VERSION; @@ -3462,12 +4389,12 @@ pub mod raw { pub const NAME: &'static [u8] = sys::HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME; } #[derive(Copy, Clone)] - pub struct ViveTrackerInteractionHTCX { - pub enumerate_vive_tracker_paths: pfn::EnumerateViveTrackerPathsHTCX, + pub struct FoveationHTC { + pub apply_foveation: pfn::ApplyFoveationHTC, } - impl ViveTrackerInteractionHTCX { - pub const VERSION: u32 = sys::HTCX_vive_tracker_interaction_SPEC_VERSION; - pub const NAME: &'static [u8] = sys::HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME; + impl FoveationHTC { + pub const VERSION: u32 = sys::HTC_foveation_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::HTC_FOVEATION_EXTENSION_NAME; #[doc = r" Load the extension's function pointer table"] #[doc = r""] #[doc = r" # Safety"] @@ -3475,9 +4402,9 @@ pub mod raw { #[doc = r" `instance` must be a valid instance handle."] pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { Ok(Self { - enumerate_vive_tracker_paths: mem::transmute(entry.get_instance_proc_addr( + apply_foveation: mem::transmute(entry.get_instance_proc_addr( instance, - CStr::from_bytes_with_nul_unchecked(b"xrEnumerateViveTrackerPathsHTCX\0"), + CStr::from_bytes_with_nul_unchecked(b"xrApplyFoveationHTC\0"), )?), }) } @@ -3871,6 +4798,138 @@ pub mod raw { sys::KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct FoveationEyeTrackedMETA { + pub get_foveation_eye_tracked_state: pfn::GetFoveationEyeTrackedStateMETA, + } + impl FoveationEyeTrackedMETA { + pub const VERSION: u32 = sys::META_foveation_eye_tracked_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_FOVEATION_EYE_TRACKED_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + get_foveation_eye_tracked_state: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetFoveationEyeTrackedStateMETA\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct LocalDimmingMETA {} + impl LocalDimmingMETA { + pub const VERSION: u32 = sys::META_local_dimming_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_LOCAL_DIMMING_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct PassthroughPreferencesMETA { + pub get_passthrough_preferences: pfn::GetPassthroughPreferencesMETA, + } + impl PassthroughPreferencesMETA { + pub const VERSION: u32 = sys::META_passthrough_preferences_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + get_passthrough_preferences: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetPassthroughPreferencesMETA\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct VirtualKeyboardMETA { + pub create_virtual_keyboard: pfn::CreateVirtualKeyboardMETA, + pub destroy_virtual_keyboard: pfn::DestroyVirtualKeyboardMETA, + pub create_virtual_keyboard_space: pfn::CreateVirtualKeyboardSpaceMETA, + pub suggest_virtual_keyboard_location: pfn::SuggestVirtualKeyboardLocationMETA, + pub get_virtual_keyboard_scale: pfn::GetVirtualKeyboardScaleMETA, + pub set_virtual_keyboard_model_visibility: pfn::SetVirtualKeyboardModelVisibilityMETA, + pub get_virtual_keyboard_model_animation_states: + pfn::GetVirtualKeyboardModelAnimationStatesMETA, + pub get_virtual_keyboard_dirty_textures: pfn::GetVirtualKeyboardDirtyTexturesMETA, + pub get_virtual_keyboard_texture_data: pfn::GetVirtualKeyboardTextureDataMETA, + pub send_virtual_keyboard_input: pfn::SendVirtualKeyboardInputMETA, + pub change_virtual_keyboard_text_context: pfn::ChangeVirtualKeyboardTextContextMETA, + } + impl VirtualKeyboardMETA { + pub const VERSION: u32 = sys::META_virtual_keyboard_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_VIRTUAL_KEYBOARD_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_virtual_keyboard: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateVirtualKeyboardMETA\0"), + )?), + destroy_virtual_keyboard: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyVirtualKeyboardMETA\0"), + )?), + create_virtual_keyboard_space: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreateVirtualKeyboardSpaceMETA\0"), + )?), + suggest_virtual_keyboard_location: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrSuggestVirtualKeyboardLocationMETA\0"), + )?), + get_virtual_keyboard_scale: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardScaleMETA\0"), + )?), + set_virtual_keyboard_model_visibility: mem::transmute( + entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked( + b"xrSetVirtualKeyboardModelVisibilityMETA\0", + ), + )?, + ), + get_virtual_keyboard_model_animation_states: mem::transmute( + entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked( + b"xrGetVirtualKeyboardModelAnimationStatesMETA\0", + ), + )?, + ), + get_virtual_keyboard_dirty_textures: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardDirtyTexturesMETA\0"), + )?), + get_virtual_keyboard_texture_data: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardTextureDataMETA\0"), + )?), + send_virtual_keyboard_input: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrSendVirtualKeyboardInputMETA\0"), + )?), + change_virtual_keyboard_text_context: mem::transmute( + entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked( + b"xrChangeVirtualKeyboardTextContextMETA\0", + ), + )?, + ), + }) + } + } + #[derive(Copy, Clone)] pub struct VulkanSwapchainCreateInfoMETA {} impl VulkanSwapchainCreateInfoMETA { pub const VERSION: u32 = sys::META_vulkan_swapchain_create_info_SPEC_VERSION; @@ -3918,12 +4977,86 @@ pub mod raw { } } #[derive(Copy, Clone)] + pub struct HeadsetIdMETA {} + impl HeadsetIdMETA { + pub const VERSION: u32 = sys::META_headset_id_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_HEADSET_ID_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct PassthroughColorLutMETA { + pub create_passthrough_color_lut: pfn::CreatePassthroughColorLutMETA, + pub destroy_passthrough_color_lut: pfn::DestroyPassthroughColorLutMETA, + pub update_passthrough_color_lut: pfn::UpdatePassthroughColorLutMETA, + } + impl PassthroughColorLutMETA { + pub const VERSION: u32 = sys::META_passthrough_color_lut_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughColorLutMETA\0"), + )?), + destroy_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughColorLutMETA\0"), + )?), + update_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrUpdatePassthroughColorLutMETA\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct Ml2ControllerInteractionML {} impl Ml2ControllerInteractionML { pub const VERSION: u32 = sys::ML_ml2_controller_interaction_SPEC_VERSION; pub const NAME: &'static [u8] = sys::ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct FrameEndInfoML {} + impl FrameEndInfoML { + pub const VERSION: u32 = sys::ML_frame_end_info_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::ML_FRAME_END_INFO_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct GlobalDimmerML {} + impl GlobalDimmerML { + pub const VERSION: u32 = sys::ML_global_dimmer_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::ML_GLOBAL_DIMMER_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct CompatML { + pub create_space_from_coordinate_frame_uid: pfn::CreateSpaceFromCoordinateFrameUIDML, + } + impl CompatML { + pub const VERSION: u32 = sys::ML_compat_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::ML_COMPAT_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_space_from_coordinate_frame_uid: mem::transmute( + entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked( + b"xrCreateSpaceFromCoordinateFrameUIDML\0", + ), + )?, + ), + }) + } + } + #[derive(Copy, Clone)] pub struct HeadlessMND {} impl HeadlessMND { pub const VERSION: u32 = sys::MND_headless_SPEC_VERSION; @@ -3937,12 +5070,6 @@ pub mod raw { sys::MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME; } #[derive(Copy, Clone)] - pub struct EglEnableMNDX {} - impl EglEnableMNDX { - pub const VERSION: u32 = sys::MNDX_egl_enable_SPEC_VERSION; - pub const NAME: &'static [u8] = sys::MNDX_EGL_ENABLE_EXTENSION_NAME; - } - #[derive(Copy, Clone)] pub struct UnboundedReferenceSpaceMSFT {} impl UnboundedReferenceSpaceMSFT { pub const VERSION: u32 = sys::MSFT_unbounded_reference_space_SPEC_VERSION; @@ -4275,6 +5402,58 @@ pub mod raw { } } #[derive(Copy, Clone)] + pub struct ExternalCameraOCULUS { + pub enumerate_external_cameras: pfn::EnumerateExternalCamerasOCULUS, + } + impl ExternalCameraOCULUS { + pub const VERSION: u32 = sys::OCULUS_external_camera_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + enumerate_external_cameras: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrEnumerateExternalCamerasOCULUS\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] + pub struct ControllerInteractionOPPO {} + impl ControllerInteractionOPPO { + pub const VERSION: u32 = sys::OPPO_controller_interaction_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME; + } + #[derive(Copy, Clone)] + pub struct TrackingOptimizationSettingsQCOM { + pub set_tracking_optimization_settings_hint: pfn::SetTrackingOptimizationSettingsHintQCOM, + } + impl TrackingOptimizationSettingsQCOM { + pub const VERSION: u32 = sys::QCOM_tracking_optimization_settings_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + set_tracking_optimization_settings_hint: mem::transmute( + entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked( + b"xrSetTrackingOptimizationSettingsHintQCOM\0", + ), + )?, + ), + }) + } + } + #[derive(Copy, Clone)] pub struct HandTrackingForearmULTRALEAP {} impl HandTrackingForearmULTRALEAP { pub const VERSION: u32 = sys::ULTRALEAP_hand_tracking_forearm_SPEC_VERSION; @@ -5216,6 +6395,140 @@ pub(crate) mod builder { Self::new() } } + #[derive(Copy, Clone)] + #[repr(transparent)] + pub struct HapticAmplitudeEnvelopeVibrationFB<'a> { + inner: sys::HapticAmplitudeEnvelopeVibrationFB, + _marker: PhantomData<&'a ()>, + } + impl<'a> HapticAmplitudeEnvelopeVibrationFB<'a> { + #[inline] + pub fn new() -> Self { + Self { + inner: sys::HapticAmplitudeEnvelopeVibrationFB { + ty: sys::StructureType::HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB, + ..unsafe { mem::zeroed() } + }, + _marker: PhantomData, + } + } + #[doc = r" Initialize with the supplied raw values"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"] + #[doc = r" preserved."] + #[inline] + pub unsafe fn from_raw(inner: sys::HapticAmplitudeEnvelopeVibrationFB) -> Self { + Self { + inner, + _marker: PhantomData, + } + } + #[inline] + pub fn into_raw(self) -> sys::HapticAmplitudeEnvelopeVibrationFB { + self.inner + } + #[inline] + pub fn as_raw(&self) -> &sys::HapticAmplitudeEnvelopeVibrationFB { + &self.inner + } + #[inline] + pub fn duration(mut self, value: Duration) -> Self { + self.inner.duration = value; + self + } + #[inline] + pub fn amplitudes(mut self, value: &'a [f32]) -> Self { + self.inner.amplitudes = value.as_ptr() as *const _ as _; + self.inner.amplitude_count = value.len() as u32; + self + } + } + impl<'a> Deref for HapticAmplitudeEnvelopeVibrationFB<'a> { + type Target = HapticBase<'a>; + #[inline] + fn deref(&self) -> &Self::Target { + unsafe { mem::transmute(&self.inner) } + } + } + impl<'a> Default for HapticAmplitudeEnvelopeVibrationFB<'a> { + fn default() -> Self { + Self::new() + } + } + #[derive(Copy, Clone)] + #[repr(transparent)] + pub struct HapticPcmVibrationFB<'a> { + inner: sys::HapticPcmVibrationFB, + _marker: PhantomData<&'a ()>, + } + impl<'a> HapticPcmVibrationFB<'a> { + #[inline] + pub fn new() -> Self { + Self { + inner: sys::HapticPcmVibrationFB { + ty: sys::StructureType::HAPTIC_PCM_VIBRATION_FB, + ..unsafe { mem::zeroed() } + }, + _marker: PhantomData, + } + } + #[doc = r" Initialize with the supplied raw values"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"] + #[doc = r" preserved."] + #[inline] + pub unsafe fn from_raw(inner: sys::HapticPcmVibrationFB) -> Self { + Self { + inner, + _marker: PhantomData, + } + } + #[inline] + pub fn into_raw(self) -> sys::HapticPcmVibrationFB { + self.inner + } + #[inline] + pub fn as_raw(&self) -> &sys::HapticPcmVibrationFB { + &self.inner + } + #[inline] + pub fn buffer(mut self, value: &'a [f32]) -> Self { + self.inner.buffer = value.as_ptr() as *const _ as _; + self.inner.buffer_size = value.len() as u32; + self + } + #[inline] + pub fn sample_rate(mut self, value: f32) -> Self { + self.inner.sample_rate = value; + self + } + #[inline] + pub fn append(mut self, value: bool) -> Self { + self.inner.append = value.into(); + self + } + #[inline] + pub fn samples_consumed(mut self, value: &'a u32) -> Self { + self.inner.samples_consumed = value as *const _ as _; + self + } + } + impl<'a> Deref for HapticPcmVibrationFB<'a> { + type Target = HapticBase<'a>; + #[inline] + fn deref(&self) -> &Self::Target { + unsafe { mem::transmute(&self.inner) } + } + } + impl<'a> Default for HapticPcmVibrationFB<'a> { + fn default() -> Self { + Self::new() + } + } #[repr(transparent)] pub struct BindingModificationBase<'a> { _inner: sys::BindingModificationBaseHeaderKHR, diff --git a/openxr/src/lib.rs b/openxr/src/lib.rs index 109bb52f..b81f12d7 100644 --- a/openxr/src/lib.rs +++ b/openxr/src/lib.rs @@ -6,7 +6,7 @@ use std::os::raw::c_char; pub use sys::{ self, AsyncRequestIdFB, Duration, Path, SystemId, Time, UuidEXT, Version, CURRENT_API_VERSION, - FREQUENCY_UNSPECIFIED, + FREQUENCY_UNSPECIFIED, MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META, }; mod generated; diff --git a/sys/OpenXR-SDK b/sys/OpenXR-SDK index c16a18c9..90734c5b 160000 --- a/sys/OpenXR-SDK +++ b/sys/OpenXR-SDK @@ -1 +1 @@ -Subproject commit c16a18c99740ea5dd251e3af117e0e5aea4ceaa9 +Subproject commit 90734c5b713bfde15eeb95a767e22a29dcbbd312 diff --git a/sys/src/generated.rs b/sys/src/generated.rs index bbbf49bb..6f85a3ab 100644 --- a/sys/src/generated.rs +++ b/sys/src/generated.rs @@ -13,7 +13,9 @@ use libc::{timespec, wchar_t}; use std::fmt; use std::mem::MaybeUninit; use std::os::raw::{c_char, c_void}; -pub const CURRENT_API_VERSION: Version = Version::new(1u16, 0u16, 25u32); +pub const CURRENT_API_VERSION: Version = Version::new(1u16, 0u16, 29u32); +pub const EXTENSION_ENUM_BASE: usize = 1000000000usize; +pub const EXTENSION_ENUM_STRIDE: usize = 1000usize; pub const NULL_PATH: usize = 0usize; pub const NULL_SYSTEM_ID: usize = 0usize; pub const NO_DURATION: usize = 0usize; @@ -25,6 +27,7 @@ pub const NULL_RENDER_MODEL_KEY_FB: usize = 0usize; pub const FACIAL_EXPRESSION_EYE_COUNT_HTC: usize = 14usize; pub const FACIAL_EXPRESSION_LIP_COUNT_HTC: usize = 37usize; pub const HAND_FOREARM_JOINT_COUNT_ULTRALEAP: usize = 27usize; +pub const MAX_HAPTIC_PCM_BUFFER_SIZE_FB: usize = 4000usize; pub const MAX_EXTENSION_NAME_SIZE: usize = 128usize; pub const MAX_API_LAYER_NAME_SIZE: usize = 256usize; pub const MAX_API_LAYER_DESCRIPTION_SIZE: usize = 256usize; @@ -49,6 +52,9 @@ pub const PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB: usize = 256usize; pub const MAX_RENDER_MODEL_NAME_SIZE_FB: usize = 64usize; pub const MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT: usize = 256usize; pub const MAX_AUDIO_DEVICE_STR_SIZE_OCULUS: usize = 128usize; +pub const FOVEATION_CENTER_SIZE_META: usize = 2usize; +pub const MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META: usize = 3992usize; +pub const MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS: usize = 32usize; pub const UUID_SIZE_EXT: usize = 16usize; #[doc = "Structure type enumerant - see [XrStructureType](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrStructureType)"] #[repr(transparent)] @@ -183,6 +189,11 @@ impl StructureType { Self(1000066001i32); pub const ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB: StructureType = Self(1000070000i32); pub const COMPOSITION_LAYER_SECURE_CONTENT_FB: StructureType = Self(1000072000i32); + pub const BODY_TRACKER_CREATE_INFO_FB: StructureType = Self(1000076001i32); + pub const BODY_JOINTS_LOCATE_INFO_FB: StructureType = Self(1000076002i32); + pub const SYSTEM_BODY_TRACKING_PROPERTIES_FB: StructureType = Self(1000076004i32); + pub const BODY_JOINT_LOCATIONS_FB: StructureType = Self(1000076005i32); + pub const BODY_SKELETON_FB: StructureType = Self(1000076006i32); pub const INTERACTION_PROFILE_DPAD_BINDING_EXT: StructureType = Self(1000078000i32); pub const INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE: StructureType = Self(1000079000i32); pub const HAND_JOINTS_MOTION_RANGE_INFO_EXT: StructureType = Self(1000080000i32); @@ -267,6 +278,9 @@ impl StructureType { pub const SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO: StructureType = Self(1000124000i32); pub const EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO: StructureType = Self(1000124001i32); pub const MARKER_SPACE_CREATE_INFO_VARJO: StructureType = Self(1000124002i32); + pub const FRAME_END_INFO_ML: StructureType = Self(1000135000i32); + pub const GLOBAL_DIMMER_FRAME_END_INFO_ML: StructureType = Self(1000136000i32); + pub const COORDINATE_SPACE_CREATE_INFO_ML: StructureType = Self(1000137000i32); pub const SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT: StructureType = Self(1000142000i32); pub const SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT: StructureType = Self(1000142001i32); @@ -285,18 +299,86 @@ impl StructureType { pub const SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB: StructureType = Self(1000161000i32); pub const SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB: StructureType = Self(1000162000i32); pub const SWAPCHAIN_STATE_SAMPLER_VULKAN_FB: StructureType = Self(1000163000i32); + pub const SPACE_SHARE_INFO_FB: StructureType = Self(1000169001i32); + pub const EVENT_DATA_SPACE_SHARE_COMPLETE_FB: StructureType = Self(1000169002i32); pub const COMPOSITION_LAYER_SPACE_WARP_INFO_FB: StructureType = Self(1000171000i32); pub const SYSTEM_SPACE_WARP_PROPERTIES_FB: StructureType = Self(1000171001i32); + pub const HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB: StructureType = Self(1000173001i32); pub const SEMANTIC_LABELS_FB: StructureType = Self(1000175000i32); pub const ROOM_LAYOUT_FB: StructureType = Self(1000175001i32); pub const BOUNDARY_2D_FB: StructureType = Self(1000175002i32); + pub const SEMANTIC_LABELS_SUPPORT_INFO_FB: StructureType = Self(1000175010i32); pub const DIGITAL_LENS_CONTROL_ALMALENCE: StructureType = Self(1000196000i32); + pub const EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB: StructureType = Self(1000198001i32); + pub const SCENE_CAPTURE_REQUEST_INFO_FB: StructureType = Self(1000198050i32); pub const SPACE_CONTAINER_FB: StructureType = Self(1000199000i32); + pub const FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META: StructureType = Self(1000200000i32); + pub const FOVEATION_EYE_TRACKED_STATE_META: StructureType = Self(1000200001i32); + pub const SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META: StructureType = Self(1000200002i32); + pub const SYSTEM_FACE_TRACKING_PROPERTIES_FB: StructureType = Self(1000201004i32); + pub const FACE_TRACKER_CREATE_INFO_FB: StructureType = Self(1000201005i32); + pub const FACE_EXPRESSION_INFO_FB: StructureType = Self(1000201002i32); + pub const FACE_EXPRESSION_WEIGHTS_FB: StructureType = Self(1000201006i32); + pub const EYE_TRACKER_CREATE_INFO_FB: StructureType = Self(1000202001i32); + pub const EYE_GAZES_INFO_FB: StructureType = Self(1000202002i32); + pub const EYE_GAZES_FB: StructureType = Self(1000202003i32); + pub const SYSTEM_EYE_TRACKING_PROPERTIES_FB: StructureType = Self(1000202004i32); pub const PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB: StructureType = Self(1000203002i32); pub const COMPOSITION_LAYER_SETTINGS_FB: StructureType = Self(1000204000i32); + pub const HAPTIC_PCM_VIBRATION_FB: StructureType = Self(1000209001i32); + pub const DEVICE_PCM_SAMPLE_RATE_STATE_FB: StructureType = Self(1000209002i32); + pub const DEVICE_PCM_SAMPLE_RATE_GET_INFO_FB: StructureType = + Self::DEVICE_PCM_SAMPLE_RATE_STATE_FB; + pub const COMPOSITION_LAYER_DEPTH_TEST_FB: StructureType = Self(1000212000i32); + pub const LOCAL_DIMMING_FRAME_END_INFO_META: StructureType = Self(1000216000i32); + pub const PASSTHROUGH_PREFERENCES_META: StructureType = Self(1000217000i32); + pub const SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META: StructureType = Self(1000219001i32); + pub const VIRTUAL_KEYBOARD_CREATE_INFO_META: StructureType = Self(1000219002i32); + pub const VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META: StructureType = Self(1000219003i32); + pub const VIRTUAL_KEYBOARD_LOCATION_INFO_META: StructureType = Self(1000219004i32); + pub const VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META: StructureType = Self(1000219005i32); + pub const VIRTUAL_KEYBOARD_ANIMATION_STATE_META: StructureType = Self(1000219006i32); + pub const VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META: StructureType = Self(1000219007i32); + pub const VIRTUAL_KEYBOARD_TEXTURE_DATA_META: StructureType = Self(1000219009i32); + pub const VIRTUAL_KEYBOARD_INPUT_INFO_META: StructureType = Self(1000219010i32); + pub const VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META: StructureType = Self(1000219011i32); + pub const EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META: StructureType = Self(1000219014i32); + pub const EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META: StructureType = Self(1000219015i32); + pub const EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META: StructureType = Self(1000219016i32); + pub const EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META: StructureType = Self(1000219017i32); + pub const EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META: StructureType = Self(1000219018i32); + pub const EXTERNAL_CAMERA_OCULUS: StructureType = Self(1000226000i32); pub const VULKAN_SWAPCHAIN_CREATE_INFO_META: StructureType = Self(1000227000i32); pub const PERFORMANCE_METRICS_STATE_META: StructureType = Self(1000232001i32); pub const PERFORMANCE_METRICS_COUNTER_META: StructureType = Self(1000232002i32); + pub const SPACE_LIST_SAVE_INFO_FB: StructureType = Self(1000238000i32); + pub const EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB: StructureType = Self(1000238001i32); + pub const SPACE_USER_CREATE_INFO_FB: StructureType = Self(1000241001i32); + pub const SYSTEM_HEADSET_ID_PROPERTIES_META: StructureType = Self(1000245000i32); + pub const SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META: StructureType = Self(1000266000i32); + pub const PASSTHROUGH_COLOR_LUT_CREATE_INFO_META: StructureType = Self(1000266001i32); + pub const PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META: StructureType = Self(1000266002i32); + pub const PASSTHROUGH_COLOR_MAP_LUT_META: StructureType = Self(1000266100i32); + pub const PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META: StructureType = Self(1000266101i32); + pub const PASSTHROUGH_CREATE_INFO_HTC: StructureType = Self(1000317001i32); + pub const PASSTHROUGH_COLOR_HTC: StructureType = Self(1000317002i32); + pub const PASSTHROUGH_MESH_TRANSFORM_INFO_HTC: StructureType = Self(1000317003i32); + pub const COMPOSITION_LAYER_PASSTHROUGH_HTC: StructureType = Self(1000317004i32); + pub const FOVEATION_APPLY_INFO_HTC: StructureType = Self(1000318000i32); + pub const FOVEATION_DYNAMIC_MODE_INFO_HTC: StructureType = Self(1000318001i32); + pub const FOVEATION_CUSTOM_MODE_INFO_HTC: StructureType = Self(1000318002i32); + pub const ACTIVE_ACTION_SET_PRIORITIES_EXT: StructureType = Self(1000373000i32); + pub const SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX: StructureType = Self(1000375000i32); + pub const FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX: StructureType = Self(1000375001i32); + pub const HAND_TRACKING_DATA_SOURCE_INFO_EXT: StructureType = Self(1000428000i32); + pub const HAND_TRACKING_DATA_SOURCE_STATE_EXT: StructureType = Self(1000428001i32); + pub const PLANE_DETECTOR_CREATE_INFO_EXT: StructureType = Self(1000429001i32); + pub const PLANE_DETECTOR_BEGIN_INFO_EXT: StructureType = Self(1000429002i32); + pub const PLANE_DETECTOR_GET_INFO_EXT: StructureType = Self(1000429003i32); + pub const PLANE_DETECTOR_LOCATIONS_EXT: StructureType = Self(1000429004i32); + pub const PLANE_DETECTOR_LOCATION_EXT: StructureType = Self(1000429005i32); + pub const PLANE_DETECTOR_POLYGON_BUFFER_EXT: StructureType = Self(1000429006i32); + pub const SYSTEM_PLANE_DETECTION_PROPERTIES_EXT: StructureType = Self(1000429007i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -496,6 +578,11 @@ impl fmt::Debug for StructureType { Self::COMPOSITION_LAYER_SECURE_CONTENT_FB => { Some("COMPOSITION_LAYER_SECURE_CONTENT_FB") } + Self::BODY_TRACKER_CREATE_INFO_FB => Some("BODY_TRACKER_CREATE_INFO_FB"), + Self::BODY_JOINTS_LOCATE_INFO_FB => Some("BODY_JOINTS_LOCATE_INFO_FB"), + Self::SYSTEM_BODY_TRACKING_PROPERTIES_FB => Some("SYSTEM_BODY_TRACKING_PROPERTIES_FB"), + Self::BODY_JOINT_LOCATIONS_FB => Some("BODY_JOINT_LOCATIONS_FB"), + Self::BODY_SKELETON_FB => Some("BODY_SKELETON_FB"), Self::INTERACTION_PROFILE_DPAD_BINDING_EXT => { Some("INTERACTION_PROFILE_DPAD_BINDING_EXT") } @@ -626,6 +713,9 @@ impl fmt::Debug for StructureType { Some("EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO") } Self::MARKER_SPACE_CREATE_INFO_VARJO => Some("MARKER_SPACE_CREATE_INFO_VARJO"), + Self::FRAME_END_INFO_ML => Some("FRAME_END_INFO_ML"), + Self::GLOBAL_DIMMER_FRAME_END_INFO_ML => Some("GLOBAL_DIMMER_FRAME_END_INFO_ML"), + Self::COORDINATE_SPACE_CREATE_INFO_ML => Some("COORDINATE_SPACE_CREATE_INFO_ML"), Self::SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT => { Some("SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT") } @@ -657,22 +747,140 @@ impl fmt::Debug for StructureType { Some("SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB") } Self::SWAPCHAIN_STATE_SAMPLER_VULKAN_FB => Some("SWAPCHAIN_STATE_SAMPLER_VULKAN_FB"), + Self::SPACE_SHARE_INFO_FB => Some("SPACE_SHARE_INFO_FB"), + Self::EVENT_DATA_SPACE_SHARE_COMPLETE_FB => Some("EVENT_DATA_SPACE_SHARE_COMPLETE_FB"), Self::COMPOSITION_LAYER_SPACE_WARP_INFO_FB => { Some("COMPOSITION_LAYER_SPACE_WARP_INFO_FB") } Self::SYSTEM_SPACE_WARP_PROPERTIES_FB => Some("SYSTEM_SPACE_WARP_PROPERTIES_FB"), + Self::HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB => { + Some("HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB") + } Self::SEMANTIC_LABELS_FB => Some("SEMANTIC_LABELS_FB"), Self::ROOM_LAYOUT_FB => Some("ROOM_LAYOUT_FB"), Self::BOUNDARY_2D_FB => Some("BOUNDARY_2D_FB"), + Self::SEMANTIC_LABELS_SUPPORT_INFO_FB => Some("SEMANTIC_LABELS_SUPPORT_INFO_FB"), Self::DIGITAL_LENS_CONTROL_ALMALENCE => Some("DIGITAL_LENS_CONTROL_ALMALENCE"), + Self::EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB => { + Some("EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB") + } + Self::SCENE_CAPTURE_REQUEST_INFO_FB => Some("SCENE_CAPTURE_REQUEST_INFO_FB"), Self::SPACE_CONTAINER_FB => Some("SPACE_CONTAINER_FB"), + Self::FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META => { + Some("FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META") + } + Self::FOVEATION_EYE_TRACKED_STATE_META => Some("FOVEATION_EYE_TRACKED_STATE_META"), + Self::SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META => { + Some("SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META") + } + Self::SYSTEM_FACE_TRACKING_PROPERTIES_FB => Some("SYSTEM_FACE_TRACKING_PROPERTIES_FB"), + Self::FACE_TRACKER_CREATE_INFO_FB => Some("FACE_TRACKER_CREATE_INFO_FB"), + Self::FACE_EXPRESSION_INFO_FB => Some("FACE_EXPRESSION_INFO_FB"), + Self::FACE_EXPRESSION_WEIGHTS_FB => Some("FACE_EXPRESSION_WEIGHTS_FB"), + Self::EYE_TRACKER_CREATE_INFO_FB => Some("EYE_TRACKER_CREATE_INFO_FB"), + Self::EYE_GAZES_INFO_FB => Some("EYE_GAZES_INFO_FB"), + Self::EYE_GAZES_FB => Some("EYE_GAZES_FB"), + Self::SYSTEM_EYE_TRACKING_PROPERTIES_FB => Some("SYSTEM_EYE_TRACKING_PROPERTIES_FB"), Self::PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB => { Some("PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB") } Self::COMPOSITION_LAYER_SETTINGS_FB => Some("COMPOSITION_LAYER_SETTINGS_FB"), + Self::HAPTIC_PCM_VIBRATION_FB => Some("HAPTIC_PCM_VIBRATION_FB"), + Self::DEVICE_PCM_SAMPLE_RATE_STATE_FB => Some("DEVICE_PCM_SAMPLE_RATE_STATE_FB"), + Self::COMPOSITION_LAYER_DEPTH_TEST_FB => Some("COMPOSITION_LAYER_DEPTH_TEST_FB"), + Self::LOCAL_DIMMING_FRAME_END_INFO_META => Some("LOCAL_DIMMING_FRAME_END_INFO_META"), + Self::PASSTHROUGH_PREFERENCES_META => Some("PASSTHROUGH_PREFERENCES_META"), + Self::SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META => { + Some("SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META") + } + Self::VIRTUAL_KEYBOARD_CREATE_INFO_META => Some("VIRTUAL_KEYBOARD_CREATE_INFO_META"), + Self::VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META => { + Some("VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META") + } + Self::VIRTUAL_KEYBOARD_LOCATION_INFO_META => { + Some("VIRTUAL_KEYBOARD_LOCATION_INFO_META") + } + Self::VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META => { + Some("VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META") + } + Self::VIRTUAL_KEYBOARD_ANIMATION_STATE_META => { + Some("VIRTUAL_KEYBOARD_ANIMATION_STATE_META") + } + Self::VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META => { + Some("VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META") + } + Self::VIRTUAL_KEYBOARD_TEXTURE_DATA_META => Some("VIRTUAL_KEYBOARD_TEXTURE_DATA_META"), + Self::VIRTUAL_KEYBOARD_INPUT_INFO_META => Some("VIRTUAL_KEYBOARD_INPUT_INFO_META"), + Self::VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META => { + Some("VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META") + } + Self::EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META => { + Some("EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META") + } + Self::EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META => { + Some("EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META") + } + Self::EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META => { + Some("EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META") + } + Self::EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META => { + Some("EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META") + } + Self::EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META => { + Some("EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META") + } + Self::EXTERNAL_CAMERA_OCULUS => Some("EXTERNAL_CAMERA_OCULUS"), Self::VULKAN_SWAPCHAIN_CREATE_INFO_META => Some("VULKAN_SWAPCHAIN_CREATE_INFO_META"), Self::PERFORMANCE_METRICS_STATE_META => Some("PERFORMANCE_METRICS_STATE_META"), Self::PERFORMANCE_METRICS_COUNTER_META => Some("PERFORMANCE_METRICS_COUNTER_META"), + Self::SPACE_LIST_SAVE_INFO_FB => Some("SPACE_LIST_SAVE_INFO_FB"), + Self::EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB => { + Some("EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB") + } + Self::SPACE_USER_CREATE_INFO_FB => Some("SPACE_USER_CREATE_INFO_FB"), + Self::SYSTEM_HEADSET_ID_PROPERTIES_META => Some("SYSTEM_HEADSET_ID_PROPERTIES_META"), + Self::SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META => { + Some("SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META") + } + Self::PASSTHROUGH_COLOR_LUT_CREATE_INFO_META => { + Some("PASSTHROUGH_COLOR_LUT_CREATE_INFO_META") + } + Self::PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META => { + Some("PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META") + } + Self::PASSTHROUGH_COLOR_MAP_LUT_META => Some("PASSTHROUGH_COLOR_MAP_LUT_META"), + Self::PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META => { + Some("PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META") + } + Self::PASSTHROUGH_CREATE_INFO_HTC => Some("PASSTHROUGH_CREATE_INFO_HTC"), + Self::PASSTHROUGH_COLOR_HTC => Some("PASSTHROUGH_COLOR_HTC"), + Self::PASSTHROUGH_MESH_TRANSFORM_INFO_HTC => { + Some("PASSTHROUGH_MESH_TRANSFORM_INFO_HTC") + } + Self::COMPOSITION_LAYER_PASSTHROUGH_HTC => Some("COMPOSITION_LAYER_PASSTHROUGH_HTC"), + Self::FOVEATION_APPLY_INFO_HTC => Some("FOVEATION_APPLY_INFO_HTC"), + Self::FOVEATION_DYNAMIC_MODE_INFO_HTC => Some("FOVEATION_DYNAMIC_MODE_INFO_HTC"), + Self::FOVEATION_CUSTOM_MODE_INFO_HTC => Some("FOVEATION_CUSTOM_MODE_INFO_HTC"), + Self::ACTIVE_ACTION_SET_PRIORITIES_EXT => Some("ACTIVE_ACTION_SET_PRIORITIES_EXT"), + Self::SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX => { + Some("SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX") + } + Self::FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX => { + Some("FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX") + } + Self::HAND_TRACKING_DATA_SOURCE_INFO_EXT => Some("HAND_TRACKING_DATA_SOURCE_INFO_EXT"), + Self::HAND_TRACKING_DATA_SOURCE_STATE_EXT => { + Some("HAND_TRACKING_DATA_SOURCE_STATE_EXT") + } + Self::PLANE_DETECTOR_CREATE_INFO_EXT => Some("PLANE_DETECTOR_CREATE_INFO_EXT"), + Self::PLANE_DETECTOR_BEGIN_INFO_EXT => Some("PLANE_DETECTOR_BEGIN_INFO_EXT"), + Self::PLANE_DETECTOR_GET_INFO_EXT => Some("PLANE_DETECTOR_GET_INFO_EXT"), + Self::PLANE_DETECTOR_LOCATIONS_EXT => Some("PLANE_DETECTOR_LOCATIONS_EXT"), + Self::PLANE_DETECTOR_LOCATION_EXT => Some("PLANE_DETECTOR_LOCATION_EXT"), + Self::PLANE_DETECTOR_POLYGON_BUFFER_EXT => Some("PLANE_DETECTOR_POLYGON_BUFFER_EXT"), + Self::SYSTEM_PLANE_DETECTION_PROPERTIES_EXT => { + Some("SYSTEM_PLANE_DETECTION_PROPERTIES_EXT") + } _ => None, }; fmt_enum(fmt, self.0, name) @@ -854,6 +1062,24 @@ impl Result { pub const ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT: Result = Self(-1000142001i32); #[doc = "The spatial anchor name provided was not valid"] pub const ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT: Result = Self(-1000142002i32); + #[doc = "Anchor import from cloud or export from device failed."] + pub const ERROR_SPACE_MAPPING_INSUFFICIENT_FB: Result = Self(-1000169000i32); + #[doc = "Anchors were downloaded from the cloud but failed to be imported/aligned on the device."] + pub const ERROR_SPACE_LOCALIZATION_FAILED_FB: Result = Self(-1000169001i32); + #[doc = "Timeout occurred while waiting for network request to complete."] + pub const ERROR_SPACE_NETWORK_TIMEOUT_FB: Result = Self(-1000169002i32); + #[doc = "The network request failed."] + pub const ERROR_SPACE_NETWORK_REQUEST_FAILED_FB: Result = Self(-1000169003i32); + #[doc = "Cloud storage is required for this operation but is currently disabled."] + pub const ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB: Result = Self(-1000169004i32); + #[doc = "The provided data buffer did not match the required size."] + pub const ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META: Result = Self(-1000266000i32); + #[doc = "Tracking optimization hint is already set for the domain."] + pub const ERROR_HINT_ALREADY_SET_QCOM: Result = Self(-1000306000i32); + #[doc = "The space passed to the function was not locatable."] + pub const ERROR_SPACE_NOT_LOCATABLE_EXT: Result = Self(-1000429000i32); + #[doc = "The permission for this resource was not granted."] + pub const ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT: Result = Self(-1000429001i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1001,6 +1227,25 @@ impl fmt::Debug for Result { Self::ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT => { Some("ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT") } + Self::ERROR_SPACE_MAPPING_INSUFFICIENT_FB => { + Some("ERROR_SPACE_MAPPING_INSUFFICIENT_FB") + } + Self::ERROR_SPACE_LOCALIZATION_FAILED_FB => Some("ERROR_SPACE_LOCALIZATION_FAILED_FB"), + Self::ERROR_SPACE_NETWORK_TIMEOUT_FB => Some("ERROR_SPACE_NETWORK_TIMEOUT_FB"), + Self::ERROR_SPACE_NETWORK_REQUEST_FAILED_FB => { + Some("ERROR_SPACE_NETWORK_REQUEST_FAILED_FB") + } + Self::ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB => { + Some("ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB") + } + Self::ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META => { + Some("ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META") + } + Self::ERROR_HINT_ALREADY_SET_QCOM => Some("ERROR_HINT_ALREADY_SET_QCOM"), + Self::ERROR_SPACE_NOT_LOCATABLE_EXT => Some("ERROR_SPACE_NOT_LOCATABLE_EXT"), + Self::ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT => { + Some("ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT") + } _ => None, }; fmt_enum(fmt, self.0, name) @@ -1008,7 +1253,7 @@ impl fmt::Debug for Result { } impl fmt::Display for Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - let reason = match * self { Self :: SUCCESS => Some ("function successfully completed") , Self :: TIMEOUT_EXPIRED => Some ("the specified timeout time occurred before the operation could complete") , Self :: SESSION_LOSS_PENDING => Some ("the session will be lost soon") , Self :: EVENT_UNAVAILABLE => Some ("no event was available") , Self :: SPACE_BOUNDS_UNAVAILABLE => Some ("the space's bounds are not known at the moment") , Self :: SESSION_NOT_FOCUSED => Some ("the session is not in the focused state") , Self :: FRAME_DISCARDED => Some ("a frame has been discarded from composition") , Self :: ERROR_VALIDATION_FAILURE => Some ("the function usage was invalid in some way") , Self :: ERROR_RUNTIME_FAILURE => Some ("the runtime failed to handle the function in an unexpected way that is not covered by another error result") , Self :: ERROR_OUT_OF_MEMORY => Some ("a memory allocation has failed") , Self :: ERROR_API_VERSION_UNSUPPORTED => Some ("the runtime does not support the requested API version") , Self :: ERROR_INITIALIZATION_FAILED => Some ("initialization of object could not be completed") , Self :: ERROR_FUNCTION_UNSUPPORTED => Some ("the requested function was not found or is otherwise unsupported") , Self :: ERROR_FEATURE_UNSUPPORTED => Some ("the requested feature is not supported") , Self :: ERROR_EXTENSION_NOT_PRESENT => Some ("a requested extension is not supported") , Self :: ERROR_LIMIT_REACHED => Some ("the runtime supports no more of the requested resource") , Self :: ERROR_SIZE_INSUFFICIENT => Some ("the supplied size was smaller than required") , Self :: ERROR_HANDLE_INVALID => Some ("a supplied object handle was invalid") , Self :: ERROR_INSTANCE_LOST => Some ("the XrInstance was lost or could not be found. It will need to be destroyed and optionally recreated") , Self :: ERROR_SESSION_RUNNING => Some ("the session is already running") , Self :: ERROR_SESSION_NOT_RUNNING => Some ("the session is not yet running") , Self :: ERROR_SESSION_LOST => Some ("the XrSession was lost. It will need to be destroyed and optionally recreated") , Self :: ERROR_SYSTEM_INVALID => Some ("the provided XrSystemId was invalid") , Self :: ERROR_PATH_INVALID => Some ("the provided XrPath was not valid") , Self :: ERROR_PATH_COUNT_EXCEEDED => Some ("the maximum number of supported semantic paths has been reached") , Self :: ERROR_PATH_FORMAT_INVALID => Some ("the semantic path character format is invalid") , Self :: ERROR_PATH_UNSUPPORTED => Some ("the semantic path is unsupported") , Self :: ERROR_LAYER_INVALID => Some ("the layer was NULL or otherwise invalid") , Self :: ERROR_LAYER_LIMIT_EXCEEDED => Some ("the number of specified layers is greater than the supported number") , Self :: ERROR_SWAPCHAIN_RECT_INVALID => Some ("the image rect was negatively sized or otherwise invalid") , Self :: ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED => Some ("the image format is not supported by the runtime or platform") , Self :: ERROR_ACTION_TYPE_MISMATCH => Some ("the API used to retrieve an action's state does not match the action's type") , Self :: ERROR_SESSION_NOT_READY => Some ("the session is not in the ready state") , Self :: ERROR_SESSION_NOT_STOPPING => Some ("the session is not in the stopping state") , Self :: ERROR_TIME_INVALID => Some ("the provided XrTime was zero, negative, or out of range") , Self :: ERROR_REFERENCE_SPACE_UNSUPPORTED => Some ("the specified reference space is not supported by the runtime or system") , Self :: ERROR_FILE_ACCESS_ERROR => Some ("the file could not be accessed") , Self :: ERROR_FILE_CONTENTS_INVALID => Some ("the file's contents were invalid") , Self :: ERROR_FORM_FACTOR_UNSUPPORTED => Some ("the specified form factor is not supported by the current runtime or platform") , Self :: ERROR_FORM_FACTOR_UNAVAILABLE => Some ("the specified form factor is supported, but the device is currently not available, e.g. not plugged in or powered off") , Self :: ERROR_API_LAYER_NOT_PRESENT => Some ("a requested API layer is not present or could not be loaded") , Self :: ERROR_CALL_ORDER_INVALID => Some ("the call was made without having made a previously required call") , Self :: ERROR_GRAPHICS_DEVICE_INVALID => Some ("the given graphics device is not in a valid state. The graphics device could be lost or initialized without meeting graphics requirements") , Self :: ERROR_POSE_INVALID => Some ("the supplied pose was invalid with respect to the requirements") , Self :: ERROR_INDEX_OUT_OF_RANGE => Some ("the supplied index was outside the range of valid indices") , Self :: ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED => Some ("the specified view configuration type is not supported by the runtime or platform") , Self :: ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED => Some ("the specified environment blend mode is not supported by the runtime or platform") , Self :: ERROR_NAME_DUPLICATED => Some ("the name provided was a duplicate of an already-existing resource") , Self :: ERROR_NAME_INVALID => Some ("the name provided was invalid") , Self :: ERROR_ACTIONSET_NOT_ATTACHED => Some ("a referenced action set is not attached to the session") , Self :: ERROR_ACTIONSETS_ALREADY_ATTACHED => Some ("the session already has attached action sets") , Self :: ERROR_LOCALIZED_NAME_DUPLICATED => Some ("the localized name provided was a duplicate of an already-existing resource") , Self :: ERROR_LOCALIZED_NAME_INVALID => Some ("the localized name provided was invalid") , Self :: ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING => Some ("the xrGetGraphicsRequirements* call was not made before calling xrCreateSession") , Self :: ERROR_RUNTIME_UNAVAILABLE => Some ("the loader was unable to find or load a runtime") , Self :: ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR => Some ("xrSetAndroidApplicationThreadKHR failed as thread id is invalid") , Self :: ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR => Some ("xrSetAndroidApplicationThreadKHR failed setting the thread attributes/priority") , Self :: ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT => Some ("spatial anchor could not be created at that location") , Self :: ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT => Some ("the secondary view configuration was not enabled when creating the session") , Self :: ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT => Some ("the controller model key is invalid") , Self :: ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT => Some ("the reprojection mode is not supported") , Self :: ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT => Some ("compute new scene not completed") , Self :: ERROR_SCENE_COMPONENT_ID_INVALID_MSFT => Some ("scene component id invalid") , Self :: ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT => Some ("scene component type mismatch") , Self :: ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT => Some ("scene mesh buffer id invalid") , Self :: ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT => Some ("scene compute feature incompatible") , Self :: ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT => Some ("scene compute consistency mismatch") , Self :: ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB => Some ("the display refresh rate is not supported by the platform") , Self :: ERROR_COLOR_SPACE_UNSUPPORTED_FB => Some ("the color space is not supported by the runtime") , Self :: ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB => Some ("the component type is not supported for this space") , Self :: ERROR_SPACE_COMPONENT_NOT_ENABLED_FB => Some ("the required component is not enabled for this space") , Self :: ERROR_SPACE_COMPONENT_STATUS_PENDING_FB => Some ("a request to set the component's status is currently pending") , Self :: ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB => Some ("the component is already set to the requested value") , Self :: ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB => Some ("the object state is unexpected for the issued command") , Self :: ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB => Some ("trying to create an MR feature when one was already created and only one instance is allowed") , Self :: ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB => Some ("requested functionality requires a feature to be created first") , Self :: ERROR_NOT_PERMITTED_PASSTHROUGH_FB => Some ("requested functionality is not permitted - application is not allowed to perform the requested operation") , Self :: ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB => Some ("there weren't sufficient resources available to perform an operation") , Self :: ERROR_UNKNOWN_PASSTHROUGH_FB => Some ("unknown Passthrough error (no further details provided)") , Self :: ERROR_RENDER_MODEL_KEY_INVALID_FB => Some ("the model key is invalid") , Self :: RENDER_MODEL_UNAVAILABLE_FB => Some ("the model is unavailable") , Self :: ERROR_MARKER_NOT_TRACKED_VARJO => Some ("marker tracking is disabled or the specified marker is not currently tracked") , Self :: ERROR_MARKER_ID_INVALID_VARJO => Some ("the specified marker ID is not valid") , Self :: ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT => Some ("a spatial anchor was not found associated with the spatial anchor name provided") , Self :: ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT => Some ("the spatial anchor name provided was not valid") , _ => None , } ; + let reason = match * self { Self :: SUCCESS => Some ("function successfully completed") , Self :: TIMEOUT_EXPIRED => Some ("the specified timeout time occurred before the operation could complete") , Self :: SESSION_LOSS_PENDING => Some ("the session will be lost soon") , Self :: EVENT_UNAVAILABLE => Some ("no event was available") , Self :: SPACE_BOUNDS_UNAVAILABLE => Some ("the space's bounds are not known at the moment") , Self :: SESSION_NOT_FOCUSED => Some ("the session is not in the focused state") , Self :: FRAME_DISCARDED => Some ("a frame has been discarded from composition") , Self :: ERROR_VALIDATION_FAILURE => Some ("the function usage was invalid in some way") , Self :: ERROR_RUNTIME_FAILURE => Some ("the runtime failed to handle the function in an unexpected way that is not covered by another error result") , Self :: ERROR_OUT_OF_MEMORY => Some ("a memory allocation has failed") , Self :: ERROR_API_VERSION_UNSUPPORTED => Some ("the runtime does not support the requested API version") , Self :: ERROR_INITIALIZATION_FAILED => Some ("initialization of object could not be completed") , Self :: ERROR_FUNCTION_UNSUPPORTED => Some ("the requested function was not found or is otherwise unsupported") , Self :: ERROR_FEATURE_UNSUPPORTED => Some ("the requested feature is not supported") , Self :: ERROR_EXTENSION_NOT_PRESENT => Some ("a requested extension is not supported") , Self :: ERROR_LIMIT_REACHED => Some ("the runtime supports no more of the requested resource") , Self :: ERROR_SIZE_INSUFFICIENT => Some ("the supplied size was smaller than required") , Self :: ERROR_HANDLE_INVALID => Some ("a supplied object handle was invalid") , Self :: ERROR_INSTANCE_LOST => Some ("the XrInstance was lost or could not be found. It will need to be destroyed and optionally recreated") , Self :: ERROR_SESSION_RUNNING => Some ("the session is already running") , Self :: ERROR_SESSION_NOT_RUNNING => Some ("the session is not yet running") , Self :: ERROR_SESSION_LOST => Some ("the XrSession was lost. It will need to be destroyed and optionally recreated") , Self :: ERROR_SYSTEM_INVALID => Some ("the provided XrSystemId was invalid") , Self :: ERROR_PATH_INVALID => Some ("the provided XrPath was not valid") , Self :: ERROR_PATH_COUNT_EXCEEDED => Some ("the maximum number of supported semantic paths has been reached") , Self :: ERROR_PATH_FORMAT_INVALID => Some ("the semantic path character format is invalid") , Self :: ERROR_PATH_UNSUPPORTED => Some ("the semantic path is unsupported") , Self :: ERROR_LAYER_INVALID => Some ("the layer was NULL or otherwise invalid") , Self :: ERROR_LAYER_LIMIT_EXCEEDED => Some ("the number of specified layers is greater than the supported number") , Self :: ERROR_SWAPCHAIN_RECT_INVALID => Some ("the image rect was negatively sized or otherwise invalid") , Self :: ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED => Some ("the image format is not supported by the runtime or platform") , Self :: ERROR_ACTION_TYPE_MISMATCH => Some ("the API used to retrieve an action's state does not match the action's type") , Self :: ERROR_SESSION_NOT_READY => Some ("the session is not in the ready state") , Self :: ERROR_SESSION_NOT_STOPPING => Some ("the session is not in the stopping state") , Self :: ERROR_TIME_INVALID => Some ("the provided XrTime was zero, negative, or out of range") , Self :: ERROR_REFERENCE_SPACE_UNSUPPORTED => Some ("the specified reference space is not supported by the runtime or system") , Self :: ERROR_FILE_ACCESS_ERROR => Some ("the file could not be accessed") , Self :: ERROR_FILE_CONTENTS_INVALID => Some ("the file's contents were invalid") , Self :: ERROR_FORM_FACTOR_UNSUPPORTED => Some ("the specified form factor is not supported by the current runtime or platform") , Self :: ERROR_FORM_FACTOR_UNAVAILABLE => Some ("the specified form factor is supported, but the device is currently not available, e.g. not plugged in or powered off") , Self :: ERROR_API_LAYER_NOT_PRESENT => Some ("a requested API layer is not present or could not be loaded") , Self :: ERROR_CALL_ORDER_INVALID => Some ("the call was made without having made a previously required call") , Self :: ERROR_GRAPHICS_DEVICE_INVALID => Some ("the given graphics device is not in a valid state. The graphics device could be lost or initialized without meeting graphics requirements") , Self :: ERROR_POSE_INVALID => Some ("the supplied pose was invalid with respect to the requirements") , Self :: ERROR_INDEX_OUT_OF_RANGE => Some ("the supplied index was outside the range of valid indices") , Self :: ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED => Some ("the specified view configuration type is not supported by the runtime or platform") , Self :: ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED => Some ("the specified environment blend mode is not supported by the runtime or platform") , Self :: ERROR_NAME_DUPLICATED => Some ("the name provided was a duplicate of an already-existing resource") , Self :: ERROR_NAME_INVALID => Some ("the name provided was invalid") , Self :: ERROR_ACTIONSET_NOT_ATTACHED => Some ("a referenced action set is not attached to the session") , Self :: ERROR_ACTIONSETS_ALREADY_ATTACHED => Some ("the session already has attached action sets") , Self :: ERROR_LOCALIZED_NAME_DUPLICATED => Some ("the localized name provided was a duplicate of an already-existing resource") , Self :: ERROR_LOCALIZED_NAME_INVALID => Some ("the localized name provided was invalid") , Self :: ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING => Some ("the xrGetGraphicsRequirements* call was not made before calling xrCreateSession") , Self :: ERROR_RUNTIME_UNAVAILABLE => Some ("the loader was unable to find or load a runtime") , Self :: ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR => Some ("xrSetAndroidApplicationThreadKHR failed as thread id is invalid") , Self :: ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR => Some ("xrSetAndroidApplicationThreadKHR failed setting the thread attributes/priority") , Self :: ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT => Some ("spatial anchor could not be created at that location") , Self :: ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT => Some ("the secondary view configuration was not enabled when creating the session") , Self :: ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT => Some ("the controller model key is invalid") , Self :: ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT => Some ("the reprojection mode is not supported") , Self :: ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT => Some ("compute new scene not completed") , Self :: ERROR_SCENE_COMPONENT_ID_INVALID_MSFT => Some ("scene component id invalid") , Self :: ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT => Some ("scene component type mismatch") , Self :: ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT => Some ("scene mesh buffer id invalid") , Self :: ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT => Some ("scene compute feature incompatible") , Self :: ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT => Some ("scene compute consistency mismatch") , Self :: ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB => Some ("the display refresh rate is not supported by the platform") , Self :: ERROR_COLOR_SPACE_UNSUPPORTED_FB => Some ("the color space is not supported by the runtime") , Self :: ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB => Some ("the component type is not supported for this space") , Self :: ERROR_SPACE_COMPONENT_NOT_ENABLED_FB => Some ("the required component is not enabled for this space") , Self :: ERROR_SPACE_COMPONENT_STATUS_PENDING_FB => Some ("a request to set the component's status is currently pending") , Self :: ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB => Some ("the component is already set to the requested value") , Self :: ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB => Some ("the object state is unexpected for the issued command") , Self :: ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB => Some ("trying to create an MR feature when one was already created and only one instance is allowed") , Self :: ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB => Some ("requested functionality requires a feature to be created first") , Self :: ERROR_NOT_PERMITTED_PASSTHROUGH_FB => Some ("requested functionality is not permitted - application is not allowed to perform the requested operation") , Self :: ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB => Some ("there weren't sufficient resources available to perform an operation") , Self :: ERROR_UNKNOWN_PASSTHROUGH_FB => Some ("unknown Passthrough error (no further details provided)") , Self :: ERROR_RENDER_MODEL_KEY_INVALID_FB => Some ("the model key is invalid") , Self :: RENDER_MODEL_UNAVAILABLE_FB => Some ("the model is unavailable") , Self :: ERROR_MARKER_NOT_TRACKED_VARJO => Some ("marker tracking is disabled or the specified marker is not currently tracked") , Self :: ERROR_MARKER_ID_INVALID_VARJO => Some ("the specified marker ID is not valid") , Self :: ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT => Some ("a spatial anchor was not found associated with the spatial anchor name provided") , Self :: ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT => Some ("the spatial anchor name provided was not valid") , Self :: ERROR_SPACE_MAPPING_INSUFFICIENT_FB => Some ("anchor import from cloud or export from device failed") , Self :: ERROR_SPACE_LOCALIZATION_FAILED_FB => Some ("anchors were downloaded from the cloud but failed to be imported/aligned on the device") , Self :: ERROR_SPACE_NETWORK_TIMEOUT_FB => Some ("timeout occurred while waiting for network request to complete") , Self :: ERROR_SPACE_NETWORK_REQUEST_FAILED_FB => Some ("the network request failed") , Self :: ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB => Some ("cloud storage is required for this operation but is currently disabled") , Self :: ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META => Some ("the provided data buffer did not match the required size") , Self :: ERROR_HINT_ALREADY_SET_QCOM => Some ("tracking optimization hint is already set for the domain") , Self :: ERROR_SPACE_NOT_LOCATABLE_EXT => Some ("the space passed to the function was not locatable") , Self :: ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT => Some ("the permission for this resource was not granted") , _ => None , } ; if let Some(reason) = reason { fmt.pad(reason) } else { @@ -1043,6 +1288,8 @@ impl ObjectType { pub const SPATIAL_GRAPH_NODE_BINDING_MSFT: ObjectType = Self(1000049000i32); #[doc = "XrHandTrackerEXT"] pub const HAND_TRACKER_EXT: ObjectType = Self(1000051000i32); + #[doc = "XrBodyTrackerFB"] + pub const BODY_TRACKER_FB: ObjectType = Self(1000076000i32); #[doc = "XrSceneObserverMSFT"] pub const SCENE_OBSERVER_MSFT: ObjectType = Self(1000097000i32); #[doc = "XrSceneMSFT"] @@ -1061,6 +1308,20 @@ impl ObjectType { pub const GEOMETRY_INSTANCE_FB: ObjectType = Self(1000118004i32); #[doc = "XrSpatialAnchorStoreConnectionMSFT"] pub const SPATIAL_ANCHOR_STORE_CONNECTION_MSFT: ObjectType = Self(1000142000i32); + #[doc = "XrFaceTrackerFB"] + pub const FACE_TRACKER_FB: ObjectType = Self(1000201000i32); + #[doc = "XrEyeTrackerFB"] + pub const EYE_TRACKER_FB: ObjectType = Self(1000202000i32); + #[doc = "XrVirtualKeyboardMETA"] + pub const VIRTUAL_KEYBOARD_META: ObjectType = Self(1000219000i32); + #[doc = "XrSpaceUserFB"] + pub const SPACE_USER_FB: ObjectType = Self(1000241000i32); + #[doc = "XrPassthroughColorLutMETA"] + pub const PASSTHROUGH_COLOR_LUT_META: ObjectType = Self(1000266000i32); + #[doc = "XrPassthroughHTC"] + pub const PASSTHROUGH_HTC: ObjectType = Self(1000317000i32); + #[doc = "XrPlaneDetectorEXT"] + pub const PLANE_DETECTOR_EXT: ObjectType = Self(1000429000i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1082,6 +1343,7 @@ impl fmt::Debug for ObjectType { Self::SPATIAL_ANCHOR_MSFT => Some("SPATIAL_ANCHOR_MSFT"), Self::SPATIAL_GRAPH_NODE_BINDING_MSFT => Some("SPATIAL_GRAPH_NODE_BINDING_MSFT"), Self::HAND_TRACKER_EXT => Some("HAND_TRACKER_EXT"), + Self::BODY_TRACKER_FB => Some("BODY_TRACKER_FB"), Self::SCENE_OBSERVER_MSFT => Some("SCENE_OBSERVER_MSFT"), Self::SCENE_MSFT => Some("SCENE_MSFT"), Self::FACIAL_TRACKER_HTC => Some("FACIAL_TRACKER_HTC"), @@ -1093,6 +1355,13 @@ impl fmt::Debug for ObjectType { Self::SPATIAL_ANCHOR_STORE_CONNECTION_MSFT => { Some("SPATIAL_ANCHOR_STORE_CONNECTION_MSFT") } + Self::FACE_TRACKER_FB => Some("FACE_TRACKER_FB"), + Self::EYE_TRACKER_FB => Some("EYE_TRACKER_FB"), + Self::VIRTUAL_KEYBOARD_META => Some("VIRTUAL_KEYBOARD_META"), + Self::SPACE_USER_FB => Some("SPACE_USER_FB"), + Self::PASSTHROUGH_COLOR_LUT_META => Some("PASSTHROUGH_COLOR_LUT_META"), + Self::PASSTHROUGH_HTC => Some("PASSTHROUGH_HTC"), + Self::PLANE_DETECTOR_EXT => Some("PLANE_DETECTOR_EXT"), _ => None, }; fmt_enum(fmt, self.0, name) @@ -1195,6 +1464,7 @@ impl ReferenceSpaceType { pub const STAGE: ReferenceSpaceType = Self(3i32); pub const UNBOUNDED_MSFT: ReferenceSpaceType = Self(1000038000i32); pub const COMBINED_EYE_VARJO: ReferenceSpaceType = Self(1000121000i32); + pub const LOCAL_FLOOR_EXT: ReferenceSpaceType = Self(1000426000i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1210,6 +1480,7 @@ impl fmt::Debug for ReferenceSpaceType { Self::STAGE => Some("STAGE"), Self::UNBOUNDED_MSFT => Some("UNBOUNDED_MSFT"), Self::COMBINED_EYE_VARJO => Some("COMBINED_EYE_VARJO"), + Self::LOCAL_FLOOR_EXT => Some("LOCAL_FLOOR_EXT"), _ => None, }; fmt_enum(fmt, self.0, name) @@ -1394,13 +1665,13 @@ impl fmt::Debug for PerfSettingsSubDomainEXT { #[derive(Copy, Clone, Eq, PartialEq)] pub struct PerfSettingsLevelEXT(i32); impl PerfSettingsLevelEXT { - #[doc = "Performance settings hint used by the application to indicate that it enters a non-XR\n section (head-locked / static screen), during which power savings are to be prioritized"] + #[doc = "Performance settings hint used by the application to indicate that it enters a non-XR section (head-locked / static screen), during which power savings are to be prioritized"] pub const POWER_SAVINGS: PerfSettingsLevelEXT = Self(0i32); - #[doc = "Performance settings hint used by the application to indicate that it enters a low\n and stable complexity section, during which reducing power is more important than\n occasional late rendering frames"] + #[doc = "Performance settings hint used by the application to indicate that it enters a low and stable complexity section, during which reducing power is more important than occasional late rendering frames"] pub const SUSTAINED_LOW: PerfSettingsLevelEXT = Self(25i32); - #[doc = "Performance settings hint used by the application to indicate that it enters\n a high or dynamic complexity section, during which the XR Runtime strives for consistent\n XR compositing and frame rendering within a thermally sustainable range"] + #[doc = "Performance settings hint used by the application to indicate that it enters a high or dynamic complexity section, during which the XR Runtime strives for consistent XR compositing and frame rendering within a thermally sustainable range"] pub const SUSTAINED_HIGH: PerfSettingsLevelEXT = Self(50i32); - #[doc = "Performance settings hint used by the application to indicate that the application enters\n a section with very high complexity, during which the XR Runtime is allowed to step\n up beyond the thermally sustainable range"] + #[doc = "Performance settings hint used by the application to indicate that the application enters a section with very high complexity, during which the XR Runtime is allowed to step up beyond the thermally sustainable range"] pub const BOOST: PerfSettingsLevelEXT = Self(75i32); pub fn from_raw(x: i32) -> Self { Self(x) @@ -1426,11 +1697,11 @@ impl fmt::Debug for PerfSettingsLevelEXT { #[derive(Copy, Clone, Eq, PartialEq)] pub struct PerfSettingsNotificationLevelEXT(i32); impl PerfSettingsNotificationLevelEXT { - #[doc = "Notifies that the sub-domain has reached a level\n where no further actions other than currently applied are necessary"] + #[doc = "Notifies that the sub-domain has reached a level where no further actions other than currently applied are necessary"] pub const NORMAL: PerfSettingsNotificationLevelEXT = Self(0i32); - #[doc = "Notifies that the sub-domain has reached an early warning level\n where the application should start proactive mitigation actions\n with the goal to return to the XR_PERF_NOTIF_LEVEL_NORMAL level"] + #[doc = "Notifies that the sub-domain has reached an early warning level where the application should start proactive mitigation actions with the goal to return to the XR_PERF_NOTIF_LEVEL_NORMAL level"] pub const WARNING: PerfSettingsNotificationLevelEXT = Self(25i32); - #[doc = "Notifies that the sub-domain has reached a critical\n level with significant performance degradation.\n The application should take drastic mitigation action"] + #[doc = "Notifies that the sub-domain has reached a critical level with significant performance degradation. The application should take drastic mitigation action"] pub const IMPAIRED: PerfSettingsNotificationLevelEXT = Self(75i32); pub fn from_raw(x: i32) -> Self { Self(x) @@ -1544,6 +1815,8 @@ impl SpaceComponentTypeFB { pub const LOCATABLE: SpaceComponentTypeFB = Self(0i32); #[doc = "Enables persistence operations: save and erase."] pub const STORABLE: SpaceComponentTypeFB = Self(1i32); + #[doc = "Enables sharing of spatial entities."] + pub const SHARABLE: SpaceComponentTypeFB = Self(2i32); #[doc = "Bounded 2D component."] pub const BOUNDED_2D: SpaceComponentTypeFB = Self(3i32); #[doc = "Bounded 3D component."] @@ -1566,6 +1839,7 @@ impl fmt::Debug for SpaceComponentTypeFB { let name = match *self { Self::LOCATABLE => Some("LOCATABLE"), Self::STORABLE => Some("STORABLE"), + Self::SHARABLE => Some("SHARABLE"), Self::BOUNDED_2D => Some("BOUNDED_2D"), Self::BOUNDED_3D => Some("BOUNDED_3D"), Self::SEMANTIC_LABELS => Some("SEMANTIC_LABELS"), @@ -1669,6 +1943,8 @@ impl SpaceStorageLocationFB { pub const INVALID: SpaceStorageLocationFB = Self(0i32); #[doc = "Local device storage"] pub const LOCAL: SpaceStorageLocationFB = Self(1i32); + #[doc = "Cloud storage"] + pub const CLOUD: SpaceStorageLocationFB = Self(2i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1681,6 +1957,7 @@ impl fmt::Debug for SpaceStorageLocationFB { let name = match *self { Self::INVALID => Some("INVALID"), Self::LOCAL => Some("LOCAL"), + Self::CLOUD => Some("CLOUD"), _ => None, }; fmt_enum(fmt, self.0, name) @@ -1712,21 +1989,19 @@ impl fmt::Debug for SpacePersistenceModeFB { fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrPerformanceMetricsCounterUnitMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterUnitMETA)"] +#[doc = "See [XrExternalCameraAttachedToDeviceOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExternalCameraAttachedToDeviceOCULUS)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct PerformanceMetricsCounterUnitMETA(i32); -impl PerformanceMetricsCounterUnitMETA { - #[doc = "the performance counter unit is generic (unspecified)."] - pub const GENERIC: PerformanceMetricsCounterUnitMETA = Self(0i32); - #[doc = "the performance counter unit is percentage (%)."] - pub const PERCENTAGE: PerformanceMetricsCounterUnitMETA = Self(1i32); - #[doc = "the performance counter unit is millisecond."] - pub const MILLISECONDS: PerformanceMetricsCounterUnitMETA = Self(2i32); - #[doc = "the performance counter unit is byte."] - pub const BYTES: PerformanceMetricsCounterUnitMETA = Self(3i32); - #[doc = "the performance counter unit is hertz (Hz)."] - pub const HERTZ: PerformanceMetricsCounterUnitMETA = Self(4i32); +pub struct ExternalCameraAttachedToDeviceOCULUS(i32); +impl ExternalCameraAttachedToDeviceOCULUS { + #[doc = "External camera is at a fixed point in LOCAL space"] + pub const NONE: ExternalCameraAttachedToDeviceOCULUS = Self(0i32); + #[doc = "External camera is attached to the HMD"] + pub const HMD: ExternalCameraAttachedToDeviceOCULUS = Self(1i32); + #[doc = "External camera is attached to a left Touch controller"] + pub const LTOUCH: ExternalCameraAttachedToDeviceOCULUS = Self(2i32); + #[doc = "External camera is attached to a right Touch controller"] + pub const RTOUCH: ExternalCameraAttachedToDeviceOCULUS = Self(3i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1734,26 +2009,25 @@ impl PerformanceMetricsCounterUnitMETA { self.0 } } -impl fmt::Debug for PerformanceMetricsCounterUnitMETA { +impl fmt::Debug for ExternalCameraAttachedToDeviceOCULUS { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GENERIC => Some("GENERIC"), - Self::PERCENTAGE => Some("PERCENTAGE"), - Self::MILLISECONDS => Some("MILLISECONDS"), - Self::BYTES => Some("BYTES"), - Self::HERTZ => Some("HERTZ"), + Self::NONE => Some("NONE"), + Self::HMD => Some("HMD"), + Self::LTOUCH => Some("LTOUCH"), + Self::RTOUCH => Some("RTOUCH"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandEXT)"] +#[doc = "See [XrPassthroughColorLutChannelsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorLutChannelsMETA)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandEXT(i32); -impl HandEXT { - pub const LEFT: HandEXT = Self(1i32); - pub const RIGHT: HandEXT = Self(2i32); +pub struct PassthroughColorLutChannelsMETA(i32); +impl PassthroughColorLutChannelsMETA { + pub const RGB: PassthroughColorLutChannelsMETA = Self(1i32); + pub const RGBA: PassthroughColorLutChannelsMETA = Self(2i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1761,47 +2035,31 @@ impl HandEXT { self.0 } } -impl fmt::Debug for HandEXT { +impl fmt::Debug for PassthroughColorLutChannelsMETA { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LEFT => Some("LEFT"), - Self::RIGHT => Some("RIGHT"), + Self::RGB => Some("RGB"), + Self::RGBA => Some("RGBA"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandJointEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointEXT)"] +#[doc = "See [XrPerformanceMetricsCounterUnitMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterUnitMETA)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandJointEXT(i32); -impl HandJointEXT { - pub const PALM: HandJointEXT = Self(0i32); - pub const WRIST: HandJointEXT = Self(1i32); - pub const THUMB_METACARPAL: HandJointEXT = Self(2i32); - pub const THUMB_PROXIMAL: HandJointEXT = Self(3i32); - pub const THUMB_DISTAL: HandJointEXT = Self(4i32); - pub const THUMB_TIP: HandJointEXT = Self(5i32); - pub const INDEX_METACARPAL: HandJointEXT = Self(6i32); - pub const INDEX_PROXIMAL: HandJointEXT = Self(7i32); - pub const INDEX_INTERMEDIATE: HandJointEXT = Self(8i32); - pub const INDEX_DISTAL: HandJointEXT = Self(9i32); - pub const INDEX_TIP: HandJointEXT = Self(10i32); - pub const MIDDLE_METACARPAL: HandJointEXT = Self(11i32); - pub const MIDDLE_PROXIMAL: HandJointEXT = Self(12i32); - pub const MIDDLE_INTERMEDIATE: HandJointEXT = Self(13i32); - pub const MIDDLE_DISTAL: HandJointEXT = Self(14i32); - pub const MIDDLE_TIP: HandJointEXT = Self(15i32); - pub const RING_METACARPAL: HandJointEXT = Self(16i32); - pub const RING_PROXIMAL: HandJointEXT = Self(17i32); - pub const RING_INTERMEDIATE: HandJointEXT = Self(18i32); - pub const RING_DISTAL: HandJointEXT = Self(19i32); - pub const RING_TIP: HandJointEXT = Self(20i32); - pub const LITTLE_METACARPAL: HandJointEXT = Self(21i32); - pub const LITTLE_PROXIMAL: HandJointEXT = Self(22i32); - pub const LITTLE_INTERMEDIATE: HandJointEXT = Self(23i32); - pub const LITTLE_DISTAL: HandJointEXT = Self(24i32); - pub const LITTLE_TIP: HandJointEXT = Self(25i32); +pub struct PerformanceMetricsCounterUnitMETA(i32); +impl PerformanceMetricsCounterUnitMETA { + #[doc = "the performance counter unit is generic (unspecified)."] + pub const GENERIC: PerformanceMetricsCounterUnitMETA = Self(0i32); + #[doc = "the performance counter unit is percentage (%)."] + pub const PERCENTAGE: PerformanceMetricsCounterUnitMETA = Self(1i32); + #[doc = "the performance counter unit is millisecond."] + pub const MILLISECONDS: PerformanceMetricsCounterUnitMETA = Self(2i32); + #[doc = "the performance counter unit is byte."] + pub const BYTES: PerformanceMetricsCounterUnitMETA = Self(3i32); + #[doc = "the performance counter unit is hertz (Hz)."] + pub const HERTZ: PerformanceMetricsCounterUnitMETA = Self(4i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1809,47 +2067,28 @@ impl HandJointEXT { self.0 } } -impl fmt::Debug for HandJointEXT { +impl fmt::Debug for PerformanceMetricsCounterUnitMETA { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PALM => Some("PALM"), - Self::WRIST => Some("WRIST"), - Self::THUMB_METACARPAL => Some("THUMB_METACARPAL"), - Self::THUMB_PROXIMAL => Some("THUMB_PROXIMAL"), - Self::THUMB_DISTAL => Some("THUMB_DISTAL"), - Self::THUMB_TIP => Some("THUMB_TIP"), - Self::INDEX_METACARPAL => Some("INDEX_METACARPAL"), - Self::INDEX_PROXIMAL => Some("INDEX_PROXIMAL"), - Self::INDEX_INTERMEDIATE => Some("INDEX_INTERMEDIATE"), - Self::INDEX_DISTAL => Some("INDEX_DISTAL"), - Self::INDEX_TIP => Some("INDEX_TIP"), - Self::MIDDLE_METACARPAL => Some("MIDDLE_METACARPAL"), - Self::MIDDLE_PROXIMAL => Some("MIDDLE_PROXIMAL"), - Self::MIDDLE_INTERMEDIATE => Some("MIDDLE_INTERMEDIATE"), - Self::MIDDLE_DISTAL => Some("MIDDLE_DISTAL"), - Self::MIDDLE_TIP => Some("MIDDLE_TIP"), - Self::RING_METACARPAL => Some("RING_METACARPAL"), - Self::RING_PROXIMAL => Some("RING_PROXIMAL"), - Self::RING_INTERMEDIATE => Some("RING_INTERMEDIATE"), - Self::RING_DISTAL => Some("RING_DISTAL"), - Self::RING_TIP => Some("RING_TIP"), - Self::LITTLE_METACARPAL => Some("LITTLE_METACARPAL"), - Self::LITTLE_PROXIMAL => Some("LITTLE_PROXIMAL"), - Self::LITTLE_INTERMEDIATE => Some("LITTLE_INTERMEDIATE"), - Self::LITTLE_DISTAL => Some("LITTLE_DISTAL"), - Self::LITTLE_TIP => Some("LITTLE_TIP"), + Self::GENERIC => Some("GENERIC"), + Self::PERCENTAGE => Some("PERCENTAGE"), + Self::MILLISECONDS => Some("MILLISECONDS"), + Self::BYTES => Some("BYTES"), + Self::HERTZ => Some("HERTZ"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandJointSetEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointSetEXT)"] +#[doc = "See [XrFacialTrackingTypeHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackingTypeHTC)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandJointSetEXT(i32); -impl HandJointSetEXT { - pub const DEFAULT: HandJointSetEXT = Self(0i32); - pub const HAND_WITH_FOREARM_ULTRA: HandJointSetEXT = Self(1000149000i32); +pub struct FacialTrackingTypeHTC(i32); +impl FacialTrackingTypeHTC { + #[doc = "Specifies this handle will observe eye expressions, with values indexed by XrEyeExpressionHTC whose count is XR_FACIAL_EXPRESSION_EYE_COUNT_HTC."] + pub const EYE_DEFAULT: FacialTrackingTypeHTC = Self(1i32); + #[doc = "Specifies this handle will observe lip expressions, with values indexed by XrLipExpressionHTC whose count is XR_FACIAL_EXPRESSION_LIP_COUNT_HTC."] + pub const LIP_DEFAULT: FacialTrackingTypeHTC = Self(2i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1857,23 +2096,35 @@ impl HandJointSetEXT { self.0 } } -impl fmt::Debug for HandJointSetEXT { +impl fmt::Debug for FacialTrackingTypeHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::HAND_WITH_FOREARM_ULTRA => Some("HAND_WITH_FOREARM_ULTRA"), + Self::EYE_DEFAULT => Some("EYE_DEFAULT"), + Self::LIP_DEFAULT => Some("LIP_DEFAULT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandJointsMotionRangeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsMotionRangeEXT)"] +#[doc = "See [XrEyeExpressionHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeExpressionHTC)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandJointsMotionRangeEXT(i32); -impl HandJointsMotionRangeEXT { - pub const UNOBSTRUCTED: HandJointsMotionRangeEXT = Self(1i32); - pub const CONFORMING_TO_CONTROLLER: HandJointsMotionRangeEXT = Self(2i32); +pub struct EyeExpressionHTC(i32); +impl EyeExpressionHTC { + pub const LEFT_BLINK: EyeExpressionHTC = Self(0i32); + pub const LEFT_WIDE: EyeExpressionHTC = Self(1i32); + pub const RIGHT_BLINK: EyeExpressionHTC = Self(2i32); + pub const RIGHT_WIDE: EyeExpressionHTC = Self(3i32); + pub const LEFT_SQUEEZE: EyeExpressionHTC = Self(4i32); + pub const RIGHT_SQUEEZE: EyeExpressionHTC = Self(5i32); + pub const LEFT_DOWN: EyeExpressionHTC = Self(6i32); + pub const RIGHT_DOWN: EyeExpressionHTC = Self(7i32); + pub const LEFT_OUT: EyeExpressionHTC = Self(8i32); + pub const RIGHT_IN: EyeExpressionHTC = Self(9i32); + pub const LEFT_IN: EyeExpressionHTC = Self(10i32); + pub const RIGHT_OUT: EyeExpressionHTC = Self(11i32); + pub const LEFT_UP: EyeExpressionHTC = Self(12i32); + pub const RIGHT_UP: EyeExpressionHTC = Self(13i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1881,23 +2132,70 @@ impl HandJointsMotionRangeEXT { self.0 } } -impl fmt::Debug for HandJointsMotionRangeEXT { +impl fmt::Debug for EyeExpressionHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNOBSTRUCTED => Some("UNOBSTRUCTED"), - Self::CONFORMING_TO_CONTROLLER => Some("CONFORMING_TO_CONTROLLER"), + Self::LEFT_BLINK => Some("LEFT_BLINK"), + Self::LEFT_WIDE => Some("LEFT_WIDE"), + Self::RIGHT_BLINK => Some("RIGHT_BLINK"), + Self::RIGHT_WIDE => Some("RIGHT_WIDE"), + Self::LEFT_SQUEEZE => Some("LEFT_SQUEEZE"), + Self::RIGHT_SQUEEZE => Some("RIGHT_SQUEEZE"), + Self::LEFT_DOWN => Some("LEFT_DOWN"), + Self::RIGHT_DOWN => Some("RIGHT_DOWN"), + Self::LEFT_OUT => Some("LEFT_OUT"), + Self::RIGHT_IN => Some("RIGHT_IN"), + Self::LEFT_IN => Some("LEFT_IN"), + Self::RIGHT_OUT => Some("RIGHT_OUT"), + Self::LEFT_UP => Some("LEFT_UP"), + Self::RIGHT_UP => Some("RIGHT_UP"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandPoseTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandPoseTypeMSFT)"] +#[doc = "See [XrLipExpressionHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLipExpressionHTC)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandPoseTypeMSFT(i32); -impl HandPoseTypeMSFT { - pub const TRACKED: HandPoseTypeMSFT = Self(0i32); - pub const REFERENCE_OPEN_PALM: HandPoseTypeMSFT = Self(1i32); +pub struct LipExpressionHTC(i32); +impl LipExpressionHTC { + pub const JAW_RIGHT: LipExpressionHTC = Self(0i32); + pub const JAW_LEFT: LipExpressionHTC = Self(1i32); + pub const JAW_FORWARD: LipExpressionHTC = Self(2i32); + pub const JAW_OPEN: LipExpressionHTC = Self(3i32); + pub const MOUTH_APE_SHAPE: LipExpressionHTC = Self(4i32); + pub const MOUTH_UPPER_RIGHT: LipExpressionHTC = Self(5i32); + pub const MOUTH_UPPER_LEFT: LipExpressionHTC = Self(6i32); + pub const MOUTH_LOWER_RIGHT: LipExpressionHTC = Self(7i32); + pub const MOUTH_LOWER_LEFT: LipExpressionHTC = Self(8i32); + pub const MOUTH_UPPER_OVERTURN: LipExpressionHTC = Self(9i32); + pub const MOUTH_LOWER_OVERTURN: LipExpressionHTC = Self(10i32); + pub const MOUTH_POUT: LipExpressionHTC = Self(11i32); + pub const MOUTH_SMILE_RIGHT: LipExpressionHTC = Self(12i32); + pub const MOUTH_SMILE_LEFT: LipExpressionHTC = Self(13i32); + pub const MOUTH_SAD_RIGHT: LipExpressionHTC = Self(14i32); + pub const MOUTH_SAD_LEFT: LipExpressionHTC = Self(15i32); + pub const CHEEK_PUFF_RIGHT: LipExpressionHTC = Self(16i32); + pub const CHEEK_PUFF_LEFT: LipExpressionHTC = Self(17i32); + pub const CHEEK_SUCK: LipExpressionHTC = Self(18i32); + pub const MOUTH_UPPER_UPRIGHT: LipExpressionHTC = Self(19i32); + pub const MOUTH_UPPER_UPLEFT: LipExpressionHTC = Self(20i32); + pub const MOUTH_LOWER_DOWNRIGHT: LipExpressionHTC = Self(21i32); + pub const MOUTH_LOWER_DOWNLEFT: LipExpressionHTC = Self(22i32); + pub const MOUTH_UPPER_INSIDE: LipExpressionHTC = Self(23i32); + pub const MOUTH_LOWER_INSIDE: LipExpressionHTC = Self(24i32); + pub const MOUTH_LOWER_OVERLAY: LipExpressionHTC = Self(25i32); + pub const TONGUE_LONGSTEP1: LipExpressionHTC = Self(26i32); + pub const TONGUE_LEFT: LipExpressionHTC = Self(27i32); + pub const TONGUE_RIGHT: LipExpressionHTC = Self(28i32); + pub const TONGUE_UP: LipExpressionHTC = Self(29i32); + pub const TONGUE_DOWN: LipExpressionHTC = Self(30i32); + pub const TONGUE_ROLL: LipExpressionHTC = Self(31i32); + pub const TONGUE_LONGSTEP2: LipExpressionHTC = Self(32i32); + pub const TONGUE_UPRIGHT_MORPH: LipExpressionHTC = Self(33i32); + pub const TONGUE_UPLEFT_MORPH: LipExpressionHTC = Self(34i32); + pub const TONGUE_DOWNRIGHT_MORPH: LipExpressionHTC = Self(35i32); + pub const TONGUE_DOWNLEFT_MORPH: LipExpressionHTC = Self(36i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1905,28 +2203,60 @@ impl HandPoseTypeMSFT { self.0 } } -impl fmt::Debug for HandPoseTypeMSFT { +impl fmt::Debug for LipExpressionHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TRACKED => Some("TRACKED"), - Self::REFERENCE_OPEN_PALM => Some("REFERENCE_OPEN_PALM"), - _ => None, - }; - fmt_enum(fmt, self.0, name) - } -} -#[doc = "See [XrSceneObjectTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneObjectTypeMSFT)"] -#[repr(transparent)] -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct SceneObjectTypeMSFT(i32); -impl SceneObjectTypeMSFT { - pub const UNCATEGORIZED: SceneObjectTypeMSFT = Self(-1i32); - pub const BACKGROUND: SceneObjectTypeMSFT = Self(1i32); - pub const WALL: SceneObjectTypeMSFT = Self(2i32); - pub const FLOOR: SceneObjectTypeMSFT = Self(3i32); - pub const CEILING: SceneObjectTypeMSFT = Self(4i32); - pub const PLATFORM: SceneObjectTypeMSFT = Self(5i32); - pub const INFERRED: SceneObjectTypeMSFT = Self(6i32); + Self::JAW_RIGHT => Some("JAW_RIGHT"), + Self::JAW_LEFT => Some("JAW_LEFT"), + Self::JAW_FORWARD => Some("JAW_FORWARD"), + Self::JAW_OPEN => Some("JAW_OPEN"), + Self::MOUTH_APE_SHAPE => Some("MOUTH_APE_SHAPE"), + Self::MOUTH_UPPER_RIGHT => Some("MOUTH_UPPER_RIGHT"), + Self::MOUTH_UPPER_LEFT => Some("MOUTH_UPPER_LEFT"), + Self::MOUTH_LOWER_RIGHT => Some("MOUTH_LOWER_RIGHT"), + Self::MOUTH_LOWER_LEFT => Some("MOUTH_LOWER_LEFT"), + Self::MOUTH_UPPER_OVERTURN => Some("MOUTH_UPPER_OVERTURN"), + Self::MOUTH_LOWER_OVERTURN => Some("MOUTH_LOWER_OVERTURN"), + Self::MOUTH_POUT => Some("MOUTH_POUT"), + Self::MOUTH_SMILE_RIGHT => Some("MOUTH_SMILE_RIGHT"), + Self::MOUTH_SMILE_LEFT => Some("MOUTH_SMILE_LEFT"), + Self::MOUTH_SAD_RIGHT => Some("MOUTH_SAD_RIGHT"), + Self::MOUTH_SAD_LEFT => Some("MOUTH_SAD_LEFT"), + Self::CHEEK_PUFF_RIGHT => Some("CHEEK_PUFF_RIGHT"), + Self::CHEEK_PUFF_LEFT => Some("CHEEK_PUFF_LEFT"), + Self::CHEEK_SUCK => Some("CHEEK_SUCK"), + Self::MOUTH_UPPER_UPRIGHT => Some("MOUTH_UPPER_UPRIGHT"), + Self::MOUTH_UPPER_UPLEFT => Some("MOUTH_UPPER_UPLEFT"), + Self::MOUTH_LOWER_DOWNRIGHT => Some("MOUTH_LOWER_DOWNRIGHT"), + Self::MOUTH_LOWER_DOWNLEFT => Some("MOUTH_LOWER_DOWNLEFT"), + Self::MOUTH_UPPER_INSIDE => Some("MOUTH_UPPER_INSIDE"), + Self::MOUTH_LOWER_INSIDE => Some("MOUTH_LOWER_INSIDE"), + Self::MOUTH_LOWER_OVERLAY => Some("MOUTH_LOWER_OVERLAY"), + Self::TONGUE_LONGSTEP1 => Some("TONGUE_LONGSTEP1"), + Self::TONGUE_LEFT => Some("TONGUE_LEFT"), + Self::TONGUE_RIGHT => Some("TONGUE_RIGHT"), + Self::TONGUE_UP => Some("TONGUE_UP"), + Self::TONGUE_DOWN => Some("TONGUE_DOWN"), + Self::TONGUE_ROLL => Some("TONGUE_ROLL"), + Self::TONGUE_LONGSTEP2 => Some("TONGUE_LONGSTEP2"), + Self::TONGUE_UPRIGHT_MORPH => Some("TONGUE_UPRIGHT_MORPH"), + Self::TONGUE_UPLEFT_MORPH => Some("TONGUE_UPLEFT_MORPH"), + Self::TONGUE_DOWNRIGHT_MORPH => Some("TONGUE_DOWNRIGHT_MORPH"), + Self::TONGUE_DOWNLEFT_MORPH => Some("TONGUE_DOWNLEFT_MORPH"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrPassthroughFormHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughFormHTC)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct PassthroughFormHTC(i32); +impl PassthroughFormHTC { + #[doc = "Presents the passthrough with full of the entire screen."] + pub const PLANAR: PassthroughFormHTC = Self(0i32); + #[doc = "Presents the passthrough projecting onto a custom mesh."] + pub const PROJECTED: PassthroughFormHTC = Self(1i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1934,29 +2264,29 @@ impl SceneObjectTypeMSFT { self.0 } } -impl fmt::Debug for SceneObjectTypeMSFT { +impl fmt::Debug for PassthroughFormHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCATEGORIZED => Some("UNCATEGORIZED"), - Self::BACKGROUND => Some("BACKGROUND"), - Self::WALL => Some("WALL"), - Self::FLOOR => Some("FLOOR"), - Self::CEILING => Some("CEILING"), - Self::PLATFORM => Some("PLATFORM"), - Self::INFERRED => Some("INFERRED"), + Self::PLANAR => Some("PLANAR"), + Self::PROJECTED => Some("PROJECTED"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrScenePlaneAlignmentTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrScenePlaneAlignmentTypeMSFT)"] +#[doc = "See [XrFoveationModeHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationModeHTC)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct ScenePlaneAlignmentTypeMSFT(i32); -impl ScenePlaneAlignmentTypeMSFT { - pub const NON_ORTHOGONAL: ScenePlaneAlignmentTypeMSFT = Self(0i32); - pub const HORIZONTAL: ScenePlaneAlignmentTypeMSFT = Self(1i32); - pub const VERTICAL: ScenePlaneAlignmentTypeMSFT = Self(2i32); +pub struct FoveationModeHTC(i32); +impl FoveationModeHTC { + #[doc = "No foveation"] + pub const DISABLE: FoveationModeHTC = Self(0i32); + #[doc = "Apply system default setting with fixed clear FOV and periphery quality."] + pub const FIXED: FoveationModeHTC = Self(1i32); + #[doc = "Allow system to set foveation dynamically according realtime system metric or other extensions."] + pub const DYNAMIC: FoveationModeHTC = Self(2i32); + #[doc = "Allow application to set foveation with desired clear FOV, periphery quality, and focal center offset."] + pub const CUSTOM: FoveationModeHTC = Self(3i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1964,26 +2294,31 @@ impl ScenePlaneAlignmentTypeMSFT { self.0 } } -impl fmt::Debug for ScenePlaneAlignmentTypeMSFT { +impl fmt::Debug for FoveationModeHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NON_ORTHOGONAL => Some("NON_ORTHOGONAL"), - Self::HORIZONTAL => Some("HORIZONTAL"), - Self::VERTICAL => Some("VERTICAL"), + Self::DISABLE => Some("DISABLE"), + Self::FIXED => Some("FIXED"), + Self::DYNAMIC => Some("DYNAMIC"), + Self::CUSTOM => Some("CUSTOM"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrSceneComputeStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeStateMSFT)"] +#[doc = "See [XrFoveationLevelHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationLevelHTC)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct SceneComputeStateMSFT(i32); -impl SceneComputeStateMSFT { - pub const NONE: SceneComputeStateMSFT = Self(0i32); - pub const UPDATING: SceneComputeStateMSFT = Self(1i32); - pub const COMPLETED: SceneComputeStateMSFT = Self(2i32); - pub const COMPLETED_WITH_ERROR: SceneComputeStateMSFT = Self(3i32); +pub struct FoveationLevelHTC(i32); +impl FoveationLevelHTC { + #[doc = "No foveation"] + pub const NONE: FoveationLevelHTC = Self(0i32); + #[doc = "Light periphery pixel density drop and lower performance gain."] + pub const LOW: FoveationLevelHTC = Self(1i32); + #[doc = "Medium periphery pixel density drop and medium performance gain"] + pub const MEDIUM: FoveationLevelHTC = Self(2i32); + #[doc = "Heavy periphery pixel density drop and higher performance gain"] + pub const HIGH: FoveationLevelHTC = Self(3i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -1991,28 +2326,27 @@ impl SceneComputeStateMSFT { self.0 } } -impl fmt::Debug for SceneComputeStateMSFT { +impl fmt::Debug for FoveationLevelHTC { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::NONE => Some("NONE"), - Self::UPDATING => Some("UPDATING"), - Self::COMPLETED => Some("COMPLETED"), - Self::COMPLETED_WITH_ERROR => Some("COMPLETED_WITH_ERROR"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrSceneComputeFeatureMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeFeatureMSFT)"] +#[doc = "See [XrLocalDimmingModeMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLocalDimmingModeMETA)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct SceneComputeFeatureMSFT(i32); -impl SceneComputeFeatureMSFT { - pub const PLANE: SceneComputeFeatureMSFT = Self(1i32); - pub const PLANE_MESH: SceneComputeFeatureMSFT = Self(2i32); - pub const VISUAL_MESH: SceneComputeFeatureMSFT = Self(3i32); - pub const COLLIDER_MESH: SceneComputeFeatureMSFT = Self(4i32); - pub const SERIALIZE_SCENE: SceneComputeFeatureMSFT = Self(1000098000i32); +pub struct LocalDimmingModeMETA(i32); +impl LocalDimmingModeMETA { + #[doc = "Local dimming is turned off by default for the current submitted frame. This is the same as not chaining XrLocalDimmingModeMETA."] + pub const OFF: LocalDimmingModeMETA = Self(0i32); + #[doc = "Local dimming is turned on for the current submitted frame."] + pub const ON: LocalDimmingModeMETA = Self(1i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2020,27 +2354,85 @@ impl SceneComputeFeatureMSFT { self.0 } } -impl fmt::Debug for SceneComputeFeatureMSFT { +impl fmt::Debug for LocalDimmingModeMETA { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PLANE => Some("PLANE"), - Self::PLANE_MESH => Some("PLANE_MESH"), - Self::VISUAL_MESH => Some("VISUAL_MESH"), - Self::COLLIDER_MESH => Some("COLLIDER_MESH"), - Self::SERIALIZE_SCENE => Some("SERIALIZE_SCENE"), + Self::OFF => Some("OFF"), + Self::ON => Some("ON"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrSceneComputeConsistencyMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeConsistencyMSFT)"] +#[doc = "See [XrFaceExpressionFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceExpressionFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct SceneComputeConsistencyMSFT(i32); -impl SceneComputeConsistencyMSFT { - pub const SNAPSHOT_COMPLETE: SceneComputeConsistencyMSFT = Self(1i32); - pub const SNAPSHOT_INCOMPLETE_FAST: SceneComputeConsistencyMSFT = Self(2i32); - pub const OCCLUSION_OPTIMIZED: SceneComputeConsistencyMSFT = Self(3i32); +pub struct FaceExpressionFB(i32); +impl FaceExpressionFB { + pub const BROW_LOWERER_L: FaceExpressionFB = Self(0i32); + pub const BROW_LOWERER_R: FaceExpressionFB = Self(1i32); + pub const CHEEK_PUFF_L: FaceExpressionFB = Self(2i32); + pub const CHEEK_PUFF_R: FaceExpressionFB = Self(3i32); + pub const CHEEK_RAISER_L: FaceExpressionFB = Self(4i32); + pub const CHEEK_RAISER_R: FaceExpressionFB = Self(5i32); + pub const CHEEK_SUCK_L: FaceExpressionFB = Self(6i32); + pub const CHEEK_SUCK_R: FaceExpressionFB = Self(7i32); + pub const CHIN_RAISER_B: FaceExpressionFB = Self(8i32); + pub const CHIN_RAISER_T: FaceExpressionFB = Self(9i32); + pub const DIMPLER_L: FaceExpressionFB = Self(10i32); + pub const DIMPLER_R: FaceExpressionFB = Self(11i32); + pub const EYES_CLOSED_L: FaceExpressionFB = Self(12i32); + pub const EYES_CLOSED_R: FaceExpressionFB = Self(13i32); + pub const EYES_LOOK_DOWN_L: FaceExpressionFB = Self(14i32); + pub const EYES_LOOK_DOWN_R: FaceExpressionFB = Self(15i32); + pub const EYES_LOOK_LEFT_L: FaceExpressionFB = Self(16i32); + pub const EYES_LOOK_LEFT_R: FaceExpressionFB = Self(17i32); + pub const EYES_LOOK_RIGHT_L: FaceExpressionFB = Self(18i32); + pub const EYES_LOOK_RIGHT_R: FaceExpressionFB = Self(19i32); + pub const EYES_LOOK_UP_L: FaceExpressionFB = Self(20i32); + pub const EYES_LOOK_UP_R: FaceExpressionFB = Self(21i32); + pub const INNER_BROW_RAISER_L: FaceExpressionFB = Self(22i32); + pub const INNER_BROW_RAISER_R: FaceExpressionFB = Self(23i32); + pub const JAW_DROP: FaceExpressionFB = Self(24i32); + pub const JAW_SIDEWAYS_LEFT: FaceExpressionFB = Self(25i32); + pub const JAW_SIDEWAYS_RIGHT: FaceExpressionFB = Self(26i32); + pub const JAW_THRUST: FaceExpressionFB = Self(27i32); + pub const LID_TIGHTENER_L: FaceExpressionFB = Self(28i32); + pub const LID_TIGHTENER_R: FaceExpressionFB = Self(29i32); + pub const LIP_CORNER_DEPRESSOR_L: FaceExpressionFB = Self(30i32); + pub const LIP_CORNER_DEPRESSOR_R: FaceExpressionFB = Self(31i32); + pub const LIP_CORNER_PULLER_L: FaceExpressionFB = Self(32i32); + pub const LIP_CORNER_PULLER_R: FaceExpressionFB = Self(33i32); + pub const LIP_FUNNELER_LB: FaceExpressionFB = Self(34i32); + pub const LIP_FUNNELER_LT: FaceExpressionFB = Self(35i32); + pub const LIP_FUNNELER_RB: FaceExpressionFB = Self(36i32); + pub const LIP_FUNNELER_RT: FaceExpressionFB = Self(37i32); + pub const LIP_PRESSOR_L: FaceExpressionFB = Self(38i32); + pub const LIP_PRESSOR_R: FaceExpressionFB = Self(39i32); + pub const LIP_PUCKER_L: FaceExpressionFB = Self(40i32); + pub const LIP_PUCKER_R: FaceExpressionFB = Self(41i32); + pub const LIP_STRETCHER_L: FaceExpressionFB = Self(42i32); + pub const LIP_STRETCHER_R: FaceExpressionFB = Self(43i32); + pub const LIP_SUCK_LB: FaceExpressionFB = Self(44i32); + pub const LIP_SUCK_LT: FaceExpressionFB = Self(45i32); + pub const LIP_SUCK_RB: FaceExpressionFB = Self(46i32); + pub const LIP_SUCK_RT: FaceExpressionFB = Self(47i32); + pub const LIP_TIGHTENER_L: FaceExpressionFB = Self(48i32); + pub const LIP_TIGHTENER_R: FaceExpressionFB = Self(49i32); + pub const LIPS_TOWARD: FaceExpressionFB = Self(50i32); + pub const LOWER_LIP_DEPRESSOR_L: FaceExpressionFB = Self(51i32); + pub const LOWER_LIP_DEPRESSOR_R: FaceExpressionFB = Self(52i32); + pub const MOUTH_LEFT: FaceExpressionFB = Self(53i32); + pub const MOUTH_RIGHT: FaceExpressionFB = Self(54i32); + pub const NOSE_WRINKLER_L: FaceExpressionFB = Self(55i32); + pub const NOSE_WRINKLER_R: FaceExpressionFB = Self(56i32); + pub const OUTER_BROW_RAISER_L: FaceExpressionFB = Self(57i32); + pub const OUTER_BROW_RAISER_R: FaceExpressionFB = Self(58i32); + pub const UPPER_LID_RAISER_L: FaceExpressionFB = Self(59i32); + pub const UPPER_LID_RAISER_R: FaceExpressionFB = Self(60i32); + pub const UPPER_LIP_RAISER_L: FaceExpressionFB = Self(61i32); + pub const UPPER_LIP_RAISER_R: FaceExpressionFB = Self(62i32); + pub const COUNT: FaceExpressionFB = Self(63i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2048,28 +2440,85 @@ impl SceneComputeConsistencyMSFT { self.0 } } -impl fmt::Debug for SceneComputeConsistencyMSFT { +impl fmt::Debug for FaceExpressionFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SNAPSHOT_COMPLETE => Some("SNAPSHOT_COMPLETE"), - Self::SNAPSHOT_INCOMPLETE_FAST => Some("SNAPSHOT_INCOMPLETE_FAST"), - Self::OCCLUSION_OPTIMIZED => Some("OCCLUSION_OPTIMIZED"), + Self::BROW_LOWERER_L => Some("BROW_LOWERER_L"), + Self::BROW_LOWERER_R => Some("BROW_LOWERER_R"), + Self::CHEEK_PUFF_L => Some("CHEEK_PUFF_L"), + Self::CHEEK_PUFF_R => Some("CHEEK_PUFF_R"), + Self::CHEEK_RAISER_L => Some("CHEEK_RAISER_L"), + Self::CHEEK_RAISER_R => Some("CHEEK_RAISER_R"), + Self::CHEEK_SUCK_L => Some("CHEEK_SUCK_L"), + Self::CHEEK_SUCK_R => Some("CHEEK_SUCK_R"), + Self::CHIN_RAISER_B => Some("CHIN_RAISER_B"), + Self::CHIN_RAISER_T => Some("CHIN_RAISER_T"), + Self::DIMPLER_L => Some("DIMPLER_L"), + Self::DIMPLER_R => Some("DIMPLER_R"), + Self::EYES_CLOSED_L => Some("EYES_CLOSED_L"), + Self::EYES_CLOSED_R => Some("EYES_CLOSED_R"), + Self::EYES_LOOK_DOWN_L => Some("EYES_LOOK_DOWN_L"), + Self::EYES_LOOK_DOWN_R => Some("EYES_LOOK_DOWN_R"), + Self::EYES_LOOK_LEFT_L => Some("EYES_LOOK_LEFT_L"), + Self::EYES_LOOK_LEFT_R => Some("EYES_LOOK_LEFT_R"), + Self::EYES_LOOK_RIGHT_L => Some("EYES_LOOK_RIGHT_L"), + Self::EYES_LOOK_RIGHT_R => Some("EYES_LOOK_RIGHT_R"), + Self::EYES_LOOK_UP_L => Some("EYES_LOOK_UP_L"), + Self::EYES_LOOK_UP_R => Some("EYES_LOOK_UP_R"), + Self::INNER_BROW_RAISER_L => Some("INNER_BROW_RAISER_L"), + Self::INNER_BROW_RAISER_R => Some("INNER_BROW_RAISER_R"), + Self::JAW_DROP => Some("JAW_DROP"), + Self::JAW_SIDEWAYS_LEFT => Some("JAW_SIDEWAYS_LEFT"), + Self::JAW_SIDEWAYS_RIGHT => Some("JAW_SIDEWAYS_RIGHT"), + Self::JAW_THRUST => Some("JAW_THRUST"), + Self::LID_TIGHTENER_L => Some("LID_TIGHTENER_L"), + Self::LID_TIGHTENER_R => Some("LID_TIGHTENER_R"), + Self::LIP_CORNER_DEPRESSOR_L => Some("LIP_CORNER_DEPRESSOR_L"), + Self::LIP_CORNER_DEPRESSOR_R => Some("LIP_CORNER_DEPRESSOR_R"), + Self::LIP_CORNER_PULLER_L => Some("LIP_CORNER_PULLER_L"), + Self::LIP_CORNER_PULLER_R => Some("LIP_CORNER_PULLER_R"), + Self::LIP_FUNNELER_LB => Some("LIP_FUNNELER_LB"), + Self::LIP_FUNNELER_LT => Some("LIP_FUNNELER_LT"), + Self::LIP_FUNNELER_RB => Some("LIP_FUNNELER_RB"), + Self::LIP_FUNNELER_RT => Some("LIP_FUNNELER_RT"), + Self::LIP_PRESSOR_L => Some("LIP_PRESSOR_L"), + Self::LIP_PRESSOR_R => Some("LIP_PRESSOR_R"), + Self::LIP_PUCKER_L => Some("LIP_PUCKER_L"), + Self::LIP_PUCKER_R => Some("LIP_PUCKER_R"), + Self::LIP_STRETCHER_L => Some("LIP_STRETCHER_L"), + Self::LIP_STRETCHER_R => Some("LIP_STRETCHER_R"), + Self::LIP_SUCK_LB => Some("LIP_SUCK_LB"), + Self::LIP_SUCK_LT => Some("LIP_SUCK_LT"), + Self::LIP_SUCK_RB => Some("LIP_SUCK_RB"), + Self::LIP_SUCK_RT => Some("LIP_SUCK_RT"), + Self::LIP_TIGHTENER_L => Some("LIP_TIGHTENER_L"), + Self::LIP_TIGHTENER_R => Some("LIP_TIGHTENER_R"), + Self::LIPS_TOWARD => Some("LIPS_TOWARD"), + Self::LOWER_LIP_DEPRESSOR_L => Some("LOWER_LIP_DEPRESSOR_L"), + Self::LOWER_LIP_DEPRESSOR_R => Some("LOWER_LIP_DEPRESSOR_R"), + Self::MOUTH_LEFT => Some("MOUTH_LEFT"), + Self::MOUTH_RIGHT => Some("MOUTH_RIGHT"), + Self::NOSE_WRINKLER_L => Some("NOSE_WRINKLER_L"), + Self::NOSE_WRINKLER_R => Some("NOSE_WRINKLER_R"), + Self::OUTER_BROW_RAISER_L => Some("OUTER_BROW_RAISER_L"), + Self::OUTER_BROW_RAISER_R => Some("OUTER_BROW_RAISER_R"), + Self::UPPER_LID_RAISER_L => Some("UPPER_LID_RAISER_L"), + Self::UPPER_LID_RAISER_R => Some("UPPER_LID_RAISER_R"), + Self::UPPER_LIP_RAISER_L => Some("UPPER_LIP_RAISER_L"), + Self::UPPER_LIP_RAISER_R => Some("UPPER_LIP_RAISER_R"), + Self::COUNT => Some("COUNT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrSceneComponentTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComponentTypeMSFT)"] +#[doc = "See [XrFaceExpressionSetFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceExpressionSetFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct SceneComponentTypeMSFT(i32); -impl SceneComponentTypeMSFT { - pub const INVALID: SceneComponentTypeMSFT = Self(-1i32); - pub const OBJECT: SceneComponentTypeMSFT = Self(1i32); - pub const PLANE: SceneComponentTypeMSFT = Self(2i32); - pub const VISUAL_MESH: SceneComponentTypeMSFT = Self(3i32); - pub const COLLIDER_MESH: SceneComponentTypeMSFT = Self(4i32); - pub const SERIALIZED_SCENE_FRAGMENT: SceneComponentTypeMSFT = Self(1000098000i32); +pub struct FaceExpressionSetFB(i32); +impl FaceExpressionSetFB { + #[doc = "indicates that the created XrFaceTrackerFB tracks the set of blend shapes described by XrFaceExpressionFB enum, i.e. the xrGetFaceExpressionWeightsFB function returns an array of blend shapes with the count of XR_FACE_EXPRESSION_COUNT_FB and can: be indexed using XrFaceExpressionFB."] + pub const DEFAULT: FaceExpressionSetFB = Self(0i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2077,29 +2526,23 @@ impl SceneComponentTypeMSFT { self.0 } } -impl fmt::Debug for SceneComponentTypeMSFT { +impl fmt::Debug for FaceExpressionSetFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INVALID => Some("INVALID"), - Self::OBJECT => Some("OBJECT"), - Self::PLANE => Some("PLANE"), - Self::VISUAL_MESH => Some("VISUAL_MESH"), - Self::COLLIDER_MESH => Some("COLLIDER_MESH"), - Self::SERIALIZED_SCENE_FRAGMENT => Some("SERIALIZED_SCENE_FRAGMENT"), + Self::DEFAULT => Some("DEFAULT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrMeshComputeLodMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrMeshComputeLodMSFT)"] +#[doc = "See [XrFaceConfidenceFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceConfidenceFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct MeshComputeLodMSFT(i32); -impl MeshComputeLodMSFT { - pub const COARSE: MeshComputeLodMSFT = Self(1i32); - pub const MEDIUM: MeshComputeLodMSFT = Self(2i32); - pub const FINE: MeshComputeLodMSFT = Self(3i32); - pub const UNLIMITED: MeshComputeLodMSFT = Self(4i32); +pub struct FaceConfidenceFB(i32); +impl FaceConfidenceFB { + pub const LOWER_FACE: FaceConfidenceFB = Self(0i32); + pub const UPPER_FACE: FaceConfidenceFB = Self(1i32); + pub const COUNT: FaceConfidenceFB = Self(2i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2107,31 +2550,94 @@ impl MeshComputeLodMSFT { self.0 } } -impl fmt::Debug for MeshComputeLodMSFT { +impl fmt::Debug for FaceConfidenceFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COARSE => Some("COARSE"), - Self::MEDIUM => Some("MEDIUM"), - Self::FINE => Some("FINE"), - Self::UNLIMITED => Some("UNLIMITED"), + Self::LOWER_FACE => Some("LOWER_FACE"), + Self::UPPER_FACE => Some("UPPER_FACE"), + Self::COUNT => Some("COUNT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrColorSpaceFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrColorSpaceFB)"] +#[doc = "See [XrBodyJointFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyJointFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct ColorSpaceFB(i32); -impl ColorSpaceFB { - pub const UNMANAGED: ColorSpaceFB = Self(0i32); - pub const REC2020: ColorSpaceFB = Self(1i32); - pub const REC709: ColorSpaceFB = Self(2i32); - pub const RIFT_CV1: ColorSpaceFB = Self(3i32); - pub const RIFT_S: ColorSpaceFB = Self(4i32); - pub const QUEST: ColorSpaceFB = Self(5i32); - pub const P3: ColorSpaceFB = Self(6i32); - pub const ADOBE_RGB: ColorSpaceFB = Self(7i32); +pub struct BodyJointFB(i32); +impl BodyJointFB { + pub const ROOT: BodyJointFB = Self(0i32); + pub const HIPS: BodyJointFB = Self(1i32); + pub const SPINE_LOWER: BodyJointFB = Self(2i32); + pub const SPINE_MIDDLE: BodyJointFB = Self(3i32); + pub const SPINE_UPPER: BodyJointFB = Self(4i32); + pub const CHEST: BodyJointFB = Self(5i32); + pub const NECK: BodyJointFB = Self(6i32); + pub const HEAD: BodyJointFB = Self(7i32); + pub const LEFT_SHOULDER: BodyJointFB = Self(8i32); + pub const LEFT_SCAPULA: BodyJointFB = Self(9i32); + pub const LEFT_ARM_UPPER: BodyJointFB = Self(10i32); + pub const LEFT_ARM_LOWER: BodyJointFB = Self(11i32); + pub const LEFT_HAND_WRIST_TWIST: BodyJointFB = Self(12i32); + pub const RIGHT_SHOULDER: BodyJointFB = Self(13i32); + pub const RIGHT_SCAPULA: BodyJointFB = Self(14i32); + pub const RIGHT_ARM_UPPER: BodyJointFB = Self(15i32); + pub const RIGHT_ARM_LOWER: BodyJointFB = Self(16i32); + pub const RIGHT_HAND_WRIST_TWIST: BodyJointFB = Self(17i32); + pub const LEFT_HAND_PALM: BodyJointFB = Self(18i32); + pub const LEFT_HAND_WRIST: BodyJointFB = Self(19i32); + pub const LEFT_HAND_THUMB_METACARPAL: BodyJointFB = Self(20i32); + pub const LEFT_HAND_THUMB_PROXIMAL: BodyJointFB = Self(21i32); + pub const LEFT_HAND_THUMB_DISTAL: BodyJointFB = Self(22i32); + pub const LEFT_HAND_THUMB_TIP: BodyJointFB = Self(23i32); + pub const LEFT_HAND_INDEX_METACARPAL: BodyJointFB = Self(24i32); + pub const LEFT_HAND_INDEX_PROXIMAL: BodyJointFB = Self(25i32); + pub const LEFT_HAND_INDEX_INTERMEDIATE: BodyJointFB = Self(26i32); + pub const LEFT_HAND_INDEX_DISTAL: BodyJointFB = Self(27i32); + pub const LEFT_HAND_INDEX_TIP: BodyJointFB = Self(28i32); + pub const LEFT_HAND_MIDDLE_METACARPAL: BodyJointFB = Self(29i32); + pub const LEFT_HAND_MIDDLE_PROXIMAL: BodyJointFB = Self(30i32); + pub const LEFT_HAND_MIDDLE_INTERMEDIATE: BodyJointFB = Self(31i32); + pub const LEFT_HAND_MIDDLE_DISTAL: BodyJointFB = Self(32i32); + pub const LEFT_HAND_MIDDLE_TIP: BodyJointFB = Self(33i32); + pub const LEFT_HAND_RING_METACARPAL: BodyJointFB = Self(34i32); + pub const LEFT_HAND_RING_PROXIMAL: BodyJointFB = Self(35i32); + pub const LEFT_HAND_RING_INTERMEDIATE: BodyJointFB = Self(36i32); + pub const LEFT_HAND_RING_DISTAL: BodyJointFB = Self(37i32); + pub const LEFT_HAND_RING_TIP: BodyJointFB = Self(38i32); + pub const LEFT_HAND_LITTLE_METACARPAL: BodyJointFB = Self(39i32); + pub const LEFT_HAND_LITTLE_PROXIMAL: BodyJointFB = Self(40i32); + pub const LEFT_HAND_LITTLE_INTERMEDIATE: BodyJointFB = Self(41i32); + pub const LEFT_HAND_LITTLE_DISTAL: BodyJointFB = Self(42i32); + pub const LEFT_HAND_LITTLE_TIP: BodyJointFB = Self(43i32); + pub const RIGHT_HAND_PALM: BodyJointFB = Self(44i32); + pub const RIGHT_HAND_WRIST: BodyJointFB = Self(45i32); + pub const RIGHT_HAND_THUMB_METACARPAL: BodyJointFB = Self(46i32); + pub const RIGHT_HAND_THUMB_PROXIMAL: BodyJointFB = Self(47i32); + pub const RIGHT_HAND_THUMB_DISTAL: BodyJointFB = Self(48i32); + pub const RIGHT_HAND_THUMB_TIP: BodyJointFB = Self(49i32); + pub const RIGHT_HAND_INDEX_METACARPAL: BodyJointFB = Self(50i32); + pub const RIGHT_HAND_INDEX_PROXIMAL: BodyJointFB = Self(51i32); + pub const RIGHT_HAND_INDEX_INTERMEDIATE: BodyJointFB = Self(52i32); + pub const RIGHT_HAND_INDEX_DISTAL: BodyJointFB = Self(53i32); + pub const RIGHT_HAND_INDEX_TIP: BodyJointFB = Self(54i32); + pub const RIGHT_HAND_MIDDLE_METACARPAL: BodyJointFB = Self(55i32); + pub const RIGHT_HAND_MIDDLE_PROXIMAL: BodyJointFB = Self(56i32); + pub const RIGHT_HAND_MIDDLE_INTERMEDIATE: BodyJointFB = Self(57i32); + pub const RIGHT_HAND_MIDDLE_DISTAL: BodyJointFB = Self(58i32); + pub const RIGHT_HAND_MIDDLE_TIP: BodyJointFB = Self(59i32); + pub const RIGHT_HAND_RING_METACARPAL: BodyJointFB = Self(60i32); + pub const RIGHT_HAND_RING_PROXIMAL: BodyJointFB = Self(61i32); + pub const RIGHT_HAND_RING_INTERMEDIATE: BodyJointFB = Self(62i32); + pub const RIGHT_HAND_RING_DISTAL: BodyJointFB = Self(63i32); + pub const RIGHT_HAND_RING_TIP: BodyJointFB = Self(64i32); + pub const RIGHT_HAND_LITTLE_METACARPAL: BodyJointFB = Self(65i32); + pub const RIGHT_HAND_LITTLE_PROXIMAL: BodyJointFB = Self(66i32); + pub const RIGHT_HAND_LITTLE_INTERMEDIATE: BodyJointFB = Self(67i32); + pub const RIGHT_HAND_LITTLE_DISTAL: BodyJointFB = Self(68i32); + pub const RIGHT_HAND_LITTLE_TIP: BodyJointFB = Self(69i32); + pub const COUNT: BodyJointFB = Self(70i32); + pub const NONE: BodyJointFB = Self(-1i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2139,35 +2645,93 @@ impl ColorSpaceFB { self.0 } } -impl fmt::Debug for ColorSpaceFB { +impl fmt::Debug for BodyJointFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNMANAGED => Some("UNMANAGED"), - Self::REC2020 => Some("REC2020"), - Self::REC709 => Some("REC709"), - Self::RIFT_CV1 => Some("RIFT_CV1"), - Self::RIFT_S => Some("RIFT_S"), - Self::QUEST => Some("QUEST"), - Self::P3 => Some("P3"), - Self::ADOBE_RGB => Some("ADOBE_RGB"), + Self::ROOT => Some("ROOT"), + Self::HIPS => Some("HIPS"), + Self::SPINE_LOWER => Some("SPINE_LOWER"), + Self::SPINE_MIDDLE => Some("SPINE_MIDDLE"), + Self::SPINE_UPPER => Some("SPINE_UPPER"), + Self::CHEST => Some("CHEST"), + Self::NECK => Some("NECK"), + Self::HEAD => Some("HEAD"), + Self::LEFT_SHOULDER => Some("LEFT_SHOULDER"), + Self::LEFT_SCAPULA => Some("LEFT_SCAPULA"), + Self::LEFT_ARM_UPPER => Some("LEFT_ARM_UPPER"), + Self::LEFT_ARM_LOWER => Some("LEFT_ARM_LOWER"), + Self::LEFT_HAND_WRIST_TWIST => Some("LEFT_HAND_WRIST_TWIST"), + Self::RIGHT_SHOULDER => Some("RIGHT_SHOULDER"), + Self::RIGHT_SCAPULA => Some("RIGHT_SCAPULA"), + Self::RIGHT_ARM_UPPER => Some("RIGHT_ARM_UPPER"), + Self::RIGHT_ARM_LOWER => Some("RIGHT_ARM_LOWER"), + Self::RIGHT_HAND_WRIST_TWIST => Some("RIGHT_HAND_WRIST_TWIST"), + Self::LEFT_HAND_PALM => Some("LEFT_HAND_PALM"), + Self::LEFT_HAND_WRIST => Some("LEFT_HAND_WRIST"), + Self::LEFT_HAND_THUMB_METACARPAL => Some("LEFT_HAND_THUMB_METACARPAL"), + Self::LEFT_HAND_THUMB_PROXIMAL => Some("LEFT_HAND_THUMB_PROXIMAL"), + Self::LEFT_HAND_THUMB_DISTAL => Some("LEFT_HAND_THUMB_DISTAL"), + Self::LEFT_HAND_THUMB_TIP => Some("LEFT_HAND_THUMB_TIP"), + Self::LEFT_HAND_INDEX_METACARPAL => Some("LEFT_HAND_INDEX_METACARPAL"), + Self::LEFT_HAND_INDEX_PROXIMAL => Some("LEFT_HAND_INDEX_PROXIMAL"), + Self::LEFT_HAND_INDEX_INTERMEDIATE => Some("LEFT_HAND_INDEX_INTERMEDIATE"), + Self::LEFT_HAND_INDEX_DISTAL => Some("LEFT_HAND_INDEX_DISTAL"), + Self::LEFT_HAND_INDEX_TIP => Some("LEFT_HAND_INDEX_TIP"), + Self::LEFT_HAND_MIDDLE_METACARPAL => Some("LEFT_HAND_MIDDLE_METACARPAL"), + Self::LEFT_HAND_MIDDLE_PROXIMAL => Some("LEFT_HAND_MIDDLE_PROXIMAL"), + Self::LEFT_HAND_MIDDLE_INTERMEDIATE => Some("LEFT_HAND_MIDDLE_INTERMEDIATE"), + Self::LEFT_HAND_MIDDLE_DISTAL => Some("LEFT_HAND_MIDDLE_DISTAL"), + Self::LEFT_HAND_MIDDLE_TIP => Some("LEFT_HAND_MIDDLE_TIP"), + Self::LEFT_HAND_RING_METACARPAL => Some("LEFT_HAND_RING_METACARPAL"), + Self::LEFT_HAND_RING_PROXIMAL => Some("LEFT_HAND_RING_PROXIMAL"), + Self::LEFT_HAND_RING_INTERMEDIATE => Some("LEFT_HAND_RING_INTERMEDIATE"), + Self::LEFT_HAND_RING_DISTAL => Some("LEFT_HAND_RING_DISTAL"), + Self::LEFT_HAND_RING_TIP => Some("LEFT_HAND_RING_TIP"), + Self::LEFT_HAND_LITTLE_METACARPAL => Some("LEFT_HAND_LITTLE_METACARPAL"), + Self::LEFT_HAND_LITTLE_PROXIMAL => Some("LEFT_HAND_LITTLE_PROXIMAL"), + Self::LEFT_HAND_LITTLE_INTERMEDIATE => Some("LEFT_HAND_LITTLE_INTERMEDIATE"), + Self::LEFT_HAND_LITTLE_DISTAL => Some("LEFT_HAND_LITTLE_DISTAL"), + Self::LEFT_HAND_LITTLE_TIP => Some("LEFT_HAND_LITTLE_TIP"), + Self::RIGHT_HAND_PALM => Some("RIGHT_HAND_PALM"), + Self::RIGHT_HAND_WRIST => Some("RIGHT_HAND_WRIST"), + Self::RIGHT_HAND_THUMB_METACARPAL => Some("RIGHT_HAND_THUMB_METACARPAL"), + Self::RIGHT_HAND_THUMB_PROXIMAL => Some("RIGHT_HAND_THUMB_PROXIMAL"), + Self::RIGHT_HAND_THUMB_DISTAL => Some("RIGHT_HAND_THUMB_DISTAL"), + Self::RIGHT_HAND_THUMB_TIP => Some("RIGHT_HAND_THUMB_TIP"), + Self::RIGHT_HAND_INDEX_METACARPAL => Some("RIGHT_HAND_INDEX_METACARPAL"), + Self::RIGHT_HAND_INDEX_PROXIMAL => Some("RIGHT_HAND_INDEX_PROXIMAL"), + Self::RIGHT_HAND_INDEX_INTERMEDIATE => Some("RIGHT_HAND_INDEX_INTERMEDIATE"), + Self::RIGHT_HAND_INDEX_DISTAL => Some("RIGHT_HAND_INDEX_DISTAL"), + Self::RIGHT_HAND_INDEX_TIP => Some("RIGHT_HAND_INDEX_TIP"), + Self::RIGHT_HAND_MIDDLE_METACARPAL => Some("RIGHT_HAND_MIDDLE_METACARPAL"), + Self::RIGHT_HAND_MIDDLE_PROXIMAL => Some("RIGHT_HAND_MIDDLE_PROXIMAL"), + Self::RIGHT_HAND_MIDDLE_INTERMEDIATE => Some("RIGHT_HAND_MIDDLE_INTERMEDIATE"), + Self::RIGHT_HAND_MIDDLE_DISTAL => Some("RIGHT_HAND_MIDDLE_DISTAL"), + Self::RIGHT_HAND_MIDDLE_TIP => Some("RIGHT_HAND_MIDDLE_TIP"), + Self::RIGHT_HAND_RING_METACARPAL => Some("RIGHT_HAND_RING_METACARPAL"), + Self::RIGHT_HAND_RING_PROXIMAL => Some("RIGHT_HAND_RING_PROXIMAL"), + Self::RIGHT_HAND_RING_INTERMEDIATE => Some("RIGHT_HAND_RING_INTERMEDIATE"), + Self::RIGHT_HAND_RING_DISTAL => Some("RIGHT_HAND_RING_DISTAL"), + Self::RIGHT_HAND_RING_TIP => Some("RIGHT_HAND_RING_TIP"), + Self::RIGHT_HAND_LITTLE_METACARPAL => Some("RIGHT_HAND_LITTLE_METACARPAL"), + Self::RIGHT_HAND_LITTLE_PROXIMAL => Some("RIGHT_HAND_LITTLE_PROXIMAL"), + Self::RIGHT_HAND_LITTLE_INTERMEDIATE => Some("RIGHT_HAND_LITTLE_INTERMEDIATE"), + Self::RIGHT_HAND_LITTLE_DISTAL => Some("RIGHT_HAND_LITTLE_DISTAL"), + Self::RIGHT_HAND_LITTLE_TIP => Some("RIGHT_HAND_LITTLE_TIP"), + Self::COUNT => Some("COUNT"), + Self::NONE => Some("NONE"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrFoveationLevelFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationLevelFB)"] +#[doc = "Describes the set of body joints to track when creating an XrBodyTrackerFB. - see [XrBodyJointSetFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyJointSetFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct FoveationLevelFB(i32); -impl FoveationLevelFB { - #[doc = "No foveation"] - pub const NONE: FoveationLevelFB = Self(0i32); - #[doc = "Less foveation (higher periphery visual fidelity, lower performance)"] - pub const LOW: FoveationLevelFB = Self(1i32); - #[doc = "Medium foveation (medium periphery visual fidelity, medium performance)"] - pub const MEDIUM: FoveationLevelFB = Self(2i32); - #[doc = "High foveation (lower periphery visual fidelity, higher performance)"] - pub const HIGH: FoveationLevelFB = Self(3i32); +pub struct BodyJointSetFB(i32); +impl BodyJointSetFB { + #[doc = "Indicates that the created XrBodyTrackerFB tracks the set of body joints described by XrBodyJointFB enum, i.e. the xrLocateBodyJointsFB function returns an array of joint locations with the count of XR_BODY_JOINT_COUNT_FB and can be indexed using XrBodyJointFB."] + pub const DEFAULT: BodyJointSetFB = Self(0i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2175,27 +2739,25 @@ impl FoveationLevelFB { self.0 } } -impl fmt::Debug for FoveationLevelFB { +impl fmt::Debug for BodyJointSetFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NONE => Some("NONE"), - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), + Self::DEFAULT => Some("DEFAULT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrFoveationDynamicFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationDynamicFB)"] +#[doc = "See [XrEyePositionFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyePositionFB)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct FoveationDynamicFB(i32); -impl FoveationDynamicFB { - #[doc = "Static foveation at the maximum desired level"] - pub const DISABLED: FoveationDynamicFB = Self(0i32); - #[doc = "Dynamic changing foveation based on performance headroom available up to the maximum desired level"] - pub const LEVEL_ENABLED: FoveationDynamicFB = Self(1i32); +pub struct EyePositionFB(i32); +impl EyePositionFB { + #[doc = "Specifies the position of the left eye."] + pub const LEFT: EyePositionFB = Self(0i32); + #[doc = "Specifies the position of the right eye."] + pub const RIGHT: EyePositionFB = Self(1i32); + pub const COUNT: EyePositionFB = Self(2i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2203,25 +2765,24 @@ impl FoveationDynamicFB { self.0 } } -impl fmt::Debug for FoveationDynamicFB { +impl fmt::Debug for EyePositionFB { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::LEVEL_ENABLED => Some("LEVEL_ENABLED"), + Self::LEFT => Some("LEFT"), + Self::RIGHT => Some("RIGHT"), + Self::COUNT => Some("COUNT"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrReprojectionModeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrReprojectionModeMSFT)"] +#[doc = "See [XrTrackingOptimizationSettingsDomainQCOM](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTrackingOptimizationSettingsDomainQCOM)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct ReprojectionModeMSFT(i32); -impl ReprojectionModeMSFT { - pub const DEPTH: ReprojectionModeMSFT = Self(1i32); - pub const PLANAR_FROM_DEPTH: ReprojectionModeMSFT = Self(2i32); - pub const PLANAR_MANUAL: ReprojectionModeMSFT = Self(3i32); - pub const ORIENTATION_ONLY: ReprojectionModeMSFT = Self(4i32); +pub struct TrackingOptimizationSettingsDomainQCOM(i32); +impl TrackingOptimizationSettingsDomainQCOM { + #[doc = "Setting applies to all QCOM tracking extensions."] + pub const ALL: TrackingOptimizationSettingsDomainQCOM = Self(1i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2229,27 +2790,30 @@ impl ReprojectionModeMSFT { self.0 } } -impl fmt::Debug for ReprojectionModeMSFT { +impl fmt::Debug for TrackingOptimizationSettingsDomainQCOM { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEPTH => Some("DEPTH"), - Self::PLANAR_FROM_DEPTH => Some("PLANAR_FROM_DEPTH"), - Self::PLANAR_MANUAL => Some("PLANAR_MANUAL"), - Self::ORIENTATION_ONLY => Some("ORIENTATION_ONLY"), + Self::ALL => Some("ALL"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrFacialTrackingTypeHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackingTypeHTC)"] +#[doc = "See [XrTrackingOptimizationSettingsHintQCOM](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTrackingOptimizationSettingsHintQCOM)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct FacialTrackingTypeHTC(i32); -impl FacialTrackingTypeHTC { - #[doc = "Specifies this handle will observe eye expressions, with values indexed by XrEyeExpressionHTC whose count is XR_FACIAL_EXPRESSION_EYE_COUNT_HTC."] - pub const EYE_DEFAULT: FacialTrackingTypeHTC = Self(1i32); - #[doc = "Specifies this handle will observe lip expressions, with values indexed by XrLipExpressionHTC whose count is XR_FACIAL_EXPRESSION_LIP_COUNT_HTC."] - pub const LIP_DEFAULT: FacialTrackingTypeHTC = Self(2i32); +pub struct TrackingOptimizationSettingsHintQCOM(i32); +impl TrackingOptimizationSettingsHintQCOM { + #[doc = "Used by the application to indicate that it does not have a preference to optimize for. The run-time is understood to choose a balanced approach."] + pub const NONE: TrackingOptimizationSettingsHintQCOM = Self(0i32); + #[doc = "Used by the application to indicate that it prefers tracking to be optimized for long range, possibly at the expense of competing interests."] + pub const LONG_RANGE_PRIORIZATION: TrackingOptimizationSettingsHintQCOM = Self(1i32); + #[doc = "Used by the application to indicate that it prefers tracking to be optimized for close range, possibly at the expense of competing interests."] + pub const CLOSE_RANGE_PRIORIZATION: TrackingOptimizationSettingsHintQCOM = Self(2i32); + #[doc = "Used by the application to indicate that it prefers tracking to be optimized for low power consumption, possibly at the expense of competing interests."] + pub const LOW_POWER_PRIORIZATION: TrackingOptimizationSettingsHintQCOM = Self(3i32); + #[doc = "Used by the application to indicate that it prefers tracking to be optimized for increased tracking performance, possibly at the cost of increased power consumption."] + pub const HIGH_POWER_PRIORIZATION: TrackingOptimizationSettingsHintQCOM = Self(4i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2257,35 +2821,34 @@ impl FacialTrackingTypeHTC { self.0 } } -impl fmt::Debug for FacialTrackingTypeHTC { +impl fmt::Debug for TrackingOptimizationSettingsHintQCOM { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EYE_DEFAULT => Some("EYE_DEFAULT"), - Self::LIP_DEFAULT => Some("LIP_DEFAULT"), + Self::NONE => Some("NONE"), + Self::LONG_RANGE_PRIORIZATION => Some("LONG_RANGE_PRIORIZATION"), + Self::CLOSE_RANGE_PRIORIZATION => Some("CLOSE_RANGE_PRIORIZATION"), + Self::LOW_POWER_PRIORIZATION => Some("LOW_POWER_PRIORIZATION"), + Self::HIGH_POWER_PRIORIZATION => Some("HIGH_POWER_PRIORIZATION"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrEyeExpressionHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeExpressionHTC)"] +#[doc = "See [XrForceFeedbackCurlLocationMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrForceFeedbackCurlLocationMNDX)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct EyeExpressionHTC(i32); -impl EyeExpressionHTC { - pub const LEFT_BLINK: EyeExpressionHTC = Self(0i32); - pub const LEFT_WIDE: EyeExpressionHTC = Self(1i32); - pub const RIGHT_BLINK: EyeExpressionHTC = Self(2i32); - pub const RIGHT_WIDE: EyeExpressionHTC = Self(3i32); - pub const LEFT_SQUEEZE: EyeExpressionHTC = Self(4i32); - pub const RIGHT_SQUEEZE: EyeExpressionHTC = Self(5i32); - pub const LEFT_DOWN: EyeExpressionHTC = Self(6i32); - pub const RIGHT_DOWN: EyeExpressionHTC = Self(7i32); - pub const LEFT_OUT: EyeExpressionHTC = Self(8i32); - pub const RIGHT_IN: EyeExpressionHTC = Self(9i32); - pub const LEFT_IN: EyeExpressionHTC = Self(10i32); - pub const RIGHT_OUT: EyeExpressionHTC = Self(11i32); - pub const LEFT_UP: EyeExpressionHTC = Self(12i32); - pub const RIGHT_UP: EyeExpressionHTC = Self(13i32); +pub struct ForceFeedbackCurlLocationMNDX(i32); +impl ForceFeedbackCurlLocationMNDX { + #[doc = "force feedback for thumb curl"] + pub const THUMB_CURL: ForceFeedbackCurlLocationMNDX = Self(0i32); + #[doc = "force feedback for index finger curl"] + pub const INDEX_CURL: ForceFeedbackCurlLocationMNDX = Self(1i32); + #[doc = "force feedback for middle finger curl"] + pub const MIDDLE_CURL: ForceFeedbackCurlLocationMNDX = Self(2i32); + #[doc = "force feedback for ring finger curl"] + pub const RING_CURL: ForceFeedbackCurlLocationMNDX = Self(3i32); + #[doc = "force feedback for little finger curl"] + pub const LITTLE_CURL: ForceFeedbackCurlLocationMNDX = Self(4i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2293,70 +2856,29 @@ impl EyeExpressionHTC { self.0 } } -impl fmt::Debug for EyeExpressionHTC { +impl fmt::Debug for ForceFeedbackCurlLocationMNDX { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LEFT_BLINK => Some("LEFT_BLINK"), - Self::LEFT_WIDE => Some("LEFT_WIDE"), - Self::RIGHT_BLINK => Some("RIGHT_BLINK"), - Self::RIGHT_WIDE => Some("RIGHT_WIDE"), - Self::LEFT_SQUEEZE => Some("LEFT_SQUEEZE"), - Self::RIGHT_SQUEEZE => Some("RIGHT_SQUEEZE"), - Self::LEFT_DOWN => Some("LEFT_DOWN"), - Self::RIGHT_DOWN => Some("RIGHT_DOWN"), - Self::LEFT_OUT => Some("LEFT_OUT"), - Self::RIGHT_IN => Some("RIGHT_IN"), - Self::LEFT_IN => Some("LEFT_IN"), - Self::RIGHT_OUT => Some("RIGHT_OUT"), - Self::LEFT_UP => Some("LEFT_UP"), - Self::RIGHT_UP => Some("RIGHT_UP"), + Self::THUMB_CURL => Some("THUMB_CURL"), + Self::INDEX_CURL => Some("INDEX_CURL"), + Self::MIDDLE_CURL => Some("MIDDLE_CURL"), + Self::RING_CURL => Some("RING_CURL"), + Self::LITTLE_CURL => Some("LITTLE_CURL"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrLipExpressionHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLipExpressionHTC)"] +#[doc = "See [XrPlaneDetectionStateEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectionStateEXT)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct LipExpressionHTC(i32); -impl LipExpressionHTC { - pub const JAW_RIGHT: LipExpressionHTC = Self(0i32); - pub const JAW_LEFT: LipExpressionHTC = Self(1i32); - pub const JAW_FORWARD: LipExpressionHTC = Self(2i32); - pub const JAW_OPEN: LipExpressionHTC = Self(3i32); - pub const MOUTH_APE_SHAPE: LipExpressionHTC = Self(4i32); - pub const MOUTH_UPPER_RIGHT: LipExpressionHTC = Self(5i32); - pub const MOUTH_UPPER_LEFT: LipExpressionHTC = Self(6i32); - pub const MOUTH_LOWER_RIGHT: LipExpressionHTC = Self(7i32); - pub const MOUTH_LOWER_LEFT: LipExpressionHTC = Self(8i32); - pub const MOUTH_UPPER_OVERTURN: LipExpressionHTC = Self(9i32); - pub const MOUTH_LOWER_OVERTURN: LipExpressionHTC = Self(10i32); - pub const MOUTH_POUT: LipExpressionHTC = Self(11i32); - pub const MOUTH_SMILE_RIGHT: LipExpressionHTC = Self(12i32); - pub const MOUTH_SMILE_LEFT: LipExpressionHTC = Self(13i32); - pub const MOUTH_SAD_RIGHT: LipExpressionHTC = Self(14i32); - pub const MOUTH_SAD_LEFT: LipExpressionHTC = Self(15i32); - pub const CHEEK_PUFF_RIGHT: LipExpressionHTC = Self(16i32); - pub const CHEEK_PUFF_LEFT: LipExpressionHTC = Self(17i32); - pub const CHEEK_SUCK: LipExpressionHTC = Self(18i32); - pub const MOUTH_UPPER_UPRIGHT: LipExpressionHTC = Self(19i32); - pub const MOUTH_UPPER_UPLEFT: LipExpressionHTC = Self(20i32); - pub const MOUTH_LOWER_DOWNRIGHT: LipExpressionHTC = Self(21i32); - pub const MOUTH_LOWER_DOWNLEFT: LipExpressionHTC = Self(22i32); - pub const MOUTH_UPPER_INSIDE: LipExpressionHTC = Self(23i32); - pub const MOUTH_LOWER_INSIDE: LipExpressionHTC = Self(24i32); - pub const MOUTH_LOWER_OVERLAY: LipExpressionHTC = Self(25i32); - pub const TONGUE_LONGSTEP1: LipExpressionHTC = Self(26i32); - pub const TONGUE_LEFT: LipExpressionHTC = Self(27i32); - pub const TONGUE_RIGHT: LipExpressionHTC = Self(28i32); - pub const TONGUE_UP: LipExpressionHTC = Self(29i32); - pub const TONGUE_DOWN: LipExpressionHTC = Self(30i32); - pub const TONGUE_ROLL: LipExpressionHTC = Self(31i32); - pub const TONGUE_LONGSTEP2: LipExpressionHTC = Self(32i32); - pub const TONGUE_UPRIGHT_MORPH: LipExpressionHTC = Self(33i32); - pub const TONGUE_UPLEFT_MORPH: LipExpressionHTC = Self(34i32); - pub const TONGUE_DOWNRIGHT_MORPH: LipExpressionHTC = Self(35i32); - pub const TONGUE_DOWNLEFT_MORPH: LipExpressionHTC = Self(36i32); +pub struct PlaneDetectionStateEXT(i32); +impl PlaneDetectionStateEXT { + pub const NONE: PlaneDetectionStateEXT = Self(0i32); + pub const PENDING: PlaneDetectionStateEXT = Self(1i32); + pub const DONE: PlaneDetectionStateEXT = Self(2i32); + pub const ERROR: PlaneDetectionStateEXT = Self(3i32); + pub const FATAL: PlaneDetectionStateEXT = Self(4i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2364,83 +2886,32 @@ impl LipExpressionHTC { self.0 } } -impl fmt::Debug for LipExpressionHTC { +impl fmt::Debug for PlaneDetectionStateEXT { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::JAW_RIGHT => Some("JAW_RIGHT"), - Self::JAW_LEFT => Some("JAW_LEFT"), - Self::JAW_FORWARD => Some("JAW_FORWARD"), - Self::JAW_OPEN => Some("JAW_OPEN"), - Self::MOUTH_APE_SHAPE => Some("MOUTH_APE_SHAPE"), - Self::MOUTH_UPPER_RIGHT => Some("MOUTH_UPPER_RIGHT"), - Self::MOUTH_UPPER_LEFT => Some("MOUTH_UPPER_LEFT"), - Self::MOUTH_LOWER_RIGHT => Some("MOUTH_LOWER_RIGHT"), - Self::MOUTH_LOWER_LEFT => Some("MOUTH_LOWER_LEFT"), - Self::MOUTH_UPPER_OVERTURN => Some("MOUTH_UPPER_OVERTURN"), - Self::MOUTH_LOWER_OVERTURN => Some("MOUTH_LOWER_OVERTURN"), - Self::MOUTH_POUT => Some("MOUTH_POUT"), - Self::MOUTH_SMILE_RIGHT => Some("MOUTH_SMILE_RIGHT"), - Self::MOUTH_SMILE_LEFT => Some("MOUTH_SMILE_LEFT"), - Self::MOUTH_SAD_RIGHT => Some("MOUTH_SAD_RIGHT"), - Self::MOUTH_SAD_LEFT => Some("MOUTH_SAD_LEFT"), - Self::CHEEK_PUFF_RIGHT => Some("CHEEK_PUFF_RIGHT"), - Self::CHEEK_PUFF_LEFT => Some("CHEEK_PUFF_LEFT"), - Self::CHEEK_SUCK => Some("CHEEK_SUCK"), - Self::MOUTH_UPPER_UPRIGHT => Some("MOUTH_UPPER_UPRIGHT"), - Self::MOUTH_UPPER_UPLEFT => Some("MOUTH_UPPER_UPLEFT"), - Self::MOUTH_LOWER_DOWNRIGHT => Some("MOUTH_LOWER_DOWNRIGHT"), - Self::MOUTH_LOWER_DOWNLEFT => Some("MOUTH_LOWER_DOWNLEFT"), - Self::MOUTH_UPPER_INSIDE => Some("MOUTH_UPPER_INSIDE"), - Self::MOUTH_LOWER_INSIDE => Some("MOUTH_LOWER_INSIDE"), - Self::MOUTH_LOWER_OVERLAY => Some("MOUTH_LOWER_OVERLAY"), - Self::TONGUE_LONGSTEP1 => Some("TONGUE_LONGSTEP1"), - Self::TONGUE_LEFT => Some("TONGUE_LEFT"), - Self::TONGUE_RIGHT => Some("TONGUE_RIGHT"), - Self::TONGUE_UP => Some("TONGUE_UP"), - Self::TONGUE_DOWN => Some("TONGUE_DOWN"), - Self::TONGUE_ROLL => Some("TONGUE_ROLL"), - Self::TONGUE_LONGSTEP2 => Some("TONGUE_LONGSTEP2"), - Self::TONGUE_UPRIGHT_MORPH => Some("TONGUE_UPRIGHT_MORPH"), - Self::TONGUE_UPLEFT_MORPH => Some("TONGUE_UPLEFT_MORPH"), - Self::TONGUE_DOWNRIGHT_MORPH => Some("TONGUE_DOWNRIGHT_MORPH"), - Self::TONGUE_DOWNLEFT_MORPH => Some("TONGUE_DOWNLEFT_MORPH"), + Self::NONE => Some("NONE"), + Self::PENDING => Some("PENDING"), + Self::DONE => Some("DONE"), + Self::ERROR => Some("ERROR"), + Self::FATAL => Some("FATAL"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrHandForearmJointULTRALEAP](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandForearmJointULTRALEAP)"] +#[doc = "See [XrPlaneDetectorOrientationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorOrientationEXT)"] #[repr(transparent)] #[derive(Copy, Clone, Eq, PartialEq)] -pub struct HandForearmJointULTRALEAP(i32); -impl HandForearmJointULTRALEAP { - pub const PALM: HandForearmJointULTRALEAP = Self(0i32); - pub const WRIST: HandForearmJointULTRALEAP = Self(1i32); - pub const THUMB_METACARPAL: HandForearmJointULTRALEAP = Self(2i32); - pub const THUMB_PROXIMAL: HandForearmJointULTRALEAP = Self(3i32); - pub const THUMB_DISTAL: HandForearmJointULTRALEAP = Self(4i32); - pub const THUMB_TIP: HandForearmJointULTRALEAP = Self(5i32); - pub const INDEX_METACARPAL: HandForearmJointULTRALEAP = Self(6i32); - pub const INDEX_PROXIMAL: HandForearmJointULTRALEAP = Self(7i32); - pub const INDEX_INTERMEDIATE: HandForearmJointULTRALEAP = Self(8i32); - pub const INDEX_DISTAL: HandForearmJointULTRALEAP = Self(9i32); - pub const INDEX_TIP: HandForearmJointULTRALEAP = Self(10i32); - pub const MIDDLE_METACARPAL: HandForearmJointULTRALEAP = Self(11i32); - pub const MIDDLE_PROXIMAL: HandForearmJointULTRALEAP = Self(12i32); - pub const MIDDLE_INTERMEDIATE: HandForearmJointULTRALEAP = Self(13i32); - pub const MIDDLE_DISTAL: HandForearmJointULTRALEAP = Self(14i32); - pub const MIDDLE_TIP: HandForearmJointULTRALEAP = Self(15i32); - pub const RING_METACARPAL: HandForearmJointULTRALEAP = Self(16i32); - pub const RING_PROXIMAL: HandForearmJointULTRALEAP = Self(17i32); - pub const RING_INTERMEDIATE: HandForearmJointULTRALEAP = Self(18i32); - pub const RING_DISTAL: HandForearmJointULTRALEAP = Self(19i32); - pub const RING_TIP: HandForearmJointULTRALEAP = Self(20i32); - pub const LITTLE_METACARPAL: HandForearmJointULTRALEAP = Self(21i32); - pub const LITTLE_PROXIMAL: HandForearmJointULTRALEAP = Self(22i32); - pub const LITTLE_INTERMEDIATE: HandForearmJointULTRALEAP = Self(23i32); - pub const LITTLE_DISTAL: HandForearmJointULTRALEAP = Self(24i32); - pub const LITTLE_TIP: HandForearmJointULTRALEAP = Self(25i32); - pub const ELBOW: HandForearmJointULTRALEAP = Self(26i32); +pub struct PlaneDetectorOrientationEXT(i32); +impl PlaneDetectorOrientationEXT { + #[doc = "The detected plane is horizontal and faces upward (e.g. floor)."] + pub const HORIZONTAL_UPWARD: PlaneDetectorOrientationEXT = Self(0i32); + #[doc = "The detected plane is horizontal and faces downward (e.g. ceiling)."] + pub const HORIZONTAL_DOWNWARD: PlaneDetectorOrientationEXT = Self(1i32); + #[doc = "The detected plane is vertical (e.g. wall)."] + pub const VERTICAL: PlaneDetectorOrientationEXT = Self(2i32); + #[doc = "The detected plane has an arbitrary, non-vertical and non-horizontal orientation."] + pub const ARBITRARY: PlaneDetectorOrientationEXT = Self(3i32); pub fn from_raw(x: i32) -> Self { Self(x) } @@ -2448,7 +2919,189 @@ impl HandForearmJointULTRALEAP { self.0 } } -impl fmt::Debug for HandForearmJointULTRALEAP { +impl fmt::Debug for PlaneDetectorOrientationEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::HORIZONTAL_UPWARD => Some("HORIZONTAL_UPWARD"), + Self::HORIZONTAL_DOWNWARD => Some("HORIZONTAL_DOWNWARD"), + Self::VERTICAL => Some("VERTICAL"), + Self::ARBITRARY => Some("ARBITRARY"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrPlaneDetectorSemanticTypeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorSemanticTypeEXT)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct PlaneDetectorSemanticTypeEXT(i32); +impl PlaneDetectorSemanticTypeEXT { + #[doc = "The runtime was unable to classify this plane."] + pub const UNDEFINED: PlaneDetectorSemanticTypeEXT = Self(0i32); + #[doc = "The detected plane is a ceiling."] + pub const CEILING: PlaneDetectorSemanticTypeEXT = Self(1i32); + #[doc = "The detected plane is a floor."] + pub const FLOOR: PlaneDetectorSemanticTypeEXT = Self(2i32); + #[doc = "The detected plane is a wall."] + pub const WALL: PlaneDetectorSemanticTypeEXT = Self(3i32); + #[doc = "The detected plane is a platform, like a table."] + pub const PLATFORM: PlaneDetectorSemanticTypeEXT = Self(4i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for PlaneDetectorSemanticTypeEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::CEILING => Some("CEILING"), + Self::FLOOR => Some("FLOOR"), + Self::WALL => Some("WALL"), + Self::PLATFORM => Some("PLATFORM"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrVirtualKeyboardLocationTypeMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardLocationTypeMETA)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct VirtualKeyboardLocationTypeMETA(i32); +impl VirtualKeyboardLocationTypeMETA { + #[doc = "Indicates that the application will provide the position and scale of the keyboard."] + pub const CUSTOM: VirtualKeyboardLocationTypeMETA = Self(0i32); + #[doc = "Indicates that the runtime will set the position and scale for far field keyboard."] + pub const FAR: VirtualKeyboardLocationTypeMETA = Self(1i32); + #[doc = "Indicates that the runtime will set the position and scale for direct interaction keyboard."] + pub const DIRECT: VirtualKeyboardLocationTypeMETA = Self(2i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for VirtualKeyboardLocationTypeMETA { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CUSTOM => Some("CUSTOM"), + Self::FAR => Some("FAR"), + Self::DIRECT => Some("DIRECT"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrVirtualKeyboardInputSourceMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardInputSourceMETA)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct VirtualKeyboardInputSourceMETA(i32); +impl VirtualKeyboardInputSourceMETA { + #[doc = "Left controller ray."] + pub const CONTROLLER_RAY_LEFT: VirtualKeyboardInputSourceMETA = Self(1i32); + #[doc = "Right controller ray."] + pub const CONTROLLER_RAY_RIGHT: VirtualKeyboardInputSourceMETA = Self(2i32); + #[doc = "Left hand ray."] + pub const HAND_RAY_LEFT: VirtualKeyboardInputSourceMETA = Self(3i32); + #[doc = "Right hand ray."] + pub const HAND_RAY_RIGHT: VirtualKeyboardInputSourceMETA = Self(4i32); + #[doc = "Left controller direct touch."] + pub const CONTROLLER_DIRECT_LEFT: VirtualKeyboardInputSourceMETA = Self(5i32); + #[doc = "Right controller direct touch."] + pub const CONTROLLER_DIRECT_RIGHT: VirtualKeyboardInputSourceMETA = Self(6i32); + #[doc = "Left hand direct touch."] + pub const HAND_DIRECT_INDEX_TIP_LEFT: VirtualKeyboardInputSourceMETA = Self(7i32); + #[doc = "Right hand direct touch."] + pub const HAND_DIRECT_INDEX_TIP_RIGHT: VirtualKeyboardInputSourceMETA = Self(8i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for VirtualKeyboardInputSourceMETA { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CONTROLLER_RAY_LEFT => Some("CONTROLLER_RAY_LEFT"), + Self::CONTROLLER_RAY_RIGHT => Some("CONTROLLER_RAY_RIGHT"), + Self::HAND_RAY_LEFT => Some("HAND_RAY_LEFT"), + Self::HAND_RAY_RIGHT => Some("HAND_RAY_RIGHT"), + Self::CONTROLLER_DIRECT_LEFT => Some("CONTROLLER_DIRECT_LEFT"), + Self::CONTROLLER_DIRECT_RIGHT => Some("CONTROLLER_DIRECT_RIGHT"), + Self::HAND_DIRECT_INDEX_TIP_LEFT => Some("HAND_DIRECT_INDEX_TIP_LEFT"), + Self::HAND_DIRECT_INDEX_TIP_RIGHT => Some("HAND_DIRECT_INDEX_TIP_RIGHT"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrHandEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandEXT)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandEXT(i32); +impl HandEXT { + pub const LEFT: HandEXT = Self(1i32); + pub const RIGHT: HandEXT = Self(2i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for HandEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LEFT => Some("LEFT"), + Self::RIGHT => Some("RIGHT"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrHandJointEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointEXT)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandJointEXT(i32); +impl HandJointEXT { + pub const PALM: HandJointEXT = Self(0i32); + pub const WRIST: HandJointEXT = Self(1i32); + pub const THUMB_METACARPAL: HandJointEXT = Self(2i32); + pub const THUMB_PROXIMAL: HandJointEXT = Self(3i32); + pub const THUMB_DISTAL: HandJointEXT = Self(4i32); + pub const THUMB_TIP: HandJointEXT = Self(5i32); + pub const INDEX_METACARPAL: HandJointEXT = Self(6i32); + pub const INDEX_PROXIMAL: HandJointEXT = Self(7i32); + pub const INDEX_INTERMEDIATE: HandJointEXT = Self(8i32); + pub const INDEX_DISTAL: HandJointEXT = Self(9i32); + pub const INDEX_TIP: HandJointEXT = Self(10i32); + pub const MIDDLE_METACARPAL: HandJointEXT = Self(11i32); + pub const MIDDLE_PROXIMAL: HandJointEXT = Self(12i32); + pub const MIDDLE_INTERMEDIATE: HandJointEXT = Self(13i32); + pub const MIDDLE_DISTAL: HandJointEXT = Self(14i32); + pub const MIDDLE_TIP: HandJointEXT = Self(15i32); + pub const RING_METACARPAL: HandJointEXT = Self(16i32); + pub const RING_PROXIMAL: HandJointEXT = Self(17i32); + pub const RING_INTERMEDIATE: HandJointEXT = Self(18i32); + pub const RING_DISTAL: HandJointEXT = Self(19i32); + pub const RING_TIP: HandJointEXT = Self(20i32); + pub const LITTLE_METACARPAL: HandJointEXT = Self(21i32); + pub const LITTLE_PROXIMAL: HandJointEXT = Self(22i32); + pub const LITTLE_INTERMEDIATE: HandJointEXT = Self(23i32); + pub const LITTLE_DISTAL: HandJointEXT = Self(24i32); + pub const LITTLE_TIP: HandJointEXT = Self(25i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for HandJointEXT { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::PALM => Some("PALM"), @@ -2477,599 +3130,2247 @@ impl fmt::Debug for HandForearmJointULTRALEAP { Self::LITTLE_INTERMEDIATE => Some("LITTLE_INTERMEDIATE"), Self::LITTLE_DISTAL => Some("LITTLE_DISTAL"), Self::LITTLE_TIP => Some("LITTLE_TIP"), - Self::ELBOW => Some("ELBOW"), _ => None, }; fmt_enum(fmt, self.0, name) } } -#[doc = "See [XrInstanceCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct InstanceCreateFlags(u64); -impl InstanceCreateFlags {} -bitmask!(InstanceCreateFlags); -#[doc = "See [XrSessionCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SessionCreateFlags(u64); -impl SessionCreateFlags {} -bitmask!(SessionCreateFlags); -#[doc = "See [XrSwapchainCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateFlagBits)"] +#[doc = "See [XrHandJointSetEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointSetEXT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SwapchainCreateFlags(u64); -impl SwapchainCreateFlags { - #[doc = "Content will be protected from CPU access"] - pub const PROTECTED_CONTENT: SwapchainCreateFlags = Self(1 << 0u64); - #[doc = "Only one image will be acquired from this swapchain over its lifetime"] - pub const STATIC_IMAGE: SwapchainCreateFlags = Self(1 << 1u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandJointSetEXT(i32); +impl HandJointSetEXT { + pub const DEFAULT: HandJointSetEXT = Self(0i32); + pub const HAND_WITH_FOREARM_ULTRA: HandJointSetEXT = Self(1000149000i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(SwapchainCreateFlags); -#[doc = "See [XrSwapchainUsageFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainUsageFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SwapchainUsageFlags(u64); -impl SwapchainUsageFlags { - #[doc = "Specifies that the image may: be a color rendering target."] - pub const COLOR_ATTACHMENT: SwapchainUsageFlags = Self(1 << 0u64); - #[doc = "Specifies that the image may: be a depth/stencil rendering target."] - pub const DEPTH_STENCIL_ATTACHMENT: SwapchainUsageFlags = Self(1 << 1u64); - #[doc = "Specifies that the image may: be accessed out of order and that access may: be via atomic operations."] - pub const UNORDERED_ACCESS: SwapchainUsageFlags = Self(1 << 2u64); - #[doc = "Specifies that the image may: be used as the source of a transfer operation."] - pub const TRANSFER_SRC: SwapchainUsageFlags = Self(1 << 3u64); - #[doc = "Specifies that the image may: be used as the destination of a transfer operation."] - pub const TRANSFER_DST: SwapchainUsageFlags = Self(1 << 4u64); - #[doc = "Specifies that the image may: be sampled by a shader."] - pub const SAMPLED: SwapchainUsageFlags = Self(1 << 5u64); - #[doc = "Specifies that the image may: be reinterpreted as another image format."] - pub const MUTABLE_FORMAT: SwapchainUsageFlags = Self(1 << 6u64); - #[doc = "Specifies that the image may: be used as a input attachment."] - pub const INPUT_ATTACHMENT: SwapchainUsageFlags = Self(1 << 7u64); -} -bitmask!(SwapchainUsageFlags); -#[doc = "See [XrViewStateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewStateFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct ViewStateFlags(u64); -impl ViewStateFlags { - #[doc = "Indicates validity of all XrView orientations"] - pub const ORIENTATION_VALID: ViewStateFlags = Self(1 << 0u64); - #[doc = "Indicates validity of all XrView positions"] - pub const POSITION_VALID: ViewStateFlags = Self(1 << 1u64); - #[doc = "Indicates whether all XrView orientations are actively tracked"] - pub const ORIENTATION_TRACKED: ViewStateFlags = Self(1 << 2u64); - #[doc = "Indicates whether all XrView positions are actively tracked"] - pub const POSITION_TRACKED: ViewStateFlags = Self(1 << 3u64); +impl fmt::Debug for HandJointSetEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::HAND_WITH_FOREARM_ULTRA => Some("HAND_WITH_FOREARM_ULTRA"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(ViewStateFlags); -#[doc = "See [XrCompositionLayerFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerFlagBits)"] +#[doc = "See [XrHandJointsMotionRangeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsMotionRangeEXT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct CompositionLayerFlags(u64); -impl CompositionLayerFlags { - #[doc = "Enables chromatic aberration correction when not done by default."] - pub const CORRECT_CHROMATIC_ABERRATION: CompositionLayerFlags = Self(1 << 0u64); - #[doc = "Enables the layer texture alpha channel."] - pub const BLEND_TEXTURE_SOURCE_ALPHA: CompositionLayerFlags = Self(1 << 1u64); - #[doc = "Indicates the texture color channels have not been premultiplied by the texture alpha channel."] - pub const UNPREMULTIPLIED_ALPHA: CompositionLayerFlags = Self(1 << 2u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandJointsMotionRangeEXT(i32); +impl HandJointsMotionRangeEXT { + pub const UNOBSTRUCTED: HandJointsMotionRangeEXT = Self(1i32); + pub const CONFORMING_TO_CONTROLLER: HandJointsMotionRangeEXT = Self(2i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(CompositionLayerFlags); -#[doc = "See [XrSpaceLocationFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceLocationFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SpaceLocationFlags(u64); -impl SpaceLocationFlags { - #[doc = "Indicates that the orientation member contains valid data"] - pub const ORIENTATION_VALID: SpaceLocationFlags = Self(1 << 0u64); - #[doc = "Indicates that the position member contains valid data"] - pub const POSITION_VALID: SpaceLocationFlags = Self(1 << 1u64); - #[doc = "Indicates whether pose member contains an actively tracked orientation"] - pub const ORIENTATION_TRACKED: SpaceLocationFlags = Self(1 << 2u64); - #[doc = "Indicates whether pose member contains an actively tracked position"] - pub const POSITION_TRACKED: SpaceLocationFlags = Self(1 << 3u64); +impl fmt::Debug for HandJointsMotionRangeEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNOBSTRUCTED => Some("UNOBSTRUCTED"), + Self::CONFORMING_TO_CONTROLLER => Some("CONFORMING_TO_CONTROLLER"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(SpaceLocationFlags); -#[doc = "See [XrSpaceVelocityFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceVelocityFlagBits)"] +#[doc = "See [XrHandTrackingDataSourceEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingDataSourceEXT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SpaceVelocityFlags(u64); -impl SpaceVelocityFlags { - #[doc = "Indicates that the linearVelocity member contains valid data. Applications must: not read the linearVelocity field if this flag is unset."] - pub const LINEAR_VALID: SpaceVelocityFlags = Self(1 << 0u64); - #[doc = "Indicates that the angularVelocity member contains valid data. Applications must: not read the angularVelocity field if this flag is unset."] - pub const ANGULAR_VALID: SpaceVelocityFlags = Self(1 << 1u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandTrackingDataSourceEXT(i32); +impl HandTrackingDataSourceEXT { + #[doc = "This data source value indicates individual fingers and joints are tracked from unobstructed data source such as optical hand tracking, data gloves, or motion capture devices."] + pub const UNOBSTRUCTED: HandTrackingDataSourceEXT = Self(1i32); + #[doc = "This data source value indicates hand joints are inferred based on motion controller state."] + pub const CONTROLLER: HandTrackingDataSourceEXT = Self(2i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(SpaceVelocityFlags); -#[doc = "See [XrInputSourceLocalizedNameFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInputSourceLocalizedNameFlagBits)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct InputSourceLocalizedNameFlags(u64); -impl InputSourceLocalizedNameFlags { - #[doc = "Asks for the part of the string which indicates the top level user path the source represents"] - pub const USER_PATH: InputSourceLocalizedNameFlags = Self(1 << 0u64); - #[doc = "Asks for the part of the string which represents the interaction profile of the source"] - pub const INTERACTION_PROFILE: InputSourceLocalizedNameFlags = Self(1 << 1u64); - #[doc = "Asks for the part of the string which represents the component on the device which needs to be interacted with"] - pub const COMPONENT: InputSourceLocalizedNameFlags = Self(1 << 2u64); +impl fmt::Debug for HandTrackingDataSourceEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNOBSTRUCTED => Some("UNOBSTRUCTED"), + Self::CONTROLLER => Some("CONTROLLER"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(InputSourceLocalizedNameFlags); -#[doc = "See [XrVulkanInstanceCreateFlagsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanInstanceCreateFlagsKHR)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct VulkanInstanceCreateFlagsKHR(u64); -impl VulkanInstanceCreateFlagsKHR {} -bitmask!(VulkanInstanceCreateFlagsKHR); -#[doc = "See [XrVulkanDeviceCreateFlagsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanDeviceCreateFlagsKHR)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct VulkanDeviceCreateFlagsKHR(u64); -impl VulkanDeviceCreateFlagsKHR {} -bitmask!(VulkanDeviceCreateFlagsKHR); -#[doc = "See [XrDebugUtilsMessageSeverityFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessageSeverityFlagsEXT)"] +#[doc = "See [XrHandPoseTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandPoseTypeMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct DebugUtilsMessageSeverityFlagsEXT(u64); -impl DebugUtilsMessageSeverityFlagsEXT { - #[doc = "Most verbose output severity, typically used for debugging."] - pub const VERBOSE: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 0u64); - #[doc = "General info message"] - pub const INFO: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 4u64); - #[doc = "Indicates the item may be the cause of issues."] - pub const WARNING: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 8u64); - #[doc = "Indicates that the item is definitely related to erroneous behavior."] - pub const ERROR: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 12u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandPoseTypeMSFT(i32); +impl HandPoseTypeMSFT { + pub const TRACKED: HandPoseTypeMSFT = Self(0i32); + pub const REFERENCE_OPEN_PALM: HandPoseTypeMSFT = Self(1i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(DebugUtilsMessageSeverityFlagsEXT); -#[doc = "See [XrDebugUtilsMessageTypeFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessageTypeFlagsEXT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct DebugUtilsMessageTypeFlagsEXT(u64); -impl DebugUtilsMessageTypeFlagsEXT { - #[doc = "Indicates this is a general message"] - pub const GENERAL: DebugUtilsMessageTypeFlagsEXT = Self(1 << 0u64); - #[doc = "Indicates the message is related to a validation message"] - pub const VALIDATION: DebugUtilsMessageTypeFlagsEXT = Self(1 << 1u64); - #[doc = "Indicates the message is related to a potential performance situation"] - pub const PERFORMANCE: DebugUtilsMessageTypeFlagsEXT = Self(1 << 2u64); - #[doc = "Indicates the message is related to a non-conformant runtime result"] - pub const CONFORMANCE: DebugUtilsMessageTypeFlagsEXT = Self(1 << 3u64); +impl fmt::Debug for HandPoseTypeMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRACKED => Some("TRACKED"), + Self::REFERENCE_OPEN_PALM => Some("REFERENCE_OPEN_PALM"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(DebugUtilsMessageTypeFlagsEXT); -#[doc = "See [XrOverlayMainSessionFlagsEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOverlayMainSessionFlagsEXTX)"] +#[doc = "See [XrSceneObjectTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneObjectTypeMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct OverlayMainSessionFlagsEXTX(u64); -impl OverlayMainSessionFlagsEXTX { - #[doc = "Indicates the main session enabled `XR_KHR_composition_layer_depth`"] - pub const ENABLED_COMPOSITION_LAYER_INFO_DEPTH: OverlayMainSessionFlagsEXTX = Self(1 << 0u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct SceneObjectTypeMSFT(i32); +impl SceneObjectTypeMSFT { + pub const UNCATEGORIZED: SceneObjectTypeMSFT = Self(-1i32); + pub const BACKGROUND: SceneObjectTypeMSFT = Self(1i32); + pub const WALL: SceneObjectTypeMSFT = Self(2i32); + pub const FLOOR: SceneObjectTypeMSFT = Self(3i32); + pub const CEILING: SceneObjectTypeMSFT = Self(4i32); + pub const PLATFORM: SceneObjectTypeMSFT = Self(5i32); + pub const INFERRED: SceneObjectTypeMSFT = Self(6i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(OverlayMainSessionFlagsEXTX); -#[doc = "See [XrOverlaySessionCreateFlagsEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOverlaySessionCreateFlagsEXTX)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct OverlaySessionCreateFlagsEXTX(u64); -impl OverlaySessionCreateFlagsEXTX {} -bitmask!(OverlaySessionCreateFlagsEXTX); -#[doc = "See [XrAndroidSurfaceSwapchainFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAndroidSurfaceSwapchainFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct AndroidSurfaceSwapchainFlagsFB(u64); -impl AndroidSurfaceSwapchainFlagsFB { - #[doc = "Create the underlying BufferQueue in synchronous mode"] - pub const SYNCHRONOUS: AndroidSurfaceSwapchainFlagsFB = Self(1 << 0u64); - #[doc = "Acquire most recent buffer whose presentation timestamp is not greater than display time of final composited frame"] - pub const USE_TIMESTAMPS: AndroidSurfaceSwapchainFlagsFB = Self(1 << 1u64); +impl fmt::Debug for SceneObjectTypeMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCATEGORIZED => Some("UNCATEGORIZED"), + Self::BACKGROUND => Some("BACKGROUND"), + Self::WALL => Some("WALL"), + Self::FLOOR => Some("FLOOR"), + Self::CEILING => Some("CEILING"), + Self::PLATFORM => Some("PLATFORM"), + Self::INFERRED => Some("INFERRED"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(AndroidSurfaceSwapchainFlagsFB); -#[doc = "See [XrCompositionLayerImageLayoutFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerImageLayoutFlagsFB)"] +#[doc = "See [XrScenePlaneAlignmentTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrScenePlaneAlignmentTypeMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct CompositionLayerImageLayoutFlagsFB(u64); -impl CompositionLayerImageLayoutFlagsFB { - #[doc = "The coordinate origin of the swapchain image must be considered to be flipped vertically."] - pub const VERTICAL_FLIP: CompositionLayerImageLayoutFlagsFB = Self(1 << 0u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct ScenePlaneAlignmentTypeMSFT(i32); +impl ScenePlaneAlignmentTypeMSFT { + pub const NON_ORTHOGONAL: ScenePlaneAlignmentTypeMSFT = Self(0i32); + pub const HORIZONTAL: ScenePlaneAlignmentTypeMSFT = Self(1i32); + pub const VERTICAL: ScenePlaneAlignmentTypeMSFT = Self(2i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(CompositionLayerImageLayoutFlagsFB); -#[doc = "See [XrCompositionLayerSecureContentFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSecureContentFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct CompositionLayerSecureContentFlagsFB(u64); -impl CompositionLayerSecureContentFlagsFB { - #[doc = "Indicates the layer will only be visible inside the HMD, and not visible to external sources"] - pub const EXCLUDE_LAYER: CompositionLayerSecureContentFlagsFB = Self(1 << 0u64); - #[doc = "Indicates the layer will be displayed inside the HMD, but replaced by proxy content when written to external sources"] - pub const REPLACE_LAYER: CompositionLayerSecureContentFlagsFB = Self(1 << 1u64); +impl fmt::Debug for ScenePlaneAlignmentTypeMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NON_ORTHOGONAL => Some("NON_ORTHOGONAL"), + Self::HORIZONTAL => Some("HORIZONTAL"), + Self::VERTICAL => Some("VERTICAL"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(CompositionLayerSecureContentFlagsFB); -#[doc = "See [XrSwapchainCreateFoveationFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateFoveationFlagsFB)"] +#[doc = "See [XrSceneComputeStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeStateMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SwapchainCreateFoveationFlagsFB(u64); -impl SwapchainCreateFoveationFlagsFB { - #[doc = "Explicitly create the swapchain with scaled bin foveation support. The application must ensure that the swapchain is using the OpenGL graphics API and that the QCOM_texture_foveated extension is supported and enabled."] - pub const SCALED_BIN: SwapchainCreateFoveationFlagsFB = Self(1 << 0u64); - #[doc = "Explicitly create the swapchain with fragment density map foveation support. The application must ensure that the swapchain is using the Vulkan graphics API and that the VK_EXT_fragment_density_map extension is supported and enabled."] - pub const FRAGMENT_DENSITY_MAP: SwapchainCreateFoveationFlagsFB = Self(1 << 1u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct SceneComputeStateMSFT(i32); +impl SceneComputeStateMSFT { + pub const NONE: SceneComputeStateMSFT = Self(0i32); + pub const UPDATING: SceneComputeStateMSFT = Self(1i32); + pub const COMPLETED: SceneComputeStateMSFT = Self(2i32); + pub const COMPLETED_WITH_ERROR: SceneComputeStateMSFT = Self(3i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(SwapchainCreateFoveationFlagsFB); -#[doc = "See [XrSwapchainStateFoveationFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateFoveationFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SwapchainStateFoveationFlagsFB(u64); -impl SwapchainStateFoveationFlagsFB {} -bitmask!(SwapchainStateFoveationFlagsFB); -#[doc = "See [XrTriangleMeshFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct TriangleMeshFlagsFB(u64); -impl TriangleMeshFlagsFB { - #[doc = "The triangle mesh is mutable (can be modified after it is created)."] - pub const MUTABLE: TriangleMeshFlagsFB = Self(1 << 0u64); +impl fmt::Debug for SceneComputeStateMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::UPDATING => Some("UPDATING"), + Self::COMPLETED => Some("COMPLETED"), + Self::COMPLETED_WITH_ERROR => Some("COMPLETED_WITH_ERROR"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(TriangleMeshFlagsFB); -#[doc = "See [XrPassthroughFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughFlagsFB)"] +#[doc = "See [XrSceneComputeFeatureMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeFeatureMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct PassthroughFlagsFB(u64); -impl PassthroughFlagsFB { - #[doc = "The object (passthrough, layer) is running at creation."] - pub const IS_RUNNING_AT_CREATION: PassthroughFlagsFB = Self(1 << 0u64); - #[doc = "The passthrough system sends depth information to the compositor. Only applicable to layer objects."] - pub const LAYER_DEPTH: PassthroughFlagsFB = Self(1 << 1u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct SceneComputeFeatureMSFT(i32); +impl SceneComputeFeatureMSFT { + pub const PLANE: SceneComputeFeatureMSFT = Self(1i32); + pub const PLANE_MESH: SceneComputeFeatureMSFT = Self(2i32); + pub const VISUAL_MESH: SceneComputeFeatureMSFT = Self(3i32); + pub const COLLIDER_MESH: SceneComputeFeatureMSFT = Self(4i32); + pub const SERIALIZE_SCENE: SceneComputeFeatureMSFT = Self(1000098000i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(PassthroughFlagsFB); -#[doc = "See [XrPassthroughStateChangedFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughStateChangedFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct PassthroughStateChangedFlagsFB(u64); -impl PassthroughStateChangedFlagsFB { - #[doc = "Passthrough system requires reinitialization."] - pub const REINIT_REQUIRED: PassthroughStateChangedFlagsFB = Self(1 << 0u64); - #[doc = "Non-recoverable error has occurred. A device reboot or a firmware update may be required."] - pub const NON_RECOVERABLE_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 1u64); - #[doc = "A recoverable error has occurred. The runtime will attempt to recover, but some functionality may be temporarily unavailable."] - pub const RECOVERABLE_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 2u64); - #[doc = "The runtime has recovered from a previous error and is functioning normally."] - pub const RESTORED_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 3u64); +impl fmt::Debug for SceneComputeFeatureMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PLANE => Some("PLANE"), + Self::PLANE_MESH => Some("PLANE_MESH"), + Self::VISUAL_MESH => Some("VISUAL_MESH"), + Self::COLLIDER_MESH => Some("COLLIDER_MESH"), + Self::SERIALIZE_SCENE => Some("SERIALIZE_SCENE"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(PassthroughStateChangedFlagsFB); -#[doc = "See [XrPassthroughCapabilityFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughCapabilityFlagsFB)"] +#[doc = "See [XrSceneComputeConsistencyMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComputeConsistencyMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct PassthroughCapabilityFlagsFB(u64); -impl PassthroughCapabilityFlagsFB { - #[doc = "The system supports passthrough."] - pub const PASSTHROUGH_CAPABILITY: PassthroughCapabilityFlagsFB = Self(1 << 0u64); - #[doc = "The system can show passthrough with realistic colors. XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB is set."] - pub const COLOR: PassthroughCapabilityFlagsFB = Self(1 << 1u64); - #[doc = "The system supports passthrough layers composited using depth testing. XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB is set."] - pub const LAYER_DEPTH: PassthroughCapabilityFlagsFB = Self(1 << 2u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct SceneComputeConsistencyMSFT(i32); +impl SceneComputeConsistencyMSFT { + pub const SNAPSHOT_COMPLETE: SceneComputeConsistencyMSFT = Self(1i32); + pub const SNAPSHOT_INCOMPLETE_FAST: SceneComputeConsistencyMSFT = Self(2i32); + pub const OCCLUSION_OPTIMIZED: SceneComputeConsistencyMSFT = Self(3i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(PassthroughCapabilityFlagsFB); -#[doc = "See [XrHandTrackingAimFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingAimFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct HandTrackingAimFlagsFB(u64); -impl HandTrackingAimFlagsFB { - #[doc = "Aiming data is computed from additional sources beyond the hand data in the base structure"] - pub const COMPUTED: HandTrackingAimFlagsFB = Self(1 << 0u64); - #[doc = "Aiming data is valid"] - pub const VALID: HandTrackingAimFlagsFB = Self(1 << 1u64); - #[doc = "Index finger pinch discrete signal"] - pub const INDEX_PINCHING: HandTrackingAimFlagsFB = Self(1 << 2u64); - #[doc = "Middle finger pinch discrete signal"] - pub const MIDDLE_PINCHING: HandTrackingAimFlagsFB = Self(1 << 3u64); - #[doc = "Ring finger pinch discrete signal"] - pub const RING_PINCHING: HandTrackingAimFlagsFB = Self(1 << 4u64); - #[doc = "Little finger pinch discrete signal"] - pub const LITTLE_PINCHING: HandTrackingAimFlagsFB = Self(1 << 5u64); - #[doc = "System gesture is active"] - pub const SYSTEM_GESTURE: HandTrackingAimFlagsFB = Self(1 << 6u64); - #[doc = "Hand is currently marked as dominant for the system"] - pub const DOMINANT_HAND: HandTrackingAimFlagsFB = Self(1 << 7u64); - #[doc = "System menu gesture is active"] - pub const MENU_PRESSED: HandTrackingAimFlagsFB = Self(1 << 8u64); +impl fmt::Debug for SceneComputeConsistencyMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SNAPSHOT_COMPLETE => Some("SNAPSHOT_COMPLETE"), + Self::SNAPSHOT_INCOMPLETE_FAST => Some("SNAPSHOT_INCOMPLETE_FAST"), + Self::OCCLUSION_OPTIMIZED => Some("OCCLUSION_OPTIMIZED"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(HandTrackingAimFlagsFB); -#[doc = "See [XrKeyboardTrackingFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingFlagsFB)"] +#[doc = "See [XrSceneComponentTypeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneComponentTypeMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct KeyboardTrackingFlagsFB(u64); -impl KeyboardTrackingFlagsFB { - #[doc = "indicates that the system has a physically tracked keyboard to report. If not set then no other bits should be considered to be valid or meaningful. If set either XR_KEYBOARD_TRACKING_LOCAL_BIT_FB or XR_KEYBOARD_TRACKING_REMOTE_BIT_FB must also be set."] - pub const EXISTS: KeyboardTrackingFlagsFB = Self(1 << 0u64); - #[doc = "indicates that the physically tracked keyboard is intended to be used in a local pairing with the system. Mutally exclusive with XR_KEYBOARD_TRACKING_REMOTE_BIT_FB."] - pub const LOCAL: KeyboardTrackingFlagsFB = Self(1 << 1u64); - #[doc = "indicates that the physically tracked keyboard is intended to be used while paired to a separate remote computing device. Mutally exclusive with XR_KEYBOARD_TRACKING_LOCAL_BIT_FB."] - pub const REMOTE: KeyboardTrackingFlagsFB = Self(1 << 2u64); - #[doc = "indicates that the physically tracked keyboard is actively connected to the headset and capable of sending key data"] - pub const CONNECTED: KeyboardTrackingFlagsFB = Self(1 << 3u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct SceneComponentTypeMSFT(i32); +impl SceneComponentTypeMSFT { + pub const INVALID: SceneComponentTypeMSFT = Self(-1i32); + pub const OBJECT: SceneComponentTypeMSFT = Self(1i32); + pub const PLANE: SceneComponentTypeMSFT = Self(2i32); + pub const VISUAL_MESH: SceneComponentTypeMSFT = Self(3i32); + pub const COLLIDER_MESH: SceneComponentTypeMSFT = Self(4i32); + pub const SERIALIZED_SCENE_FRAGMENT: SceneComponentTypeMSFT = Self(1000098000i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(KeyboardTrackingFlagsFB); -#[doc = "See [XrKeyboardTrackingQueryFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingQueryFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct KeyboardTrackingQueryFlagsFB(u64); -impl KeyboardTrackingQueryFlagsFB { - #[doc = "indicates the query is for the physically tracked keyboard that is intended to be used in a local pairing with the System. Mutally exclusive with XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB."] - pub const LOCAL: KeyboardTrackingQueryFlagsFB = Self(1 << 1u64); - #[doc = "indicates the query is for the physically tracked keyboard that may be connected to a separate remote computing device. Mutally exclusive with XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB."] - pub const REMOTE: KeyboardTrackingQueryFlagsFB = Self(1 << 2u64); +impl fmt::Debug for SceneComponentTypeMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INVALID => Some("INVALID"), + Self::OBJECT => Some("OBJECT"), + Self::PLANE => Some("PLANE"), + Self::VISUAL_MESH => Some("VISUAL_MESH"), + Self::COLLIDER_MESH => Some("COLLIDER_MESH"), + Self::SERIALIZED_SCENE_FRAGMENT => Some("SERIALIZED_SCENE_FRAGMENT"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } } -bitmask!(KeyboardTrackingQueryFlagsFB); -#[doc = "See [XrCompositionLayerSpaceWarpInfoFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSpaceWarpInfoFlagsFB)"] +#[doc = "See [XrMeshComputeLodMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrMeshComputeLodMSFT)"] #[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct CompositionLayerSpaceWarpInfoFlagsFB(u64); -impl CompositionLayerSpaceWarpInfoFlagsFB { - #[doc = "Skip current frame's space warp extrapolation"] - pub const FRAME_SKIP: CompositionLayerSpaceWarpInfoFlagsFB = Self(1 << 0u64); +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct MeshComputeLodMSFT(i32); +impl MeshComputeLodMSFT { + pub const COARSE: MeshComputeLodMSFT = Self(1i32); + pub const MEDIUM: MeshComputeLodMSFT = Self(2i32); + pub const FINE: MeshComputeLodMSFT = Self(3i32); + pub const UNLIMITED: MeshComputeLodMSFT = Self(4i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } } -bitmask!(CompositionLayerSpaceWarpInfoFlagsFB); -#[doc = "See [XrRenderModelFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct RenderModelFlagsFB(u64); -impl RenderModelFlagsFB { - #[doc = "Minimal level of support. Can only contain a single mesh. Can only contain a single texture. Can not contain transparency. Assumes unlit rendering. Requires Extension KHR_texturebasisu."] - pub const SUPPORTS_GLTF_2_0_SUBSET_1: RenderModelFlagsFB = Self(1 << 0u64); - #[doc = "All of XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB support plus: Multiple meshes. Multiple Textures. Texture Transparency."] +impl fmt::Debug for MeshComputeLodMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COARSE => Some("COARSE"), + Self::MEDIUM => Some("MEDIUM"), + Self::FINE => Some("FINE"), + Self::UNLIMITED => Some("UNLIMITED"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrColorSpaceFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrColorSpaceFB)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct ColorSpaceFB(i32); +impl ColorSpaceFB { + pub const UNMANAGED: ColorSpaceFB = Self(0i32); + pub const REC2020: ColorSpaceFB = Self(1i32); + pub const REC709: ColorSpaceFB = Self(2i32); + pub const RIFT_CV1: ColorSpaceFB = Self(3i32); + pub const RIFT_S: ColorSpaceFB = Self(4i32); + pub const QUEST: ColorSpaceFB = Self(5i32); + pub const P3: ColorSpaceFB = Self(6i32); + pub const ADOBE_RGB: ColorSpaceFB = Self(7i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for ColorSpaceFB { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNMANAGED => Some("UNMANAGED"), + Self::REC2020 => Some("REC2020"), + Self::REC709 => Some("REC709"), + Self::RIFT_CV1 => Some("RIFT_CV1"), + Self::RIFT_S => Some("RIFT_S"), + Self::QUEST => Some("QUEST"), + Self::P3 => Some("P3"), + Self::ADOBE_RGB => Some("ADOBE_RGB"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrFoveationLevelFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationLevelFB)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct FoveationLevelFB(i32); +impl FoveationLevelFB { + #[doc = "No foveation"] + pub const NONE: FoveationLevelFB = Self(0i32); + #[doc = "Less foveation (higher periphery visual fidelity, lower performance)"] + pub const LOW: FoveationLevelFB = Self(1i32); + #[doc = "Medium foveation (medium periphery visual fidelity, medium performance)"] + pub const MEDIUM: FoveationLevelFB = Self(2i32); + #[doc = "High foveation (lower periphery visual fidelity, higher performance)"] + pub const HIGH: FoveationLevelFB = Self(3i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for FoveationLevelFB { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrFoveationDynamicFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationDynamicFB)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct FoveationDynamicFB(i32); +impl FoveationDynamicFB { + #[doc = "Static foveation at the maximum desired level"] + pub const DISABLED: FoveationDynamicFB = Self(0i32); + #[doc = "Dynamic changing foveation based on performance headroom available up to the maximum desired level"] + pub const LEVEL_ENABLED: FoveationDynamicFB = Self(1i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for FoveationDynamicFB { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::LEVEL_ENABLED => Some("LEVEL_ENABLED"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrReprojectionModeMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrReprojectionModeMSFT)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct ReprojectionModeMSFT(i32); +impl ReprojectionModeMSFT { + pub const DEPTH: ReprojectionModeMSFT = Self(1i32); + pub const PLANAR_FROM_DEPTH: ReprojectionModeMSFT = Self(2i32); + pub const PLANAR_MANUAL: ReprojectionModeMSFT = Self(3i32); + pub const ORIENTATION_ONLY: ReprojectionModeMSFT = Self(4i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for ReprojectionModeMSFT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEPTH => Some("DEPTH"), + Self::PLANAR_FROM_DEPTH => Some("PLANAR_FROM_DEPTH"), + Self::PLANAR_MANUAL => Some("PLANAR_MANUAL"), + Self::ORIENTATION_ONLY => Some("ORIENTATION_ONLY"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrHandForearmJointULTRALEAP](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandForearmJointULTRALEAP)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct HandForearmJointULTRALEAP(i32); +impl HandForearmJointULTRALEAP { + pub const PALM: HandForearmJointULTRALEAP = Self(0i32); + pub const WRIST: HandForearmJointULTRALEAP = Self(1i32); + pub const THUMB_METACARPAL: HandForearmJointULTRALEAP = Self(2i32); + pub const THUMB_PROXIMAL: HandForearmJointULTRALEAP = Self(3i32); + pub const THUMB_DISTAL: HandForearmJointULTRALEAP = Self(4i32); + pub const THUMB_TIP: HandForearmJointULTRALEAP = Self(5i32); + pub const INDEX_METACARPAL: HandForearmJointULTRALEAP = Self(6i32); + pub const INDEX_PROXIMAL: HandForearmJointULTRALEAP = Self(7i32); + pub const INDEX_INTERMEDIATE: HandForearmJointULTRALEAP = Self(8i32); + pub const INDEX_DISTAL: HandForearmJointULTRALEAP = Self(9i32); + pub const INDEX_TIP: HandForearmJointULTRALEAP = Self(10i32); + pub const MIDDLE_METACARPAL: HandForearmJointULTRALEAP = Self(11i32); + pub const MIDDLE_PROXIMAL: HandForearmJointULTRALEAP = Self(12i32); + pub const MIDDLE_INTERMEDIATE: HandForearmJointULTRALEAP = Self(13i32); + pub const MIDDLE_DISTAL: HandForearmJointULTRALEAP = Self(14i32); + pub const MIDDLE_TIP: HandForearmJointULTRALEAP = Self(15i32); + pub const RING_METACARPAL: HandForearmJointULTRALEAP = Self(16i32); + pub const RING_PROXIMAL: HandForearmJointULTRALEAP = Self(17i32); + pub const RING_INTERMEDIATE: HandForearmJointULTRALEAP = Self(18i32); + pub const RING_DISTAL: HandForearmJointULTRALEAP = Self(19i32); + pub const RING_TIP: HandForearmJointULTRALEAP = Self(20i32); + pub const LITTLE_METACARPAL: HandForearmJointULTRALEAP = Self(21i32); + pub const LITTLE_PROXIMAL: HandForearmJointULTRALEAP = Self(22i32); + pub const LITTLE_INTERMEDIATE: HandForearmJointULTRALEAP = Self(23i32); + pub const LITTLE_DISTAL: HandForearmJointULTRALEAP = Self(24i32); + pub const LITTLE_TIP: HandForearmJointULTRALEAP = Self(25i32); + pub const ELBOW: HandForearmJointULTRALEAP = Self(26i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for HandForearmJointULTRALEAP { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PALM => Some("PALM"), + Self::WRIST => Some("WRIST"), + Self::THUMB_METACARPAL => Some("THUMB_METACARPAL"), + Self::THUMB_PROXIMAL => Some("THUMB_PROXIMAL"), + Self::THUMB_DISTAL => Some("THUMB_DISTAL"), + Self::THUMB_TIP => Some("THUMB_TIP"), + Self::INDEX_METACARPAL => Some("INDEX_METACARPAL"), + Self::INDEX_PROXIMAL => Some("INDEX_PROXIMAL"), + Self::INDEX_INTERMEDIATE => Some("INDEX_INTERMEDIATE"), + Self::INDEX_DISTAL => Some("INDEX_DISTAL"), + Self::INDEX_TIP => Some("INDEX_TIP"), + Self::MIDDLE_METACARPAL => Some("MIDDLE_METACARPAL"), + Self::MIDDLE_PROXIMAL => Some("MIDDLE_PROXIMAL"), + Self::MIDDLE_INTERMEDIATE => Some("MIDDLE_INTERMEDIATE"), + Self::MIDDLE_DISTAL => Some("MIDDLE_DISTAL"), + Self::MIDDLE_TIP => Some("MIDDLE_TIP"), + Self::RING_METACARPAL => Some("RING_METACARPAL"), + Self::RING_PROXIMAL => Some("RING_PROXIMAL"), + Self::RING_INTERMEDIATE => Some("RING_INTERMEDIATE"), + Self::RING_DISTAL => Some("RING_DISTAL"), + Self::RING_TIP => Some("RING_TIP"), + Self::LITTLE_METACARPAL => Some("LITTLE_METACARPAL"), + Self::LITTLE_PROXIMAL => Some("LITTLE_PROXIMAL"), + Self::LITTLE_INTERMEDIATE => Some("LITTLE_INTERMEDIATE"), + Self::LITTLE_DISTAL => Some("LITTLE_DISTAL"), + Self::LITTLE_TIP => Some("LITTLE_TIP"), + Self::ELBOW => Some("ELBOW"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrCompareOpFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompareOpFB)"] +#[repr(transparent)] +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct CompareOpFB(i32); +impl CompareOpFB { + #[doc = "Comparison is never true."] + pub const NEVER: CompareOpFB = Self(0i32); + #[doc = "Comparison is true if source less than is destination."] + pub const LESS: CompareOpFB = Self(1i32); + #[doc = "Comparison is true if source is equal to destination."] + pub const EQUAL: CompareOpFB = Self(2i32); + #[doc = "Comparison is true if source is less than or equal to destination."] + pub const LESS_OR_EQUAL: CompareOpFB = Self(3i32); + #[doc = "Comparison is true if source is greater than destination."] + pub const GREATER: CompareOpFB = Self(4i32); + #[doc = "Comparison is true if source is not equal to destination."] + pub const NOT_EQUAL: CompareOpFB = Self(5i32); + #[doc = "Comparison is true if source is greater than or equal to destination."] + pub const GREATER_OR_EQUAL: CompareOpFB = Self(6i32); + #[doc = "Comparison is always true."] + pub const ALWAYS: CompareOpFB = Self(7i32); + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn into_raw(self) -> i32 { + self.0 + } +} +impl fmt::Debug for CompareOpFB { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + fmt_enum(fmt, self.0, name) + } +} +#[doc = "See [XrInstanceCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct InstanceCreateFlags(u64); +impl InstanceCreateFlags {} +bitmask!(InstanceCreateFlags); +#[doc = "See [XrSessionCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SessionCreateFlags(u64); +impl SessionCreateFlags {} +bitmask!(SessionCreateFlags); +#[doc = "See [XrSwapchainCreateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SwapchainCreateFlags(u64); +impl SwapchainCreateFlags { + #[doc = "Content will be protected from CPU access"] + pub const PROTECTED_CONTENT: SwapchainCreateFlags = Self(1 << 0u64); + #[doc = "Only one image will be acquired from this swapchain over its lifetime"] + pub const STATIC_IMAGE: SwapchainCreateFlags = Self(1 << 1u64); +} +bitmask!(SwapchainCreateFlags); +#[doc = "See [XrSwapchainUsageFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainUsageFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SwapchainUsageFlags(u64); +impl SwapchainUsageFlags { + #[doc = "Specifies that the image may: be a color rendering target."] + pub const COLOR_ATTACHMENT: SwapchainUsageFlags = Self(1 << 0u64); + #[doc = "Specifies that the image may: be a depth/stencil rendering target."] + pub const DEPTH_STENCIL_ATTACHMENT: SwapchainUsageFlags = Self(1 << 1u64); + #[doc = "Specifies that the image may: be accessed out of order and that access may: be via atomic operations."] + pub const UNORDERED_ACCESS: SwapchainUsageFlags = Self(1 << 2u64); + #[doc = "Specifies that the image may: be used as the source of a transfer operation."] + pub const TRANSFER_SRC: SwapchainUsageFlags = Self(1 << 3u64); + #[doc = "Specifies that the image may: be used as the destination of a transfer operation."] + pub const TRANSFER_DST: SwapchainUsageFlags = Self(1 << 4u64); + #[doc = "Specifies that the image may: be sampled by a shader."] + pub const SAMPLED: SwapchainUsageFlags = Self(1 << 5u64); + #[doc = "Specifies that the image may: be reinterpreted as another image format."] + pub const MUTABLE_FORMAT: SwapchainUsageFlags = Self(1 << 6u64); + #[doc = "Specifies that the image may: be used as a input attachment."] + pub const INPUT_ATTACHMENT: SwapchainUsageFlags = Self(1 << 7u64); +} +bitmask!(SwapchainUsageFlags); +#[doc = "See [XrViewStateFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewStateFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct ViewStateFlags(u64); +impl ViewStateFlags { + #[doc = "Indicates validity of all XrView orientations"] + pub const ORIENTATION_VALID: ViewStateFlags = Self(1 << 0u64); + #[doc = "Indicates validity of all XrView positions"] + pub const POSITION_VALID: ViewStateFlags = Self(1 << 1u64); + #[doc = "Indicates whether all XrView orientations are actively tracked"] + pub const ORIENTATION_TRACKED: ViewStateFlags = Self(1 << 2u64); + #[doc = "Indicates whether all XrView positions are actively tracked"] + pub const POSITION_TRACKED: ViewStateFlags = Self(1 << 3u64); +} +bitmask!(ViewStateFlags); +#[doc = "See [XrCompositionLayerFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct CompositionLayerFlags(u64); +impl CompositionLayerFlags { + #[doc = "Enables chromatic aberration correction when not done by default. This flag has no effect on any known conformant runtime, and is planned for deprecation for OpenXR 1.1"] + pub const CORRECT_CHROMATIC_ABERRATION: CompositionLayerFlags = Self(1 << 0u64); + #[doc = "Enables the layer texture alpha channel."] + pub const BLEND_TEXTURE_SOURCE_ALPHA: CompositionLayerFlags = Self(1 << 1u64); + #[doc = "Indicates the texture color channels have not been premultiplied by the texture alpha channel."] + pub const UNPREMULTIPLIED_ALPHA: CompositionLayerFlags = Self(1 << 2u64); +} +bitmask!(CompositionLayerFlags); +#[doc = "See [XrSpaceLocationFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceLocationFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SpaceLocationFlags(u64); +impl SpaceLocationFlags { + #[doc = "Indicates that the orientation member contains valid data"] + pub const ORIENTATION_VALID: SpaceLocationFlags = Self(1 << 0u64); + #[doc = "Indicates that the position member contains valid data"] + pub const POSITION_VALID: SpaceLocationFlags = Self(1 << 1u64); + #[doc = "Indicates whether pose member contains an actively tracked orientation"] + pub const ORIENTATION_TRACKED: SpaceLocationFlags = Self(1 << 2u64); + #[doc = "Indicates whether pose member contains an actively tracked position"] + pub const POSITION_TRACKED: SpaceLocationFlags = Self(1 << 3u64); +} +bitmask!(SpaceLocationFlags); +#[doc = "See [XrSpaceVelocityFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceVelocityFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SpaceVelocityFlags(u64); +impl SpaceVelocityFlags { + #[doc = "Indicates that the linearVelocity member contains valid data. Applications must: not read the linearVelocity field if this flag is unset."] + pub const LINEAR_VALID: SpaceVelocityFlags = Self(1 << 0u64); + #[doc = "Indicates that the angularVelocity member contains valid data. Applications must: not read the angularVelocity field if this flag is unset."] + pub const ANGULAR_VALID: SpaceVelocityFlags = Self(1 << 1u64); +} +bitmask!(SpaceVelocityFlags); +#[doc = "See [XrInputSourceLocalizedNameFlagBits](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInputSourceLocalizedNameFlagBits)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct InputSourceLocalizedNameFlags(u64); +impl InputSourceLocalizedNameFlags { + #[doc = "Asks for the part of the string which indicates the top level user path the source represents"] + pub const USER_PATH: InputSourceLocalizedNameFlags = Self(1 << 0u64); + #[doc = "Asks for the part of the string which represents the interaction profile of the source"] + pub const INTERACTION_PROFILE: InputSourceLocalizedNameFlags = Self(1 << 1u64); + #[doc = "Asks for the part of the string which represents the component on the device which needs to be interacted with"] + pub const COMPONENT: InputSourceLocalizedNameFlags = Self(1 << 2u64); +} +bitmask!(InputSourceLocalizedNameFlags); +#[doc = "See [XrVulkanInstanceCreateFlagsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanInstanceCreateFlagsKHR)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct VulkanInstanceCreateFlagsKHR(u64); +impl VulkanInstanceCreateFlagsKHR {} +bitmask!(VulkanInstanceCreateFlagsKHR); +#[doc = "See [XrVulkanDeviceCreateFlagsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanDeviceCreateFlagsKHR)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct VulkanDeviceCreateFlagsKHR(u64); +impl VulkanDeviceCreateFlagsKHR {} +bitmask!(VulkanDeviceCreateFlagsKHR); +#[doc = "See [XrDebugUtilsMessageSeverityFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessageSeverityFlagsEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct DebugUtilsMessageSeverityFlagsEXT(u64); +impl DebugUtilsMessageSeverityFlagsEXT { + #[doc = "Most verbose output severity, typically used for debugging."] + pub const VERBOSE: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 0u64); + #[doc = "General info message"] + pub const INFO: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 4u64); + #[doc = "Indicates the item may be the cause of issues."] + pub const WARNING: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 8u64); + #[doc = "Indicates that the item is definitely related to erroneous behavior."] + pub const ERROR: DebugUtilsMessageSeverityFlagsEXT = Self(1 << 12u64); +} +bitmask!(DebugUtilsMessageSeverityFlagsEXT); +#[doc = "See [XrDebugUtilsMessageTypeFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessageTypeFlagsEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct DebugUtilsMessageTypeFlagsEXT(u64); +impl DebugUtilsMessageTypeFlagsEXT { + #[doc = "Indicates this is a general message"] + pub const GENERAL: DebugUtilsMessageTypeFlagsEXT = Self(1 << 0u64); + #[doc = "Indicates the message is related to a validation message"] + pub const VALIDATION: DebugUtilsMessageTypeFlagsEXT = Self(1 << 1u64); + #[doc = "Indicates the message is related to a potential performance situation"] + pub const PERFORMANCE: DebugUtilsMessageTypeFlagsEXT = Self(1 << 2u64); + #[doc = "Indicates the message is related to a non-conformant runtime result"] + pub const CONFORMANCE: DebugUtilsMessageTypeFlagsEXT = Self(1 << 3u64); +} +bitmask!(DebugUtilsMessageTypeFlagsEXT); +#[doc = "See [XrOverlayMainSessionFlagsEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOverlayMainSessionFlagsEXTX)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct OverlayMainSessionFlagsEXTX(u64); +impl OverlayMainSessionFlagsEXTX { + #[doc = "Indicates the main session enabled `XR_KHR_composition_layer_depth`"] + pub const ENABLED_COMPOSITION_LAYER_INFO_DEPTH: OverlayMainSessionFlagsEXTX = Self(1 << 0u64); +} +bitmask!(OverlayMainSessionFlagsEXTX); +#[doc = "See [XrOverlaySessionCreateFlagsEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOverlaySessionCreateFlagsEXTX)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct OverlaySessionCreateFlagsEXTX(u64); +impl OverlaySessionCreateFlagsEXTX {} +bitmask!(OverlaySessionCreateFlagsEXTX); +#[doc = "See [XrAndroidSurfaceSwapchainFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAndroidSurfaceSwapchainFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct AndroidSurfaceSwapchainFlagsFB(u64); +impl AndroidSurfaceSwapchainFlagsFB { + #[doc = "Create the underlying BufferQueue in synchronous mode"] + pub const SYNCHRONOUS: AndroidSurfaceSwapchainFlagsFB = Self(1 << 0u64); + #[doc = "Acquire most recent buffer whose presentation timestamp is not greater than display time of final composited frame"] + pub const USE_TIMESTAMPS: AndroidSurfaceSwapchainFlagsFB = Self(1 << 1u64); +} +bitmask!(AndroidSurfaceSwapchainFlagsFB); +#[doc = "See [XrCompositionLayerImageLayoutFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerImageLayoutFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct CompositionLayerImageLayoutFlagsFB(u64); +impl CompositionLayerImageLayoutFlagsFB { + #[doc = "The coordinate origin of the swapchain image must be considered to be flipped vertically."] + pub const VERTICAL_FLIP: CompositionLayerImageLayoutFlagsFB = Self(1 << 0u64); +} +bitmask!(CompositionLayerImageLayoutFlagsFB); +#[doc = "See [XrCompositionLayerSecureContentFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSecureContentFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct CompositionLayerSecureContentFlagsFB(u64); +impl CompositionLayerSecureContentFlagsFB { + #[doc = "Indicates the layer will only be visible inside the HMD, and not visible to external sources"] + pub const EXCLUDE_LAYER: CompositionLayerSecureContentFlagsFB = Self(1 << 0u64); + #[doc = "Indicates the layer will be displayed inside the HMD, but replaced by proxy content when written to external sources"] + pub const REPLACE_LAYER: CompositionLayerSecureContentFlagsFB = Self(1 << 1u64); +} +bitmask!(CompositionLayerSecureContentFlagsFB); +#[doc = "See [XrSwapchainCreateFoveationFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateFoveationFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SwapchainCreateFoveationFlagsFB(u64); +impl SwapchainCreateFoveationFlagsFB { + #[doc = "Explicitly create the swapchain with scaled bin foveation support. The application must ensure that the swapchain is using the OpenGL graphics API and that the QCOM_texture_foveated extension is supported and enabled."] + pub const SCALED_BIN: SwapchainCreateFoveationFlagsFB = Self(1 << 0u64); + #[doc = "Explicitly create the swapchain with fragment density map foveation support. The application must ensure that the swapchain is using the Vulkan graphics API and that the VK_EXT_fragment_density_map extension is supported and enabled."] + pub const FRAGMENT_DENSITY_MAP: SwapchainCreateFoveationFlagsFB = Self(1 << 1u64); +} +bitmask!(SwapchainCreateFoveationFlagsFB); +#[doc = "See [XrSwapchainStateFoveationFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateFoveationFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SwapchainStateFoveationFlagsFB(u64); +impl SwapchainStateFoveationFlagsFB {} +bitmask!(SwapchainStateFoveationFlagsFB); +#[doc = "See [XrFoveationEyeTrackedProfileCreateFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationEyeTrackedProfileCreateFlagsMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct FoveationEyeTrackedProfileCreateFlagsMETA(u64); +impl FoveationEyeTrackedProfileCreateFlagsMETA {} +bitmask!(FoveationEyeTrackedProfileCreateFlagsMETA); +#[doc = "See [XrFoveationEyeTrackedStateFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationEyeTrackedStateFlagsMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct FoveationEyeTrackedStateFlagsMETA(u64); +impl FoveationEyeTrackedStateFlagsMETA { + #[doc = "Indicates whether or not foveation data is valid. This can happen if the eye tracker is obscured, the camera has dirt, or eye lid is closed, etc."] + pub const VALID: FoveationEyeTrackedStateFlagsMETA = Self(1 << 0u64); +} +bitmask!(FoveationEyeTrackedStateFlagsMETA); +#[doc = "See [XrTriangleMeshFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct TriangleMeshFlagsFB(u64); +impl TriangleMeshFlagsFB { + #[doc = "The triangle mesh is mutable (can be modified after it is created)."] + pub const MUTABLE: TriangleMeshFlagsFB = Self(1 << 0u64); +} +bitmask!(TriangleMeshFlagsFB); +#[doc = "See [XrPassthroughFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PassthroughFlagsFB(u64); +impl PassthroughFlagsFB { + #[doc = "The object (passthrough, layer) is running at creation."] + pub const IS_RUNNING_AT_CREATION: PassthroughFlagsFB = Self(1 << 0u64); + #[doc = "The passthrough system sends depth information to the compositor. Only applicable to layer objects."] + pub const LAYER_DEPTH: PassthroughFlagsFB = Self(1 << 1u64); +} +bitmask!(PassthroughFlagsFB); +#[doc = "See [XrPassthroughStateChangedFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughStateChangedFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PassthroughStateChangedFlagsFB(u64); +impl PassthroughStateChangedFlagsFB { + #[doc = "Passthrough system requires reinitialization."] + pub const REINIT_REQUIRED: PassthroughStateChangedFlagsFB = Self(1 << 0u64); + #[doc = "Non-recoverable error has occurred. A device reboot or a firmware update may be required."] + pub const NON_RECOVERABLE_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 1u64); + #[doc = "A recoverable error has occurred. The runtime will attempt to recover, but some functionality may be temporarily unavailable."] + pub const RECOVERABLE_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 2u64); + #[doc = "The runtime has recovered from a previous error and is functioning normally."] + pub const RESTORED_ERROR: PassthroughStateChangedFlagsFB = Self(1 << 3u64); +} +bitmask!(PassthroughStateChangedFlagsFB); +#[doc = "See [XrPassthroughCapabilityFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughCapabilityFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PassthroughCapabilityFlagsFB(u64); +impl PassthroughCapabilityFlagsFB { + #[doc = "The system supports passthrough."] + pub const PASSTHROUGH_CAPABILITY: PassthroughCapabilityFlagsFB = Self(1 << 0u64); + #[doc = "The system can show passthrough with realistic colors. XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB is set."] + pub const COLOR: PassthroughCapabilityFlagsFB = Self(1 << 1u64); + #[doc = "The system supports passthrough layers composited using depth testing. XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB is set."] + pub const LAYER_DEPTH: PassthroughCapabilityFlagsFB = Self(1 << 2u64); +} +bitmask!(PassthroughCapabilityFlagsFB); +#[doc = "See [XrSemanticLabelsSupportFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSemanticLabelsSupportFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SemanticLabelsSupportFlagsFB(u64); +impl SemanticLabelsSupportFlagsFB { + #[doc = "If set, and the runtime reports the extensionVersion as 2 or greater, the runtime may: return multiple semantic labels separated by a comma without spaces. Otherwise, the runtime must: return a single semantic label."] + pub const MULTIPLE_SEMANTIC_LABELS: SemanticLabelsSupportFlagsFB = Self(1 << 0u64); + #[doc = "If set, and the runtime reports the extensionVersion as 3 or greater, the runtime must: return \"TABLE\" instead of \"DESK\" as a semantic label to the application. Otherwise, the runtime must: return \"DESK\" instead of \"TABLE\" as a semantic label to the application, when applicable."] + pub const ACCEPT_DESK_TO_TABLE_MIGRATION: SemanticLabelsSupportFlagsFB = Self(1 << 1u64); +} +bitmask!(SemanticLabelsSupportFlagsFB); +#[doc = "See [XrHandTrackingAimFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingAimFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct HandTrackingAimFlagsFB(u64); +impl HandTrackingAimFlagsFB { + #[doc = "Aiming data is computed from additional sources beyond the hand data in the base structure"] + pub const COMPUTED: HandTrackingAimFlagsFB = Self(1 << 0u64); + #[doc = "Aiming data is valid"] + pub const VALID: HandTrackingAimFlagsFB = Self(1 << 1u64); + #[doc = "Index finger pinch discrete signal"] + pub const INDEX_PINCHING: HandTrackingAimFlagsFB = Self(1 << 2u64); + #[doc = "Middle finger pinch discrete signal"] + pub const MIDDLE_PINCHING: HandTrackingAimFlagsFB = Self(1 << 3u64); + #[doc = "Ring finger pinch discrete signal"] + pub const RING_PINCHING: HandTrackingAimFlagsFB = Self(1 << 4u64); + #[doc = "Little finger pinch discrete signal"] + pub const LITTLE_PINCHING: HandTrackingAimFlagsFB = Self(1 << 5u64); + #[doc = "System gesture is active"] + pub const SYSTEM_GESTURE: HandTrackingAimFlagsFB = Self(1 << 6u64); + #[doc = "Hand is currently marked as dominant for the system"] + pub const DOMINANT_HAND: HandTrackingAimFlagsFB = Self(1 << 7u64); + #[doc = "System menu gesture is active"] + pub const MENU_PRESSED: HandTrackingAimFlagsFB = Self(1 << 8u64); +} +bitmask!(HandTrackingAimFlagsFB); +#[doc = "See [XrKeyboardTrackingFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct KeyboardTrackingFlagsFB(u64); +impl KeyboardTrackingFlagsFB { + #[doc = "indicates that the system has a physically tracked keyboard to report. If not set then no other bits should be considered to be valid or meaningful. If set either XR_KEYBOARD_TRACKING_LOCAL_BIT_FB or XR_KEYBOARD_TRACKING_REMOTE_BIT_FB must also be set."] + pub const EXISTS: KeyboardTrackingFlagsFB = Self(1 << 0u64); + #[doc = "indicates that the physically tracked keyboard is intended to be used in a local pairing with the system. Mutally exclusive with XR_KEYBOARD_TRACKING_REMOTE_BIT_FB."] + pub const LOCAL: KeyboardTrackingFlagsFB = Self(1 << 1u64); + #[doc = "indicates that the physically tracked keyboard is intended to be used while paired to a separate remote computing device. Mutally exclusive with XR_KEYBOARD_TRACKING_LOCAL_BIT_FB."] + pub const REMOTE: KeyboardTrackingFlagsFB = Self(1 << 2u64); + #[doc = "indicates that the physically tracked keyboard is actively connected to the headset and capable of sending key data"] + pub const CONNECTED: KeyboardTrackingFlagsFB = Self(1 << 3u64); +} +bitmask!(KeyboardTrackingFlagsFB); +#[doc = "See [XrKeyboardTrackingQueryFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingQueryFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct KeyboardTrackingQueryFlagsFB(u64); +impl KeyboardTrackingQueryFlagsFB { + #[doc = "indicates the query is for the physically tracked keyboard that is intended to be used in a local pairing with the System. Mutally exclusive with XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB."] + pub const LOCAL: KeyboardTrackingQueryFlagsFB = Self(1 << 1u64); + #[doc = "indicates the query is for the physically tracked keyboard that may be connected to a separate remote computing device. Mutally exclusive with XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB."] + pub const REMOTE: KeyboardTrackingQueryFlagsFB = Self(1 << 2u64); +} +bitmask!(KeyboardTrackingQueryFlagsFB); +#[doc = "See [XrCompositionLayerSpaceWarpInfoFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSpaceWarpInfoFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct CompositionLayerSpaceWarpInfoFlagsFB(u64); +impl CompositionLayerSpaceWarpInfoFlagsFB { + #[doc = "Skip current frame's space warp extrapolation"] + pub const FRAME_SKIP: CompositionLayerSpaceWarpInfoFlagsFB = Self(1 << 0u64); +} +bitmask!(CompositionLayerSpaceWarpInfoFlagsFB); +#[doc = "See [XrRenderModelFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct RenderModelFlagsFB(u64); +impl RenderModelFlagsFB { + #[doc = "Minimal level of support. Can only contain a single mesh. Can only contain a single texture. Can not contain transparency. Assumes unlit rendering. Requires Extension KHR_texturebasisu."] + pub const SUPPORTS_GLTF_2_0_SUBSET_1: RenderModelFlagsFB = Self(1 << 0u64); + #[doc = "All of XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB support plus: Multiple meshes. Multiple Textures. Texture Transparency."] pub const SUPPORTS_GLTF_2_0_SUBSET_2: RenderModelFlagsFB = Self(1 << 1u64); } -bitmask!(RenderModelFlagsFB); -#[doc = "See [XrDigitalLensControlFlagsALMALENCE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDigitalLensControlFlagsALMALENCE)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct DigitalLensControlFlagsALMALENCE(u64); -impl DigitalLensControlFlagsALMALENCE { - #[doc = "disables Digital Lens processing of render textures"] - pub const PROCESSING_DISABLE: DigitalLensControlFlagsALMALENCE = Self(1 << 0u64); +bitmask!(RenderModelFlagsFB); +#[doc = "See [XrDigitalLensControlFlagsALMALENCE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDigitalLensControlFlagsALMALENCE)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct DigitalLensControlFlagsALMALENCE(u64); +impl DigitalLensControlFlagsALMALENCE { + #[doc = "disables Digital Lens processing of render textures"] + pub const PROCESSING_DISABLE: DigitalLensControlFlagsALMALENCE = Self(1 << 0u64); +} +bitmask!(DigitalLensControlFlagsALMALENCE); +#[doc = "See [XrCompositionLayerSettingsFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSettingsFlagsFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct CompositionLayerSettingsFlagsFB(u64); +impl CompositionLayerSettingsFlagsFB { + #[doc = "Indicates compositor may: use layer texture supersampling."] + pub const NORMAL_SUPER_SAMPLING: CompositionLayerSettingsFlagsFB = Self(1 << 0u64); + #[doc = "Indicates compositor may: use high quality layer texture supersampling."] + pub const QUALITY_SUPER_SAMPLING: CompositionLayerSettingsFlagsFB = Self(1 << 1u64); + #[doc = "Indicates compositor may: use layer texture sharpening."] + pub const NORMAL_SHARPENING: CompositionLayerSettingsFlagsFB = Self(1 << 2u64); + #[doc = "Indicates compositor may: use high quality layer texture sharpening."] + pub const QUALITY_SHARPENING: CompositionLayerSettingsFlagsFB = Self(1 << 3u64); +} +bitmask!(CompositionLayerSettingsFlagsFB); +#[doc = "See [XrExternalCameraStatusFlagsOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExternalCameraStatusFlagsOCULUS)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct ExternalCameraStatusFlagsOCULUS(u64); +impl ExternalCameraStatusFlagsOCULUS { + #[doc = "External camera is connected"] + pub const CONNECTED: ExternalCameraStatusFlagsOCULUS = Self(1 << 0u64); + #[doc = "External camera is undergoing calibration"] + pub const CALIBRATING: ExternalCameraStatusFlagsOCULUS = Self(1 << 1u64); + #[doc = "External camera has tried and failed calibration"] + pub const CALIBRATION_FAILED: ExternalCameraStatusFlagsOCULUS = Self(1 << 2u64); + #[doc = "External camera has tried and passed calibration"] + pub const CALIBRATED: ExternalCameraStatusFlagsOCULUS = Self(1 << 3u64); + #[doc = "External camera is capturing"] + pub const CAPTURING: ExternalCameraStatusFlagsOCULUS = Self(1 << 4u64); +} +bitmask!(ExternalCameraStatusFlagsOCULUS); +#[doc = "See [XrPerformanceMetricsCounterFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterFlagsMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PerformanceMetricsCounterFlagsMETA(u64); +impl PerformanceMetricsCounterFlagsMETA { + #[doc = "Indicates any of the values in XrPerformanceMetricsCounterMETA is valid."] + pub const ANY_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 0u64); + #[doc = "Indicates the uintValue in XrPerformanceMetricsCounterMETA is valid."] + pub const UINT_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 1u64); + #[doc = "Indicates the floatValue in XrPerformanceMetricsCounterMETA is valid."] + pub const FLOAT_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 2u64); +} +bitmask!(PerformanceMetricsCounterFlagsMETA); +#[doc = "See [XrPassthroughPreferenceFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughPreferenceFlagsMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PassthroughPreferenceFlagsMETA(u64); +impl PassthroughPreferenceFlagsMETA { + #[doc = "Indicates that the runtime recommends apps to default to a mixed reality experience with passthrough (if supported)."] + pub const DEFAULT_TO_ACTIVE: PassthroughPreferenceFlagsMETA = Self(1 << 0u64); +} +bitmask!(PassthroughPreferenceFlagsMETA); +#[doc = "See [XrFoveationDynamicFlagsHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationDynamicFlagsHTC)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct FoveationDynamicFlagsHTC(u64); +impl FoveationDynamicFlagsHTC { + #[doc = "Allow system to set periphery pixel density dynamically."] + pub const LEVEL_ENABLED: FoveationDynamicFlagsHTC = Self(1 << 0u64); + #[doc = "Allow system to set clear FOV degree dynamically."] + pub const CLEAR_FOV_ENABLED: FoveationDynamicFlagsHTC = Self(1 << 1u64); + #[doc = "Allow system to set focal center offset dynamically."] + pub const FOCAL_CENTER_OFFSET_ENABLED: FoveationDynamicFlagsHTC = Self(1 << 2u64); +} +bitmask!(FoveationDynamicFlagsHTC); +#[doc = "See [XrFrameEndInfoFlagsML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameEndInfoFlagsML)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct FrameEndInfoFlagsML(u64); +impl FrameEndInfoFlagsML { + #[doc = "Indicates that the content for this frame is protected and should not be recorded or captured outside the graphics system."] + pub const PROTECTED: FrameEndInfoFlagsML = Self(1 << 0u64); + #[doc = "Indicates that a soft fade to transparent should be added to the frame in the compositor to blend any hard edges at the FOV limits."] + pub const VIGNETTE: FrameEndInfoFlagsML = Self(1 << 1u64); +} +bitmask!(FrameEndInfoFlagsML); +#[doc = "See [XrGlobalDimmerFrameEndInfoFlagsML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGlobalDimmerFrameEndInfoFlagsML)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct GlobalDimmerFrameEndInfoFlagsML(u64); +impl GlobalDimmerFrameEndInfoFlagsML { + #[doc = "Indicates that the global dimmer should: be enabled and controlled by dimmerValue."] + pub const ENABLED: GlobalDimmerFrameEndInfoFlagsML = Self(1 << 0u64); +} +bitmask!(GlobalDimmerFrameEndInfoFlagsML); +#[doc = "See [XrPlaneDetectorFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorFlagsEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PlaneDetectorFlagsEXT(u64); +impl PlaneDetectorFlagsEXT { + #[doc = "populate the plane contour information"] + pub const ENABLE_CONTOUR: PlaneDetectorFlagsEXT = Self(1 << 0u64); +} +bitmask!(PlaneDetectorFlagsEXT); +#[doc = "See [XrPlaneDetectionCapabilityFlagsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectionCapabilityFlagsEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PlaneDetectionCapabilityFlagsEXT(u64); +impl PlaneDetectionCapabilityFlagsEXT { + #[doc = "plane detection is supported"] + pub const PLANE_DETECTION: PlaneDetectionCapabilityFlagsEXT = Self(1 << 0u64); + #[doc = "polygon buffers for holes in planes can be generated"] + pub const PLANE_HOLES: PlaneDetectionCapabilityFlagsEXT = Self(1 << 1u64); + #[doc = "plane detection supports ceiling semantic classification"] + pub const SEMANTIC_CEILING: PlaneDetectionCapabilityFlagsEXT = Self(1 << 2u64); + #[doc = "plane detection supports floor semantic classification"] + pub const SEMANTIC_FLOOR: PlaneDetectionCapabilityFlagsEXT = Self(1 << 3u64); + #[doc = "plane detection supports wall semantic classification"] + pub const SEMANTIC_WALL: PlaneDetectionCapabilityFlagsEXT = Self(1 << 4u64); + #[doc = "plane detection supports platform semantic classification (for example table tops)"] + pub const SEMANTIC_PLATFORM: PlaneDetectionCapabilityFlagsEXT = Self(1 << 5u64); + #[doc = "plane detection supports plane orientation classification. If not supported planes are always classified as ARBITRARY."] + pub const ORIENTATION: PlaneDetectionCapabilityFlagsEXT = Self(1 << 6u64); +} +bitmask!(PlaneDetectionCapabilityFlagsEXT); +#[doc = "See [XrVirtualKeyboardInputStateFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardInputStateFlagsMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct VirtualKeyboardInputStateFlagsMETA(u64); +impl VirtualKeyboardInputStateFlagsMETA { + #[doc = "If the input source is considered 'pressed' at all. Pinch for hands, Primary button for controllers."] + pub const PRESSED: VirtualKeyboardInputStateFlagsMETA = Self(1 << 0u64); +} +bitmask!(VirtualKeyboardInputStateFlagsMETA); +#[doc = "See [XrInstance](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstance)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct Instance(u64); +handle!(Instance); +#[doc = "See [XrSession](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSession)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct Session(u64); +handle!(Session); +#[doc = "See [XrActionSet](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSet)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct ActionSet(u64); +handle!(ActionSet); +#[doc = "See [XrAction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAction)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct Action(u64); +handle!(Action); +#[doc = "See [XrSwapchain](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchain)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct Swapchain(u64); +handle!(Swapchain); +#[doc = "See [XrSpace](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpace)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct Space(u64); +handle!(Space); +#[doc = "See [XrDebugUtilsMessengerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct DebugUtilsMessengerEXT(u64); +handle!(DebugUtilsMessengerEXT); +#[doc = "See [XrSpatialAnchorMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorMSFT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SpatialAnchorMSFT(u64); +handle!(SpatialAnchorMSFT); +#[doc = "See [XrHandTrackerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct HandTrackerEXT(u64); +handle!(HandTrackerEXT); +#[doc = "See [XrFoveationProfileFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationProfileFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct FoveationProfileFB(u64); +handle!(FoveationProfileFB); +#[doc = "See [XrTriangleMeshFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct TriangleMeshFB(u64); +handle!(TriangleMeshFB); +#[doc = "See [XrPassthroughFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct PassthroughFB(u64); +handle!(PassthroughFB); +#[doc = "See [XrPassthroughLayerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughLayerFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct PassthroughLayerFB(u64); +handle!(PassthroughLayerFB); +#[doc = "See [XrGeometryInstanceFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct GeometryInstanceFB(u64); +handle!(GeometryInstanceFB); +#[doc = "See [XrFacialTrackerHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerHTC)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct FacialTrackerHTC(u64); +handle!(FacialTrackerHTC); +#[doc = "See [XrPassthroughHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughHTC)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct PassthroughHTC(u64); +handle!(PassthroughHTC); +#[doc = "See [XrFaceTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceTrackerFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct FaceTrackerFB(u64); +handle!(FaceTrackerFB); +#[doc = "See [XrBodyTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyTrackerFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct BodyTrackerFB(u64); +handle!(BodyTrackerFB); +#[doc = "See [XrEyeTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeTrackerFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct EyeTrackerFB(u64); +handle!(EyeTrackerFB); +#[doc = "See [XrSpaceUserFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceUserFB)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SpaceUserFB(u64); +handle!(SpaceUserFB); +#[doc = "See [XrPassthroughColorLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorLutMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct PassthroughColorLutMETA(u64); +handle!(PassthroughColorLutMETA); +#[doc = "See [XrPlaneDetectorEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorEXT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct PlaneDetectorEXT(u64); +handle!(PlaneDetectorEXT); +#[doc = "See [XrVirtualKeyboardMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardMETA)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct VirtualKeyboardMETA(u64); +handle!(VirtualKeyboardMETA); +#[doc = "See [XrSpatialGraphNodeBindingMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingMSFT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SpatialGraphNodeBindingMSFT(u64); +handle!(SpatialGraphNodeBindingMSFT); +#[doc = "See [XrSceneObserverMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneObserverMSFT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SceneObserverMSFT(u64); +handle!(SceneObserverMSFT); +#[doc = "See [XrSceneMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneMSFT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SceneMSFT(u64); +handle!(SceneMSFT); +#[doc = "See [XrSpatialAnchorStoreConnectionMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorStoreConnectionMSFT)"] +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct SpatialAnchorStoreConnectionMSFT(u64); +handle!(SpatialAnchorStoreConnectionMSFT); +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrVector2f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector2f)"] +pub struct Vector2f { + pub x: f32, + pub y: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrVector3f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector3f)"] +pub struct Vector3f { + pub x: f32, + pub y: f32, + pub z: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrVector4f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector4f)"] +pub struct Vector4f { + pub x: f32, + pub y: f32, + pub z: f32, + pub w: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrColor4f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrColor4f)"] +pub struct Color4f { + pub r: f32, + pub g: f32, + pub b: f32, + pub a: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrQuaternionf](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrQuaternionf)"] +pub struct Quaternionf { + pub x: f32, + pub y: f32, + pub z: f32, + pub w: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrPosef](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPosef)"] +pub struct Posef { + pub orientation: Quaternionf, + pub position: Vector3f, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrOffset2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset2Df)"] +pub struct Offset2Df { + pub x: f32, + pub y: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrExtent2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent2Df)"] +pub struct Extent2Df { + pub width: f32, + pub height: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrExtent3DfEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent3DfEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct Extent3DfEXT { + pub width: f32, + pub height: f32, + pub depth: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrRect2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect2Df)"] +pub struct Rect2Df { + pub offset: Offset2Df, + pub extent: Extent2Df, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrOffset2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset2Di)"] +pub struct Offset2Di { + pub x: i32, + pub y: i32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrExtent2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent2Di)"] +pub struct Extent2Di { + pub width: i32, + pub height: i32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrRect2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect2Di)"] +pub struct Rect2Di { + pub offset: Offset2Di, + pub extent: Extent2Di, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBaseInStructure](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBaseInStructure)"] +pub struct BaseInStructure { + pub ty: StructureType, + pub next: *const BaseInStructure, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBaseOutStructure](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBaseOutStructure)"] +pub struct BaseOutStructure { + pub ty: StructureType, + pub next: *mut BaseOutStructure, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrApiLayerProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrApiLayerProperties)"] +pub struct ApiLayerProperties { + pub ty: StructureType, + pub next: *mut c_void, + pub layer_name: [c_char; MAX_API_LAYER_NAME_SIZE], + pub spec_version: Version, + pub layer_version: u32, + pub description: [c_char; MAX_API_LAYER_DESCRIPTION_SIZE], +} +impl ApiLayerProperties { + pub const TYPE: StructureType = StructureType::API_LAYER_PROPERTIES; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrExtensionProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtensionProperties)"] +pub struct ExtensionProperties { + pub ty: StructureType, + pub next: *mut c_void, + pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub extension_version: u32, +} +impl ExtensionProperties { + pub const TYPE: StructureType = StructureType::EXTENSION_PROPERTIES; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrApplicationInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrApplicationInfo)"] +pub struct ApplicationInfo { + pub application_name: [c_char; MAX_APPLICATION_NAME_SIZE], + pub application_version: u32, + pub engine_name: [c_char; MAX_ENGINE_NAME_SIZE], + pub engine_version: u32, + pub api_version: Version, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrInstanceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateInfo)"] +pub struct InstanceCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub create_flags: InstanceCreateFlags, + pub application_info: ApplicationInfo, + pub enabled_api_layer_count: u32, + pub enabled_api_layer_names: *const *const c_char, + pub enabled_extension_count: u32, + pub enabled_extension_names: *const *const c_char, +} +impl InstanceCreateInfo { + pub const TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrInstanceProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceProperties)"] +pub struct InstanceProperties { + pub ty: StructureType, + pub next: *mut c_void, + pub runtime_version: Version, + pub runtime_name: [c_char; MAX_RUNTIME_NAME_SIZE], +} +impl InstanceProperties { + pub const TYPE: StructureType = StructureType::INSTANCE_PROPERTIES; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemGetInfo)"] +pub struct SystemGetInfo { + pub ty: StructureType, + pub next: *const c_void, + pub form_factor: FormFactor, +} +impl SystemGetInfo { + pub const TYPE: StructureType = StructureType::SYSTEM_GET_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemProperties)"] +pub struct SystemProperties { + pub ty: StructureType, + pub next: *mut c_void, + pub system_id: SystemId, + pub vendor_id: u32, + pub system_name: [c_char; MAX_SYSTEM_NAME_SIZE], + pub graphics_properties: SystemGraphicsProperties, + pub tracking_properties: SystemTrackingProperties, +} +impl SystemProperties { + pub const TYPE: StructureType = StructureType::SYSTEM_PROPERTIES; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrSystemGraphicsProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemGraphicsProperties)"] +pub struct SystemGraphicsProperties { + pub max_swapchain_image_height: u32, + pub max_swapchain_image_width: u32, + pub max_layer_count: u32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrSystemTrackingProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemTrackingProperties)"] +pub struct SystemTrackingProperties { + pub orientation_tracking: Bool32, + pub position_tracking: Bool32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingOpenGLWin32KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLWin32KHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +#[cfg(windows)] +pub struct GraphicsBindingOpenGLWin32KHR { + pub ty: StructureType, + pub next: *const c_void, + pub h_dc: HDC, + pub h_glrc: HGLRC, +} +#[cfg(windows)] +impl GraphicsBindingOpenGLWin32KHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_WIN32_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingOpenGLXlibKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLXlibKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +pub struct GraphicsBindingOpenGLXlibKHR { + pub ty: StructureType, + pub next: *const c_void, + pub x_display: *mut Display, + pub visualid: u32, + pub glx_fb_config: GLXFBConfig, + pub glx_drawable: GLXDrawable, + pub glx_context: GLXContext, +} +impl GraphicsBindingOpenGLXlibKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_XLIB_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingOpenGLXcbKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLXcbKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +pub struct GraphicsBindingOpenGLXcbKHR { + pub ty: StructureType, + pub next: *const c_void, + pub connection: *mut xcb_connection_t, + pub screen_number: u32, + pub fbconfigid: xcb_glx_fbconfig_t, + pub visualid: xcb_visualid_t, + pub glx_drawable: xcb_glx_drawable_t, + pub glx_context: xcb_glx_context_t, +} +impl GraphicsBindingOpenGLXcbKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_XCB_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingOpenGLWaylandKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLWaylandKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +pub struct GraphicsBindingOpenGLWaylandKHR { + pub ty: StructureType, + pub next: *const c_void, + pub display: *mut wl_display, +} +impl GraphicsBindingOpenGLWaylandKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_WAYLAND_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] +#[cfg(windows)] +pub struct GraphicsBindingD3D11KHR { + pub ty: StructureType, + pub next: *const c_void, + pub device: *mut ID3D11Device, +} +#[cfg(windows)] +impl GraphicsBindingD3D11KHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_D3D11_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] +#[cfg(windows)] +pub struct GraphicsBindingD3D12KHR { + pub ty: StructureType, + pub next: *const c_void, + pub device: *mut ID3D12Device, + pub queue: *mut ID3D12CommandQueue, +} +#[cfg(windows)] +impl GraphicsBindingD3D12KHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_D3D12_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingOpenGLESAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLESAndroidKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] +#[cfg(target_os = "android")] +pub struct GraphicsBindingOpenGLESAndroidKHR { + pub ty: StructureType, + pub next: *const c_void, + pub display: EGLDisplay, + pub config: EGLConfig, + pub context: EGLContext, +} +#[cfg(target_os = "android")] +impl GraphicsBindingOpenGLESAndroidKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGraphicsBindingVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] +pub struct GraphicsBindingVulkanKHR { + pub ty: StructureType, + pub next: *const c_void, + pub instance: VkInstance, + pub physical_device: VkPhysicalDevice, + pub device: VkDevice, + pub queue_family_index: u32, + pub queue_index: u32, +} +impl GraphicsBindingVulkanKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_VULKAN_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSessionCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateInfo)"] +pub struct SessionCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub create_flags: SessionCreateFlags, + pub system_id: SystemId, +} +impl SessionCreateInfo { + pub const TYPE: StructureType = StructureType::SESSION_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSessionBeginInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionBeginInfo)"] +pub struct SessionBeginInfo { + pub ty: StructureType, + pub next: *const c_void, + pub primary_view_configuration_type: ViewConfigurationType, +} +impl SessionBeginInfo { + pub const TYPE: StructureType = StructureType::SESSION_BEGIN_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateInfo)"] +pub struct SwapchainCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub create_flags: SwapchainCreateFlags, + pub usage_flags: SwapchainUsageFlags, + pub format: i64, + pub sample_count: u32, + pub width: u32, + pub height: u32, + pub face_count: u32, + pub array_size: u32, + pub mip_count: u32, +} +impl SwapchainCreateInfo { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageBaseHeader)"] +pub struct SwapchainImageBaseHeader { + pub ty: StructureType, + pub next: *mut c_void, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageOpenGLKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageOpenGLKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +pub struct SwapchainImageOpenGLKHR { + pub ty: StructureType, + pub next: *mut c_void, + pub image: u32, +} +impl SwapchainImageOpenGLKHR { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_OPENGL_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageOpenGLESKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageOpenGLESKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] +pub struct SwapchainImageOpenGLESKHR { + pub ty: StructureType, + pub next: *mut c_void, + pub image: u32, +} +impl SwapchainImageOpenGLESKHR { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_OPENGL_ES_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] +pub struct SwapchainImageVulkanKHR { + pub ty: StructureType, + pub next: *mut c_void, + pub image: VkImage, +} +impl SwapchainImageVulkanKHR { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_VULKAN_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] +#[cfg(windows)] +pub struct SwapchainImageD3D11KHR { + pub ty: StructureType, + pub next: *mut c_void, + pub texture: *mut ID3D11Texture2D, +} +#[cfg(windows)] +impl SwapchainImageD3D11KHR { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_D3D11_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] +#[cfg(windows)] +pub struct SwapchainImageD3D12KHR { + pub ty: StructureType, + pub next: *mut c_void, + pub texture: *mut ID3D12Resource, +} +#[cfg(windows)] +impl SwapchainImageD3D12KHR { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_D3D12_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageAcquireInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageAcquireInfo)"] +pub struct SwapchainImageAcquireInfo { + pub ty: StructureType, + pub next: *const c_void, +} +impl SwapchainImageAcquireInfo { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_ACQUIRE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageWaitInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageWaitInfo)"] +pub struct SwapchainImageWaitInfo { + pub ty: StructureType, + pub next: *const c_void, + pub timeout: Duration, +} +impl SwapchainImageWaitInfo { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_WAIT_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainImageReleaseInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageReleaseInfo)"] +pub struct SwapchainImageReleaseInfo { + pub ty: StructureType, + pub next: *const c_void, +} +impl SwapchainImageReleaseInfo { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_RELEASE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrReferenceSpaceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrReferenceSpaceCreateInfo)"] +pub struct ReferenceSpaceCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub reference_space_type: ReferenceSpaceType, + pub pose_in_reference_space: Posef, +} +impl ReferenceSpaceCreateInfo { + pub const TYPE: StructureType = StructureType::REFERENCE_SPACE_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrActionSpaceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSpaceCreateInfo)"] +pub struct ActionSpaceCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub action: Action, + pub subaction_path: Path, + pub pose_in_action_space: Posef, +} +impl ActionSpaceCreateInfo { + pub const TYPE: StructureType = StructureType::ACTION_SPACE_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSpaceLocation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceLocation)"] +pub struct SpaceLocation { + pub ty: StructureType, + pub next: *mut c_void, + pub location_flags: SpaceLocationFlags, + pub pose: Posef, +} +impl SpaceLocation { + pub const TYPE: StructureType = StructureType::SPACE_LOCATION; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSpaceVelocity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceVelocity)"] +pub struct SpaceVelocity { + pub ty: StructureType, + pub next: *mut c_void, + pub velocity_flags: SpaceVelocityFlags, + pub linear_velocity: Vector3f, + pub angular_velocity: Vector3f, +} +impl SpaceVelocity { + pub const TYPE: StructureType = StructureType::SPACE_VELOCITY; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrFovf](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFovf)"] +pub struct Fovf { + pub angle_left: f32, + pub angle_right: f32, + pub angle_up: f32, + pub angle_down: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrView)"] +pub struct View { + pub ty: StructureType, + pub next: *mut c_void, + pub pose: Posef, + pub fov: Fovf, +} +impl View { + pub const TYPE: StructureType = StructureType::VIEW; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrViewLocateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewLocateInfo)"] +pub struct ViewLocateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub view_configuration_type: ViewConfigurationType, + pub display_time: Time, + pub space: Space, +} +impl ViewLocateInfo { + pub const TYPE: StructureType = StructureType::VIEW_LOCATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrViewState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewState)"] +pub struct ViewState { + pub ty: StructureType, + pub next: *mut c_void, + pub view_state_flags: ViewStateFlags, +} +impl ViewState { + pub const TYPE: StructureType = StructureType::VIEW_STATE; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrViewConfigurationView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationView)"] +pub struct ViewConfigurationView { + pub ty: StructureType, + pub next: *mut c_void, + pub recommended_image_rect_width: u32, + pub max_image_rect_width: u32, + pub recommended_image_rect_height: u32, + pub max_image_rect_height: u32, + pub recommended_swapchain_sample_count: u32, + pub max_swapchain_sample_count: u32, +} +impl ViewConfigurationView { + pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_VIEW; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainSubImage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainSubImage)"] +pub struct SwapchainSubImage { + pub swapchain: Swapchain, + pub image_rect: Rect2Di, + pub image_array_index: u32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerBaseHeader)"] +pub struct CompositionLayerBaseHeader { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerProjectionView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerProjectionView)"] +pub struct CompositionLayerProjectionView { + pub ty: StructureType, + pub next: *const c_void, + pub pose: Posef, + pub fov: Fovf, + pub sub_image: SwapchainSubImage, +} +impl CompositionLayerProjectionView { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PROJECTION_VIEW; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerProjection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerProjection)"] +pub struct CompositionLayerProjection { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub view_count: u32, + pub views: *const CompositionLayerProjectionView, +} +impl CompositionLayerProjection { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PROJECTION; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerQuad](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerQuad)"] +pub struct CompositionLayerQuad { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub eye_visibility: EyeVisibility, + pub sub_image: SwapchainSubImage, + pub pose: Posef, + pub size: Extent2Df, +} +impl CompositionLayerQuad { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_QUAD; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerCylinderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerCylinderKHR) - defined by [XR_KHR_composition_layer_cylinder](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_cylinder)"] +pub struct CompositionLayerCylinderKHR { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub eye_visibility: EyeVisibility, + pub sub_image: SwapchainSubImage, + pub pose: Posef, + pub radius: f32, + pub central_angle: f32, + pub aspect_ratio: f32, +} +impl CompositionLayerCylinderKHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_CYLINDER_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerCubeKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerCubeKHR) - defined by [XR_KHR_composition_layer_cube](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_cube)"] +pub struct CompositionLayerCubeKHR { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub eye_visibility: EyeVisibility, + pub swapchain: Swapchain, + pub image_array_index: u32, + pub orientation: Quaternionf, +} +impl CompositionLayerCubeKHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_CUBE_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerEquirectKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerEquirectKHR) - defined by [XR_KHR_composition_layer_equirect](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_equirect)"] +pub struct CompositionLayerEquirectKHR { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub eye_visibility: EyeVisibility, + pub sub_image: SwapchainSubImage, + pub pose: Posef, + pub radius: f32, + pub scale: Vector2f, + pub bias: Vector2f, +} +impl CompositionLayerEquirectKHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_EQUIRECT_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerDepthInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerDepthInfoKHR) - defined by [XR_KHR_composition_layer_depth](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_depth)"] +pub struct CompositionLayerDepthInfoKHR { + pub ty: StructureType, + pub next: *const c_void, + pub sub_image: SwapchainSubImage, + pub min_depth: f32, + pub max_depth: f32, + pub near_z: f32, + pub far_z: f32, +} +impl CompositionLayerDepthInfoKHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_DEPTH_INFO_KHR; } -bitmask!(DigitalLensControlFlagsALMALENCE); -#[doc = "See [XrCompositionLayerSettingsFlagsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSettingsFlagsFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct CompositionLayerSettingsFlagsFB(u64); -impl CompositionLayerSettingsFlagsFB { - #[doc = "Indicates compositor may: use layer texture supersampling."] - pub const NORMAL_SUPER_SAMPLING: CompositionLayerSettingsFlagsFB = Self(1 << 0u64); - #[doc = "Indicates compositor may: use high quality layer texture supersampling."] - pub const QUALITY_SUPER_SAMPLING: CompositionLayerSettingsFlagsFB = Self(1 << 1u64); - #[doc = "Indicates compositor may: use layer texture sharpening."] - pub const NORMAL_SHARPENING: CompositionLayerSettingsFlagsFB = Self(1 << 2u64); - #[doc = "Indicates compositor may: use high quality layer texture sharpening."] - pub const QUALITY_SHARPENING: CompositionLayerSettingsFlagsFB = Self(1 << 3u64); +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrFrameBeginInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameBeginInfo)"] +pub struct FrameBeginInfo { + pub ty: StructureType, + pub next: *const c_void, } -bitmask!(CompositionLayerSettingsFlagsFB); -#[doc = "See [XrPerformanceMetricsCounterFlagsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterFlagsMETA)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct PerformanceMetricsCounterFlagsMETA(u64); -impl PerformanceMetricsCounterFlagsMETA { - #[doc = "Indicates any of the values in XrPerformanceMetricsCounterMETA is valid."] - pub const ANY_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 0u64); - #[doc = "Indicates the uintValue in XrPerformanceMetricsCounterMETA is valid."] - pub const UINT_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 1u64); - #[doc = "Indicates the floatValue in XrPerformanceMetricsCounterMETA is valid."] - pub const FLOAT_VALUE_VALID: PerformanceMetricsCounterFlagsMETA = Self(1 << 2u64); +impl FrameBeginInfo { + pub const TYPE: StructureType = StructureType::FRAME_BEGIN_INFO; } -bitmask!(PerformanceMetricsCounterFlagsMETA); -#[doc = "See [XrInstance](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstance)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct Instance(u64); -handle!(Instance); -#[doc = "See [XrSession](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSession)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct Session(u64); -handle!(Session); -#[doc = "See [XrActionSet](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSet)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct ActionSet(u64); -handle!(ActionSet); -#[doc = "See [XrAction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAction)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct Action(u64); -handle!(Action); -#[doc = "See [XrSwapchain](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchain)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct Swapchain(u64); -handle!(Swapchain); -#[doc = "See [XrSpace](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpace)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct Space(u64); -handle!(Space); -#[doc = "See [XrDebugUtilsMessengerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerEXT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct DebugUtilsMessengerEXT(u64); -handle!(DebugUtilsMessengerEXT); -#[doc = "See [XrSpatialAnchorMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorMSFT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct SpatialAnchorMSFT(u64); -handle!(SpatialAnchorMSFT); -#[doc = "See [XrHandTrackerEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerEXT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct HandTrackerEXT(u64); -handle!(HandTrackerEXT); -#[doc = "See [XrFoveationProfileFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationProfileFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct FoveationProfileFB(u64); -handle!(FoveationProfileFB); -#[doc = "See [XrTriangleMeshFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct TriangleMeshFB(u64); -handle!(TriangleMeshFB); -#[doc = "See [XrPassthroughFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct PassthroughFB(u64); -handle!(PassthroughFB); -#[doc = "See [XrPassthroughLayerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughLayerFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct PassthroughLayerFB(u64); -handle!(PassthroughLayerFB); -#[doc = "See [XrGeometryInstanceFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceFB)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct GeometryInstanceFB(u64); -handle!(GeometryInstanceFB); -#[doc = "See [XrSpatialGraphNodeBindingMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingMSFT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct SpatialGraphNodeBindingMSFT(u64); -handle!(SpatialGraphNodeBindingMSFT); -#[doc = "See [XrSceneObserverMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneObserverMSFT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct SceneObserverMSFT(u64); -handle!(SceneObserverMSFT); -#[doc = "See [XrSceneMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneMSFT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct SceneMSFT(u64); -handle!(SceneMSFT); -#[doc = "See [XrSpatialAnchorStoreConnectionMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorStoreConnectionMSFT)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct SpatialAnchorStoreConnectionMSFT(u64); -handle!(SpatialAnchorStoreConnectionMSFT); -#[doc = "See [XrFacialTrackerHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerHTC)"] -#[repr(transparent)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct FacialTrackerHTC(u64); -handle!(FacialTrackerHTC); #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrVector2f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector2f)"] -pub struct Vector2f { - pub x: f32, - pub y: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrFrameEndInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameEndInfo)"] +pub struct FrameEndInfo { + pub ty: StructureType, + pub next: *const c_void, + pub display_time: Time, + pub environment_blend_mode: EnvironmentBlendMode, + pub layer_count: u32, + pub layers: *const *const CompositionLayerBaseHeader, +} +impl FrameEndInfo { + pub const TYPE: StructureType = StructureType::FRAME_END_INFO; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrVector3f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector3f)"] -pub struct Vector3f { - pub x: f32, - pub y: f32, - pub z: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrFrameWaitInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameWaitInfo)"] +pub struct FrameWaitInfo { + pub ty: StructureType, + pub next: *const c_void, +} +impl FrameWaitInfo { + pub const TYPE: StructureType = StructureType::FRAME_WAIT_INFO; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrVector4f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector4f)"] -pub struct Vector4f { - pub x: f32, - pub y: f32, - pub z: f32, - pub w: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrFrameState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameState)"] +pub struct FrameState { + pub ty: StructureType, + pub next: *mut c_void, + pub predicted_display_time: Time, + pub predicted_display_period: Duration, + pub should_render: Bool32, +} +impl FrameState { + pub const TYPE: StructureType = StructureType::FRAME_STATE; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrColor4f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrColor4f)"] -pub struct Color4f { - pub r: f32, - pub g: f32, - pub b: f32, - pub a: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrHapticBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticBaseHeader)"] +pub struct HapticBaseHeader { + pub ty: StructureType, + pub next: *const c_void, } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrQuaternionf](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrQuaternionf)"] -pub struct Quaternionf { - pub x: f32, - pub y: f32, - pub z: f32, - pub w: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrHapticVibration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticVibration)"] +pub struct HapticVibration { + pub ty: StructureType, + pub next: *const c_void, + pub duration: Duration, + pub frequency: f32, + pub amplitude: f32, +} +impl HapticVibration { + pub const TYPE: StructureType = StructureType::HAPTIC_VIBRATION; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrPosef](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPosef)"] -pub struct Posef { - pub orientation: Quaternionf, - pub position: Vector3f, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataBaseHeader)"] +pub struct EventDataBaseHeader { + pub ty: StructureType, + pub next: *const c_void, } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrOffset2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset2Df)"] -pub struct Offset2Df { - pub x: f32, - pub y: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataBuffer](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataBuffer)"] +pub struct EventDataBuffer { + pub ty: StructureType, + pub next: *const c_void, + pub varying: [u8; 4000usize], +} +impl EventDataBuffer { + pub const TYPE: StructureType = StructureType::EVENT_DATA_BUFFER; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrExtent2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent2Df)"] -pub struct Extent2Df { - pub width: f32, - pub height: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataEventsLost](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataEventsLost)"] +pub struct EventDataEventsLost { + pub ty: StructureType, + pub next: *const c_void, + pub lost_event_count: u32, } -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrRect2Df](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect2Df)"] -pub struct Rect2Df { - pub offset: Offset2Df, - pub extent: Extent2Df, +impl EventDataEventsLost { + pub const TYPE: StructureType = StructureType::EVENT_DATA_EVENTS_LOST; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrOffset2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset2Di)"] -pub struct Offset2Di { - pub x: i32, - pub y: i32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataInstanceLossPending](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataInstanceLossPending)"] +pub struct EventDataInstanceLossPending { + pub ty: StructureType, + pub next: *const c_void, + pub loss_time: Time, +} +impl EventDataInstanceLossPending { + pub const TYPE: StructureType = StructureType::EVENT_DATA_INSTANCE_LOSS_PENDING; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrExtent2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent2Di)"] -pub struct Extent2Di { - pub width: i32, - pub height: i32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataSessionStateChanged](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSessionStateChanged)"] +pub struct EventDataSessionStateChanged { + pub ty: StructureType, + pub next: *const c_void, + pub session: Session, + pub state: SessionState, + pub time: Time, +} +impl EventDataSessionStateChanged { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SESSION_STATE_CHANGED; } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrRect2Di](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect2Di)"] -pub struct Rect2Di { - pub offset: Offset2Di, - pub extent: Extent2Di, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataReferenceSpaceChangePending](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataReferenceSpaceChangePending)"] +pub struct EventDataReferenceSpaceChangePending { + pub ty: StructureType, + pub next: *const c_void, + pub session: Session, + pub reference_space_type: ReferenceSpaceType, + pub change_time: Time, + pub pose_valid: Bool32, + pub pose_in_previous_space: Posef, +} +impl EventDataReferenceSpaceChangePending { + pub const TYPE: StructureType = StructureType::EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBaseInStructure](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBaseInStructure)"] -pub struct BaseInStructure { +#[doc = "See [XrEventDataPerfSettingsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataPerfSettingsEXT) - defined by [XR_EXT_performance_settings](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_performance_settings)"] +pub struct EventDataPerfSettingsEXT { pub ty: StructureType, - pub next: *const BaseInStructure, + pub next: *const c_void, + pub domain: PerfSettingsDomainEXT, + pub sub_domain: PerfSettingsSubDomainEXT, + pub from_level: PerfSettingsNotificationLevelEXT, + pub to_level: PerfSettingsNotificationLevelEXT, +} +impl EventDataPerfSettingsEXT { + pub const TYPE: StructureType = StructureType::EVENT_DATA_PERF_SETTINGS_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBaseOutStructure](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBaseOutStructure)"] -pub struct BaseOutStructure { +#[doc = "See [XrEventDataVisibilityMaskChangedKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVisibilityMaskChangedKHR) - defined by [XR_KHR_visibility_mask](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask)"] +pub struct EventDataVisibilityMaskChangedKHR { pub ty: StructureType, - pub next: *mut BaseOutStructure, + pub next: *const c_void, + pub session: Session, + pub view_configuration_type: ViewConfigurationType, + pub view_index: u32, +} +impl EventDataVisibilityMaskChangedKHR { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrApiLayerProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrApiLayerProperties)"] -pub struct ApiLayerProperties { +#[doc = "See [XrViewConfigurationProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationProperties)"] +pub struct ViewConfigurationProperties { pub ty: StructureType, pub next: *mut c_void, - pub layer_name: [c_char; MAX_API_LAYER_NAME_SIZE], - pub spec_version: Version, - pub layer_version: u32, - pub description: [c_char; MAX_API_LAYER_DESCRIPTION_SIZE], + pub view_configuration_type: ViewConfigurationType, + pub fov_mutable: Bool32, } -impl ApiLayerProperties { - pub const TYPE: StructureType = StructureType::API_LAYER_PROPERTIES; +impl ViewConfigurationProperties { + pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_PROPERTIES; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3085,15 +5386,17 @@ impl ApiLayerProperties { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrExtensionProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtensionProperties)"] -pub struct ExtensionProperties { +#[doc = "See [XrActionStateBoolean](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateBoolean)"] +pub struct ActionStateBoolean { pub ty: StructureType, pub next: *mut c_void, - pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], - pub extension_version: u32, + pub current_state: Bool32, + pub changed_since_last_sync: Bool32, + pub last_change_time: Time, + pub is_active: Bool32, } -impl ExtensionProperties { - pub const TYPE: StructureType = StructureType::EXTENSION_PROPERTIES; +impl ActionStateBoolean { + pub const TYPE: StructureType = StructureType::ACTION_STATE_BOOLEAN; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3109,41 +5412,17 @@ impl ExtensionProperties { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrApplicationInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrApplicationInfo)"] -pub struct ApplicationInfo { - pub application_name: [c_char; MAX_APPLICATION_NAME_SIZE], - pub application_version: u32, - pub engine_name: [c_char; MAX_ENGINE_NAME_SIZE], - pub engine_version: u32, - pub api_version: Version, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrInstanceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateInfo)"] -pub struct InstanceCreateInfo { - pub ty: StructureType, - pub next: *const c_void, - pub create_flags: InstanceCreateFlags, - pub application_info: ApplicationInfo, - pub enabled_api_layer_count: u32, - pub enabled_api_layer_names: *const *const c_char, - pub enabled_extension_count: u32, - pub enabled_extension_names: *const *const c_char, -} -impl InstanceCreateInfo { - pub const TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrInstanceProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceProperties)"] -pub struct InstanceProperties { +#[doc = "See [XrActionStateFloat](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateFloat)"] +pub struct ActionStateFloat { pub ty: StructureType, pub next: *mut c_void, - pub runtime_version: Version, - pub runtime_name: [c_char; MAX_RUNTIME_NAME_SIZE], + pub current_state: f32, + pub changed_since_last_sync: Bool32, + pub last_change_time: Time, + pub is_active: Bool32, } -impl InstanceProperties { - pub const TYPE: StructureType = StructureType::INSTANCE_PROPERTIES; +impl ActionStateFloat { + pub const TYPE: StructureType = StructureType::ACTION_STATE_FLOAT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3159,29 +5438,40 @@ impl InstanceProperties { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemGetInfo)"] -pub struct SystemGetInfo { +#[doc = "See [XrActionStateVector2f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateVector2f)"] +pub struct ActionStateVector2f { pub ty: StructureType, - pub next: *const c_void, - pub form_factor: FormFactor, + pub next: *mut c_void, + pub current_state: Vector2f, + pub changed_since_last_sync: Bool32, + pub last_change_time: Time, + pub is_active: Bool32, } -impl SystemGetInfo { - pub const TYPE: StructureType = StructureType::SYSTEM_GET_INFO; +impl ActionStateVector2f { + pub const TYPE: StructureType = StructureType::ACTION_STATE_VECTOR2F; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemProperties)"] -pub struct SystemProperties { +#[doc = "See [XrActionStatePose](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStatePose)"] +pub struct ActionStatePose { pub ty: StructureType, pub next: *mut c_void, - pub system_id: SystemId, - pub vendor_id: u32, - pub system_name: [c_char; MAX_SYSTEM_NAME_SIZE], - pub graphics_properties: SystemGraphicsProperties, - pub tracking_properties: SystemTrackingProperties, + pub is_active: Bool32, } -impl SystemProperties { - pub const TYPE: StructureType = StructureType::SYSTEM_PROPERTIES; +impl ActionStatePose { + pub const TYPE: StructureType = StructureType::ACTION_STATE_POSE; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3196,192 +5486,285 @@ impl SystemProperties { } } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrSystemGraphicsProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemGraphicsProperties)"] -pub struct SystemGraphicsProperties { - pub max_swapchain_image_height: u32, - pub max_swapchain_image_width: u32, - pub max_layer_count: u32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrActionStateGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateGetInfo)"] +pub struct ActionStateGetInfo { + pub ty: StructureType, + pub next: *const c_void, + pub action: Action, + pub subaction_path: Path, +} +impl ActionStateGetInfo { + pub const TYPE: StructureType = StructureType::ACTION_STATE_GET_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrHapticActionInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticActionInfo)"] +pub struct HapticActionInfo { + pub ty: StructureType, + pub next: *const c_void, + pub action: Action, + pub subaction_path: Path, +} +impl HapticActionInfo { + pub const TYPE: StructureType = StructureType::HAPTIC_ACTION_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrActionSetCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSetCreateInfo)"] +pub struct ActionSetCreateInfo { + pub ty: StructureType, + pub next: *const c_void, + pub action_set_name: [c_char; MAX_ACTION_SET_NAME_SIZE], + pub localized_action_set_name: [c_char; MAX_LOCALIZED_ACTION_SET_NAME_SIZE], + pub priority: u32, +} +impl ActionSetCreateInfo { + pub const TYPE: StructureType = StructureType::ACTION_SET_CREATE_INFO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrActionSuggestedBinding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSuggestedBinding)"] +pub struct ActionSuggestedBinding { + pub action: Action, + pub binding: Path, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrInteractionProfileSuggestedBinding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileSuggestedBinding)"] +pub struct InteractionProfileSuggestedBinding { + pub ty: StructureType, + pub next: *const c_void, + pub interaction_profile: Path, + pub count_suggested_bindings: u32, + pub suggested_bindings: *const ActionSuggestedBinding, +} +impl InteractionProfileSuggestedBinding { + pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_SUGGESTED_BINDING; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrActiveActionSet](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActiveActionSet)"] +pub struct ActiveActionSet { + pub action_set: ActionSet, + pub subaction_path: Path, } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrSystemTrackingProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemTrackingProperties)"] -pub struct SystemTrackingProperties { - pub orientation_tracking: Bool32, - pub position_tracking: Bool32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSessionActionSetsAttachInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionActionSetsAttachInfo)"] +pub struct SessionActionSetsAttachInfo { + pub ty: StructureType, + pub next: *const c_void, + pub count_action_sets: u32, + pub action_sets: *const ActionSet, +} +impl SessionActionSetsAttachInfo { + pub const TYPE: StructureType = StructureType::SESSION_ACTION_SETS_ATTACH_INFO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingOpenGLWin32KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLWin32KHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -#[cfg(windows)] -pub struct GraphicsBindingOpenGLWin32KHR { +#[doc = "See [XrActionsSyncInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionsSyncInfo)"] +pub struct ActionsSyncInfo { pub ty: StructureType, pub next: *const c_void, - pub h_dc: HDC, - pub h_glrc: HGLRC, + pub count_active_action_sets: u32, + pub active_action_sets: *const ActiveActionSet, } -#[cfg(windows)] -impl GraphicsBindingOpenGLWin32KHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_WIN32_KHR; +impl ActionsSyncInfo { + pub const TYPE: StructureType = StructureType::ACTIONS_SYNC_INFO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingOpenGLXlibKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLXlibKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -pub struct GraphicsBindingOpenGLXlibKHR { +#[doc = "See [XrBoundSourcesForActionEnumerateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBoundSourcesForActionEnumerateInfo)"] +pub struct BoundSourcesForActionEnumerateInfo { pub ty: StructureType, pub next: *const c_void, - pub x_display: *mut Display, - pub visualid: u32, - pub glx_fb_config: GLXFBConfig, - pub glx_drawable: GLXDrawable, - pub glx_context: GLXContext, + pub action: Action, } -impl GraphicsBindingOpenGLXlibKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_XLIB_KHR; +impl BoundSourcesForActionEnumerateInfo { + pub const TYPE: StructureType = StructureType::BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingOpenGLXcbKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLXcbKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -pub struct GraphicsBindingOpenGLXcbKHR { +#[doc = "See [XrInputSourceLocalizedNameGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInputSourceLocalizedNameGetInfo)"] +pub struct InputSourceLocalizedNameGetInfo { pub ty: StructureType, pub next: *const c_void, - pub connection: *mut xcb_connection_t, - pub screen_number: u32, - pub fbconfigid: xcb_glx_fbconfig_t, - pub visualid: xcb_visualid_t, - pub glx_drawable: xcb_glx_drawable_t, - pub glx_context: xcb_glx_context_t, + pub source_path: Path, + pub which_components: InputSourceLocalizedNameFlags, } -impl GraphicsBindingOpenGLXcbKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_XCB_KHR; +impl InputSourceLocalizedNameGetInfo { + pub const TYPE: StructureType = StructureType::INPUT_SOURCE_LOCALIZED_NAME_GET_INFO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingOpenGLWaylandKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLWaylandKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -pub struct GraphicsBindingOpenGLWaylandKHR { +#[doc = "See [XrEventDataInteractionProfileChanged](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataInteractionProfileChanged)"] +pub struct EventDataInteractionProfileChanged { pub ty: StructureType, pub next: *const c_void, - pub display: *mut wl_display, + pub session: Session, } -impl GraphicsBindingOpenGLWaylandKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_WAYLAND_KHR; +impl EventDataInteractionProfileChanged { + pub const TYPE: StructureType = StructureType::EVENT_DATA_INTERACTION_PROFILE_CHANGED; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] -#[cfg(windows)] -pub struct GraphicsBindingD3D11KHR { +#[doc = "See [XrInteractionProfileState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileState)"] +pub struct InteractionProfileState { pub ty: StructureType, - pub next: *const c_void, - pub device: *mut ID3D11Device, + pub next: *mut c_void, + pub interaction_profile: Path, } -#[cfg(windows)] -impl GraphicsBindingD3D11KHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_D3D11_KHR; +impl InteractionProfileState { + pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_STATE; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] -#[cfg(windows)] -pub struct GraphicsBindingD3D12KHR { +#[doc = "See [XrActionCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionCreateInfo)"] +pub struct ActionCreateInfo { pub ty: StructureType, pub next: *const c_void, - pub device: *mut ID3D12Device, - pub queue: *mut ID3D12CommandQueue, + pub action_name: [c_char; MAX_ACTION_NAME_SIZE], + pub action_type: ActionType, + pub count_subaction_paths: u32, + pub subaction_paths: *const Path, + pub localized_action_name: [c_char; MAX_LOCALIZED_ACTION_NAME_SIZE], } -#[cfg(windows)] -impl GraphicsBindingD3D12KHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_D3D12_KHR; +impl ActionCreateInfo { + pub const TYPE: StructureType = StructureType::ACTION_CREATE_INFO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingOpenGLESAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingOpenGLESAndroidKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] +#[doc = "See [XrInstanceCreateInfoAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateInfoAndroidKHR) - defined by [XR_KHR_android_create_instance](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_android_create_instance)"] #[cfg(target_os = "android")] -pub struct GraphicsBindingOpenGLESAndroidKHR { +pub struct InstanceCreateInfoAndroidKHR { pub ty: StructureType, pub next: *const c_void, - pub display: EGLDisplay, - pub config: EGLConfig, - pub context: EGLContext, + pub application_vm: *mut c_void, + pub application_activity: *mut c_void, } #[cfg(target_os = "android")] -impl GraphicsBindingOpenGLESAndroidKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR; +impl InstanceCreateInfoAndroidKHR { + pub const TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO_ANDROID_KHR; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsBindingVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] -pub struct GraphicsBindingVulkanKHR { +#[doc = "See [XrVulkanSwapchainFormatListCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanSwapchainFormatListCreateInfoKHR) - defined by [XR_KHR_vulkan_swapchain_format_list](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_swapchain_format_list)"] +pub struct VulkanSwapchainFormatListCreateInfoKHR { pub ty: StructureType, pub next: *const c_void, - pub instance: VkInstance, - pub physical_device: VkPhysicalDevice, - pub device: VkDevice, - pub queue_family_index: u32, - pub queue_index: u32, + pub view_format_count: u32, + pub view_formats: *const VkFormat, } -impl GraphicsBindingVulkanKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_VULKAN_KHR; +impl VulkanSwapchainFormatListCreateInfoKHR { + pub const TYPE: StructureType = StructureType::VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSessionCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateInfo)"] -pub struct SessionCreateInfo { +#[doc = "See [XrDebugUtilsObjectNameInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsObjectNameInfoEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] +pub struct DebugUtilsObjectNameInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub create_flags: SessionCreateFlags, - pub system_id: SystemId, + pub object_type: ObjectType, + pub object_handle: u64, + pub object_name: *const c_char, } -impl SessionCreateInfo { - pub const TYPE: StructureType = StructureType::SESSION_CREATE_INFO; +impl DebugUtilsObjectNameInfoEXT { + pub const TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSessionBeginInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionBeginInfo)"] -pub struct SessionBeginInfo { +#[doc = "See [XrDebugUtilsLabelEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsLabelEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] +pub struct DebugUtilsLabelEXT { pub ty: StructureType, pub next: *const c_void, - pub primary_view_configuration_type: ViewConfigurationType, + pub label_name: *const c_char, } -impl SessionBeginInfo { - pub const TYPE: StructureType = StructureType::SESSION_BEGIN_INFO; +impl DebugUtilsLabelEXT { + pub const TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateInfo)"] -pub struct SwapchainCreateInfo { +#[doc = "See [XrDebugUtilsMessengerCallbackDataEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerCallbackDataEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] +pub struct DebugUtilsMessengerCallbackDataEXT { pub ty: StructureType, pub next: *const c_void, - pub create_flags: SwapchainCreateFlags, - pub usage_flags: SwapchainUsageFlags, - pub format: i64, - pub sample_count: u32, - pub width: u32, - pub height: u32, - pub face_count: u32, - pub array_size: u32, - pub mip_count: u32, + pub message_id: *const c_char, + pub function_name: *const c_char, + pub message: *const c_char, + pub object_count: u32, + pub objects: *mut DebugUtilsObjectNameInfoEXT, + pub session_label_count: u32, + pub session_labels: *mut DebugUtilsLabelEXT, } -impl SwapchainCreateInfo { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO; +impl DebugUtilsMessengerCallbackDataEXT { + pub const TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = "See [XrDebugUtilsMessengerCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerCreateInfoEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] +pub struct DebugUtilsMessengerCreateInfoEXT { + pub ty: StructureType, + pub next: *const c_void, + pub message_severities: DebugUtilsMessageSeverityFlagsEXT, + pub message_types: DebugUtilsMessageTypeFlagsEXT, + pub user_callback: Option, + pub user_data: *mut c_void, +} +impl DebugUtilsMessengerCreateInfoEXT { + pub const TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageBaseHeader)"] -pub struct SwapchainImageBaseHeader { +#[doc = "See [XrVisibilityMaskKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVisibilityMaskKHR) - defined by [XR_KHR_visibility_mask](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask)"] +pub struct VisibilityMaskKHR { pub ty: StructureType, pub next: *mut c_void, + pub vertex_capacity_input: u32, + pub vertex_count_output: u32, + pub vertices: *mut Vector2f, + pub index_capacity_input: u32, + pub index_count_output: u32, + pub indices: *mut u32, +} +impl VisibilityMaskKHR { + pub const TYPE: StructureType = StructureType::VISIBILITY_MASK_KHR; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageOpenGLKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageOpenGLKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -pub struct SwapchainImageOpenGLKHR { +#[doc = "See [XrGraphicsRequirementsOpenGLKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsOpenGLKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] +pub struct GraphicsRequirementsOpenGLKHR { pub ty: StructureType, pub next: *mut c_void, - pub image: u32, + pub min_api_version_supported: Version, + pub max_api_version_supported: Version, } -impl SwapchainImageOpenGLKHR { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_OPENGL_KHR; +impl GraphicsRequirementsOpenGLKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_OPENGL_KHR; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3397,14 +5780,15 @@ impl SwapchainImageOpenGLKHR { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageOpenGLESKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageOpenGLESKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] -pub struct SwapchainImageOpenGLESKHR { +#[doc = "See [XrGraphicsRequirementsOpenGLESKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsOpenGLESKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] +pub struct GraphicsRequirementsOpenGLESKHR { pub ty: StructureType, pub next: *mut c_void, - pub image: u32, + pub min_api_version_supported: Version, + pub max_api_version_supported: Version, } -impl SwapchainImageOpenGLESKHR { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_OPENGL_ES_KHR; +impl GraphicsRequirementsOpenGLESKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3420,14 +5804,15 @@ impl SwapchainImageOpenGLESKHR { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] -pub struct SwapchainImageVulkanKHR { +#[doc = "See [XrGraphicsRequirementsVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] +pub struct GraphicsRequirementsVulkanKHR { pub ty: StructureType, pub next: *mut c_void, - pub image: VkImage, + pub min_api_version_supported: Version, + pub max_api_version_supported: Version, } -impl SwapchainImageVulkanKHR { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_VULKAN_KHR; +impl GraphicsRequirementsVulkanKHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_VULKAN_KHR; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3442,17 +5827,18 @@ impl SwapchainImageVulkanKHR { } } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] +#[derive(Copy, Clone)] +#[doc = "See [XrGraphicsRequirementsD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] #[cfg(windows)] -pub struct SwapchainImageD3D11KHR { +pub struct GraphicsRequirementsD3D11KHR { pub ty: StructureType, pub next: *mut c_void, - pub texture: *mut ID3D11Texture2D, + pub adapter_luid: LUID, + pub min_feature_level: D3D_FEATURE_LEVEL, } #[cfg(windows)] -impl SwapchainImageD3D11KHR { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_D3D11_KHR; +impl GraphicsRequirementsD3D11KHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_D3D11_KHR; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3467,17 +5853,18 @@ impl SwapchainImageD3D11KHR { } } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] +#[derive(Copy, Clone)] +#[doc = "See [XrGraphicsRequirementsD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] #[cfg(windows)] -pub struct SwapchainImageD3D12KHR { +pub struct GraphicsRequirementsD3D12KHR { pub ty: StructureType, pub next: *mut c_void, - pub texture: *mut ID3D12Resource, + pub adapter_luid: LUID, + pub min_feature_level: D3D_FEATURE_LEVEL, } #[cfg(windows)] -impl SwapchainImageD3D12KHR { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_D3D12_KHR; +impl GraphicsRequirementsD3D12KHR { + pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_D3D12_KHR; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3492,72 +5879,109 @@ impl SwapchainImageD3D12KHR { } } #[repr(C)] +#[derive(Copy, Clone)] +#[doc = "See [XrVulkanInstanceCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanInstanceCreateInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] +pub struct VulkanInstanceCreateInfoKHR { + pub ty: StructureType, + pub next: *const c_void, + pub system_id: SystemId, + pub create_flags: VulkanInstanceCreateFlagsKHR, + pub pfn_get_instance_proc_addr: Option, + pub vulkan_create_info: *const VkInstanceCreateInfo, + pub vulkan_allocator: *const VkAllocationCallbacks, +} +impl VulkanInstanceCreateInfoKHR { + pub const TYPE: StructureType = StructureType::VULKAN_INSTANCE_CREATE_INFO_KHR; +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = "See [XrVulkanDeviceCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanDeviceCreateInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] +pub struct VulkanDeviceCreateInfoKHR { + pub ty: StructureType, + pub next: *const c_void, + pub system_id: SystemId, + pub create_flags: VulkanDeviceCreateFlagsKHR, + pub pfn_get_instance_proc_addr: Option, + pub vulkan_physical_device: VkPhysicalDevice, + pub vulkan_create_info: *const VkDeviceCreateInfo, + pub vulkan_allocator: *const VkAllocationCallbacks, +} +impl VulkanDeviceCreateInfoKHR { + pub const TYPE: StructureType = StructureType::VULKAN_DEVICE_CREATE_INFO_KHR; +} +#[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageAcquireInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageAcquireInfo)"] -pub struct SwapchainImageAcquireInfo { +#[doc = "See [XrVulkanGraphicsDeviceGetInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanGraphicsDeviceGetInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] +pub struct VulkanGraphicsDeviceGetInfoKHR { pub ty: StructureType, pub next: *const c_void, + pub system_id: SystemId, + pub vulkan_instance: VkInstance, } -impl SwapchainImageAcquireInfo { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_ACQUIRE_INFO; +impl VulkanGraphicsDeviceGetInfoKHR { + pub const TYPE: StructureType = StructureType::VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageWaitInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageWaitInfo)"] -pub struct SwapchainImageWaitInfo { +#[doc = "See [XrVulkanSwapchainCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanSwapchainCreateInfoMETA) - defined by [XR_META_vulkan_swapchain_create_info](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_vulkan_swapchain_create_info)"] +pub struct VulkanSwapchainCreateInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub timeout: Duration, + pub additional_create_flags: VkImageCreateFlags, + pub additional_usage_flags: VkImageUsageFlags, } -impl SwapchainImageWaitInfo { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_WAIT_INFO; +impl VulkanSwapchainCreateInfoMETA { + pub const TYPE: StructureType = StructureType::VULKAN_SWAPCHAIN_CREATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageReleaseInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageReleaseInfo)"] -pub struct SwapchainImageReleaseInfo { +#[doc = "See [XrSessionCreateInfoOverlayEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateInfoOverlayEXTX) - defined by [XR_EXTX_overlay](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXTX_overlay)"] +pub struct SessionCreateInfoOverlayEXTX { pub ty: StructureType, pub next: *const c_void, + pub create_flags: OverlaySessionCreateFlagsEXTX, + pub session_layers_placement: u32, } -impl SwapchainImageReleaseInfo { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_RELEASE_INFO; +impl SessionCreateInfoOverlayEXTX { + pub const TYPE: StructureType = StructureType::SESSION_CREATE_INFO_OVERLAY_EXTX; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrReferenceSpaceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrReferenceSpaceCreateInfo)"] -pub struct ReferenceSpaceCreateInfo { +#[doc = "See [XrEventDataMainSessionVisibilityChangedEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataMainSessionVisibilityChangedEXTX) - defined by [XR_EXTX_overlay](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXTX_overlay)"] +pub struct EventDataMainSessionVisibilityChangedEXTX { pub ty: StructureType, pub next: *const c_void, - pub reference_space_type: ReferenceSpaceType, - pub pose_in_reference_space: Posef, + pub visible: Bool32, + pub flags: OverlayMainSessionFlagsEXTX, } -impl ReferenceSpaceCreateInfo { - pub const TYPE: StructureType = StructureType::REFERENCE_SPACE_CREATE_INFO; +impl EventDataMainSessionVisibilityChangedEXTX { + pub const TYPE: StructureType = StructureType::EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionSpaceCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSpaceCreateInfo)"] -pub struct ActionSpaceCreateInfo { +#[doc = "See [XrEventDataDisplayRefreshRateChangedFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataDisplayRefreshRateChangedFB) - defined by [XR_FB_display_refresh_rate](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_display_refresh_rate)"] +pub struct EventDataDisplayRefreshRateChangedFB { pub ty: StructureType, pub next: *const c_void, - pub action: Action, - pub subaction_path: Path, - pub pose_in_action_space: Posef, + pub from_display_refresh_rate: f32, + pub to_display_refresh_rate: f32, } -impl ActionSpaceCreateInfo { - pub const TYPE: StructureType = StructureType::ACTION_SPACE_CREATE_INFO; +impl EventDataDisplayRefreshRateChangedFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceLocation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceLocation)"] -pub struct SpaceLocation { +#[doc = "See [XrViewConfigurationDepthRangeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationDepthRangeEXT) - defined by [XR_EXT_view_configuration_depth_range](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_view_configuration_depth_range)"] +pub struct ViewConfigurationDepthRangeEXT { pub ty: StructureType, pub next: *mut c_void, - pub location_flags: SpaceLocationFlags, - pub pose: Posef, + pub recommended_near_z: f32, + pub min_near_z: f32, + pub recommended_far_z: f32, + pub max_far_z: f32, } -impl SpaceLocation { - pub const TYPE: StructureType = StructureType::SPACE_LOCATION; +impl ViewConfigurationDepthRangeEXT { + pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_DEPTH_RANGE_EXT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3573,16 +5997,80 @@ impl SpaceLocation { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceVelocity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceVelocity)"] -pub struct SpaceVelocity { +#[doc = "See [XrViewConfigurationViewFovEPIC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationViewFovEPIC) - defined by [XR_EPIC_view_configuration_fov](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EPIC_view_configuration_fov)"] +pub struct ViewConfigurationViewFovEPIC { + pub ty: StructureType, + pub next: *const c_void, + pub recommended_fov: Fovf, + pub max_mutable_fov: Fovf, +} +impl ViewConfigurationViewFovEPIC { + pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_VIEW_FOV_EPIC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrInteractionProfileDpadBindingEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileDpadBindingEXT) - defined by [XR_EXT_dpad_binding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_dpad_binding)"] +pub struct InteractionProfileDpadBindingEXT { + pub ty: StructureType, + pub next: *const c_void, + pub binding: Path, + pub action_set: ActionSet, + pub force_threshold: f32, + pub force_threshold_released: f32, + pub center_region: f32, + pub wedge_angle: f32, + pub is_sticky: Bool32, + pub on_haptic: *const HapticBaseHeader, + pub off_haptic: *const HapticBaseHeader, +} +impl InteractionProfileDpadBindingEXT { + pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_DPAD_BINDING_EXT; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrInteractionProfileAnalogThresholdVALVE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileAnalogThresholdVALVE) - defined by [XR_VALVE_analog_threshold](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VALVE_analog_threshold)"] +pub struct InteractionProfileAnalogThresholdVALVE { + pub ty: StructureType, + pub next: *const c_void, + pub action: Action, + pub binding: Path, + pub on_threshold: f32, + pub off_threshold: f32, + pub on_haptic: *const HapticBaseHeader, + pub off_haptic: *const HapticBaseHeader, +} +impl InteractionProfileAnalogThresholdVALVE { + pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBindingModificationsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBindingModificationsKHR) - defined by [XR_KHR_binding_modification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_binding_modification)"] +pub struct BindingModificationsKHR { + pub ty: StructureType, + pub next: *const c_void, + pub binding_modification_count: u32, + pub binding_modifications: *const *const BindingModificationBaseHeaderKHR, +} +impl BindingModificationsKHR { + pub const TYPE: StructureType = StructureType::BINDING_MODIFICATIONS_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBindingModificationBaseHeaderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBindingModificationBaseHeaderKHR) - defined by [XR_KHR_binding_modification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_binding_modification)"] +pub struct BindingModificationBaseHeaderKHR { + pub ty: StructureType, + pub next: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemEyeGazeInteractionPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemEyeGazeInteractionPropertiesEXT) - defined by [XR_EXT_eye_gaze_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_eye_gaze_interaction)"] +pub struct SystemEyeGazeInteractionPropertiesEXT { pub ty: StructureType, pub next: *mut c_void, - pub velocity_flags: SpaceVelocityFlags, - pub linear_velocity: Vector3f, - pub angular_velocity: Vector3f, + pub supports_eye_gaze_interaction: Bool32, } -impl SpaceVelocity { - pub const TYPE: StructureType = StructureType::SPACE_VELOCITY; +impl SystemEyeGazeInteractionPropertiesEXT { + pub const TYPE: StructureType = StructureType::SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3597,25 +6085,15 @@ impl SpaceVelocity { } } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrFovf](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFovf)"] -pub struct Fovf { - pub angle_left: f32, - pub angle_right: f32, - pub angle_up: f32, - pub angle_down: f32, -} -#[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrView)"] -pub struct View { +#[doc = "See [XrEyeGazeSampleTimeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeGazeSampleTimeEXT) - defined by [XR_EXT_eye_gaze_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_eye_gaze_interaction)"] +pub struct EyeGazeSampleTimeEXT { pub ty: StructureType, pub next: *mut c_void, - pub pose: Posef, - pub fov: Fovf, + pub time: Time, } -impl View { - pub const TYPE: StructureType = StructureType::VIEW; +impl EyeGazeSampleTimeEXT { + pub const TYPE: StructureType = StructureType::EYE_GAZE_SAMPLE_TIME_EXT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3631,27 +6109,39 @@ impl View { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewLocateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewLocateInfo)"] -pub struct ViewLocateInfo { +#[doc = "See [XrSpatialAnchorCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorCreateInfoMSFT)"] +pub struct SpatialAnchorCreateInfoMSFT { + pub ty: StructureType, + pub next: *const c_void, + pub space: Space, + pub pose: Posef, + pub time: Time, +} +impl SpatialAnchorCreateInfoMSFT { + pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_CREATE_INFO_MSFT; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSpatialAnchorSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorSpaceCreateInfoMSFT)"] +pub struct SpatialAnchorSpaceCreateInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub view_configuration_type: ViewConfigurationType, - pub display_time: Time, - pub space: Space, + pub anchor: SpatialAnchorMSFT, + pub pose_in_anchor_space: Posef, } -impl ViewLocateInfo { - pub const TYPE: StructureType = StructureType::VIEW_LOCATE_INFO; +impl SpatialAnchorSpaceCreateInfoMSFT { + pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewState)"] -pub struct ViewState { +#[doc = "See [XrCompositionLayerImageLayoutFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerImageLayoutFB) - defined by [XR_FB_composition_layer_image_layout](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_image_layout)"] +pub struct CompositionLayerImageLayoutFB { pub ty: StructureType, pub next: *mut c_void, - pub view_state_flags: ViewStateFlags, + pub flags: CompositionLayerImageLayoutFlagsFB, } -impl ViewState { - pub const TYPE: StructureType = StructureType::VIEW_STATE; +impl CompositionLayerImageLayoutFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_IMAGE_LAYOUT_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3667,19 +6157,17 @@ impl ViewState { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewConfigurationView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationView)"] -pub struct ViewConfigurationView { +#[doc = "See [XrCompositionLayerAlphaBlendFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerAlphaBlendFB) - defined by [XR_FB_composition_layer_alpha_blend](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_alpha_blend)"] +pub struct CompositionLayerAlphaBlendFB { pub ty: StructureType, pub next: *mut c_void, - pub recommended_image_rect_width: u32, - pub max_image_rect_width: u32, - pub recommended_image_rect_height: u32, - pub max_image_rect_height: u32, - pub recommended_swapchain_sample_count: u32, - pub max_swapchain_sample_count: u32, + pub src_factor_color: BlendFactorFB, + pub dst_factor_color: BlendFactorFB, + pub src_factor_alpha: BlendFactorFB, + pub dst_factor_alpha: BlendFactorFB, } -impl ViewConfigurationView { - pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_VIEW; +impl CompositionLayerAlphaBlendFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_ALPHA_BLEND_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3694,178 +6182,180 @@ impl ViewConfigurationView { } } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainSubImage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainSubImage)"] -pub struct SwapchainSubImage { - pub swapchain: Swapchain, - pub image_rect: Rect2Di, - pub image_array_index: u32, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerBaseHeader)"] -pub struct CompositionLayerBaseHeader { +#[derive(Copy, Clone)] +#[doc = "See [XrGraphicsBindingEGLMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingEGLMNDX) - defined by [XR_MNDX_egl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_egl_enable)"] +pub struct GraphicsBindingEGLMNDX { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, - pub space: Space, + pub get_proc_address: Option, + pub display: EGLDisplay, + pub config: EGLConfig, + pub context: EGLContext, +} +impl GraphicsBindingEGLMNDX { + pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_EGL_MNDX; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerProjectionView](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerProjectionView)"] -pub struct CompositionLayerProjectionView { +#[doc = "See [XrSpatialGraphNodeSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeSpaceCreateInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] +pub struct SpatialGraphNodeSpaceCreateInfoMSFT { pub ty: StructureType, pub next: *const c_void, + pub node_type: SpatialGraphNodeTypeMSFT, + pub node_id: [u8; GUID_SIZE_MSFT], pub pose: Posef, - pub fov: Fovf, - pub sub_image: SwapchainSubImage, } -impl CompositionLayerProjectionView { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PROJECTION_VIEW; +impl SpatialGraphNodeSpaceCreateInfoMSFT { + pub const TYPE: StructureType = StructureType::SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerProjection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerProjection)"] -pub struct CompositionLayerProjection { +#[doc = "See [XrSpatialGraphStaticNodeBindingCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphStaticNodeBindingCreateInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] +pub struct SpatialGraphStaticNodeBindingCreateInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, pub space: Space, - pub view_count: u32, - pub views: *const CompositionLayerProjectionView, + pub pose_in_space: Posef, + pub time: Time, } -impl CompositionLayerProjection { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PROJECTION; +impl SpatialGraphStaticNodeBindingCreateInfoMSFT { + pub const TYPE: StructureType = + StructureType::SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerQuad](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerQuad)"] -pub struct CompositionLayerQuad { +#[doc = "See [XrSpatialGraphNodeBindingPropertiesGetInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingPropertiesGetInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] +pub struct SpatialGraphNodeBindingPropertiesGetInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, - pub space: Space, - pub eye_visibility: EyeVisibility, - pub sub_image: SwapchainSubImage, - pub pose: Posef, - pub size: Extent2Df, } -impl CompositionLayerQuad { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_QUAD; +impl SpatialGraphNodeBindingPropertiesGetInfoMSFT { + pub const TYPE: StructureType = + StructureType::SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerCylinderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerCylinderKHR) - defined by [XR_KHR_composition_layer_cylinder](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_cylinder)"] -pub struct CompositionLayerCylinderKHR { +#[doc = "See [XrSpatialGraphNodeBindingPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingPropertiesMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] +pub struct SpatialGraphNodeBindingPropertiesMSFT { pub ty: StructureType, - pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, - pub space: Space, - pub eye_visibility: EyeVisibility, - pub sub_image: SwapchainSubImage, - pub pose: Posef, - pub radius: f32, - pub central_angle: f32, - pub aspect_ratio: f32, + pub next: *mut c_void, + pub node_id: [u8; GUID_SIZE_MSFT], + pub pose_in_node_space: Posef, } -impl CompositionLayerCylinderKHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_CYLINDER_KHR; +impl SpatialGraphNodeBindingPropertiesMSFT { + pub const TYPE: StructureType = StructureType::SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerCubeKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerCubeKHR) - defined by [XR_KHR_composition_layer_cube](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_cube)"] -pub struct CompositionLayerCubeKHR { +#[doc = "See [XrSystemHandTrackingPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHandTrackingPropertiesEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct SystemHandTrackingPropertiesEXT { pub ty: StructureType, - pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, - pub space: Space, - pub eye_visibility: EyeVisibility, - pub swapchain: Swapchain, - pub image_array_index: u32, - pub orientation: Quaternionf, + pub next: *mut c_void, + pub supports_hand_tracking: Bool32, } -impl CompositionLayerCubeKHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_CUBE_KHR; +impl SystemHandTrackingPropertiesEXT { + pub const TYPE: StructureType = StructureType::SYSTEM_HAND_TRACKING_PROPERTIES_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerEquirectKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerEquirectKHR) - defined by [XR_KHR_composition_layer_equirect](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_equirect)"] -pub struct CompositionLayerEquirectKHR { +#[doc = "See [XrHandTrackerCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerCreateInfoEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandTrackerCreateInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, - pub space: Space, - pub eye_visibility: EyeVisibility, - pub sub_image: SwapchainSubImage, - pub pose: Posef, - pub radius: f32, - pub scale: Vector2f, - pub bias: Vector2f, + pub hand: HandEXT, + pub hand_joint_set: HandJointSetEXT, } -impl CompositionLayerEquirectKHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_EQUIRECT_KHR; +impl HandTrackerCreateInfoEXT { + pub const TYPE: StructureType = StructureType::HAND_TRACKER_CREATE_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerDepthInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerDepthInfoKHR) - defined by [XR_KHR_composition_layer_depth](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_depth)"] -pub struct CompositionLayerDepthInfoKHR { +#[doc = "See [XrHandJointsLocateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsLocateInfoEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandJointsLocateInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub sub_image: SwapchainSubImage, - pub min_depth: f32, - pub max_depth: f32, - pub near_z: f32, - pub far_z: f32, + pub base_space: Space, + pub time: Time, } -impl CompositionLayerDepthInfoKHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_DEPTH_INFO_KHR; +impl HandJointsLocateInfoEXT { + pub const TYPE: StructureType = StructureType::HAND_JOINTS_LOCATE_INFO_EXT; } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrFrameBeginInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameBeginInfo)"] -pub struct FrameBeginInfo { - pub ty: StructureType, - pub next: *const c_void, -} -impl FrameBeginInfo { - pub const TYPE: StructureType = StructureType::FRAME_BEGIN_INFO; +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrHandJointLocationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandJointLocationEXT { + pub location_flags: SpaceLocationFlags, + pub pose: Posef, + pub radius: f32, } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrFrameEndInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameEndInfo)"] -pub struct FrameEndInfo { - pub ty: StructureType, - pub next: *const c_void, - pub display_time: Time, - pub environment_blend_mode: EnvironmentBlendMode, - pub layer_count: u32, - pub layers: *const *const CompositionLayerBaseHeader, -} -impl FrameEndInfo { - pub const TYPE: StructureType = StructureType::FRAME_END_INFO; +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrHandJointVelocityEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocityEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandJointVelocityEXT { + pub velocity_flags: SpaceVelocityFlags, + pub linear_velocity: Vector3f, + pub angular_velocity: Vector3f, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFrameWaitInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameWaitInfo)"] -pub struct FrameWaitInfo { +#[doc = "See [XrHandJointLocationsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationsEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandJointLocationsEXT { pub ty: StructureType, - pub next: *const c_void, + pub next: *mut c_void, + pub is_active: Bool32, + pub joint_count: u32, + pub joint_locations: *mut HandJointLocationEXT, } -impl FrameWaitInfo { - pub const TYPE: StructureType = StructureType::FRAME_WAIT_INFO; +impl HandJointLocationsEXT { + pub const TYPE: StructureType = StructureType::HAND_JOINT_LOCATIONS_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFrameState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameState)"] -pub struct FrameState { +#[doc = "See [XrHandJointVelocitiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocitiesEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] +pub struct HandJointVelocitiesEXT { pub ty: StructureType, pub next: *mut c_void, - pub predicted_display_time: Time, - pub predicted_display_period: Duration, - pub should_render: Bool32, + pub joint_count: u32, + pub joint_velocities: *mut HandJointVelocityEXT, } -impl FrameState { - pub const TYPE: StructureType = StructureType::FRAME_STATE; +impl HandJointVelocitiesEXT { + pub const TYPE: StructureType = StructureType::HAND_JOINT_VELOCITIES_EXT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -3881,130 +6371,94 @@ impl FrameState { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHapticBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticBaseHeader)"] -pub struct HapticBaseHeader { - pub ty: StructureType, - pub next: *const c_void, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrHapticVibration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticVibration)"] -pub struct HapticVibration { - pub ty: StructureType, - pub next: *const c_void, - pub duration: Duration, - pub frequency: f32, - pub amplitude: f32, -} -impl HapticVibration { - pub const TYPE: StructureType = StructureType::HAPTIC_VIBRATION; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataBaseHeader](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataBaseHeader)"] -pub struct EventDataBaseHeader { - pub ty: StructureType, - pub next: *const c_void, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataBuffer](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataBuffer)"] -pub struct EventDataBuffer { - pub ty: StructureType, - pub next: *const c_void, - pub varying: [u8; 4000usize], -} -impl EventDataBuffer { - pub const TYPE: StructureType = StructureType::EVENT_DATA_BUFFER; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataEventsLost](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataEventsLost)"] -pub struct EventDataEventsLost { +#[doc = "See [XrSystemFaceTrackingPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFaceTrackingPropertiesFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] +pub struct SystemFaceTrackingPropertiesFB { pub ty: StructureType, - pub next: *const c_void, - pub lost_event_count: u32, + pub next: *mut c_void, + pub supports_face_tracking: Bool32, } -impl EventDataEventsLost { - pub const TYPE: StructureType = StructureType::EVENT_DATA_EVENTS_LOST; +impl SystemFaceTrackingPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_FACE_TRACKING_PROPERTIES_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataInstanceLossPending](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataInstanceLossPending)"] -pub struct EventDataInstanceLossPending { +#[doc = "See [XrFaceTrackerCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceTrackerCreateInfoFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] +pub struct FaceTrackerCreateInfoFB { pub ty: StructureType, pub next: *const c_void, - pub loss_time: Time, + pub face_expression_set: FaceExpressionSetFB, } -impl EventDataInstanceLossPending { - pub const TYPE: StructureType = StructureType::EVENT_DATA_INSTANCE_LOSS_PENDING; +impl FaceTrackerCreateInfoFB { + pub const TYPE: StructureType = StructureType::FACE_TRACKER_CREATE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSessionStateChanged](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSessionStateChanged)"] -pub struct EventDataSessionStateChanged { +#[doc = "See [XrFaceExpressionInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceExpressionInfoFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] +pub struct FaceExpressionInfoFB { pub ty: StructureType, pub next: *const c_void, - pub session: Session, - pub state: SessionState, pub time: Time, } -impl EventDataSessionStateChanged { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SESSION_STATE_CHANGED; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataReferenceSpaceChangePending](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataReferenceSpaceChangePending)"] -pub struct EventDataReferenceSpaceChangePending { - pub ty: StructureType, - pub next: *const c_void, - pub session: Session, - pub reference_space_type: ReferenceSpaceType, - pub change_time: Time, - pub pose_valid: Bool32, - pub pose_in_previous_space: Posef, -} -impl EventDataReferenceSpaceChangePending { - pub const TYPE: StructureType = StructureType::EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING; +impl FaceExpressionInfoFB { + pub const TYPE: StructureType = StructureType::FACE_EXPRESSION_INFO_FB; } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataPerfSettingsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataPerfSettingsEXT) - defined by [XR_EXT_performance_settings](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_performance_settings)"] -pub struct EventDataPerfSettingsEXT { - pub ty: StructureType, - pub next: *const c_void, - pub domain: PerfSettingsDomainEXT, - pub sub_domain: PerfSettingsSubDomainEXT, - pub from_level: PerfSettingsNotificationLevelEXT, - pub to_level: PerfSettingsNotificationLevelEXT, -} -impl EventDataPerfSettingsEXT { - pub const TYPE: StructureType = StructureType::EVENT_DATA_PERF_SETTINGS_EXT; +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrFaceExpressionStatusFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceExpressionStatusFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] +pub struct FaceExpressionStatusFB { + pub is_valid: Bool32, + pub is_eye_following_blendshapes_valid: Bool32, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataVisibilityMaskChangedKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVisibilityMaskChangedKHR) - defined by [XR_KHR_visibility_mask](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask)"] -pub struct EventDataVisibilityMaskChangedKHR { +#[doc = "See [XrFaceExpressionWeightsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFaceExpressionWeightsFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] +pub struct FaceExpressionWeightsFB { pub ty: StructureType, - pub next: *const c_void, - pub session: Session, - pub view_configuration_type: ViewConfigurationType, - pub view_index: u32, + pub next: *mut c_void, + pub weight_count: u32, + pub weights: *mut f32, + pub confidence_count: u32, + pub confidences: *mut f32, + pub status: FaceExpressionStatusFB, + pub time: Time, } -impl EventDataVisibilityMaskChangedKHR { - pub const TYPE: StructureType = StructureType::EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR; +impl FaceExpressionWeightsFB { + pub const TYPE: StructureType = StructureType::FACE_EXPRESSION_WEIGHTS_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewConfigurationProperties](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationProperties)"] -pub struct ViewConfigurationProperties { +#[doc = "See [XrSystemBodyTrackingPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemBodyTrackingPropertiesFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct SystemBodyTrackingPropertiesFB { pub ty: StructureType, pub next: *mut c_void, - pub view_configuration_type: ViewConfigurationType, - pub fov_mutable: Bool32, + pub supports_body_tracking: Bool32, } -impl ViewConfigurationProperties { - pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_PROPERTIES; +impl SystemBodyTrackingPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_BODY_TRACKING_PROPERTIES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4020,17 +6474,34 @@ impl ViewConfigurationProperties { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionStateBoolean](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateBoolean)"] -pub struct ActionStateBoolean { +#[doc = "See [XrBodyTrackerCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyTrackerCreateInfoFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodyTrackerCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub body_joint_set: BodyJointSetFB, +} +impl BodyTrackerCreateInfoFB { + pub const TYPE: StructureType = StructureType::BODY_TRACKER_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrBodySkeletonJointFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodySkeletonJointFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodySkeletonJointFB { + pub joint: i32, + pub parent_joint: i32, + pub pose: Posef, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBodySkeletonFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodySkeletonFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodySkeletonFB { pub ty: StructureType, pub next: *mut c_void, - pub current_state: Bool32, - pub changed_since_last_sync: Bool32, - pub last_change_time: Time, - pub is_active: Bool32, + pub joint_count: u32, + pub joints: *mut BodySkeletonJointFB, } -impl ActionStateBoolean { - pub const TYPE: StructureType = StructureType::ACTION_STATE_BOOLEAN; +impl BodySkeletonFB { + pub const TYPE: StructureType = StructureType::BODY_SKELETON_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4046,17 +6517,38 @@ impl ActionStateBoolean { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionStateFloat](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateFloat)"] -pub struct ActionStateFloat { +#[doc = "See [XrBodyJointsLocateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyJointsLocateInfoFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodyJointsLocateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub base_space: Space, + pub time: Time, +} +impl BodyJointsLocateInfoFB { + pub const TYPE: StructureType = StructureType::BODY_JOINTS_LOCATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrBodyJointLocationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyJointLocationFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodyJointLocationFB { + pub location_flags: SpaceLocationFlags, + pub pose: Posef, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrBodyJointLocationsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBodyJointLocationsFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] +pub struct BodyJointLocationsFB { pub ty: StructureType, pub next: *mut c_void, - pub current_state: f32, - pub changed_since_last_sync: Bool32, - pub last_change_time: Time, pub is_active: Bool32, + pub confidence: f32, + pub joint_count: u32, + pub joint_locations: *mut BodyJointLocationFB, + pub skeleton_changed_count: u32, + pub time: Time, } -impl ActionStateFloat { - pub const TYPE: StructureType = StructureType::ACTION_STATE_FLOAT; +impl BodyJointLocationsFB { + pub const TYPE: StructureType = StructureType::BODY_JOINT_LOCATIONS_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4072,17 +6564,14 @@ impl ActionStateFloat { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionStateVector2f](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateVector2f)"] -pub struct ActionStateVector2f { +#[doc = "See [XrSystemEyeTrackingPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemEyeTrackingPropertiesFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] +pub struct SystemEyeTrackingPropertiesFB { pub ty: StructureType, pub next: *mut c_void, - pub current_state: Vector2f, - pub changed_since_last_sync: Bool32, - pub last_change_time: Time, - pub is_active: Bool32, + pub supports_eye_tracking: Bool32, } -impl ActionStateVector2f { - pub const TYPE: StructureType = StructureType::ACTION_STATE_VECTOR2F; +impl SystemEyeTrackingPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_EYE_TRACKING_PROPERTIES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4098,14 +6587,45 @@ impl ActionStateVector2f { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionStatePose](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStatePose)"] -pub struct ActionStatePose { +#[doc = "See [XrEyeTrackerCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeTrackerCreateInfoFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] +pub struct EyeTrackerCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, +} +impl EyeTrackerCreateInfoFB { + pub const TYPE: StructureType = StructureType::EYE_TRACKER_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEyeGazesInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeGazesInfoFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] +pub struct EyeGazesInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub base_space: Space, + pub time: Time, +} +impl EyeGazesInfoFB { + pub const TYPE: StructureType = StructureType::EYE_GAZES_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrEyeGazeFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeGazeFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] +pub struct EyeGazeFB { + pub is_valid: Bool32, + pub gaze_pose: Posef, + pub gaze_confidence: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEyeGazesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeGazesFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] +pub struct EyeGazesFB { pub ty: StructureType, pub next: *mut c_void, - pub is_active: Bool32, + pub gaze: [EyeGazeFB; EYE_POSITION_COUNT_FB], + pub time: Time, } -impl ActionStatePose { - pub const TYPE: StructureType = StructureType::ACTION_STATE_POSE; +impl EyeGazesFB { + pub const TYPE: StructureType = StructureType::EYE_GAZES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4121,136 +6641,187 @@ impl ActionStatePose { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionStateGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionStateGetInfo)"] -pub struct ActionStateGetInfo { +#[doc = "See [XrHandJointsMotionRangeInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsMotionRangeInfoEXT) - defined by [XR_EXT_hand_joints_motion_range](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_joints_motion_range)"] +pub struct HandJointsMotionRangeInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub action: Action, - pub subaction_path: Path, + pub hand_joints_motion_range: HandJointsMotionRangeEXT, } -impl ActionStateGetInfo { - pub const TYPE: StructureType = StructureType::ACTION_STATE_GET_INFO; +impl HandJointsMotionRangeInfoEXT { + pub const TYPE: StructureType = StructureType::HAND_JOINTS_MOTION_RANGE_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHapticActionInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticActionInfo)"] -pub struct HapticActionInfo { +#[doc = "See [XrHandTrackingDataSourceInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingDataSourceInfoEXT) - defined by [XR_EXT_hand_tracking_data_source](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking_data_source)"] +pub struct HandTrackingDataSourceInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub action: Action, - pub subaction_path: Path, + pub requested_data_source_count: u32, + pub requested_data_sources: *mut HandTrackingDataSourceEXT, } -impl HapticActionInfo { - pub const TYPE: StructureType = StructureType::HAPTIC_ACTION_INFO; +impl HandTrackingDataSourceInfoEXT { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_DATA_SOURCE_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionSetCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSetCreateInfo)"] -pub struct ActionSetCreateInfo { +#[doc = "See [XrHandTrackingDataSourceStateEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingDataSourceStateEXT) - defined by [XR_EXT_hand_tracking_data_source](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking_data_source)"] +pub struct HandTrackingDataSourceStateEXT { pub ty: StructureType, - pub next: *const c_void, - pub action_set_name: [c_char; MAX_ACTION_SET_NAME_SIZE], - pub localized_action_set_name: [c_char; MAX_LOCALIZED_ACTION_SET_NAME_SIZE], - pub priority: u32, + pub next: *mut c_void, + pub is_active: Bool32, + pub data_source: HandTrackingDataSourceEXT, } -impl ActionSetCreateInfo { - pub const TYPE: StructureType = StructureType::ACTION_SET_CREATE_INFO; +impl HandTrackingDataSourceStateEXT { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_DATA_SOURCE_STATE_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionSuggestedBinding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionSuggestedBinding)"] -pub struct ActionSuggestedBinding { - pub action: Action, - pub binding: Path, +#[doc = "See [XrHandMeshSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshSpaceCreateInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshSpaceCreateInfoMSFT { + pub ty: StructureType, + pub next: *const c_void, + pub hand_pose_type: HandPoseTypeMSFT, + pub pose_in_hand_mesh_space: Posef, +} +impl HandMeshSpaceCreateInfoMSFT { + pub const TYPE: StructureType = StructureType::HAND_MESH_SPACE_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInteractionProfileSuggestedBinding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileSuggestedBinding)"] -pub struct InteractionProfileSuggestedBinding { +#[doc = "See [XrHandMeshUpdateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshUpdateInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshUpdateInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub interaction_profile: Path, - pub count_suggested_bindings: u32, - pub suggested_bindings: *const ActionSuggestedBinding, + pub time: Time, + pub hand_pose_type: HandPoseTypeMSFT, } -impl InteractionProfileSuggestedBinding { - pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_SUGGESTED_BINDING; +impl HandMeshUpdateInfoMSFT { + pub const TYPE: StructureType = StructureType::HAND_MESH_UPDATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActiveActionSet](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActiveActionSet)"] -pub struct ActiveActionSet { - pub action_set: ActionSet, - pub subaction_path: Path, +#[doc = "See [XrHandMeshMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshMSFT { + pub ty: StructureType, + pub next: *mut c_void, + pub is_active: Bool32, + pub index_buffer_changed: Bool32, + pub vertex_buffer_changed: Bool32, + pub index_buffer: HandMeshIndexBufferMSFT, + pub vertex_buffer: HandMeshVertexBufferMSFT, +} +impl HandMeshMSFT { + pub const TYPE: StructureType = StructureType::HAND_MESH_MSFT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSessionActionSetsAttachInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionActionSetsAttachInfo)"] -pub struct SessionActionSetsAttachInfo { - pub ty: StructureType, - pub next: *const c_void, - pub count_action_sets: u32, - pub action_sets: *const ActionSet, -} -impl SessionActionSetsAttachInfo { - pub const TYPE: StructureType = StructureType::SESSION_ACTION_SETS_ATTACH_INFO; +#[doc = "See [XrHandMeshIndexBufferMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshIndexBufferMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshIndexBufferMSFT { + pub index_buffer_key: u32, + pub index_capacity_input: u32, + pub index_count_output: u32, + pub indices: *mut u32, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionsSyncInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionsSyncInfo)"] -pub struct ActionsSyncInfo { - pub ty: StructureType, - pub next: *const c_void, - pub count_active_action_sets: u32, - pub active_action_sets: *const ActiveActionSet, +#[doc = "See [XrHandMeshVertexBufferMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshVertexBufferMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshVertexBufferMSFT { + pub vertex_update_time: Time, + pub vertex_capacity_input: u32, + pub vertex_count_output: u32, + pub vertices: *mut HandMeshVertexMSFT, } -impl ActionsSyncInfo { - pub const TYPE: StructureType = StructureType::ACTIONS_SYNC_INFO; +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrHandMeshVertexMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshVertexMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandMeshVertexMSFT { + pub position: Vector3f, + pub normal: Vector3f, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBoundSourcesForActionEnumerateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBoundSourcesForActionEnumerateInfo)"] -pub struct BoundSourcesForActionEnumerateInfo { +#[doc = "See [XrSystemHandTrackingMeshPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHandTrackingMeshPropertiesMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct SystemHandTrackingMeshPropertiesMSFT { pub ty: StructureType, - pub next: *const c_void, - pub action: Action, + pub next: *mut c_void, + pub supports_hand_tracking_mesh: Bool32, + pub max_hand_mesh_index_count: u32, + pub max_hand_mesh_vertex_count: u32, } -impl BoundSourcesForActionEnumerateInfo { - pub const TYPE: StructureType = StructureType::BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO; +impl SystemHandTrackingMeshPropertiesMSFT { + pub const TYPE: StructureType = StructureType::SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInputSourceLocalizedNameGetInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInputSourceLocalizedNameGetInfo)"] -pub struct InputSourceLocalizedNameGetInfo { +#[doc = "See [XrHandPoseTypeInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandPoseTypeInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] +pub struct HandPoseTypeInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub source_path: Path, - pub which_components: InputSourceLocalizedNameFlags, + pub hand_pose_type: HandPoseTypeMSFT, } -impl InputSourceLocalizedNameGetInfo { - pub const TYPE: StructureType = StructureType::INPUT_SOURCE_LOCALIZED_NAME_GET_INFO; +impl HandPoseTypeInfoMSFT { + pub const TYPE: StructureType = StructureType::HAND_POSE_TYPE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataInteractionProfileChanged](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataInteractionProfileChanged)"] -pub struct EventDataInteractionProfileChanged { +#[doc = "See [XrSecondaryViewConfigurationSessionBeginInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationSessionBeginInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationSessionBeginInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub session: Session, + pub view_configuration_count: u32, + pub enabled_view_configuration_types: *const ViewConfigurationType, } -impl EventDataInteractionProfileChanged { - pub const TYPE: StructureType = StructureType::EVENT_DATA_INTERACTION_PROFILE_CHANGED; +impl SecondaryViewConfigurationSessionBeginInfoMSFT { + pub const TYPE: StructureType = + StructureType::SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInteractionProfileState](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileState)"] -pub struct InteractionProfileState { +#[doc = "See [XrSecondaryViewConfigurationStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationStateMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationStateMSFT { pub ty: StructureType, pub next: *mut c_void, - pub interaction_profile: Path, + pub view_configuration_type: ViewConfigurationType, + pub active: Bool32, } -impl InteractionProfileState { - pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_STATE; +impl SecondaryViewConfigurationStateMSFT { + pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_STATE_MSFT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4266,115 +6837,113 @@ impl InteractionProfileState { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrActionCreateInfo](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActionCreateInfo)"] -pub struct ActionCreateInfo { +#[doc = "See [XrSecondaryViewConfigurationFrameStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationFrameStateMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationFrameStateMSFT { pub ty: StructureType, - pub next: *const c_void, - pub action_name: [c_char; MAX_ACTION_NAME_SIZE], - pub action_type: ActionType, - pub count_subaction_paths: u32, - pub subaction_paths: *const Path, - pub localized_action_name: [c_char; MAX_LOCALIZED_ACTION_NAME_SIZE], + pub next: *mut c_void, + pub view_configuration_count: u32, + pub view_configuration_states: *mut SecondaryViewConfigurationStateMSFT, } -impl ActionCreateInfo { - pub const TYPE: StructureType = StructureType::ACTION_CREATE_INFO; +impl SecondaryViewConfigurationFrameStateMSFT { + pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInstanceCreateInfoAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInstanceCreateInfoAndroidKHR) - defined by [XR_KHR_android_create_instance](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_android_create_instance)"] -#[cfg(target_os = "android")] -pub struct InstanceCreateInfoAndroidKHR { +#[doc = "See [XrSecondaryViewConfigurationFrameEndInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationFrameEndInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationFrameEndInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub application_vm: *mut c_void, - pub application_activity: *mut c_void, + pub view_configuration_count: u32, + pub view_configuration_layers_info: *const SecondaryViewConfigurationLayerInfoMSFT, } -#[cfg(target_os = "android")] -impl InstanceCreateInfoAndroidKHR { - pub const TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO_ANDROID_KHR; +impl SecondaryViewConfigurationFrameEndInfoMSFT { + pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrVulkanSwapchainFormatListCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanSwapchainFormatListCreateInfoKHR) - defined by [XR_KHR_vulkan_swapchain_format_list](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_swapchain_format_list)"] -pub struct VulkanSwapchainFormatListCreateInfoKHR { +#[doc = "See [XrSecondaryViewConfigurationLayerInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationLayerInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationLayerInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub view_format_count: u32, - pub view_formats: *const VkFormat, + pub view_configuration_type: ViewConfigurationType, + pub environment_blend_mode: EnvironmentBlendMode, + pub layer_count: u32, + pub layers: *const *const CompositionLayerBaseHeader, } -impl VulkanSwapchainFormatListCreateInfoKHR { - pub const TYPE: StructureType = StructureType::VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR; +impl SecondaryViewConfigurationLayerInfoMSFT { + pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrDebugUtilsObjectNameInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsObjectNameInfoEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] -pub struct DebugUtilsObjectNameInfoEXT { +#[doc = "See [XrSecondaryViewConfigurationSwapchainCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationSwapchainCreateInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] +pub struct SecondaryViewConfigurationSwapchainCreateInfoMSFT { pub ty: StructureType, pub next: *const c_void, - pub object_type: ObjectType, - pub object_handle: u64, - pub object_name: *const c_char, + pub view_configuration_type: ViewConfigurationType, } -impl DebugUtilsObjectNameInfoEXT { - pub const TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT; +impl SecondaryViewConfigurationSwapchainCreateInfoMSFT { + pub const TYPE: StructureType = + StructureType::SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrDebugUtilsLabelEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsLabelEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] -pub struct DebugUtilsLabelEXT { +#[doc = "See [XrHolographicWindowAttachmentMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHolographicWindowAttachmentMSFT) - defined by [XR_MSFT_holographic_window_attachment](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_holographic_window_attachment)"] +#[cfg(windows)] +pub struct HolographicWindowAttachmentMSFT { pub ty: StructureType, pub next: *const c_void, - pub label_name: *const c_char, + pub holographic_space: *mut IUnknown, + pub core_window: *mut IUnknown, } -impl DebugUtilsLabelEXT { - pub const TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT; +#[cfg(windows)] +impl HolographicWindowAttachmentMSFT { + pub const TYPE: StructureType = StructureType::HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrDebugUtilsMessengerCallbackDataEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerCallbackDataEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] -pub struct DebugUtilsMessengerCallbackDataEXT { +#[doc = "See [XrAndroidSurfaceSwapchainCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAndroidSurfaceSwapchainCreateInfoFB) - defined by [XR_FB_android_surface_swapchain_create](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_android_surface_swapchain_create)"] +#[cfg(target_os = "android")] +pub struct AndroidSurfaceSwapchainCreateInfoFB { pub ty: StructureType, pub next: *const c_void, - pub message_id: *const c_char, - pub function_name: *const c_char, - pub message: *const c_char, - pub object_count: u32, - pub objects: *mut DebugUtilsObjectNameInfoEXT, - pub session_label_count: u32, - pub session_labels: *mut DebugUtilsLabelEXT, + pub create_flags: AndroidSurfaceSwapchainFlagsFB, } -impl DebugUtilsMessengerCallbackDataEXT { - pub const TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; +#[cfg(target_os = "android")] +impl AndroidSurfaceSwapchainCreateInfoFB { + pub const TYPE: StructureType = StructureType::ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB; } #[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrDebugUtilsMessengerCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDebugUtilsMessengerCreateInfoEXT) - defined by [XR_EXT_debug_utils](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_debug_utils)"] -pub struct DebugUtilsMessengerCreateInfoEXT { +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSwapchainStateBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateBaseHeaderFB) - defined by [XR_FB_swapchain_update_state](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state)"] +pub struct SwapchainStateBaseHeaderFB { pub ty: StructureType, - pub next: *const c_void, - pub message_severities: DebugUtilsMessageSeverityFlagsEXT, - pub message_types: DebugUtilsMessageTypeFlagsEXT, - pub user_callback: Option, - pub user_data: *mut c_void, -} -impl DebugUtilsMessengerCreateInfoEXT { - pub const TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + pub next: *mut c_void, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrVisibilityMaskKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVisibilityMaskKHR) - defined by [XR_KHR_visibility_mask](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask)"] -pub struct VisibilityMaskKHR { +#[doc = "See [XrSwapchainStateAndroidSurfaceDimensionsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateAndroidSurfaceDimensionsFB) - defined by [XR_FB_swapchain_update_state_android_surface](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_android_surface)"] +#[cfg(target_os = "android")] +pub struct SwapchainStateAndroidSurfaceDimensionsFB { pub ty: StructureType, pub next: *mut c_void, - pub vertex_capacity_input: u32, - pub vertex_count_output: u32, - pub vertices: *mut Vector2f, - pub index_capacity_input: u32, - pub index_count_output: u32, - pub indices: *mut u32, + pub width: u32, + pub height: u32, } -impl VisibilityMaskKHR { - pub const TYPE: StructureType = StructureType::VISIBILITY_MASK_KHR; +#[cfg(target_os = "android")] +impl SwapchainStateAndroidSurfaceDimensionsFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4390,15 +6959,23 @@ impl VisibilityMaskKHR { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsRequirementsOpenGLKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsOpenGLKHR) - defined by [XR_KHR_opengl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_enable)"] -pub struct GraphicsRequirementsOpenGLKHR { +#[doc = "See [XrSwapchainStateSamplerOpenGLESFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateSamplerOpenGLESFB) - defined by [XR_FB_swapchain_update_state_opengl_es](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_opengl_es)"] +pub struct SwapchainStateSamplerOpenGLESFB { pub ty: StructureType, pub next: *mut c_void, - pub min_api_version_supported: Version, - pub max_api_version_supported: Version, + pub min_filter: EGLenum, + pub mag_filter: EGLenum, + pub wrap_mode_s: EGLenum, + pub wrap_mode_t: EGLenum, + pub swizzle_red: EGLenum, + pub swizzle_green: EGLenum, + pub swizzle_blue: EGLenum, + pub swizzle_alpha: EGLenum, + pub max_anisotropy: f32, + pub border_color: Color4f, } -impl GraphicsRequirementsOpenGLKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_OPENGL_KHR; +impl SwapchainStateSamplerOpenGLESFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4414,15 +6991,24 @@ impl GraphicsRequirementsOpenGLKHR { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsRequirementsOpenGLESKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsOpenGLESKHR) - defined by [XR_KHR_opengl_es_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable)"] -pub struct GraphicsRequirementsOpenGLESKHR { +#[doc = "See [XrSwapchainStateSamplerVulkanFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateSamplerVulkanFB) - defined by [XR_FB_swapchain_update_state_vulkan](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_vulkan)"] +pub struct SwapchainStateSamplerVulkanFB { pub ty: StructureType, pub next: *mut c_void, - pub min_api_version_supported: Version, - pub max_api_version_supported: Version, + pub min_filter: VkFilter, + pub mag_filter: VkFilter, + pub mipmap_mode: VkSamplerMipmapMode, + pub wrap_mode_s: VkSamplerAddressMode, + pub wrap_mode_t: VkSamplerAddressMode, + pub swizzle_red: VkComponentSwizzle, + pub swizzle_green: VkComponentSwizzle, + pub swizzle_blue: VkComponentSwizzle, + pub swizzle_alpha: VkComponentSwizzle, + pub max_anisotropy: f32, + pub border_color: Color4f, } -impl GraphicsRequirementsOpenGLESKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR; +impl SwapchainStateSamplerVulkanFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_SAMPLER_VULKAN_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4438,15 +7024,77 @@ impl GraphicsRequirementsOpenGLESKHR { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGraphicsRequirementsVulkanKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsVulkanKHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] -pub struct GraphicsRequirementsVulkanKHR { +#[doc = "See [XrCompositionLayerSecureContentFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSecureContentFB) - defined by [XR_FB_composition_layer_secure_content](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_secure_content)"] +pub struct CompositionLayerSecureContentFB { + pub ty: StructureType, + pub next: *const c_void, + pub flags: CompositionLayerSecureContentFlagsFB, +} +impl CompositionLayerSecureContentFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SECURE_CONTENT_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrLoaderInitInfoBaseHeaderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLoaderInitInfoBaseHeaderKHR) - defined by [XR_KHR_loader_init](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_loader_init)"] +pub struct LoaderInitInfoBaseHeaderKHR { + pub ty: StructureType, + pub next: *const c_void, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrLoaderInitInfoAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLoaderInitInfoAndroidKHR) - defined by [XR_KHR_loader_init_android](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_loader_init_android)"] +#[cfg(target_os = "android")] +pub struct LoaderInitInfoAndroidKHR { + pub ty: StructureType, + pub next: *const c_void, + pub application_vm: *mut c_void, + pub application_context: *mut c_void, +} +#[cfg(target_os = "android")] +impl LoaderInitInfoAndroidKHR { + pub const TYPE: StructureType = StructureType::LOADER_INIT_INFO_ANDROID_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerEquirect2KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerEquirect2KHR) - defined by [XR_KHR_composition_layer_equirect2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_equirect2)"] +pub struct CompositionLayerEquirect2KHR { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub eye_visibility: EyeVisibility, + pub sub_image: SwapchainSubImage, + pub pose: Posef, + pub radius: f32, + pub central_horizontal_angle: f32, + pub upper_vertical_angle: f32, + pub lower_vertical_angle: f32, +} +impl CompositionLayerEquirect2KHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_EQUIRECT2_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerColorScaleBiasKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerColorScaleBiasKHR) - defined by [XR_KHR_composition_layer_color_scale_bias](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_color_scale_bias)"] +pub struct CompositionLayerColorScaleBiasKHR { + pub ty: StructureType, + pub next: *const c_void, + pub color_scale: Color4f, + pub color_bias: Color4f, +} +impl CompositionLayerColorScaleBiasKHR { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrControllerModelKeyStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelKeyStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] +pub struct ControllerModelKeyStateMSFT { pub ty: StructureType, pub next: *mut c_void, - pub min_api_version_supported: Version, - pub max_api_version_supported: Version, + pub model_key: ControllerModelKeyMSFT, } -impl GraphicsRequirementsVulkanKHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_VULKAN_KHR; +impl ControllerModelKeyStateMSFT { + pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_KEY_STATE_MSFT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4461,18 +7109,16 @@ impl GraphicsRequirementsVulkanKHR { } } #[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrGraphicsRequirementsD3D11KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsD3D11KHR) - defined by [XR_KHR_D3D11_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D11_enable)"] -#[cfg(windows)] -pub struct GraphicsRequirementsD3D11KHR { +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrControllerModelNodePropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelNodePropertiesMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] +pub struct ControllerModelNodePropertiesMSFT { pub ty: StructureType, pub next: *mut c_void, - pub adapter_luid: LUID, - pub min_feature_level: D3D_FEATURE_LEVEL, + pub parent_node_name: [c_char; MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT], + pub node_name: [c_char; MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT], } -#[cfg(windows)] -impl GraphicsRequirementsD3D11KHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_D3D11_KHR; +impl ControllerModelNodePropertiesMSFT { + pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_NODE_PROPERTIES_MSFT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4487,18 +7133,17 @@ impl GraphicsRequirementsD3D11KHR { } } #[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrGraphicsRequirementsD3D12KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsRequirementsD3D12KHR) - defined by [XR_KHR_D3D12_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_D3D12_enable)"] -#[cfg(windows)] -pub struct GraphicsRequirementsD3D12KHR { +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrControllerModelPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelPropertiesMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] +pub struct ControllerModelPropertiesMSFT { pub ty: StructureType, pub next: *mut c_void, - pub adapter_luid: LUID, - pub min_feature_level: D3D_FEATURE_LEVEL, + pub node_capacity_input: u32, + pub node_count_output: u32, + pub node_properties: *mut ControllerModelNodePropertiesMSFT, } -#[cfg(windows)] -impl GraphicsRequirementsD3D12KHR { - pub const TYPE: StructureType = StructureType::GRAPHICS_REQUIREMENTS_D3D12_KHR; +impl ControllerModelPropertiesMSFT { + pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_PROPERTIES_MSFT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4510,112 +7155,18 @@ impl GraphicsRequirementsD3D12KHR { }); } x - } -} -#[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrVulkanInstanceCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanInstanceCreateInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] -pub struct VulkanInstanceCreateInfoKHR { - pub ty: StructureType, - pub next: *const c_void, - pub system_id: SystemId, - pub create_flags: VulkanInstanceCreateFlagsKHR, - pub pfn_get_instance_proc_addr: Option, - pub vulkan_create_info: *const VkInstanceCreateInfo, - pub vulkan_allocator: *const VkAllocationCallbacks, -} -impl VulkanInstanceCreateInfoKHR { - pub const TYPE: StructureType = StructureType::VULKAN_INSTANCE_CREATE_INFO_KHR; -} -#[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrVulkanDeviceCreateInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanDeviceCreateInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] -pub struct VulkanDeviceCreateInfoKHR { - pub ty: StructureType, - pub next: *const c_void, - pub system_id: SystemId, - pub create_flags: VulkanDeviceCreateFlagsKHR, - pub pfn_get_instance_proc_addr: Option, - pub vulkan_physical_device: VkPhysicalDevice, - pub vulkan_create_info: *const VkDeviceCreateInfo, - pub vulkan_allocator: *const VkAllocationCallbacks, -} -impl VulkanDeviceCreateInfoKHR { - pub const TYPE: StructureType = StructureType::VULKAN_DEVICE_CREATE_INFO_KHR; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrVulkanGraphicsDeviceGetInfoKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanGraphicsDeviceGetInfoKHR) - defined by [XR_KHR_vulkan_enable2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable2)"] -pub struct VulkanGraphicsDeviceGetInfoKHR { - pub ty: StructureType, - pub next: *const c_void, - pub system_id: SystemId, - pub vulkan_instance: VkInstance, -} -impl VulkanGraphicsDeviceGetInfoKHR { - pub const TYPE: StructureType = StructureType::VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrVulkanSwapchainCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVulkanSwapchainCreateInfoMETA) - defined by [XR_META_vulkan_swapchain_create_info](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_vulkan_swapchain_create_info)"] -pub struct VulkanSwapchainCreateInfoMETA { - pub ty: StructureType, - pub next: *const c_void, - pub additional_create_flags: VkImageCreateFlags, - pub additional_usage_flags: VkImageUsageFlags, -} -impl VulkanSwapchainCreateInfoMETA { - pub const TYPE: StructureType = StructureType::VULKAN_SWAPCHAIN_CREATE_INFO_META; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSessionCreateInfoOverlayEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSessionCreateInfoOverlayEXTX) - defined by [XR_EXTX_overlay](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXTX_overlay)"] -pub struct SessionCreateInfoOverlayEXTX { - pub ty: StructureType, - pub next: *const c_void, - pub create_flags: OverlaySessionCreateFlagsEXTX, - pub session_layers_placement: u32, -} -impl SessionCreateInfoOverlayEXTX { - pub const TYPE: StructureType = StructureType::SESSION_CREATE_INFO_OVERLAY_EXTX; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataMainSessionVisibilityChangedEXTX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataMainSessionVisibilityChangedEXTX) - defined by [XR_EXTX_overlay](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXTX_overlay)"] -pub struct EventDataMainSessionVisibilityChangedEXTX { - pub ty: StructureType, - pub next: *const c_void, - pub visible: Bool32, - pub flags: OverlayMainSessionFlagsEXTX, -} -impl EventDataMainSessionVisibilityChangedEXTX { - pub const TYPE: StructureType = StructureType::EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataDisplayRefreshRateChangedFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataDisplayRefreshRateChangedFB) - defined by [XR_FB_display_refresh_rate](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_display_refresh_rate)"] -pub struct EventDataDisplayRefreshRateChangedFB { - pub ty: StructureType, - pub next: *const c_void, - pub from_display_refresh_rate: f32, - pub to_display_refresh_rate: f32, -} -impl EventDataDisplayRefreshRateChangedFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB; + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewConfigurationDepthRangeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationDepthRangeEXT) - defined by [XR_EXT_view_configuration_depth_range](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_view_configuration_depth_range)"] -pub struct ViewConfigurationDepthRangeEXT { +#[doc = "See [XrControllerModelNodeStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelNodeStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] +pub struct ControllerModelNodeStateMSFT { pub ty: StructureType, pub next: *mut c_void, - pub recommended_near_z: f32, - pub min_near_z: f32, - pub recommended_far_z: f32, - pub max_far_z: f32, + pub node_pose: Posef, } -impl ViewConfigurationDepthRangeEXT { - pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_DEPTH_RANGE_EXT; +impl ControllerModelNodeStateMSFT { + pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_NODE_STATE_MSFT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4631,103 +7182,100 @@ impl ViewConfigurationDepthRangeEXT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewConfigurationViewFovEPIC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewConfigurationViewFovEPIC) - defined by [XR_EPIC_view_configuration_fov](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EPIC_view_configuration_fov)"] -pub struct ViewConfigurationViewFovEPIC { +#[doc = "See [XrControllerModelStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] +pub struct ControllerModelStateMSFT { pub ty: StructureType, - pub next: *const c_void, - pub recommended_fov: Fovf, - pub max_mutable_fov: Fovf, + pub next: *mut c_void, + pub node_capacity_input: u32, + pub node_count_output: u32, + pub node_states: *mut ControllerModelNodeStateMSFT, } -impl ViewConfigurationViewFovEPIC { - pub const TYPE: StructureType = StructureType::VIEW_CONFIGURATION_VIEW_FOV_EPIC; +impl ControllerModelStateMSFT { + pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_STATE_MSFT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInteractionProfileDpadBindingEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileDpadBindingEXT) - defined by [XR_EXT_dpad_binding](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_dpad_binding)"] -pub struct InteractionProfileDpadBindingEXT { +#[doc = "See [XrSystemColorSpacePropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemColorSpacePropertiesFB) - defined by [XR_FB_color_space](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_color_space)"] +pub struct SystemColorSpacePropertiesFB { pub ty: StructureType, - pub next: *const c_void, - pub binding: Path, - pub action_set: ActionSet, - pub force_threshold: f32, - pub force_threshold_released: f32, - pub center_region: f32, - pub wedge_angle: f32, - pub is_sticky: Bool32, - pub on_haptic: *const HapticBaseHeader, - pub off_haptic: *const HapticBaseHeader, + pub next: *mut c_void, + pub color_space: ColorSpaceFB, } -impl InteractionProfileDpadBindingEXT { - pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_DPAD_BINDING_EXT; +impl SystemColorSpacePropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_COLOR_SPACE_PROPERTIES_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrInteractionProfileAnalogThresholdVALVE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrInteractionProfileAnalogThresholdVALVE) - defined by [XR_VALVE_analog_threshold](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VALVE_analog_threshold)"] -pub struct InteractionProfileAnalogThresholdVALVE { +#[doc = "See [XrSystemSpatialEntityPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemSpatialEntityPropertiesFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct SystemSpatialEntityPropertiesFB { pub ty: StructureType, pub next: *const c_void, - pub action: Action, - pub binding: Path, - pub on_threshold: f32, - pub off_threshold: f32, - pub on_haptic: *const HapticBaseHeader, - pub off_haptic: *const HapticBaseHeader, + pub supports_spatial_entity: Bool32, } -impl InteractionProfileAnalogThresholdVALVE { - pub const TYPE: StructureType = StructureType::INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE; +impl SystemSpatialEntityPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBindingModificationsKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBindingModificationsKHR) - defined by [XR_KHR_binding_modification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_binding_modification)"] -pub struct BindingModificationsKHR { +#[doc = "See [XrSpatialAnchorCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorCreateInfoFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct SpatialAnchorCreateInfoFB { pub ty: StructureType, pub next: *const c_void, - pub binding_modification_count: u32, - pub binding_modifications: *const *const BindingModificationBaseHeaderKHR, + pub space: Space, + pub pose_in_space: Posef, + pub time: Time, } -impl BindingModificationsKHR { - pub const TYPE: StructureType = StructureType::BINDING_MODIFICATIONS_KHR; +impl SpatialAnchorCreateInfoFB { + pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_CREATE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBindingModificationBaseHeaderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBindingModificationBaseHeaderKHR) - defined by [XR_KHR_binding_modification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_binding_modification)"] -pub struct BindingModificationBaseHeaderKHR { +#[doc = "See [XrSpaceComponentStatusSetInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentStatusSetInfoFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct SpaceComponentStatusSetInfoFB { pub ty: StructureType, pub next: *const c_void, + pub component_type: SpaceComponentTypeFB, + pub enabled: Bool32, + pub timeout: Duration, } -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemEyeGazeInteractionPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemEyeGazeInteractionPropertiesEXT) - defined by [XR_EXT_eye_gaze_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_eye_gaze_interaction)"] -pub struct SystemEyeGazeInteractionPropertiesEXT { - pub ty: StructureType, - pub next: *mut c_void, - pub supports_eye_gaze_interaction: Bool32, -} -impl SystemEyeGazeInteractionPropertiesEXT { - pub const TYPE: StructureType = StructureType::SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpaceComponentStatusSetInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_STATUS_SET_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEyeGazeSampleTimeEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEyeGazeSampleTimeEXT) - defined by [XR_EXT_eye_gaze_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_eye_gaze_interaction)"] -pub struct EyeGazeSampleTimeEXT { +#[doc = "See [XrSpaceComponentStatusFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentStatusFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct SpaceComponentStatusFB { pub ty: StructureType, pub next: *mut c_void, - pub time: Time, + pub enabled: Bool32, + pub change_pending: Bool32, } -impl EyeGazeSampleTimeEXT { - pub const TYPE: StructureType = StructureType::EYE_GAZE_SAMPLE_TIME_EXT; +impl SpaceComponentStatusFB { + pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_STATUS_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4743,39 +7291,43 @@ impl EyeGazeSampleTimeEXT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorCreateInfoMSFT)"] -pub struct SpatialAnchorCreateInfoMSFT { +#[doc = "See [XrEventDataSpatialAnchorCreateCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpatialAnchorCreateCompleteFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct EventDataSpatialAnchorCreateCompleteFB { pub ty: StructureType, pub next: *const c_void, + pub request_id: AsyncRequestIdFB, + pub result: Result, pub space: Space, - pub pose: Posef, - pub time: Time, + pub uuid: UuidEXT, } -impl SpatialAnchorCreateInfoMSFT { - pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_CREATE_INFO_MSFT; +impl EventDataSpatialAnchorCreateCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorSpaceCreateInfoMSFT)"] -pub struct SpatialAnchorSpaceCreateInfoMSFT { +#[doc = "See [XrEventDataSpaceSetStatusCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceSetStatusCompleteFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] +pub struct EventDataSpaceSetStatusCompleteFB { pub ty: StructureType, pub next: *const c_void, - pub anchor: SpatialAnchorMSFT, - pub pose_in_anchor_space: Posef, + pub request_id: AsyncRequestIdFB, + pub result: Result, + pub space: Space, + pub uuid: UuidEXT, + pub component_type: SpaceComponentTypeFB, + pub enabled: Bool32, } -impl SpatialAnchorSpaceCreateInfoMSFT { - pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT; +impl EventDataSpaceSetStatusCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerImageLayoutFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerImageLayoutFB) - defined by [XR_FB_composition_layer_image_layout](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_image_layout)"] -pub struct CompositionLayerImageLayoutFB { +#[doc = "See [XrFoveationProfileCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationProfileCreateInfoFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] +pub struct FoveationProfileCreateInfoFB { pub ty: StructureType, pub next: *mut c_void, - pub flags: CompositionLayerImageLayoutFlagsFB, } -impl CompositionLayerImageLayoutFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_IMAGE_LAYOUT_FB; +impl FoveationProfileCreateInfoFB { + pub const TYPE: StructureType = StructureType::FOVEATION_PROFILE_CREATE_INFO_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4791,17 +7343,14 @@ impl CompositionLayerImageLayoutFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerAlphaBlendFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerAlphaBlendFB) - defined by [XR_FB_composition_layer_alpha_blend](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_alpha_blend)"] -pub struct CompositionLayerAlphaBlendFB { +#[doc = "See [XrSwapchainCreateInfoFoveationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateInfoFoveationFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] +pub struct SwapchainCreateInfoFoveationFB { pub ty: StructureType, pub next: *mut c_void, - pub src_factor_color: BlendFactorFB, - pub dst_factor_color: BlendFactorFB, - pub src_factor_alpha: BlendFactorFB, - pub dst_factor_alpha: BlendFactorFB, + pub flags: SwapchainCreateFoveationFlagsFB, } -impl CompositionLayerAlphaBlendFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_ALPHA_BLEND_FB; +impl SwapchainCreateInfoFoveationFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_FOVEATION_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4816,68 +7365,41 @@ impl CompositionLayerAlphaBlendFB { } } #[repr(C)] -#[derive(Copy, Clone)] -#[doc = "See [XrGraphicsBindingEGLMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGraphicsBindingEGLMNDX) - defined by [XR_MNDX_egl_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_egl_enable)"] -pub struct GraphicsBindingEGLMNDX { - pub ty: StructureType, - pub next: *const c_void, - pub get_proc_address: PFNEGLGETPROCADDRESSPROC, - pub display: EGLDisplay, - pub config: EGLConfig, - pub context: EGLContext, -} -impl GraphicsBindingEGLMNDX { - pub const TYPE: StructureType = StructureType::GRAPHICS_BINDING_EGL_MNDX; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialGraphNodeSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeSpaceCreateInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] -pub struct SpatialGraphNodeSpaceCreateInfoMSFT { - pub ty: StructureType, - pub next: *const c_void, - pub node_type: SpatialGraphNodeTypeMSFT, - pub node_id: [u8; GUID_SIZE_MSFT], - pub pose: Posef, -} -impl SpatialGraphNodeSpaceCreateInfoMSFT { - pub const TYPE: StructureType = StructureType::SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialGraphStaticNodeBindingCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphStaticNodeBindingCreateInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] -pub struct SpatialGraphStaticNodeBindingCreateInfoMSFT { - pub ty: StructureType, - pub next: *const c_void, - pub space: Space, - pub pose_in_space: Posef, - pub time: Time, -} -impl SpatialGraphStaticNodeBindingCreateInfoMSFT { - pub const TYPE: StructureType = - StructureType::SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT; -} -#[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialGraphNodeBindingPropertiesGetInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingPropertiesGetInfoMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] -pub struct SpatialGraphNodeBindingPropertiesGetInfoMSFT { +#[doc = "See [XrSwapchainStateFoveationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateFoveationFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] +pub struct SwapchainStateFoveationFB { pub ty: StructureType, - pub next: *const c_void, + pub next: *mut c_void, + pub flags: SwapchainStateFoveationFlagsFB, + pub profile: FoveationProfileFB, } -impl SpatialGraphNodeBindingPropertiesGetInfoMSFT { - pub const TYPE: StructureType = - StructureType::SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT; +impl SwapchainStateFoveationFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_FOVEATION_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialGraphNodeBindingPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialGraphNodeBindingPropertiesMSFT) - defined by [XR_MSFT_spatial_graph_bridge](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_graph_bridge)"] -pub struct SpatialGraphNodeBindingPropertiesMSFT { +#[doc = "See [XrSwapchainImageFoveationVulkanFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageFoveationVulkanFB) - defined by [XR_FB_foveation_vulkan](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation_vulkan)"] +pub struct SwapchainImageFoveationVulkanFB { pub ty: StructureType, pub next: *mut c_void, - pub node_id: [u8; GUID_SIZE_MSFT], - pub pose_in_node_space: Posef, + pub image: VkImage, + pub width: u32, + pub height: u32, } -impl SpatialGraphNodeBindingPropertiesMSFT { - pub const TYPE: StructureType = StructureType::SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT; +impl SwapchainImageFoveationVulkanFB { + pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4893,14 +7415,16 @@ impl SpatialGraphNodeBindingPropertiesMSFT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemHandTrackingPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHandTrackingPropertiesEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct SystemHandTrackingPropertiesEXT { +#[doc = "See [XrFoveationLevelProfileCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationLevelProfileCreateInfoFB) - defined by [XR_FB_foveation_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation_configuration)"] +pub struct FoveationLevelProfileCreateInfoFB { pub ty: StructureType, pub next: *mut c_void, - pub supports_hand_tracking: Bool32, + pub level: FoveationLevelFB, + pub vertical_offset: f32, + pub dynamic: FoveationDynamicFB, } -impl SystemHandTrackingPropertiesEXT { - pub const TYPE: StructureType = StructureType::SYSTEM_HAND_TRACKING_PROPERTIES_EXT; +impl FoveationLevelProfileCreateInfoFB { + pub const TYPE: StructureType = StructureType::FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4916,56 +7440,95 @@ impl SystemHandTrackingPropertiesEXT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandTrackerCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackerCreateInfoEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandTrackerCreateInfoEXT { +#[doc = "See [XrFoveationEyeTrackedProfileCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationEyeTrackedProfileCreateInfoMETA) - defined by [XR_META_foveation_eye_tracked](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_foveation_eye_tracked)"] +pub struct FoveationEyeTrackedProfileCreateInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub hand: HandEXT, - pub hand_joint_set: HandJointSetEXT, + pub flags: FoveationEyeTrackedProfileCreateFlagsMETA, } -impl HandTrackerCreateInfoEXT { - pub const TYPE: StructureType = StructureType::HAND_TRACKER_CREATE_INFO_EXT; +impl FoveationEyeTrackedProfileCreateInfoMETA { + pub const TYPE: StructureType = StructureType::FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandJointsLocateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsLocateInfoEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandJointsLocateInfoEXT { +#[doc = "See [XrFoveationEyeTrackedStateMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationEyeTrackedStateMETA) - defined by [XR_META_foveation_eye_tracked](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_foveation_eye_tracked)"] +pub struct FoveationEyeTrackedStateMETA { pub ty: StructureType, - pub next: *const c_void, - pub base_space: Space, - pub time: Time, + pub next: *mut c_void, + pub foveation_center: [Vector2f; FOVEATION_CENTER_SIZE_META], + pub flags: FoveationEyeTrackedStateFlagsMETA, } -impl HandJointsLocateInfoEXT { - pub const TYPE: StructureType = StructureType::HAND_JOINTS_LOCATE_INFO_EXT; +impl FoveationEyeTrackedStateMETA { + pub const TYPE: StructureType = StructureType::FOVEATION_EYE_TRACKED_STATE_META; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrHandJointLocationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandJointLocationEXT { - pub location_flags: SpaceLocationFlags, - pub pose: Posef, - pub radius: f32, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemFoveationEyeTrackedPropertiesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFoveationEyeTrackedPropertiesMETA) - defined by [XR_META_foveation_eye_tracked](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_foveation_eye_tracked)"] +pub struct SystemFoveationEyeTrackedPropertiesMETA { + pub ty: StructureType, + pub next: *mut c_void, + pub supports_foveation_eye_tracked: Bool32, +} +impl SystemFoveationEyeTrackedPropertiesMETA { + pub const TYPE: StructureType = StructureType::SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrHandJointVelocityEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocityEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandJointVelocityEXT { - pub velocity_flags: SpaceVelocityFlags, - pub linear_velocity: Vector3f, - pub angular_velocity: Vector3f, +#[doc = "See [XrVector4sFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector4sFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] +pub struct Vector4sFB { + pub x: i16, + pub y: i16, + pub z: i16, + pub w: i16, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandJointLocationsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointLocationsEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandJointLocationsEXT { +#[doc = "See [XrHandTrackingMeshFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingMeshFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] +pub struct HandTrackingMeshFB { pub ty: StructureType, pub next: *mut c_void, - pub is_active: Bool32, - pub joint_count: u32, - pub joint_locations: *mut HandJointLocationEXT, + pub joint_capacity_input: u32, + pub joint_count_output: u32, + pub joint_bind_poses: *mut Posef, + pub joint_radii: *mut f32, + pub joint_parents: *mut HandJointEXT, + pub vertex_capacity_input: u32, + pub vertex_count_output: u32, + pub vertex_positions: *mut Vector3f, + pub vertex_normals: *mut Vector3f, + pub vertex_u_vs: *mut Vector2f, + pub vertex_blend_indices: *mut Vector4sFB, + pub vertex_blend_weights: *mut Vector4f, + pub index_capacity_input: u32, + pub index_count_output: u32, + pub indices: *mut i16, } -impl HandJointLocationsEXT { - pub const TYPE: StructureType = StructureType::HAND_JOINT_LOCATIONS_EXT; +impl HandTrackingMeshFB { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_MESH_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -4981,15 +7544,17 @@ impl HandJointLocationsEXT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandJointVelocitiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointVelocitiesEXT) - defined by [XR_EXT_hand_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_tracking)"] -pub struct HandJointVelocitiesEXT { +#[doc = "See [XrHandTrackingScaleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingScaleFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] +pub struct HandTrackingScaleFB { pub ty: StructureType, pub next: *mut c_void, - pub joint_count: u32, - pub joint_velocities: *mut HandJointVelocityEXT, + pub sensor_output: f32, + pub current_output: f32, + pub override_hand_scale: Bool32, + pub override_value_input: f32, } -impl HandJointVelocitiesEXT { - pub const TYPE: StructureType = StructureType::HAND_JOINT_VELOCITIES_EXT; +impl HandTrackingScaleFB { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_SCALE_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5005,53 +7570,73 @@ impl HandJointVelocitiesEXT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandJointsMotionRangeInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandJointsMotionRangeInfoEXT) - defined by [XR_EXT_hand_joints_motion_range](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_hand_joints_motion_range)"] -pub struct HandJointsMotionRangeInfoEXT { +#[doc = "See [XrHandTrackingAimStateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingAimStateFB) - defined by [XR_FB_hand_tracking_aim](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_aim)"] +pub struct HandTrackingAimStateFB { pub ty: StructureType, - pub next: *const c_void, - pub hand_joints_motion_range: HandJointsMotionRangeEXT, + pub next: *mut c_void, + pub status: HandTrackingAimFlagsFB, + pub aim_pose: Posef, + pub pinch_strength_index: f32, + pub pinch_strength_middle: f32, + pub pinch_strength_ring: f32, + pub pinch_strength_little: f32, } -impl HandJointsMotionRangeInfoEXT { - pub const TYPE: StructureType = StructureType::HAND_JOINTS_MOTION_RANGE_INFO_EXT; +impl HandTrackingAimStateFB { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_AIM_STATE_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandMeshSpaceCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshSpaceCreateInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshSpaceCreateInfoMSFT { - pub ty: StructureType, - pub next: *const c_void, - pub hand_pose_type: HandPoseTypeMSFT, - pub pose_in_hand_mesh_space: Posef, -} -impl HandMeshSpaceCreateInfoMSFT { - pub const TYPE: StructureType = StructureType::HAND_MESH_SPACE_CREATE_INFO_MSFT; +#[doc = "See [XrHandCapsuleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandCapsuleFB) - defined by [XR_FB_hand_tracking_capsules](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_capsules)"] +pub struct HandCapsuleFB { + pub points: [Vector3f; HAND_TRACKING_CAPSULE_POINT_COUNT_FB], + pub radius: f32, + pub joint: HandJointEXT, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandMeshUpdateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshUpdateInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshUpdateInfoMSFT { +#[doc = "See [XrHandTrackingCapsulesStateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingCapsulesStateFB) - defined by [XR_FB_hand_tracking_capsules](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_capsules)"] +pub struct HandTrackingCapsulesStateFB { pub ty: StructureType, - pub next: *const c_void, - pub time: Time, - pub hand_pose_type: HandPoseTypeMSFT, + pub next: *mut c_void, + pub capsules: [HandCapsuleFB; HAND_TRACKING_CAPSULE_COUNT_FB], } -impl HandMeshUpdateInfoMSFT { - pub const TYPE: StructureType = StructureType::HAND_MESH_UPDATE_INFO_MSFT; +impl HandTrackingCapsulesStateFB { + pub const TYPE: StructureType = StructureType::HAND_TRACKING_CAPSULES_STATE_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandMeshMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshMSFT { +#[doc = "See [XrRenderModelPathInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelPathInfoFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct RenderModelPathInfoFB { pub ty: StructureType, pub next: *mut c_void, - pub is_active: Bool32, - pub index_buffer_changed: Bool32, - pub vertex_buffer_changed: Bool32, - pub index_buffer: HandMeshIndexBufferMSFT, - pub vertex_buffer: HandMeshVertexBufferMSFT, + pub path: Path, } -impl HandMeshMSFT { - pub const TYPE: StructureType = StructureType::HAND_MESH_MSFT; +impl RenderModelPathInfoFB { + pub const TYPE: StructureType = StructureType::RENDER_MODEL_PATH_INFO_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5067,41 +7652,43 @@ impl HandMeshMSFT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandMeshIndexBufferMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshIndexBufferMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshIndexBufferMSFT { - pub index_buffer_key: u32, - pub index_capacity_input: u32, - pub index_count_output: u32, - pub indices: *mut u32, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandMeshVertexBufferMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshVertexBufferMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshVertexBufferMSFT { - pub vertex_update_time: Time, - pub vertex_capacity_input: u32, - pub vertex_count_output: u32, - pub vertices: *mut HandMeshVertexMSFT, +#[doc = "See [XrRenderModelPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelPropertiesFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct RenderModelPropertiesFB { + pub ty: StructureType, + pub next: *mut c_void, + pub vendor_id: u32, + pub model_name: [c_char; MAX_RENDER_MODEL_NAME_SIZE_FB], + pub model_key: RenderModelKeyFB, + pub model_version: u32, + pub flags: RenderModelFlagsFB, } -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrHandMeshVertexMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandMeshVertexMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandMeshVertexMSFT { - pub position: Vector3f, - pub normal: Vector3f, +impl RenderModelPropertiesFB { + pub const TYPE: StructureType = StructureType::RENDER_MODEL_PROPERTIES_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemHandTrackingMeshPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHandTrackingMeshPropertiesMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct SystemHandTrackingMeshPropertiesMSFT { +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrRenderModelBufferFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelBufferFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct RenderModelBufferFB { pub ty: StructureType, pub next: *mut c_void, - pub supports_hand_tracking_mesh: Bool32, - pub max_hand_mesh_index_count: u32, - pub max_hand_mesh_vertex_count: u32, + pub buffer_capacity_input: u32, + pub buffer_count_output: u32, + pub buffer: *mut u8, } -impl SystemHandTrackingMeshPropertiesMSFT { - pub const TYPE: StructureType = StructureType::SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT; +impl RenderModelBufferFB { + pub const TYPE: StructureType = StructureType::RENDER_MODEL_BUFFER_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5117,39 +7704,37 @@ impl SystemHandTrackingMeshPropertiesMSFT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandPoseTypeInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandPoseTypeInfoMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] -pub struct HandPoseTypeInfoMSFT { - pub ty: StructureType, - pub next: *const c_void, - pub hand_pose_type: HandPoseTypeMSFT, -} -impl HandPoseTypeInfoMSFT { - pub const TYPE: StructureType = StructureType::HAND_POSE_TYPE_INFO_MSFT; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationSessionBeginInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationSessionBeginInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationSessionBeginInfoMSFT { +#[doc = "See [XrRenderModelLoadInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelLoadInfoFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct RenderModelLoadInfoFB { pub ty: StructureType, - pub next: *const c_void, - pub view_configuration_count: u32, - pub enabled_view_configuration_types: *const ViewConfigurationType, + pub next: *mut c_void, + pub model_key: RenderModelKeyFB, } -impl SecondaryViewConfigurationSessionBeginInfoMSFT { - pub const TYPE: StructureType = - StructureType::SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT; +impl RenderModelLoadInfoFB { + pub const TYPE: StructureType = StructureType::RENDER_MODEL_LOAD_INFO_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationStateMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationStateMSFT { +#[doc = "See [XrSystemRenderModelPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemRenderModelPropertiesFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct SystemRenderModelPropertiesFB { pub ty: StructureType, pub next: *mut c_void, - pub view_configuration_type: ViewConfigurationType, - pub active: Bool32, + pub supports_render_model_loading: Bool32, } -impl SecondaryViewConfigurationStateMSFT { - pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_STATE_MSFT; +impl SystemRenderModelPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_RENDER_MODEL_PROPERTIES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5165,15 +7750,14 @@ impl SecondaryViewConfigurationStateMSFT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationFrameStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationFrameStateMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationFrameStateMSFT { +#[doc = "See [XrRenderModelCapabilitiesRequestFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelCapabilitiesRequestFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] +pub struct RenderModelCapabilitiesRequestFB { pub ty: StructureType, pub next: *mut c_void, - pub view_configuration_count: u32, - pub view_configuration_states: *mut SecondaryViewConfigurationStateMSFT, + pub flags: RenderModelFlagsFB, } -impl SecondaryViewConfigurationFrameStateMSFT { - pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT; +impl RenderModelCapabilitiesRequestFB { + pub const TYPE: StructureType = StructureType::RENDER_MODEL_CAPABILITIES_REQUEST_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5189,154 +7773,86 @@ impl SecondaryViewConfigurationFrameStateMSFT { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationFrameEndInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationFrameEndInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationFrameEndInfoMSFT { +#[doc = "See [XrSpaceQueryInfoBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryInfoBaseHeaderFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceQueryInfoBaseHeaderFB { pub ty: StructureType, pub next: *const c_void, - pub view_configuration_count: u32, - pub view_configuration_layers_info: *const SecondaryViewConfigurationLayerInfoMSFT, -} -impl SecondaryViewConfigurationFrameEndInfoMSFT { - pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationLayerInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationLayerInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationLayerInfoMSFT { +#[doc = "See [XrSpaceFilterInfoBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceFilterInfoBaseHeaderFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceFilterInfoBaseHeaderFB { pub ty: StructureType, pub next: *const c_void, - pub view_configuration_type: ViewConfigurationType, - pub environment_blend_mode: EnvironmentBlendMode, - pub layer_count: u32, - pub layers: *const *const CompositionLayerBaseHeader, -} -impl SecondaryViewConfigurationLayerInfoMSFT { - pub const TYPE: StructureType = StructureType::SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSecondaryViewConfigurationSwapchainCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSecondaryViewConfigurationSwapchainCreateInfoMSFT) - defined by [XR_MSFT_secondary_view_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_secondary_view_configuration)"] -pub struct SecondaryViewConfigurationSwapchainCreateInfoMSFT { +#[doc = "See [XrSpaceQueryInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceQueryInfoFB { pub ty: StructureType, pub next: *const c_void, - pub view_configuration_type: ViewConfigurationType, + pub query_action: SpaceQueryActionFB, + pub max_result_count: u32, + pub timeout: Duration, + pub filter: *const SpaceFilterInfoBaseHeaderFB, + pub exclude_filter: *const SpaceFilterInfoBaseHeaderFB, } -impl SecondaryViewConfigurationSwapchainCreateInfoMSFT { - pub const TYPE: StructureType = - StructureType::SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT; +impl SpaceQueryInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_QUERY_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHolographicWindowAttachmentMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHolographicWindowAttachmentMSFT) - defined by [XR_MSFT_holographic_window_attachment](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_holographic_window_attachment)"] -#[cfg(windows)] -pub struct HolographicWindowAttachmentMSFT { +#[doc = "See [XrSpaceStorageLocationFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceStorageLocationFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceStorageLocationFilterInfoFB { pub ty: StructureType, pub next: *const c_void, - pub holographic_space: *mut IUnknown, - pub core_window: *mut IUnknown, + pub location: SpaceStorageLocationFB, } -#[cfg(windows)] -impl HolographicWindowAttachmentMSFT { - pub const TYPE: StructureType = StructureType::HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT; +impl SpaceStorageLocationFilterInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_STORAGE_LOCATION_FILTER_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrAndroidSurfaceSwapchainCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrAndroidSurfaceSwapchainCreateInfoFB) - defined by [XR_FB_android_surface_swapchain_create](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_android_surface_swapchain_create)"] -#[cfg(target_os = "android")] -pub struct AndroidSurfaceSwapchainCreateInfoFB { +#[doc = "See [XrSpaceUuidFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceUuidFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceUuidFilterInfoFB { pub ty: StructureType, pub next: *const c_void, - pub create_flags: AndroidSurfaceSwapchainFlagsFB, -} -#[cfg(target_os = "android")] -impl AndroidSurfaceSwapchainCreateInfoFB { - pub const TYPE: StructureType = StructureType::ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB; + pub uuid_count: u32, + pub uuids: *mut UuidEXT, } -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainStateBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateBaseHeaderFB) - defined by [XR_FB_swapchain_update_state](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state)"] -pub struct SwapchainStateBaseHeaderFB { - pub ty: StructureType, - pub next: *mut c_void, +impl SpaceUuidFilterInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_UUID_FILTER_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainStateAndroidSurfaceDimensionsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateAndroidSurfaceDimensionsFB) - defined by [XR_FB_swapchain_update_state_android_surface](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_android_surface)"] -#[cfg(target_os = "android")] -pub struct SwapchainStateAndroidSurfaceDimensionsFB { +#[doc = "See [XrSpaceComponentFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceComponentFilterInfoFB { pub ty: StructureType, - pub next: *mut c_void, - pub width: u32, - pub height: u32, + pub next: *const c_void, + pub component_type: SpaceComponentTypeFB, } -#[cfg(target_os = "android")] -impl SwapchainStateAndroidSurfaceDimensionsFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpaceComponentFilterInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_FILTER_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainStateSamplerOpenGLESFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateSamplerOpenGLESFB) - defined by [XR_FB_swapchain_update_state_opengl_es](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_opengl_es)"] -pub struct SwapchainStateSamplerOpenGLESFB { - pub ty: StructureType, - pub next: *mut c_void, - pub min_filter: EGLenum, - pub mag_filter: EGLenum, - pub wrap_mode_s: EGLenum, - pub wrap_mode_t: EGLenum, - pub swizzle_red: EGLenum, - pub swizzle_green: EGLenum, - pub swizzle_blue: EGLenum, - pub swizzle_alpha: EGLenum, - pub max_anisotropy: f32, - pub border_color: Color4f, -} -impl SwapchainStateSamplerOpenGLESFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +#[doc = "See [XrSpaceQueryResultFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryResultFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceQueryResultFB { + pub space: Space, + pub uuid: UuidEXT, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainStateSamplerVulkanFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateSamplerVulkanFB) - defined by [XR_FB_swapchain_update_state_vulkan](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_swapchain_update_state_vulkan)"] -pub struct SwapchainStateSamplerVulkanFB { +#[doc = "See [XrSpaceQueryResultsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryResultsFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct SpaceQueryResultsFB { pub ty: StructureType, pub next: *mut c_void, - pub min_filter: VkFilter, - pub mag_filter: VkFilter, - pub mipmap_mode: VkSamplerMipmapMode, - pub wrap_mode_s: VkSamplerAddressMode, - pub wrap_mode_t: VkSamplerAddressMode, - pub swizzle_red: VkComponentSwizzle, - pub swizzle_green: VkComponentSwizzle, - pub swizzle_blue: VkComponentSwizzle, - pub swizzle_alpha: VkComponentSwizzle, - pub max_anisotropy: f32, - pub border_color: Color4f, + pub result_capacity_input: u32, + pub result_count_output: u32, + pub results: *mut SpaceQueryResultFB, } -impl SwapchainStateSamplerVulkanFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_SAMPLER_VULKAN_FB; +impl SpaceQueryResultsFB { + pub const TYPE: StructureType = StructureType::SPACE_QUERY_RESULTS_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5352,310 +7868,256 @@ impl SwapchainStateSamplerVulkanFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerSecureContentFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSecureContentFB) - defined by [XR_FB_composition_layer_secure_content](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_secure_content)"] -pub struct CompositionLayerSecureContentFB { +#[doc = "See [XrEventDataSpaceQueryResultsAvailableFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceQueryResultsAvailableFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct EventDataSpaceQueryResultsAvailableFB { pub ty: StructureType, pub next: *const c_void, - pub flags: CompositionLayerSecureContentFlagsFB, + pub request_id: AsyncRequestIdFB, } -impl CompositionLayerSecureContentFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SECURE_CONTENT_FB; +impl EventDataSpaceQueryResultsAvailableFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrLoaderInitInfoBaseHeaderKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLoaderInitInfoBaseHeaderKHR) - defined by [XR_KHR_loader_init](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_loader_init)"] -pub struct LoaderInitInfoBaseHeaderKHR { +#[doc = "See [XrEventDataSpaceQueryCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceQueryCompleteFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] +pub struct EventDataSpaceQueryCompleteFB { pub ty: StructureType, pub next: *const c_void, + pub request_id: AsyncRequestIdFB, + pub result: Result, +} +impl EventDataSpaceQueryCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_QUERY_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrLoaderInitInfoAndroidKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLoaderInitInfoAndroidKHR) - defined by [XR_KHR_loader_init_android](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_loader_init_android)"] -#[cfg(target_os = "android")] -pub struct LoaderInitInfoAndroidKHR { +#[doc = "See [XrSpaceSaveInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceSaveInfoFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] +pub struct SpaceSaveInfoFB { pub ty: StructureType, pub next: *const c_void, - pub application_vm: *mut c_void, - pub application_context: *mut c_void, + pub space: Space, + pub location: SpaceStorageLocationFB, + pub persistence_mode: SpacePersistenceModeFB, } -#[cfg(target_os = "android")] -impl LoaderInitInfoAndroidKHR { - pub const TYPE: StructureType = StructureType::LOADER_INIT_INFO_ANDROID_KHR; +impl SpaceSaveInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_SAVE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerEquirect2KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerEquirect2KHR) - defined by [XR_KHR_composition_layer_equirect2](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_equirect2)"] -pub struct CompositionLayerEquirect2KHR { +#[doc = "See [XrSpaceEraseInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceEraseInfoFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] +pub struct SpaceEraseInfoFB { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerFlags, pub space: Space, - pub eye_visibility: EyeVisibility, - pub sub_image: SwapchainSubImage, - pub pose: Posef, - pub radius: f32, - pub central_horizontal_angle: f32, - pub upper_vertical_angle: f32, - pub lower_vertical_angle: f32, + pub location: SpaceStorageLocationFB, } -impl CompositionLayerEquirect2KHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_EQUIRECT2_KHR; +impl SpaceEraseInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_ERASE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerColorScaleBiasKHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerColorScaleBiasKHR) - defined by [XR_KHR_composition_layer_color_scale_bias](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_composition_layer_color_scale_bias)"] -pub struct CompositionLayerColorScaleBiasKHR { +#[doc = "See [XrEventDataSpaceSaveCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceSaveCompleteFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] +pub struct EventDataSpaceSaveCompleteFB { pub ty: StructureType, pub next: *const c_void, - pub color_scale: Color4f, - pub color_bias: Color4f, + pub request_id: AsyncRequestIdFB, + pub result: Result, + pub space: Space, + pub uuid: UuidEXT, + pub location: SpaceStorageLocationFB, } -impl CompositionLayerColorScaleBiasKHR { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR; +impl EventDataSpaceSaveCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_SAVE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrControllerModelKeyStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelKeyStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] -pub struct ControllerModelKeyStateMSFT { +#[doc = "See [XrEventDataSpaceEraseCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceEraseCompleteFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] +pub struct EventDataSpaceEraseCompleteFB { pub ty: StructureType, - pub next: *mut c_void, - pub model_key: ControllerModelKeyMSFT, + pub next: *const c_void, + pub request_id: AsyncRequestIdFB, + pub result: Result, + pub space: Space, + pub uuid: UuidEXT, + pub location: SpaceStorageLocationFB, } -impl ControllerModelKeyStateMSFT { - pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_KEY_STATE_MSFT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl EventDataSpaceEraseCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_ERASE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrControllerModelNodePropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelNodePropertiesMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] -pub struct ControllerModelNodePropertiesMSFT { +#[doc = "See [XrSpaceShareInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceShareInfoFB) - defined by [XR_FB_spatial_entity_sharing](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_sharing)"] +pub struct SpaceShareInfoFB { pub ty: StructureType, - pub next: *mut c_void, - pub parent_node_name: [c_char; MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT], - pub node_name: [c_char; MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT], + pub next: *const c_void, + pub space_count: u32, + pub spaces: *mut Space, + pub user_count: u32, + pub users: *mut SpaceUserFB, } -impl ControllerModelNodePropertiesMSFT { - pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_NODE_PROPERTIES_MSFT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpaceShareInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_SHARE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrControllerModelPropertiesMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelPropertiesMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] -pub struct ControllerModelPropertiesMSFT { +#[doc = "See [XrEventDataSpaceShareCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceShareCompleteFB) - defined by [XR_FB_spatial_entity_sharing](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_sharing)"] +pub struct EventDataSpaceShareCompleteFB { pub ty: StructureType, - pub next: *mut c_void, - pub node_capacity_input: u32, - pub node_count_output: u32, - pub node_properties: *mut ControllerModelNodePropertiesMSFT, + pub next: *const c_void, + pub request_id: AsyncRequestIdFB, + pub result: Result, } -impl ControllerModelPropertiesMSFT { - pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_PROPERTIES_MSFT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl EventDataSpaceShareCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_SHARE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrControllerModelNodeStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelNodeStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] -pub struct ControllerModelNodeStateMSFT { +#[doc = "See [XrSpaceListSaveInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceListSaveInfoFB) - defined by [XR_FB_spatial_entity_storage_batch](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage_batch)"] +pub struct SpaceListSaveInfoFB { pub ty: StructureType, - pub next: *mut c_void, - pub node_pose: Posef, + pub next: *const c_void, + pub space_count: u32, + pub spaces: *mut Space, + pub location: SpaceStorageLocationFB, } -impl ControllerModelNodeStateMSFT { - pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_NODE_STATE_MSFT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpaceListSaveInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_LIST_SAVE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrControllerModelStateMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrControllerModelStateMSFT) - defined by [XR_MSFT_controller_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_controller_model)"] -pub struct ControllerModelStateMSFT { +#[doc = "See [XrEventDataSpaceListSaveCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceListSaveCompleteFB) - defined by [XR_FB_spatial_entity_storage_batch](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage_batch)"] +pub struct EventDataSpaceListSaveCompleteFB { pub ty: StructureType, - pub next: *mut c_void, - pub node_capacity_input: u32, - pub node_count_output: u32, - pub node_states: *mut ControllerModelNodeStateMSFT, + pub next: *const c_void, + pub request_id: AsyncRequestIdFB, + pub result: Result, } -impl ControllerModelStateMSFT { - pub const TYPE: StructureType = StructureType::CONTROLLER_MODEL_STATE_MSFT; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl EventDataSpaceListSaveCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemColorSpacePropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemColorSpacePropertiesFB) - defined by [XR_FB_color_space](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_color_space)"] -pub struct SystemColorSpacePropertiesFB { +#[doc = "See [XrSpaceContainerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceContainerFB) - defined by [XR_FB_spatial_entity_container](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_container)"] +pub struct SpaceContainerFB { pub ty: StructureType, - pub next: *mut c_void, - pub color_space: ColorSpaceFB, + pub next: *const c_void, + pub uuid_capacity_input: u32, + pub uuid_count_output: u32, + pub uuids: *mut UuidEXT, } -impl SystemColorSpacePropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_COLOR_SPACE_PROPERTIES_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpaceContainerFB { + pub const TYPE: StructureType = StructureType::SPACE_CONTAINER_FB; } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemSpatialEntityPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemSpatialEntityPropertiesFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct SystemSpatialEntityPropertiesFB { - pub ty: StructureType, - pub next: *const c_void, - pub supports_spatial_entity: Bool32, +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrExtent3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct Extent3DfFB { + pub width: f32, + pub height: f32, + pub depth: f32, } -impl SystemSpatialEntityPropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB; +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrOffset3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct Offset3DfFB { + pub x: f32, + pub y: f32, + pub z: f32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[doc = "See [XrRect3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct Rect3DfFB { + pub offset: Offset3DfFB, + pub extent: Extent3DfFB, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorCreateInfoFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct SpatialAnchorCreateInfoFB { +#[doc = "See [XrSemanticLabelsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSemanticLabelsFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct SemanticLabelsFB { pub ty: StructureType, pub next: *const c_void, - pub space: Space, - pub pose_in_space: Posef, - pub time: Time, + pub buffer_capacity_input: u32, + pub buffer_count_output: u32, + pub buffer: *mut c_char, } -impl SpatialAnchorCreateInfoFB { - pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_CREATE_INFO_FB; +impl SemanticLabelsFB { + pub const TYPE: StructureType = StructureType::SEMANTIC_LABELS_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceComponentStatusSetInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentStatusSetInfoFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct SpaceComponentStatusSetInfoFB { +#[doc = "See [XrRoomLayoutFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRoomLayoutFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct RoomLayoutFB { pub ty: StructureType, pub next: *const c_void, - pub component_type: SpaceComponentTypeFB, - pub enabled: Bool32, - pub timeout: Duration, + pub floor_uuid: UuidEXT, + pub ceiling_uuid: UuidEXT, + pub wall_uuid_capacity_input: u32, + pub wall_uuid_count_output: u32, + pub wall_uuids: *mut UuidEXT, } -impl SpaceComponentStatusSetInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_STATUS_SET_INFO_FB; +impl RoomLayoutFB { + pub const TYPE: StructureType = StructureType::ROOM_LAYOUT_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceComponentStatusFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentStatusFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct SpaceComponentStatusFB { +#[doc = "See [XrBoundary2DFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBoundary2DFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct Boundary2DFB { pub ty: StructureType, - pub next: *mut c_void, - pub enabled: Bool32, - pub change_pending: Bool32, + pub next: *const c_void, + pub vertex_capacity_input: u32, + pub vertex_count_output: u32, + pub vertices: *mut Vector2f, } -impl SpaceComponentStatusFB { - pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_STATUS_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl Boundary2DFB { + pub const TYPE: StructureType = StructureType::BOUNDARY_2D_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpatialAnchorCreateCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpatialAnchorCreateCompleteFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct EventDataSpatialAnchorCreateCompleteFB { +#[doc = "See [XrSemanticLabelsSupportInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSemanticLabelsSupportInfoFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] +pub struct SemanticLabelsSupportInfoFB { pub ty: StructureType, pub next: *const c_void, - pub request_id: AsyncRequestIdFB, - pub result: Result, - pub space: Space, - pub uuid: UuidEXT, + pub flags: SemanticLabelsSupportFlagsFB, + pub recognized_labels: *const c_char, } -impl EventDataSpatialAnchorCreateCompleteFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB; +impl SemanticLabelsSupportInfoFB { + pub const TYPE: StructureType = StructureType::SEMANTIC_LABELS_SUPPORT_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpaceSetStatusCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceSetStatusCompleteFB) - defined by [XR_FB_spatial_entity](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity)"] -pub struct EventDataSpaceSetStatusCompleteFB { +#[doc = "See [XrSceneCaptureRequestInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSceneCaptureRequestInfoFB) - defined by [XR_FB_scene_capture](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene_capture)"] +pub struct SceneCaptureRequestInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub request_byte_count: u32, + pub request: *const c_char, +} +impl SceneCaptureRequestInfoFB { + pub const TYPE: StructureType = StructureType::SCENE_CAPTURE_REQUEST_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrEventDataSceneCaptureCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSceneCaptureCompleteFB) - defined by [XR_FB_scene_capture](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene_capture)"] +pub struct EventDataSceneCaptureCompleteFB { pub ty: StructureType, pub next: *const c_void, pub request_id: AsyncRequestIdFB, pub result: Result, - pub space: Space, - pub uuid: UuidEXT, - pub component_type: SpaceComponentTypeFB, - pub enabled: Bool32, } -impl EventDataSpaceSetStatusCompleteFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB; +impl EventDataSceneCaptureCompleteFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFoveationProfileCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationProfileCreateInfoFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] -pub struct FoveationProfileCreateInfoFB { +#[doc = "See [XrSystemKeyboardTrackingPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemKeyboardTrackingPropertiesFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] +pub struct SystemKeyboardTrackingPropertiesFB { pub ty: StructureType, pub next: *mut c_void, + pub supports_keyboard_tracking: Bool32, } -impl FoveationProfileCreateInfoFB { - pub const TYPE: StructureType = StructureType::FOVEATION_PROFILE_CREATE_INFO_FB; +impl SystemKeyboardTrackingPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5671,14 +8133,23 @@ impl FoveationProfileCreateInfoFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainCreateInfoFoveationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainCreateInfoFoveationFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] -pub struct SwapchainCreateInfoFoveationFB { +#[doc = "See [XrKeyboardTrackingDescriptionFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingDescriptionFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] +pub struct KeyboardTrackingDescriptionFB { + pub tracked_keyboard_id: u64, + pub size: Vector3f, + pub flags: KeyboardTrackingFlagsFB, + pub name: [c_char; MAX_KEYBOARD_TRACKING_NAME_SIZE_FB], +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrKeyboardSpaceCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardSpaceCreateInfoFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] +pub struct KeyboardSpaceCreateInfoFB { pub ty: StructureType, pub next: *mut c_void, - pub flags: SwapchainCreateFoveationFlagsFB, + pub tracked_keyboard_id: u64, } -impl SwapchainCreateInfoFoveationFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_FOVEATION_FB; +impl KeyboardSpaceCreateInfoFB { + pub const TYPE: StructureType = StructureType::KEYBOARD_SPACE_CREATE_INFO_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5694,15 +8165,14 @@ impl SwapchainCreateInfoFoveationFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainStateFoveationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainStateFoveationFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] -pub struct SwapchainStateFoveationFB { +#[doc = "See [XrKeyboardTrackingQueryFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingQueryFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] +pub struct KeyboardTrackingQueryFB { pub ty: StructureType, pub next: *mut c_void, - pub flags: SwapchainStateFoveationFlagsFB, - pub profile: FoveationProfileFB, + pub flags: KeyboardTrackingQueryFlagsFB, } -impl SwapchainStateFoveationFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_STATE_FOVEATION_FB; +impl KeyboardTrackingQueryFB { + pub const TYPE: StructureType = StructureType::KEYBOARD_TRACKING_QUERY_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5718,16 +8188,37 @@ impl SwapchainStateFoveationFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSwapchainImageFoveationVulkanFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSwapchainImageFoveationVulkanFB) - defined by [XR_FB_foveation_vulkan](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation_vulkan)"] -pub struct SwapchainImageFoveationVulkanFB { +#[doc = "See [XrCompositionLayerDepthTestVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerDepthTestVARJO) - defined by [XR_VARJO_composition_layer_depth_test](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_composition_layer_depth_test)"] +pub struct CompositionLayerDepthTestVARJO { + pub ty: StructureType, + pub next: *const c_void, + pub depth_test_range_near_z: f32, + pub depth_test_range_far_z: f32, +} +impl CompositionLayerDepthTestVARJO { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_DEPTH_TEST_VARJO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrViewLocateFoveatedRenderingVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewLocateFoveatedRenderingVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] +pub struct ViewLocateFoveatedRenderingVARJO { + pub ty: StructureType, + pub next: *const c_void, + pub foveated_rendering_active: Bool32, +} +impl ViewLocateFoveatedRenderingVARJO { + pub const TYPE: StructureType = StructureType::VIEW_LOCATE_FOVEATED_RENDERING_VARJO; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrFoveatedViewConfigurationViewVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveatedViewConfigurationViewVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] +pub struct FoveatedViewConfigurationViewVARJO { pub ty: StructureType, pub next: *mut c_void, - pub image: VkImage, - pub width: u32, - pub height: u32, + pub foveated_rendering_active: Bool32, } -impl SwapchainImageFoveationVulkanFB { - pub const TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB; +impl FoveatedViewConfigurationViewVARJO { + pub const TYPE: StructureType = StructureType::FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5743,16 +8234,14 @@ impl SwapchainImageFoveationVulkanFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFoveationLevelProfileCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationLevelProfileCreateInfoFB) - defined by [XR_FB_foveation_configuration](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation_configuration)"] -pub struct FoveationLevelProfileCreateInfoFB { +#[doc = "See [XrSystemFoveatedRenderingPropertiesVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFoveatedRenderingPropertiesVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] +pub struct SystemFoveatedRenderingPropertiesVARJO { pub ty: StructureType, pub next: *mut c_void, - pub level: FoveationLevelFB, - pub vertical_offset: f32, - pub dynamic: FoveationDynamicFB, + pub supports_foveated_rendering: Bool32, } -impl FoveationLevelProfileCreateInfoFB { - pub const TYPE: StructureType = StructureType::FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB; +impl SystemFoveatedRenderingPropertiesVARJO { + pub const TYPE: StructureType = StructureType::SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -5767,267 +8256,268 @@ impl FoveationLevelProfileCreateInfoFB { } } #[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrVector4sFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVector4sFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] -pub struct Vector4sFB { - pub x: i16, - pub y: i16, - pub z: i16, - pub w: i16, +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerReprojectionInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerReprojectionInfoMSFT) - defined by [XR_MSFT_composition_layer_reprojection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_composition_layer_reprojection)"] +pub struct CompositionLayerReprojectionInfoMSFT { + pub ty: StructureType, + pub next: *const c_void, + pub reprojection_mode: ReprojectionModeMSFT, +} +impl CompositionLayerReprojectionInfoMSFT { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_REPROJECTION_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandTrackingMeshFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingMeshFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] -pub struct HandTrackingMeshFB { +#[doc = "See [XrCompositionLayerReprojectionPlaneOverrideMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerReprojectionPlaneOverrideMSFT) - defined by [XR_MSFT_composition_layer_reprojection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_composition_layer_reprojection)"] +pub struct CompositionLayerReprojectionPlaneOverrideMSFT { pub ty: StructureType, - pub next: *mut c_void, - pub joint_capacity_input: u32, - pub joint_count_output: u32, - pub joint_bind_poses: *mut Posef, - pub joint_radii: *mut f32, - pub joint_parents: *mut HandJointEXT, - pub vertex_capacity_input: u32, - pub vertex_count_output: u32, - pub vertex_positions: *mut Vector3f, - pub vertex_normals: *mut Vector3f, - pub vertex_u_vs: *mut Vector2f, - pub vertex_blend_indices: *mut Vector4sFB, - pub vertex_blend_weights: *mut Vector4f, - pub index_capacity_input: u32, - pub index_count_output: u32, - pub indices: *mut i16, + pub next: *const c_void, + pub position: Vector3f, + pub normal: Vector3f, + pub velocity: Vector3f, +} +impl CompositionLayerReprojectionPlaneOverrideMSFT { + pub const TYPE: StructureType = + StructureType::COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrTriangleMeshCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshCreateInfoFB) - defined by [XR_FB_triangle_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_triangle_mesh)"] +pub struct TriangleMeshCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub flags: TriangleMeshFlagsFB, + pub winding_order: WindingOrderFB, + pub vertex_count: u32, + pub vertex_buffer: *const Vector3f, + pub triangle_count: u32, + pub index_buffer: *const u32, +} +impl TriangleMeshCreateInfoFB { + pub const TYPE: StructureType = StructureType::TRIANGLE_MESH_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemPassthroughPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPassthroughPropertiesFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct SystemPassthroughPropertiesFB { + pub ty: StructureType, + pub next: *const c_void, + pub supports_passthrough: Bool32, +} +impl SystemPassthroughPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_PASSTHROUGH_PROPERTIES_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSystemPassthroughProperties2FB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPassthroughProperties2FB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct SystemPassthroughProperties2FB { + pub ty: StructureType, + pub next: *const c_void, + pub capabilities: PassthroughCapabilityFlagsFB, +} +impl SystemPassthroughProperties2FB { + pub const TYPE: StructureType = StructureType::SYSTEM_PASSTHROUGH_PROPERTIES2_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub flags: PassthroughFlagsFB, +} +impl PassthroughCreateInfoFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughLayerCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughLayerCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughLayerCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub passthrough: PassthroughFB, + pub flags: PassthroughFlagsFB, + pub purpose: PassthroughLayerPurposeFB, +} +impl PassthroughLayerCreateInfoFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_LAYER_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerPassthroughFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerPassthroughFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct CompositionLayerPassthroughFB { + pub ty: StructureType, + pub next: *const c_void, + pub flags: CompositionLayerFlags, + pub space: Space, + pub layer_handle: PassthroughLayerFB, +} +impl CompositionLayerPassthroughFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PASSTHROUGH_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGeometryInstanceCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct GeometryInstanceCreateInfoFB { + pub ty: StructureType, + pub next: *const c_void, + pub layer: PassthroughLayerFB, + pub mesh: TriangleMeshFB, + pub base_space: Space, + pub pose: Posef, + pub scale: Vector3f, +} +impl GeometryInstanceCreateInfoFB { + pub const TYPE: StructureType = StructureType::GEOMETRY_INSTANCE_CREATE_INFO_FB; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrGeometryInstanceTransformFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceTransformFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct GeometryInstanceTransformFB { + pub ty: StructureType, + pub next: *const c_void, + pub base_space: Space, + pub time: Time, + pub pose: Posef, + pub scale: Vector3f, +} +impl GeometryInstanceTransformFB { + pub const TYPE: StructureType = StructureType::GEOMETRY_INSTANCE_TRANSFORM_FB; } -impl HandTrackingMeshFB { - pub const TYPE: StructureType = StructureType::HAND_TRACKING_MESH_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughStyleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughStyleFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughStyleFB { + pub ty: StructureType, + pub next: *const c_void, + pub texture_opacity_factor: f32, + pub edge_color: Color4f, +} +impl PassthroughStyleFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_STYLE_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandTrackingScaleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingScaleFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] -pub struct HandTrackingScaleFB { +#[doc = "See [XrPassthroughColorMapMonoToRgbaFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapMonoToRgbaFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughColorMapMonoToRgbaFB { pub ty: StructureType, - pub next: *mut c_void, - pub sensor_output: f32, - pub current_output: f32, - pub override_hand_scale: Bool32, - pub override_value_input: f32, + pub next: *const c_void, + pub texture_color_map: [Color4f; PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB], } -impl HandTrackingScaleFB { - pub const TYPE: StructureType = StructureType::HAND_TRACKING_SCALE_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughColorMapMonoToRgbaFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandTrackingAimStateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingAimStateFB) - defined by [XR_FB_hand_tracking_aim](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_aim)"] -pub struct HandTrackingAimStateFB { +#[doc = "See [XrPassthroughColorMapMonoToMonoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapMonoToMonoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughColorMapMonoToMonoFB { pub ty: StructureType, - pub next: *mut c_void, - pub status: HandTrackingAimFlagsFB, - pub aim_pose: Posef, - pub pinch_strength_index: f32, - pub pinch_strength_middle: f32, - pub pinch_strength_ring: f32, - pub pinch_strength_little: f32, + pub next: *const c_void, + pub texture_color_map: [u8; PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB], } -impl HandTrackingAimStateFB { - pub const TYPE: StructureType = StructureType::HAND_TRACKING_AIM_STATE_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughColorMapMonoToMonoFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandCapsuleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandCapsuleFB) - defined by [XR_FB_hand_tracking_capsules](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_capsules)"] -pub struct HandCapsuleFB { - pub points: [Vector3f; HAND_TRACKING_CAPSULE_POINT_COUNT_FB], - pub radius: f32, - pub joint: HandJointEXT, +#[doc = "See [XrPassthroughBrightnessContrastSaturationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughBrightnessContrastSaturationFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct PassthroughBrightnessContrastSaturationFB { + pub ty: StructureType, + pub next: *const c_void, + pub brightness: f32, + pub contrast: f32, + pub saturation: f32, +} +impl PassthroughBrightnessContrastSaturationFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrHandTrackingCapsulesStateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHandTrackingCapsulesStateFB) - defined by [XR_FB_hand_tracking_capsules](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_capsules)"] -pub struct HandTrackingCapsulesStateFB { +#[doc = "See [XrEventDataPassthroughStateChangedFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataPassthroughStateChangedFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] +pub struct EventDataPassthroughStateChangedFB { pub ty: StructureType, - pub next: *mut c_void, - pub capsules: [HandCapsuleFB; HAND_TRACKING_CAPSULE_COUNT_FB], + pub next: *const c_void, + pub flags: PassthroughStateChangedFlagsFB, } -impl HandTrackingCapsulesStateFB { - pub const TYPE: StructureType = StructureType::HAND_TRACKING_CAPSULES_STATE_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl EventDataPassthroughStateChangedFB { + pub const TYPE: StructureType = StructureType::EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrRenderModelPathInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelPathInfoFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct RenderModelPathInfoFB { +#[doc = "See [XrPassthroughKeyboardHandsIntensityFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughKeyboardHandsIntensityFB) - defined by [XR_FB_passthrough_keyboard_hands](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough_keyboard_hands)"] +pub struct PassthroughKeyboardHandsIntensityFB { pub ty: StructureType, - pub next: *mut c_void, - pub path: Path, + pub next: *const c_void, + pub left_hand_intensity: f32, + pub right_hand_intensity: f32, } -impl RenderModelPathInfoFB { - pub const TYPE: StructureType = StructureType::RENDER_MODEL_PATH_INFO_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughKeyboardHandsIntensityFB { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrRenderModelPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelPropertiesFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct RenderModelPropertiesFB { +#[doc = "See [XrLocalDimmingFrameEndInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrLocalDimmingFrameEndInfoMETA) - defined by [XR_META_local_dimming](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_local_dimming)"] +pub struct LocalDimmingFrameEndInfoMETA { pub ty: StructureType, - pub next: *mut c_void, - pub vendor_id: u32, - pub model_name: [c_char; MAX_RENDER_MODEL_NAME_SIZE_FB], - pub model_key: RenderModelKeyFB, - pub model_version: u32, - pub flags: RenderModelFlagsFB, + pub next: *const c_void, + pub local_dimming_mode: LocalDimmingModeMETA, } -impl RenderModelPropertiesFB { - pub const TYPE: StructureType = StructureType::RENDER_MODEL_PROPERTIES_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl LocalDimmingFrameEndInfoMETA { + pub const TYPE: StructureType = StructureType::LOCAL_DIMMING_FRAME_END_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrRenderModelBufferFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelBufferFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct RenderModelBufferFB { +#[doc = "See [XrSpatialAnchorPersistenceNameMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorPersistenceNameMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] +pub struct SpatialAnchorPersistenceNameMSFT { + pub name: [c_char; MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT], +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrSpatialAnchorPersistenceInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorPersistenceInfoMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] +pub struct SpatialAnchorPersistenceInfoMSFT { pub ty: StructureType, - pub next: *mut c_void, - pub buffer_capacity_input: u32, - pub buffer_count_output: u32, - pub buffer: *mut u8, + pub next: *const c_void, + pub spatial_anchor_persistence_name: SpatialAnchorPersistenceNameMSFT, + pub spatial_anchor: SpatialAnchorMSFT, } -impl RenderModelBufferFB { - pub const TYPE: StructureType = StructureType::RENDER_MODEL_BUFFER_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpatialAnchorPersistenceInfoMSFT { + pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrRenderModelLoadInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelLoadInfoFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct RenderModelLoadInfoFB { +#[doc = "See [XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] +pub struct SpatialAnchorFromPersistedAnchorCreateInfoMSFT { pub ty: StructureType, - pub next: *mut c_void, - pub model_key: RenderModelKeyFB, + pub next: *const c_void, + pub spatial_anchor_store: SpatialAnchorStoreConnectionMSFT, + pub spatial_anchor_persistence_name: SpatialAnchorPersistenceNameMSFT, } -impl RenderModelLoadInfoFB { - pub const TYPE: StructureType = StructureType::RENDER_MODEL_LOAD_INFO_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl SpatialAnchorFromPersistedAnchorCreateInfoMSFT { + pub const TYPE: StructureType = + StructureType::SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemRenderModelPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemRenderModelPropertiesFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct SystemRenderModelPropertiesFB { +#[doc = "See [XrFacialTrackerCreateInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerCreateInfoHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] +pub struct FacialTrackerCreateInfoHTC { pub ty: StructureType, - pub next: *mut c_void, - pub supports_render_model_loading: Bool32, + pub next: *const c_void, + pub facial_tracking_type: FacialTrackingTypeHTC, } -impl SystemRenderModelPropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_RENDER_MODEL_PROPERTIES_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl FacialTrackerCreateInfoHTC { + pub const TYPE: StructureType = StructureType::FACIAL_TRACKER_CREATE_INFO_HTC; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrRenderModelCapabilitiesRequestFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRenderModelCapabilitiesRequestFB) - defined by [XR_FB_render_model](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_render_model)"] -pub struct RenderModelCapabilitiesRequestFB { +#[doc = "See [XrSystemFacialTrackingPropertiesHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFacialTrackingPropertiesHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] +pub struct SystemFacialTrackingPropertiesHTC { pub ty: StructureType, pub next: *mut c_void, - pub flags: RenderModelFlagsFB, + pub support_eye_facial_tracking: Bool32, + pub support_lip_facial_tracking: Bool32, } -impl RenderModelCapabilitiesRequestFB { - pub const TYPE: StructureType = StructureType::RENDER_MODEL_CAPABILITIES_REQUEST_FB; +impl SystemFacialTrackingPropertiesHTC { + pub const TYPE: StructureType = StructureType::SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6043,86 +8533,82 @@ impl RenderModelCapabilitiesRequestFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceQueryInfoBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryInfoBaseHeaderFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceQueryInfoBaseHeaderFB { - pub ty: StructureType, - pub next: *const c_void, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceFilterInfoBaseHeaderFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceFilterInfoBaseHeaderFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceFilterInfoBaseHeaderFB { - pub ty: StructureType, - pub next: *const c_void, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceQueryInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceQueryInfoFB { +#[doc = "See [XrFacialExpressionsHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialExpressionsHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] +pub struct FacialExpressionsHTC { pub ty: StructureType, pub next: *const c_void, - pub query_action: SpaceQueryActionFB, - pub max_result_count: u32, - pub timeout: Duration, - pub filter: *const SpaceFilterInfoBaseHeaderFB, - pub exclude_filter: *const SpaceFilterInfoBaseHeaderFB, + pub is_active: Bool32, + pub sample_time: Time, + pub expression_count: u32, + pub expression_weightings: *mut f32, } -impl SpaceQueryInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_QUERY_INFO_FB; +impl FacialExpressionsHTC { + pub const TYPE: StructureType = StructureType::FACIAL_EXPRESSIONS_HTC; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceStorageLocationFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceStorageLocationFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceStorageLocationFilterInfoFB { +#[doc = "See [XrViveTrackerPathsHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViveTrackerPathsHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] +pub struct ViveTrackerPathsHTCX { pub ty: StructureType, - pub next: *const c_void, - pub location: SpaceStorageLocationFB, + pub next: *mut c_void, + pub persistent_path: Path, + pub role_path: Path, } -impl SpaceStorageLocationFilterInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_STORAGE_LOCATION_FILTER_INFO_FB; +impl ViveTrackerPathsHTCX { + pub const TYPE: StructureType = StructureType::VIVE_TRACKER_PATHS_HTCX; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceUuidFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceUuidFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceUuidFilterInfoFB { +#[doc = "See [XrEventDataViveTrackerConnectedHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataViveTrackerConnectedHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] +pub struct EventDataViveTrackerConnectedHTCX { pub ty: StructureType, pub next: *const c_void, - pub uuid_count: u32, - pub uuids: *mut UuidEXT, + pub paths: *mut ViveTrackerPathsHTCX, } -impl SpaceUuidFilterInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_UUID_FILTER_INFO_FB; +impl EventDataViveTrackerConnectedHTCX { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceComponentFilterInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceComponentFilterInfoFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceComponentFilterInfoFB { +#[doc = "See [XrCompositionLayerSpaceWarpInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSpaceWarpInfoFB) - defined by [XR_FB_space_warp](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_space_warp)"] +pub struct CompositionLayerSpaceWarpInfoFB { pub ty: StructureType, pub next: *const c_void, - pub component_type: SpaceComponentTypeFB, -} -impl SpaceComponentFilterInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_COMPONENT_FILTER_INFO_FB; + pub layer_flags: CompositionLayerSpaceWarpInfoFlagsFB, + pub motion_vector_sub_image: SwapchainSubImage, + pub app_space_delta_pose: Posef, + pub depth_sub_image: SwapchainSubImage, + pub min_depth: f32, + pub max_depth: f32, + pub near_z: f32, + pub far_z: f32, } -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceQueryResultFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryResultFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceQueryResultFB { - pub space: Space, - pub uuid: UuidEXT, +impl CompositionLayerSpaceWarpInfoFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SPACE_WARP_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceQueryResultsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceQueryResultsFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct SpaceQueryResultsFB { +#[doc = "See [XrSystemSpaceWarpPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemSpaceWarpPropertiesFB) - defined by [XR_FB_space_warp](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_space_warp)"] +pub struct SystemSpaceWarpPropertiesFB { pub ty: StructureType, pub next: *mut c_void, - pub result_capacity_input: u32, - pub result_count_output: u32, - pub results: *mut SpaceQueryResultFB, + pub recommended_motion_vector_image_rect_width: u32, + pub recommended_motion_vector_image_rect_height: u32, } -impl SpaceQueryResultsFB { - pub const TYPE: StructureType = StructureType::SPACE_QUERY_RESULTS_FB; +impl SystemSpaceWarpPropertiesFB { + pub const TYPE: StructureType = StructureType::SYSTEM_SPACE_WARP_PROPERTIES_FB; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6138,224 +8624,171 @@ impl SpaceQueryResultsFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpaceQueryResultsAvailableFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceQueryResultsAvailableFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct EventDataSpaceQueryResultsAvailableFB { - pub ty: StructureType, - pub next: *const c_void, - pub request_id: AsyncRequestIdFB, -} -impl EventDataSpaceQueryResultsAvailableFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB; -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpaceQueryCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceQueryCompleteFB) - defined by [XR_FB_spatial_entity_query](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_query)"] -pub struct EventDataSpaceQueryCompleteFB { +#[doc = "See [XrSystemMarkerTrackingPropertiesVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemMarkerTrackingPropertiesVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] +pub struct SystemMarkerTrackingPropertiesVARJO { pub ty: StructureType, - pub next: *const c_void, - pub request_id: AsyncRequestIdFB, - pub result: Result, + pub next: *mut c_void, + pub supports_marker_tracking: Bool32, } -impl EventDataSpaceQueryCompleteFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_QUERY_COMPLETE_FB; +impl SystemMarkerTrackingPropertiesVARJO { + pub const TYPE: StructureType = StructureType::SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceSaveInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceSaveInfoFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] -pub struct SpaceSaveInfoFB { +#[doc = "See [XrEventDataMarkerTrackingUpdateVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataMarkerTrackingUpdateVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] +pub struct EventDataMarkerTrackingUpdateVARJO { pub ty: StructureType, pub next: *const c_void, - pub space: Space, - pub location: SpaceStorageLocationFB, - pub persistence_mode: SpacePersistenceModeFB, + pub marker_id: u64, + pub is_active: Bool32, + pub is_predicted: Bool32, + pub time: Time, } -impl SpaceSaveInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_SAVE_INFO_FB; +impl EventDataMarkerTrackingUpdateVARJO { + pub const TYPE: StructureType = StructureType::EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceEraseInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceEraseInfoFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] -pub struct SpaceEraseInfoFB { +#[doc = "See [XrMarkerSpaceCreateInfoVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrMarkerSpaceCreateInfoVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] +pub struct MarkerSpaceCreateInfoVARJO { pub ty: StructureType, pub next: *const c_void, - pub space: Space, - pub location: SpaceStorageLocationFB, + pub marker_id: u64, + pub pose_in_marker_space: Posef, } -impl SpaceEraseInfoFB { - pub const TYPE: StructureType = StructureType::SPACE_ERASE_INFO_FB; +impl MarkerSpaceCreateInfoVARJO { + pub const TYPE: StructureType = StructureType::MARKER_SPACE_CREATE_INFO_VARJO; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpaceSaveCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceSaveCompleteFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] -pub struct EventDataSpaceSaveCompleteFB { - pub ty: StructureType, - pub next: *const c_void, - pub request_id: AsyncRequestIdFB, - pub result: Result, - pub space: Space, - pub uuid: UuidEXT, - pub location: SpaceStorageLocationFB, -} -impl EventDataSpaceSaveCompleteFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_SAVE_COMPLETE_FB; +#[doc = "See [XrUuidEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrUuidEXT) - defined by [XR_EXT_uuid](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_uuid)"] +pub struct UuidEXT { + pub data: [u8; UUID_SIZE_EXT], } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataSpaceEraseCompleteFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataSpaceEraseCompleteFB) - defined by [XR_FB_spatial_entity_storage](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage)"] -pub struct EventDataSpaceEraseCompleteFB { +#[doc = "See [XrGlobalDimmerFrameEndInfoML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGlobalDimmerFrameEndInfoML) - defined by [XR_ML_global_dimmer](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_ML_global_dimmer)"] +pub struct GlobalDimmerFrameEndInfoML { pub ty: StructureType, pub next: *const c_void, - pub request_id: AsyncRequestIdFB, - pub result: Result, - pub space: Space, - pub uuid: UuidEXT, - pub location: SpaceStorageLocationFB, + pub dimmer_value: f32, + pub flags: GlobalDimmerFrameEndInfoFlagsML, } -impl EventDataSpaceEraseCompleteFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_SPACE_ERASE_COMPLETE_FB; +impl GlobalDimmerFrameEndInfoML { + pub const TYPE: StructureType = StructureType::GLOBAL_DIMMER_FRAME_END_INFO_ML; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpaceContainerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceContainerFB) - defined by [XR_FB_spatial_entity_container](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_container)"] -pub struct SpaceContainerFB { +#[doc = "See [XrDigitalLensControlALMALENCE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDigitalLensControlALMALENCE)"] +pub struct DigitalLensControlALMALENCE { pub ty: StructureType, pub next: *const c_void, - pub uuid_capacity_input: u32, - pub uuid_count_output: u32, - pub uuids: *mut UuidEXT, -} -impl SpaceContainerFB { - pub const TYPE: StructureType = StructureType::SPACE_CONTAINER_FB; -} -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrExtent3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExtent3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct Extent3DfFB { - pub width: f32, - pub height: f32, - pub depth: f32, -} -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrOffset3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrOffset3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct Offset3DfFB { - pub x: f32, - pub y: f32, - pub z: f32, + pub flags: DigitalLensControlFlagsALMALENCE, } -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, PartialEq)] -#[doc = "See [XrRect3DfFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRect3DfFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct Rect3DfFB { - pub offset: Offset3DfFB, - pub extent: Extent3DfFB, +impl DigitalLensControlALMALENCE { + pub const TYPE: StructureType = StructureType::DIGITAL_LENS_CONTROL_ALMALENCE; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSemanticLabelsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSemanticLabelsFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct SemanticLabelsFB { +#[doc = "See [XrCompositionLayerSettingsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSettingsFB) - defined by [XR_FB_composition_layer_settings](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_settings)"] +pub struct CompositionLayerSettingsFB { pub ty: StructureType, pub next: *const c_void, - pub buffer_capacity_input: u32, - pub buffer_count_output: u32, - pub buffer: *mut c_char, + pub layer_flags: CompositionLayerSettingsFlagsFB, } -impl SemanticLabelsFB { - pub const TYPE: StructureType = StructureType::SEMANTIC_LABELS_FB; +impl CompositionLayerSettingsFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SETTINGS_FB; } #[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = "See [XrRoomLayoutFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrRoomLayoutFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct RoomLayoutFB { - pub ty: StructureType, - pub next: *const c_void, - pub floor_uuid: UuidEXT, - pub ceiling_uuid: UuidEXT, - pub wall_uuid_capacity_input: u32, - pub wall_uuid_count_output: u32, - pub wall_uuids: *mut UuidEXT, +#[derive(Copy, Clone, Debug, PartialEq)] +#[doc = "See [XrExternalCameraIntrinsicsOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExternalCameraIntrinsicsOCULUS) - defined by [XR_OCULUS_external_camera](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_OCULUS_external_camera)"] +pub struct ExternalCameraIntrinsicsOCULUS { + pub last_change_time: Time, + pub fov: Fovf, + pub virtual_near_plane_distance: f32, + pub virtual_far_plane_distance: f32, + pub image_sensor_pixel_resolution: Extent2Di, } -impl RoomLayoutFB { - pub const TYPE: StructureType = StructureType::ROOM_LAYOUT_FB; +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq)] +#[doc = "See [XrExternalCameraExtrinsicsOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExternalCameraExtrinsicsOCULUS) - defined by [XR_OCULUS_external_camera](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_OCULUS_external_camera)"] +pub struct ExternalCameraExtrinsicsOCULUS { + pub last_change_time: Time, + pub camera_status_flags: ExternalCameraStatusFlagsOCULUS, + pub attached_to_device: ExternalCameraAttachedToDeviceOCULUS, + pub relative_pose: Posef, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrBoundary2DFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrBoundary2DFB) - defined by [XR_FB_scene](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene)"] -pub struct Boundary2DFB { +#[doc = "See [XrExternalCameraOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrExternalCameraOCULUS) - defined by [XR_OCULUS_external_camera](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_OCULUS_external_camera)"] +pub struct ExternalCameraOCULUS { pub ty: StructureType, pub next: *const c_void, - pub vertex_capacity_input: u32, - pub vertex_count_output: u32, - pub vertices: *mut Vector2f, + pub name: [c_char; MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS], + pub intrinsics: ExternalCameraIntrinsicsOCULUS, + pub extrinsics: ExternalCameraExtrinsicsOCULUS, } -impl Boundary2DFB { - pub const TYPE: StructureType = StructureType::BOUNDARY_2D_FB; +impl ExternalCameraOCULUS { + pub const TYPE: StructureType = StructureType::EXTERNAL_CAMERA_OCULUS; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemKeyboardTrackingPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemKeyboardTrackingPropertiesFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] -pub struct SystemKeyboardTrackingPropertiesFB { +#[doc = "See [XrPerformanceMetricsStateMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsStateMETA) - defined by [XR_META_performance_metrics](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_performance_metrics)"] +pub struct PerformanceMetricsStateMETA { pub ty: StructureType, - pub next: *mut c_void, - pub supports_keyboard_tracking: Bool32, + pub next: *const c_void, + pub enabled: Bool32, } -impl SystemKeyboardTrackingPropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PerformanceMetricsStateMETA { + pub const TYPE: StructureType = StructureType::PERFORMANCE_METRICS_STATE_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrKeyboardTrackingDescriptionFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingDescriptionFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] -pub struct KeyboardTrackingDescriptionFB { - pub tracked_keyboard_id: u64, - pub size: Vector3f, - pub flags: KeyboardTrackingFlagsFB, - pub name: [c_char; MAX_KEYBOARD_TRACKING_NAME_SIZE_FB], +#[doc = "See [XrPerformanceMetricsCounterMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterMETA) - defined by [XR_META_performance_metrics](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_performance_metrics)"] +pub struct PerformanceMetricsCounterMETA { + pub ty: StructureType, + pub next: *const c_void, + pub counter_flags: PerformanceMetricsCounterFlagsMETA, + pub counter_unit: PerformanceMetricsCounterUnitMETA, + pub uint_value: u32, + pub float_value: f32, +} +impl PerformanceMetricsCounterMETA { + pub const TYPE: StructureType = StructureType::PERFORMANCE_METRICS_COUNTER_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrKeyboardSpaceCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardSpaceCreateInfoFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] -pub struct KeyboardSpaceCreateInfoFB { +#[doc = "See [XrPassthroughPreferencesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughPreferencesMETA) - defined by [XR_META_passthrough_preferences](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_preferences)"] +pub struct PassthroughPreferencesMETA { pub ty: StructureType, - pub next: *mut c_void, - pub tracked_keyboard_id: u64, + pub next: *const c_void, + pub flags: PassthroughPreferenceFlagsMETA, } -impl KeyboardSpaceCreateInfoFB { - pub const TYPE: StructureType = StructureType::KEYBOARD_SPACE_CREATE_INFO_FB; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughPreferencesMETA { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_PREFERENCES_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrKeyboardTrackingQueryFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrKeyboardTrackingQueryFB) - defined by [XR_FB_keyboard_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_keyboard_tracking)"] -pub struct KeyboardTrackingQueryFB { +#[doc = "See [XrSystemHeadsetIdPropertiesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemHeadsetIdPropertiesMETA) - defined by [XR_META_headset_id](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_headset_id)"] +pub struct SystemHeadsetIdPropertiesMETA { pub ty: StructureType, pub next: *mut c_void, - pub flags: KeyboardTrackingQueryFlagsFB, + pub id: UuidEXT, } -impl KeyboardTrackingQueryFB { - pub const TYPE: StructureType = StructureType::KEYBOARD_TRACKING_QUERY_FB; +impl SystemHeadsetIdPropertiesMETA { + pub const TYPE: StructureType = StructureType::SYSTEM_HEADSET_ID_PROPERTIES_META; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6371,325 +8804,381 @@ impl KeyboardTrackingQueryFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerDepthTestVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerDepthTestVARJO) - defined by [XR_VARJO_composition_layer_depth_test](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_composition_layer_depth_test)"] -pub struct CompositionLayerDepthTestVARJO { - pub ty: StructureType, - pub next: *const c_void, - pub depth_test_range_near_z: f32, - pub depth_test_range_far_z: f32, -} -impl CompositionLayerDepthTestVARJO { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_DEPTH_TEST_VARJO; +#[doc = "See [XrPassthroughColorLutDataMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorLutDataMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct PassthroughColorLutDataMETA { + pub buffer_size: u32, + pub buffer: *const u8, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViewLocateFoveatedRenderingVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViewLocateFoveatedRenderingVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] -pub struct ViewLocateFoveatedRenderingVARJO { +#[doc = "See [XrPassthroughColorLutCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorLutCreateInfoMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct PassthroughColorLutCreateInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub foveated_rendering_active: Bool32, + pub channels: PassthroughColorLutChannelsMETA, + pub resolution: u32, + pub data: PassthroughColorLutDataMETA, } -impl ViewLocateFoveatedRenderingVARJO { - pub const TYPE: StructureType = StructureType::VIEW_LOCATE_FOVEATED_RENDERING_VARJO; +impl PassthroughColorLutCreateInfoMETA { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_LUT_CREATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFoveatedViewConfigurationViewVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveatedViewConfigurationViewVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] -pub struct FoveatedViewConfigurationViewVARJO { +#[doc = "See [XrPassthroughColorLutUpdateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorLutUpdateInfoMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct PassthroughColorLutUpdateInfoMETA { pub ty: StructureType, - pub next: *mut c_void, - pub foveated_rendering_active: Bool32, + pub next: *const c_void, + pub data: PassthroughColorLutDataMETA, } -impl FoveatedViewConfigurationViewVARJO { - pub const TYPE: StructureType = StructureType::FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughColorLutUpdateInfoMETA { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemFoveatedRenderingPropertiesVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFoveatedRenderingPropertiesVARJO) - defined by [XR_VARJO_foveated_rendering](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_foveated_rendering)"] -pub struct SystemFoveatedRenderingPropertiesVARJO { +#[doc = "See [XrPassthroughColorMapLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapLutMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct PassthroughColorMapLutMETA { pub ty: StructureType, - pub next: *mut c_void, - pub supports_foveated_rendering: Bool32, + pub next: *const c_void, + pub color_lut: PassthroughColorLutMETA, + pub weight: f32, } -impl SystemFoveatedRenderingPropertiesVARJO { - pub const TYPE: StructureType = StructureType::SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO; - #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] - #[inline] - pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { - let mut x = MaybeUninit::::uninit(); - unsafe { - (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { - ty: Self::TYPE, - next, - }); - } - x - } +impl PassthroughColorMapLutMETA { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_LUT_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerReprojectionInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerReprojectionInfoMSFT) - defined by [XR_MSFT_composition_layer_reprojection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_composition_layer_reprojection)"] -pub struct CompositionLayerReprojectionInfoMSFT { +#[doc = "See [XrPassthroughColorMapInterpolatedLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapInterpolatedLutMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct PassthroughColorMapInterpolatedLutMETA { pub ty: StructureType, pub next: *const c_void, - pub reprojection_mode: ReprojectionModeMSFT, + pub source_color_lut: PassthroughColorLutMETA, + pub target_color_lut: PassthroughColorLutMETA, + pub weight: f32, } -impl CompositionLayerReprojectionInfoMSFT { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_REPROJECTION_INFO_MSFT; +impl PassthroughColorMapInterpolatedLutMETA { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerReprojectionPlaneOverrideMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerReprojectionPlaneOverrideMSFT) - defined by [XR_MSFT_composition_layer_reprojection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_composition_layer_reprojection)"] -pub struct CompositionLayerReprojectionPlaneOverrideMSFT { +#[doc = "See [XrSystemPassthroughColorLutPropertiesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPassthroughColorLutPropertiesMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] +pub struct SystemPassthroughColorLutPropertiesMETA { pub ty: StructureType, pub next: *const c_void, - pub position: Vector3f, - pub normal: Vector3f, - pub velocity: Vector3f, + pub max_color_lut_resolution: u32, } -impl CompositionLayerReprojectionPlaneOverrideMSFT { - pub const TYPE: StructureType = - StructureType::COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT; +impl SystemPassthroughColorLutPropertiesMETA { + pub const TYPE: StructureType = StructureType::SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrTriangleMeshCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrTriangleMeshCreateInfoFB) - defined by [XR_FB_triangle_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_triangle_mesh)"] -pub struct TriangleMeshCreateInfoFB { +#[doc = "See [XrFoveationApplyInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationApplyInfoHTC) - defined by [XR_HTC_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation)"] +pub struct FoveationApplyInfoHTC { pub ty: StructureType, pub next: *const c_void, - pub flags: TriangleMeshFlagsFB, - pub winding_order: WindingOrderFB, - pub vertex_count: u32, - pub vertex_buffer: *const Vector3f, - pub triangle_count: u32, - pub index_buffer: *const u32, + pub mode: FoveationModeHTC, + pub sub_image_count: u32, + pub sub_images: *mut SwapchainSubImage, } -impl TriangleMeshCreateInfoFB { - pub const TYPE: StructureType = StructureType::TRIANGLE_MESH_CREATE_INFO_FB; +impl FoveationApplyInfoHTC { + pub const TYPE: StructureType = StructureType::FOVEATION_APPLY_INFO_HTC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq)] +#[doc = "See [XrFoveationConfigurationHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationConfigurationHTC) - defined by [XR_HTC_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation)"] +pub struct FoveationConfigurationHTC { + pub level: FoveationLevelHTC, + pub clear_fov_degree: f32, + pub focal_center_offset: Vector2f, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemPassthroughPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPassthroughPropertiesFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct SystemPassthroughPropertiesFB { +#[doc = "See [XrFoveationDynamicModeInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationDynamicModeInfoHTC) - defined by [XR_HTC_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation)"] +pub struct FoveationDynamicModeInfoHTC { pub ty: StructureType, pub next: *const c_void, - pub supports_passthrough: Bool32, + pub dynamic_flags: FoveationDynamicFlagsHTC, } -impl SystemPassthroughPropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_PASSTHROUGH_PROPERTIES_FB; +impl FoveationDynamicModeInfoHTC { + pub const TYPE: StructureType = StructureType::FOVEATION_DYNAMIC_MODE_INFO_HTC; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemPassthroughProperties2FB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPassthroughProperties2FB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct SystemPassthroughProperties2FB { +#[doc = "See [XrFoveationCustomModeInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFoveationCustomModeInfoHTC) - defined by [XR_HTC_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation)"] +pub struct FoveationCustomModeInfoHTC { pub ty: StructureType, pub next: *const c_void, - pub capabilities: PassthroughCapabilityFlagsFB, + pub config_count: u32, + pub configs: *const FoveationConfigurationHTC, } -impl SystemPassthroughProperties2FB { - pub const TYPE: StructureType = StructureType::SYSTEM_PASSTHROUGH_PROPERTIES2_FB; +impl FoveationCustomModeInfoHTC { + pub const TYPE: StructureType = StructureType::FOVEATION_CUSTOM_MODE_INFO_HTC; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughCreateInfoFB { +#[doc = "See [XrActiveActionSetPrioritiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActiveActionSetPrioritiesEXT) - defined by [XR_EXT_active_action_set_priority](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_active_action_set_priority)"] +pub struct ActiveActionSetPrioritiesEXT { pub ty: StructureType, pub next: *const c_void, - pub flags: PassthroughFlagsFB, + pub action_set_priority_count: u32, + pub action_set_priorities: *const ActiveActionSetPriorityEXT, } -impl PassthroughCreateInfoFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_CREATE_INFO_FB; +impl ActiveActionSetPrioritiesEXT { + pub const TYPE: StructureType = StructureType::ACTIVE_ACTION_SET_PRIORITIES_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughLayerCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughLayerCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughLayerCreateInfoFB { +#[doc = "See [XrActiveActionSetPriorityEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrActiveActionSetPriorityEXT) - defined by [XR_EXT_active_action_set_priority](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_active_action_set_priority)"] +pub struct ActiveActionSetPriorityEXT { + pub action_set: ActionSet, + pub priority_override: u32, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerDepthTestFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerDepthTestFB) - defined by [XR_FB_composition_layer_depth_test](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_depth_test)"] +pub struct CompositionLayerDepthTestFB { pub ty: StructureType, pub next: *const c_void, - pub passthrough: PassthroughFB, - pub flags: PassthroughFlagsFB, - pub purpose: PassthroughLayerPurposeFB, + pub depth_mask: Bool32, + pub compare_op: CompareOpFB, } -impl PassthroughLayerCreateInfoFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_LAYER_CREATE_INFO_FB; +impl CompositionLayerDepthTestFB { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_DEPTH_TEST_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerPassthroughFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerPassthroughFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct CompositionLayerPassthroughFB { +#[doc = "See [XrCoordinateSpaceCreateInfoML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCoordinateSpaceCreateInfoML)"] +pub struct CoordinateSpaceCreateInfoML { pub ty: StructureType, pub next: *const c_void, - pub flags: CompositionLayerFlags, - pub space: Space, - pub layer_handle: PassthroughLayerFB, + pub cfuid: MLCoordinateFrameUID, + pub pose_in_coordinate_space: Posef, } -impl CompositionLayerPassthroughFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PASSTHROUGH_FB; +impl CoordinateSpaceCreateInfoML { + pub const TYPE: StructureType = StructureType::COORDINATE_SPACE_CREATE_INFO_ML; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGeometryInstanceCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceCreateInfoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct GeometryInstanceCreateInfoFB { +#[doc = "See [XrFrameEndInfoML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFrameEndInfoML) - defined by [XR_ML_frame_end_info](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_ML_frame_end_info)"] +pub struct FrameEndInfoML { pub ty: StructureType, pub next: *const c_void, - pub layer: PassthroughLayerFB, - pub mesh: TriangleMeshFB, - pub base_space: Space, - pub pose: Posef, - pub scale: Vector3f, + pub focus_distance: f32, + pub flags: FrameEndInfoFlagsML, } -impl GeometryInstanceCreateInfoFB { - pub const TYPE: StructureType = StructureType::GEOMETRY_INSTANCE_CREATE_INFO_FB; +impl FrameEndInfoML { + pub const TYPE: StructureType = StructureType::FRAME_END_INFO_ML; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrGeometryInstanceTransformFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrGeometryInstanceTransformFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct GeometryInstanceTransformFB { +#[doc = "See [XrHapticAmplitudeEnvelopeVibrationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticAmplitudeEnvelopeVibrationFB) - defined by [XR_FB_haptic_amplitude_envelope](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_haptic_amplitude_envelope)"] +pub struct HapticAmplitudeEnvelopeVibrationFB { pub ty: StructureType, pub next: *const c_void, - pub base_space: Space, - pub time: Time, - pub pose: Posef, - pub scale: Vector3f, + pub duration: Duration, + pub amplitude_count: u32, + pub amplitudes: *const f32, } -impl GeometryInstanceTransformFB { - pub const TYPE: StructureType = StructureType::GEOMETRY_INSTANCE_TRANSFORM_FB; +impl HapticAmplitudeEnvelopeVibrationFB { + pub const TYPE: StructureType = StructureType::HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughStyleFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughStyleFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughStyleFB { +#[doc = "See [XrHapticPcmVibrationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrHapticPcmVibrationFB) - defined by [XR_FB_haptic_pcm](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_haptic_pcm)"] +pub struct HapticPcmVibrationFB { pub ty: StructureType, pub next: *const c_void, - pub texture_opacity_factor: f32, - pub edge_color: Color4f, + pub buffer_size: u32, + pub buffer: *const f32, + pub sample_rate: f32, + pub append: Bool32, + pub samples_consumed: *mut u32, } -impl PassthroughStyleFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_STYLE_FB; +impl HapticPcmVibrationFB { + pub const TYPE: StructureType = StructureType::HAPTIC_PCM_VIBRATION_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughColorMapMonoToRgbaFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapMonoToRgbaFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughColorMapMonoToRgbaFB { +#[doc = "See [XrDevicePcmSampleRateStateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDevicePcmSampleRateStateFB) - defined by [XR_FB_haptic_pcm](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_haptic_pcm)"] +pub struct DevicePcmSampleRateStateFB { pub ty: StructureType, - pub next: *const c_void, - pub texture_color_map: [Color4f; PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB], + pub next: *mut c_void, + pub sample_rate: f32, } -impl PassthroughColorMapMonoToRgbaFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB; +impl DevicePcmSampleRateStateFB { + pub const TYPE: StructureType = StructureType::DEVICE_PCM_SAMPLE_RATE_STATE_FB; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughColorMapMonoToMonoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorMapMonoToMonoFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughColorMapMonoToMonoFB { +#[doc = "See [XrSpaceUserCreateInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpaceUserCreateInfoFB) - defined by [XR_FB_spatial_entity_user](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_user)"] +pub struct SpaceUserCreateInfoFB { pub ty: StructureType, pub next: *const c_void, - pub texture_color_map: [u8; PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB], + pub user_id: SpaceUserIdFB, } -impl PassthroughColorMapMonoToMonoFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB; +impl SpaceUserCreateInfoFB { + pub const TYPE: StructureType = StructureType::SPACE_USER_CREATE_INFO_FB; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughBrightnessContrastSaturationFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughBrightnessContrastSaturationFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct PassthroughBrightnessContrastSaturationFB { +#[doc = "See [XrSystemForceFeedbackCurlPropertiesMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemForceFeedbackCurlPropertiesMNDX) - defined by [XR_MNDX_force_feedback_curl](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_force_feedback_curl)"] +pub struct SystemForceFeedbackCurlPropertiesMNDX { pub ty: StructureType, - pub next: *const c_void, - pub brightness: f32, - pub contrast: f32, - pub saturation: f32, + pub next: *mut c_void, + pub supports_force_feedback_curl: Bool32, } -impl PassthroughBrightnessContrastSaturationFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB; +impl SystemForceFeedbackCurlPropertiesMNDX { + pub const TYPE: StructureType = StructureType::SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataPassthroughStateChangedFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataPassthroughStateChangedFB) - defined by [XR_FB_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough)"] -pub struct EventDataPassthroughStateChangedFB { +#[doc = "See [XrForceFeedbackCurlApplyLocationsMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrForceFeedbackCurlApplyLocationsMNDX) - defined by [XR_MNDX_force_feedback_curl](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_force_feedback_curl)"] +pub struct ForceFeedbackCurlApplyLocationsMNDX { pub ty: StructureType, pub next: *const c_void, - pub flags: PassthroughStateChangedFlagsFB, + pub location_count: u32, + pub locations: *mut ForceFeedbackCurlApplyLocationMNDX, } -impl EventDataPassthroughStateChangedFB { - pub const TYPE: StructureType = StructureType::EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB; +impl ForceFeedbackCurlApplyLocationsMNDX { + pub const TYPE: StructureType = StructureType::FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX; +} +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq)] +#[doc = "See [XrForceFeedbackCurlApplyLocationMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrForceFeedbackCurlApplyLocationMNDX) - defined by [XR_MNDX_force_feedback_curl](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_force_feedback_curl)"] +pub struct ForceFeedbackCurlApplyLocationMNDX { + pub location: ForceFeedbackCurlLocationMNDX, + pub value: f32, } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPassthroughKeyboardHandsIntensityFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughKeyboardHandsIntensityFB) - defined by [XR_FB_passthrough_keyboard_hands](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough_keyboard_hands)"] -pub struct PassthroughKeyboardHandsIntensityFB { +#[doc = "See [XrSystemPlaneDetectionPropertiesEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemPlaneDetectionPropertiesEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct SystemPlaneDetectionPropertiesEXT { pub ty: StructureType, - pub next: *const c_void, - pub left_hand_intensity: f32, - pub right_hand_intensity: f32, + pub next: *mut c_void, + pub supported_features: PlaneDetectionCapabilityFlagsEXT, } -impl PassthroughKeyboardHandsIntensityFB { - pub const TYPE: StructureType = StructureType::PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB; +impl SystemPlaneDetectionPropertiesEXT { + pub const TYPE: StructureType = StructureType::SYSTEM_PLANE_DETECTION_PROPERTIES_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorPersistenceNameMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorPersistenceNameMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] -pub struct SpatialAnchorPersistenceNameMSFT { - pub name: [c_char; MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT], +#[doc = "See [XrPlaneDetectorCreateInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorCreateInfoEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorCreateInfoEXT { + pub ty: StructureType, + pub next: *const c_void, + pub flags: PlaneDetectorFlagsEXT, +} +impl PlaneDetectorCreateInfoEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_CREATE_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorPersistenceInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorPersistenceInfoMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] -pub struct SpatialAnchorPersistenceInfoMSFT { +#[doc = "See [XrPlaneDetectorBeginInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorBeginInfoEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorBeginInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub spatial_anchor_persistence_name: SpatialAnchorPersistenceNameMSFT, - pub spatial_anchor: SpatialAnchorMSFT, + pub base_space: Space, + pub time: Time, + pub orientation_count: u32, + pub orientations: *const PlaneDetectorOrientationEXT, + pub semantic_type_count: u32, + pub semantic_types: *const PlaneDetectorSemanticTypeEXT, + pub max_planes: u32, + pub min_area: f32, + pub bounding_box_pose: Posef, + pub bounding_box_extent: Extent3DfEXT, } -impl SpatialAnchorPersistenceInfoMSFT { - pub const TYPE: StructureType = StructureType::SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT; +impl PlaneDetectorBeginInfoEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_BEGIN_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT) - defined by [XR_MSFT_spatial_anchor_persistence](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_spatial_anchor_persistence)"] -pub struct SpatialAnchorFromPersistedAnchorCreateInfoMSFT { +#[doc = "See [XrPlaneDetectorGetInfoEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorGetInfoEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorGetInfoEXT { pub ty: StructureType, pub next: *const c_void, - pub spatial_anchor_store: SpatialAnchorStoreConnectionMSFT, - pub spatial_anchor_persistence_name: SpatialAnchorPersistenceNameMSFT, + pub base_space: Space, + pub time: Time, } -impl SpatialAnchorFromPersistedAnchorCreateInfoMSFT { - pub const TYPE: StructureType = - StructureType::SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT; +impl PlaneDetectorGetInfoEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_GET_INFO_EXT; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFacialTrackerCreateInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialTrackerCreateInfoHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] -pub struct FacialTrackerCreateInfoHTC { +#[doc = "See [XrPlaneDetectorLocationsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorLocationsEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorLocationsEXT { pub ty: StructureType, - pub next: *const c_void, - pub facial_tracking_type: FacialTrackingTypeHTC, + pub next: *mut c_void, + pub plane_location_capacity_input: u32, + pub plane_location_count_output: u32, + pub plane_locations: *mut PlaneDetectorLocationEXT, } -impl FacialTrackerCreateInfoHTC { - pub const TYPE: StructureType = StructureType::FACIAL_TRACKER_CREATE_INFO_HTC; +impl PlaneDetectorLocationsEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_LOCATIONS_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemFacialTrackingPropertiesHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemFacialTrackingPropertiesHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] -pub struct SystemFacialTrackingPropertiesHTC { +#[doc = "See [XrPlaneDetectorLocationEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorLocationEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorLocationEXT { pub ty: StructureType, pub next: *mut c_void, - pub support_eye_facial_tracking: Bool32, - pub support_lip_facial_tracking: Bool32, + pub plane_id: u64, + pub location_flags: SpaceLocationFlags, + pub pose: Posef, + pub extents: Extent2Df, + pub orientation: PlaneDetectorOrientationEXT, + pub semantic_type: PlaneDetectorSemanticTypeEXT, + pub polygon_buffer_count: u32, } -impl SystemFacialTrackingPropertiesHTC { - pub const TYPE: StructureType = StructureType::SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC; +impl PlaneDetectorLocationEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_LOCATION_EXT; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6705,29 +9194,39 @@ impl SystemFacialTrackingPropertiesHTC { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrFacialExpressionsHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrFacialExpressionsHTC) - defined by [XR_HTC_facial_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_facial_tracking)"] -pub struct FacialExpressionsHTC { +#[doc = "See [XrPlaneDetectorPolygonBufferEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPlaneDetectorPolygonBufferEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] +pub struct PlaneDetectorPolygonBufferEXT { pub ty: StructureType, - pub next: *const c_void, - pub is_active: Bool32, - pub sample_time: Time, - pub expression_count: u32, - pub expression_weightings: *mut f32, + pub next: *mut c_void, + pub vertex_capacity_input: u32, + pub vertex_count_output: u32, + pub vertices: *mut Vector2f, } -impl FacialExpressionsHTC { - pub const TYPE: StructureType = StructureType::FACIAL_EXPRESSIONS_HTC; +impl PlaneDetectorPolygonBufferEXT { + pub const TYPE: StructureType = StructureType::PLANE_DETECTOR_POLYGON_BUFFER_EXT; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrViveTrackerPathsHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViveTrackerPathsHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] -pub struct ViveTrackerPathsHTCX { +#[doc = "See [XrSystemVirtualKeyboardPropertiesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemVirtualKeyboardPropertiesMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct SystemVirtualKeyboardPropertiesMETA { pub ty: StructureType, pub next: *mut c_void, - pub persistent_path: Path, - pub role_path: Path, + pub supports_virtual_keyboard: Bool32, } -impl ViveTrackerPathsHTCX { - pub const TYPE: StructureType = StructureType::VIVE_TRACKER_PATHS_HTCX; +impl SystemVirtualKeyboardPropertiesMETA { + pub const TYPE: StructureType = StructureType::SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6743,44 +9242,63 @@ impl ViveTrackerPathsHTCX { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataViveTrackerConnectedHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataViveTrackerConnectedHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] -pub struct EventDataViveTrackerConnectedHTCX { +#[doc = "See [XrVirtualKeyboardCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardCreateInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardCreateInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub paths: *mut ViveTrackerPathsHTCX, } -impl EventDataViveTrackerConnectedHTCX { - pub const TYPE: StructureType = StructureType::EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX; +impl VirtualKeyboardCreateInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_CREATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerSpaceWarpInfoFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSpaceWarpInfoFB) - defined by [XR_FB_space_warp](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_space_warp)"] -pub struct CompositionLayerSpaceWarpInfoFB { +#[doc = "See [XrVirtualKeyboardSpaceCreateInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardSpaceCreateInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardSpaceCreateInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerSpaceWarpInfoFlagsFB, - pub motion_vector_sub_image: SwapchainSubImage, - pub app_space_delta_pose: Posef, - pub depth_sub_image: SwapchainSubImage, - pub min_depth: f32, - pub max_depth: f32, - pub near_z: f32, - pub far_z: f32, + pub location_type: VirtualKeyboardLocationTypeMETA, + pub space: Space, + pub pose_in_space: Posef, } -impl CompositionLayerSpaceWarpInfoFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SPACE_WARP_INFO_FB; +impl VirtualKeyboardSpaceCreateInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemSpaceWarpPropertiesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemSpaceWarpPropertiesFB) - defined by [XR_FB_space_warp](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_space_warp)"] -pub struct SystemSpaceWarpPropertiesFB { +#[doc = "See [XrVirtualKeyboardLocationInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardLocationInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardLocationInfoMETA { + pub ty: StructureType, + pub next: *const c_void, + pub location_type: VirtualKeyboardLocationTypeMETA, + pub space: Space, + pub pose_in_space: Posef, + pub scale: f32, +} +impl VirtualKeyboardLocationInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_LOCATION_INFO_META; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrVirtualKeyboardModelVisibilitySetInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardModelVisibilitySetInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardModelVisibilitySetInfoMETA { + pub ty: StructureType, + pub next: *const c_void, + pub visible: Bool32, +} +impl VirtualKeyboardModelVisibilitySetInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrVirtualKeyboardAnimationStateMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardAnimationStateMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardAnimationStateMETA { pub ty: StructureType, pub next: *mut c_void, - pub recommended_motion_vector_image_rect_width: u32, - pub recommended_motion_vector_image_rect_height: u32, + pub animation_index: i32, + pub fraction: f32, } -impl SystemSpaceWarpPropertiesFB { - pub const TYPE: StructureType = StructureType::SYSTEM_SPACE_WARP_PROPERTIES_FB; +impl VirtualKeyboardAnimationStateMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_ANIMATION_STATE_META; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6796,14 +9314,16 @@ impl SystemSpaceWarpPropertiesFB { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrSystemMarkerTrackingPropertiesVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemMarkerTrackingPropertiesVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] -pub struct SystemMarkerTrackingPropertiesVARJO { +#[doc = "See [XrVirtualKeyboardModelAnimationStatesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardModelAnimationStatesMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardModelAnimationStatesMETA { pub ty: StructureType, pub next: *mut c_void, - pub supports_marker_tracking: Bool32, + pub state_capacity_input: u32, + pub state_count_output: u32, + pub states: *mut VirtualKeyboardAnimationStateMETA, } -impl SystemMarkerTrackingPropertiesVARJO { - pub const TYPE: StructureType = StructureType::SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO; +impl VirtualKeyboardModelAnimationStatesMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META; #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] #[inline] pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { @@ -6819,86 +9339,116 @@ impl SystemMarkerTrackingPropertiesVARJO { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrEventDataMarkerTrackingUpdateVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataMarkerTrackingUpdateVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] -pub struct EventDataMarkerTrackingUpdateVARJO { +#[doc = "See [XrVirtualKeyboardTextureDataMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardTextureDataMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardTextureDataMETA { + pub ty: StructureType, + pub next: *mut c_void, + pub texture_width: u32, + pub texture_height: u32, + pub buffer_capacity_input: u32, + pub buffer_count_output: u32, + pub buffer: *mut u8, +} +impl VirtualKeyboardTextureDataMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_TEXTURE_DATA_META; + #[doc = r" Construct a partially-initialized value suitable for passing to OpenXR"] + #[inline] + pub fn out(next: *mut BaseOutStructure) -> MaybeUninit { + let mut x = MaybeUninit::::uninit(); + unsafe { + (x.as_mut_ptr() as *mut BaseOutStructure).write(BaseOutStructure { + ty: Self::TYPE, + next, + }); + } + x + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrVirtualKeyboardInputInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardInputInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardInputInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub marker_id: u64, - pub is_active: Bool32, - pub is_predicted: Bool32, - pub time: Time, + pub input_source: VirtualKeyboardInputSourceMETA, + pub input_space: Space, + pub input_pose_in_space: Posef, + pub input_state: VirtualKeyboardInputStateFlagsMETA, } -impl EventDataMarkerTrackingUpdateVARJO { - pub const TYPE: StructureType = StructureType::EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO; +impl VirtualKeyboardInputInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_INPUT_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrMarkerSpaceCreateInfoVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrMarkerSpaceCreateInfoVARJO) - defined by [XR_VARJO_marker_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_marker_tracking)"] -pub struct MarkerSpaceCreateInfoVARJO { +#[doc = "See [XrVirtualKeyboardTextContextChangeInfoMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVirtualKeyboardTextContextChangeInfoMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct VirtualKeyboardTextContextChangeInfoMETA { pub ty: StructureType, pub next: *const c_void, - pub marker_id: u64, - pub pose_in_marker_space: Posef, + pub text_context: *const c_char, } -impl MarkerSpaceCreateInfoVARJO { - pub const TYPE: StructureType = StructureType::MARKER_SPACE_CREATE_INFO_VARJO; +impl VirtualKeyboardTextContextChangeInfoMETA { + pub const TYPE: StructureType = StructureType::VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrUuidEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrUuidEXT) - defined by [XR_EXT_uuid](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_uuid)"] -pub struct UuidEXT { - pub data: [u8; UUID_SIZE_EXT], +#[doc = "See [XrEventDataVirtualKeyboardCommitTextMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVirtualKeyboardCommitTextMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct EventDataVirtualKeyboardCommitTextMETA { + pub ty: StructureType, + pub next: *const c_void, + pub keyboard: VirtualKeyboardMETA, + pub text: [c_char; MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META], +} +impl EventDataVirtualKeyboardCommitTextMETA { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrDigitalLensControlALMALENCE](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrDigitalLensControlALMALENCE)"] -pub struct DigitalLensControlALMALENCE { +#[doc = "See [XrEventDataVirtualKeyboardBackspaceMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVirtualKeyboardBackspaceMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct EventDataVirtualKeyboardBackspaceMETA { pub ty: StructureType, pub next: *const c_void, - pub flags: DigitalLensControlFlagsALMALENCE, + pub keyboard: VirtualKeyboardMETA, } -impl DigitalLensControlALMALENCE { - pub const TYPE: StructureType = StructureType::DIGITAL_LENS_CONTROL_ALMALENCE; +impl EventDataVirtualKeyboardBackspaceMETA { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrCompositionLayerSettingsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerSettingsFB) - defined by [XR_FB_composition_layer_settings](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_composition_layer_settings)"] -pub struct CompositionLayerSettingsFB { +#[doc = "See [XrEventDataVirtualKeyboardEnterMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVirtualKeyboardEnterMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct EventDataVirtualKeyboardEnterMETA { pub ty: StructureType, pub next: *const c_void, - pub layer_flags: CompositionLayerSettingsFlagsFB, + pub keyboard: VirtualKeyboardMETA, } -impl CompositionLayerSettingsFB { - pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_SETTINGS_FB; +impl EventDataVirtualKeyboardEnterMETA { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPerformanceMetricsStateMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsStateMETA) - defined by [XR_META_performance_metrics](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_performance_metrics)"] -pub struct PerformanceMetricsStateMETA { +#[doc = "See [XrEventDataVirtualKeyboardShownMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVirtualKeyboardShownMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct EventDataVirtualKeyboardShownMETA { pub ty: StructureType, pub next: *const c_void, - pub enabled: Bool32, + pub keyboard: VirtualKeyboardMETA, } -impl PerformanceMetricsStateMETA { - pub const TYPE: StructureType = StructureType::PERFORMANCE_METRICS_STATE_META; +impl EventDataVirtualKeyboardShownMETA { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META; } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = "See [XrPerformanceMetricsCounterMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPerformanceMetricsCounterMETA) - defined by [XR_META_performance_metrics](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_performance_metrics)"] -pub struct PerformanceMetricsCounterMETA { +#[doc = "See [XrEventDataVirtualKeyboardHiddenMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrEventDataVirtualKeyboardHiddenMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] +pub struct EventDataVirtualKeyboardHiddenMETA { pub ty: StructureType, pub next: *const c_void, - pub counter_flags: PerformanceMetricsCounterFlagsMETA, - pub counter_unit: PerformanceMetricsCounterUnitMETA, - pub uint_value: u32, - pub float_value: f32, + pub keyboard: VirtualKeyboardMETA, } -impl PerformanceMetricsCounterMETA { - pub const TYPE: StructureType = StructureType::PERFORMANCE_METRICS_COUNTER_META; +impl EventDataVirtualKeyboardHiddenMETA { + pub const TYPE: StructureType = StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META; } #[doc = r" Function pointer prototypes"] pub mod pfn { use super::*; + pub use crate::platform::EglGetProcAddressMNDX; pub type VoidFunction = unsafe extern "system" fn(); pub type DebugUtilsMessengerCallbackEXT = unsafe extern "system" fn( DebugUtilsMessageSeverityFlagsEXT, @@ -7466,6 +10016,55 @@ pub mod pfn { locate_info: *const HandJointsLocateInfoEXT, locations: *mut HandJointLocationsEXT, ) -> Result; + #[doc = "See [xrCreateFaceTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateFaceTrackerFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] + pub type CreateFaceTrackerFB = unsafe extern "system" fn( + session: Session, + create_info: *const FaceTrackerCreateInfoFB, + face_tracker: *mut FaceTrackerFB, + ) -> Result; + #[doc = "See [xrDestroyFaceTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyFaceTrackerFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] + pub type DestroyFaceTrackerFB = + unsafe extern "system" fn(face_tracker: FaceTrackerFB) -> Result; + #[doc = "See [xrGetFaceExpressionWeightsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetFaceExpressionWeightsFB) - defined by [XR_FB_face_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_face_tracking)"] + pub type GetFaceExpressionWeightsFB = unsafe extern "system" fn( + face_tracker: FaceTrackerFB, + expression_info: *const FaceExpressionInfoFB, + expression_weights: *mut FaceExpressionWeightsFB, + ) -> Result; + #[doc = "See [xrCreateBodyTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateBodyTrackerFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] + pub type CreateBodyTrackerFB = unsafe extern "system" fn( + session: Session, + create_info: *const BodyTrackerCreateInfoFB, + body_tracker: *mut BodyTrackerFB, + ) -> Result; + #[doc = "See [xrDestroyBodyTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyBodyTrackerFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] + pub type DestroyBodyTrackerFB = + unsafe extern "system" fn(body_tracker: BodyTrackerFB) -> Result; + #[doc = "See [xrLocateBodyJointsFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrLocateBodyJointsFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] + pub type LocateBodyJointsFB = unsafe extern "system" fn( + body_tracker: BodyTrackerFB, + locate_info: *const BodyJointsLocateInfoFB, + locations: *mut BodyJointLocationsFB, + ) -> Result; + #[doc = "See [xrGetBodySkeletonFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetBodySkeletonFB) - defined by [XR_FB_body_tracking](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_body_tracking)"] + pub type GetBodySkeletonFB = unsafe extern "system" fn( + body_tracker: BodyTrackerFB, + skeleton: *mut BodySkeletonFB, + ) -> Result; + #[doc = "See [xrCreateEyeTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateEyeTrackerFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] + pub type CreateEyeTrackerFB = unsafe extern "system" fn( + session: Session, + create_info: *const EyeTrackerCreateInfoFB, + eye_tracker: *mut EyeTrackerFB, + ) -> Result; + #[doc = "See [xrDestroyEyeTrackerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyEyeTrackerFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] + pub type DestroyEyeTrackerFB = unsafe extern "system" fn(eye_tracker: EyeTrackerFB) -> Result; + #[doc = "See [xrGetEyeGazesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetEyeGazesFB) - defined by [XR_FB_eye_tracking_social](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_eye_tracking_social)"] + pub type GetEyeGazesFB = unsafe extern "system" fn( + eye_tracker: EyeTrackerFB, + gaze_info: *const EyeGazesInfoFB, + eye_gazes: *mut EyeGazesFB, + ) -> Result; #[doc = "See [xrCreateHandMeshSpaceMSFT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateHandMeshSpaceMSFT) - defined by [XR_MSFT_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MSFT_hand_tracking_mesh)"] pub type CreateHandMeshSpaceMSFT = unsafe extern "system" fn( hand_tracker: HandTrackerEXT, @@ -7560,6 +10159,11 @@ pub mod pfn { #[doc = "See [xrDestroyFoveationProfileFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyFoveationProfileFB) - defined by [XR_FB_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_foveation)"] pub type DestroyFoveationProfileFB = unsafe extern "system" fn(profile: FoveationProfileFB) -> Result; + #[doc = "See [xrGetFoveationEyeTrackedStateMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetFoveationEyeTrackedStateMETA) - defined by [XR_META_foveation_eye_tracked](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_foveation_eye_tracked)"] + pub type GetFoveationEyeTrackedStateMETA = unsafe extern "system" fn( + session: Session, + foveation_state: *mut FoveationEyeTrackedStateMETA, + ) -> Result; #[doc = "See [xrGetHandMeshFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetHandMeshFB) - defined by [XR_FB_hand_tracking_mesh](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_hand_tracking_mesh)"] pub type GetHandMeshFB = unsafe extern "system" fn( hand_tracker: HandTrackerEXT, @@ -7741,6 +10345,18 @@ pub mod pfn { info: *const SpaceEraseInfoFB, request_id: *mut AsyncRequestIdFB, ) -> Result; + #[doc = "See [xrSaveSpaceListFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSaveSpaceListFB) - defined by [XR_FB_spatial_entity_storage_batch](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_storage_batch)"] + pub type SaveSpaceListFB = unsafe extern "system" fn( + session: Session, + info: *const SpaceListSaveInfoFB, + request_id: *mut AsyncRequestIdFB, + ) -> Result; + #[doc = "See [xrShareSpacesFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrShareSpacesFB) - defined by [XR_FB_spatial_entity_sharing](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_sharing)"] + pub type ShareSpacesFB = unsafe extern "system" fn( + session: Session, + info: *const SpaceShareInfoFB, + request_id: *mut AsyncRequestIdFB, + ) -> Result; #[doc = "See [xrGetSpaceContainerFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetSpaceContainerFB) - defined by [XR_FB_spatial_entity_container](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_container)"] pub type GetSpaceContainerFB = unsafe extern "system" fn( session: Session, @@ -7777,6 +10393,12 @@ pub mod pfn { space: Space, room_layout_output: *mut RoomLayoutFB, ) -> Result; + #[doc = "See [xrRequestSceneCaptureFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrRequestSceneCaptureFB) - defined by [XR_FB_scene_capture](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_scene_capture)"] + pub type RequestSceneCaptureFB = unsafe extern "system" fn( + session: Session, + info: *const SceneCaptureRequestInfoFB, + request_id: *mut AsyncRequestIdFB, + ) -> Result; #[doc = "See [xrPassthroughLayerSetKeyboardHandsIntensityFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrPassthroughLayerSetKeyboardHandsIntensityFB) - defined by [XR_FB_passthrough_keyboard_hands](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_passthrough_keyboard_hands)"] pub type PassthroughLayerSetKeyboardHandsIntensityFB = unsafe extern "system" fn( layer: PassthroughLayerFB, @@ -7863,6 +10485,27 @@ pub mod pfn { #[doc = "See [xrSetViewOffsetVARJO](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSetViewOffsetVARJO) - defined by [XR_VARJO_view_offset](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_VARJO_view_offset)"] pub type SetViewOffsetVARJO = unsafe extern "system" fn(session: Session, offset: f32) -> Result; + #[doc = "See [xrEnumerateExternalCamerasOCULUS](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrEnumerateExternalCamerasOCULUS) - defined by [XR_OCULUS_external_camera](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_OCULUS_external_camera)"] + pub type EnumerateExternalCamerasOCULUS = unsafe extern "system" fn( + session: Session, + camera_capacity_input: u32, + camera_count_output: *mut u32, + cameras: *mut ExternalCameraOCULUS, + ) -> Result; + #[doc = "See [xrCreatePassthroughColorLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreatePassthroughColorLutMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] + pub type CreatePassthroughColorLutMETA = unsafe extern "system" fn( + passthrough: PassthroughFB, + create_info: *const PassthroughColorLutCreateInfoMETA, + color_lut: *mut PassthroughColorLutMETA, + ) -> Result; + #[doc = "See [xrDestroyPassthroughColorLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyPassthroughColorLutMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] + pub type DestroyPassthroughColorLutMETA = + unsafe extern "system" fn(color_lut: PassthroughColorLutMETA) -> Result; + #[doc = "See [xrUpdatePassthroughColorLutMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrUpdatePassthroughColorLutMETA) - defined by [XR_META_passthrough_color_lut](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_color_lut)"] + pub type UpdatePassthroughColorLutMETA = unsafe extern "system" fn( + color_lut: PassthroughColorLutMETA, + update_info: *const PassthroughColorLutUpdateInfoMETA, + ) -> Result; #[doc = "See [xrEnumeratePerformanceMetricsCounterPathsMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrEnumeratePerformanceMetricsCounterPathsMETA) - defined by [XR_META_performance_metrics](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_performance_metrics)"] pub type EnumeratePerformanceMetricsCounterPathsMETA = unsafe extern "system" fn( instance: Instance, @@ -7886,6 +10529,140 @@ pub mod pfn { counter_path: Path, counter: *mut PerformanceMetricsCounterMETA, ) -> Result; + #[doc = "See [xrGetPassthroughPreferencesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetPassthroughPreferencesMETA) - defined by [XR_META_passthrough_preferences](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_passthrough_preferences)"] + pub type GetPassthroughPreferencesMETA = unsafe extern "system" fn( + session: Session, + preferences: *mut PassthroughPreferencesMETA, + ) -> Result; + #[doc = "See [xrApplyFoveationHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrApplyFoveationHTC) - defined by [XR_HTC_foveation](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_foveation)"] + pub type ApplyFoveationHTC = unsafe extern "system" fn( + session: Session, + apply_info: *const FoveationApplyInfoHTC, + ) -> Result; + #[doc = "See [xrCreateSpaceFromCoordinateFrameUIDML](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateSpaceFromCoordinateFrameUIDML) - defined by [XR_ML_compat](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_ML_compat)"] + pub type CreateSpaceFromCoordinateFrameUIDML = unsafe extern "system" fn( + session: Session, + create_info: *const CoordinateSpaceCreateInfoML, + space: *mut Space, + ) -> Result; + #[doc = "See [xrGetDeviceSampleRateFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetDeviceSampleRateFB) - defined by [XR_FB_haptic_pcm](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_haptic_pcm)"] + pub type GetDeviceSampleRateFB = unsafe extern "system" fn( + session: Session, + haptic_action_info: *const HapticActionInfo, + device_sample_rate: *mut DevicePcmSampleRateGetInfoFB, + ) -> Result; + #[doc = "See [xrSetTrackingOptimizationSettingsHintQCOM](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSetTrackingOptimizationSettingsHintQCOM) - defined by [XR_QCOM_tracking_optimization_settings](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_QCOM_tracking_optimization_settings)"] + pub type SetTrackingOptimizationSettingsHintQCOM = unsafe extern "system" fn( + session: Session, + domain: TrackingOptimizationSettingsDomainQCOM, + hint: TrackingOptimizationSettingsHintQCOM, + ) -> Result; + #[doc = "See [xrCreateSpaceUserFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateSpaceUserFB) - defined by [XR_FB_spatial_entity_user](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_user)"] + pub type CreateSpaceUserFB = unsafe extern "system" fn( + session: Session, + info: *const SpaceUserCreateInfoFB, + user: *mut SpaceUserFB, + ) -> Result; + #[doc = "See [xrGetSpaceUserIdFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetSpaceUserIdFB) - defined by [XR_FB_spatial_entity_user](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_user)"] + pub type GetSpaceUserIdFB = + unsafe extern "system" fn(user: SpaceUserFB, user_id: *mut SpaceUserIdFB) -> Result; + #[doc = "See [xrDestroySpaceUserFB](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroySpaceUserFB) - defined by [XR_FB_spatial_entity_user](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_FB_spatial_entity_user)"] + pub type DestroySpaceUserFB = unsafe extern "system" fn(user: SpaceUserFB) -> Result; + #[doc = "See [xrApplyForceFeedbackCurlMNDX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrApplyForceFeedbackCurlMNDX) - defined by [XR_MNDX_force_feedback_curl](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_MNDX_force_feedback_curl)"] + pub type ApplyForceFeedbackCurlMNDX = unsafe extern "system" fn( + hand_tracker: HandTrackerEXT, + locations: *const ForceFeedbackCurlApplyLocationsMNDX, + ) -> Result; + #[doc = "See [xrCreatePlaneDetectorEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreatePlaneDetectorEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type CreatePlaneDetectorEXT = unsafe extern "system" fn( + session: Session, + create_info: *const PlaneDetectorCreateInfoEXT, + plane_detector: *mut PlaneDetectorEXT, + ) -> Result; + #[doc = "See [xrDestroyPlaneDetectorEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyPlaneDetectorEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type DestroyPlaneDetectorEXT = + unsafe extern "system" fn(plane_detector: PlaneDetectorEXT) -> Result; + #[doc = "See [xrBeginPlaneDetectionEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrBeginPlaneDetectionEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type BeginPlaneDetectionEXT = unsafe extern "system" fn( + plane_detector: PlaneDetectorEXT, + begin_info: *const PlaneDetectorBeginInfoEXT, + ) -> Result; + #[doc = "See [xrGetPlaneDetectionStateEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetPlaneDetectionStateEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type GetPlaneDetectionStateEXT = unsafe extern "system" fn( + plane_detector: PlaneDetectorEXT, + state: *mut PlaneDetectionStateEXT, + ) -> Result; + #[doc = "See [xrGetPlaneDetectionsEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetPlaneDetectionsEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type GetPlaneDetectionsEXT = unsafe extern "system" fn( + plane_detector: PlaneDetectorEXT, + info: *const PlaneDetectorGetInfoEXT, + locations: *mut PlaneDetectorLocationsEXT, + ) -> Result; + #[doc = "See [xrGetPlanePolygonBufferEXT](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetPlanePolygonBufferEXT) - defined by [XR_EXT_plane_detection](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_EXT_plane_detection)"] + pub type GetPlanePolygonBufferEXT = unsafe extern "system" fn( + plane_detector: PlaneDetectorEXT, + plane_id: u64, + polygon_buffer_index: u32, + polygon_buffer: *mut PlaneDetectorPolygonBufferEXT, + ) -> Result; + #[doc = "See [xrCreateVirtualKeyboardMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateVirtualKeyboardMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type CreateVirtualKeyboardMETA = unsafe extern "system" fn( + session: Session, + create_info: *const VirtualKeyboardCreateInfoMETA, + keyboard: *mut VirtualKeyboardMETA, + ) -> Result; + #[doc = "See [xrDestroyVirtualKeyboardMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyVirtualKeyboardMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type DestroyVirtualKeyboardMETA = + unsafe extern "system" fn(keyboard: VirtualKeyboardMETA) -> Result; + #[doc = "See [xrCreateVirtualKeyboardSpaceMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreateVirtualKeyboardSpaceMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type CreateVirtualKeyboardSpaceMETA = unsafe extern "system" fn( + session: Session, + keyboard: VirtualKeyboardMETA, + create_info: *const VirtualKeyboardSpaceCreateInfoMETA, + keyboard_space: *mut Space, + ) -> Result; + #[doc = "See [xrSuggestVirtualKeyboardLocationMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSuggestVirtualKeyboardLocationMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type SuggestVirtualKeyboardLocationMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + location_info: *const VirtualKeyboardLocationInfoMETA, + ) -> Result; + #[doc = "See [xrGetVirtualKeyboardScaleMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetVirtualKeyboardScaleMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type GetVirtualKeyboardScaleMETA = + unsafe extern "system" fn(keyboard: VirtualKeyboardMETA, scale: *mut f32) -> Result; + #[doc = "See [xrSetVirtualKeyboardModelVisibilityMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSetVirtualKeyboardModelVisibilityMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type SetVirtualKeyboardModelVisibilityMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + model_visibility: *const VirtualKeyboardModelVisibilitySetInfoMETA, + ) -> Result; + #[doc = "See [xrGetVirtualKeyboardModelAnimationStatesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetVirtualKeyboardModelAnimationStatesMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type GetVirtualKeyboardModelAnimationStatesMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + animation_states: *mut VirtualKeyboardModelAnimationStatesMETA, + ) -> Result; + #[doc = "See [xrGetVirtualKeyboardDirtyTexturesMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetVirtualKeyboardDirtyTexturesMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type GetVirtualKeyboardDirtyTexturesMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + texture_id_capacity_input: u32, + texture_id_count_output: *mut u32, + texture_ids: *mut u64, + ) -> Result; + #[doc = "See [xrGetVirtualKeyboardTextureDataMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetVirtualKeyboardTextureDataMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type GetVirtualKeyboardTextureDataMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + texture_id: u64, + texture_data: *mut VirtualKeyboardTextureDataMETA, + ) -> Result; + #[doc = "See [xrSendVirtualKeyboardInputMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrSendVirtualKeyboardInputMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type SendVirtualKeyboardInputMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + info: *const VirtualKeyboardInputInfoMETA, + interactor_root_pose: *mut Posef, + ) -> Result; + #[doc = "See [xrChangeVirtualKeyboardTextContextMETA](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrChangeVirtualKeyboardTextContextMETA) - defined by [XR_META_virtual_keyboard](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_META_virtual_keyboard)"] + pub type ChangeVirtualKeyboardTextContextMETA = unsafe extern "system" fn( + keyboard: VirtualKeyboardMETA, + change_info: *const VirtualKeyboardTextContextChangeInfoMETA, + ) -> Result; #[doc = "See [xrGetVulkanGraphicsRequirements2KHR](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrGetVulkanGraphicsRequirements2KHR) - defined by [XR_KHR_vulkan_enable](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_vulkan_enable)"] pub type GetVulkanGraphicsRequirements2KHR = unsafe extern "system" fn( instance: Instance, @@ -7896,9 +10673,11 @@ pub mod pfn { pub const ALMALENCE_digital_lens_control_SPEC_VERSION: u32 = 1u32; pub const ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME: &[u8] = b"XR_ALMALENCE_digital_lens_control\0"; +pub const BD_controller_interaction_SPEC_VERSION: u32 = 1u32; +pub const BD_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_BD_controller_interaction\0"; pub const EPIC_view_configuration_fov_SPEC_VERSION: u32 = 2u32; pub const EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME: &[u8] = b"XR_EPIC_view_configuration_fov\0"; -pub const EXT_performance_settings_SPEC_VERSION: u32 = 3u32; +pub const EXT_performance_settings_SPEC_VERSION: u32 = 4u32; pub const EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME: &[u8] = b"XR_EXT_performance_settings\0"; pub const EXT_thermal_query_SPEC_VERSION: u32 = 2u32; pub const EXT_THERMAL_QUERY_EXTENSION_NAME: &[u8] = b"XR_EXT_thermal_query\0"; @@ -7932,8 +10711,18 @@ pub const EXT_palm_pose_SPEC_VERSION: u32 = 2u32; pub const EXT_PALM_POSE_EXTENSION_NAME: &[u8] = b"XR_EXT_palm_pose\0"; pub const EXT_uuid_SPEC_VERSION: u32 = 1u32; pub const EXT_UUID_EXTENSION_NAME: &[u8] = b"XR_EXT_uuid\0"; -pub const EXTX_overlay_SPEC_VERSION: u32 = 5u32; -pub const EXTX_OVERLAY_EXTENSION_NAME: &[u8] = b"XR_EXTX_overlay\0"; +pub const EXT_hand_interaction_SPEC_VERSION: u32 = 1u32; +pub const EXT_HAND_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_EXT_hand_interaction\0"; +pub const EXT_active_action_set_priority_SPEC_VERSION: u32 = 1u32; +pub const EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME: &[u8] = + b"XR_EXT_active_action_set_priority\0"; +pub const EXT_local_floor_SPEC_VERSION: u32 = 1u32; +pub const EXT_LOCAL_FLOOR_EXTENSION_NAME: &[u8] = b"XR_EXT_local_floor\0"; +pub const EXT_hand_tracking_data_source_SPEC_VERSION: u32 = 1u32; +pub const EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME: &[u8] = + b"XR_EXT_hand_tracking_data_source\0"; +pub const EXT_plane_detection_SPEC_VERSION: u32 = 1u32; +pub const EXT_PLANE_DETECTION_EXTENSION_NAME: &[u8] = b"XR_EXT_plane_detection\0"; pub const FB_composition_layer_image_layout_SPEC_VERSION: u32 = 1u32; pub const FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME: &[u8] = b"XR_FB_composition_layer_image_layout\0"; @@ -7950,6 +10739,8 @@ pub const FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME: &[u8] = b"XR_FB_swapchain_up pub const FB_composition_layer_secure_content_SPEC_VERSION: u32 = 1u32; pub const FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME: &[u8] = b"XR_FB_composition_layer_secure_content\0"; +pub const FB_body_tracking_SPEC_VERSION: u32 = 1u32; +pub const FB_BODY_TRACKING_EXTENSION_NAME: &[u8] = b"XR_FB_body_tracking\0"; pub const FB_display_refresh_rate_SPEC_VERSION: u32 = 1u32; pub const FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME: &[u8] = b"XR_FB_display_refresh_rate\0"; pub const FB_color_space_SPEC_VERSION: u32 = 3u32; @@ -7960,7 +10751,7 @@ pub const FB_hand_tracking_aim_SPEC_VERSION: u32 = 2u32; pub const FB_HAND_TRACKING_AIM_EXTENSION_NAME: &[u8] = b"XR_FB_hand_tracking_aim\0"; pub const FB_hand_tracking_capsules_SPEC_VERSION: u32 = 3u32; pub const FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME: &[u8] = b"XR_FB_hand_tracking_capsules\0"; -pub const FB_spatial_entity_SPEC_VERSION: u32 = 1u32; +pub const FB_spatial_entity_SPEC_VERSION: u32 = 2u32; pub const FB_SPATIAL_ENTITY_EXTENSION_NAME: &[u8] = b"XR_FB_spatial_entity\0"; pub const FB_foveation_SPEC_VERSION: u32 = 1u32; pub const FB_FOVEATION_EXTENSION_NAME: &[u8] = b"XR_FB_foveation\0"; @@ -7972,7 +10763,7 @@ pub const FB_triangle_mesh_SPEC_VERSION: u32 = 2u32; pub const FB_TRIANGLE_MESH_EXTENSION_NAME: &[u8] = b"XR_FB_triangle_mesh\0"; pub const FB_passthrough_SPEC_VERSION: u32 = 3u32; pub const FB_PASSTHROUGH_EXTENSION_NAME: &[u8] = b"XR_FB_passthrough\0"; -pub const FB_render_model_SPEC_VERSION: u32 = 3u32; +pub const FB_render_model_SPEC_VERSION: u32 = 4u32; pub const FB_RENDER_MODEL_EXTENSION_NAME: &[u8] = b"XR_FB_render_model\0"; pub const FB_spatial_entity_query_SPEC_VERSION: u32 = 1u32; pub const FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME: &[u8] = b"XR_FB_spatial_entity_query\0"; @@ -7991,22 +10782,47 @@ pub const FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME: &[u8] = pub const FB_swapchain_update_state_vulkan_SPEC_VERSION: u32 = 1u32; pub const FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME: &[u8] = b"XR_FB_swapchain_update_state_vulkan\0"; +pub const FB_touch_controller_pro_SPEC_VERSION: u32 = 1u32; +pub const FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME: &[u8] = b"XR_FB_touch_controller_pro\0"; +pub const FB_spatial_entity_sharing_SPEC_VERSION: u32 = 1u32; +pub const FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME: &[u8] = b"XR_FB_spatial_entity_sharing\0"; pub const FB_space_warp_SPEC_VERSION: u32 = 2u32; pub const FB_SPACE_WARP_EXTENSION_NAME: &[u8] = b"XR_FB_space_warp\0"; -pub const FB_scene_SPEC_VERSION: u32 = 1u32; +pub const FB_haptic_amplitude_envelope_SPEC_VERSION: u32 = 1u32; +pub const FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME: &[u8] = b"XR_FB_haptic_amplitude_envelope\0"; +pub const FB_scene_SPEC_VERSION: u32 = 3u32; pub const FB_SCENE_EXTENSION_NAME: &[u8] = b"XR_FB_scene\0"; +pub const FB_scene_capture_SPEC_VERSION: u32 = 1u32; +pub const FB_SCENE_CAPTURE_EXTENSION_NAME: &[u8] = b"XR_FB_scene_capture\0"; pub const FB_spatial_entity_container_SPEC_VERSION: u32 = 2u32; pub const FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME: &[u8] = b"XR_FB_spatial_entity_container\0"; +pub const FB_face_tracking_SPEC_VERSION: u32 = 1u32; +pub const FB_FACE_TRACKING_EXTENSION_NAME: &[u8] = b"XR_FB_face_tracking\0"; +pub const FB_eye_tracking_social_SPEC_VERSION: u32 = 1u32; +pub const FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME: &[u8] = b"XR_FB_eye_tracking_social\0"; pub const FB_passthrough_keyboard_hands_SPEC_VERSION: u32 = 2u32; pub const FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME: &[u8] = b"XR_FB_passthrough_keyboard_hands\0"; pub const FB_composition_layer_settings_SPEC_VERSION: u32 = 1u32; pub const FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME: &[u8] = b"XR_FB_composition_layer_settings\0"; +pub const FB_touch_controller_proximity_SPEC_VERSION: u32 = 1u32; +pub const FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME: &[u8] = + b"XR_FB_touch_controller_proximity\0"; +pub const FB_haptic_pcm_SPEC_VERSION: u32 = 1u32; +pub const FB_HAPTIC_PCM_EXTENSION_NAME: &[u8] = b"XR_FB_haptic_pcm\0"; +pub const FB_composition_layer_depth_test_SPEC_VERSION: u32 = 1u32; +pub const FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME: &[u8] = + b"XR_FB_composition_layer_depth_test\0"; +pub const FB_spatial_entity_storage_batch_SPEC_VERSION: u32 = 1u32; +pub const FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME: &[u8] = + b"XR_FB_spatial_entity_storage_batch\0"; +pub const FB_spatial_entity_user_SPEC_VERSION: u32 = 1u32; +pub const FB_SPATIAL_ENTITY_USER_EXTENSION_NAME: &[u8] = b"XR_FB_spatial_entity_user\0"; pub const HTC_vive_cosmos_controller_interaction_SPEC_VERSION: u32 = 1u32; pub const HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_HTC_vive_cosmos_controller_interaction\0"; -pub const HTC_facial_tracking_SPEC_VERSION: u32 = 1u32; +pub const HTC_facial_tracking_SPEC_VERSION: u32 = 2u32; pub const HTC_FACIAL_TRACKING_EXTENSION_NAME: &[u8] = b"XR_HTC_facial_tracking\0"; pub const HTC_vive_focus3_controller_interaction_SPEC_VERSION: u32 = 2u32; pub const HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = @@ -8016,9 +10832,10 @@ pub const HTC_HAND_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_HTC_hand_interaction pub const HTC_vive_wrist_tracker_interaction_SPEC_VERSION: u32 = 1u32; pub const HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_HTC_vive_wrist_tracker_interaction\0"; -pub const HTCX_vive_tracker_interaction_SPEC_VERSION: u32 = 1u32; -pub const HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME: &[u8] = - b"XR_HTCX_vive_tracker_interaction\0"; +pub const HTC_passthrough_SPEC_VERSION: u32 = 1u32; +pub const HTC_PASSTHROUGH_EXTENSION_NAME: &[u8] = b"XR_HTC_passthrough\0"; +pub const HTC_foveation_SPEC_VERSION: u32 = 1u32; +pub const HTC_FOVEATION_EXTENSION_NAME: &[u8] = b"XR_HTC_foveation\0"; pub const HUAWEI_controller_interaction_SPEC_VERSION: u32 = 1u32; pub const HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_HUAWEI_controller_interaction\0"; @@ -8090,21 +10907,37 @@ pub const KHR_BINDING_MODIFICATION_EXTENSION_NAME: &[u8] = b"XR_KHR_binding_modi pub const KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION: u32 = 3u32; pub const KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME: &[u8] = b"XR_KHR_swapchain_usage_input_attachment_bit\0"; +pub const META_foveation_eye_tracked_SPEC_VERSION: u32 = 1u32; +pub const META_FOVEATION_EYE_TRACKED_EXTENSION_NAME: &[u8] = b"XR_META_foveation_eye_tracked\0"; +pub const META_local_dimming_SPEC_VERSION: u32 = 1u32; +pub const META_LOCAL_DIMMING_EXTENSION_NAME: &[u8] = b"XR_META_local_dimming\0"; +pub const META_passthrough_preferences_SPEC_VERSION: u32 = 1u32; +pub const META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME: &[u8] = b"XR_META_passthrough_preferences\0"; +pub const META_virtual_keyboard_SPEC_VERSION: u32 = 1u32; +pub const META_VIRTUAL_KEYBOARD_EXTENSION_NAME: &[u8] = b"XR_META_virtual_keyboard\0"; pub const META_vulkan_swapchain_create_info_SPEC_VERSION: u32 = 1u32; pub const META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME: &[u8] = b"XR_META_vulkan_swapchain_create_info\0"; -pub const META_performance_metrics_SPEC_VERSION: u32 = 1u32; +pub const META_performance_metrics_SPEC_VERSION: u32 = 2u32; pub const META_PERFORMANCE_METRICS_EXTENSION_NAME: &[u8] = b"XR_META_performance_metrics\0"; +pub const META_headset_id_SPEC_VERSION: u32 = 1u32; +pub const META_HEADSET_ID_EXTENSION_NAME: &[u8] = b"XR_META_headset_id\0"; +pub const META_passthrough_color_lut_SPEC_VERSION: u32 = 1u32; +pub const META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME: &[u8] = b"XR_META_passthrough_color_lut\0"; pub const ML_ml2_controller_interaction_SPEC_VERSION: u32 = 1u32; pub const ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_ML_ml2_controller_interaction\0"; +pub const ML_frame_end_info_SPEC_VERSION: u32 = 1u32; +pub const ML_FRAME_END_INFO_EXTENSION_NAME: &[u8] = b"XR_ML_frame_end_info\0"; +pub const ML_global_dimmer_SPEC_VERSION: u32 = 1u32; +pub const ML_GLOBAL_DIMMER_EXTENSION_NAME: &[u8] = b"XR_ML_global_dimmer\0"; +pub const ML_compat_SPEC_VERSION: u32 = 1u32; +pub const ML_COMPAT_EXTENSION_NAME: &[u8] = b"XR_ML_compat\0"; pub const MND_headless_SPEC_VERSION: u32 = 2u32; pub const MND_HEADLESS_EXTENSION_NAME: &[u8] = b"XR_MND_headless\0"; pub const MND_swapchain_usage_input_attachment_bit_SPEC_VERSION: u32 = 2u32; pub const MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME: &[u8] = b"XR_MND_swapchain_usage_input_attachment_bit\0"; -pub const MNDX_egl_enable_SPEC_VERSION: u32 = 1u32; -pub const MNDX_EGL_ENABLE_EXTENSION_NAME: &[u8] = b"XR_MNDX_egl_enable\0"; pub const MSFT_unbounded_reference_space_SPEC_VERSION: u32 = 1u32; pub const MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME: &[u8] = b"XR_MSFT_unbounded_reference_space\0"; @@ -8151,6 +10984,13 @@ pub const OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME: &[u8] = b"XR_OCULUS_android_session_state_enable\0"; pub const OCULUS_audio_device_guid_SPEC_VERSION: u32 = 1u32; pub const OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME: &[u8] = b"XR_OCULUS_audio_device_guid\0"; +pub const OCULUS_external_camera_SPEC_VERSION: u32 = 1u32; +pub const OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME: &[u8] = b"XR_OCULUS_external_camera\0"; +pub const OPPO_controller_interaction_SPEC_VERSION: u32 = 1u32; +pub const OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME: &[u8] = b"XR_OPPO_controller_interaction\0"; +pub const QCOM_tracking_optimization_settings_SPEC_VERSION: u32 = 1u32; +pub const QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME: &[u8] = + b"XR_QCOM_tracking_optimization_settings\0"; pub const ULTRALEAP_hand_tracking_forearm_SPEC_VERSION: u32 = 1u32; pub const ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME: &[u8] = b"XR_ULTRALEAP_hand_tracking_forearm\0"; @@ -8158,7 +10998,7 @@ pub const VALVE_analog_threshold_SPEC_VERSION: u32 = 2u32; pub const VALVE_ANALOG_THRESHOLD_EXTENSION_NAME: &[u8] = b"XR_VALVE_analog_threshold\0"; pub const VARJO_quad_views_SPEC_VERSION: u32 = 1u32; pub const VARJO_QUAD_VIEWS_EXTENSION_NAME: &[u8] = b"XR_VARJO_quad_views\0"; -pub const VARJO_foveated_rendering_SPEC_VERSION: u32 = 2u32; +pub const VARJO_foveated_rendering_SPEC_VERSION: u32 = 3u32; pub const VARJO_FOVEATED_RENDERING_EXTENSION_NAME: &[u8] = b"XR_VARJO_foveated_rendering\0"; pub const VARJO_composition_layer_depth_test_SPEC_VERSION: u32 = 2u32; pub const VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME: &[u8] = diff --git a/sys/src/lib.rs b/sys/src/lib.rs index 0c8bf193..2a006ad5 100644 --- a/sys/src/lib.rs +++ b/sys/src/lib.rs @@ -220,3 +220,18 @@ impl std::ops::IndexMut for [T] { &mut self[joint.into_raw() as usize] } } + +type DevicePcmSampleRateGetInfoFB = DevicePcmSampleRateStateFB; + +// Magic Leap +#[derive(Copy, Clone, Debug)] +#[repr(C)] +pub struct MLCoordinateFrameUID { + pub data: [u64; 2], +} + +// Hacky constants originating from enums +pub const EYE_POSITION_COUNT_FB: usize = 2; +pub const MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META: usize = 3992; + +pub type SpaceUserIdFB = u64; diff --git a/sys/src/platform.rs b/sys/src/platform.rs index 63fd2f45..94fdfc04 100644 --- a/sys/src/platform.rs +++ b/sys/src/platform.rs @@ -79,5 +79,5 @@ pub type EGLConfig = *mut c_void; pub type EGLContext = *mut c_void; pub type EGLDisplay = *mut c_void; pub type EGLenum = c_uint; -pub type PFNEGLGETPROCADDRESSPROC = +pub type EglGetProcAddressMNDX = unsafe extern "system" fn(*const c_char) -> Option; From c80bf21e473d3e8464f8c34db728b9d2b4f44208 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Wed, 13 Sep 2023 23:04:15 +0200 Subject: [PATCH 2/7] Handle mutable pointers in generate_setters --- generator/src/main.rs | 15 +++++++++++---- openxr/src/generated.rs | 4 ++-- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/generator/src/main.rs b/generator/src/main.rs index 155f51b1..d01ee40a 100644 --- a/generator/src/main.rs +++ b/generator/src/main.rs @@ -1804,10 +1804,17 @@ impl Parser { let mut inner = m.clone(); inner.ptr_depth -= 1; let ty = xr_var_ty(self.api_aliases.as_ref(), &inner); - ( - quote! { &'a #ty #type_args }, - quote! { self.inner.#ident = value as *const _ as _; }, - ) + if m.is_const { + ( + quote! { &'a #ty #type_args }, + quote! { self.inner.#ident = value as *const _ as _; }, + ) + } else { + ( + quote! { &'a mut #ty #type_args }, + quote! { self.inner.#ident = value as *mut _ as _; }, + ) + } } else if self.structs.contains_key(&m.ty) && !simple.contains(&m.ty[..]) { let ty = xr_var_ty(self.api_aliases.as_ref(), m); ( diff --git a/openxr/src/generated.rs b/openxr/src/generated.rs index 5ff260ff..aed2bd8e 100644 --- a/openxr/src/generated.rs +++ b/openxr/src/generated.rs @@ -6512,8 +6512,8 @@ pub(crate) mod builder { self } #[inline] - pub fn samples_consumed(mut self, value: &'a u32) -> Self { - self.inner.samples_consumed = value as *const _ as _; + pub fn samples_consumed(mut self, value: &'a mut u32) -> Self { + self.inner.samples_consumed = value as *mut _ as _; self } } From 272abd1ff7bc3be90d652f236bcd5acb1bcf8228 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Wed, 13 Sep 2023 23:34:40 +0200 Subject: [PATCH 3/7] Export HapticPcmVibrationFB --- openxr/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openxr/src/lib.rs b/openxr/src/lib.rs index b81f12d7..fe751730 100644 --- a/openxr/src/lib.rs +++ b/openxr/src/lib.rs @@ -44,7 +44,7 @@ pub use passthrough::*; pub use builder::{ CompositionLayerBase, CompositionLayerCubeKHR, CompositionLayerCylinderKHR, CompositionLayerEquirectKHR, CompositionLayerProjection, CompositionLayerProjectionView, - CompositionLayerQuad, HapticBase, HapticVibration, SwapchainSubImage, + CompositionLayerQuad, HapticBase, HapticPcmVibrationFB, HapticVibration, SwapchainSubImage, }; pub type Result = std::result::Result; From beadbe68e6db582e2add21bdd8614a1e373620f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Wed, 13 Sep 2023 23:50:02 +0200 Subject: [PATCH 4/7] Appease clippy --- generator/src/main.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/generator/src/main.rs b/generator/src/main.rs index d01ee40a..79bfba73 100644 --- a/generator/src/main.rs +++ b/generator/src/main.rs @@ -600,7 +600,7 @@ impl Parser { } self.base_headers .entry(parent.into()) - .or_insert_with(Vec::new) + .or_default() .push(struct_name.into()); } if let Some(target) = attr(attrs, "alias") { @@ -1135,7 +1135,7 @@ impl Parser { let commands = self.commands.iter().chain( self.cmd_aliases .iter() - .map(|&(ref name, ref target)| (name, self.commands.get(target).unwrap())), + .map(|(name, target)| (name, self.commands.get(target).unwrap())), ); let (pfns, protos) = commands From f90921285937f8ddb230e3f692edc4f7e4607dc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Mon, 25 Sep 2023 20:53:02 +0200 Subject: [PATCH 5/7] Use Default for Duration --- generator/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generator/src/main.rs b/generator/src/main.rs index 79bfba73..92e7688b 100644 --- a/generator/src/main.rs +++ b/generator/src/main.rs @@ -1621,7 +1621,7 @@ impl Parser { out.has_pointer |= member.ptr_depth != 0 || self.handles.contains(&member.ty); out.has_graphics |= member.ty == "XrSession" || member.ty == "XrSwapchain"; out.has_array |= member.static_array_len.is_some(); - out.has_non_default |= member.ty == "XrTime" || member.ty == "XrDuration"; + out.has_non_default |= member.ty == "XrTime"; if member.ty != name { if let Some(x) = self.structs.get(&member.ty) { out |= self.compute_meta(&member.ty, x); From 905ea77b6da7a44e86abd043eafadd39e591ddf5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Mon, 25 Sep 2023 22:45:09 +0200 Subject: [PATCH 6/7] Add XR_HTC_passthrough The problem with XR_HTC_passthrough was that we were generating code for XrCompositionLayerPassthroughHTC that didn't compile. This erroneous code was in the high level bindings so it turn out that we don't need to disable the whole extension if we just skip the high level bindings for XrCompositionLayerPassthroughHTC. This also removes the ugly blacklist for structs during parsing that was added to avoid the problematic code gen. --- generator/src/main.rs | 21 +++----------- openxr/src/generated.rs | 41 +++++++++++++++++++++++++++ sys/src/generated.rs | 63 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 108 insertions(+), 17 deletions(-) diff --git a/generator/src/main.rs b/generator/src/main.rs index 92e7688b..337eea44 100644 --- a/generator/src/main.rs +++ b/generator/src/main.rs @@ -78,7 +78,6 @@ impl Parser { extensions: IndexMap::new(), // TODO: Handle these extensions disabled_exts: [ - "XR_HTC_passthrough", "XR_MSFT_scene_understanding", "XR_MSFT_scene_understanding_serialization", ] @@ -547,11 +546,6 @@ impl Parser { } fn parse_struct(&mut self, attrs: &[OwnedAttribute]) { - const STRUCTS_BLACKLIST: [&str; 3] = [ - "XrCompositionLayerPassthroughHTC", - "XrPassthroughColorHTC", - "XrPassthroughHTC", - ]; let struct_name = attr(attrs, "name").unwrap(); let mut members = Vec::new(); let mut ty = None; @@ -585,19 +579,8 @@ impl Parser { _ => {} } } - if STRUCTS_BLACKLIST.contains(&struct_name) { - return; - } - if let Some(structextends) = attr(attrs, "structextends") { - if STRUCTS_BLACKLIST.contains(&structextends) { - return; - } - } let parent = attr(attrs, "parentstruct"); if let Some(parent) = parent { - if STRUCTS_BLACKLIST.contains(&parent) { - return; - } self.base_headers .entry(parent.into()) .or_default() @@ -1650,6 +1633,10 @@ impl Parser { let (type_params, type_args, marker, marker_init) = base_meta.type_params(); let builders = children.iter().map(|name| { + if name == "XrCompositionLayerPassthroughHTC" { + // XrCompositionLayerPassthroughHTC has problems with its setters so we skip for now. + return quote! {}; + } let ident = xr_ty_name(name); let s = self.structs.get(name).unwrap(); let conds = conditions(name, s.extension.as_ref().map(|x| &x[..])); diff --git a/openxr/src/generated.rs b/openxr/src/generated.rs index aed2bd8e..d79f2e27 100644 --- a/openxr/src/generated.rs +++ b/openxr/src/generated.rs @@ -121,6 +121,7 @@ pub struct ExtensionSet { pub htc_vive_focus3_controller_interaction: bool, pub htc_hand_interaction: bool, pub htc_vive_wrist_tracker_interaction: bool, + pub htc_passthrough: bool, pub htc_foveation: bool, pub huawei_controller_interaction: bool, #[cfg(target_os = "android")] @@ -407,6 +408,9 @@ impl ExtensionSet { raw::ViveWristTrackerInteractionHTC::NAME => { out.htc_vive_wrist_tracker_interaction = true; } + raw::PassthroughHTC::NAME => { + out.htc_passthrough = true; + } raw::FoveationHTC::NAME => { out.htc_foveation = true; } @@ -958,6 +962,11 @@ impl ExtensionSet { out.push(raw::ViveWristTrackerInteractionHTC::NAME.into()); } } + { + if self.htc_passthrough { + out.push(raw::PassthroughHTC::NAME.into()); + } + } { if self.htc_foveation { out.push(raw::FoveationHTC::NAME.into()); @@ -1371,6 +1380,7 @@ pub struct InstanceExtensions { pub htc_vive_focus3_controller_interaction: Option, pub htc_hand_interaction: Option, pub htc_vive_wrist_tracker_interaction: Option, + pub htc_passthrough: Option, pub htc_foveation: Option, pub huawei_controller_interaction: Option, #[cfg(target_os = "android")] @@ -1803,6 +1813,11 @@ impl InstanceExtensions { } else { None }, + htc_passthrough: if required.htc_passthrough { + Some(raw::PassthroughHTC::load(entry, instance)?) + } else { + None + }, htc_foveation: if required.htc_foveation { Some(raw::FoveationHTC::load(entry, instance)?) } else { @@ -4389,6 +4404,32 @@ pub mod raw { pub const NAME: &'static [u8] = sys::HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME; } #[derive(Copy, Clone)] + pub struct PassthroughHTC { + pub create_passthrough: pfn::CreatePassthroughHTC, + pub destroy_passthrough: pfn::DestroyPassthroughHTC, + } + impl PassthroughHTC { + pub const VERSION: u32 = sys::HTC_passthrough_SPEC_VERSION; + pub const NAME: &'static [u8] = sys::HTC_PASSTHROUGH_EXTENSION_NAME; + #[doc = r" Load the extension's function pointer table"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r""] + #[doc = r" `instance` must be a valid instance handle."] + pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result { + Ok(Self { + create_passthrough: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughHTC\0"), + )?), + destroy_passthrough: mem::transmute(entry.get_instance_proc_addr( + instance, + CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughHTC\0"), + )?), + }) + } + } + #[derive(Copy, Clone)] pub struct FoveationHTC { pub apply_foveation: pfn::ApplyFoveationHTC, } diff --git a/sys/src/generated.rs b/sys/src/generated.rs index 6f85a3ab..f8ba18f0 100644 --- a/sys/src/generated.rs +++ b/sys/src/generated.rs @@ -8547,6 +8547,60 @@ impl FacialExpressionsHTC { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughCreateInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughCreateInfoHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] +pub struct PassthroughCreateInfoHTC { + pub ty: StructureType, + pub next: *const c_void, + pub form: PassthroughFormHTC, +} +impl PassthroughCreateInfoHTC { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_CREATE_INFO_HTC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughColorHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughColorHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] +pub struct PassthroughColorHTC { + pub ty: StructureType, + pub next: *const c_void, + pub alpha: f32, +} +impl PassthroughColorHTC { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_COLOR_HTC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrPassthroughMeshTransformInfoHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrPassthroughMeshTransformInfoHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] +pub struct PassthroughMeshTransformInfoHTC { + pub ty: StructureType, + pub next: *const c_void, + pub vertex_count: u32, + pub vertices: *const Vector3f, + pub index_count: u32, + pub indices: *const u32, + pub base_space: Space, + pub time: Time, + pub pose: Posef, + pub scale: Vector3f, +} +impl PassthroughMeshTransformInfoHTC { + pub const TYPE: StructureType = StructureType::PASSTHROUGH_MESH_TRANSFORM_INFO_HTC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = "See [XrCompositionLayerPassthroughHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrCompositionLayerPassthroughHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] +pub struct CompositionLayerPassthroughHTC { + pub ty: StructureType, + pub next: *const c_void, + pub layer_flags: CompositionLayerFlags, + pub space: Space, + pub passthrough: PassthroughHTC, + pub color: PassthroughColorHTC, +} +impl CompositionLayerPassthroughHTC { + pub const TYPE: StructureType = StructureType::COMPOSITION_LAYER_PASSTHROUGH_HTC; +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = "See [XrViveTrackerPathsHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrViveTrackerPathsHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] pub struct ViveTrackerPathsHTCX { pub ty: StructureType, @@ -10452,6 +10506,15 @@ pub mod pfn { facial_tracker: FacialTrackerHTC, facial_expressions: *mut FacialExpressionsHTC, ) -> Result; + #[doc = "See [xrCreatePassthroughHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrCreatePassthroughHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] + pub type CreatePassthroughHTC = unsafe extern "system" fn( + session: Session, + create_info: *const PassthroughCreateInfoHTC, + passthrough: *mut PassthroughHTC, + ) -> Result; + #[doc = "See [xrDestroyPassthroughHTC](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrDestroyPassthroughHTC) - defined by [XR_HTC_passthrough](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTC_passthrough)"] + pub type DestroyPassthroughHTC = + unsafe extern "system" fn(passthrough: PassthroughHTC) -> Result; #[doc = "See [xrEnumerateViveTrackerPathsHTCX](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#xrEnumerateViveTrackerPathsHTCX) - defined by [XR_HTCX_vive_tracker_interaction](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_HTCX_vive_tracker_interaction)"] pub type EnumerateViveTrackerPathsHTCX = unsafe extern "system" fn( instance: Instance, From c587c7435d79532adc437d9e0652a35108b44d75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rasmus=20Br=C3=B6nneg=C3=A5rd?= <1162652+rasmusgo@users.noreply.github.com> Date: Tue, 26 Sep 2023 21:14:12 +0200 Subject: [PATCH 7/7] Add missing Default for Duration --- sys/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/src/lib.rs b/sys/src/lib.rs index 2a006ad5..f86eea4c 100644 --- a/sys/src/lib.rs +++ b/sys/src/lib.rs @@ -68,7 +68,7 @@ impl std::ops::Sub