1#![doc = r" Automatically generated code; do not edit!"]
2#![allow(
3 clippy::wrong_self_convention,
4 clippy::transmute_ptr_to_ptr,
5 clippy::missing_transmute_annotations
6)]
7use crate::*;
8use std::borrow::Cow;
9use std::ffi::CStr;
10use std::mem::MaybeUninit;
11pub use sys::platform::{
12 EGLenum, VkComponentSwizzle, VkFilter, VkSamplerAddressMode, VkSamplerMipmapMode,
13};
14pub use sys::{
15 ActionType, AndroidSurfaceSwapchainFlagsFB, AndroidThreadTypeKHR, BlendFactorFB, BodyJointFB,
16 BodyJointLocationFB, BodyJointSetFB, BodySkeletonJointFB, Boxf, Color3f, Color4f, ColorSpaceFB,
17 CompareOpFB, CompositionLayerFlags, CompositionLayerImageLayoutFlagsFB,
18 CompositionLayerSecureContentFlagsFB, CompositionLayerSettingsFlagsFB,
19 CompositionLayerSpaceWarpInfoFlagsFB, DebugUtilsMessageSeverityFlagsEXT,
20 DebugUtilsMessageTypeFlagsEXT, DigitalLensControlFlagsALMALENCE, EnvironmentBlendMode,
21 EnvironmentDepthProviderCreateFlagsMETA, EnvironmentDepthSwapchainCreateFlagsMETA, Extent2Df,
22 Extent2Di, Extent3Df, ExternalCameraAttachedToDeviceOCULUS, ExternalCameraExtrinsicsOCULUS,
23 ExternalCameraIntrinsicsOCULUS, ExternalCameraStatusFlagsOCULUS, EyeCalibrationStatusML,
24 EyeExpressionHTC, EyePositionFB, EyeVisibility, FaceConfidence2FB, FaceConfidenceFB,
25 FaceExpression2FB, FaceExpressionFB, FaceExpressionSet2FB, FaceExpressionSetFB,
26 FaceTrackingDataSource2FB, FacialTrackingTypeHTC, ForceFeedbackCurlApplyLocationMNDX,
27 ForceFeedbackCurlLocationMNDX, FormFactor, FoveationConfigurationHTC, FoveationDynamicFB,
28 FoveationDynamicFlagsHTC, FoveationEyeTrackedProfileCreateFlagsMETA,
29 FoveationEyeTrackedStateFlagsMETA, FoveationLevelFB, FoveationLevelHTC, FoveationModeHTC, Fovf,
30 FrameEndInfoFlagsML, Frustumf, FutureStateEXT, GlobalDimmerFrameEndInfoFlagsML, HandEXT,
31 HandForearmJointULTRALEAP, HandJointEXT, HandJointLocationEXT, HandJointSetEXT,
32 HandJointVelocityEXT, HandJointsMotionRangeEXT, HandMeshVertexMSFT, HandPoseTypeMSFT,
33 HandTrackingAimFlagsFB, HandTrackingDataSourceEXT, HeadsetFitStatusML,
34 InputSourceLocalizedNameFlags, InstanceCreateFlags, KeyboardTrackingFlagsFB,
35 KeyboardTrackingQueryFlagsFB, LipExpressionHTC, LoaderInterfaceStructs, LocalDimmingModeMETA,
36 LocalizationMapConfidenceML, LocalizationMapErrorFlagsML, LocalizationMapStateML,
37 LocalizationMapTypeML, MarkerAprilTagDictML, MarkerArucoDictML, MarkerDetectorCameraML,
38 MarkerDetectorCornerRefineMethodML, MarkerDetectorFpsML, MarkerDetectorFullAnalysisIntervalML,
39 MarkerDetectorProfileML, MarkerDetectorResolutionML, MarkerDetectorStatusML, MarkerTypeML,
40 MeshComputeLodMSFT, NegotiateApiLayerRequest, NegotiateLoaderInfo, NegotiateRuntimeRequest,
41 ObjectType, Offset2Df, Offset2Di, Offset3DfFB, OverlayMainSessionFlagsEXTX,
42 OverlaySessionCreateFlagsEXTX, PassthroughCapabilityFlagsFB, PassthroughColorLutChannelsMETA,
43 PassthroughFlagsFB, PassthroughFormHTC, PassthroughLayerPurposeFB,
44 PassthroughPreferenceFlagsMETA, PassthroughStateChangedFlagsFB, PerfSettingsDomainEXT,
45 PerfSettingsLevelEXT, PerfSettingsNotificationLevelEXT, PerfSettingsSubDomainEXT,
46 PerformanceMetricsCounterFlagsMETA, PerformanceMetricsCounterUnitMETA,
47 PlaneDetectionCapabilityFlagsEXT, PlaneDetectionStateEXT, PlaneDetectorFlagsEXT,
48 PlaneDetectorOrientationEXT, PlaneDetectorSemanticTypeEXT, Posef, Quaternionf, Rect2Df,
49 Rect2Di, Rect3DfFB, ReferenceSpaceType, RenderModelFlagsFB, ReprojectionModeMSFT,
50 SceneComponentTypeMSFT, SceneComputeConsistencyMSFT, SceneComputeFeatureMSFT,
51 SceneComputeStateMSFT, SceneMarkerQRCodeSymbolTypeMSFT, SceneMarkerTypeMSFT,
52 SceneObjectTypeMSFT, ScenePlaneAlignmentTypeMSFT, SemanticLabelsSupportFlagsFB,
53 SessionCreateFlags, SessionState, SpaceComponentTypeFB, SpaceLocationData, SpaceLocationFlags,
54 SpacePersistenceModeFB, SpaceQueryActionFB, SpaceStorageLocationFB, SpaceVelocityData,
55 SpaceVelocityFlags, SpatialGraphNodeTypeMSFT, Spheref, StructureType, SwapchainCreateFlags,
56 SwapchainCreateFoveationFlagsFB, SwapchainStateFoveationFlagsFB, SwapchainUsageFlags,
57 SystemGraphicsProperties, TrackingOptimizationSettingsDomainQCOM,
58 TrackingOptimizationSettingsHintQCOM, TriangleMeshFlagsFB, Vector2f, Vector3f, Vector4f,
59 Vector4sFB, ViewConfigurationType, ViewStateFlags, VirtualKeyboardInputSourceMETA,
60 VirtualKeyboardInputStateFlagsMETA, VirtualKeyboardLocationTypeMETA, VisibilityMaskTypeKHR,
61 VulkanDeviceCreateFlagsKHR, VulkanInstanceCreateFlagsKHR, WindingOrderFB,
62};
63#[doc = r" A subset of known extensions"]
64#[derive(Debug, Clone, Eq, PartialEq, Default)]
65#[non_exhaustive]
66pub struct ExtensionSet {
67 pub almalence_digital_lens_control: bool,
68 pub bd_controller_interaction: bool,
69 pub epic_view_configuration_fov: bool,
70 pub ext_performance_settings: bool,
71 pub ext_thermal_query: bool,
72 pub ext_debug_utils: bool,
73 pub ext_eye_gaze_interaction: bool,
74 pub ext_view_configuration_depth_range: bool,
75 pub ext_conformance_automation: bool,
76 pub ext_hand_tracking: bool,
77 #[cfg(windows)]
78 pub ext_win32_appcontainer_compatible: bool,
79 pub ext_dpad_binding: bool,
80 pub ext_hand_joints_motion_range: bool,
81 pub ext_samsung_odyssey_controller: bool,
82 pub ext_hp_mixed_reality_controller: bool,
83 pub ext_palm_pose: bool,
84 pub ext_uuid: bool,
85 pub ext_hand_interaction: bool,
86 pub ext_active_action_set_priority: bool,
87 pub ext_local_floor: bool,
88 pub ext_hand_tracking_data_source: bool,
89 pub ext_plane_detection: bool,
90 pub ext_future: bool,
91 pub ext_user_presence: bool,
92 pub fb_composition_layer_image_layout: bool,
93 pub fb_composition_layer_alpha_blend: bool,
94 #[cfg(target_os = "android")]
95 pub fb_android_surface_swapchain_create: bool,
96 pub fb_swapchain_update_state: bool,
97 pub fb_composition_layer_secure_content: bool,
98 pub fb_body_tracking: bool,
99 pub fb_display_refresh_rate: bool,
100 pub fb_color_space: bool,
101 pub fb_hand_tracking_mesh: bool,
102 pub fb_hand_tracking_aim: bool,
103 pub fb_hand_tracking_capsules: bool,
104 pub fb_spatial_entity: bool,
105 pub fb_foveation: bool,
106 pub fb_foveation_configuration: bool,
107 pub fb_keyboard_tracking: bool,
108 pub fb_triangle_mesh: bool,
109 pub fb_passthrough: bool,
110 pub fb_render_model: bool,
111 pub fb_spatial_entity_query: bool,
112 pub fb_spatial_entity_storage: bool,
113 pub fb_foveation_vulkan: bool,
114 #[cfg(target_os = "android")]
115 pub fb_swapchain_update_state_android_surface: bool,
116 pub fb_swapchain_update_state_opengl_es: bool,
117 pub fb_swapchain_update_state_vulkan: bool,
118 pub fb_touch_controller_pro: bool,
119 pub fb_spatial_entity_sharing: bool,
120 pub fb_space_warp: bool,
121 pub fb_haptic_amplitude_envelope: bool,
122 pub fb_scene: bool,
123 pub fb_scene_capture: bool,
124 pub fb_spatial_entity_container: bool,
125 pub fb_face_tracking: bool,
126 pub fb_eye_tracking_social: bool,
127 pub fb_passthrough_keyboard_hands: bool,
128 pub fb_composition_layer_settings: bool,
129 pub fb_touch_controller_proximity: bool,
130 pub fb_haptic_pcm: bool,
131 pub fb_composition_layer_depth_test: bool,
132 pub fb_spatial_entity_storage_batch: bool,
133 pub fb_spatial_entity_user: bool,
134 pub fb_face_tracking2: bool,
135 pub htc_vive_cosmos_controller_interaction: bool,
136 pub htc_facial_tracking: bool,
137 pub htc_vive_focus3_controller_interaction: bool,
138 pub htc_hand_interaction: bool,
139 pub htc_vive_wrist_tracker_interaction: bool,
140 pub htc_passthrough: bool,
141 pub htc_foveation: bool,
142 pub htc_anchor: bool,
143 pub huawei_controller_interaction: bool,
144 #[cfg(target_os = "android")]
145 pub khr_android_thread_settings: bool,
146 #[cfg(target_os = "android")]
147 pub khr_android_surface_swapchain: bool,
148 pub khr_composition_layer_cube: bool,
149 #[cfg(target_os = "android")]
150 pub khr_android_create_instance: bool,
151 pub khr_composition_layer_depth: bool,
152 pub khr_vulkan_swapchain_format_list: bool,
153 pub khr_composition_layer_cylinder: bool,
154 pub khr_composition_layer_equirect: bool,
155 pub khr_opengl_enable: bool,
156 pub khr_opengl_es_enable: bool,
157 pub khr_vulkan_enable: bool,
158 #[cfg(windows)]
159 pub khr_d3d11_enable: bool,
160 #[cfg(windows)]
161 pub khr_d3d12_enable: bool,
162 pub khr_visibility_mask: bool,
163 pub khr_composition_layer_color_scale_bias: bool,
164 #[cfg(windows)]
165 pub khr_win32_convert_performance_counter_time: bool,
166 pub khr_convert_timespec_time: bool,
167 pub khr_loader_init: bool,
168 #[cfg(target_os = "android")]
169 pub khr_loader_init_android: bool,
170 pub khr_vulkan_enable2: bool,
171 pub khr_composition_layer_equirect2: bool,
172 pub khr_binding_modification: bool,
173 pub khr_swapchain_usage_input_attachment_bit: bool,
174 pub khr_locate_spaces: bool,
175 pub khr_maintenance1: bool,
176 pub meta_foveation_eye_tracked: bool,
177 pub meta_local_dimming: bool,
178 pub meta_passthrough_preferences: bool,
179 pub meta_virtual_keyboard: bool,
180 pub meta_vulkan_swapchain_create_info: bool,
181 pub meta_performance_metrics: bool,
182 pub meta_headset_id: bool,
183 pub meta_recommended_layer_resolution: bool,
184 pub meta_passthrough_color_lut: bool,
185 pub meta_spatial_entity_mesh: bool,
186 pub meta_automatic_layer_filter: bool,
187 pub meta_touch_controller_plus: bool,
188 pub meta_environment_depth: bool,
189 pub ml_ml2_controller_interaction: bool,
190 pub ml_frame_end_info: bool,
191 pub ml_global_dimmer: bool,
192 pub ml_compat: bool,
193 pub ml_marker_understanding: bool,
194 pub ml_localization_map: bool,
195 pub ml_user_calibration: bool,
196 pub mnd_headless: bool,
197 pub mnd_swapchain_usage_input_attachment_bit: bool,
198 pub msft_unbounded_reference_space: bool,
199 pub msft_spatial_anchor: bool,
200 pub msft_spatial_graph_bridge: bool,
201 pub msft_hand_interaction: bool,
202 pub msft_hand_tracking_mesh: bool,
203 pub msft_secondary_view_configuration: bool,
204 pub msft_first_person_observer: bool,
205 pub msft_controller_model: bool,
206 #[cfg(windows)]
207 pub msft_perception_anchor_interop: bool,
208 #[cfg(windows)]
209 pub msft_holographic_window_attachment: bool,
210 pub msft_composition_layer_reprojection: bool,
211 pub msft_spatial_anchor_persistence: bool,
212 #[cfg(target_os = "android")]
213 pub oculus_android_session_state_enable: bool,
214 pub oculus_audio_device_guid: bool,
215 pub oculus_external_camera: bool,
216 pub oppo_controller_interaction: bool,
217 pub qcom_tracking_optimization_settings: bool,
218 pub ultraleap_hand_tracking_forearm: bool,
219 pub valve_analog_threshold: bool,
220 pub varjo_quad_views: bool,
221 pub varjo_foveated_rendering: bool,
222 pub varjo_composition_layer_depth_test: bool,
223 pub varjo_environment_depth_estimation: bool,
224 pub varjo_marker_tracking: bool,
225 pub varjo_view_offset: bool,
226 pub varjo_xr4_controller_interaction: bool,
227 pub yvr_controller_interaction: bool,
228 pub extx_overlay: bool,
229 pub mndx_egl_enable: bool,
230 pub mndx_force_feedback_curl: bool,
231 pub htcx_vive_tracker_interaction: bool,
232 #[doc = r" Extensions unknown to the high-level bindings"]
233 pub other: Vec<String>,
234}
235impl ExtensionSet {
236 pub(crate) fn from_properties(properties: &[sys::ExtensionProperties]) -> Self {
237 let mut out = Self::default();
238 for ext in properties {
239 match crate::fixed_str_bytes(&ext.extension_name) {
240 raw::DigitalLensControlALMALENCE::NAME => {
241 out.almalence_digital_lens_control = true;
242 }
243 raw::ControllerInteractionBD::NAME => {
244 out.bd_controller_interaction = true;
245 }
246 raw::ViewConfigurationFovEPIC::NAME => {
247 out.epic_view_configuration_fov = true;
248 }
249 raw::PerformanceSettingsEXT::NAME => {
250 out.ext_performance_settings = true;
251 }
252 raw::ThermalQueryEXT::NAME => {
253 out.ext_thermal_query = true;
254 }
255 raw::DebugUtilsEXT::NAME => {
256 out.ext_debug_utils = true;
257 }
258 raw::EyeGazeInteractionEXT::NAME => {
259 out.ext_eye_gaze_interaction = true;
260 }
261 raw::ViewConfigurationDepthRangeEXT::NAME => {
262 out.ext_view_configuration_depth_range = true;
263 }
264 raw::ConformanceAutomationEXT::NAME => {
265 out.ext_conformance_automation = true;
266 }
267 raw::HandTrackingEXT::NAME => {
268 out.ext_hand_tracking = true;
269 }
270 #[cfg(windows)]
271 raw::Win32AppcontainerCompatibleEXT::NAME => {
272 out.ext_win32_appcontainer_compatible = true;
273 }
274 raw::DpadBindingEXT::NAME => {
275 out.ext_dpad_binding = true;
276 }
277 raw::HandJointsMotionRangeEXT::NAME => {
278 out.ext_hand_joints_motion_range = true;
279 }
280 raw::SamsungOdysseyControllerEXT::NAME => {
281 out.ext_samsung_odyssey_controller = true;
282 }
283 raw::HpMixedRealityControllerEXT::NAME => {
284 out.ext_hp_mixed_reality_controller = true;
285 }
286 raw::PalmPoseEXT::NAME => {
287 out.ext_palm_pose = true;
288 }
289 raw::UuidEXT::NAME => {
290 out.ext_uuid = true;
291 }
292 raw::HandInteractionEXT::NAME => {
293 out.ext_hand_interaction = true;
294 }
295 raw::ActiveActionSetPriorityEXT::NAME => {
296 out.ext_active_action_set_priority = true;
297 }
298 raw::LocalFloorEXT::NAME => {
299 out.ext_local_floor = true;
300 }
301 raw::HandTrackingDataSourceEXT::NAME => {
302 out.ext_hand_tracking_data_source = true;
303 }
304 raw::PlaneDetectionEXT::NAME => {
305 out.ext_plane_detection = true;
306 }
307 raw::FutureEXT::NAME => {
308 out.ext_future = true;
309 }
310 raw::UserPresenceEXT::NAME => {
311 out.ext_user_presence = true;
312 }
313 raw::CompositionLayerImageLayoutFB::NAME => {
314 out.fb_composition_layer_image_layout = true;
315 }
316 raw::CompositionLayerAlphaBlendFB::NAME => {
317 out.fb_composition_layer_alpha_blend = true;
318 }
319 #[cfg(target_os = "android")]
320 raw::AndroidSurfaceSwapchainCreateFB::NAME => {
321 out.fb_android_surface_swapchain_create = true;
322 }
323 raw::SwapchainUpdateStateFB::NAME => {
324 out.fb_swapchain_update_state = true;
325 }
326 raw::CompositionLayerSecureContentFB::NAME => {
327 out.fb_composition_layer_secure_content = true;
328 }
329 raw::BodyTrackingFB::NAME => {
330 out.fb_body_tracking = true;
331 }
332 raw::DisplayRefreshRateFB::NAME => {
333 out.fb_display_refresh_rate = true;
334 }
335 raw::ColorSpaceFB::NAME => {
336 out.fb_color_space = true;
337 }
338 raw::HandTrackingMeshFB::NAME => {
339 out.fb_hand_tracking_mesh = true;
340 }
341 raw::HandTrackingAimFB::NAME => {
342 out.fb_hand_tracking_aim = true;
343 }
344 raw::HandTrackingCapsulesFB::NAME => {
345 out.fb_hand_tracking_capsules = true;
346 }
347 raw::SpatialEntityFB::NAME => {
348 out.fb_spatial_entity = true;
349 }
350 raw::FoveationFB::NAME => {
351 out.fb_foveation = true;
352 }
353 raw::FoveationConfigurationFB::NAME => {
354 out.fb_foveation_configuration = true;
355 }
356 raw::KeyboardTrackingFB::NAME => {
357 out.fb_keyboard_tracking = true;
358 }
359 raw::TriangleMeshFB::NAME => {
360 out.fb_triangle_mesh = true;
361 }
362 raw::PassthroughFB::NAME => {
363 out.fb_passthrough = true;
364 }
365 raw::RenderModelFB::NAME => {
366 out.fb_render_model = true;
367 }
368 raw::SpatialEntityQueryFB::NAME => {
369 out.fb_spatial_entity_query = true;
370 }
371 raw::SpatialEntityStorageFB::NAME => {
372 out.fb_spatial_entity_storage = true;
373 }
374 raw::FoveationVulkanFB::NAME => {
375 out.fb_foveation_vulkan = true;
376 }
377 #[cfg(target_os = "android")]
378 raw::SwapchainUpdateStateAndroidSurfaceFB::NAME => {
379 out.fb_swapchain_update_state_android_surface = true;
380 }
381 raw::SwapchainUpdateStateOpenglEsFB::NAME => {
382 out.fb_swapchain_update_state_opengl_es = true;
383 }
384 raw::SwapchainUpdateStateVulkanFB::NAME => {
385 out.fb_swapchain_update_state_vulkan = true;
386 }
387 raw::TouchControllerProFB::NAME => {
388 out.fb_touch_controller_pro = true;
389 }
390 raw::SpatialEntitySharingFB::NAME => {
391 out.fb_spatial_entity_sharing = true;
392 }
393 raw::SpaceWarpFB::NAME => {
394 out.fb_space_warp = true;
395 }
396 raw::HapticAmplitudeEnvelopeFB::NAME => {
397 out.fb_haptic_amplitude_envelope = true;
398 }
399 raw::SceneFB::NAME => {
400 out.fb_scene = true;
401 }
402 raw::SceneCaptureFB::NAME => {
403 out.fb_scene_capture = true;
404 }
405 raw::SpatialEntityContainerFB::NAME => {
406 out.fb_spatial_entity_container = true;
407 }
408 raw::FaceTrackingFB::NAME => {
409 out.fb_face_tracking = true;
410 }
411 raw::EyeTrackingSocialFB::NAME => {
412 out.fb_eye_tracking_social = true;
413 }
414 raw::PassthroughKeyboardHandsFB::NAME => {
415 out.fb_passthrough_keyboard_hands = true;
416 }
417 raw::CompositionLayerSettingsFB::NAME => {
418 out.fb_composition_layer_settings = true;
419 }
420 raw::TouchControllerProximityFB::NAME => {
421 out.fb_touch_controller_proximity = true;
422 }
423 raw::HapticPcmFB::NAME => {
424 out.fb_haptic_pcm = true;
425 }
426 raw::CompositionLayerDepthTestFB::NAME => {
427 out.fb_composition_layer_depth_test = true;
428 }
429 raw::SpatialEntityStorageBatchFB::NAME => {
430 out.fb_spatial_entity_storage_batch = true;
431 }
432 raw::SpatialEntityUserFB::NAME => {
433 out.fb_spatial_entity_user = true;
434 }
435 raw::FaceTracking2FB::NAME => {
436 out.fb_face_tracking2 = true;
437 }
438 raw::ViveCosmosControllerInteractionHTC::NAME => {
439 out.htc_vive_cosmos_controller_interaction = true;
440 }
441 raw::FacialTrackingHTC::NAME => {
442 out.htc_facial_tracking = true;
443 }
444 raw::ViveFocus3ControllerInteractionHTC::NAME => {
445 out.htc_vive_focus3_controller_interaction = true;
446 }
447 raw::HandInteractionHTC::NAME => {
448 out.htc_hand_interaction = true;
449 }
450 raw::ViveWristTrackerInteractionHTC::NAME => {
451 out.htc_vive_wrist_tracker_interaction = true;
452 }
453 raw::PassthroughHTC::NAME => {
454 out.htc_passthrough = true;
455 }
456 raw::FoveationHTC::NAME => {
457 out.htc_foveation = true;
458 }
459 raw::AnchorHTC::NAME => {
460 out.htc_anchor = true;
461 }
462 raw::ControllerInteractionHUAWEI::NAME => {
463 out.huawei_controller_interaction = true;
464 }
465 #[cfg(target_os = "android")]
466 raw::AndroidThreadSettingsKHR::NAME => {
467 out.khr_android_thread_settings = true;
468 }
469 #[cfg(target_os = "android")]
470 raw::AndroidSurfaceSwapchainKHR::NAME => {
471 out.khr_android_surface_swapchain = true;
472 }
473 raw::CompositionLayerCubeKHR::NAME => {
474 out.khr_composition_layer_cube = true;
475 }
476 #[cfg(target_os = "android")]
477 raw::AndroidCreateInstanceKHR::NAME => {
478 out.khr_android_create_instance = true;
479 }
480 raw::CompositionLayerDepthKHR::NAME => {
481 out.khr_composition_layer_depth = true;
482 }
483 raw::VulkanSwapchainFormatListKHR::NAME => {
484 out.khr_vulkan_swapchain_format_list = true;
485 }
486 raw::CompositionLayerCylinderKHR::NAME => {
487 out.khr_composition_layer_cylinder = true;
488 }
489 raw::CompositionLayerEquirectKHR::NAME => {
490 out.khr_composition_layer_equirect = true;
491 }
492 raw::OpenglEnableKHR::NAME => {
493 out.khr_opengl_enable = true;
494 }
495 raw::OpenglEsEnableKHR::NAME => {
496 out.khr_opengl_es_enable = true;
497 }
498 raw::VulkanEnableKHR::NAME => {
499 out.khr_vulkan_enable = true;
500 }
501 #[cfg(windows)]
502 raw::D3d11EnableKHR::NAME => {
503 out.khr_d3d11_enable = true;
504 }
505 #[cfg(windows)]
506 raw::D3d12EnableKHR::NAME => {
507 out.khr_d3d12_enable = true;
508 }
509 raw::VisibilityMaskKHR::NAME => {
510 out.khr_visibility_mask = true;
511 }
512 raw::CompositionLayerColorScaleBiasKHR::NAME => {
513 out.khr_composition_layer_color_scale_bias = true;
514 }
515 #[cfg(windows)]
516 raw::Win32ConvertPerformanceCounterTimeKHR::NAME => {
517 out.khr_win32_convert_performance_counter_time = true;
518 }
519 raw::ConvertTimespecTimeKHR::NAME => {
520 out.khr_convert_timespec_time = true;
521 }
522 raw::LoaderInitKHR::NAME => {
523 out.khr_loader_init = true;
524 }
525 #[cfg(target_os = "android")]
526 raw::LoaderInitAndroidKHR::NAME => {
527 out.khr_loader_init_android = true;
528 }
529 raw::VulkanEnable2KHR::NAME => {
530 out.khr_vulkan_enable2 = true;
531 }
532 raw::CompositionLayerEquirect2KHR::NAME => {
533 out.khr_composition_layer_equirect2 = true;
534 }
535 raw::BindingModificationKHR::NAME => {
536 out.khr_binding_modification = true;
537 }
538 raw::SwapchainUsageInputAttachmentBitKHR::NAME => {
539 out.khr_swapchain_usage_input_attachment_bit = true;
540 }
541 raw::LocateSpacesKHR::NAME => {
542 out.khr_locate_spaces = true;
543 }
544 raw::Maintenance1KHR::NAME => {
545 out.khr_maintenance1 = true;
546 }
547 raw::FoveationEyeTrackedMETA::NAME => {
548 out.meta_foveation_eye_tracked = true;
549 }
550 raw::LocalDimmingMETA::NAME => {
551 out.meta_local_dimming = true;
552 }
553 raw::PassthroughPreferencesMETA::NAME => {
554 out.meta_passthrough_preferences = true;
555 }
556 raw::VirtualKeyboardMETA::NAME => {
557 out.meta_virtual_keyboard = true;
558 }
559 raw::VulkanSwapchainCreateInfoMETA::NAME => {
560 out.meta_vulkan_swapchain_create_info = true;
561 }
562 raw::PerformanceMetricsMETA::NAME => {
563 out.meta_performance_metrics = true;
564 }
565 raw::HeadsetIdMETA::NAME => {
566 out.meta_headset_id = true;
567 }
568 raw::RecommendedLayerResolutionMETA::NAME => {
569 out.meta_recommended_layer_resolution = true;
570 }
571 raw::PassthroughColorLutMETA::NAME => {
572 out.meta_passthrough_color_lut = true;
573 }
574 raw::SpatialEntityMeshMETA::NAME => {
575 out.meta_spatial_entity_mesh = true;
576 }
577 raw::AutomaticLayerFilterMETA::NAME => {
578 out.meta_automatic_layer_filter = true;
579 }
580 raw::TouchControllerPlusMETA::NAME => {
581 out.meta_touch_controller_plus = true;
582 }
583 raw::EnvironmentDepthMETA::NAME => {
584 out.meta_environment_depth = true;
585 }
586 raw::Ml2ControllerInteractionML::NAME => {
587 out.ml_ml2_controller_interaction = true;
588 }
589 raw::FrameEndInfoML::NAME => {
590 out.ml_frame_end_info = true;
591 }
592 raw::GlobalDimmerML::NAME => {
593 out.ml_global_dimmer = true;
594 }
595 raw::CompatML::NAME => {
596 out.ml_compat = true;
597 }
598 raw::MarkerUnderstandingML::NAME => {
599 out.ml_marker_understanding = true;
600 }
601 raw::LocalizationMapML::NAME => {
602 out.ml_localization_map = true;
603 }
604 raw::UserCalibrationML::NAME => {
605 out.ml_user_calibration = true;
606 }
607 raw::HeadlessMND::NAME => {
608 out.mnd_headless = true;
609 }
610 raw::SwapchainUsageInputAttachmentBitMND::NAME => {
611 out.mnd_swapchain_usage_input_attachment_bit = true;
612 }
613 raw::UnboundedReferenceSpaceMSFT::NAME => {
614 out.msft_unbounded_reference_space = true;
615 }
616 raw::SpatialAnchorMSFT::NAME => {
617 out.msft_spatial_anchor = true;
618 }
619 raw::SpatialGraphBridgeMSFT::NAME => {
620 out.msft_spatial_graph_bridge = true;
621 }
622 raw::HandInteractionMSFT::NAME => {
623 out.msft_hand_interaction = true;
624 }
625 raw::HandTrackingMeshMSFT::NAME => {
626 out.msft_hand_tracking_mesh = true;
627 }
628 raw::SecondaryViewConfigurationMSFT::NAME => {
629 out.msft_secondary_view_configuration = true;
630 }
631 raw::FirstPersonObserverMSFT::NAME => {
632 out.msft_first_person_observer = true;
633 }
634 raw::ControllerModelMSFT::NAME => {
635 out.msft_controller_model = true;
636 }
637 #[cfg(windows)]
638 raw::PerceptionAnchorInteropMSFT::NAME => {
639 out.msft_perception_anchor_interop = true;
640 }
641 #[cfg(windows)]
642 raw::HolographicWindowAttachmentMSFT::NAME => {
643 out.msft_holographic_window_attachment = true;
644 }
645 raw::CompositionLayerReprojectionMSFT::NAME => {
646 out.msft_composition_layer_reprojection = true;
647 }
648 raw::SpatialAnchorPersistenceMSFT::NAME => {
649 out.msft_spatial_anchor_persistence = true;
650 }
651 #[cfg(target_os = "android")]
652 raw::AndroidSessionStateEnableOCULUS::NAME => {
653 out.oculus_android_session_state_enable = true;
654 }
655 raw::AudioDeviceGuidOCULUS::NAME => {
656 out.oculus_audio_device_guid = true;
657 }
658 raw::ExternalCameraOCULUS::NAME => {
659 out.oculus_external_camera = true;
660 }
661 raw::ControllerInteractionOPPO::NAME => {
662 out.oppo_controller_interaction = true;
663 }
664 raw::TrackingOptimizationSettingsQCOM::NAME => {
665 out.qcom_tracking_optimization_settings = true;
666 }
667 raw::HandTrackingForearmULTRALEAP::NAME => {
668 out.ultraleap_hand_tracking_forearm = true;
669 }
670 raw::AnalogThresholdVALVE::NAME => {
671 out.valve_analog_threshold = true;
672 }
673 raw::QuadViewsVARJO::NAME => {
674 out.varjo_quad_views = true;
675 }
676 raw::FoveatedRenderingVARJO::NAME => {
677 out.varjo_foveated_rendering = true;
678 }
679 raw::CompositionLayerDepthTestVARJO::NAME => {
680 out.varjo_composition_layer_depth_test = true;
681 }
682 raw::EnvironmentDepthEstimationVARJO::NAME => {
683 out.varjo_environment_depth_estimation = true;
684 }
685 raw::MarkerTrackingVARJO::NAME => {
686 out.varjo_marker_tracking = true;
687 }
688 raw::ViewOffsetVARJO::NAME => {
689 out.varjo_view_offset = true;
690 }
691 raw::Xr4ControllerInteractionVARJO::NAME => {
692 out.varjo_xr4_controller_interaction = true;
693 }
694 raw::ControllerInteractionYVR::NAME => {
695 out.yvr_controller_interaction = true;
696 }
697 raw::OverlayEXTX::NAME => {
698 out.extx_overlay = true;
699 }
700 raw::EglEnableMNDX::NAME => {
701 out.mndx_egl_enable = true;
702 }
703 raw::ForceFeedbackCurlMNDX::NAME => {
704 out.mndx_force_feedback_curl = true;
705 }
706 raw::ViveTrackerInteractionHTCX::NAME => {
707 out.htcx_vive_tracker_interaction = true;
708 }
709 bytes => {
710 let cstr = CStr::from_bytes_with_nul(bytes)
711 .expect("extension names should be null terminated strings");
712 let string = cstr
713 .to_str()
714 .expect("extension names should be valid UTF-8")
715 .to_string();
716 out.other.push(string);
717 }
718 }
719 }
720 out
721 }
722 pub(crate) fn names(&self) -> Vec<Cow<'static, [u8]>> {
723 let mut out = Vec::new();
724 {
725 if self.almalence_digital_lens_control {
726 out.push(raw::DigitalLensControlALMALENCE::NAME.into());
727 }
728 }
729 {
730 if self.bd_controller_interaction {
731 out.push(raw::ControllerInteractionBD::NAME.into());
732 }
733 }
734 {
735 if self.epic_view_configuration_fov {
736 out.push(raw::ViewConfigurationFovEPIC::NAME.into());
737 }
738 }
739 {
740 if self.ext_performance_settings {
741 out.push(raw::PerformanceSettingsEXT::NAME.into());
742 }
743 }
744 {
745 if self.ext_thermal_query {
746 out.push(raw::ThermalQueryEXT::NAME.into());
747 }
748 }
749 {
750 if self.ext_debug_utils {
751 out.push(raw::DebugUtilsEXT::NAME.into());
752 }
753 }
754 {
755 if self.ext_eye_gaze_interaction {
756 out.push(raw::EyeGazeInteractionEXT::NAME.into());
757 }
758 }
759 {
760 if self.ext_view_configuration_depth_range {
761 out.push(raw::ViewConfigurationDepthRangeEXT::NAME.into());
762 }
763 }
764 {
765 if self.ext_conformance_automation {
766 out.push(raw::ConformanceAutomationEXT::NAME.into());
767 }
768 }
769 {
770 if self.ext_hand_tracking {
771 out.push(raw::HandTrackingEXT::NAME.into());
772 }
773 }
774 #[cfg(windows)]
775 {
776 if self.ext_win32_appcontainer_compatible {
777 out.push(raw::Win32AppcontainerCompatibleEXT::NAME.into());
778 }
779 }
780 {
781 if self.ext_dpad_binding {
782 out.push(raw::DpadBindingEXT::NAME.into());
783 }
784 }
785 {
786 if self.ext_hand_joints_motion_range {
787 out.push(raw::HandJointsMotionRangeEXT::NAME.into());
788 }
789 }
790 {
791 if self.ext_samsung_odyssey_controller {
792 out.push(raw::SamsungOdysseyControllerEXT::NAME.into());
793 }
794 }
795 {
796 if self.ext_hp_mixed_reality_controller {
797 out.push(raw::HpMixedRealityControllerEXT::NAME.into());
798 }
799 }
800 {
801 if self.ext_palm_pose {
802 out.push(raw::PalmPoseEXT::NAME.into());
803 }
804 }
805 {
806 if self.ext_uuid {
807 out.push(raw::UuidEXT::NAME.into());
808 }
809 }
810 {
811 if self.ext_hand_interaction {
812 out.push(raw::HandInteractionEXT::NAME.into());
813 }
814 }
815 {
816 if self.ext_active_action_set_priority {
817 out.push(raw::ActiveActionSetPriorityEXT::NAME.into());
818 }
819 }
820 {
821 if self.ext_local_floor {
822 out.push(raw::LocalFloorEXT::NAME.into());
823 }
824 }
825 {
826 if self.ext_hand_tracking_data_source {
827 out.push(raw::HandTrackingDataSourceEXT::NAME.into());
828 }
829 }
830 {
831 if self.ext_plane_detection {
832 out.push(raw::PlaneDetectionEXT::NAME.into());
833 }
834 }
835 {
836 if self.ext_future {
837 out.push(raw::FutureEXT::NAME.into());
838 }
839 }
840 {
841 if self.ext_user_presence {
842 out.push(raw::UserPresenceEXT::NAME.into());
843 }
844 }
845 {
846 if self.fb_composition_layer_image_layout {
847 out.push(raw::CompositionLayerImageLayoutFB::NAME.into());
848 }
849 }
850 {
851 if self.fb_composition_layer_alpha_blend {
852 out.push(raw::CompositionLayerAlphaBlendFB::NAME.into());
853 }
854 }
855 #[cfg(target_os = "android")]
856 {
857 if self.fb_android_surface_swapchain_create {
858 out.push(raw::AndroidSurfaceSwapchainCreateFB::NAME.into());
859 }
860 }
861 {
862 if self.fb_swapchain_update_state {
863 out.push(raw::SwapchainUpdateStateFB::NAME.into());
864 }
865 }
866 {
867 if self.fb_composition_layer_secure_content {
868 out.push(raw::CompositionLayerSecureContentFB::NAME.into());
869 }
870 }
871 {
872 if self.fb_body_tracking {
873 out.push(raw::BodyTrackingFB::NAME.into());
874 }
875 }
876 {
877 if self.fb_display_refresh_rate {
878 out.push(raw::DisplayRefreshRateFB::NAME.into());
879 }
880 }
881 {
882 if self.fb_color_space {
883 out.push(raw::ColorSpaceFB::NAME.into());
884 }
885 }
886 {
887 if self.fb_hand_tracking_mesh {
888 out.push(raw::HandTrackingMeshFB::NAME.into());
889 }
890 }
891 {
892 if self.fb_hand_tracking_aim {
893 out.push(raw::HandTrackingAimFB::NAME.into());
894 }
895 }
896 {
897 if self.fb_hand_tracking_capsules {
898 out.push(raw::HandTrackingCapsulesFB::NAME.into());
899 }
900 }
901 {
902 if self.fb_spatial_entity {
903 out.push(raw::SpatialEntityFB::NAME.into());
904 }
905 }
906 {
907 if self.fb_foveation {
908 out.push(raw::FoveationFB::NAME.into());
909 }
910 }
911 {
912 if self.fb_foveation_configuration {
913 out.push(raw::FoveationConfigurationFB::NAME.into());
914 }
915 }
916 {
917 if self.fb_keyboard_tracking {
918 out.push(raw::KeyboardTrackingFB::NAME.into());
919 }
920 }
921 {
922 if self.fb_triangle_mesh {
923 out.push(raw::TriangleMeshFB::NAME.into());
924 }
925 }
926 {
927 if self.fb_passthrough {
928 out.push(raw::PassthroughFB::NAME.into());
929 }
930 }
931 {
932 if self.fb_render_model {
933 out.push(raw::RenderModelFB::NAME.into());
934 }
935 }
936 {
937 if self.fb_spatial_entity_query {
938 out.push(raw::SpatialEntityQueryFB::NAME.into());
939 }
940 }
941 {
942 if self.fb_spatial_entity_storage {
943 out.push(raw::SpatialEntityStorageFB::NAME.into());
944 }
945 }
946 {
947 if self.fb_foveation_vulkan {
948 out.push(raw::FoveationVulkanFB::NAME.into());
949 }
950 }
951 #[cfg(target_os = "android")]
952 {
953 if self.fb_swapchain_update_state_android_surface {
954 out.push(raw::SwapchainUpdateStateAndroidSurfaceFB::NAME.into());
955 }
956 }
957 {
958 if self.fb_swapchain_update_state_opengl_es {
959 out.push(raw::SwapchainUpdateStateOpenglEsFB::NAME.into());
960 }
961 }
962 {
963 if self.fb_swapchain_update_state_vulkan {
964 out.push(raw::SwapchainUpdateStateVulkanFB::NAME.into());
965 }
966 }
967 {
968 if self.fb_touch_controller_pro {
969 out.push(raw::TouchControllerProFB::NAME.into());
970 }
971 }
972 {
973 if self.fb_spatial_entity_sharing {
974 out.push(raw::SpatialEntitySharingFB::NAME.into());
975 }
976 }
977 {
978 if self.fb_space_warp {
979 out.push(raw::SpaceWarpFB::NAME.into());
980 }
981 }
982 {
983 if self.fb_haptic_amplitude_envelope {
984 out.push(raw::HapticAmplitudeEnvelopeFB::NAME.into());
985 }
986 }
987 {
988 if self.fb_scene {
989 out.push(raw::SceneFB::NAME.into());
990 }
991 }
992 {
993 if self.fb_scene_capture {
994 out.push(raw::SceneCaptureFB::NAME.into());
995 }
996 }
997 {
998 if self.fb_spatial_entity_container {
999 out.push(raw::SpatialEntityContainerFB::NAME.into());
1000 }
1001 }
1002 {
1003 if self.fb_face_tracking {
1004 out.push(raw::FaceTrackingFB::NAME.into());
1005 }
1006 }
1007 {
1008 if self.fb_eye_tracking_social {
1009 out.push(raw::EyeTrackingSocialFB::NAME.into());
1010 }
1011 }
1012 {
1013 if self.fb_passthrough_keyboard_hands {
1014 out.push(raw::PassthroughKeyboardHandsFB::NAME.into());
1015 }
1016 }
1017 {
1018 if self.fb_composition_layer_settings {
1019 out.push(raw::CompositionLayerSettingsFB::NAME.into());
1020 }
1021 }
1022 {
1023 if self.fb_touch_controller_proximity {
1024 out.push(raw::TouchControllerProximityFB::NAME.into());
1025 }
1026 }
1027 {
1028 if self.fb_haptic_pcm {
1029 out.push(raw::HapticPcmFB::NAME.into());
1030 }
1031 }
1032 {
1033 if self.fb_composition_layer_depth_test {
1034 out.push(raw::CompositionLayerDepthTestFB::NAME.into());
1035 }
1036 }
1037 {
1038 if self.fb_spatial_entity_storage_batch {
1039 out.push(raw::SpatialEntityStorageBatchFB::NAME.into());
1040 }
1041 }
1042 {
1043 if self.fb_spatial_entity_user {
1044 out.push(raw::SpatialEntityUserFB::NAME.into());
1045 }
1046 }
1047 {
1048 if self.fb_face_tracking2 {
1049 out.push(raw::FaceTracking2FB::NAME.into());
1050 }
1051 }
1052 {
1053 if self.htc_vive_cosmos_controller_interaction {
1054 out.push(raw::ViveCosmosControllerInteractionHTC::NAME.into());
1055 }
1056 }
1057 {
1058 if self.htc_facial_tracking {
1059 out.push(raw::FacialTrackingHTC::NAME.into());
1060 }
1061 }
1062 {
1063 if self.htc_vive_focus3_controller_interaction {
1064 out.push(raw::ViveFocus3ControllerInteractionHTC::NAME.into());
1065 }
1066 }
1067 {
1068 if self.htc_hand_interaction {
1069 out.push(raw::HandInteractionHTC::NAME.into());
1070 }
1071 }
1072 {
1073 if self.htc_vive_wrist_tracker_interaction {
1074 out.push(raw::ViveWristTrackerInteractionHTC::NAME.into());
1075 }
1076 }
1077 {
1078 if self.htc_passthrough {
1079 out.push(raw::PassthroughHTC::NAME.into());
1080 }
1081 }
1082 {
1083 if self.htc_foveation {
1084 out.push(raw::FoveationHTC::NAME.into());
1085 }
1086 }
1087 {
1088 if self.htc_anchor {
1089 out.push(raw::AnchorHTC::NAME.into());
1090 }
1091 }
1092 {
1093 if self.huawei_controller_interaction {
1094 out.push(raw::ControllerInteractionHUAWEI::NAME.into());
1095 }
1096 }
1097 #[cfg(target_os = "android")]
1098 {
1099 if self.khr_android_thread_settings {
1100 out.push(raw::AndroidThreadSettingsKHR::NAME.into());
1101 }
1102 }
1103 #[cfg(target_os = "android")]
1104 {
1105 if self.khr_android_surface_swapchain {
1106 out.push(raw::AndroidSurfaceSwapchainKHR::NAME.into());
1107 }
1108 }
1109 {
1110 if self.khr_composition_layer_cube {
1111 out.push(raw::CompositionLayerCubeKHR::NAME.into());
1112 }
1113 }
1114 #[cfg(target_os = "android")]
1115 {
1116 if self.khr_android_create_instance {
1117 out.push(raw::AndroidCreateInstanceKHR::NAME.into());
1118 }
1119 }
1120 {
1121 if self.khr_composition_layer_depth {
1122 out.push(raw::CompositionLayerDepthKHR::NAME.into());
1123 }
1124 }
1125 {
1126 if self.khr_vulkan_swapchain_format_list {
1127 out.push(raw::VulkanSwapchainFormatListKHR::NAME.into());
1128 }
1129 }
1130 {
1131 if self.khr_composition_layer_cylinder {
1132 out.push(raw::CompositionLayerCylinderKHR::NAME.into());
1133 }
1134 }
1135 {
1136 if self.khr_composition_layer_equirect {
1137 out.push(raw::CompositionLayerEquirectKHR::NAME.into());
1138 }
1139 }
1140 {
1141 if self.khr_opengl_enable {
1142 out.push(raw::OpenglEnableKHR::NAME.into());
1143 }
1144 }
1145 {
1146 if self.khr_opengl_es_enable {
1147 out.push(raw::OpenglEsEnableKHR::NAME.into());
1148 }
1149 }
1150 {
1151 if self.khr_vulkan_enable {
1152 out.push(raw::VulkanEnableKHR::NAME.into());
1153 }
1154 }
1155 #[cfg(windows)]
1156 {
1157 if self.khr_d3d11_enable {
1158 out.push(raw::D3d11EnableKHR::NAME.into());
1159 }
1160 }
1161 #[cfg(windows)]
1162 {
1163 if self.khr_d3d12_enable {
1164 out.push(raw::D3d12EnableKHR::NAME.into());
1165 }
1166 }
1167 {
1168 if self.khr_visibility_mask {
1169 out.push(raw::VisibilityMaskKHR::NAME.into());
1170 }
1171 }
1172 {
1173 if self.khr_composition_layer_color_scale_bias {
1174 out.push(raw::CompositionLayerColorScaleBiasKHR::NAME.into());
1175 }
1176 }
1177 #[cfg(windows)]
1178 {
1179 if self.khr_win32_convert_performance_counter_time {
1180 out.push(raw::Win32ConvertPerformanceCounterTimeKHR::NAME.into());
1181 }
1182 }
1183 {
1184 if self.khr_convert_timespec_time {
1185 out.push(raw::ConvertTimespecTimeKHR::NAME.into());
1186 }
1187 }
1188 {
1189 if self.khr_loader_init {
1190 out.push(raw::LoaderInitKHR::NAME.into());
1191 }
1192 }
1193 #[cfg(target_os = "android")]
1194 {
1195 if self.khr_loader_init_android {
1196 out.push(raw::LoaderInitAndroidKHR::NAME.into());
1197 }
1198 }
1199 {
1200 if self.khr_vulkan_enable2 {
1201 out.push(raw::VulkanEnable2KHR::NAME.into());
1202 }
1203 }
1204 {
1205 if self.khr_composition_layer_equirect2 {
1206 out.push(raw::CompositionLayerEquirect2KHR::NAME.into());
1207 }
1208 }
1209 {
1210 if self.khr_binding_modification {
1211 out.push(raw::BindingModificationKHR::NAME.into());
1212 }
1213 }
1214 {
1215 if self.khr_swapchain_usage_input_attachment_bit {
1216 out.push(raw::SwapchainUsageInputAttachmentBitKHR::NAME.into());
1217 }
1218 }
1219 {
1220 if self.khr_locate_spaces {
1221 out.push(raw::LocateSpacesKHR::NAME.into());
1222 }
1223 }
1224 {
1225 if self.khr_maintenance1 {
1226 out.push(raw::Maintenance1KHR::NAME.into());
1227 }
1228 }
1229 {
1230 if self.meta_foveation_eye_tracked {
1231 out.push(raw::FoveationEyeTrackedMETA::NAME.into());
1232 }
1233 }
1234 {
1235 if self.meta_local_dimming {
1236 out.push(raw::LocalDimmingMETA::NAME.into());
1237 }
1238 }
1239 {
1240 if self.meta_passthrough_preferences {
1241 out.push(raw::PassthroughPreferencesMETA::NAME.into());
1242 }
1243 }
1244 {
1245 if self.meta_virtual_keyboard {
1246 out.push(raw::VirtualKeyboardMETA::NAME.into());
1247 }
1248 }
1249 {
1250 if self.meta_vulkan_swapchain_create_info {
1251 out.push(raw::VulkanSwapchainCreateInfoMETA::NAME.into());
1252 }
1253 }
1254 {
1255 if self.meta_performance_metrics {
1256 out.push(raw::PerformanceMetricsMETA::NAME.into());
1257 }
1258 }
1259 {
1260 if self.meta_headset_id {
1261 out.push(raw::HeadsetIdMETA::NAME.into());
1262 }
1263 }
1264 {
1265 if self.meta_recommended_layer_resolution {
1266 out.push(raw::RecommendedLayerResolutionMETA::NAME.into());
1267 }
1268 }
1269 {
1270 if self.meta_passthrough_color_lut {
1271 out.push(raw::PassthroughColorLutMETA::NAME.into());
1272 }
1273 }
1274 {
1275 if self.meta_spatial_entity_mesh {
1276 out.push(raw::SpatialEntityMeshMETA::NAME.into());
1277 }
1278 }
1279 {
1280 if self.meta_automatic_layer_filter {
1281 out.push(raw::AutomaticLayerFilterMETA::NAME.into());
1282 }
1283 }
1284 {
1285 if self.meta_touch_controller_plus {
1286 out.push(raw::TouchControllerPlusMETA::NAME.into());
1287 }
1288 }
1289 {
1290 if self.meta_environment_depth {
1291 out.push(raw::EnvironmentDepthMETA::NAME.into());
1292 }
1293 }
1294 {
1295 if self.ml_ml2_controller_interaction {
1296 out.push(raw::Ml2ControllerInteractionML::NAME.into());
1297 }
1298 }
1299 {
1300 if self.ml_frame_end_info {
1301 out.push(raw::FrameEndInfoML::NAME.into());
1302 }
1303 }
1304 {
1305 if self.ml_global_dimmer {
1306 out.push(raw::GlobalDimmerML::NAME.into());
1307 }
1308 }
1309 {
1310 if self.ml_compat {
1311 out.push(raw::CompatML::NAME.into());
1312 }
1313 }
1314 {
1315 if self.ml_marker_understanding {
1316 out.push(raw::MarkerUnderstandingML::NAME.into());
1317 }
1318 }
1319 {
1320 if self.ml_localization_map {
1321 out.push(raw::LocalizationMapML::NAME.into());
1322 }
1323 }
1324 {
1325 if self.ml_user_calibration {
1326 out.push(raw::UserCalibrationML::NAME.into());
1327 }
1328 }
1329 {
1330 if self.mnd_headless {
1331 out.push(raw::HeadlessMND::NAME.into());
1332 }
1333 }
1334 {
1335 if self.mnd_swapchain_usage_input_attachment_bit {
1336 out.push(raw::SwapchainUsageInputAttachmentBitMND::NAME.into());
1337 }
1338 }
1339 {
1340 if self.msft_unbounded_reference_space {
1341 out.push(raw::UnboundedReferenceSpaceMSFT::NAME.into());
1342 }
1343 }
1344 {
1345 if self.msft_spatial_anchor {
1346 out.push(raw::SpatialAnchorMSFT::NAME.into());
1347 }
1348 }
1349 {
1350 if self.msft_spatial_graph_bridge {
1351 out.push(raw::SpatialGraphBridgeMSFT::NAME.into());
1352 }
1353 }
1354 {
1355 if self.msft_hand_interaction {
1356 out.push(raw::HandInteractionMSFT::NAME.into());
1357 }
1358 }
1359 {
1360 if self.msft_hand_tracking_mesh {
1361 out.push(raw::HandTrackingMeshMSFT::NAME.into());
1362 }
1363 }
1364 {
1365 if self.msft_secondary_view_configuration {
1366 out.push(raw::SecondaryViewConfigurationMSFT::NAME.into());
1367 }
1368 }
1369 {
1370 if self.msft_first_person_observer {
1371 out.push(raw::FirstPersonObserverMSFT::NAME.into());
1372 }
1373 }
1374 {
1375 if self.msft_controller_model {
1376 out.push(raw::ControllerModelMSFT::NAME.into());
1377 }
1378 }
1379 #[cfg(windows)]
1380 {
1381 if self.msft_perception_anchor_interop {
1382 out.push(raw::PerceptionAnchorInteropMSFT::NAME.into());
1383 }
1384 }
1385 #[cfg(windows)]
1386 {
1387 if self.msft_holographic_window_attachment {
1388 out.push(raw::HolographicWindowAttachmentMSFT::NAME.into());
1389 }
1390 }
1391 {
1392 if self.msft_composition_layer_reprojection {
1393 out.push(raw::CompositionLayerReprojectionMSFT::NAME.into());
1394 }
1395 }
1396 {
1397 if self.msft_spatial_anchor_persistence {
1398 out.push(raw::SpatialAnchorPersistenceMSFT::NAME.into());
1399 }
1400 }
1401 #[cfg(target_os = "android")]
1402 {
1403 if self.oculus_android_session_state_enable {
1404 out.push(raw::AndroidSessionStateEnableOCULUS::NAME.into());
1405 }
1406 }
1407 {
1408 if self.oculus_audio_device_guid {
1409 out.push(raw::AudioDeviceGuidOCULUS::NAME.into());
1410 }
1411 }
1412 {
1413 if self.oculus_external_camera {
1414 out.push(raw::ExternalCameraOCULUS::NAME.into());
1415 }
1416 }
1417 {
1418 if self.oppo_controller_interaction {
1419 out.push(raw::ControllerInteractionOPPO::NAME.into());
1420 }
1421 }
1422 {
1423 if self.qcom_tracking_optimization_settings {
1424 out.push(raw::TrackingOptimizationSettingsQCOM::NAME.into());
1425 }
1426 }
1427 {
1428 if self.ultraleap_hand_tracking_forearm {
1429 out.push(raw::HandTrackingForearmULTRALEAP::NAME.into());
1430 }
1431 }
1432 {
1433 if self.valve_analog_threshold {
1434 out.push(raw::AnalogThresholdVALVE::NAME.into());
1435 }
1436 }
1437 {
1438 if self.varjo_quad_views {
1439 out.push(raw::QuadViewsVARJO::NAME.into());
1440 }
1441 }
1442 {
1443 if self.varjo_foveated_rendering {
1444 out.push(raw::FoveatedRenderingVARJO::NAME.into());
1445 }
1446 }
1447 {
1448 if self.varjo_composition_layer_depth_test {
1449 out.push(raw::CompositionLayerDepthTestVARJO::NAME.into());
1450 }
1451 }
1452 {
1453 if self.varjo_environment_depth_estimation {
1454 out.push(raw::EnvironmentDepthEstimationVARJO::NAME.into());
1455 }
1456 }
1457 {
1458 if self.varjo_marker_tracking {
1459 out.push(raw::MarkerTrackingVARJO::NAME.into());
1460 }
1461 }
1462 {
1463 if self.varjo_view_offset {
1464 out.push(raw::ViewOffsetVARJO::NAME.into());
1465 }
1466 }
1467 {
1468 if self.varjo_xr4_controller_interaction {
1469 out.push(raw::Xr4ControllerInteractionVARJO::NAME.into());
1470 }
1471 }
1472 {
1473 if self.yvr_controller_interaction {
1474 out.push(raw::ControllerInteractionYVR::NAME.into());
1475 }
1476 }
1477 {
1478 if self.extx_overlay {
1479 out.push(raw::OverlayEXTX::NAME.into());
1480 }
1481 }
1482 {
1483 if self.mndx_egl_enable {
1484 out.push(raw::EglEnableMNDX::NAME.into());
1485 }
1486 }
1487 {
1488 if self.mndx_force_feedback_curl {
1489 out.push(raw::ForceFeedbackCurlMNDX::NAME.into());
1490 }
1491 }
1492 {
1493 if self.htcx_vive_tracker_interaction {
1494 out.push(raw::ViveTrackerInteractionHTCX::NAME.into());
1495 }
1496 }
1497 for name in &self.other {
1498 let mut bytes = Vec::with_capacity(name.len() + 1);
1499 bytes.extend_from_slice(name.as_bytes());
1500 bytes.push(0);
1501 out.push(bytes.into());
1502 }
1503 out
1504 }
1505}
1506#[doc = r" Extensions used internally by the bindings"]
1507#[derive(Default, Copy, Clone)]
1508pub struct InstanceExtensions {
1509 pub almalence_digital_lens_control: Option<raw::DigitalLensControlALMALENCE>,
1510 pub bd_controller_interaction: Option<raw::ControllerInteractionBD>,
1511 pub epic_view_configuration_fov: Option<raw::ViewConfigurationFovEPIC>,
1512 pub ext_performance_settings: Option<raw::PerformanceSettingsEXT>,
1513 pub ext_thermal_query: Option<raw::ThermalQueryEXT>,
1514 pub ext_debug_utils: Option<raw::DebugUtilsEXT>,
1515 pub ext_eye_gaze_interaction: Option<raw::EyeGazeInteractionEXT>,
1516 pub ext_view_configuration_depth_range: Option<raw::ViewConfigurationDepthRangeEXT>,
1517 pub ext_conformance_automation: Option<raw::ConformanceAutomationEXT>,
1518 pub ext_hand_tracking: Option<raw::HandTrackingEXT>,
1519 #[cfg(windows)]
1520 pub ext_win32_appcontainer_compatible: Option<raw::Win32AppcontainerCompatibleEXT>,
1521 pub ext_dpad_binding: Option<raw::DpadBindingEXT>,
1522 pub ext_hand_joints_motion_range: Option<raw::HandJointsMotionRangeEXT>,
1523 pub ext_samsung_odyssey_controller: Option<raw::SamsungOdysseyControllerEXT>,
1524 pub ext_hp_mixed_reality_controller: Option<raw::HpMixedRealityControllerEXT>,
1525 pub ext_palm_pose: Option<raw::PalmPoseEXT>,
1526 pub ext_uuid: Option<raw::UuidEXT>,
1527 pub ext_hand_interaction: Option<raw::HandInteractionEXT>,
1528 pub ext_active_action_set_priority: Option<raw::ActiveActionSetPriorityEXT>,
1529 pub ext_local_floor: Option<raw::LocalFloorEXT>,
1530 pub ext_hand_tracking_data_source: Option<raw::HandTrackingDataSourceEXT>,
1531 pub ext_plane_detection: Option<raw::PlaneDetectionEXT>,
1532 pub ext_future: Option<raw::FutureEXT>,
1533 pub ext_user_presence: Option<raw::UserPresenceEXT>,
1534 pub fb_composition_layer_image_layout: Option<raw::CompositionLayerImageLayoutFB>,
1535 pub fb_composition_layer_alpha_blend: Option<raw::CompositionLayerAlphaBlendFB>,
1536 #[cfg(target_os = "android")]
1537 pub fb_android_surface_swapchain_create: Option<raw::AndroidSurfaceSwapchainCreateFB>,
1538 pub fb_swapchain_update_state: Option<raw::SwapchainUpdateStateFB>,
1539 pub fb_composition_layer_secure_content: Option<raw::CompositionLayerSecureContentFB>,
1540 pub fb_body_tracking: Option<raw::BodyTrackingFB>,
1541 pub fb_display_refresh_rate: Option<raw::DisplayRefreshRateFB>,
1542 pub fb_color_space: Option<raw::ColorSpaceFB>,
1543 pub fb_hand_tracking_mesh: Option<raw::HandTrackingMeshFB>,
1544 pub fb_hand_tracking_aim: Option<raw::HandTrackingAimFB>,
1545 pub fb_hand_tracking_capsules: Option<raw::HandTrackingCapsulesFB>,
1546 pub fb_spatial_entity: Option<raw::SpatialEntityFB>,
1547 pub fb_foveation: Option<raw::FoveationFB>,
1548 pub fb_foveation_configuration: Option<raw::FoveationConfigurationFB>,
1549 pub fb_keyboard_tracking: Option<raw::KeyboardTrackingFB>,
1550 pub fb_triangle_mesh: Option<raw::TriangleMeshFB>,
1551 pub fb_passthrough: Option<raw::PassthroughFB>,
1552 pub fb_render_model: Option<raw::RenderModelFB>,
1553 pub fb_spatial_entity_query: Option<raw::SpatialEntityQueryFB>,
1554 pub fb_spatial_entity_storage: Option<raw::SpatialEntityStorageFB>,
1555 pub fb_foveation_vulkan: Option<raw::FoveationVulkanFB>,
1556 #[cfg(target_os = "android")]
1557 pub fb_swapchain_update_state_android_surface:
1558 Option<raw::SwapchainUpdateStateAndroidSurfaceFB>,
1559 pub fb_swapchain_update_state_opengl_es: Option<raw::SwapchainUpdateStateOpenglEsFB>,
1560 pub fb_swapchain_update_state_vulkan: Option<raw::SwapchainUpdateStateVulkanFB>,
1561 pub fb_touch_controller_pro: Option<raw::TouchControllerProFB>,
1562 pub fb_spatial_entity_sharing: Option<raw::SpatialEntitySharingFB>,
1563 pub fb_space_warp: Option<raw::SpaceWarpFB>,
1564 pub fb_haptic_amplitude_envelope: Option<raw::HapticAmplitudeEnvelopeFB>,
1565 pub fb_scene: Option<raw::SceneFB>,
1566 pub fb_scene_capture: Option<raw::SceneCaptureFB>,
1567 pub fb_spatial_entity_container: Option<raw::SpatialEntityContainerFB>,
1568 pub fb_face_tracking: Option<raw::FaceTrackingFB>,
1569 pub fb_eye_tracking_social: Option<raw::EyeTrackingSocialFB>,
1570 pub fb_passthrough_keyboard_hands: Option<raw::PassthroughKeyboardHandsFB>,
1571 pub fb_composition_layer_settings: Option<raw::CompositionLayerSettingsFB>,
1572 pub fb_touch_controller_proximity: Option<raw::TouchControllerProximityFB>,
1573 pub fb_haptic_pcm: Option<raw::HapticPcmFB>,
1574 pub fb_composition_layer_depth_test: Option<raw::CompositionLayerDepthTestFB>,
1575 pub fb_spatial_entity_storage_batch: Option<raw::SpatialEntityStorageBatchFB>,
1576 pub fb_spatial_entity_user: Option<raw::SpatialEntityUserFB>,
1577 pub fb_face_tracking2: Option<raw::FaceTracking2FB>,
1578 pub htc_vive_cosmos_controller_interaction: Option<raw::ViveCosmosControllerInteractionHTC>,
1579 pub htc_facial_tracking: Option<raw::FacialTrackingHTC>,
1580 pub htc_vive_focus3_controller_interaction: Option<raw::ViveFocus3ControllerInteractionHTC>,
1581 pub htc_hand_interaction: Option<raw::HandInteractionHTC>,
1582 pub htc_vive_wrist_tracker_interaction: Option<raw::ViveWristTrackerInteractionHTC>,
1583 pub htc_passthrough: Option<raw::PassthroughHTC>,
1584 pub htc_foveation: Option<raw::FoveationHTC>,
1585 pub htc_anchor: Option<raw::AnchorHTC>,
1586 pub huawei_controller_interaction: Option<raw::ControllerInteractionHUAWEI>,
1587 #[cfg(target_os = "android")]
1588 pub khr_android_thread_settings: Option<raw::AndroidThreadSettingsKHR>,
1589 #[cfg(target_os = "android")]
1590 pub khr_android_surface_swapchain: Option<raw::AndroidSurfaceSwapchainKHR>,
1591 pub khr_composition_layer_cube: Option<raw::CompositionLayerCubeKHR>,
1592 #[cfg(target_os = "android")]
1593 pub khr_android_create_instance: Option<raw::AndroidCreateInstanceKHR>,
1594 pub khr_composition_layer_depth: Option<raw::CompositionLayerDepthKHR>,
1595 pub khr_vulkan_swapchain_format_list: Option<raw::VulkanSwapchainFormatListKHR>,
1596 pub khr_composition_layer_cylinder: Option<raw::CompositionLayerCylinderKHR>,
1597 pub khr_composition_layer_equirect: Option<raw::CompositionLayerEquirectKHR>,
1598 pub khr_opengl_enable: Option<raw::OpenglEnableKHR>,
1599 pub khr_opengl_es_enable: Option<raw::OpenglEsEnableKHR>,
1600 pub khr_vulkan_enable: Option<raw::VulkanEnableKHR>,
1601 #[cfg(windows)]
1602 pub khr_d3d11_enable: Option<raw::D3d11EnableKHR>,
1603 #[cfg(windows)]
1604 pub khr_d3d12_enable: Option<raw::D3d12EnableKHR>,
1605 pub khr_visibility_mask: Option<raw::VisibilityMaskKHR>,
1606 pub khr_composition_layer_color_scale_bias: Option<raw::CompositionLayerColorScaleBiasKHR>,
1607 #[cfg(windows)]
1608 pub khr_win32_convert_performance_counter_time:
1609 Option<raw::Win32ConvertPerformanceCounterTimeKHR>,
1610 pub khr_convert_timespec_time: Option<raw::ConvertTimespecTimeKHR>,
1611 pub khr_loader_init: Option<raw::LoaderInitKHR>,
1612 #[cfg(target_os = "android")]
1613 pub khr_loader_init_android: Option<raw::LoaderInitAndroidKHR>,
1614 pub khr_vulkan_enable2: Option<raw::VulkanEnable2KHR>,
1615 pub khr_composition_layer_equirect2: Option<raw::CompositionLayerEquirect2KHR>,
1616 pub khr_binding_modification: Option<raw::BindingModificationKHR>,
1617 pub khr_swapchain_usage_input_attachment_bit: Option<raw::SwapchainUsageInputAttachmentBitKHR>,
1618 pub khr_locate_spaces: Option<raw::LocateSpacesKHR>,
1619 pub khr_maintenance1: Option<raw::Maintenance1KHR>,
1620 pub meta_foveation_eye_tracked: Option<raw::FoveationEyeTrackedMETA>,
1621 pub meta_local_dimming: Option<raw::LocalDimmingMETA>,
1622 pub meta_passthrough_preferences: Option<raw::PassthroughPreferencesMETA>,
1623 pub meta_virtual_keyboard: Option<raw::VirtualKeyboardMETA>,
1624 pub meta_vulkan_swapchain_create_info: Option<raw::VulkanSwapchainCreateInfoMETA>,
1625 pub meta_performance_metrics: Option<raw::PerformanceMetricsMETA>,
1626 pub meta_headset_id: Option<raw::HeadsetIdMETA>,
1627 pub meta_recommended_layer_resolution: Option<raw::RecommendedLayerResolutionMETA>,
1628 pub meta_passthrough_color_lut: Option<raw::PassthroughColorLutMETA>,
1629 pub meta_spatial_entity_mesh: Option<raw::SpatialEntityMeshMETA>,
1630 pub meta_automatic_layer_filter: Option<raw::AutomaticLayerFilterMETA>,
1631 pub meta_touch_controller_plus: Option<raw::TouchControllerPlusMETA>,
1632 pub meta_environment_depth: Option<raw::EnvironmentDepthMETA>,
1633 pub ml_ml2_controller_interaction: Option<raw::Ml2ControllerInteractionML>,
1634 pub ml_frame_end_info: Option<raw::FrameEndInfoML>,
1635 pub ml_global_dimmer: Option<raw::GlobalDimmerML>,
1636 pub ml_compat: Option<raw::CompatML>,
1637 pub ml_marker_understanding: Option<raw::MarkerUnderstandingML>,
1638 pub ml_localization_map: Option<raw::LocalizationMapML>,
1639 pub ml_user_calibration: Option<raw::UserCalibrationML>,
1640 pub mnd_headless: Option<raw::HeadlessMND>,
1641 pub mnd_swapchain_usage_input_attachment_bit: Option<raw::SwapchainUsageInputAttachmentBitMND>,
1642 pub msft_unbounded_reference_space: Option<raw::UnboundedReferenceSpaceMSFT>,
1643 pub msft_spatial_anchor: Option<raw::SpatialAnchorMSFT>,
1644 pub msft_spatial_graph_bridge: Option<raw::SpatialGraphBridgeMSFT>,
1645 pub msft_hand_interaction: Option<raw::HandInteractionMSFT>,
1646 pub msft_hand_tracking_mesh: Option<raw::HandTrackingMeshMSFT>,
1647 pub msft_secondary_view_configuration: Option<raw::SecondaryViewConfigurationMSFT>,
1648 pub msft_first_person_observer: Option<raw::FirstPersonObserverMSFT>,
1649 pub msft_controller_model: Option<raw::ControllerModelMSFT>,
1650 #[cfg(windows)]
1651 pub msft_perception_anchor_interop: Option<raw::PerceptionAnchorInteropMSFT>,
1652 #[cfg(windows)]
1653 pub msft_holographic_window_attachment: Option<raw::HolographicWindowAttachmentMSFT>,
1654 pub msft_composition_layer_reprojection: Option<raw::CompositionLayerReprojectionMSFT>,
1655 pub msft_spatial_anchor_persistence: Option<raw::SpatialAnchorPersistenceMSFT>,
1656 #[cfg(target_os = "android")]
1657 pub oculus_android_session_state_enable: Option<raw::AndroidSessionStateEnableOCULUS>,
1658 pub oculus_audio_device_guid: Option<raw::AudioDeviceGuidOCULUS>,
1659 pub oculus_external_camera: Option<raw::ExternalCameraOCULUS>,
1660 pub oppo_controller_interaction: Option<raw::ControllerInteractionOPPO>,
1661 pub qcom_tracking_optimization_settings: Option<raw::TrackingOptimizationSettingsQCOM>,
1662 pub ultraleap_hand_tracking_forearm: Option<raw::HandTrackingForearmULTRALEAP>,
1663 pub valve_analog_threshold: Option<raw::AnalogThresholdVALVE>,
1664 pub varjo_quad_views: Option<raw::QuadViewsVARJO>,
1665 pub varjo_foveated_rendering: Option<raw::FoveatedRenderingVARJO>,
1666 pub varjo_composition_layer_depth_test: Option<raw::CompositionLayerDepthTestVARJO>,
1667 pub varjo_environment_depth_estimation: Option<raw::EnvironmentDepthEstimationVARJO>,
1668 pub varjo_marker_tracking: Option<raw::MarkerTrackingVARJO>,
1669 pub varjo_view_offset: Option<raw::ViewOffsetVARJO>,
1670 pub varjo_xr4_controller_interaction: Option<raw::Xr4ControllerInteractionVARJO>,
1671 pub yvr_controller_interaction: Option<raw::ControllerInteractionYVR>,
1672 pub extx_overlay: Option<raw::OverlayEXTX>,
1673 pub mndx_egl_enable: Option<raw::EglEnableMNDX>,
1674 pub mndx_force_feedback_curl: Option<raw::ForceFeedbackCurlMNDX>,
1675 pub htcx_vive_tracker_interaction: Option<raw::ViveTrackerInteractionHTCX>,
1676}
1677impl InstanceExtensions {
1678 #[doc = r" Load extension function pointer tables"]
1679 #[doc = r""]
1680 #[doc = r" # Safety"]
1681 #[doc = r""]
1682 #[doc = r" `instance` must be a valid instance handle."]
1683 pub unsafe fn load(
1684 entry: &Entry,
1685 instance: sys::Instance,
1686 required: &ExtensionSet,
1687 ) -> Result<Self> {
1688 Ok(Self {
1689 almalence_digital_lens_control: if required.almalence_digital_lens_control {
1690 Some(raw::DigitalLensControlALMALENCE::load(entry, instance)?)
1691 } else {
1692 None
1693 },
1694 bd_controller_interaction: if required.bd_controller_interaction {
1695 Some(raw::ControllerInteractionBD {})
1696 } else {
1697 None
1698 },
1699 epic_view_configuration_fov: if required.epic_view_configuration_fov {
1700 Some(raw::ViewConfigurationFovEPIC {})
1701 } else {
1702 None
1703 },
1704 ext_performance_settings: if required.ext_performance_settings {
1705 Some(raw::PerformanceSettingsEXT::load(entry, instance)?)
1706 } else {
1707 None
1708 },
1709 ext_thermal_query: if required.ext_thermal_query {
1710 Some(raw::ThermalQueryEXT::load(entry, instance)?)
1711 } else {
1712 None
1713 },
1714 ext_debug_utils: if required.ext_debug_utils {
1715 Some(raw::DebugUtilsEXT::load(entry, instance)?)
1716 } else {
1717 None
1718 },
1719 ext_eye_gaze_interaction: if required.ext_eye_gaze_interaction {
1720 Some(raw::EyeGazeInteractionEXT {})
1721 } else {
1722 None
1723 },
1724 ext_view_configuration_depth_range: if required.ext_view_configuration_depth_range {
1725 Some(raw::ViewConfigurationDepthRangeEXT {})
1726 } else {
1727 None
1728 },
1729 ext_conformance_automation: if required.ext_conformance_automation {
1730 Some(raw::ConformanceAutomationEXT::load(entry, instance)?)
1731 } else {
1732 None
1733 },
1734 ext_hand_tracking: if required.ext_hand_tracking {
1735 Some(raw::HandTrackingEXT::load(entry, instance)?)
1736 } else {
1737 None
1738 },
1739 #[cfg(windows)]
1740 ext_win32_appcontainer_compatible: if required.ext_win32_appcontainer_compatible {
1741 Some(raw::Win32AppcontainerCompatibleEXT {})
1742 } else {
1743 None
1744 },
1745 ext_dpad_binding: if required.ext_dpad_binding {
1746 Some(raw::DpadBindingEXT {})
1747 } else {
1748 None
1749 },
1750 ext_hand_joints_motion_range: if required.ext_hand_joints_motion_range {
1751 Some(raw::HandJointsMotionRangeEXT {})
1752 } else {
1753 None
1754 },
1755 ext_samsung_odyssey_controller: if required.ext_samsung_odyssey_controller {
1756 Some(raw::SamsungOdysseyControllerEXT {})
1757 } else {
1758 None
1759 },
1760 ext_hp_mixed_reality_controller: if required.ext_hp_mixed_reality_controller {
1761 Some(raw::HpMixedRealityControllerEXT {})
1762 } else {
1763 None
1764 },
1765 ext_palm_pose: if required.ext_palm_pose {
1766 Some(raw::PalmPoseEXT {})
1767 } else {
1768 None
1769 },
1770 ext_uuid: if required.ext_uuid {
1771 Some(raw::UuidEXT {})
1772 } else {
1773 None
1774 },
1775 ext_hand_interaction: if required.ext_hand_interaction {
1776 Some(raw::HandInteractionEXT {})
1777 } else {
1778 None
1779 },
1780 ext_active_action_set_priority: if required.ext_active_action_set_priority {
1781 Some(raw::ActiveActionSetPriorityEXT {})
1782 } else {
1783 None
1784 },
1785 ext_local_floor: if required.ext_local_floor {
1786 Some(raw::LocalFloorEXT {})
1787 } else {
1788 None
1789 },
1790 ext_hand_tracking_data_source: if required.ext_hand_tracking_data_source {
1791 Some(raw::HandTrackingDataSourceEXT {})
1792 } else {
1793 None
1794 },
1795 ext_plane_detection: if required.ext_plane_detection {
1796 Some(raw::PlaneDetectionEXT::load(entry, instance)?)
1797 } else {
1798 None
1799 },
1800 ext_future: if required.ext_future {
1801 Some(raw::FutureEXT::load(entry, instance)?)
1802 } else {
1803 None
1804 },
1805 ext_user_presence: if required.ext_user_presence {
1806 Some(raw::UserPresenceEXT {})
1807 } else {
1808 None
1809 },
1810 fb_composition_layer_image_layout: if required.fb_composition_layer_image_layout {
1811 Some(raw::CompositionLayerImageLayoutFB {})
1812 } else {
1813 None
1814 },
1815 fb_composition_layer_alpha_blend: if required.fb_composition_layer_alpha_blend {
1816 Some(raw::CompositionLayerAlphaBlendFB {})
1817 } else {
1818 None
1819 },
1820 #[cfg(target_os = "android")]
1821 fb_android_surface_swapchain_create: if required.fb_android_surface_swapchain_create {
1822 Some(raw::AndroidSurfaceSwapchainCreateFB {})
1823 } else {
1824 None
1825 },
1826 fb_swapchain_update_state: if required.fb_swapchain_update_state {
1827 Some(raw::SwapchainUpdateStateFB::load(entry, instance)?)
1828 } else {
1829 None
1830 },
1831 fb_composition_layer_secure_content: if required.fb_composition_layer_secure_content {
1832 Some(raw::CompositionLayerSecureContentFB {})
1833 } else {
1834 None
1835 },
1836 fb_body_tracking: if required.fb_body_tracking {
1837 Some(raw::BodyTrackingFB::load(entry, instance)?)
1838 } else {
1839 None
1840 },
1841 fb_display_refresh_rate: if required.fb_display_refresh_rate {
1842 Some(raw::DisplayRefreshRateFB::load(entry, instance)?)
1843 } else {
1844 None
1845 },
1846 fb_color_space: if required.fb_color_space {
1847 Some(raw::ColorSpaceFB::load(entry, instance)?)
1848 } else {
1849 None
1850 },
1851 fb_hand_tracking_mesh: if required.fb_hand_tracking_mesh {
1852 Some(raw::HandTrackingMeshFB::load(entry, instance)?)
1853 } else {
1854 None
1855 },
1856 fb_hand_tracking_aim: if required.fb_hand_tracking_aim {
1857 Some(raw::HandTrackingAimFB {})
1858 } else {
1859 None
1860 },
1861 fb_hand_tracking_capsules: if required.fb_hand_tracking_capsules {
1862 Some(raw::HandTrackingCapsulesFB {})
1863 } else {
1864 None
1865 },
1866 fb_spatial_entity: if required.fb_spatial_entity {
1867 Some(raw::SpatialEntityFB::load(entry, instance)?)
1868 } else {
1869 None
1870 },
1871 fb_foveation: if required.fb_foveation {
1872 Some(raw::FoveationFB::load(entry, instance)?)
1873 } else {
1874 None
1875 },
1876 fb_foveation_configuration: if required.fb_foveation_configuration {
1877 Some(raw::FoveationConfigurationFB {})
1878 } else {
1879 None
1880 },
1881 fb_keyboard_tracking: if required.fb_keyboard_tracking {
1882 Some(raw::KeyboardTrackingFB::load(entry, instance)?)
1883 } else {
1884 None
1885 },
1886 fb_triangle_mesh: if required.fb_triangle_mesh {
1887 Some(raw::TriangleMeshFB::load(entry, instance)?)
1888 } else {
1889 None
1890 },
1891 fb_passthrough: if required.fb_passthrough {
1892 Some(raw::PassthroughFB::load(entry, instance)?)
1893 } else {
1894 None
1895 },
1896 fb_render_model: if required.fb_render_model {
1897 Some(raw::RenderModelFB::load(entry, instance)?)
1898 } else {
1899 None
1900 },
1901 fb_spatial_entity_query: if required.fb_spatial_entity_query {
1902 Some(raw::SpatialEntityQueryFB::load(entry, instance)?)
1903 } else {
1904 None
1905 },
1906 fb_spatial_entity_storage: if required.fb_spatial_entity_storage {
1907 Some(raw::SpatialEntityStorageFB::load(entry, instance)?)
1908 } else {
1909 None
1910 },
1911 fb_foveation_vulkan: if required.fb_foveation_vulkan {
1912 Some(raw::FoveationVulkanFB {})
1913 } else {
1914 None
1915 },
1916 #[cfg(target_os = "android")]
1917 fb_swapchain_update_state_android_surface: if required
1918 .fb_swapchain_update_state_android_surface
1919 {
1920 Some(raw::SwapchainUpdateStateAndroidSurfaceFB {})
1921 } else {
1922 None
1923 },
1924 fb_swapchain_update_state_opengl_es: if required.fb_swapchain_update_state_opengl_es {
1925 Some(raw::SwapchainUpdateStateOpenglEsFB {})
1926 } else {
1927 None
1928 },
1929 fb_swapchain_update_state_vulkan: if required.fb_swapchain_update_state_vulkan {
1930 Some(raw::SwapchainUpdateStateVulkanFB {})
1931 } else {
1932 None
1933 },
1934 fb_touch_controller_pro: if required.fb_touch_controller_pro {
1935 Some(raw::TouchControllerProFB {})
1936 } else {
1937 None
1938 },
1939 fb_spatial_entity_sharing: if required.fb_spatial_entity_sharing {
1940 Some(raw::SpatialEntitySharingFB::load(entry, instance)?)
1941 } else {
1942 None
1943 },
1944 fb_space_warp: if required.fb_space_warp {
1945 Some(raw::SpaceWarpFB {})
1946 } else {
1947 None
1948 },
1949 fb_haptic_amplitude_envelope: if required.fb_haptic_amplitude_envelope {
1950 Some(raw::HapticAmplitudeEnvelopeFB {})
1951 } else {
1952 None
1953 },
1954 fb_scene: if required.fb_scene {
1955 Some(raw::SceneFB::load(entry, instance)?)
1956 } else {
1957 None
1958 },
1959 fb_scene_capture: if required.fb_scene_capture {
1960 Some(raw::SceneCaptureFB::load(entry, instance)?)
1961 } else {
1962 None
1963 },
1964 fb_spatial_entity_container: if required.fb_spatial_entity_container {
1965 Some(raw::SpatialEntityContainerFB::load(entry, instance)?)
1966 } else {
1967 None
1968 },
1969 fb_face_tracking: if required.fb_face_tracking {
1970 Some(raw::FaceTrackingFB::load(entry, instance)?)
1971 } else {
1972 None
1973 },
1974 fb_eye_tracking_social: if required.fb_eye_tracking_social {
1975 Some(raw::EyeTrackingSocialFB::load(entry, instance)?)
1976 } else {
1977 None
1978 },
1979 fb_passthrough_keyboard_hands: if required.fb_passthrough_keyboard_hands {
1980 Some(raw::PassthroughKeyboardHandsFB::load(entry, instance)?)
1981 } else {
1982 None
1983 },
1984 fb_composition_layer_settings: if required.fb_composition_layer_settings {
1985 Some(raw::CompositionLayerSettingsFB {})
1986 } else {
1987 None
1988 },
1989 fb_touch_controller_proximity: if required.fb_touch_controller_proximity {
1990 Some(raw::TouchControllerProximityFB {})
1991 } else {
1992 None
1993 },
1994 fb_haptic_pcm: if required.fb_haptic_pcm {
1995 Some(raw::HapticPcmFB::load(entry, instance)?)
1996 } else {
1997 None
1998 },
1999 fb_composition_layer_depth_test: if required.fb_composition_layer_depth_test {
2000 Some(raw::CompositionLayerDepthTestFB {})
2001 } else {
2002 None
2003 },
2004 fb_spatial_entity_storage_batch: if required.fb_spatial_entity_storage_batch {
2005 Some(raw::SpatialEntityStorageBatchFB::load(entry, instance)?)
2006 } else {
2007 None
2008 },
2009 fb_spatial_entity_user: if required.fb_spatial_entity_user {
2010 Some(raw::SpatialEntityUserFB::load(entry, instance)?)
2011 } else {
2012 None
2013 },
2014 fb_face_tracking2: if required.fb_face_tracking2 {
2015 Some(raw::FaceTracking2FB::load(entry, instance)?)
2016 } else {
2017 None
2018 },
2019 htc_vive_cosmos_controller_interaction: if required
2020 .htc_vive_cosmos_controller_interaction
2021 {
2022 Some(raw::ViveCosmosControllerInteractionHTC {})
2023 } else {
2024 None
2025 },
2026 htc_facial_tracking: if required.htc_facial_tracking {
2027 Some(raw::FacialTrackingHTC::load(entry, instance)?)
2028 } else {
2029 None
2030 },
2031 htc_vive_focus3_controller_interaction: if required
2032 .htc_vive_focus3_controller_interaction
2033 {
2034 Some(raw::ViveFocus3ControllerInteractionHTC {})
2035 } else {
2036 None
2037 },
2038 htc_hand_interaction: if required.htc_hand_interaction {
2039 Some(raw::HandInteractionHTC {})
2040 } else {
2041 None
2042 },
2043 htc_vive_wrist_tracker_interaction: if required.htc_vive_wrist_tracker_interaction {
2044 Some(raw::ViveWristTrackerInteractionHTC {})
2045 } else {
2046 None
2047 },
2048 htc_passthrough: if required.htc_passthrough {
2049 Some(raw::PassthroughHTC::load(entry, instance)?)
2050 } else {
2051 None
2052 },
2053 htc_foveation: if required.htc_foveation {
2054 Some(raw::FoveationHTC::load(entry, instance)?)
2055 } else {
2056 None
2057 },
2058 htc_anchor: if required.htc_anchor {
2059 Some(raw::AnchorHTC::load(entry, instance)?)
2060 } else {
2061 None
2062 },
2063 huawei_controller_interaction: if required.huawei_controller_interaction {
2064 Some(raw::ControllerInteractionHUAWEI {})
2065 } else {
2066 None
2067 },
2068 #[cfg(target_os = "android")]
2069 khr_android_thread_settings: if required.khr_android_thread_settings {
2070 Some(raw::AndroidThreadSettingsKHR::load(entry, instance)?)
2071 } else {
2072 None
2073 },
2074 #[cfg(target_os = "android")]
2075 khr_android_surface_swapchain: if required.khr_android_surface_swapchain {
2076 Some(raw::AndroidSurfaceSwapchainKHR::load(entry, instance)?)
2077 } else {
2078 None
2079 },
2080 khr_composition_layer_cube: if required.khr_composition_layer_cube {
2081 Some(raw::CompositionLayerCubeKHR {})
2082 } else {
2083 None
2084 },
2085 #[cfg(target_os = "android")]
2086 khr_android_create_instance: if required.khr_android_create_instance {
2087 Some(raw::AndroidCreateInstanceKHR {})
2088 } else {
2089 None
2090 },
2091 khr_composition_layer_depth: if required.khr_composition_layer_depth {
2092 Some(raw::CompositionLayerDepthKHR {})
2093 } else {
2094 None
2095 },
2096 khr_vulkan_swapchain_format_list: if required.khr_vulkan_swapchain_format_list {
2097 Some(raw::VulkanSwapchainFormatListKHR {})
2098 } else {
2099 None
2100 },
2101 khr_composition_layer_cylinder: if required.khr_composition_layer_cylinder {
2102 Some(raw::CompositionLayerCylinderKHR {})
2103 } else {
2104 None
2105 },
2106 khr_composition_layer_equirect: if required.khr_composition_layer_equirect {
2107 Some(raw::CompositionLayerEquirectKHR {})
2108 } else {
2109 None
2110 },
2111 khr_opengl_enable: if required.khr_opengl_enable {
2112 Some(raw::OpenglEnableKHR::load(entry, instance)?)
2113 } else {
2114 None
2115 },
2116 khr_opengl_es_enable: if required.khr_opengl_es_enable {
2117 Some(raw::OpenglEsEnableKHR::load(entry, instance)?)
2118 } else {
2119 None
2120 },
2121 khr_vulkan_enable: if required.khr_vulkan_enable {
2122 Some(raw::VulkanEnableKHR::load(entry, instance)?)
2123 } else {
2124 None
2125 },
2126 #[cfg(windows)]
2127 khr_d3d11_enable: if required.khr_d3d11_enable {
2128 Some(raw::D3d11EnableKHR::load(entry, instance)?)
2129 } else {
2130 None
2131 },
2132 #[cfg(windows)]
2133 khr_d3d12_enable: if required.khr_d3d12_enable {
2134 Some(raw::D3d12EnableKHR::load(entry, instance)?)
2135 } else {
2136 None
2137 },
2138 khr_visibility_mask: if required.khr_visibility_mask {
2139 Some(raw::VisibilityMaskKHR::load(entry, instance)?)
2140 } else {
2141 None
2142 },
2143 khr_composition_layer_color_scale_bias: if required
2144 .khr_composition_layer_color_scale_bias
2145 {
2146 Some(raw::CompositionLayerColorScaleBiasKHR {})
2147 } else {
2148 None
2149 },
2150 #[cfg(windows)]
2151 khr_win32_convert_performance_counter_time: if required
2152 .khr_win32_convert_performance_counter_time
2153 {
2154 Some(raw::Win32ConvertPerformanceCounterTimeKHR::load(
2155 entry, instance,
2156 )?)
2157 } else {
2158 None
2159 },
2160 khr_convert_timespec_time: if required.khr_convert_timespec_time {
2161 Some(raw::ConvertTimespecTimeKHR::load(entry, instance)?)
2162 } else {
2163 None
2164 },
2165 khr_loader_init: if required.khr_loader_init {
2166 Some(raw::LoaderInitKHR::load(entry, instance)?)
2167 } else {
2168 None
2169 },
2170 #[cfg(target_os = "android")]
2171 khr_loader_init_android: if required.khr_loader_init_android {
2172 Some(raw::LoaderInitAndroidKHR {})
2173 } else {
2174 None
2175 },
2176 khr_vulkan_enable2: if required.khr_vulkan_enable2 {
2177 Some(raw::VulkanEnable2KHR::load(entry, instance)?)
2178 } else {
2179 None
2180 },
2181 khr_composition_layer_equirect2: if required.khr_composition_layer_equirect2 {
2182 Some(raw::CompositionLayerEquirect2KHR {})
2183 } else {
2184 None
2185 },
2186 khr_binding_modification: if required.khr_binding_modification {
2187 Some(raw::BindingModificationKHR {})
2188 } else {
2189 None
2190 },
2191 khr_swapchain_usage_input_attachment_bit: if required
2192 .khr_swapchain_usage_input_attachment_bit
2193 {
2194 Some(raw::SwapchainUsageInputAttachmentBitKHR {})
2195 } else {
2196 None
2197 },
2198 khr_locate_spaces: if required.khr_locate_spaces {
2199 Some(raw::LocateSpacesKHR::load(entry, instance)?)
2200 } else {
2201 None
2202 },
2203 khr_maintenance1: if required.khr_maintenance1 {
2204 Some(raw::Maintenance1KHR {})
2205 } else {
2206 None
2207 },
2208 meta_foveation_eye_tracked: if required.meta_foveation_eye_tracked {
2209 Some(raw::FoveationEyeTrackedMETA::load(entry, instance)?)
2210 } else {
2211 None
2212 },
2213 meta_local_dimming: if required.meta_local_dimming {
2214 Some(raw::LocalDimmingMETA {})
2215 } else {
2216 None
2217 },
2218 meta_passthrough_preferences: if required.meta_passthrough_preferences {
2219 Some(raw::PassthroughPreferencesMETA::load(entry, instance)?)
2220 } else {
2221 None
2222 },
2223 meta_virtual_keyboard: if required.meta_virtual_keyboard {
2224 Some(raw::VirtualKeyboardMETA::load(entry, instance)?)
2225 } else {
2226 None
2227 },
2228 meta_vulkan_swapchain_create_info: if required.meta_vulkan_swapchain_create_info {
2229 Some(raw::VulkanSwapchainCreateInfoMETA {})
2230 } else {
2231 None
2232 },
2233 meta_performance_metrics: if required.meta_performance_metrics {
2234 Some(raw::PerformanceMetricsMETA::load(entry, instance)?)
2235 } else {
2236 None
2237 },
2238 meta_headset_id: if required.meta_headset_id {
2239 Some(raw::HeadsetIdMETA {})
2240 } else {
2241 None
2242 },
2243 meta_recommended_layer_resolution: if required.meta_recommended_layer_resolution {
2244 Some(raw::RecommendedLayerResolutionMETA::load(entry, instance)?)
2245 } else {
2246 None
2247 },
2248 meta_passthrough_color_lut: if required.meta_passthrough_color_lut {
2249 Some(raw::PassthroughColorLutMETA::load(entry, instance)?)
2250 } else {
2251 None
2252 },
2253 meta_spatial_entity_mesh: if required.meta_spatial_entity_mesh {
2254 Some(raw::SpatialEntityMeshMETA::load(entry, instance)?)
2255 } else {
2256 None
2257 },
2258 meta_automatic_layer_filter: if required.meta_automatic_layer_filter {
2259 Some(raw::AutomaticLayerFilterMETA {})
2260 } else {
2261 None
2262 },
2263 meta_touch_controller_plus: if required.meta_touch_controller_plus {
2264 Some(raw::TouchControllerPlusMETA {})
2265 } else {
2266 None
2267 },
2268 meta_environment_depth: if required.meta_environment_depth {
2269 Some(raw::EnvironmentDepthMETA::load(entry, instance)?)
2270 } else {
2271 None
2272 },
2273 ml_ml2_controller_interaction: if required.ml_ml2_controller_interaction {
2274 Some(raw::Ml2ControllerInteractionML {})
2275 } else {
2276 None
2277 },
2278 ml_frame_end_info: if required.ml_frame_end_info {
2279 Some(raw::FrameEndInfoML {})
2280 } else {
2281 None
2282 },
2283 ml_global_dimmer: if required.ml_global_dimmer {
2284 Some(raw::GlobalDimmerML {})
2285 } else {
2286 None
2287 },
2288 ml_compat: if required.ml_compat {
2289 Some(raw::CompatML::load(entry, instance)?)
2290 } else {
2291 None
2292 },
2293 ml_marker_understanding: if required.ml_marker_understanding {
2294 Some(raw::MarkerUnderstandingML::load(entry, instance)?)
2295 } else {
2296 None
2297 },
2298 ml_localization_map: if required.ml_localization_map {
2299 Some(raw::LocalizationMapML::load(entry, instance)?)
2300 } else {
2301 None
2302 },
2303 ml_user_calibration: if required.ml_user_calibration {
2304 Some(raw::UserCalibrationML::load(entry, instance)?)
2305 } else {
2306 None
2307 },
2308 mnd_headless: if required.mnd_headless {
2309 Some(raw::HeadlessMND {})
2310 } else {
2311 None
2312 },
2313 mnd_swapchain_usage_input_attachment_bit: if required
2314 .mnd_swapchain_usage_input_attachment_bit
2315 {
2316 Some(raw::SwapchainUsageInputAttachmentBitMND {})
2317 } else {
2318 None
2319 },
2320 msft_unbounded_reference_space: if required.msft_unbounded_reference_space {
2321 Some(raw::UnboundedReferenceSpaceMSFT {})
2322 } else {
2323 None
2324 },
2325 msft_spatial_anchor: if required.msft_spatial_anchor {
2326 Some(raw::SpatialAnchorMSFT::load(entry, instance)?)
2327 } else {
2328 None
2329 },
2330 msft_spatial_graph_bridge: if required.msft_spatial_graph_bridge {
2331 Some(raw::SpatialGraphBridgeMSFT::load(entry, instance)?)
2332 } else {
2333 None
2334 },
2335 msft_hand_interaction: if required.msft_hand_interaction {
2336 Some(raw::HandInteractionMSFT {})
2337 } else {
2338 None
2339 },
2340 msft_hand_tracking_mesh: if required.msft_hand_tracking_mesh {
2341 Some(raw::HandTrackingMeshMSFT::load(entry, instance)?)
2342 } else {
2343 None
2344 },
2345 msft_secondary_view_configuration: if required.msft_secondary_view_configuration {
2346 Some(raw::SecondaryViewConfigurationMSFT {})
2347 } else {
2348 None
2349 },
2350 msft_first_person_observer: if required.msft_first_person_observer {
2351 Some(raw::FirstPersonObserverMSFT {})
2352 } else {
2353 None
2354 },
2355 msft_controller_model: if required.msft_controller_model {
2356 Some(raw::ControllerModelMSFT::load(entry, instance)?)
2357 } else {
2358 None
2359 },
2360 #[cfg(windows)]
2361 msft_perception_anchor_interop: if required.msft_perception_anchor_interop {
2362 Some(raw::PerceptionAnchorInteropMSFT::load(entry, instance)?)
2363 } else {
2364 None
2365 },
2366 #[cfg(windows)]
2367 msft_holographic_window_attachment: if required.msft_holographic_window_attachment {
2368 Some(raw::HolographicWindowAttachmentMSFT {})
2369 } else {
2370 None
2371 },
2372 msft_composition_layer_reprojection: if required.msft_composition_layer_reprojection {
2373 Some(raw::CompositionLayerReprojectionMSFT::load(
2374 entry, instance,
2375 )?)
2376 } else {
2377 None
2378 },
2379 msft_spatial_anchor_persistence: if required.msft_spatial_anchor_persistence {
2380 Some(raw::SpatialAnchorPersistenceMSFT::load(entry, instance)?)
2381 } else {
2382 None
2383 },
2384 #[cfg(target_os = "android")]
2385 oculus_android_session_state_enable: if required.oculus_android_session_state_enable {
2386 Some(raw::AndroidSessionStateEnableOCULUS {})
2387 } else {
2388 None
2389 },
2390 oculus_audio_device_guid: if required.oculus_audio_device_guid {
2391 Some(raw::AudioDeviceGuidOCULUS::load(entry, instance)?)
2392 } else {
2393 None
2394 },
2395 oculus_external_camera: if required.oculus_external_camera {
2396 Some(raw::ExternalCameraOCULUS::load(entry, instance)?)
2397 } else {
2398 None
2399 },
2400 oppo_controller_interaction: if required.oppo_controller_interaction {
2401 Some(raw::ControllerInteractionOPPO {})
2402 } else {
2403 None
2404 },
2405 qcom_tracking_optimization_settings: if required.qcom_tracking_optimization_settings {
2406 Some(raw::TrackingOptimizationSettingsQCOM::load(
2407 entry, instance,
2408 )?)
2409 } else {
2410 None
2411 },
2412 ultraleap_hand_tracking_forearm: if required.ultraleap_hand_tracking_forearm {
2413 Some(raw::HandTrackingForearmULTRALEAP {})
2414 } else {
2415 None
2416 },
2417 valve_analog_threshold: if required.valve_analog_threshold {
2418 Some(raw::AnalogThresholdVALVE {})
2419 } else {
2420 None
2421 },
2422 varjo_quad_views: if required.varjo_quad_views {
2423 Some(raw::QuadViewsVARJO {})
2424 } else {
2425 None
2426 },
2427 varjo_foveated_rendering: if required.varjo_foveated_rendering {
2428 Some(raw::FoveatedRenderingVARJO {})
2429 } else {
2430 None
2431 },
2432 varjo_composition_layer_depth_test: if required.varjo_composition_layer_depth_test {
2433 Some(raw::CompositionLayerDepthTestVARJO {})
2434 } else {
2435 None
2436 },
2437 varjo_environment_depth_estimation: if required.varjo_environment_depth_estimation {
2438 Some(raw::EnvironmentDepthEstimationVARJO::load(entry, instance)?)
2439 } else {
2440 None
2441 },
2442 varjo_marker_tracking: if required.varjo_marker_tracking {
2443 Some(raw::MarkerTrackingVARJO::load(entry, instance)?)
2444 } else {
2445 None
2446 },
2447 varjo_view_offset: if required.varjo_view_offset {
2448 Some(raw::ViewOffsetVARJO::load(entry, instance)?)
2449 } else {
2450 None
2451 },
2452 varjo_xr4_controller_interaction: if required.varjo_xr4_controller_interaction {
2453 Some(raw::Xr4ControllerInteractionVARJO {})
2454 } else {
2455 None
2456 },
2457 yvr_controller_interaction: if required.yvr_controller_interaction {
2458 Some(raw::ControllerInteractionYVR {})
2459 } else {
2460 None
2461 },
2462 extx_overlay: if required.extx_overlay {
2463 Some(raw::OverlayEXTX {})
2464 } else {
2465 None
2466 },
2467 mndx_egl_enable: if required.mndx_egl_enable {
2468 Some(raw::EglEnableMNDX {})
2469 } else {
2470 None
2471 },
2472 mndx_force_feedback_curl: if required.mndx_force_feedback_curl {
2473 Some(raw::ForceFeedbackCurlMNDX::load(entry, instance)?)
2474 } else {
2475 None
2476 },
2477 htcx_vive_tracker_interaction: if required.htcx_vive_tracker_interaction {
2478 Some(raw::ViveTrackerInteractionHTCX::load(entry, instance)?)
2479 } else {
2480 None
2481 },
2482 })
2483 }
2484}
2485#[derive(Copy, Clone)]
2486#[non_exhaustive]
2487pub enum Event<'a> {
2488 EventsLost(EventsLost<'a>),
2489 InstanceLossPending(InstanceLossPending<'a>),
2490 SessionStateChanged(SessionStateChanged<'a>),
2491 ReferenceSpaceChangePending(ReferenceSpaceChangePending<'a>),
2492 PerfSettingsEXT(PerfSettingsEXT<'a>),
2493 VisibilityMaskChangedKHR(VisibilityMaskChangedKHR<'a>),
2494 InteractionProfileChanged(InteractionProfileChanged<'a>),
2495 MainSessionVisibilityChangedEXTX(MainSessionVisibilityChangedEXTX<'a>),
2496 DisplayRefreshRateChangedFB(DisplayRefreshRateChangedFB<'a>),
2497 SpatialAnchorCreateCompleteFB(SpatialAnchorCreateCompleteFB<'a>),
2498 SpaceSetStatusCompleteFB(SpaceSetStatusCompleteFB<'a>),
2499 SpaceQueryResultsAvailableFB(SpaceQueryResultsAvailableFB<'a>),
2500 SpaceQueryCompleteFB(SpaceQueryCompleteFB<'a>),
2501 SpaceSaveCompleteFB(SpaceSaveCompleteFB<'a>),
2502 SpaceEraseCompleteFB(SpaceEraseCompleteFB<'a>),
2503 SpaceShareCompleteFB(SpaceShareCompleteFB<'a>),
2504 SpaceListSaveCompleteFB(SpaceListSaveCompleteFB<'a>),
2505 SceneCaptureCompleteFB(SceneCaptureCompleteFB<'a>),
2506 PassthroughStateChangedFB(PassthroughStateChangedFB<'a>),
2507 ViveTrackerConnectedHTCX(ViveTrackerConnectedHTCX<'a>),
2508 MarkerTrackingUpdateVARJO(MarkerTrackingUpdateVARJO<'a>),
2509 VirtualKeyboardCommitTextMETA(VirtualKeyboardCommitTextMETA<'a>),
2510 VirtualKeyboardBackspaceMETA(VirtualKeyboardBackspaceMETA<'a>),
2511 VirtualKeyboardEnterMETA(VirtualKeyboardEnterMETA<'a>),
2512 VirtualKeyboardShownMETA(VirtualKeyboardShownMETA<'a>),
2513 VirtualKeyboardHiddenMETA(VirtualKeyboardHiddenMETA<'a>),
2514 HeadsetFitChangedML(HeadsetFitChangedML<'a>),
2515 EyeCalibrationChangedML(EyeCalibrationChangedML<'a>),
2516 LocalizationChangedML(LocalizationChangedML<'a>),
2517 UserPresenceChangedEXT(UserPresenceChangedEXT<'a>),
2518}
2519impl<'a> Event<'a> {
2520 #[doc = r" Decode an event"]
2521 #[doc = r""]
2522 #[doc = r" Returns `None` if the event type is not recognized, e.g. if it's from an unknown extension"]
2523 #[doc = r""]
2524 #[doc = r" # Safety"]
2525 #[doc = r""]
2526 #[doc = r" `raw` must refer to an `EventDataBuffer` populated by a successful call to"]
2527 #[doc = r" `xrPollEvent`, which has not been moved since."]
2528 pub unsafe fn from_raw(raw: &'a MaybeUninit<sys::EventDataBuffer>) -> Option<Self> {
2529 let raw = raw.as_ptr();
2530 Some(match (raw as *const sys::BaseInStructure).read().ty {
2531 sys::StructureType::EVENT_DATA_EVENTS_LOST => {
2532 let typed = &*(raw as *const sys::EventDataEventsLost);
2533 Event::EventsLost(EventsLost::new(typed))
2534 }
2535 sys::StructureType::EVENT_DATA_INSTANCE_LOSS_PENDING => {
2536 let typed = &*(raw as *const sys::EventDataInstanceLossPending);
2537 Event::InstanceLossPending(InstanceLossPending::new(typed))
2538 }
2539 sys::StructureType::EVENT_DATA_SESSION_STATE_CHANGED => {
2540 let typed = &*(raw as *const sys::EventDataSessionStateChanged);
2541 Event::SessionStateChanged(SessionStateChanged::new(typed))
2542 }
2543 sys::StructureType::EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING => {
2544 let typed = &*(raw as *const sys::EventDataReferenceSpaceChangePending);
2545 Event::ReferenceSpaceChangePending(ReferenceSpaceChangePending::new(typed))
2546 }
2547 sys::StructureType::EVENT_DATA_PERF_SETTINGS_EXT => {
2548 let typed = &*(raw as *const sys::EventDataPerfSettingsEXT);
2549 Event::PerfSettingsEXT(PerfSettingsEXT::new(typed))
2550 }
2551 sys::StructureType::EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR => {
2552 let typed = &*(raw as *const sys::EventDataVisibilityMaskChangedKHR);
2553 Event::VisibilityMaskChangedKHR(VisibilityMaskChangedKHR::new(typed))
2554 }
2555 sys::StructureType::EVENT_DATA_INTERACTION_PROFILE_CHANGED => {
2556 let typed = &*(raw as *const sys::EventDataInteractionProfileChanged);
2557 Event::InteractionProfileChanged(InteractionProfileChanged::new(typed))
2558 }
2559 sys::StructureType::EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX => {
2560 let typed = &*(raw as *const sys::EventDataMainSessionVisibilityChangedEXTX);
2561 Event::MainSessionVisibilityChangedEXTX(MainSessionVisibilityChangedEXTX::new(
2562 typed,
2563 ))
2564 }
2565 sys::StructureType::EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB => {
2566 let typed = &*(raw as *const sys::EventDataDisplayRefreshRateChangedFB);
2567 Event::DisplayRefreshRateChangedFB(DisplayRefreshRateChangedFB::new(typed))
2568 }
2569 sys::StructureType::EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB => {
2570 let typed = &*(raw as *const sys::EventDataSpatialAnchorCreateCompleteFB);
2571 Event::SpatialAnchorCreateCompleteFB(SpatialAnchorCreateCompleteFB::new(typed))
2572 }
2573 sys::StructureType::EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB => {
2574 let typed = &*(raw as *const sys::EventDataSpaceSetStatusCompleteFB);
2575 Event::SpaceSetStatusCompleteFB(SpaceSetStatusCompleteFB::new(typed))
2576 }
2577 sys::StructureType::EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB => {
2578 let typed = &*(raw as *const sys::EventDataSpaceQueryResultsAvailableFB);
2579 Event::SpaceQueryResultsAvailableFB(SpaceQueryResultsAvailableFB::new(typed))
2580 }
2581 sys::StructureType::EVENT_DATA_SPACE_QUERY_COMPLETE_FB => {
2582 let typed = &*(raw as *const sys::EventDataSpaceQueryCompleteFB);
2583 Event::SpaceQueryCompleteFB(SpaceQueryCompleteFB::new(typed))
2584 }
2585 sys::StructureType::EVENT_DATA_SPACE_SAVE_COMPLETE_FB => {
2586 let typed = &*(raw as *const sys::EventDataSpaceSaveCompleteFB);
2587 Event::SpaceSaveCompleteFB(SpaceSaveCompleteFB::new(typed))
2588 }
2589 sys::StructureType::EVENT_DATA_SPACE_ERASE_COMPLETE_FB => {
2590 let typed = &*(raw as *const sys::EventDataSpaceEraseCompleteFB);
2591 Event::SpaceEraseCompleteFB(SpaceEraseCompleteFB::new(typed))
2592 }
2593 sys::StructureType::EVENT_DATA_SPACE_SHARE_COMPLETE_FB => {
2594 let typed = &*(raw as *const sys::EventDataSpaceShareCompleteFB);
2595 Event::SpaceShareCompleteFB(SpaceShareCompleteFB::new(typed))
2596 }
2597 sys::StructureType::EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB => {
2598 let typed = &*(raw as *const sys::EventDataSpaceListSaveCompleteFB);
2599 Event::SpaceListSaveCompleteFB(SpaceListSaveCompleteFB::new(typed))
2600 }
2601 sys::StructureType::EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB => {
2602 let typed = &*(raw as *const sys::EventDataSceneCaptureCompleteFB);
2603 Event::SceneCaptureCompleteFB(SceneCaptureCompleteFB::new(typed))
2604 }
2605 sys::StructureType::EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB => {
2606 let typed = &*(raw as *const sys::EventDataPassthroughStateChangedFB);
2607 Event::PassthroughStateChangedFB(PassthroughStateChangedFB::new(typed))
2608 }
2609 sys::StructureType::EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX => {
2610 let typed = &*(raw as *const sys::EventDataViveTrackerConnectedHTCX);
2611 Event::ViveTrackerConnectedHTCX(ViveTrackerConnectedHTCX::new(typed))
2612 }
2613 sys::StructureType::EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO => {
2614 let typed = &*(raw as *const sys::EventDataMarkerTrackingUpdateVARJO);
2615 Event::MarkerTrackingUpdateVARJO(MarkerTrackingUpdateVARJO::new(typed))
2616 }
2617 sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META => {
2618 let typed = &*(raw as *const sys::EventDataVirtualKeyboardCommitTextMETA);
2619 Event::VirtualKeyboardCommitTextMETA(VirtualKeyboardCommitTextMETA::new(typed))
2620 }
2621 sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META => {
2622 let typed = &*(raw as *const sys::EventDataVirtualKeyboardBackspaceMETA);
2623 Event::VirtualKeyboardBackspaceMETA(VirtualKeyboardBackspaceMETA::new(typed))
2624 }
2625 sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META => {
2626 let typed = &*(raw as *const sys::EventDataVirtualKeyboardEnterMETA);
2627 Event::VirtualKeyboardEnterMETA(VirtualKeyboardEnterMETA::new(typed))
2628 }
2629 sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META => {
2630 let typed = &*(raw as *const sys::EventDataVirtualKeyboardShownMETA);
2631 Event::VirtualKeyboardShownMETA(VirtualKeyboardShownMETA::new(typed))
2632 }
2633 sys::StructureType::EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META => {
2634 let typed = &*(raw as *const sys::EventDataVirtualKeyboardHiddenMETA);
2635 Event::VirtualKeyboardHiddenMETA(VirtualKeyboardHiddenMETA::new(typed))
2636 }
2637 sys::StructureType::EVENT_DATA_HEADSET_FIT_CHANGED_ML => {
2638 let typed = &*(raw as *const sys::EventDataHeadsetFitChangedML);
2639 Event::HeadsetFitChangedML(HeadsetFitChangedML::new(typed))
2640 }
2641 sys::StructureType::EVENT_DATA_EYE_CALIBRATION_CHANGED_ML => {
2642 let typed = &*(raw as *const sys::EventDataEyeCalibrationChangedML);
2643 Event::EyeCalibrationChangedML(EyeCalibrationChangedML::new(typed))
2644 }
2645 sys::StructureType::EVENT_DATA_LOCALIZATION_CHANGED_ML => {
2646 let typed = &*(raw as *const sys::EventDataLocalizationChangedML);
2647 Event::LocalizationChangedML(LocalizationChangedML::new(typed))
2648 }
2649 sys::StructureType::EVENT_DATA_USER_PRESENCE_CHANGED_EXT => {
2650 let typed = &*(raw as *const sys::EventDataUserPresenceChangedEXT);
2651 Event::UserPresenceChangedEXT(UserPresenceChangedEXT::new(typed))
2652 }
2653 _ => {
2654 return None;
2655 }
2656 })
2657 }
2658}
2659#[derive(Copy, Clone)]
2660pub struct EventsLost<'a>(&'a sys::EventDataEventsLost);
2661impl<'a> EventsLost<'a> {
2662 #[inline]
2663 #[doc = r" # Safety"]
2664 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2665 #[doc = "[sys::EventDataEventsLost]"]
2666 #[doc = r" for more information."]
2667 pub unsafe fn new(inner: &'a sys::EventDataEventsLost) -> Self {
2668 Self(inner)
2669 }
2670 #[inline]
2671 pub fn lost_event_count(self) -> u32 {
2672 (self.0).lost_event_count
2673 }
2674}
2675#[derive(Copy, Clone)]
2676pub struct InstanceLossPending<'a>(&'a sys::EventDataInstanceLossPending);
2677impl<'a> InstanceLossPending<'a> {
2678 #[inline]
2679 #[doc = r" # Safety"]
2680 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2681 #[doc = "[sys::EventDataInstanceLossPending]"]
2682 #[doc = r" for more information."]
2683 pub unsafe fn new(inner: &'a sys::EventDataInstanceLossPending) -> Self {
2684 Self(inner)
2685 }
2686 #[inline]
2687 pub fn loss_time(self) -> Time {
2688 (self.0).loss_time
2689 }
2690}
2691#[derive(Copy, Clone)]
2692pub struct SessionStateChanged<'a>(&'a sys::EventDataSessionStateChanged);
2693impl<'a> SessionStateChanged<'a> {
2694 #[inline]
2695 #[doc = r" # Safety"]
2696 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2697 #[doc = "[sys::EventDataSessionStateChanged]"]
2698 #[doc = r" for more information."]
2699 pub unsafe fn new(inner: &'a sys::EventDataSessionStateChanged) -> Self {
2700 Self(inner)
2701 }
2702 #[inline]
2703 pub fn session(self) -> sys::Session {
2704 (self.0).session
2705 }
2706 #[inline]
2707 pub fn state(self) -> SessionState {
2708 (self.0).state
2709 }
2710 #[inline]
2711 pub fn time(self) -> Time {
2712 (self.0).time
2713 }
2714}
2715#[derive(Copy, Clone)]
2716pub struct ReferenceSpaceChangePending<'a>(&'a sys::EventDataReferenceSpaceChangePending);
2717impl<'a> ReferenceSpaceChangePending<'a> {
2718 #[inline]
2719 #[doc = r" # Safety"]
2720 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2721 #[doc = "[sys::EventDataReferenceSpaceChangePending]"]
2722 #[doc = r" for more information."]
2723 pub unsafe fn new(inner: &'a sys::EventDataReferenceSpaceChangePending) -> Self {
2724 Self(inner)
2725 }
2726 #[inline]
2727 pub fn session(self) -> sys::Session {
2728 (self.0).session
2729 }
2730 #[inline]
2731 pub fn reference_space_type(self) -> ReferenceSpaceType {
2732 (self.0).reference_space_type
2733 }
2734 #[inline]
2735 pub fn change_time(self) -> Time {
2736 (self.0).change_time
2737 }
2738 #[inline]
2739 pub fn pose_valid(self) -> bool {
2740 (self.0).pose_valid.into()
2741 }
2742 #[inline]
2743 pub fn pose_in_previous_space(self) -> Posef {
2744 (self.0).pose_in_previous_space
2745 }
2746}
2747#[derive(Copy, Clone)]
2748pub struct PerfSettingsEXT<'a>(&'a sys::EventDataPerfSettingsEXT);
2749impl<'a> PerfSettingsEXT<'a> {
2750 #[inline]
2751 #[doc = r" # Safety"]
2752 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2753 #[doc = "[sys::EventDataPerfSettingsEXT]"]
2754 #[doc = r" for more information."]
2755 pub unsafe fn new(inner: &'a sys::EventDataPerfSettingsEXT) -> Self {
2756 Self(inner)
2757 }
2758 #[inline]
2759 pub fn domain(self) -> PerfSettingsDomainEXT {
2760 (self.0).domain
2761 }
2762 #[inline]
2763 pub fn sub_domain(self) -> PerfSettingsSubDomainEXT {
2764 (self.0).sub_domain
2765 }
2766 #[inline]
2767 pub fn from_level(self) -> PerfSettingsNotificationLevelEXT {
2768 (self.0).from_level
2769 }
2770 #[inline]
2771 pub fn to_level(self) -> PerfSettingsNotificationLevelEXT {
2772 (self.0).to_level
2773 }
2774}
2775#[derive(Copy, Clone)]
2776pub struct VisibilityMaskChangedKHR<'a>(&'a sys::EventDataVisibilityMaskChangedKHR);
2777impl<'a> VisibilityMaskChangedKHR<'a> {
2778 #[inline]
2779 #[doc = r" # Safety"]
2780 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2781 #[doc = "[sys::EventDataVisibilityMaskChangedKHR]"]
2782 #[doc = r" for more information."]
2783 pub unsafe fn new(inner: &'a sys::EventDataVisibilityMaskChangedKHR) -> Self {
2784 Self(inner)
2785 }
2786 #[inline]
2787 pub fn session(self) -> sys::Session {
2788 (self.0).session
2789 }
2790 #[inline]
2791 pub fn view_configuration_type(self) -> ViewConfigurationType {
2792 (self.0).view_configuration_type
2793 }
2794 #[inline]
2795 pub fn view_index(self) -> u32 {
2796 (self.0).view_index
2797 }
2798}
2799#[derive(Copy, Clone)]
2800pub struct InteractionProfileChanged<'a>(&'a sys::EventDataInteractionProfileChanged);
2801impl<'a> InteractionProfileChanged<'a> {
2802 #[inline]
2803 #[doc = r" # Safety"]
2804 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2805 #[doc = "[sys::EventDataInteractionProfileChanged]"]
2806 #[doc = r" for more information."]
2807 pub unsafe fn new(inner: &'a sys::EventDataInteractionProfileChanged) -> Self {
2808 Self(inner)
2809 }
2810 #[inline]
2811 pub fn session(self) -> sys::Session {
2812 (self.0).session
2813 }
2814}
2815#[derive(Copy, Clone)]
2816pub struct MainSessionVisibilityChangedEXTX<'a>(&'a sys::EventDataMainSessionVisibilityChangedEXTX);
2817impl<'a> MainSessionVisibilityChangedEXTX<'a> {
2818 #[inline]
2819 #[doc = r" # Safety"]
2820 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2821 #[doc = "[sys::EventDataMainSessionVisibilityChangedEXTX]"]
2822 #[doc = r" for more information."]
2823 pub unsafe fn new(inner: &'a sys::EventDataMainSessionVisibilityChangedEXTX) -> Self {
2824 Self(inner)
2825 }
2826 #[inline]
2827 pub fn visible(self) -> bool {
2828 (self.0).visible.into()
2829 }
2830 #[inline]
2831 pub fn flags(self) -> OverlayMainSessionFlagsEXTX {
2832 (self.0).flags
2833 }
2834}
2835#[derive(Copy, Clone)]
2836pub struct DisplayRefreshRateChangedFB<'a>(&'a sys::EventDataDisplayRefreshRateChangedFB);
2837impl<'a> DisplayRefreshRateChangedFB<'a> {
2838 #[inline]
2839 #[doc = r" # Safety"]
2840 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2841 #[doc = "[sys::EventDataDisplayRefreshRateChangedFB]"]
2842 #[doc = r" for more information."]
2843 pub unsafe fn new(inner: &'a sys::EventDataDisplayRefreshRateChangedFB) -> Self {
2844 Self(inner)
2845 }
2846 #[inline]
2847 pub fn from_display_refresh_rate(self) -> f32 {
2848 (self.0).from_display_refresh_rate
2849 }
2850 #[inline]
2851 pub fn to_display_refresh_rate(self) -> f32 {
2852 (self.0).to_display_refresh_rate
2853 }
2854}
2855#[derive(Copy, Clone)]
2856pub struct SpatialAnchorCreateCompleteFB<'a>(&'a sys::EventDataSpatialAnchorCreateCompleteFB);
2857impl<'a> SpatialAnchorCreateCompleteFB<'a> {
2858 #[inline]
2859 #[doc = r" # Safety"]
2860 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2861 #[doc = "[sys::EventDataSpatialAnchorCreateCompleteFB]"]
2862 #[doc = r" for more information."]
2863 pub unsafe fn new(inner: &'a sys::EventDataSpatialAnchorCreateCompleteFB) -> Self {
2864 Self(inner)
2865 }
2866 #[inline]
2867 pub fn request_id(self) -> AsyncRequestIdFB {
2868 (self.0).request_id
2869 }
2870 #[inline]
2871 pub fn result(self) -> sys::Result {
2872 (self.0).result
2873 }
2874 #[inline]
2875 pub fn space(self) -> sys::Space {
2876 (self.0).space
2877 }
2878 #[inline]
2879 pub fn uuid(self) -> UuidEXT {
2880 (self.0).uuid
2881 }
2882}
2883#[derive(Copy, Clone)]
2884pub struct SpaceSetStatusCompleteFB<'a>(&'a sys::EventDataSpaceSetStatusCompleteFB);
2885impl<'a> SpaceSetStatusCompleteFB<'a> {
2886 #[inline]
2887 #[doc = r" # Safety"]
2888 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2889 #[doc = "[sys::EventDataSpaceSetStatusCompleteFB]"]
2890 #[doc = r" for more information."]
2891 pub unsafe fn new(inner: &'a sys::EventDataSpaceSetStatusCompleteFB) -> Self {
2892 Self(inner)
2893 }
2894 #[inline]
2895 pub fn request_id(self) -> AsyncRequestIdFB {
2896 (self.0).request_id
2897 }
2898 #[inline]
2899 pub fn result(self) -> sys::Result {
2900 (self.0).result
2901 }
2902 #[inline]
2903 pub fn space(self) -> sys::Space {
2904 (self.0).space
2905 }
2906 #[inline]
2907 pub fn uuid(self) -> UuidEXT {
2908 (self.0).uuid
2909 }
2910 #[inline]
2911 pub fn component_type(self) -> SpaceComponentTypeFB {
2912 (self.0).component_type
2913 }
2914 #[inline]
2915 pub fn enabled(self) -> bool {
2916 (self.0).enabled.into()
2917 }
2918}
2919#[derive(Copy, Clone)]
2920pub struct SpaceQueryResultsAvailableFB<'a>(&'a sys::EventDataSpaceQueryResultsAvailableFB);
2921impl<'a> SpaceQueryResultsAvailableFB<'a> {
2922 #[inline]
2923 #[doc = r" # Safety"]
2924 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2925 #[doc = "[sys::EventDataSpaceQueryResultsAvailableFB]"]
2926 #[doc = r" for more information."]
2927 pub unsafe fn new(inner: &'a sys::EventDataSpaceQueryResultsAvailableFB) -> Self {
2928 Self(inner)
2929 }
2930 #[inline]
2931 pub fn request_id(self) -> AsyncRequestIdFB {
2932 (self.0).request_id
2933 }
2934}
2935#[derive(Copy, Clone)]
2936pub struct SpaceQueryCompleteFB<'a>(&'a sys::EventDataSpaceQueryCompleteFB);
2937impl<'a> SpaceQueryCompleteFB<'a> {
2938 #[inline]
2939 #[doc = r" # Safety"]
2940 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2941 #[doc = "[sys::EventDataSpaceQueryCompleteFB]"]
2942 #[doc = r" for more information."]
2943 pub unsafe fn new(inner: &'a sys::EventDataSpaceQueryCompleteFB) -> Self {
2944 Self(inner)
2945 }
2946 #[inline]
2947 pub fn request_id(self) -> AsyncRequestIdFB {
2948 (self.0).request_id
2949 }
2950 #[inline]
2951 pub fn result(self) -> sys::Result {
2952 (self.0).result
2953 }
2954}
2955#[derive(Copy, Clone)]
2956pub struct SpaceSaveCompleteFB<'a>(&'a sys::EventDataSpaceSaveCompleteFB);
2957impl<'a> SpaceSaveCompleteFB<'a> {
2958 #[inline]
2959 #[doc = r" # Safety"]
2960 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2961 #[doc = "[sys::EventDataSpaceSaveCompleteFB]"]
2962 #[doc = r" for more information."]
2963 pub unsafe fn new(inner: &'a sys::EventDataSpaceSaveCompleteFB) -> Self {
2964 Self(inner)
2965 }
2966 #[inline]
2967 pub fn request_id(self) -> AsyncRequestIdFB {
2968 (self.0).request_id
2969 }
2970 #[inline]
2971 pub fn result(self) -> sys::Result {
2972 (self.0).result
2973 }
2974 #[inline]
2975 pub fn space(self) -> sys::Space {
2976 (self.0).space
2977 }
2978 #[inline]
2979 pub fn uuid(self) -> UuidEXT {
2980 (self.0).uuid
2981 }
2982 #[inline]
2983 pub fn location(self) -> SpaceStorageLocationFB {
2984 (self.0).location
2985 }
2986}
2987#[derive(Copy, Clone)]
2988pub struct SpaceEraseCompleteFB<'a>(&'a sys::EventDataSpaceEraseCompleteFB);
2989impl<'a> SpaceEraseCompleteFB<'a> {
2990 #[inline]
2991 #[doc = r" # Safety"]
2992 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
2993 #[doc = "[sys::EventDataSpaceEraseCompleteFB]"]
2994 #[doc = r" for more information."]
2995 pub unsafe fn new(inner: &'a sys::EventDataSpaceEraseCompleteFB) -> Self {
2996 Self(inner)
2997 }
2998 #[inline]
2999 pub fn request_id(self) -> AsyncRequestIdFB {
3000 (self.0).request_id
3001 }
3002 #[inline]
3003 pub fn result(self) -> sys::Result {
3004 (self.0).result
3005 }
3006 #[inline]
3007 pub fn space(self) -> sys::Space {
3008 (self.0).space
3009 }
3010 #[inline]
3011 pub fn uuid(self) -> UuidEXT {
3012 (self.0).uuid
3013 }
3014 #[inline]
3015 pub fn location(self) -> SpaceStorageLocationFB {
3016 (self.0).location
3017 }
3018}
3019#[derive(Copy, Clone)]
3020pub struct SpaceShareCompleteFB<'a>(&'a sys::EventDataSpaceShareCompleteFB);
3021impl<'a> SpaceShareCompleteFB<'a> {
3022 #[inline]
3023 #[doc = r" # Safety"]
3024 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3025 #[doc = "[sys::EventDataSpaceShareCompleteFB]"]
3026 #[doc = r" for more information."]
3027 pub unsafe fn new(inner: &'a sys::EventDataSpaceShareCompleteFB) -> Self {
3028 Self(inner)
3029 }
3030 #[inline]
3031 pub fn request_id(self) -> AsyncRequestIdFB {
3032 (self.0).request_id
3033 }
3034 #[inline]
3035 pub fn result(self) -> sys::Result {
3036 (self.0).result
3037 }
3038}
3039#[derive(Copy, Clone)]
3040pub struct SpaceListSaveCompleteFB<'a>(&'a sys::EventDataSpaceListSaveCompleteFB);
3041impl<'a> SpaceListSaveCompleteFB<'a> {
3042 #[inline]
3043 #[doc = r" # Safety"]
3044 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3045 #[doc = "[sys::EventDataSpaceListSaveCompleteFB]"]
3046 #[doc = r" for more information."]
3047 pub unsafe fn new(inner: &'a sys::EventDataSpaceListSaveCompleteFB) -> Self {
3048 Self(inner)
3049 }
3050 #[inline]
3051 pub fn request_id(self) -> AsyncRequestIdFB {
3052 (self.0).request_id
3053 }
3054 #[inline]
3055 pub fn result(self) -> sys::Result {
3056 (self.0).result
3057 }
3058}
3059#[derive(Copy, Clone)]
3060pub struct SceneCaptureCompleteFB<'a>(&'a sys::EventDataSceneCaptureCompleteFB);
3061impl<'a> SceneCaptureCompleteFB<'a> {
3062 #[inline]
3063 #[doc = r" # Safety"]
3064 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3065 #[doc = "[sys::EventDataSceneCaptureCompleteFB]"]
3066 #[doc = r" for more information."]
3067 pub unsafe fn new(inner: &'a sys::EventDataSceneCaptureCompleteFB) -> Self {
3068 Self(inner)
3069 }
3070 #[inline]
3071 pub fn request_id(self) -> AsyncRequestIdFB {
3072 (self.0).request_id
3073 }
3074 #[inline]
3075 pub fn result(self) -> sys::Result {
3076 (self.0).result
3077 }
3078}
3079#[derive(Copy, Clone)]
3080pub struct PassthroughStateChangedFB<'a>(&'a sys::EventDataPassthroughStateChangedFB);
3081impl<'a> PassthroughStateChangedFB<'a> {
3082 #[inline]
3083 #[doc = r" # Safety"]
3084 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3085 #[doc = "[sys::EventDataPassthroughStateChangedFB]"]
3086 #[doc = r" for more information."]
3087 pub unsafe fn new(inner: &'a sys::EventDataPassthroughStateChangedFB) -> Self {
3088 Self(inner)
3089 }
3090 #[inline]
3091 pub fn flags(self) -> PassthroughStateChangedFlagsFB {
3092 (self.0).flags
3093 }
3094}
3095#[derive(Copy, Clone)]
3096pub struct ViveTrackerConnectedHTCX<'a>(&'a sys::EventDataViveTrackerConnectedHTCX);
3097impl<'a> ViveTrackerConnectedHTCX<'a> {
3098 #[inline]
3099 #[doc = r" # Safety"]
3100 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3101 #[doc = "[sys::EventDataViveTrackerConnectedHTCX]"]
3102 #[doc = r" for more information."]
3103 pub unsafe fn new(inner: &'a sys::EventDataViveTrackerConnectedHTCX) -> Self {
3104 Self(inner)
3105 }
3106 #[inline]
3107 pub fn paths(self) -> ViveTrackerPathsHTCX {
3108 (*unsafe { self.0.paths.as_ref() }.unwrap()).into()
3109 }
3110}
3111#[derive(Copy, Clone)]
3112pub struct MarkerTrackingUpdateVARJO<'a>(&'a sys::EventDataMarkerTrackingUpdateVARJO);
3113impl<'a> MarkerTrackingUpdateVARJO<'a> {
3114 #[inline]
3115 #[doc = r" # Safety"]
3116 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3117 #[doc = "[sys::EventDataMarkerTrackingUpdateVARJO]"]
3118 #[doc = r" for more information."]
3119 pub unsafe fn new(inner: &'a sys::EventDataMarkerTrackingUpdateVARJO) -> Self {
3120 Self(inner)
3121 }
3122 #[inline]
3123 pub fn marker_id(self) -> u64 {
3124 (self.0).marker_id
3125 }
3126 #[inline]
3127 pub fn is_active(self) -> bool {
3128 (self.0).is_active.into()
3129 }
3130 #[inline]
3131 pub fn is_predicted(self) -> bool {
3132 (self.0).is_predicted.into()
3133 }
3134 #[inline]
3135 pub fn time(self) -> Time {
3136 (self.0).time
3137 }
3138}
3139#[derive(Copy, Clone)]
3140pub struct VirtualKeyboardCommitTextMETA<'a>(&'a sys::EventDataVirtualKeyboardCommitTextMETA);
3141impl<'a> VirtualKeyboardCommitTextMETA<'a> {
3142 #[inline]
3143 #[doc = r" # Safety"]
3144 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3145 #[doc = "[sys::EventDataVirtualKeyboardCommitTextMETA]"]
3146 #[doc = r" for more information."]
3147 pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardCommitTextMETA) -> Self {
3148 Self(inner)
3149 }
3150 #[inline]
3151 pub fn keyboard(self) -> sys::VirtualKeyboardMETA {
3152 (self.0).keyboard
3153 }
3154 #[inline]
3155 pub fn text(self) -> [c_char; MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META] {
3156 (self.0).text
3157 }
3158}
3159#[derive(Copy, Clone)]
3160pub struct VirtualKeyboardBackspaceMETA<'a>(&'a sys::EventDataVirtualKeyboardBackspaceMETA);
3161impl<'a> VirtualKeyboardBackspaceMETA<'a> {
3162 #[inline]
3163 #[doc = r" # Safety"]
3164 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3165 #[doc = "[sys::EventDataVirtualKeyboardBackspaceMETA]"]
3166 #[doc = r" for more information."]
3167 pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardBackspaceMETA) -> Self {
3168 Self(inner)
3169 }
3170 #[inline]
3171 pub fn keyboard(self) -> sys::VirtualKeyboardMETA {
3172 (self.0).keyboard
3173 }
3174}
3175#[derive(Copy, Clone)]
3176pub struct VirtualKeyboardEnterMETA<'a>(&'a sys::EventDataVirtualKeyboardEnterMETA);
3177impl<'a> VirtualKeyboardEnterMETA<'a> {
3178 #[inline]
3179 #[doc = r" # Safety"]
3180 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3181 #[doc = "[sys::EventDataVirtualKeyboardEnterMETA]"]
3182 #[doc = r" for more information."]
3183 pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardEnterMETA) -> Self {
3184 Self(inner)
3185 }
3186 #[inline]
3187 pub fn keyboard(self) -> sys::VirtualKeyboardMETA {
3188 (self.0).keyboard
3189 }
3190}
3191#[derive(Copy, Clone)]
3192pub struct VirtualKeyboardShownMETA<'a>(&'a sys::EventDataVirtualKeyboardShownMETA);
3193impl<'a> VirtualKeyboardShownMETA<'a> {
3194 #[inline]
3195 #[doc = r" # Safety"]
3196 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3197 #[doc = "[sys::EventDataVirtualKeyboardShownMETA]"]
3198 #[doc = r" for more information."]
3199 pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardShownMETA) -> Self {
3200 Self(inner)
3201 }
3202 #[inline]
3203 pub fn keyboard(self) -> sys::VirtualKeyboardMETA {
3204 (self.0).keyboard
3205 }
3206}
3207#[derive(Copy, Clone)]
3208pub struct VirtualKeyboardHiddenMETA<'a>(&'a sys::EventDataVirtualKeyboardHiddenMETA);
3209impl<'a> VirtualKeyboardHiddenMETA<'a> {
3210 #[inline]
3211 #[doc = r" # Safety"]
3212 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3213 #[doc = "[sys::EventDataVirtualKeyboardHiddenMETA]"]
3214 #[doc = r" for more information."]
3215 pub unsafe fn new(inner: &'a sys::EventDataVirtualKeyboardHiddenMETA) -> Self {
3216 Self(inner)
3217 }
3218 #[inline]
3219 pub fn keyboard(self) -> sys::VirtualKeyboardMETA {
3220 (self.0).keyboard
3221 }
3222}
3223#[derive(Copy, Clone)]
3224pub struct HeadsetFitChangedML<'a>(&'a sys::EventDataHeadsetFitChangedML);
3225impl<'a> HeadsetFitChangedML<'a> {
3226 #[inline]
3227 #[doc = r" # Safety"]
3228 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3229 #[doc = "[sys::EventDataHeadsetFitChangedML]"]
3230 #[doc = r" for more information."]
3231 pub unsafe fn new(inner: &'a sys::EventDataHeadsetFitChangedML) -> Self {
3232 Self(inner)
3233 }
3234 #[inline]
3235 pub fn status(self) -> HeadsetFitStatusML {
3236 (self.0).status
3237 }
3238 #[inline]
3239 pub fn time(self) -> Time {
3240 (self.0).time
3241 }
3242}
3243#[derive(Copy, Clone)]
3244pub struct EyeCalibrationChangedML<'a>(&'a sys::EventDataEyeCalibrationChangedML);
3245impl<'a> EyeCalibrationChangedML<'a> {
3246 #[inline]
3247 #[doc = r" # Safety"]
3248 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3249 #[doc = "[sys::EventDataEyeCalibrationChangedML]"]
3250 #[doc = r" for more information."]
3251 pub unsafe fn new(inner: &'a sys::EventDataEyeCalibrationChangedML) -> Self {
3252 Self(inner)
3253 }
3254 #[inline]
3255 pub fn status(self) -> EyeCalibrationStatusML {
3256 (self.0).status
3257 }
3258}
3259#[derive(Copy, Clone)]
3260pub struct LocalizationChangedML<'a>(&'a sys::EventDataLocalizationChangedML);
3261impl<'a> LocalizationChangedML<'a> {
3262 #[inline]
3263 #[doc = r" # Safety"]
3264 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3265 #[doc = "[sys::EventDataLocalizationChangedML]"]
3266 #[doc = r" for more information."]
3267 pub unsafe fn new(inner: &'a sys::EventDataLocalizationChangedML) -> Self {
3268 Self(inner)
3269 }
3270 #[inline]
3271 pub fn session(self) -> sys::Session {
3272 (self.0).session
3273 }
3274 #[inline]
3275 pub fn state(self) -> LocalizationMapStateML {
3276 (self.0).state
3277 }
3278 #[inline]
3279 pub fn map(self) -> LocalizationMapML {
3280 LocalizationMapML::from_raw(self.0.map)
3281 }
3282 #[inline]
3283 pub fn confidence(self) -> LocalizationMapConfidenceML {
3284 (self.0).confidence
3285 }
3286 #[inline]
3287 pub fn error_flags(self) -> LocalizationMapErrorFlagsML {
3288 (self.0).error_flags
3289 }
3290}
3291#[derive(Copy, Clone)]
3292pub struct UserPresenceChangedEXT<'a>(&'a sys::EventDataUserPresenceChangedEXT);
3293impl<'a> UserPresenceChangedEXT<'a> {
3294 #[inline]
3295 #[doc = r" # Safety"]
3296 #[doc = r" `inner` must be valid event data according to the OpenXR spec. Refer to"]
3297 #[doc = "[sys::EventDataUserPresenceChangedEXT]"]
3298 #[doc = r" for more information."]
3299 pub unsafe fn new(inner: &'a sys::EventDataUserPresenceChangedEXT) -> Self {
3300 Self(inner)
3301 }
3302 #[inline]
3303 pub fn session(self) -> sys::Session {
3304 (self.0).session
3305 }
3306 #[inline]
3307 pub fn is_user_present(self) -> bool {
3308 (self.0).is_user_present.into()
3309 }
3310}
3311pub mod raw {
3312 use crate::{Entry, Result};
3313 use std::{ffi::CStr, mem};
3314 use sys::pfn;
3315 #[derive(Copy, Clone)]
3316 pub struct Instance {
3317 pub get_instance_proc_addr: pfn::GetInstanceProcAddr,
3318 pub enumerate_api_layer_properties: pfn::EnumerateApiLayerProperties,
3319 pub enumerate_instance_extension_properties: pfn::EnumerateInstanceExtensionProperties,
3320 pub create_instance: pfn::CreateInstance,
3321 pub destroy_instance: pfn::DestroyInstance,
3322 pub result_to_string: pfn::ResultToString,
3323 pub structure_type_to_string: pfn::StructureTypeToString,
3324 pub get_instance_properties: pfn::GetInstanceProperties,
3325 pub get_system: pfn::GetSystem,
3326 pub get_system_properties: pfn::GetSystemProperties,
3327 pub create_session: pfn::CreateSession,
3328 pub destroy_session: pfn::DestroySession,
3329 pub destroy_space: pfn::DestroySpace,
3330 pub enumerate_swapchain_formats: pfn::EnumerateSwapchainFormats,
3331 pub create_swapchain: pfn::CreateSwapchain,
3332 pub destroy_swapchain: pfn::DestroySwapchain,
3333 pub enumerate_swapchain_images: pfn::EnumerateSwapchainImages,
3334 pub acquire_swapchain_image: pfn::AcquireSwapchainImage,
3335 pub wait_swapchain_image: pfn::WaitSwapchainImage,
3336 pub release_swapchain_image: pfn::ReleaseSwapchainImage,
3337 pub begin_session: pfn::BeginSession,
3338 pub end_session: pfn::EndSession,
3339 pub request_exit_session: pfn::RequestExitSession,
3340 pub enumerate_reference_spaces: pfn::EnumerateReferenceSpaces,
3341 pub create_reference_space: pfn::CreateReferenceSpace,
3342 pub create_action_space: pfn::CreateActionSpace,
3343 pub locate_space: pfn::LocateSpace,
3344 pub enumerate_view_configurations: pfn::EnumerateViewConfigurations,
3345 pub enumerate_environment_blend_modes: pfn::EnumerateEnvironmentBlendModes,
3346 pub get_view_configuration_properties: pfn::GetViewConfigurationProperties,
3347 pub enumerate_view_configuration_views: pfn::EnumerateViewConfigurationViews,
3348 pub begin_frame: pfn::BeginFrame,
3349 pub locate_views: pfn::LocateViews,
3350 pub end_frame: pfn::EndFrame,
3351 pub wait_frame: pfn::WaitFrame,
3352 pub apply_haptic_feedback: pfn::ApplyHapticFeedback,
3353 pub stop_haptic_feedback: pfn::StopHapticFeedback,
3354 pub poll_event: pfn::PollEvent,
3355 pub string_to_path: pfn::StringToPath,
3356 pub path_to_string: pfn::PathToString,
3357 pub get_reference_space_bounds_rect: pfn::GetReferenceSpaceBoundsRect,
3358 pub get_action_state_boolean: pfn::GetActionStateBoolean,
3359 pub get_action_state_float: pfn::GetActionStateFloat,
3360 pub get_action_state_vector2f: pfn::GetActionStateVector2f,
3361 pub get_action_state_pose: pfn::GetActionStatePose,
3362 pub create_action_set: pfn::CreateActionSet,
3363 pub destroy_action_set: pfn::DestroyActionSet,
3364 pub create_action: pfn::CreateAction,
3365 pub destroy_action: pfn::DestroyAction,
3366 pub suggest_interaction_profile_bindings: pfn::SuggestInteractionProfileBindings,
3367 pub attach_session_action_sets: pfn::AttachSessionActionSets,
3368 pub get_current_interaction_profile: pfn::GetCurrentInteractionProfile,
3369 pub sync_actions: pfn::SyncActions,
3370 pub enumerate_bound_sources_for_action: pfn::EnumerateBoundSourcesForAction,
3371 pub get_input_source_localized_name: pfn::GetInputSourceLocalizedName,
3372 }
3373 impl Instance {
3374 #[doc = r" Load the core function pointer table"]
3375 #[doc = r""]
3376 #[doc = r" # Safety"]
3377 #[doc = r""]
3378 #[doc = r" `instance` must be a valid instance handle."]
3379 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3380 Ok(Self {
3381 get_instance_proc_addr: mem::transmute(entry.get_instance_proc_addr(
3382 instance,
3383 CStr::from_bytes_with_nul_unchecked(b"xrGetInstanceProcAddr\0"),
3384 )?),
3385 enumerate_api_layer_properties: mem::transmute(entry.get_instance_proc_addr(
3386 instance,
3387 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateApiLayerProperties\0"),
3388 )?),
3389 enumerate_instance_extension_properties: mem::transmute(
3390 entry.get_instance_proc_addr(
3391 instance,
3392 CStr::from_bytes_with_nul_unchecked(
3393 b"xrEnumerateInstanceExtensionProperties\0",
3394 ),
3395 )?,
3396 ),
3397 create_instance: mem::transmute(entry.get_instance_proc_addr(
3398 instance,
3399 CStr::from_bytes_with_nul_unchecked(b"xrCreateInstance\0"),
3400 )?),
3401 destroy_instance: mem::transmute(entry.get_instance_proc_addr(
3402 instance,
3403 CStr::from_bytes_with_nul_unchecked(b"xrDestroyInstance\0"),
3404 )?),
3405 result_to_string: mem::transmute(entry.get_instance_proc_addr(
3406 instance,
3407 CStr::from_bytes_with_nul_unchecked(b"xrResultToString\0"),
3408 )?),
3409 structure_type_to_string: mem::transmute(entry.get_instance_proc_addr(
3410 instance,
3411 CStr::from_bytes_with_nul_unchecked(b"xrStructureTypeToString\0"),
3412 )?),
3413 get_instance_properties: mem::transmute(entry.get_instance_proc_addr(
3414 instance,
3415 CStr::from_bytes_with_nul_unchecked(b"xrGetInstanceProperties\0"),
3416 )?),
3417 get_system: mem::transmute(entry.get_instance_proc_addr(
3418 instance,
3419 CStr::from_bytes_with_nul_unchecked(b"xrGetSystem\0"),
3420 )?),
3421 get_system_properties: mem::transmute(entry.get_instance_proc_addr(
3422 instance,
3423 CStr::from_bytes_with_nul_unchecked(b"xrGetSystemProperties\0"),
3424 )?),
3425 create_session: mem::transmute(entry.get_instance_proc_addr(
3426 instance,
3427 CStr::from_bytes_with_nul_unchecked(b"xrCreateSession\0"),
3428 )?),
3429 destroy_session: mem::transmute(entry.get_instance_proc_addr(
3430 instance,
3431 CStr::from_bytes_with_nul_unchecked(b"xrDestroySession\0"),
3432 )?),
3433 destroy_space: mem::transmute(entry.get_instance_proc_addr(
3434 instance,
3435 CStr::from_bytes_with_nul_unchecked(b"xrDestroySpace\0"),
3436 )?),
3437 enumerate_swapchain_formats: mem::transmute(entry.get_instance_proc_addr(
3438 instance,
3439 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateSwapchainFormats\0"),
3440 )?),
3441 create_swapchain: mem::transmute(entry.get_instance_proc_addr(
3442 instance,
3443 CStr::from_bytes_with_nul_unchecked(b"xrCreateSwapchain\0"),
3444 )?),
3445 destroy_swapchain: mem::transmute(entry.get_instance_proc_addr(
3446 instance,
3447 CStr::from_bytes_with_nul_unchecked(b"xrDestroySwapchain\0"),
3448 )?),
3449 enumerate_swapchain_images: mem::transmute(entry.get_instance_proc_addr(
3450 instance,
3451 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateSwapchainImages\0"),
3452 )?),
3453 acquire_swapchain_image: mem::transmute(entry.get_instance_proc_addr(
3454 instance,
3455 CStr::from_bytes_with_nul_unchecked(b"xrAcquireSwapchainImage\0"),
3456 )?),
3457 wait_swapchain_image: mem::transmute(entry.get_instance_proc_addr(
3458 instance,
3459 CStr::from_bytes_with_nul_unchecked(b"xrWaitSwapchainImage\0"),
3460 )?),
3461 release_swapchain_image: mem::transmute(entry.get_instance_proc_addr(
3462 instance,
3463 CStr::from_bytes_with_nul_unchecked(b"xrReleaseSwapchainImage\0"),
3464 )?),
3465 begin_session: mem::transmute(entry.get_instance_proc_addr(
3466 instance,
3467 CStr::from_bytes_with_nul_unchecked(b"xrBeginSession\0"),
3468 )?),
3469 end_session: mem::transmute(entry.get_instance_proc_addr(
3470 instance,
3471 CStr::from_bytes_with_nul_unchecked(b"xrEndSession\0"),
3472 )?),
3473 request_exit_session: mem::transmute(entry.get_instance_proc_addr(
3474 instance,
3475 CStr::from_bytes_with_nul_unchecked(b"xrRequestExitSession\0"),
3476 )?),
3477 enumerate_reference_spaces: mem::transmute(entry.get_instance_proc_addr(
3478 instance,
3479 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateReferenceSpaces\0"),
3480 )?),
3481 create_reference_space: mem::transmute(entry.get_instance_proc_addr(
3482 instance,
3483 CStr::from_bytes_with_nul_unchecked(b"xrCreateReferenceSpace\0"),
3484 )?),
3485 create_action_space: mem::transmute(entry.get_instance_proc_addr(
3486 instance,
3487 CStr::from_bytes_with_nul_unchecked(b"xrCreateActionSpace\0"),
3488 )?),
3489 locate_space: mem::transmute(entry.get_instance_proc_addr(
3490 instance,
3491 CStr::from_bytes_with_nul_unchecked(b"xrLocateSpace\0"),
3492 )?),
3493 enumerate_view_configurations: mem::transmute(entry.get_instance_proc_addr(
3494 instance,
3495 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateViewConfigurations\0"),
3496 )?),
3497 enumerate_environment_blend_modes: mem::transmute(entry.get_instance_proc_addr(
3498 instance,
3499 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateEnvironmentBlendModes\0"),
3500 )?),
3501 get_view_configuration_properties: mem::transmute(entry.get_instance_proc_addr(
3502 instance,
3503 CStr::from_bytes_with_nul_unchecked(b"xrGetViewConfigurationProperties\0"),
3504 )?),
3505 enumerate_view_configuration_views: mem::transmute(entry.get_instance_proc_addr(
3506 instance,
3507 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateViewConfigurationViews\0"),
3508 )?),
3509 begin_frame: mem::transmute(entry.get_instance_proc_addr(
3510 instance,
3511 CStr::from_bytes_with_nul_unchecked(b"xrBeginFrame\0"),
3512 )?),
3513 locate_views: mem::transmute(entry.get_instance_proc_addr(
3514 instance,
3515 CStr::from_bytes_with_nul_unchecked(b"xrLocateViews\0"),
3516 )?),
3517 end_frame: mem::transmute(entry.get_instance_proc_addr(
3518 instance,
3519 CStr::from_bytes_with_nul_unchecked(b"xrEndFrame\0"),
3520 )?),
3521 wait_frame: mem::transmute(entry.get_instance_proc_addr(
3522 instance,
3523 CStr::from_bytes_with_nul_unchecked(b"xrWaitFrame\0"),
3524 )?),
3525 apply_haptic_feedback: mem::transmute(entry.get_instance_proc_addr(
3526 instance,
3527 CStr::from_bytes_with_nul_unchecked(b"xrApplyHapticFeedback\0"),
3528 )?),
3529 stop_haptic_feedback: mem::transmute(entry.get_instance_proc_addr(
3530 instance,
3531 CStr::from_bytes_with_nul_unchecked(b"xrStopHapticFeedback\0"),
3532 )?),
3533 poll_event: mem::transmute(entry.get_instance_proc_addr(
3534 instance,
3535 CStr::from_bytes_with_nul_unchecked(b"xrPollEvent\0"),
3536 )?),
3537 string_to_path: mem::transmute(entry.get_instance_proc_addr(
3538 instance,
3539 CStr::from_bytes_with_nul_unchecked(b"xrStringToPath\0"),
3540 )?),
3541 path_to_string: mem::transmute(entry.get_instance_proc_addr(
3542 instance,
3543 CStr::from_bytes_with_nul_unchecked(b"xrPathToString\0"),
3544 )?),
3545 get_reference_space_bounds_rect: mem::transmute(entry.get_instance_proc_addr(
3546 instance,
3547 CStr::from_bytes_with_nul_unchecked(b"xrGetReferenceSpaceBoundsRect\0"),
3548 )?),
3549 get_action_state_boolean: mem::transmute(entry.get_instance_proc_addr(
3550 instance,
3551 CStr::from_bytes_with_nul_unchecked(b"xrGetActionStateBoolean\0"),
3552 )?),
3553 get_action_state_float: mem::transmute(entry.get_instance_proc_addr(
3554 instance,
3555 CStr::from_bytes_with_nul_unchecked(b"xrGetActionStateFloat\0"),
3556 )?),
3557 get_action_state_vector2f: mem::transmute(entry.get_instance_proc_addr(
3558 instance,
3559 CStr::from_bytes_with_nul_unchecked(b"xrGetActionStateVector2f\0"),
3560 )?),
3561 get_action_state_pose: mem::transmute(entry.get_instance_proc_addr(
3562 instance,
3563 CStr::from_bytes_with_nul_unchecked(b"xrGetActionStatePose\0"),
3564 )?),
3565 create_action_set: mem::transmute(entry.get_instance_proc_addr(
3566 instance,
3567 CStr::from_bytes_with_nul_unchecked(b"xrCreateActionSet\0"),
3568 )?),
3569 destroy_action_set: mem::transmute(entry.get_instance_proc_addr(
3570 instance,
3571 CStr::from_bytes_with_nul_unchecked(b"xrDestroyActionSet\0"),
3572 )?),
3573 create_action: mem::transmute(entry.get_instance_proc_addr(
3574 instance,
3575 CStr::from_bytes_with_nul_unchecked(b"xrCreateAction\0"),
3576 )?),
3577 destroy_action: mem::transmute(entry.get_instance_proc_addr(
3578 instance,
3579 CStr::from_bytes_with_nul_unchecked(b"xrDestroyAction\0"),
3580 )?),
3581 suggest_interaction_profile_bindings: mem::transmute(
3582 entry.get_instance_proc_addr(
3583 instance,
3584 CStr::from_bytes_with_nul_unchecked(
3585 b"xrSuggestInteractionProfileBindings\0",
3586 ),
3587 )?,
3588 ),
3589 attach_session_action_sets: mem::transmute(entry.get_instance_proc_addr(
3590 instance,
3591 CStr::from_bytes_with_nul_unchecked(b"xrAttachSessionActionSets\0"),
3592 )?),
3593 get_current_interaction_profile: mem::transmute(entry.get_instance_proc_addr(
3594 instance,
3595 CStr::from_bytes_with_nul_unchecked(b"xrGetCurrentInteractionProfile\0"),
3596 )?),
3597 sync_actions: mem::transmute(entry.get_instance_proc_addr(
3598 instance,
3599 CStr::from_bytes_with_nul_unchecked(b"xrSyncActions\0"),
3600 )?),
3601 enumerate_bound_sources_for_action: mem::transmute(entry.get_instance_proc_addr(
3602 instance,
3603 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateBoundSourcesForAction\0"),
3604 )?),
3605 get_input_source_localized_name: mem::transmute(entry.get_instance_proc_addr(
3606 instance,
3607 CStr::from_bytes_with_nul_unchecked(b"xrGetInputSourceLocalizedName\0"),
3608 )?),
3609 })
3610 }
3611 }
3612 #[derive(Copy, Clone)]
3613 pub struct DigitalLensControlALMALENCE {
3614 pub set_digital_lens_control: pfn::SetDigitalLensControlALMALENCE,
3615 }
3616 impl DigitalLensControlALMALENCE {
3617 pub const VERSION: u32 = sys::ALMALENCE_digital_lens_control_SPEC_VERSION;
3618 pub const NAME: &'static [u8] = sys::ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME;
3619 #[doc = r" Load the extension's function pointer table"]
3620 #[doc = r""]
3621 #[doc = r" # Safety"]
3622 #[doc = r""]
3623 #[doc = r" `instance` must be a valid instance handle."]
3624 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3625 Ok(Self {
3626 set_digital_lens_control: mem::transmute(entry.get_instance_proc_addr(
3627 instance,
3628 CStr::from_bytes_with_nul_unchecked(b"xrSetDigitalLensControlALMALENCE\0"),
3629 )?),
3630 })
3631 }
3632 }
3633 #[derive(Copy, Clone)]
3634 pub struct ControllerInteractionBD {}
3635 impl ControllerInteractionBD {
3636 pub const VERSION: u32 = sys::BD_controller_interaction_SPEC_VERSION;
3637 pub const NAME: &'static [u8] = sys::BD_CONTROLLER_INTERACTION_EXTENSION_NAME;
3638 }
3639 #[derive(Copy, Clone)]
3640 pub struct ViewConfigurationFovEPIC {}
3641 impl ViewConfigurationFovEPIC {
3642 pub const VERSION: u32 = sys::EPIC_view_configuration_fov_SPEC_VERSION;
3643 pub const NAME: &'static [u8] = sys::EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME;
3644 }
3645 #[derive(Copy, Clone)]
3646 pub struct PerformanceSettingsEXT {
3647 pub perf_settings_set_performance_level: pfn::PerfSettingsSetPerformanceLevelEXT,
3648 }
3649 impl PerformanceSettingsEXT {
3650 pub const VERSION: u32 = sys::EXT_performance_settings_SPEC_VERSION;
3651 pub const NAME: &'static [u8] = sys::EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME;
3652 #[doc = r" Load the extension's function pointer table"]
3653 #[doc = r""]
3654 #[doc = r" # Safety"]
3655 #[doc = r""]
3656 #[doc = r" `instance` must be a valid instance handle."]
3657 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3658 Ok(Self {
3659 perf_settings_set_performance_level: mem::transmute(entry.get_instance_proc_addr(
3660 instance,
3661 CStr::from_bytes_with_nul_unchecked(b"xrPerfSettingsSetPerformanceLevelEXT\0"),
3662 )?),
3663 })
3664 }
3665 }
3666 #[derive(Copy, Clone)]
3667 pub struct ThermalQueryEXT {
3668 pub thermal_get_temperature_trend: pfn::ThermalGetTemperatureTrendEXT,
3669 }
3670 impl ThermalQueryEXT {
3671 pub const VERSION: u32 = sys::EXT_thermal_query_SPEC_VERSION;
3672 pub const NAME: &'static [u8] = sys::EXT_THERMAL_QUERY_EXTENSION_NAME;
3673 #[doc = r" Load the extension's function pointer table"]
3674 #[doc = r""]
3675 #[doc = r" # Safety"]
3676 #[doc = r""]
3677 #[doc = r" `instance` must be a valid instance handle."]
3678 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3679 Ok(Self {
3680 thermal_get_temperature_trend: mem::transmute(entry.get_instance_proc_addr(
3681 instance,
3682 CStr::from_bytes_with_nul_unchecked(b"xrThermalGetTemperatureTrendEXT\0"),
3683 )?),
3684 })
3685 }
3686 }
3687 #[derive(Copy, Clone)]
3688 pub struct DebugUtilsEXT {
3689 pub set_debug_utils_object_name: pfn::SetDebugUtilsObjectNameEXT,
3690 pub create_debug_utils_messenger: pfn::CreateDebugUtilsMessengerEXT,
3691 pub destroy_debug_utils_messenger: pfn::DestroyDebugUtilsMessengerEXT,
3692 pub submit_debug_utils_message: pfn::SubmitDebugUtilsMessageEXT,
3693 pub session_begin_debug_utils_label_region: pfn::SessionBeginDebugUtilsLabelRegionEXT,
3694 pub session_end_debug_utils_label_region: pfn::SessionEndDebugUtilsLabelRegionEXT,
3695 pub session_insert_debug_utils_label: pfn::SessionInsertDebugUtilsLabelEXT,
3696 }
3697 impl DebugUtilsEXT {
3698 pub const VERSION: u32 = sys::EXT_debug_utils_SPEC_VERSION;
3699 pub const NAME: &'static [u8] = sys::EXT_DEBUG_UTILS_EXTENSION_NAME;
3700 #[doc = r" Load the extension's function pointer table"]
3701 #[doc = r""]
3702 #[doc = r" # Safety"]
3703 #[doc = r""]
3704 #[doc = r" `instance` must be a valid instance handle."]
3705 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3706 Ok(Self {
3707 set_debug_utils_object_name: mem::transmute(entry.get_instance_proc_addr(
3708 instance,
3709 CStr::from_bytes_with_nul_unchecked(b"xrSetDebugUtilsObjectNameEXT\0"),
3710 )?),
3711 create_debug_utils_messenger: mem::transmute(entry.get_instance_proc_addr(
3712 instance,
3713 CStr::from_bytes_with_nul_unchecked(b"xrCreateDebugUtilsMessengerEXT\0"),
3714 )?),
3715 destroy_debug_utils_messenger: mem::transmute(entry.get_instance_proc_addr(
3716 instance,
3717 CStr::from_bytes_with_nul_unchecked(b"xrDestroyDebugUtilsMessengerEXT\0"),
3718 )?),
3719 submit_debug_utils_message: mem::transmute(entry.get_instance_proc_addr(
3720 instance,
3721 CStr::from_bytes_with_nul_unchecked(b"xrSubmitDebugUtilsMessageEXT\0"),
3722 )?),
3723 session_begin_debug_utils_label_region: mem::transmute(
3724 entry.get_instance_proc_addr(
3725 instance,
3726 CStr::from_bytes_with_nul_unchecked(
3727 b"xrSessionBeginDebugUtilsLabelRegionEXT\0",
3728 ),
3729 )?,
3730 ),
3731 session_end_debug_utils_label_region: mem::transmute(
3732 entry.get_instance_proc_addr(
3733 instance,
3734 CStr::from_bytes_with_nul_unchecked(
3735 b"xrSessionEndDebugUtilsLabelRegionEXT\0",
3736 ),
3737 )?,
3738 ),
3739 session_insert_debug_utils_label: mem::transmute(entry.get_instance_proc_addr(
3740 instance,
3741 CStr::from_bytes_with_nul_unchecked(b"xrSessionInsertDebugUtilsLabelEXT\0"),
3742 )?),
3743 })
3744 }
3745 }
3746 #[derive(Copy, Clone)]
3747 pub struct EyeGazeInteractionEXT {}
3748 impl EyeGazeInteractionEXT {
3749 pub const VERSION: u32 = sys::EXT_eye_gaze_interaction_SPEC_VERSION;
3750 pub const NAME: &'static [u8] = sys::EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME;
3751 }
3752 #[derive(Copy, Clone)]
3753 pub struct ViewConfigurationDepthRangeEXT {}
3754 impl ViewConfigurationDepthRangeEXT {
3755 pub const VERSION: u32 = sys::EXT_view_configuration_depth_range_SPEC_VERSION;
3756 pub const NAME: &'static [u8] = sys::EXT_VIEW_CONFIGURATION_DEPTH_RANGE_EXTENSION_NAME;
3757 }
3758 #[derive(Copy, Clone)]
3759 pub struct ConformanceAutomationEXT {
3760 pub set_input_device_active: pfn::SetInputDeviceActiveEXT,
3761 pub set_input_device_state_bool: pfn::SetInputDeviceStateBoolEXT,
3762 pub set_input_device_state_float: pfn::SetInputDeviceStateFloatEXT,
3763 pub set_input_device_state_vector2f: pfn::SetInputDeviceStateVector2fEXT,
3764 pub set_input_device_location: pfn::SetInputDeviceLocationEXT,
3765 }
3766 impl ConformanceAutomationEXT {
3767 pub const VERSION: u32 = sys::EXT_conformance_automation_SPEC_VERSION;
3768 pub const NAME: &'static [u8] = sys::EXT_CONFORMANCE_AUTOMATION_EXTENSION_NAME;
3769 #[doc = r" Load the extension's function pointer table"]
3770 #[doc = r""]
3771 #[doc = r" # Safety"]
3772 #[doc = r""]
3773 #[doc = r" `instance` must be a valid instance handle."]
3774 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3775 Ok(Self {
3776 set_input_device_active: mem::transmute(entry.get_instance_proc_addr(
3777 instance,
3778 CStr::from_bytes_with_nul_unchecked(b"xrSetInputDeviceActiveEXT\0"),
3779 )?),
3780 set_input_device_state_bool: mem::transmute(entry.get_instance_proc_addr(
3781 instance,
3782 CStr::from_bytes_with_nul_unchecked(b"xrSetInputDeviceStateBoolEXT\0"),
3783 )?),
3784 set_input_device_state_float: mem::transmute(entry.get_instance_proc_addr(
3785 instance,
3786 CStr::from_bytes_with_nul_unchecked(b"xrSetInputDeviceStateFloatEXT\0"),
3787 )?),
3788 set_input_device_state_vector2f: mem::transmute(entry.get_instance_proc_addr(
3789 instance,
3790 CStr::from_bytes_with_nul_unchecked(b"xrSetInputDeviceStateVector2fEXT\0"),
3791 )?),
3792 set_input_device_location: mem::transmute(entry.get_instance_proc_addr(
3793 instance,
3794 CStr::from_bytes_with_nul_unchecked(b"xrSetInputDeviceLocationEXT\0"),
3795 )?),
3796 })
3797 }
3798 }
3799 #[derive(Copy, Clone)]
3800 pub struct HandTrackingEXT {
3801 pub create_hand_tracker: pfn::CreateHandTrackerEXT,
3802 pub destroy_hand_tracker: pfn::DestroyHandTrackerEXT,
3803 pub locate_hand_joints: pfn::LocateHandJointsEXT,
3804 }
3805 impl HandTrackingEXT {
3806 pub const VERSION: u32 = sys::EXT_hand_tracking_SPEC_VERSION;
3807 pub const NAME: &'static [u8] = sys::EXT_HAND_TRACKING_EXTENSION_NAME;
3808 #[doc = r" Load the extension's function pointer table"]
3809 #[doc = r""]
3810 #[doc = r" # Safety"]
3811 #[doc = r""]
3812 #[doc = r" `instance` must be a valid instance handle."]
3813 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3814 Ok(Self {
3815 create_hand_tracker: mem::transmute(entry.get_instance_proc_addr(
3816 instance,
3817 CStr::from_bytes_with_nul_unchecked(b"xrCreateHandTrackerEXT\0"),
3818 )?),
3819 destroy_hand_tracker: mem::transmute(entry.get_instance_proc_addr(
3820 instance,
3821 CStr::from_bytes_with_nul_unchecked(b"xrDestroyHandTrackerEXT\0"),
3822 )?),
3823 locate_hand_joints: mem::transmute(entry.get_instance_proc_addr(
3824 instance,
3825 CStr::from_bytes_with_nul_unchecked(b"xrLocateHandJointsEXT\0"),
3826 )?),
3827 })
3828 }
3829 }
3830 #[cfg(windows)]
3831 #[derive(Copy, Clone)]
3832 pub struct Win32AppcontainerCompatibleEXT {}
3833 #[cfg(windows)]
3834 impl Win32AppcontainerCompatibleEXT {
3835 pub const VERSION: u32 = sys::EXT_win32_appcontainer_compatible_SPEC_VERSION;
3836 pub const NAME: &'static [u8] = sys::EXT_WIN32_APPCONTAINER_COMPATIBLE_EXTENSION_NAME;
3837 }
3838 #[derive(Copy, Clone)]
3839 pub struct DpadBindingEXT {}
3840 impl DpadBindingEXT {
3841 pub const VERSION: u32 = sys::EXT_dpad_binding_SPEC_VERSION;
3842 pub const NAME: &'static [u8] = sys::EXT_DPAD_BINDING_EXTENSION_NAME;
3843 }
3844 #[derive(Copy, Clone)]
3845 pub struct HandJointsMotionRangeEXT {}
3846 impl HandJointsMotionRangeEXT {
3847 pub const VERSION: u32 = sys::EXT_hand_joints_motion_range_SPEC_VERSION;
3848 pub const NAME: &'static [u8] = sys::EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME;
3849 }
3850 #[derive(Copy, Clone)]
3851 pub struct SamsungOdysseyControllerEXT {}
3852 impl SamsungOdysseyControllerEXT {
3853 pub const VERSION: u32 = sys::EXT_samsung_odyssey_controller_SPEC_VERSION;
3854 pub const NAME: &'static [u8] = sys::EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME;
3855 }
3856 #[derive(Copy, Clone)]
3857 pub struct HpMixedRealityControllerEXT {}
3858 impl HpMixedRealityControllerEXT {
3859 pub const VERSION: u32 = sys::EXT_hp_mixed_reality_controller_SPEC_VERSION;
3860 pub const NAME: &'static [u8] = sys::EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME;
3861 }
3862 #[derive(Copy, Clone)]
3863 pub struct PalmPoseEXT {}
3864 impl PalmPoseEXT {
3865 pub const VERSION: u32 = sys::EXT_palm_pose_SPEC_VERSION;
3866 pub const NAME: &'static [u8] = sys::EXT_PALM_POSE_EXTENSION_NAME;
3867 }
3868 #[derive(Copy, Clone)]
3869 pub struct UuidEXT {}
3870 impl UuidEXT {
3871 pub const VERSION: u32 = sys::EXT_uuid_SPEC_VERSION;
3872 pub const NAME: &'static [u8] = sys::EXT_UUID_EXTENSION_NAME;
3873 }
3874 #[derive(Copy, Clone)]
3875 pub struct HandInteractionEXT {}
3876 impl HandInteractionEXT {
3877 pub const VERSION: u32 = sys::EXT_hand_interaction_SPEC_VERSION;
3878 pub const NAME: &'static [u8] = sys::EXT_HAND_INTERACTION_EXTENSION_NAME;
3879 }
3880 #[derive(Copy, Clone)]
3881 pub struct ActiveActionSetPriorityEXT {}
3882 impl ActiveActionSetPriorityEXT {
3883 pub const VERSION: u32 = sys::EXT_active_action_set_priority_SPEC_VERSION;
3884 pub const NAME: &'static [u8] = sys::EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME;
3885 }
3886 #[derive(Copy, Clone)]
3887 pub struct LocalFloorEXT {}
3888 impl LocalFloorEXT {
3889 pub const VERSION: u32 = sys::EXT_local_floor_SPEC_VERSION;
3890 pub const NAME: &'static [u8] = sys::EXT_LOCAL_FLOOR_EXTENSION_NAME;
3891 }
3892 #[derive(Copy, Clone)]
3893 pub struct HandTrackingDataSourceEXT {}
3894 impl HandTrackingDataSourceEXT {
3895 pub const VERSION: u32 = sys::EXT_hand_tracking_data_source_SPEC_VERSION;
3896 pub const NAME: &'static [u8] = sys::EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME;
3897 }
3898 #[derive(Copy, Clone)]
3899 pub struct PlaneDetectionEXT {
3900 pub create_plane_detector: pfn::CreatePlaneDetectorEXT,
3901 pub destroy_plane_detector: pfn::DestroyPlaneDetectorEXT,
3902 pub begin_plane_detection: pfn::BeginPlaneDetectionEXT,
3903 pub get_plane_detection_state: pfn::GetPlaneDetectionStateEXT,
3904 pub get_plane_detections: pfn::GetPlaneDetectionsEXT,
3905 pub get_plane_polygon_buffer: pfn::GetPlanePolygonBufferEXT,
3906 }
3907 impl PlaneDetectionEXT {
3908 pub const VERSION: u32 = sys::EXT_plane_detection_SPEC_VERSION;
3909 pub const NAME: &'static [u8] = sys::EXT_PLANE_DETECTION_EXTENSION_NAME;
3910 #[doc = r" Load the extension's function pointer table"]
3911 #[doc = r""]
3912 #[doc = r" # Safety"]
3913 #[doc = r""]
3914 #[doc = r" `instance` must be a valid instance handle."]
3915 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3916 Ok(Self {
3917 create_plane_detector: mem::transmute(entry.get_instance_proc_addr(
3918 instance,
3919 CStr::from_bytes_with_nul_unchecked(b"xrCreatePlaneDetectorEXT\0"),
3920 )?),
3921 destroy_plane_detector: mem::transmute(entry.get_instance_proc_addr(
3922 instance,
3923 CStr::from_bytes_with_nul_unchecked(b"xrDestroyPlaneDetectorEXT\0"),
3924 )?),
3925 begin_plane_detection: mem::transmute(entry.get_instance_proc_addr(
3926 instance,
3927 CStr::from_bytes_with_nul_unchecked(b"xrBeginPlaneDetectionEXT\0"),
3928 )?),
3929 get_plane_detection_state: mem::transmute(entry.get_instance_proc_addr(
3930 instance,
3931 CStr::from_bytes_with_nul_unchecked(b"xrGetPlaneDetectionStateEXT\0"),
3932 )?),
3933 get_plane_detections: mem::transmute(entry.get_instance_proc_addr(
3934 instance,
3935 CStr::from_bytes_with_nul_unchecked(b"xrGetPlaneDetectionsEXT\0"),
3936 )?),
3937 get_plane_polygon_buffer: mem::transmute(entry.get_instance_proc_addr(
3938 instance,
3939 CStr::from_bytes_with_nul_unchecked(b"xrGetPlanePolygonBufferEXT\0"),
3940 )?),
3941 })
3942 }
3943 }
3944 #[derive(Copy, Clone)]
3945 pub struct FutureEXT {
3946 pub poll_future: pfn::PollFutureEXT,
3947 pub cancel_future: pfn::CancelFutureEXT,
3948 }
3949 impl FutureEXT {
3950 pub const VERSION: u32 = sys::EXT_future_SPEC_VERSION;
3951 pub const NAME: &'static [u8] = sys::EXT_FUTURE_EXTENSION_NAME;
3952 #[doc = r" Load the extension's function pointer table"]
3953 #[doc = r""]
3954 #[doc = r" # Safety"]
3955 #[doc = r""]
3956 #[doc = r" `instance` must be a valid instance handle."]
3957 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
3958 Ok(Self {
3959 poll_future: mem::transmute(entry.get_instance_proc_addr(
3960 instance,
3961 CStr::from_bytes_with_nul_unchecked(b"xrPollFutureEXT\0"),
3962 )?),
3963 cancel_future: mem::transmute(entry.get_instance_proc_addr(
3964 instance,
3965 CStr::from_bytes_with_nul_unchecked(b"xrCancelFutureEXT\0"),
3966 )?),
3967 })
3968 }
3969 }
3970 #[derive(Copy, Clone)]
3971 pub struct UserPresenceEXT {}
3972 impl UserPresenceEXT {
3973 pub const VERSION: u32 = sys::EXT_user_presence_SPEC_VERSION;
3974 pub const NAME: &'static [u8] = sys::EXT_USER_PRESENCE_EXTENSION_NAME;
3975 }
3976 #[derive(Copy, Clone)]
3977 pub struct CompositionLayerImageLayoutFB {}
3978 impl CompositionLayerImageLayoutFB {
3979 pub const VERSION: u32 = sys::FB_composition_layer_image_layout_SPEC_VERSION;
3980 pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME;
3981 }
3982 #[derive(Copy, Clone)]
3983 pub struct CompositionLayerAlphaBlendFB {}
3984 impl CompositionLayerAlphaBlendFB {
3985 pub const VERSION: u32 = sys::FB_composition_layer_alpha_blend_SPEC_VERSION;
3986 pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME;
3987 }
3988 #[cfg(target_os = "android")]
3989 #[derive(Copy, Clone)]
3990 pub struct AndroidSurfaceSwapchainCreateFB {}
3991 #[cfg(target_os = "android")]
3992 impl AndroidSurfaceSwapchainCreateFB {
3993 pub const VERSION: u32 = sys::FB_android_surface_swapchain_create_SPEC_VERSION;
3994 pub const NAME: &'static [u8] = sys::FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME;
3995 }
3996 #[derive(Copy, Clone)]
3997 pub struct SwapchainUpdateStateFB {
3998 pub update_swapchain: pfn::UpdateSwapchainFB,
3999 pub get_swapchain_state: pfn::GetSwapchainStateFB,
4000 }
4001 impl SwapchainUpdateStateFB {
4002 pub const VERSION: u32 = sys::FB_swapchain_update_state_SPEC_VERSION;
4003 pub const NAME: &'static [u8] = sys::FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME;
4004 #[doc = r" Load the extension's function pointer table"]
4005 #[doc = r""]
4006 #[doc = r" # Safety"]
4007 #[doc = r""]
4008 #[doc = r" `instance` must be a valid instance handle."]
4009 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4010 Ok(Self {
4011 update_swapchain: mem::transmute(entry.get_instance_proc_addr(
4012 instance,
4013 CStr::from_bytes_with_nul_unchecked(b"xrUpdateSwapchainFB\0"),
4014 )?),
4015 get_swapchain_state: mem::transmute(entry.get_instance_proc_addr(
4016 instance,
4017 CStr::from_bytes_with_nul_unchecked(b"xrGetSwapchainStateFB\0"),
4018 )?),
4019 })
4020 }
4021 }
4022 #[derive(Copy, Clone)]
4023 pub struct CompositionLayerSecureContentFB {}
4024 impl CompositionLayerSecureContentFB {
4025 pub const VERSION: u32 = sys::FB_composition_layer_secure_content_SPEC_VERSION;
4026 pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME;
4027 }
4028 #[derive(Copy, Clone)]
4029 pub struct BodyTrackingFB {
4030 pub create_body_tracker: pfn::CreateBodyTrackerFB,
4031 pub destroy_body_tracker: pfn::DestroyBodyTrackerFB,
4032 pub locate_body_joints: pfn::LocateBodyJointsFB,
4033 pub get_body_skeleton: pfn::GetBodySkeletonFB,
4034 }
4035 impl BodyTrackingFB {
4036 pub const VERSION: u32 = sys::FB_body_tracking_SPEC_VERSION;
4037 pub const NAME: &'static [u8] = sys::FB_BODY_TRACKING_EXTENSION_NAME;
4038 #[doc = r" Load the extension's function pointer table"]
4039 #[doc = r""]
4040 #[doc = r" # Safety"]
4041 #[doc = r""]
4042 #[doc = r" `instance` must be a valid instance handle."]
4043 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4044 Ok(Self {
4045 create_body_tracker: mem::transmute(entry.get_instance_proc_addr(
4046 instance,
4047 CStr::from_bytes_with_nul_unchecked(b"xrCreateBodyTrackerFB\0"),
4048 )?),
4049 destroy_body_tracker: mem::transmute(entry.get_instance_proc_addr(
4050 instance,
4051 CStr::from_bytes_with_nul_unchecked(b"xrDestroyBodyTrackerFB\0"),
4052 )?),
4053 locate_body_joints: mem::transmute(entry.get_instance_proc_addr(
4054 instance,
4055 CStr::from_bytes_with_nul_unchecked(b"xrLocateBodyJointsFB\0"),
4056 )?),
4057 get_body_skeleton: mem::transmute(entry.get_instance_proc_addr(
4058 instance,
4059 CStr::from_bytes_with_nul_unchecked(b"xrGetBodySkeletonFB\0"),
4060 )?),
4061 })
4062 }
4063 }
4064 #[derive(Copy, Clone)]
4065 pub struct DisplayRefreshRateFB {
4066 pub enumerate_display_refresh_rates: pfn::EnumerateDisplayRefreshRatesFB,
4067 pub get_display_refresh_rate: pfn::GetDisplayRefreshRateFB,
4068 pub request_display_refresh_rate: pfn::RequestDisplayRefreshRateFB,
4069 }
4070 impl DisplayRefreshRateFB {
4071 pub const VERSION: u32 = sys::FB_display_refresh_rate_SPEC_VERSION;
4072 pub const NAME: &'static [u8] = sys::FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME;
4073 #[doc = r" Load the extension's function pointer table"]
4074 #[doc = r""]
4075 #[doc = r" # Safety"]
4076 #[doc = r""]
4077 #[doc = r" `instance` must be a valid instance handle."]
4078 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4079 Ok(Self {
4080 enumerate_display_refresh_rates: mem::transmute(entry.get_instance_proc_addr(
4081 instance,
4082 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateDisplayRefreshRatesFB\0"),
4083 )?),
4084 get_display_refresh_rate: mem::transmute(entry.get_instance_proc_addr(
4085 instance,
4086 CStr::from_bytes_with_nul_unchecked(b"xrGetDisplayRefreshRateFB\0"),
4087 )?),
4088 request_display_refresh_rate: mem::transmute(entry.get_instance_proc_addr(
4089 instance,
4090 CStr::from_bytes_with_nul_unchecked(b"xrRequestDisplayRefreshRateFB\0"),
4091 )?),
4092 })
4093 }
4094 }
4095 #[derive(Copy, Clone)]
4096 pub struct ColorSpaceFB {
4097 pub enumerate_color_spaces: pfn::EnumerateColorSpacesFB,
4098 pub set_color_space: pfn::SetColorSpaceFB,
4099 }
4100 impl ColorSpaceFB {
4101 pub const VERSION: u32 = sys::FB_color_space_SPEC_VERSION;
4102 pub const NAME: &'static [u8] = sys::FB_COLOR_SPACE_EXTENSION_NAME;
4103 #[doc = r" Load the extension's function pointer table"]
4104 #[doc = r""]
4105 #[doc = r" # Safety"]
4106 #[doc = r""]
4107 #[doc = r" `instance` must be a valid instance handle."]
4108 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4109 Ok(Self {
4110 enumerate_color_spaces: mem::transmute(entry.get_instance_proc_addr(
4111 instance,
4112 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateColorSpacesFB\0"),
4113 )?),
4114 set_color_space: mem::transmute(entry.get_instance_proc_addr(
4115 instance,
4116 CStr::from_bytes_with_nul_unchecked(b"xrSetColorSpaceFB\0"),
4117 )?),
4118 })
4119 }
4120 }
4121 #[derive(Copy, Clone)]
4122 pub struct HandTrackingMeshFB {
4123 pub get_hand_mesh: pfn::GetHandMeshFB,
4124 }
4125 impl HandTrackingMeshFB {
4126 pub const VERSION: u32 = sys::FB_hand_tracking_mesh_SPEC_VERSION;
4127 pub const NAME: &'static [u8] = sys::FB_HAND_TRACKING_MESH_EXTENSION_NAME;
4128 #[doc = r" Load the extension's function pointer table"]
4129 #[doc = r""]
4130 #[doc = r" # Safety"]
4131 #[doc = r""]
4132 #[doc = r" `instance` must be a valid instance handle."]
4133 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4134 Ok(Self {
4135 get_hand_mesh: mem::transmute(entry.get_instance_proc_addr(
4136 instance,
4137 CStr::from_bytes_with_nul_unchecked(b"xrGetHandMeshFB\0"),
4138 )?),
4139 })
4140 }
4141 }
4142 #[derive(Copy, Clone)]
4143 pub struct HandTrackingAimFB {}
4144 impl HandTrackingAimFB {
4145 pub const VERSION: u32 = sys::FB_hand_tracking_aim_SPEC_VERSION;
4146 pub const NAME: &'static [u8] = sys::FB_HAND_TRACKING_AIM_EXTENSION_NAME;
4147 }
4148 #[derive(Copy, Clone)]
4149 pub struct HandTrackingCapsulesFB {}
4150 impl HandTrackingCapsulesFB {
4151 pub const VERSION: u32 = sys::FB_hand_tracking_capsules_SPEC_VERSION;
4152 pub const NAME: &'static [u8] = sys::FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME;
4153 }
4154 #[derive(Copy, Clone)]
4155 pub struct SpatialEntityFB {
4156 pub create_spatial_anchor: pfn::CreateSpatialAnchorFB,
4157 pub get_space_uuid: pfn::GetSpaceUuidFB,
4158 pub enumerate_space_supported_components: pfn::EnumerateSpaceSupportedComponentsFB,
4159 pub set_space_component_status: pfn::SetSpaceComponentStatusFB,
4160 pub get_space_component_status: pfn::GetSpaceComponentStatusFB,
4161 }
4162 impl SpatialEntityFB {
4163 pub const VERSION: u32 = sys::FB_spatial_entity_SPEC_VERSION;
4164 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_EXTENSION_NAME;
4165 #[doc = r" Load the extension's function pointer table"]
4166 #[doc = r""]
4167 #[doc = r" # Safety"]
4168 #[doc = r""]
4169 #[doc = r" `instance` must be a valid instance handle."]
4170 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4171 Ok(Self {
4172 create_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
4173 instance,
4174 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpatialAnchorFB\0"),
4175 )?),
4176 get_space_uuid: mem::transmute(entry.get_instance_proc_addr(
4177 instance,
4178 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceUuidFB\0"),
4179 )?),
4180 enumerate_space_supported_components: mem::transmute(
4181 entry.get_instance_proc_addr(
4182 instance,
4183 CStr::from_bytes_with_nul_unchecked(
4184 b"xrEnumerateSpaceSupportedComponentsFB\0",
4185 ),
4186 )?,
4187 ),
4188 set_space_component_status: mem::transmute(entry.get_instance_proc_addr(
4189 instance,
4190 CStr::from_bytes_with_nul_unchecked(b"xrSetSpaceComponentStatusFB\0"),
4191 )?),
4192 get_space_component_status: mem::transmute(entry.get_instance_proc_addr(
4193 instance,
4194 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceComponentStatusFB\0"),
4195 )?),
4196 })
4197 }
4198 }
4199 #[derive(Copy, Clone)]
4200 pub struct FoveationFB {
4201 pub create_foveation_profile: pfn::CreateFoveationProfileFB,
4202 pub destroy_foveation_profile: pfn::DestroyFoveationProfileFB,
4203 }
4204 impl FoveationFB {
4205 pub const VERSION: u32 = sys::FB_foveation_SPEC_VERSION;
4206 pub const NAME: &'static [u8] = sys::FB_FOVEATION_EXTENSION_NAME;
4207 #[doc = r" Load the extension's function pointer table"]
4208 #[doc = r""]
4209 #[doc = r" # Safety"]
4210 #[doc = r""]
4211 #[doc = r" `instance` must be a valid instance handle."]
4212 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4213 Ok(Self {
4214 create_foveation_profile: mem::transmute(entry.get_instance_proc_addr(
4215 instance,
4216 CStr::from_bytes_with_nul_unchecked(b"xrCreateFoveationProfileFB\0"),
4217 )?),
4218 destroy_foveation_profile: mem::transmute(entry.get_instance_proc_addr(
4219 instance,
4220 CStr::from_bytes_with_nul_unchecked(b"xrDestroyFoveationProfileFB\0"),
4221 )?),
4222 })
4223 }
4224 }
4225 #[derive(Copy, Clone)]
4226 pub struct FoveationConfigurationFB {}
4227 impl FoveationConfigurationFB {
4228 pub const VERSION: u32 = sys::FB_foveation_configuration_SPEC_VERSION;
4229 pub const NAME: &'static [u8] = sys::FB_FOVEATION_CONFIGURATION_EXTENSION_NAME;
4230 }
4231 #[derive(Copy, Clone)]
4232 pub struct KeyboardTrackingFB {
4233 pub query_system_tracked_keyboard: pfn::QuerySystemTrackedKeyboardFB,
4234 pub create_keyboard_space: pfn::CreateKeyboardSpaceFB,
4235 }
4236 impl KeyboardTrackingFB {
4237 pub const VERSION: u32 = sys::FB_keyboard_tracking_SPEC_VERSION;
4238 pub const NAME: &'static [u8] = sys::FB_KEYBOARD_TRACKING_EXTENSION_NAME;
4239 #[doc = r" Load the extension's function pointer table"]
4240 #[doc = r""]
4241 #[doc = r" # Safety"]
4242 #[doc = r""]
4243 #[doc = r" `instance` must be a valid instance handle."]
4244 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4245 Ok(Self {
4246 query_system_tracked_keyboard: mem::transmute(entry.get_instance_proc_addr(
4247 instance,
4248 CStr::from_bytes_with_nul_unchecked(b"xrQuerySystemTrackedKeyboardFB\0"),
4249 )?),
4250 create_keyboard_space: mem::transmute(entry.get_instance_proc_addr(
4251 instance,
4252 CStr::from_bytes_with_nul_unchecked(b"xrCreateKeyboardSpaceFB\0"),
4253 )?),
4254 })
4255 }
4256 }
4257 #[derive(Copy, Clone)]
4258 pub struct TriangleMeshFB {
4259 pub create_triangle_mesh: pfn::CreateTriangleMeshFB,
4260 pub destroy_triangle_mesh: pfn::DestroyTriangleMeshFB,
4261 pub triangle_mesh_get_vertex_buffer: pfn::TriangleMeshGetVertexBufferFB,
4262 pub triangle_mesh_get_index_buffer: pfn::TriangleMeshGetIndexBufferFB,
4263 pub triangle_mesh_begin_update: pfn::TriangleMeshBeginUpdateFB,
4264 pub triangle_mesh_end_update: pfn::TriangleMeshEndUpdateFB,
4265 pub triangle_mesh_begin_vertex_buffer_update: pfn::TriangleMeshBeginVertexBufferUpdateFB,
4266 pub triangle_mesh_end_vertex_buffer_update: pfn::TriangleMeshEndVertexBufferUpdateFB,
4267 }
4268 impl TriangleMeshFB {
4269 pub const VERSION: u32 = sys::FB_triangle_mesh_SPEC_VERSION;
4270 pub const NAME: &'static [u8] = sys::FB_TRIANGLE_MESH_EXTENSION_NAME;
4271 #[doc = r" Load the extension's function pointer table"]
4272 #[doc = r""]
4273 #[doc = r" # Safety"]
4274 #[doc = r""]
4275 #[doc = r" `instance` must be a valid instance handle."]
4276 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4277 Ok(Self {
4278 create_triangle_mesh: mem::transmute(entry.get_instance_proc_addr(
4279 instance,
4280 CStr::from_bytes_with_nul_unchecked(b"xrCreateTriangleMeshFB\0"),
4281 )?),
4282 destroy_triangle_mesh: mem::transmute(entry.get_instance_proc_addr(
4283 instance,
4284 CStr::from_bytes_with_nul_unchecked(b"xrDestroyTriangleMeshFB\0"),
4285 )?),
4286 triangle_mesh_get_vertex_buffer: mem::transmute(entry.get_instance_proc_addr(
4287 instance,
4288 CStr::from_bytes_with_nul_unchecked(b"xrTriangleMeshGetVertexBufferFB\0"),
4289 )?),
4290 triangle_mesh_get_index_buffer: mem::transmute(entry.get_instance_proc_addr(
4291 instance,
4292 CStr::from_bytes_with_nul_unchecked(b"xrTriangleMeshGetIndexBufferFB\0"),
4293 )?),
4294 triangle_mesh_begin_update: mem::transmute(entry.get_instance_proc_addr(
4295 instance,
4296 CStr::from_bytes_with_nul_unchecked(b"xrTriangleMeshBeginUpdateFB\0"),
4297 )?),
4298 triangle_mesh_end_update: mem::transmute(entry.get_instance_proc_addr(
4299 instance,
4300 CStr::from_bytes_with_nul_unchecked(b"xrTriangleMeshEndUpdateFB\0"),
4301 )?),
4302 triangle_mesh_begin_vertex_buffer_update: mem::transmute(
4303 entry.get_instance_proc_addr(
4304 instance,
4305 CStr::from_bytes_with_nul_unchecked(
4306 b"xrTriangleMeshBeginVertexBufferUpdateFB\0",
4307 ),
4308 )?,
4309 ),
4310 triangle_mesh_end_vertex_buffer_update: mem::transmute(
4311 entry.get_instance_proc_addr(
4312 instance,
4313 CStr::from_bytes_with_nul_unchecked(
4314 b"xrTriangleMeshEndVertexBufferUpdateFB\0",
4315 ),
4316 )?,
4317 ),
4318 })
4319 }
4320 }
4321 #[derive(Copy, Clone)]
4322 pub struct PassthroughFB {
4323 pub create_passthrough: pfn::CreatePassthroughFB,
4324 pub destroy_passthrough: pfn::DestroyPassthroughFB,
4325 pub passthrough_start: pfn::PassthroughStartFB,
4326 pub passthrough_pause: pfn::PassthroughPauseFB,
4327 pub create_passthrough_layer: pfn::CreatePassthroughLayerFB,
4328 pub destroy_passthrough_layer: pfn::DestroyPassthroughLayerFB,
4329 pub passthrough_layer_pause: pfn::PassthroughLayerPauseFB,
4330 pub passthrough_layer_resume: pfn::PassthroughLayerResumeFB,
4331 pub passthrough_layer_set_style: pfn::PassthroughLayerSetStyleFB,
4332 pub create_geometry_instance: pfn::CreateGeometryInstanceFB,
4333 pub destroy_geometry_instance: pfn::DestroyGeometryInstanceFB,
4334 pub geometry_instance_set_transform: pfn::GeometryInstanceSetTransformFB,
4335 }
4336 impl PassthroughFB {
4337 pub const VERSION: u32 = sys::FB_passthrough_SPEC_VERSION;
4338 pub const NAME: &'static [u8] = sys::FB_PASSTHROUGH_EXTENSION_NAME;
4339 #[doc = r" Load the extension's function pointer table"]
4340 #[doc = r""]
4341 #[doc = r" # Safety"]
4342 #[doc = r""]
4343 #[doc = r" `instance` must be a valid instance handle."]
4344 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4345 Ok(Self {
4346 create_passthrough: mem::transmute(entry.get_instance_proc_addr(
4347 instance,
4348 CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughFB\0"),
4349 )?),
4350 destroy_passthrough: mem::transmute(entry.get_instance_proc_addr(
4351 instance,
4352 CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughFB\0"),
4353 )?),
4354 passthrough_start: mem::transmute(entry.get_instance_proc_addr(
4355 instance,
4356 CStr::from_bytes_with_nul_unchecked(b"xrPassthroughStartFB\0"),
4357 )?),
4358 passthrough_pause: mem::transmute(entry.get_instance_proc_addr(
4359 instance,
4360 CStr::from_bytes_with_nul_unchecked(b"xrPassthroughPauseFB\0"),
4361 )?),
4362 create_passthrough_layer: mem::transmute(entry.get_instance_proc_addr(
4363 instance,
4364 CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughLayerFB\0"),
4365 )?),
4366 destroy_passthrough_layer: mem::transmute(entry.get_instance_proc_addr(
4367 instance,
4368 CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughLayerFB\0"),
4369 )?),
4370 passthrough_layer_pause: mem::transmute(entry.get_instance_proc_addr(
4371 instance,
4372 CStr::from_bytes_with_nul_unchecked(b"xrPassthroughLayerPauseFB\0"),
4373 )?),
4374 passthrough_layer_resume: mem::transmute(entry.get_instance_proc_addr(
4375 instance,
4376 CStr::from_bytes_with_nul_unchecked(b"xrPassthroughLayerResumeFB\0"),
4377 )?),
4378 passthrough_layer_set_style: mem::transmute(entry.get_instance_proc_addr(
4379 instance,
4380 CStr::from_bytes_with_nul_unchecked(b"xrPassthroughLayerSetStyleFB\0"),
4381 )?),
4382 create_geometry_instance: mem::transmute(entry.get_instance_proc_addr(
4383 instance,
4384 CStr::from_bytes_with_nul_unchecked(b"xrCreateGeometryInstanceFB\0"),
4385 )?),
4386 destroy_geometry_instance: mem::transmute(entry.get_instance_proc_addr(
4387 instance,
4388 CStr::from_bytes_with_nul_unchecked(b"xrDestroyGeometryInstanceFB\0"),
4389 )?),
4390 geometry_instance_set_transform: mem::transmute(entry.get_instance_proc_addr(
4391 instance,
4392 CStr::from_bytes_with_nul_unchecked(b"xrGeometryInstanceSetTransformFB\0"),
4393 )?),
4394 })
4395 }
4396 }
4397 #[derive(Copy, Clone)]
4398 pub struct RenderModelFB {
4399 pub enumerate_render_model_paths: pfn::EnumerateRenderModelPathsFB,
4400 pub get_render_model_properties: pfn::GetRenderModelPropertiesFB,
4401 pub load_render_model: pfn::LoadRenderModelFB,
4402 }
4403 impl RenderModelFB {
4404 pub const VERSION: u32 = sys::FB_render_model_SPEC_VERSION;
4405 pub const NAME: &'static [u8] = sys::FB_RENDER_MODEL_EXTENSION_NAME;
4406 #[doc = r" Load the extension's function pointer table"]
4407 #[doc = r""]
4408 #[doc = r" # Safety"]
4409 #[doc = r""]
4410 #[doc = r" `instance` must be a valid instance handle."]
4411 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4412 Ok(Self {
4413 enumerate_render_model_paths: mem::transmute(entry.get_instance_proc_addr(
4414 instance,
4415 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateRenderModelPathsFB\0"),
4416 )?),
4417 get_render_model_properties: mem::transmute(entry.get_instance_proc_addr(
4418 instance,
4419 CStr::from_bytes_with_nul_unchecked(b"xrGetRenderModelPropertiesFB\0"),
4420 )?),
4421 load_render_model: mem::transmute(entry.get_instance_proc_addr(
4422 instance,
4423 CStr::from_bytes_with_nul_unchecked(b"xrLoadRenderModelFB\0"),
4424 )?),
4425 })
4426 }
4427 }
4428 #[derive(Copy, Clone)]
4429 pub struct SpatialEntityQueryFB {
4430 pub query_spaces: pfn::QuerySpacesFB,
4431 pub retrieve_space_query_results: pfn::RetrieveSpaceQueryResultsFB,
4432 }
4433 impl SpatialEntityQueryFB {
4434 pub const VERSION: u32 = sys::FB_spatial_entity_query_SPEC_VERSION;
4435 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME;
4436 #[doc = r" Load the extension's function pointer table"]
4437 #[doc = r""]
4438 #[doc = r" # Safety"]
4439 #[doc = r""]
4440 #[doc = r" `instance` must be a valid instance handle."]
4441 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4442 Ok(Self {
4443 query_spaces: mem::transmute(entry.get_instance_proc_addr(
4444 instance,
4445 CStr::from_bytes_with_nul_unchecked(b"xrQuerySpacesFB\0"),
4446 )?),
4447 retrieve_space_query_results: mem::transmute(entry.get_instance_proc_addr(
4448 instance,
4449 CStr::from_bytes_with_nul_unchecked(b"xrRetrieveSpaceQueryResultsFB\0"),
4450 )?),
4451 })
4452 }
4453 }
4454 #[derive(Copy, Clone)]
4455 pub struct SpatialEntityStorageFB {
4456 pub save_space: pfn::SaveSpaceFB,
4457 pub erase_space: pfn::EraseSpaceFB,
4458 }
4459 impl SpatialEntityStorageFB {
4460 pub const VERSION: u32 = sys::FB_spatial_entity_storage_SPEC_VERSION;
4461 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_STORAGE_EXTENSION_NAME;
4462 #[doc = r" Load the extension's function pointer table"]
4463 #[doc = r""]
4464 #[doc = r" # Safety"]
4465 #[doc = r""]
4466 #[doc = r" `instance` must be a valid instance handle."]
4467 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4468 Ok(Self {
4469 save_space: mem::transmute(entry.get_instance_proc_addr(
4470 instance,
4471 CStr::from_bytes_with_nul_unchecked(b"xrSaveSpaceFB\0"),
4472 )?),
4473 erase_space: mem::transmute(entry.get_instance_proc_addr(
4474 instance,
4475 CStr::from_bytes_with_nul_unchecked(b"xrEraseSpaceFB\0"),
4476 )?),
4477 })
4478 }
4479 }
4480 #[derive(Copy, Clone)]
4481 pub struct FoveationVulkanFB {}
4482 impl FoveationVulkanFB {
4483 pub const VERSION: u32 = sys::FB_foveation_vulkan_SPEC_VERSION;
4484 pub const NAME: &'static [u8] = sys::FB_FOVEATION_VULKAN_EXTENSION_NAME;
4485 }
4486 #[cfg(target_os = "android")]
4487 #[derive(Copy, Clone)]
4488 pub struct SwapchainUpdateStateAndroidSurfaceFB {}
4489 #[cfg(target_os = "android")]
4490 impl SwapchainUpdateStateAndroidSurfaceFB {
4491 pub const VERSION: u32 = sys::FB_swapchain_update_state_android_surface_SPEC_VERSION;
4492 pub const NAME: &'static [u8] =
4493 sys::FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME;
4494 }
4495 #[derive(Copy, Clone)]
4496 pub struct SwapchainUpdateStateOpenglEsFB {}
4497 impl SwapchainUpdateStateOpenglEsFB {
4498 pub const VERSION: u32 = sys::FB_swapchain_update_state_opengl_es_SPEC_VERSION;
4499 pub const NAME: &'static [u8] = sys::FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME;
4500 }
4501 #[derive(Copy, Clone)]
4502 pub struct SwapchainUpdateStateVulkanFB {}
4503 impl SwapchainUpdateStateVulkanFB {
4504 pub const VERSION: u32 = sys::FB_swapchain_update_state_vulkan_SPEC_VERSION;
4505 pub const NAME: &'static [u8] = sys::FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME;
4506 }
4507 #[derive(Copy, Clone)]
4508 pub struct TouchControllerProFB {}
4509 impl TouchControllerProFB {
4510 pub const VERSION: u32 = sys::FB_touch_controller_pro_SPEC_VERSION;
4511 pub const NAME: &'static [u8] = sys::FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME;
4512 }
4513 #[derive(Copy, Clone)]
4514 pub struct SpatialEntitySharingFB {
4515 pub share_spaces: pfn::ShareSpacesFB,
4516 }
4517 impl SpatialEntitySharingFB {
4518 pub const VERSION: u32 = sys::FB_spatial_entity_sharing_SPEC_VERSION;
4519 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME;
4520 #[doc = r" Load the extension's function pointer table"]
4521 #[doc = r""]
4522 #[doc = r" # Safety"]
4523 #[doc = r""]
4524 #[doc = r" `instance` must be a valid instance handle."]
4525 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4526 Ok(Self {
4527 share_spaces: mem::transmute(entry.get_instance_proc_addr(
4528 instance,
4529 CStr::from_bytes_with_nul_unchecked(b"xrShareSpacesFB\0"),
4530 )?),
4531 })
4532 }
4533 }
4534 #[derive(Copy, Clone)]
4535 pub struct SpaceWarpFB {}
4536 impl SpaceWarpFB {
4537 pub const VERSION: u32 = sys::FB_space_warp_SPEC_VERSION;
4538 pub const NAME: &'static [u8] = sys::FB_SPACE_WARP_EXTENSION_NAME;
4539 }
4540 #[derive(Copy, Clone)]
4541 pub struct HapticAmplitudeEnvelopeFB {}
4542 impl HapticAmplitudeEnvelopeFB {
4543 pub const VERSION: u32 = sys::FB_haptic_amplitude_envelope_SPEC_VERSION;
4544 pub const NAME: &'static [u8] = sys::FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME;
4545 }
4546 #[derive(Copy, Clone)]
4547 pub struct SceneFB {
4548 pub get_space_bounding_box2_d: pfn::GetSpaceBoundingBox2DFB,
4549 pub get_space_bounding_box3_d: pfn::GetSpaceBoundingBox3DFB,
4550 pub get_space_semantic_labels: pfn::GetSpaceSemanticLabelsFB,
4551 pub get_space_boundary2_d: pfn::GetSpaceBoundary2DFB,
4552 pub get_space_room_layout: pfn::GetSpaceRoomLayoutFB,
4553 }
4554 impl SceneFB {
4555 pub const VERSION: u32 = sys::FB_scene_SPEC_VERSION;
4556 pub const NAME: &'static [u8] = sys::FB_SCENE_EXTENSION_NAME;
4557 #[doc = r" Load the extension's function pointer table"]
4558 #[doc = r""]
4559 #[doc = r" # Safety"]
4560 #[doc = r""]
4561 #[doc = r" `instance` must be a valid instance handle."]
4562 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4563 Ok(Self {
4564 get_space_bounding_box2_d: mem::transmute(entry.get_instance_proc_addr(
4565 instance,
4566 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceBoundingBox2DFB\0"),
4567 )?),
4568 get_space_bounding_box3_d: mem::transmute(entry.get_instance_proc_addr(
4569 instance,
4570 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceBoundingBox3DFB\0"),
4571 )?),
4572 get_space_semantic_labels: mem::transmute(entry.get_instance_proc_addr(
4573 instance,
4574 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceSemanticLabelsFB\0"),
4575 )?),
4576 get_space_boundary2_d: mem::transmute(entry.get_instance_proc_addr(
4577 instance,
4578 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceBoundary2DFB\0"),
4579 )?),
4580 get_space_room_layout: mem::transmute(entry.get_instance_proc_addr(
4581 instance,
4582 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceRoomLayoutFB\0"),
4583 )?),
4584 })
4585 }
4586 }
4587 #[derive(Copy, Clone)]
4588 pub struct SceneCaptureFB {
4589 pub request_scene_capture: pfn::RequestSceneCaptureFB,
4590 }
4591 impl SceneCaptureFB {
4592 pub const VERSION: u32 = sys::FB_scene_capture_SPEC_VERSION;
4593 pub const NAME: &'static [u8] = sys::FB_SCENE_CAPTURE_EXTENSION_NAME;
4594 #[doc = r" Load the extension's function pointer table"]
4595 #[doc = r""]
4596 #[doc = r" # Safety"]
4597 #[doc = r""]
4598 #[doc = r" `instance` must be a valid instance handle."]
4599 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4600 Ok(Self {
4601 request_scene_capture: mem::transmute(entry.get_instance_proc_addr(
4602 instance,
4603 CStr::from_bytes_with_nul_unchecked(b"xrRequestSceneCaptureFB\0"),
4604 )?),
4605 })
4606 }
4607 }
4608 #[derive(Copy, Clone)]
4609 pub struct SpatialEntityContainerFB {
4610 pub get_space_container: pfn::GetSpaceContainerFB,
4611 }
4612 impl SpatialEntityContainerFB {
4613 pub const VERSION: u32 = sys::FB_spatial_entity_container_SPEC_VERSION;
4614 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME;
4615 #[doc = r" Load the extension's function pointer table"]
4616 #[doc = r""]
4617 #[doc = r" # Safety"]
4618 #[doc = r""]
4619 #[doc = r" `instance` must be a valid instance handle."]
4620 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4621 Ok(Self {
4622 get_space_container: mem::transmute(entry.get_instance_proc_addr(
4623 instance,
4624 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceContainerFB\0"),
4625 )?),
4626 })
4627 }
4628 }
4629 #[derive(Copy, Clone)]
4630 pub struct FaceTrackingFB {
4631 pub create_face_tracker: pfn::CreateFaceTrackerFB,
4632 pub destroy_face_tracker: pfn::DestroyFaceTrackerFB,
4633 pub get_face_expression_weights: pfn::GetFaceExpressionWeightsFB,
4634 }
4635 impl FaceTrackingFB {
4636 pub const VERSION: u32 = sys::FB_face_tracking_SPEC_VERSION;
4637 pub const NAME: &'static [u8] = sys::FB_FACE_TRACKING_EXTENSION_NAME;
4638 #[doc = r" Load the extension's function pointer table"]
4639 #[doc = r""]
4640 #[doc = r" # Safety"]
4641 #[doc = r""]
4642 #[doc = r" `instance` must be a valid instance handle."]
4643 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4644 Ok(Self {
4645 create_face_tracker: mem::transmute(entry.get_instance_proc_addr(
4646 instance,
4647 CStr::from_bytes_with_nul_unchecked(b"xrCreateFaceTrackerFB\0"),
4648 )?),
4649 destroy_face_tracker: mem::transmute(entry.get_instance_proc_addr(
4650 instance,
4651 CStr::from_bytes_with_nul_unchecked(b"xrDestroyFaceTrackerFB\0"),
4652 )?),
4653 get_face_expression_weights: mem::transmute(entry.get_instance_proc_addr(
4654 instance,
4655 CStr::from_bytes_with_nul_unchecked(b"xrGetFaceExpressionWeightsFB\0"),
4656 )?),
4657 })
4658 }
4659 }
4660 #[derive(Copy, Clone)]
4661 pub struct EyeTrackingSocialFB {
4662 pub create_eye_tracker: pfn::CreateEyeTrackerFB,
4663 pub destroy_eye_tracker: pfn::DestroyEyeTrackerFB,
4664 pub get_eye_gazes: pfn::GetEyeGazesFB,
4665 }
4666 impl EyeTrackingSocialFB {
4667 pub const VERSION: u32 = sys::FB_eye_tracking_social_SPEC_VERSION;
4668 pub const NAME: &'static [u8] = sys::FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME;
4669 #[doc = r" Load the extension's function pointer table"]
4670 #[doc = r""]
4671 #[doc = r" # Safety"]
4672 #[doc = r""]
4673 #[doc = r" `instance` must be a valid instance handle."]
4674 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4675 Ok(Self {
4676 create_eye_tracker: mem::transmute(entry.get_instance_proc_addr(
4677 instance,
4678 CStr::from_bytes_with_nul_unchecked(b"xrCreateEyeTrackerFB\0"),
4679 )?),
4680 destroy_eye_tracker: mem::transmute(entry.get_instance_proc_addr(
4681 instance,
4682 CStr::from_bytes_with_nul_unchecked(b"xrDestroyEyeTrackerFB\0"),
4683 )?),
4684 get_eye_gazes: mem::transmute(entry.get_instance_proc_addr(
4685 instance,
4686 CStr::from_bytes_with_nul_unchecked(b"xrGetEyeGazesFB\0"),
4687 )?),
4688 })
4689 }
4690 }
4691 #[derive(Copy, Clone)]
4692 pub struct PassthroughKeyboardHandsFB {
4693 pub passthrough_layer_set_keyboard_hands_intensity:
4694 pfn::PassthroughLayerSetKeyboardHandsIntensityFB,
4695 }
4696 impl PassthroughKeyboardHandsFB {
4697 pub const VERSION: u32 = sys::FB_passthrough_keyboard_hands_SPEC_VERSION;
4698 pub const NAME: &'static [u8] = sys::FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME;
4699 #[doc = r" Load the extension's function pointer table"]
4700 #[doc = r""]
4701 #[doc = r" # Safety"]
4702 #[doc = r""]
4703 #[doc = r" `instance` must be a valid instance handle."]
4704 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4705 Ok(Self {
4706 passthrough_layer_set_keyboard_hands_intensity: mem::transmute(
4707 entry.get_instance_proc_addr(
4708 instance,
4709 CStr::from_bytes_with_nul_unchecked(
4710 b"xrPassthroughLayerSetKeyboardHandsIntensityFB\0",
4711 ),
4712 )?,
4713 ),
4714 })
4715 }
4716 }
4717 #[derive(Copy, Clone)]
4718 pub struct CompositionLayerSettingsFB {}
4719 impl CompositionLayerSettingsFB {
4720 pub const VERSION: u32 = sys::FB_composition_layer_settings_SPEC_VERSION;
4721 pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME;
4722 }
4723 #[derive(Copy, Clone)]
4724 pub struct TouchControllerProximityFB {}
4725 impl TouchControllerProximityFB {
4726 pub const VERSION: u32 = sys::FB_touch_controller_proximity_SPEC_VERSION;
4727 pub const NAME: &'static [u8] = sys::FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME;
4728 }
4729 #[derive(Copy, Clone)]
4730 pub struct HapticPcmFB {
4731 pub get_device_sample_rate: pfn::GetDeviceSampleRateFB,
4732 }
4733 impl HapticPcmFB {
4734 pub const VERSION: u32 = sys::FB_haptic_pcm_SPEC_VERSION;
4735 pub const NAME: &'static [u8] = sys::FB_HAPTIC_PCM_EXTENSION_NAME;
4736 #[doc = r" Load the extension's function pointer table"]
4737 #[doc = r""]
4738 #[doc = r" # Safety"]
4739 #[doc = r""]
4740 #[doc = r" `instance` must be a valid instance handle."]
4741 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4742 Ok(Self {
4743 get_device_sample_rate: mem::transmute(entry.get_instance_proc_addr(
4744 instance,
4745 CStr::from_bytes_with_nul_unchecked(b"xrGetDeviceSampleRateFB\0"),
4746 )?),
4747 })
4748 }
4749 }
4750 #[derive(Copy, Clone)]
4751 pub struct CompositionLayerDepthTestFB {}
4752 impl CompositionLayerDepthTestFB {
4753 pub const VERSION: u32 = sys::FB_composition_layer_depth_test_SPEC_VERSION;
4754 pub const NAME: &'static [u8] = sys::FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME;
4755 }
4756 #[derive(Copy, Clone)]
4757 pub struct SpatialEntityStorageBatchFB {
4758 pub save_space_list: pfn::SaveSpaceListFB,
4759 }
4760 impl SpatialEntityStorageBatchFB {
4761 pub const VERSION: u32 = sys::FB_spatial_entity_storage_batch_SPEC_VERSION;
4762 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME;
4763 #[doc = r" Load the extension's function pointer table"]
4764 #[doc = r""]
4765 #[doc = r" # Safety"]
4766 #[doc = r""]
4767 #[doc = r" `instance` must be a valid instance handle."]
4768 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4769 Ok(Self {
4770 save_space_list: mem::transmute(entry.get_instance_proc_addr(
4771 instance,
4772 CStr::from_bytes_with_nul_unchecked(b"xrSaveSpaceListFB\0"),
4773 )?),
4774 })
4775 }
4776 }
4777 #[derive(Copy, Clone)]
4778 pub struct SpatialEntityUserFB {
4779 pub create_space_user: pfn::CreateSpaceUserFB,
4780 pub get_space_user_id: pfn::GetSpaceUserIdFB,
4781 pub destroy_space_user: pfn::DestroySpaceUserFB,
4782 }
4783 impl SpatialEntityUserFB {
4784 pub const VERSION: u32 = sys::FB_spatial_entity_user_SPEC_VERSION;
4785 pub const NAME: &'static [u8] = sys::FB_SPATIAL_ENTITY_USER_EXTENSION_NAME;
4786 #[doc = r" Load the extension's function pointer table"]
4787 #[doc = r""]
4788 #[doc = r" # Safety"]
4789 #[doc = r""]
4790 #[doc = r" `instance` must be a valid instance handle."]
4791 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4792 Ok(Self {
4793 create_space_user: mem::transmute(entry.get_instance_proc_addr(
4794 instance,
4795 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpaceUserFB\0"),
4796 )?),
4797 get_space_user_id: mem::transmute(entry.get_instance_proc_addr(
4798 instance,
4799 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceUserIdFB\0"),
4800 )?),
4801 destroy_space_user: mem::transmute(entry.get_instance_proc_addr(
4802 instance,
4803 CStr::from_bytes_with_nul_unchecked(b"xrDestroySpaceUserFB\0"),
4804 )?),
4805 })
4806 }
4807 }
4808 #[derive(Copy, Clone)]
4809 pub struct FaceTracking2FB {
4810 pub create_face_tracker2: pfn::CreateFaceTracker2FB,
4811 pub destroy_face_tracker2: pfn::DestroyFaceTracker2FB,
4812 pub get_face_expression_weights2: pfn::GetFaceExpressionWeights2FB,
4813 }
4814 impl FaceTracking2FB {
4815 pub const VERSION: u32 = sys::FB_face_tracking2_SPEC_VERSION;
4816 pub const NAME: &'static [u8] = sys::FB_FACE_TRACKING2_EXTENSION_NAME;
4817 #[doc = r" Load the extension's function pointer table"]
4818 #[doc = r""]
4819 #[doc = r" # Safety"]
4820 #[doc = r""]
4821 #[doc = r" `instance` must be a valid instance handle."]
4822 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4823 Ok(Self {
4824 create_face_tracker2: mem::transmute(entry.get_instance_proc_addr(
4825 instance,
4826 CStr::from_bytes_with_nul_unchecked(b"xrCreateFaceTracker2FB\0"),
4827 )?),
4828 destroy_face_tracker2: mem::transmute(entry.get_instance_proc_addr(
4829 instance,
4830 CStr::from_bytes_with_nul_unchecked(b"xrDestroyFaceTracker2FB\0"),
4831 )?),
4832 get_face_expression_weights2: mem::transmute(entry.get_instance_proc_addr(
4833 instance,
4834 CStr::from_bytes_with_nul_unchecked(b"xrGetFaceExpressionWeights2FB\0"),
4835 )?),
4836 })
4837 }
4838 }
4839 #[derive(Copy, Clone)]
4840 pub struct ViveCosmosControllerInteractionHTC {}
4841 impl ViveCosmosControllerInteractionHTC {
4842 pub const VERSION: u32 = sys::HTC_vive_cosmos_controller_interaction_SPEC_VERSION;
4843 pub const NAME: &'static [u8] = sys::HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME;
4844 }
4845 #[derive(Copy, Clone)]
4846 pub struct FacialTrackingHTC {
4847 pub create_facial_tracker: pfn::CreateFacialTrackerHTC,
4848 pub destroy_facial_tracker: pfn::DestroyFacialTrackerHTC,
4849 pub get_facial_expressions: pfn::GetFacialExpressionsHTC,
4850 }
4851 impl FacialTrackingHTC {
4852 pub const VERSION: u32 = sys::HTC_facial_tracking_SPEC_VERSION;
4853 pub const NAME: &'static [u8] = sys::HTC_FACIAL_TRACKING_EXTENSION_NAME;
4854 #[doc = r" Load the extension's function pointer table"]
4855 #[doc = r""]
4856 #[doc = r" # Safety"]
4857 #[doc = r""]
4858 #[doc = r" `instance` must be a valid instance handle."]
4859 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4860 Ok(Self {
4861 create_facial_tracker: mem::transmute(entry.get_instance_proc_addr(
4862 instance,
4863 CStr::from_bytes_with_nul_unchecked(b"xrCreateFacialTrackerHTC\0"),
4864 )?),
4865 destroy_facial_tracker: mem::transmute(entry.get_instance_proc_addr(
4866 instance,
4867 CStr::from_bytes_with_nul_unchecked(b"xrDestroyFacialTrackerHTC\0"),
4868 )?),
4869 get_facial_expressions: mem::transmute(entry.get_instance_proc_addr(
4870 instance,
4871 CStr::from_bytes_with_nul_unchecked(b"xrGetFacialExpressionsHTC\0"),
4872 )?),
4873 })
4874 }
4875 }
4876 #[derive(Copy, Clone)]
4877 pub struct ViveFocus3ControllerInteractionHTC {}
4878 impl ViveFocus3ControllerInteractionHTC {
4879 pub const VERSION: u32 = sys::HTC_vive_focus3_controller_interaction_SPEC_VERSION;
4880 pub const NAME: &'static [u8] = sys::HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME;
4881 }
4882 #[derive(Copy, Clone)]
4883 pub struct HandInteractionHTC {}
4884 impl HandInteractionHTC {
4885 pub const VERSION: u32 = sys::HTC_hand_interaction_SPEC_VERSION;
4886 pub const NAME: &'static [u8] = sys::HTC_HAND_INTERACTION_EXTENSION_NAME;
4887 }
4888 #[derive(Copy, Clone)]
4889 pub struct ViveWristTrackerInteractionHTC {}
4890 impl ViveWristTrackerInteractionHTC {
4891 pub const VERSION: u32 = sys::HTC_vive_wrist_tracker_interaction_SPEC_VERSION;
4892 pub const NAME: &'static [u8] = sys::HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME;
4893 }
4894 #[derive(Copy, Clone)]
4895 pub struct PassthroughHTC {
4896 pub create_passthrough: pfn::CreatePassthroughHTC,
4897 pub destroy_passthrough: pfn::DestroyPassthroughHTC,
4898 }
4899 impl PassthroughHTC {
4900 pub const VERSION: u32 = sys::HTC_passthrough_SPEC_VERSION;
4901 pub const NAME: &'static [u8] = sys::HTC_PASSTHROUGH_EXTENSION_NAME;
4902 #[doc = r" Load the extension's function pointer table"]
4903 #[doc = r""]
4904 #[doc = r" # Safety"]
4905 #[doc = r""]
4906 #[doc = r" `instance` must be a valid instance handle."]
4907 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4908 Ok(Self {
4909 create_passthrough: mem::transmute(entry.get_instance_proc_addr(
4910 instance,
4911 CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughHTC\0"),
4912 )?),
4913 destroy_passthrough: mem::transmute(entry.get_instance_proc_addr(
4914 instance,
4915 CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughHTC\0"),
4916 )?),
4917 })
4918 }
4919 }
4920 #[derive(Copy, Clone)]
4921 pub struct FoveationHTC {
4922 pub apply_foveation: pfn::ApplyFoveationHTC,
4923 }
4924 impl FoveationHTC {
4925 pub const VERSION: u32 = sys::HTC_foveation_SPEC_VERSION;
4926 pub const NAME: &'static [u8] = sys::HTC_FOVEATION_EXTENSION_NAME;
4927 #[doc = r" Load the extension's function pointer table"]
4928 #[doc = r""]
4929 #[doc = r" # Safety"]
4930 #[doc = r""]
4931 #[doc = r" `instance` must be a valid instance handle."]
4932 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4933 Ok(Self {
4934 apply_foveation: mem::transmute(entry.get_instance_proc_addr(
4935 instance,
4936 CStr::from_bytes_with_nul_unchecked(b"xrApplyFoveationHTC\0"),
4937 )?),
4938 })
4939 }
4940 }
4941 #[derive(Copy, Clone)]
4942 pub struct AnchorHTC {
4943 pub create_spatial_anchor: pfn::CreateSpatialAnchorHTC,
4944 pub get_spatial_anchor_name: pfn::GetSpatialAnchorNameHTC,
4945 }
4946 impl AnchorHTC {
4947 pub const VERSION: u32 = sys::HTC_anchor_SPEC_VERSION;
4948 pub const NAME: &'static [u8] = sys::HTC_ANCHOR_EXTENSION_NAME;
4949 #[doc = r" Load the extension's function pointer table"]
4950 #[doc = r""]
4951 #[doc = r" # Safety"]
4952 #[doc = r""]
4953 #[doc = r" `instance` must be a valid instance handle."]
4954 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4955 Ok(Self {
4956 create_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
4957 instance,
4958 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpatialAnchorHTC\0"),
4959 )?),
4960 get_spatial_anchor_name: mem::transmute(entry.get_instance_proc_addr(
4961 instance,
4962 CStr::from_bytes_with_nul_unchecked(b"xrGetSpatialAnchorNameHTC\0"),
4963 )?),
4964 })
4965 }
4966 }
4967 #[derive(Copy, Clone)]
4968 pub struct ControllerInteractionHUAWEI {}
4969 impl ControllerInteractionHUAWEI {
4970 pub const VERSION: u32 = sys::HUAWEI_controller_interaction_SPEC_VERSION;
4971 pub const NAME: &'static [u8] = sys::HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME;
4972 }
4973 #[cfg(target_os = "android")]
4974 #[derive(Copy, Clone)]
4975 pub struct AndroidThreadSettingsKHR {
4976 pub set_android_application_thread: pfn::SetAndroidApplicationThreadKHR,
4977 }
4978 #[cfg(target_os = "android")]
4979 impl AndroidThreadSettingsKHR {
4980 pub const VERSION: u32 = sys::KHR_android_thread_settings_SPEC_VERSION;
4981 pub const NAME: &'static [u8] = sys::KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME;
4982 #[doc = r" Load the extension's function pointer table"]
4983 #[doc = r""]
4984 #[doc = r" # Safety"]
4985 #[doc = r""]
4986 #[doc = r" `instance` must be a valid instance handle."]
4987 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
4988 Ok(Self {
4989 set_android_application_thread: mem::transmute(entry.get_instance_proc_addr(
4990 instance,
4991 CStr::from_bytes_with_nul_unchecked(b"xrSetAndroidApplicationThreadKHR\0"),
4992 )?),
4993 })
4994 }
4995 }
4996 #[cfg(target_os = "android")]
4997 #[derive(Copy, Clone)]
4998 pub struct AndroidSurfaceSwapchainKHR {
4999 pub create_swapchain_android_surface: pfn::CreateSwapchainAndroidSurfaceKHR,
5000 }
5001 #[cfg(target_os = "android")]
5002 impl AndroidSurfaceSwapchainKHR {
5003 pub const VERSION: u32 = sys::KHR_android_surface_swapchain_SPEC_VERSION;
5004 pub const NAME: &'static [u8] = sys::KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME;
5005 #[doc = r" Load the extension's function pointer table"]
5006 #[doc = r""]
5007 #[doc = r" # Safety"]
5008 #[doc = r""]
5009 #[doc = r" `instance` must be a valid instance handle."]
5010 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5011 Ok(Self {
5012 create_swapchain_android_surface: mem::transmute(entry.get_instance_proc_addr(
5013 instance,
5014 CStr::from_bytes_with_nul_unchecked(b"xrCreateSwapchainAndroidSurfaceKHR\0"),
5015 )?),
5016 })
5017 }
5018 }
5019 #[derive(Copy, Clone)]
5020 pub struct CompositionLayerCubeKHR {}
5021 impl CompositionLayerCubeKHR {
5022 pub const VERSION: u32 = sys::KHR_composition_layer_cube_SPEC_VERSION;
5023 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME;
5024 }
5025 #[cfg(target_os = "android")]
5026 #[derive(Copy, Clone)]
5027 pub struct AndroidCreateInstanceKHR {}
5028 #[cfg(target_os = "android")]
5029 impl AndroidCreateInstanceKHR {
5030 pub const VERSION: u32 = sys::KHR_android_create_instance_SPEC_VERSION;
5031 pub const NAME: &'static [u8] = sys::KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME;
5032 }
5033 #[derive(Copy, Clone)]
5034 pub struct CompositionLayerDepthKHR {}
5035 impl CompositionLayerDepthKHR {
5036 pub const VERSION: u32 = sys::KHR_composition_layer_depth_SPEC_VERSION;
5037 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME;
5038 }
5039 #[derive(Copy, Clone)]
5040 pub struct VulkanSwapchainFormatListKHR {}
5041 impl VulkanSwapchainFormatListKHR {
5042 pub const VERSION: u32 = sys::KHR_vulkan_swapchain_format_list_SPEC_VERSION;
5043 pub const NAME: &'static [u8] = sys::KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME;
5044 }
5045 #[derive(Copy, Clone)]
5046 pub struct CompositionLayerCylinderKHR {}
5047 impl CompositionLayerCylinderKHR {
5048 pub const VERSION: u32 = sys::KHR_composition_layer_cylinder_SPEC_VERSION;
5049 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME;
5050 }
5051 #[derive(Copy, Clone)]
5052 pub struct CompositionLayerEquirectKHR {}
5053 impl CompositionLayerEquirectKHR {
5054 pub const VERSION: u32 = sys::KHR_composition_layer_equirect_SPEC_VERSION;
5055 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME;
5056 }
5057 #[derive(Copy, Clone)]
5058 pub struct OpenglEnableKHR {
5059 pub get_open_gl_graphics_requirements: pfn::GetOpenGLGraphicsRequirementsKHR,
5060 }
5061 impl OpenglEnableKHR {
5062 pub const VERSION: u32 = sys::KHR_opengl_enable_SPEC_VERSION;
5063 pub const NAME: &'static [u8] = sys::KHR_OPENGL_ENABLE_EXTENSION_NAME;
5064 #[doc = r" Load the extension's function pointer table"]
5065 #[doc = r""]
5066 #[doc = r" # Safety"]
5067 #[doc = r""]
5068 #[doc = r" `instance` must be a valid instance handle."]
5069 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5070 Ok(Self {
5071 get_open_gl_graphics_requirements: mem::transmute(entry.get_instance_proc_addr(
5072 instance,
5073 CStr::from_bytes_with_nul_unchecked(b"xrGetOpenGLGraphicsRequirementsKHR\0"),
5074 )?),
5075 })
5076 }
5077 }
5078 #[derive(Copy, Clone)]
5079 pub struct OpenglEsEnableKHR {
5080 pub get_open_gles_graphics_requirements: pfn::GetOpenGLESGraphicsRequirementsKHR,
5081 }
5082 impl OpenglEsEnableKHR {
5083 pub const VERSION: u32 = sys::KHR_opengl_es_enable_SPEC_VERSION;
5084 pub const NAME: &'static [u8] = sys::KHR_OPENGL_ES_ENABLE_EXTENSION_NAME;
5085 #[doc = r" Load the extension's function pointer table"]
5086 #[doc = r""]
5087 #[doc = r" # Safety"]
5088 #[doc = r""]
5089 #[doc = r" `instance` must be a valid instance handle."]
5090 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5091 Ok(Self {
5092 get_open_gles_graphics_requirements: mem::transmute(entry.get_instance_proc_addr(
5093 instance,
5094 CStr::from_bytes_with_nul_unchecked(b"xrGetOpenGLESGraphicsRequirementsKHR\0"),
5095 )?),
5096 })
5097 }
5098 }
5099 #[derive(Copy, Clone)]
5100 pub struct VulkanEnableKHR {
5101 pub get_vulkan_instance_extensions: pfn::GetVulkanInstanceExtensionsKHR,
5102 pub get_vulkan_device_extensions: pfn::GetVulkanDeviceExtensionsKHR,
5103 pub get_vulkan_graphics_device: pfn::GetVulkanGraphicsDeviceKHR,
5104 pub get_vulkan_graphics_requirements: pfn::GetVulkanGraphicsRequirementsKHR,
5105 }
5106 impl VulkanEnableKHR {
5107 pub const VERSION: u32 = sys::KHR_vulkan_enable_SPEC_VERSION;
5108 pub const NAME: &'static [u8] = sys::KHR_VULKAN_ENABLE_EXTENSION_NAME;
5109 #[doc = r" Load the extension's function pointer table"]
5110 #[doc = r""]
5111 #[doc = r" # Safety"]
5112 #[doc = r""]
5113 #[doc = r" `instance` must be a valid instance handle."]
5114 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5115 Ok(Self {
5116 get_vulkan_instance_extensions: mem::transmute(entry.get_instance_proc_addr(
5117 instance,
5118 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanInstanceExtensionsKHR\0"),
5119 )?),
5120 get_vulkan_device_extensions: mem::transmute(entry.get_instance_proc_addr(
5121 instance,
5122 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanDeviceExtensionsKHR\0"),
5123 )?),
5124 get_vulkan_graphics_device: mem::transmute(entry.get_instance_proc_addr(
5125 instance,
5126 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanGraphicsDeviceKHR\0"),
5127 )?),
5128 get_vulkan_graphics_requirements: mem::transmute(entry.get_instance_proc_addr(
5129 instance,
5130 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanGraphicsRequirementsKHR\0"),
5131 )?),
5132 })
5133 }
5134 }
5135 #[cfg(windows)]
5136 #[derive(Copy, Clone)]
5137 pub struct D3d11EnableKHR {
5138 pub get_d3d11_graphics_requirements: pfn::GetD3D11GraphicsRequirementsKHR,
5139 }
5140 #[cfg(windows)]
5141 impl D3d11EnableKHR {
5142 pub const VERSION: u32 = sys::KHR_D3D11_enable_SPEC_VERSION;
5143 pub const NAME: &'static [u8] = sys::KHR_D3D11_ENABLE_EXTENSION_NAME;
5144 #[doc = r" Load the extension's function pointer table"]
5145 #[doc = r""]
5146 #[doc = r" # Safety"]
5147 #[doc = r""]
5148 #[doc = r" `instance` must be a valid instance handle."]
5149 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5150 Ok(Self {
5151 get_d3d11_graphics_requirements: mem::transmute(entry.get_instance_proc_addr(
5152 instance,
5153 CStr::from_bytes_with_nul_unchecked(b"xrGetD3D11GraphicsRequirementsKHR\0"),
5154 )?),
5155 })
5156 }
5157 }
5158 #[cfg(windows)]
5159 #[derive(Copy, Clone)]
5160 pub struct D3d12EnableKHR {
5161 pub get_d3d12_graphics_requirements: pfn::GetD3D12GraphicsRequirementsKHR,
5162 }
5163 #[cfg(windows)]
5164 impl D3d12EnableKHR {
5165 pub const VERSION: u32 = sys::KHR_D3D12_enable_SPEC_VERSION;
5166 pub const NAME: &'static [u8] = sys::KHR_D3D12_ENABLE_EXTENSION_NAME;
5167 #[doc = r" Load the extension's function pointer table"]
5168 #[doc = r""]
5169 #[doc = r" # Safety"]
5170 #[doc = r""]
5171 #[doc = r" `instance` must be a valid instance handle."]
5172 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5173 Ok(Self {
5174 get_d3d12_graphics_requirements: mem::transmute(entry.get_instance_proc_addr(
5175 instance,
5176 CStr::from_bytes_with_nul_unchecked(b"xrGetD3D12GraphicsRequirementsKHR\0"),
5177 )?),
5178 })
5179 }
5180 }
5181 #[derive(Copy, Clone)]
5182 pub struct VisibilityMaskKHR {
5183 pub get_visibility_mask: pfn::GetVisibilityMaskKHR,
5184 }
5185 impl VisibilityMaskKHR {
5186 pub const VERSION: u32 = sys::KHR_visibility_mask_SPEC_VERSION;
5187 pub const NAME: &'static [u8] = sys::KHR_VISIBILITY_MASK_EXTENSION_NAME;
5188 #[doc = r" Load the extension's function pointer table"]
5189 #[doc = r""]
5190 #[doc = r" # Safety"]
5191 #[doc = r""]
5192 #[doc = r" `instance` must be a valid instance handle."]
5193 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5194 Ok(Self {
5195 get_visibility_mask: mem::transmute(entry.get_instance_proc_addr(
5196 instance,
5197 CStr::from_bytes_with_nul_unchecked(b"xrGetVisibilityMaskKHR\0"),
5198 )?),
5199 })
5200 }
5201 }
5202 #[derive(Copy, Clone)]
5203 pub struct CompositionLayerColorScaleBiasKHR {}
5204 impl CompositionLayerColorScaleBiasKHR {
5205 pub const VERSION: u32 = sys::KHR_composition_layer_color_scale_bias_SPEC_VERSION;
5206 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME;
5207 }
5208 #[cfg(windows)]
5209 #[derive(Copy, Clone)]
5210 pub struct Win32ConvertPerformanceCounterTimeKHR {
5211 pub convert_win32_performance_counter_to_time: pfn::ConvertWin32PerformanceCounterToTimeKHR,
5212 pub convert_time_to_win32_performance_counter: pfn::ConvertTimeToWin32PerformanceCounterKHR,
5213 }
5214 #[cfg(windows)]
5215 impl Win32ConvertPerformanceCounterTimeKHR {
5216 pub const VERSION: u32 = sys::KHR_win32_convert_performance_counter_time_SPEC_VERSION;
5217 pub const NAME: &'static [u8] =
5218 sys::KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME;
5219 #[doc = r" Load the extension's function pointer table"]
5220 #[doc = r""]
5221 #[doc = r" # Safety"]
5222 #[doc = r""]
5223 #[doc = r" `instance` must be a valid instance handle."]
5224 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5225 Ok(Self {
5226 convert_win32_performance_counter_to_time: mem::transmute(
5227 entry.get_instance_proc_addr(
5228 instance,
5229 CStr::from_bytes_with_nul_unchecked(
5230 b"xrConvertWin32PerformanceCounterToTimeKHR\0",
5231 ),
5232 )?,
5233 ),
5234 convert_time_to_win32_performance_counter: mem::transmute(
5235 entry.get_instance_proc_addr(
5236 instance,
5237 CStr::from_bytes_with_nul_unchecked(
5238 b"xrConvertTimeToWin32PerformanceCounterKHR\0",
5239 ),
5240 )?,
5241 ),
5242 })
5243 }
5244 }
5245 #[derive(Copy, Clone)]
5246 pub struct ConvertTimespecTimeKHR {
5247 pub convert_timespec_time_to_time: pfn::ConvertTimespecTimeToTimeKHR,
5248 pub convert_time_to_timespec_time: pfn::ConvertTimeToTimespecTimeKHR,
5249 }
5250 impl ConvertTimespecTimeKHR {
5251 pub const VERSION: u32 = sys::KHR_convert_timespec_time_SPEC_VERSION;
5252 pub const NAME: &'static [u8] = sys::KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME;
5253 #[doc = r" Load the extension's function pointer table"]
5254 #[doc = r""]
5255 #[doc = r" # Safety"]
5256 #[doc = r""]
5257 #[doc = r" `instance` must be a valid instance handle."]
5258 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5259 Ok(Self {
5260 convert_timespec_time_to_time: mem::transmute(entry.get_instance_proc_addr(
5261 instance,
5262 CStr::from_bytes_with_nul_unchecked(b"xrConvertTimespecTimeToTimeKHR\0"),
5263 )?),
5264 convert_time_to_timespec_time: mem::transmute(entry.get_instance_proc_addr(
5265 instance,
5266 CStr::from_bytes_with_nul_unchecked(b"xrConvertTimeToTimespecTimeKHR\0"),
5267 )?),
5268 })
5269 }
5270 }
5271 #[derive(Copy, Clone)]
5272 pub struct LoaderInitKHR {
5273 pub initialize_loader: pfn::InitializeLoaderKHR,
5274 }
5275 impl LoaderInitKHR {
5276 pub const VERSION: u32 = sys::KHR_loader_init_SPEC_VERSION;
5277 pub const NAME: &'static [u8] = sys::KHR_LOADER_INIT_EXTENSION_NAME;
5278 #[doc = r" Load the extension's function pointer table"]
5279 #[doc = r""]
5280 #[doc = r" # Safety"]
5281 #[doc = r""]
5282 #[doc = r" `instance` must be a valid instance handle."]
5283 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5284 Ok(Self {
5285 initialize_loader: mem::transmute(entry.get_instance_proc_addr(
5286 instance,
5287 CStr::from_bytes_with_nul_unchecked(b"xrInitializeLoaderKHR\0"),
5288 )?),
5289 })
5290 }
5291 }
5292 #[cfg(target_os = "android")]
5293 #[derive(Copy, Clone)]
5294 pub struct LoaderInitAndroidKHR {}
5295 #[cfg(target_os = "android")]
5296 impl LoaderInitAndroidKHR {
5297 pub const VERSION: u32 = sys::KHR_loader_init_android_SPEC_VERSION;
5298 pub const NAME: &'static [u8] = sys::KHR_LOADER_INIT_ANDROID_EXTENSION_NAME;
5299 }
5300 #[derive(Copy, Clone)]
5301 pub struct VulkanEnable2KHR {
5302 pub create_vulkan_instance: pfn::CreateVulkanInstanceKHR,
5303 pub create_vulkan_device: pfn::CreateVulkanDeviceKHR,
5304 pub get_vulkan_graphics_device2: pfn::GetVulkanGraphicsDevice2KHR,
5305 pub get_vulkan_graphics_requirements2: pfn::GetVulkanGraphicsRequirements2KHR,
5306 }
5307 impl VulkanEnable2KHR {
5308 pub const VERSION: u32 = sys::KHR_vulkan_enable2_SPEC_VERSION;
5309 pub const NAME: &'static [u8] = sys::KHR_VULKAN_ENABLE2_EXTENSION_NAME;
5310 #[doc = r" Load the extension's function pointer table"]
5311 #[doc = r""]
5312 #[doc = r" # Safety"]
5313 #[doc = r""]
5314 #[doc = r" `instance` must be a valid instance handle."]
5315 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5316 Ok(Self {
5317 create_vulkan_instance: mem::transmute(entry.get_instance_proc_addr(
5318 instance,
5319 CStr::from_bytes_with_nul_unchecked(b"xrCreateVulkanInstanceKHR\0"),
5320 )?),
5321 create_vulkan_device: mem::transmute(entry.get_instance_proc_addr(
5322 instance,
5323 CStr::from_bytes_with_nul_unchecked(b"xrCreateVulkanDeviceKHR\0"),
5324 )?),
5325 get_vulkan_graphics_device2: mem::transmute(entry.get_instance_proc_addr(
5326 instance,
5327 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanGraphicsDevice2KHR\0"),
5328 )?),
5329 get_vulkan_graphics_requirements2: mem::transmute(entry.get_instance_proc_addr(
5330 instance,
5331 CStr::from_bytes_with_nul_unchecked(b"xrGetVulkanGraphicsRequirements2KHR\0"),
5332 )?),
5333 })
5334 }
5335 }
5336 #[derive(Copy, Clone)]
5337 pub struct CompositionLayerEquirect2KHR {}
5338 impl CompositionLayerEquirect2KHR {
5339 pub const VERSION: u32 = sys::KHR_composition_layer_equirect2_SPEC_VERSION;
5340 pub const NAME: &'static [u8] = sys::KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME;
5341 }
5342 #[derive(Copy, Clone)]
5343 pub struct BindingModificationKHR {}
5344 impl BindingModificationKHR {
5345 pub const VERSION: u32 = sys::KHR_binding_modification_SPEC_VERSION;
5346 pub const NAME: &'static [u8] = sys::KHR_BINDING_MODIFICATION_EXTENSION_NAME;
5347 }
5348 #[derive(Copy, Clone)]
5349 pub struct SwapchainUsageInputAttachmentBitKHR {}
5350 impl SwapchainUsageInputAttachmentBitKHR {
5351 pub const VERSION: u32 = sys::KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION;
5352 pub const NAME: &'static [u8] =
5353 sys::KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME;
5354 }
5355 #[derive(Copy, Clone)]
5356 pub struct LocateSpacesKHR {
5357 pub locate_spaces: pfn::LocateSpacesKHR,
5358 }
5359 impl LocateSpacesKHR {
5360 pub const VERSION: u32 = sys::KHR_locate_spaces_SPEC_VERSION;
5361 pub const NAME: &'static [u8] = sys::KHR_LOCATE_SPACES_EXTENSION_NAME;
5362 #[doc = r" Load the extension's function pointer table"]
5363 #[doc = r""]
5364 #[doc = r" # Safety"]
5365 #[doc = r""]
5366 #[doc = r" `instance` must be a valid instance handle."]
5367 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5368 Ok(Self {
5369 locate_spaces: mem::transmute(entry.get_instance_proc_addr(
5370 instance,
5371 CStr::from_bytes_with_nul_unchecked(b"xrLocateSpacesKHR\0"),
5372 )?),
5373 })
5374 }
5375 }
5376 #[derive(Copy, Clone)]
5377 pub struct Maintenance1KHR {}
5378 impl Maintenance1KHR {
5379 pub const VERSION: u32 = sys::KHR_maintenance1_SPEC_VERSION;
5380 pub const NAME: &'static [u8] = sys::KHR_MAINTENANCE1_EXTENSION_NAME;
5381 }
5382 #[derive(Copy, Clone)]
5383 pub struct FoveationEyeTrackedMETA {
5384 pub get_foveation_eye_tracked_state: pfn::GetFoveationEyeTrackedStateMETA,
5385 }
5386 impl FoveationEyeTrackedMETA {
5387 pub const VERSION: u32 = sys::META_foveation_eye_tracked_SPEC_VERSION;
5388 pub const NAME: &'static [u8] = sys::META_FOVEATION_EYE_TRACKED_EXTENSION_NAME;
5389 #[doc = r" Load the extension's function pointer table"]
5390 #[doc = r""]
5391 #[doc = r" # Safety"]
5392 #[doc = r""]
5393 #[doc = r" `instance` must be a valid instance handle."]
5394 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5395 Ok(Self {
5396 get_foveation_eye_tracked_state: mem::transmute(entry.get_instance_proc_addr(
5397 instance,
5398 CStr::from_bytes_with_nul_unchecked(b"xrGetFoveationEyeTrackedStateMETA\0"),
5399 )?),
5400 })
5401 }
5402 }
5403 #[derive(Copy, Clone)]
5404 pub struct LocalDimmingMETA {}
5405 impl LocalDimmingMETA {
5406 pub const VERSION: u32 = sys::META_local_dimming_SPEC_VERSION;
5407 pub const NAME: &'static [u8] = sys::META_LOCAL_DIMMING_EXTENSION_NAME;
5408 }
5409 #[derive(Copy, Clone)]
5410 pub struct PassthroughPreferencesMETA {
5411 pub get_passthrough_preferences: pfn::GetPassthroughPreferencesMETA,
5412 }
5413 impl PassthroughPreferencesMETA {
5414 pub const VERSION: u32 = sys::META_passthrough_preferences_SPEC_VERSION;
5415 pub const NAME: &'static [u8] = sys::META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME;
5416 #[doc = r" Load the extension's function pointer table"]
5417 #[doc = r""]
5418 #[doc = r" # Safety"]
5419 #[doc = r""]
5420 #[doc = r" `instance` must be a valid instance handle."]
5421 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5422 Ok(Self {
5423 get_passthrough_preferences: mem::transmute(entry.get_instance_proc_addr(
5424 instance,
5425 CStr::from_bytes_with_nul_unchecked(b"xrGetPassthroughPreferencesMETA\0"),
5426 )?),
5427 })
5428 }
5429 }
5430 #[derive(Copy, Clone)]
5431 pub struct VirtualKeyboardMETA {
5432 pub create_virtual_keyboard: pfn::CreateVirtualKeyboardMETA,
5433 pub destroy_virtual_keyboard: pfn::DestroyVirtualKeyboardMETA,
5434 pub create_virtual_keyboard_space: pfn::CreateVirtualKeyboardSpaceMETA,
5435 pub suggest_virtual_keyboard_location: pfn::SuggestVirtualKeyboardLocationMETA,
5436 pub get_virtual_keyboard_scale: pfn::GetVirtualKeyboardScaleMETA,
5437 pub set_virtual_keyboard_model_visibility: pfn::SetVirtualKeyboardModelVisibilityMETA,
5438 pub get_virtual_keyboard_model_animation_states:
5439 pfn::GetVirtualKeyboardModelAnimationStatesMETA,
5440 pub get_virtual_keyboard_dirty_textures: pfn::GetVirtualKeyboardDirtyTexturesMETA,
5441 pub get_virtual_keyboard_texture_data: pfn::GetVirtualKeyboardTextureDataMETA,
5442 pub send_virtual_keyboard_input: pfn::SendVirtualKeyboardInputMETA,
5443 pub change_virtual_keyboard_text_context: pfn::ChangeVirtualKeyboardTextContextMETA,
5444 }
5445 impl VirtualKeyboardMETA {
5446 pub const VERSION: u32 = sys::META_virtual_keyboard_SPEC_VERSION;
5447 pub const NAME: &'static [u8] = sys::META_VIRTUAL_KEYBOARD_EXTENSION_NAME;
5448 #[doc = r" Load the extension's function pointer table"]
5449 #[doc = r""]
5450 #[doc = r" # Safety"]
5451 #[doc = r""]
5452 #[doc = r" `instance` must be a valid instance handle."]
5453 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5454 Ok(Self {
5455 create_virtual_keyboard: mem::transmute(entry.get_instance_proc_addr(
5456 instance,
5457 CStr::from_bytes_with_nul_unchecked(b"xrCreateVirtualKeyboardMETA\0"),
5458 )?),
5459 destroy_virtual_keyboard: mem::transmute(entry.get_instance_proc_addr(
5460 instance,
5461 CStr::from_bytes_with_nul_unchecked(b"xrDestroyVirtualKeyboardMETA\0"),
5462 )?),
5463 create_virtual_keyboard_space: mem::transmute(entry.get_instance_proc_addr(
5464 instance,
5465 CStr::from_bytes_with_nul_unchecked(b"xrCreateVirtualKeyboardSpaceMETA\0"),
5466 )?),
5467 suggest_virtual_keyboard_location: mem::transmute(entry.get_instance_proc_addr(
5468 instance,
5469 CStr::from_bytes_with_nul_unchecked(b"xrSuggestVirtualKeyboardLocationMETA\0"),
5470 )?),
5471 get_virtual_keyboard_scale: mem::transmute(entry.get_instance_proc_addr(
5472 instance,
5473 CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardScaleMETA\0"),
5474 )?),
5475 set_virtual_keyboard_model_visibility: mem::transmute(
5476 entry.get_instance_proc_addr(
5477 instance,
5478 CStr::from_bytes_with_nul_unchecked(
5479 b"xrSetVirtualKeyboardModelVisibilityMETA\0",
5480 ),
5481 )?,
5482 ),
5483 get_virtual_keyboard_model_animation_states: mem::transmute(
5484 entry.get_instance_proc_addr(
5485 instance,
5486 CStr::from_bytes_with_nul_unchecked(
5487 b"xrGetVirtualKeyboardModelAnimationStatesMETA\0",
5488 ),
5489 )?,
5490 ),
5491 get_virtual_keyboard_dirty_textures: mem::transmute(entry.get_instance_proc_addr(
5492 instance,
5493 CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardDirtyTexturesMETA\0"),
5494 )?),
5495 get_virtual_keyboard_texture_data: mem::transmute(entry.get_instance_proc_addr(
5496 instance,
5497 CStr::from_bytes_with_nul_unchecked(b"xrGetVirtualKeyboardTextureDataMETA\0"),
5498 )?),
5499 send_virtual_keyboard_input: mem::transmute(entry.get_instance_proc_addr(
5500 instance,
5501 CStr::from_bytes_with_nul_unchecked(b"xrSendVirtualKeyboardInputMETA\0"),
5502 )?),
5503 change_virtual_keyboard_text_context: mem::transmute(
5504 entry.get_instance_proc_addr(
5505 instance,
5506 CStr::from_bytes_with_nul_unchecked(
5507 b"xrChangeVirtualKeyboardTextContextMETA\0",
5508 ),
5509 )?,
5510 ),
5511 })
5512 }
5513 }
5514 #[derive(Copy, Clone)]
5515 pub struct VulkanSwapchainCreateInfoMETA {}
5516 impl VulkanSwapchainCreateInfoMETA {
5517 pub const VERSION: u32 = sys::META_vulkan_swapchain_create_info_SPEC_VERSION;
5518 pub const NAME: &'static [u8] = sys::META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME;
5519 }
5520 #[derive(Copy, Clone)]
5521 pub struct PerformanceMetricsMETA {
5522 pub enumerate_performance_metrics_counter_paths:
5523 pfn::EnumeratePerformanceMetricsCounterPathsMETA,
5524 pub set_performance_metrics_state: pfn::SetPerformanceMetricsStateMETA,
5525 pub get_performance_metrics_state: pfn::GetPerformanceMetricsStateMETA,
5526 pub query_performance_metrics_counter: pfn::QueryPerformanceMetricsCounterMETA,
5527 }
5528 impl PerformanceMetricsMETA {
5529 pub const VERSION: u32 = sys::META_performance_metrics_SPEC_VERSION;
5530 pub const NAME: &'static [u8] = sys::META_PERFORMANCE_METRICS_EXTENSION_NAME;
5531 #[doc = r" Load the extension's function pointer table"]
5532 #[doc = r""]
5533 #[doc = r" # Safety"]
5534 #[doc = r""]
5535 #[doc = r" `instance` must be a valid instance handle."]
5536 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5537 Ok(Self {
5538 enumerate_performance_metrics_counter_paths: mem::transmute(
5539 entry.get_instance_proc_addr(
5540 instance,
5541 CStr::from_bytes_with_nul_unchecked(
5542 b"xrEnumeratePerformanceMetricsCounterPathsMETA\0",
5543 ),
5544 )?,
5545 ),
5546 set_performance_metrics_state: mem::transmute(entry.get_instance_proc_addr(
5547 instance,
5548 CStr::from_bytes_with_nul_unchecked(b"xrSetPerformanceMetricsStateMETA\0"),
5549 )?),
5550 get_performance_metrics_state: mem::transmute(entry.get_instance_proc_addr(
5551 instance,
5552 CStr::from_bytes_with_nul_unchecked(b"xrGetPerformanceMetricsStateMETA\0"),
5553 )?),
5554 query_performance_metrics_counter: mem::transmute(entry.get_instance_proc_addr(
5555 instance,
5556 CStr::from_bytes_with_nul_unchecked(b"xrQueryPerformanceMetricsCounterMETA\0"),
5557 )?),
5558 })
5559 }
5560 }
5561 #[derive(Copy, Clone)]
5562 pub struct HeadsetIdMETA {}
5563 impl HeadsetIdMETA {
5564 pub const VERSION: u32 = sys::META_headset_id_SPEC_VERSION;
5565 pub const NAME: &'static [u8] = sys::META_HEADSET_ID_EXTENSION_NAME;
5566 }
5567 #[derive(Copy, Clone)]
5568 pub struct RecommendedLayerResolutionMETA {
5569 pub get_recommended_layer_resolution: pfn::GetRecommendedLayerResolutionMETA,
5570 }
5571 impl RecommendedLayerResolutionMETA {
5572 pub const VERSION: u32 = sys::META_recommended_layer_resolution_SPEC_VERSION;
5573 pub const NAME: &'static [u8] = sys::META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME;
5574 #[doc = r" Load the extension's function pointer table"]
5575 #[doc = r""]
5576 #[doc = r" # Safety"]
5577 #[doc = r""]
5578 #[doc = r" `instance` must be a valid instance handle."]
5579 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5580 Ok(Self {
5581 get_recommended_layer_resolution: mem::transmute(entry.get_instance_proc_addr(
5582 instance,
5583 CStr::from_bytes_with_nul_unchecked(b"xrGetRecommendedLayerResolutionMETA\0"),
5584 )?),
5585 })
5586 }
5587 }
5588 #[derive(Copy, Clone)]
5589 pub struct PassthroughColorLutMETA {
5590 pub create_passthrough_color_lut: pfn::CreatePassthroughColorLutMETA,
5591 pub destroy_passthrough_color_lut: pfn::DestroyPassthroughColorLutMETA,
5592 pub update_passthrough_color_lut: pfn::UpdatePassthroughColorLutMETA,
5593 }
5594 impl PassthroughColorLutMETA {
5595 pub const VERSION: u32 = sys::META_passthrough_color_lut_SPEC_VERSION;
5596 pub const NAME: &'static [u8] = sys::META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME;
5597 #[doc = r" Load the extension's function pointer table"]
5598 #[doc = r""]
5599 #[doc = r" # Safety"]
5600 #[doc = r""]
5601 #[doc = r" `instance` must be a valid instance handle."]
5602 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5603 Ok(Self {
5604 create_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr(
5605 instance,
5606 CStr::from_bytes_with_nul_unchecked(b"xrCreatePassthroughColorLutMETA\0"),
5607 )?),
5608 destroy_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr(
5609 instance,
5610 CStr::from_bytes_with_nul_unchecked(b"xrDestroyPassthroughColorLutMETA\0"),
5611 )?),
5612 update_passthrough_color_lut: mem::transmute(entry.get_instance_proc_addr(
5613 instance,
5614 CStr::from_bytes_with_nul_unchecked(b"xrUpdatePassthroughColorLutMETA\0"),
5615 )?),
5616 })
5617 }
5618 }
5619 #[derive(Copy, Clone)]
5620 pub struct SpatialEntityMeshMETA {
5621 pub get_space_triangle_mesh: pfn::GetSpaceTriangleMeshMETA,
5622 }
5623 impl SpatialEntityMeshMETA {
5624 pub const VERSION: u32 = sys::META_spatial_entity_mesh_SPEC_VERSION;
5625 pub const NAME: &'static [u8] = sys::META_SPATIAL_ENTITY_MESH_EXTENSION_NAME;
5626 #[doc = r" Load the extension's function pointer table"]
5627 #[doc = r""]
5628 #[doc = r" # Safety"]
5629 #[doc = r""]
5630 #[doc = r" `instance` must be a valid instance handle."]
5631 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5632 Ok(Self {
5633 get_space_triangle_mesh: mem::transmute(entry.get_instance_proc_addr(
5634 instance,
5635 CStr::from_bytes_with_nul_unchecked(b"xrGetSpaceTriangleMeshMETA\0"),
5636 )?),
5637 })
5638 }
5639 }
5640 #[derive(Copy, Clone)]
5641 pub struct AutomaticLayerFilterMETA {}
5642 impl AutomaticLayerFilterMETA {
5643 pub const VERSION: u32 = sys::META_automatic_layer_filter_SPEC_VERSION;
5644 pub const NAME: &'static [u8] = sys::META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME;
5645 }
5646 #[derive(Copy, Clone)]
5647 pub struct TouchControllerPlusMETA {}
5648 impl TouchControllerPlusMETA {
5649 pub const VERSION: u32 = sys::META_touch_controller_plus_SPEC_VERSION;
5650 pub const NAME: &'static [u8] = sys::META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME;
5651 }
5652 #[derive(Copy, Clone)]
5653 pub struct EnvironmentDepthMETA {
5654 pub create_environment_depth_provider: pfn::CreateEnvironmentDepthProviderMETA,
5655 pub destroy_environment_depth_provider: pfn::DestroyEnvironmentDepthProviderMETA,
5656 pub start_environment_depth_provider: pfn::StartEnvironmentDepthProviderMETA,
5657 pub stop_environment_depth_provider: pfn::StopEnvironmentDepthProviderMETA,
5658 pub create_environment_depth_swapchain: pfn::CreateEnvironmentDepthSwapchainMETA,
5659 pub destroy_environment_depth_swapchain: pfn::DestroyEnvironmentDepthSwapchainMETA,
5660 pub enumerate_environment_depth_swapchain_images:
5661 pfn::EnumerateEnvironmentDepthSwapchainImagesMETA,
5662 pub get_environment_depth_swapchain_state: pfn::GetEnvironmentDepthSwapchainStateMETA,
5663 pub acquire_environment_depth_image: pfn::AcquireEnvironmentDepthImageMETA,
5664 pub set_environment_depth_hand_removal: pfn::SetEnvironmentDepthHandRemovalMETA,
5665 }
5666 impl EnvironmentDepthMETA {
5667 pub const VERSION: u32 = sys::META_environment_depth_SPEC_VERSION;
5668 pub const NAME: &'static [u8] = sys::META_ENVIRONMENT_DEPTH_EXTENSION_NAME;
5669 #[doc = r" Load the extension's function pointer table"]
5670 #[doc = r""]
5671 #[doc = r" # Safety"]
5672 #[doc = r""]
5673 #[doc = r" `instance` must be a valid instance handle."]
5674 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5675 Ok(Self {
5676 create_environment_depth_provider: mem::transmute(entry.get_instance_proc_addr(
5677 instance,
5678 CStr::from_bytes_with_nul_unchecked(b"xrCreateEnvironmentDepthProviderMETA\0"),
5679 )?),
5680 destroy_environment_depth_provider: mem::transmute(entry.get_instance_proc_addr(
5681 instance,
5682 CStr::from_bytes_with_nul_unchecked(b"xrDestroyEnvironmentDepthProviderMETA\0"),
5683 )?),
5684 start_environment_depth_provider: mem::transmute(entry.get_instance_proc_addr(
5685 instance,
5686 CStr::from_bytes_with_nul_unchecked(b"xrStartEnvironmentDepthProviderMETA\0"),
5687 )?),
5688 stop_environment_depth_provider: mem::transmute(entry.get_instance_proc_addr(
5689 instance,
5690 CStr::from_bytes_with_nul_unchecked(b"xrStopEnvironmentDepthProviderMETA\0"),
5691 )?),
5692 create_environment_depth_swapchain: mem::transmute(entry.get_instance_proc_addr(
5693 instance,
5694 CStr::from_bytes_with_nul_unchecked(b"xrCreateEnvironmentDepthSwapchainMETA\0"),
5695 )?),
5696 destroy_environment_depth_swapchain: mem::transmute(entry.get_instance_proc_addr(
5697 instance,
5698 CStr::from_bytes_with_nul_unchecked(
5699 b"xrDestroyEnvironmentDepthSwapchainMETA\0",
5700 ),
5701 )?),
5702 enumerate_environment_depth_swapchain_images: mem::transmute(
5703 entry.get_instance_proc_addr(
5704 instance,
5705 CStr::from_bytes_with_nul_unchecked(
5706 b"xrEnumerateEnvironmentDepthSwapchainImagesMETA\0",
5707 ),
5708 )?,
5709 ),
5710 get_environment_depth_swapchain_state: mem::transmute(
5711 entry.get_instance_proc_addr(
5712 instance,
5713 CStr::from_bytes_with_nul_unchecked(
5714 b"xrGetEnvironmentDepthSwapchainStateMETA\0",
5715 ),
5716 )?,
5717 ),
5718 acquire_environment_depth_image: mem::transmute(entry.get_instance_proc_addr(
5719 instance,
5720 CStr::from_bytes_with_nul_unchecked(b"xrAcquireEnvironmentDepthImageMETA\0"),
5721 )?),
5722 set_environment_depth_hand_removal: mem::transmute(entry.get_instance_proc_addr(
5723 instance,
5724 CStr::from_bytes_with_nul_unchecked(b"xrSetEnvironmentDepthHandRemovalMETA\0"),
5725 )?),
5726 })
5727 }
5728 }
5729 #[derive(Copy, Clone)]
5730 pub struct Ml2ControllerInteractionML {}
5731 impl Ml2ControllerInteractionML {
5732 pub const VERSION: u32 = sys::ML_ml2_controller_interaction_SPEC_VERSION;
5733 pub const NAME: &'static [u8] = sys::ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME;
5734 }
5735 #[derive(Copy, Clone)]
5736 pub struct FrameEndInfoML {}
5737 impl FrameEndInfoML {
5738 pub const VERSION: u32 = sys::ML_frame_end_info_SPEC_VERSION;
5739 pub const NAME: &'static [u8] = sys::ML_FRAME_END_INFO_EXTENSION_NAME;
5740 }
5741 #[derive(Copy, Clone)]
5742 pub struct GlobalDimmerML {}
5743 impl GlobalDimmerML {
5744 pub const VERSION: u32 = sys::ML_global_dimmer_SPEC_VERSION;
5745 pub const NAME: &'static [u8] = sys::ML_GLOBAL_DIMMER_EXTENSION_NAME;
5746 }
5747 #[derive(Copy, Clone)]
5748 pub struct CompatML {
5749 pub create_space_from_coordinate_frame_uid: pfn::CreateSpaceFromCoordinateFrameUIDML,
5750 }
5751 impl CompatML {
5752 pub const VERSION: u32 = sys::ML_compat_SPEC_VERSION;
5753 pub const NAME: &'static [u8] = sys::ML_COMPAT_EXTENSION_NAME;
5754 #[doc = r" Load the extension's function pointer table"]
5755 #[doc = r""]
5756 #[doc = r" # Safety"]
5757 #[doc = r""]
5758 #[doc = r" `instance` must be a valid instance handle."]
5759 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5760 Ok(Self {
5761 create_space_from_coordinate_frame_uid: mem::transmute(
5762 entry.get_instance_proc_addr(
5763 instance,
5764 CStr::from_bytes_with_nul_unchecked(
5765 b"xrCreateSpaceFromCoordinateFrameUIDML\0",
5766 ),
5767 )?,
5768 ),
5769 })
5770 }
5771 }
5772 #[derive(Copy, Clone)]
5773 pub struct MarkerUnderstandingML {
5774 pub create_marker_detector: pfn::CreateMarkerDetectorML,
5775 pub destroy_marker_detector: pfn::DestroyMarkerDetectorML,
5776 pub snapshot_marker_detector: pfn::SnapshotMarkerDetectorML,
5777 pub get_marker_detector_state: pfn::GetMarkerDetectorStateML,
5778 pub get_markers: pfn::GetMarkersML,
5779 pub get_marker_reprojection_error: pfn::GetMarkerReprojectionErrorML,
5780 pub get_marker_length: pfn::GetMarkerLengthML,
5781 pub get_marker_number: pfn::GetMarkerNumberML,
5782 pub get_marker_string: pfn::GetMarkerStringML,
5783 pub create_marker_space: pfn::CreateMarkerSpaceML,
5784 }
5785 impl MarkerUnderstandingML {
5786 pub const VERSION: u32 = sys::ML_marker_understanding_SPEC_VERSION;
5787 pub const NAME: &'static [u8] = sys::ML_MARKER_UNDERSTANDING_EXTENSION_NAME;
5788 #[doc = r" Load the extension's function pointer table"]
5789 #[doc = r""]
5790 #[doc = r" # Safety"]
5791 #[doc = r""]
5792 #[doc = r" `instance` must be a valid instance handle."]
5793 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5794 Ok(Self {
5795 create_marker_detector: mem::transmute(entry.get_instance_proc_addr(
5796 instance,
5797 CStr::from_bytes_with_nul_unchecked(b"xrCreateMarkerDetectorML\0"),
5798 )?),
5799 destroy_marker_detector: mem::transmute(entry.get_instance_proc_addr(
5800 instance,
5801 CStr::from_bytes_with_nul_unchecked(b"xrDestroyMarkerDetectorML\0"),
5802 )?),
5803 snapshot_marker_detector: mem::transmute(entry.get_instance_proc_addr(
5804 instance,
5805 CStr::from_bytes_with_nul_unchecked(b"xrSnapshotMarkerDetectorML\0"),
5806 )?),
5807 get_marker_detector_state: mem::transmute(entry.get_instance_proc_addr(
5808 instance,
5809 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerDetectorStateML\0"),
5810 )?),
5811 get_markers: mem::transmute(entry.get_instance_proc_addr(
5812 instance,
5813 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkersML\0"),
5814 )?),
5815 get_marker_reprojection_error: mem::transmute(entry.get_instance_proc_addr(
5816 instance,
5817 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerReprojectionErrorML\0"),
5818 )?),
5819 get_marker_length: mem::transmute(entry.get_instance_proc_addr(
5820 instance,
5821 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerLengthML\0"),
5822 )?),
5823 get_marker_number: mem::transmute(entry.get_instance_proc_addr(
5824 instance,
5825 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerNumberML\0"),
5826 )?),
5827 get_marker_string: mem::transmute(entry.get_instance_proc_addr(
5828 instance,
5829 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerStringML\0"),
5830 )?),
5831 create_marker_space: mem::transmute(entry.get_instance_proc_addr(
5832 instance,
5833 CStr::from_bytes_with_nul_unchecked(b"xrCreateMarkerSpaceML\0"),
5834 )?),
5835 })
5836 }
5837 }
5838 #[derive(Copy, Clone)]
5839 pub struct LocalizationMapML {
5840 pub enable_localization_events: pfn::EnableLocalizationEventsML,
5841 pub query_localization_maps: pfn::QueryLocalizationMapsML,
5842 pub request_map_localization: pfn::RequestMapLocalizationML,
5843 pub import_localization_map: pfn::ImportLocalizationMapML,
5844 pub create_exported_localization_map: pfn::CreateExportedLocalizationMapML,
5845 pub destroy_exported_localization_map: pfn::DestroyExportedLocalizationMapML,
5846 pub get_exported_localization_map_data: pfn::GetExportedLocalizationMapDataML,
5847 }
5848 impl LocalizationMapML {
5849 pub const VERSION: u32 = sys::ML_localization_map_SPEC_VERSION;
5850 pub const NAME: &'static [u8] = sys::ML_LOCALIZATION_MAP_EXTENSION_NAME;
5851 #[doc = r" Load the extension's function pointer table"]
5852 #[doc = r""]
5853 #[doc = r" # Safety"]
5854 #[doc = r""]
5855 #[doc = r" `instance` must be a valid instance handle."]
5856 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5857 Ok(Self {
5858 enable_localization_events: mem::transmute(entry.get_instance_proc_addr(
5859 instance,
5860 CStr::from_bytes_with_nul_unchecked(b"xrEnableLocalizationEventsML\0"),
5861 )?),
5862 query_localization_maps: mem::transmute(entry.get_instance_proc_addr(
5863 instance,
5864 CStr::from_bytes_with_nul_unchecked(b"xrQueryLocalizationMapsML\0"),
5865 )?),
5866 request_map_localization: mem::transmute(entry.get_instance_proc_addr(
5867 instance,
5868 CStr::from_bytes_with_nul_unchecked(b"xrRequestMapLocalizationML\0"),
5869 )?),
5870 import_localization_map: mem::transmute(entry.get_instance_proc_addr(
5871 instance,
5872 CStr::from_bytes_with_nul_unchecked(b"xrImportLocalizationMapML\0"),
5873 )?),
5874 create_exported_localization_map: mem::transmute(entry.get_instance_proc_addr(
5875 instance,
5876 CStr::from_bytes_with_nul_unchecked(b"xrCreateExportedLocalizationMapML\0"),
5877 )?),
5878 destroy_exported_localization_map: mem::transmute(entry.get_instance_proc_addr(
5879 instance,
5880 CStr::from_bytes_with_nul_unchecked(b"xrDestroyExportedLocalizationMapML\0"),
5881 )?),
5882 get_exported_localization_map_data: mem::transmute(entry.get_instance_proc_addr(
5883 instance,
5884 CStr::from_bytes_with_nul_unchecked(b"xrGetExportedLocalizationMapDataML\0"),
5885 )?),
5886 })
5887 }
5888 }
5889 #[derive(Copy, Clone)]
5890 pub struct UserCalibrationML {
5891 pub enable_user_calibration_events: pfn::EnableUserCalibrationEventsML,
5892 }
5893 impl UserCalibrationML {
5894 pub const VERSION: u32 = sys::ML_user_calibration_SPEC_VERSION;
5895 pub const NAME: &'static [u8] = sys::ML_USER_CALIBRATION_EXTENSION_NAME;
5896 #[doc = r" Load the extension's function pointer table"]
5897 #[doc = r""]
5898 #[doc = r" # Safety"]
5899 #[doc = r""]
5900 #[doc = r" `instance` must be a valid instance handle."]
5901 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5902 Ok(Self {
5903 enable_user_calibration_events: mem::transmute(entry.get_instance_proc_addr(
5904 instance,
5905 CStr::from_bytes_with_nul_unchecked(b"xrEnableUserCalibrationEventsML\0"),
5906 )?),
5907 })
5908 }
5909 }
5910 #[derive(Copy, Clone)]
5911 pub struct HeadlessMND {}
5912 impl HeadlessMND {
5913 pub const VERSION: u32 = sys::MND_headless_SPEC_VERSION;
5914 pub const NAME: &'static [u8] = sys::MND_HEADLESS_EXTENSION_NAME;
5915 }
5916 #[derive(Copy, Clone)]
5917 pub struct SwapchainUsageInputAttachmentBitMND {}
5918 impl SwapchainUsageInputAttachmentBitMND {
5919 pub const VERSION: u32 = sys::MND_swapchain_usage_input_attachment_bit_SPEC_VERSION;
5920 pub const NAME: &'static [u8] =
5921 sys::MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME;
5922 }
5923 #[derive(Copy, Clone)]
5924 pub struct UnboundedReferenceSpaceMSFT {}
5925 impl UnboundedReferenceSpaceMSFT {
5926 pub const VERSION: u32 = sys::MSFT_unbounded_reference_space_SPEC_VERSION;
5927 pub const NAME: &'static [u8] = sys::MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME;
5928 }
5929 #[derive(Copy, Clone)]
5930 pub struct SpatialAnchorMSFT {
5931 pub create_spatial_anchor: pfn::CreateSpatialAnchorMSFT,
5932 pub create_spatial_anchor_space: pfn::CreateSpatialAnchorSpaceMSFT,
5933 pub destroy_spatial_anchor: pfn::DestroySpatialAnchorMSFT,
5934 }
5935 impl SpatialAnchorMSFT {
5936 pub const VERSION: u32 = sys::MSFT_spatial_anchor_SPEC_VERSION;
5937 pub const NAME: &'static [u8] = sys::MSFT_SPATIAL_ANCHOR_EXTENSION_NAME;
5938 #[doc = r" Load the extension's function pointer table"]
5939 #[doc = r""]
5940 #[doc = r" # Safety"]
5941 #[doc = r""]
5942 #[doc = r" `instance` must be a valid instance handle."]
5943 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5944 Ok(Self {
5945 create_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
5946 instance,
5947 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpatialAnchorMSFT\0"),
5948 )?),
5949 create_spatial_anchor_space: mem::transmute(entry.get_instance_proc_addr(
5950 instance,
5951 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpatialAnchorSpaceMSFT\0"),
5952 )?),
5953 destroy_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
5954 instance,
5955 CStr::from_bytes_with_nul_unchecked(b"xrDestroySpatialAnchorMSFT\0"),
5956 )?),
5957 })
5958 }
5959 }
5960 #[derive(Copy, Clone)]
5961 pub struct SpatialGraphBridgeMSFT {
5962 pub create_spatial_graph_node_space: pfn::CreateSpatialGraphNodeSpaceMSFT,
5963 pub try_create_spatial_graph_static_node_binding:
5964 pfn::TryCreateSpatialGraphStaticNodeBindingMSFT,
5965 pub destroy_spatial_graph_node_binding: pfn::DestroySpatialGraphNodeBindingMSFT,
5966 pub get_spatial_graph_node_binding_properties:
5967 pfn::GetSpatialGraphNodeBindingPropertiesMSFT,
5968 }
5969 impl SpatialGraphBridgeMSFT {
5970 pub const VERSION: u32 = sys::MSFT_spatial_graph_bridge_SPEC_VERSION;
5971 pub const NAME: &'static [u8] = sys::MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME;
5972 #[doc = r" Load the extension's function pointer table"]
5973 #[doc = r""]
5974 #[doc = r" # Safety"]
5975 #[doc = r""]
5976 #[doc = r" `instance` must be a valid instance handle."]
5977 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
5978 Ok(Self {
5979 create_spatial_graph_node_space: mem::transmute(entry.get_instance_proc_addr(
5980 instance,
5981 CStr::from_bytes_with_nul_unchecked(b"xrCreateSpatialGraphNodeSpaceMSFT\0"),
5982 )?),
5983 try_create_spatial_graph_static_node_binding: mem::transmute(
5984 entry.get_instance_proc_addr(
5985 instance,
5986 CStr::from_bytes_with_nul_unchecked(
5987 b"xrTryCreateSpatialGraphStaticNodeBindingMSFT\0",
5988 ),
5989 )?,
5990 ),
5991 destroy_spatial_graph_node_binding: mem::transmute(entry.get_instance_proc_addr(
5992 instance,
5993 CStr::from_bytes_with_nul_unchecked(b"xrDestroySpatialGraphNodeBindingMSFT\0"),
5994 )?),
5995 get_spatial_graph_node_binding_properties: mem::transmute(
5996 entry.get_instance_proc_addr(
5997 instance,
5998 CStr::from_bytes_with_nul_unchecked(
5999 b"xrGetSpatialGraphNodeBindingPropertiesMSFT\0",
6000 ),
6001 )?,
6002 ),
6003 })
6004 }
6005 }
6006 #[derive(Copy, Clone)]
6007 pub struct HandInteractionMSFT {}
6008 impl HandInteractionMSFT {
6009 pub const VERSION: u32 = sys::MSFT_hand_interaction_SPEC_VERSION;
6010 pub const NAME: &'static [u8] = sys::MSFT_HAND_INTERACTION_EXTENSION_NAME;
6011 }
6012 #[derive(Copy, Clone)]
6013 pub struct HandTrackingMeshMSFT {
6014 pub create_hand_mesh_space: pfn::CreateHandMeshSpaceMSFT,
6015 pub update_hand_mesh: pfn::UpdateHandMeshMSFT,
6016 }
6017 impl HandTrackingMeshMSFT {
6018 pub const VERSION: u32 = sys::MSFT_hand_tracking_mesh_SPEC_VERSION;
6019 pub const NAME: &'static [u8] = sys::MSFT_HAND_TRACKING_MESH_EXTENSION_NAME;
6020 #[doc = r" Load the extension's function pointer table"]
6021 #[doc = r""]
6022 #[doc = r" # Safety"]
6023 #[doc = r""]
6024 #[doc = r" `instance` must be a valid instance handle."]
6025 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6026 Ok(Self {
6027 create_hand_mesh_space: mem::transmute(entry.get_instance_proc_addr(
6028 instance,
6029 CStr::from_bytes_with_nul_unchecked(b"xrCreateHandMeshSpaceMSFT\0"),
6030 )?),
6031 update_hand_mesh: mem::transmute(entry.get_instance_proc_addr(
6032 instance,
6033 CStr::from_bytes_with_nul_unchecked(b"xrUpdateHandMeshMSFT\0"),
6034 )?),
6035 })
6036 }
6037 }
6038 #[derive(Copy, Clone)]
6039 pub struct SecondaryViewConfigurationMSFT {}
6040 impl SecondaryViewConfigurationMSFT {
6041 pub const VERSION: u32 = sys::MSFT_secondary_view_configuration_SPEC_VERSION;
6042 pub const NAME: &'static [u8] = sys::MSFT_SECONDARY_VIEW_CONFIGURATION_EXTENSION_NAME;
6043 }
6044 #[derive(Copy, Clone)]
6045 pub struct FirstPersonObserverMSFT {}
6046 impl FirstPersonObserverMSFT {
6047 pub const VERSION: u32 = sys::MSFT_first_person_observer_SPEC_VERSION;
6048 pub const NAME: &'static [u8] = sys::MSFT_FIRST_PERSON_OBSERVER_EXTENSION_NAME;
6049 }
6050 #[derive(Copy, Clone)]
6051 pub struct ControllerModelMSFT {
6052 pub get_controller_model_key: pfn::GetControllerModelKeyMSFT,
6053 pub load_controller_model: pfn::LoadControllerModelMSFT,
6054 pub get_controller_model_properties: pfn::GetControllerModelPropertiesMSFT,
6055 pub get_controller_model_state: pfn::GetControllerModelStateMSFT,
6056 }
6057 impl ControllerModelMSFT {
6058 pub const VERSION: u32 = sys::MSFT_controller_model_SPEC_VERSION;
6059 pub const NAME: &'static [u8] = sys::MSFT_CONTROLLER_MODEL_EXTENSION_NAME;
6060 #[doc = r" Load the extension's function pointer table"]
6061 #[doc = r""]
6062 #[doc = r" # Safety"]
6063 #[doc = r""]
6064 #[doc = r" `instance` must be a valid instance handle."]
6065 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6066 Ok(Self {
6067 get_controller_model_key: mem::transmute(entry.get_instance_proc_addr(
6068 instance,
6069 CStr::from_bytes_with_nul_unchecked(b"xrGetControllerModelKeyMSFT\0"),
6070 )?),
6071 load_controller_model: mem::transmute(entry.get_instance_proc_addr(
6072 instance,
6073 CStr::from_bytes_with_nul_unchecked(b"xrLoadControllerModelMSFT\0"),
6074 )?),
6075 get_controller_model_properties: mem::transmute(entry.get_instance_proc_addr(
6076 instance,
6077 CStr::from_bytes_with_nul_unchecked(b"xrGetControllerModelPropertiesMSFT\0"),
6078 )?),
6079 get_controller_model_state: mem::transmute(entry.get_instance_proc_addr(
6080 instance,
6081 CStr::from_bytes_with_nul_unchecked(b"xrGetControllerModelStateMSFT\0"),
6082 )?),
6083 })
6084 }
6085 }
6086 #[cfg(windows)]
6087 #[derive(Copy, Clone)]
6088 pub struct PerceptionAnchorInteropMSFT {
6089 pub create_spatial_anchor_from_perception_anchor:
6090 pfn::CreateSpatialAnchorFromPerceptionAnchorMSFT,
6091 pub try_get_perception_anchor_from_spatial_anchor:
6092 pfn::TryGetPerceptionAnchorFromSpatialAnchorMSFT,
6093 }
6094 #[cfg(windows)]
6095 impl PerceptionAnchorInteropMSFT {
6096 pub const VERSION: u32 = sys::MSFT_perception_anchor_interop_SPEC_VERSION;
6097 pub const NAME: &'static [u8] = sys::MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME;
6098 #[doc = r" Load the extension's function pointer table"]
6099 #[doc = r""]
6100 #[doc = r" # Safety"]
6101 #[doc = r""]
6102 #[doc = r" `instance` must be a valid instance handle."]
6103 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6104 Ok(Self {
6105 create_spatial_anchor_from_perception_anchor: mem::transmute(
6106 entry.get_instance_proc_addr(
6107 instance,
6108 CStr::from_bytes_with_nul_unchecked(
6109 b"xrCreateSpatialAnchorFromPerceptionAnchorMSFT\0",
6110 ),
6111 )?,
6112 ),
6113 try_get_perception_anchor_from_spatial_anchor: mem::transmute(
6114 entry.get_instance_proc_addr(
6115 instance,
6116 CStr::from_bytes_with_nul_unchecked(
6117 b"xrTryGetPerceptionAnchorFromSpatialAnchorMSFT\0",
6118 ),
6119 )?,
6120 ),
6121 })
6122 }
6123 }
6124 #[cfg(windows)]
6125 #[derive(Copy, Clone)]
6126 pub struct HolographicWindowAttachmentMSFT {}
6127 #[cfg(windows)]
6128 impl HolographicWindowAttachmentMSFT {
6129 pub const VERSION: u32 = sys::MSFT_holographic_window_attachment_SPEC_VERSION;
6130 pub const NAME: &'static [u8] = sys::MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME;
6131 }
6132 #[derive(Copy, Clone)]
6133 pub struct CompositionLayerReprojectionMSFT {
6134 pub enumerate_reprojection_modes: pfn::EnumerateReprojectionModesMSFT,
6135 }
6136 impl CompositionLayerReprojectionMSFT {
6137 pub const VERSION: u32 = sys::MSFT_composition_layer_reprojection_SPEC_VERSION;
6138 pub const NAME: &'static [u8] = sys::MSFT_COMPOSITION_LAYER_REPROJECTION_EXTENSION_NAME;
6139 #[doc = r" Load the extension's function pointer table"]
6140 #[doc = r""]
6141 #[doc = r" # Safety"]
6142 #[doc = r""]
6143 #[doc = r" `instance` must be a valid instance handle."]
6144 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6145 Ok(Self {
6146 enumerate_reprojection_modes: mem::transmute(entry.get_instance_proc_addr(
6147 instance,
6148 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateReprojectionModesMSFT\0"),
6149 )?),
6150 })
6151 }
6152 }
6153 #[derive(Copy, Clone)]
6154 pub struct SpatialAnchorPersistenceMSFT {
6155 pub create_spatial_anchor_store_connection: pfn::CreateSpatialAnchorStoreConnectionMSFT,
6156 pub destroy_spatial_anchor_store_connection: pfn::DestroySpatialAnchorStoreConnectionMSFT,
6157 pub persist_spatial_anchor: pfn::PersistSpatialAnchorMSFT,
6158 pub enumerate_persisted_spatial_anchor_names: pfn::EnumeratePersistedSpatialAnchorNamesMSFT,
6159 pub create_spatial_anchor_from_persisted_name:
6160 pfn::CreateSpatialAnchorFromPersistedNameMSFT,
6161 pub unpersist_spatial_anchor: pfn::UnpersistSpatialAnchorMSFT,
6162 pub clear_spatial_anchor_store: pfn::ClearSpatialAnchorStoreMSFT,
6163 }
6164 impl SpatialAnchorPersistenceMSFT {
6165 pub const VERSION: u32 = sys::MSFT_spatial_anchor_persistence_SPEC_VERSION;
6166 pub const NAME: &'static [u8] = sys::MSFT_SPATIAL_ANCHOR_PERSISTENCE_EXTENSION_NAME;
6167 #[doc = r" Load the extension's function pointer table"]
6168 #[doc = r""]
6169 #[doc = r" # Safety"]
6170 #[doc = r""]
6171 #[doc = r" `instance` must be a valid instance handle."]
6172 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6173 Ok(Self {
6174 create_spatial_anchor_store_connection: mem::transmute(
6175 entry.get_instance_proc_addr(
6176 instance,
6177 CStr::from_bytes_with_nul_unchecked(
6178 b"xrCreateSpatialAnchorStoreConnectionMSFT\0",
6179 ),
6180 )?,
6181 ),
6182 destroy_spatial_anchor_store_connection: mem::transmute(
6183 entry.get_instance_proc_addr(
6184 instance,
6185 CStr::from_bytes_with_nul_unchecked(
6186 b"xrDestroySpatialAnchorStoreConnectionMSFT\0",
6187 ),
6188 )?,
6189 ),
6190 persist_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
6191 instance,
6192 CStr::from_bytes_with_nul_unchecked(b"xrPersistSpatialAnchorMSFT\0"),
6193 )?),
6194 enumerate_persisted_spatial_anchor_names: mem::transmute(
6195 entry.get_instance_proc_addr(
6196 instance,
6197 CStr::from_bytes_with_nul_unchecked(
6198 b"xrEnumeratePersistedSpatialAnchorNamesMSFT\0",
6199 ),
6200 )?,
6201 ),
6202 create_spatial_anchor_from_persisted_name: mem::transmute(
6203 entry.get_instance_proc_addr(
6204 instance,
6205 CStr::from_bytes_with_nul_unchecked(
6206 b"xrCreateSpatialAnchorFromPersistedNameMSFT\0",
6207 ),
6208 )?,
6209 ),
6210 unpersist_spatial_anchor: mem::transmute(entry.get_instance_proc_addr(
6211 instance,
6212 CStr::from_bytes_with_nul_unchecked(b"xrUnpersistSpatialAnchorMSFT\0"),
6213 )?),
6214 clear_spatial_anchor_store: mem::transmute(entry.get_instance_proc_addr(
6215 instance,
6216 CStr::from_bytes_with_nul_unchecked(b"xrClearSpatialAnchorStoreMSFT\0"),
6217 )?),
6218 })
6219 }
6220 }
6221 #[cfg(target_os = "android")]
6222 #[derive(Copy, Clone)]
6223 pub struct AndroidSessionStateEnableOCULUS {}
6224 #[cfg(target_os = "android")]
6225 impl AndroidSessionStateEnableOCULUS {
6226 pub const VERSION: u32 = sys::OCULUS_android_session_state_enable_SPEC_VERSION;
6227 pub const NAME: &'static [u8] = sys::OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME;
6228 }
6229 #[derive(Copy, Clone)]
6230 pub struct AudioDeviceGuidOCULUS {
6231 pub get_audio_output_device_guid: pfn::GetAudioOutputDeviceGuidOculus,
6232 pub get_audio_input_device_guid: pfn::GetAudioInputDeviceGuidOculus,
6233 }
6234 impl AudioDeviceGuidOCULUS {
6235 pub const VERSION: u32 = sys::OCULUS_audio_device_guid_SPEC_VERSION;
6236 pub const NAME: &'static [u8] = sys::OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME;
6237 #[doc = r" Load the extension's function pointer table"]
6238 #[doc = r""]
6239 #[doc = r" # Safety"]
6240 #[doc = r""]
6241 #[doc = r" `instance` must be a valid instance handle."]
6242 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6243 Ok(Self {
6244 get_audio_output_device_guid: mem::transmute(entry.get_instance_proc_addr(
6245 instance,
6246 CStr::from_bytes_with_nul_unchecked(b"xrGetAudioOutputDeviceGuidOculus\0"),
6247 )?),
6248 get_audio_input_device_guid: mem::transmute(entry.get_instance_proc_addr(
6249 instance,
6250 CStr::from_bytes_with_nul_unchecked(b"xrGetAudioInputDeviceGuidOculus\0"),
6251 )?),
6252 })
6253 }
6254 }
6255 #[derive(Copy, Clone)]
6256 pub struct ExternalCameraOCULUS {
6257 pub enumerate_external_cameras: pfn::EnumerateExternalCamerasOCULUS,
6258 }
6259 impl ExternalCameraOCULUS {
6260 pub const VERSION: u32 = sys::OCULUS_external_camera_SPEC_VERSION;
6261 pub const NAME: &'static [u8] = sys::OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME;
6262 #[doc = r" Load the extension's function pointer table"]
6263 #[doc = r""]
6264 #[doc = r" # Safety"]
6265 #[doc = r""]
6266 #[doc = r" `instance` must be a valid instance handle."]
6267 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6268 Ok(Self {
6269 enumerate_external_cameras: mem::transmute(entry.get_instance_proc_addr(
6270 instance,
6271 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateExternalCamerasOCULUS\0"),
6272 )?),
6273 })
6274 }
6275 }
6276 #[derive(Copy, Clone)]
6277 pub struct ControllerInteractionOPPO {}
6278 impl ControllerInteractionOPPO {
6279 pub const VERSION: u32 = sys::OPPO_controller_interaction_SPEC_VERSION;
6280 pub const NAME: &'static [u8] = sys::OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME;
6281 }
6282 #[derive(Copy, Clone)]
6283 pub struct TrackingOptimizationSettingsQCOM {
6284 pub set_tracking_optimization_settings_hint: pfn::SetTrackingOptimizationSettingsHintQCOM,
6285 }
6286 impl TrackingOptimizationSettingsQCOM {
6287 pub const VERSION: u32 = sys::QCOM_tracking_optimization_settings_SPEC_VERSION;
6288 pub const NAME: &'static [u8] = sys::QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME;
6289 #[doc = r" Load the extension's function pointer table"]
6290 #[doc = r""]
6291 #[doc = r" # Safety"]
6292 #[doc = r""]
6293 #[doc = r" `instance` must be a valid instance handle."]
6294 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6295 Ok(Self {
6296 set_tracking_optimization_settings_hint: mem::transmute(
6297 entry.get_instance_proc_addr(
6298 instance,
6299 CStr::from_bytes_with_nul_unchecked(
6300 b"xrSetTrackingOptimizationSettingsHintQCOM\0",
6301 ),
6302 )?,
6303 ),
6304 })
6305 }
6306 }
6307 #[derive(Copy, Clone)]
6308 pub struct HandTrackingForearmULTRALEAP {}
6309 impl HandTrackingForearmULTRALEAP {
6310 pub const VERSION: u32 = sys::ULTRALEAP_hand_tracking_forearm_SPEC_VERSION;
6311 pub const NAME: &'static [u8] = sys::ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME;
6312 }
6313 #[derive(Copy, Clone)]
6314 pub struct AnalogThresholdVALVE {}
6315 impl AnalogThresholdVALVE {
6316 pub const VERSION: u32 = sys::VALVE_analog_threshold_SPEC_VERSION;
6317 pub const NAME: &'static [u8] = sys::VALVE_ANALOG_THRESHOLD_EXTENSION_NAME;
6318 }
6319 #[derive(Copy, Clone)]
6320 pub struct QuadViewsVARJO {}
6321 impl QuadViewsVARJO {
6322 pub const VERSION: u32 = sys::VARJO_quad_views_SPEC_VERSION;
6323 pub const NAME: &'static [u8] = sys::VARJO_QUAD_VIEWS_EXTENSION_NAME;
6324 }
6325 #[derive(Copy, Clone)]
6326 pub struct FoveatedRenderingVARJO {}
6327 impl FoveatedRenderingVARJO {
6328 pub const VERSION: u32 = sys::VARJO_foveated_rendering_SPEC_VERSION;
6329 pub const NAME: &'static [u8] = sys::VARJO_FOVEATED_RENDERING_EXTENSION_NAME;
6330 }
6331 #[derive(Copy, Clone)]
6332 pub struct CompositionLayerDepthTestVARJO {}
6333 impl CompositionLayerDepthTestVARJO {
6334 pub const VERSION: u32 = sys::VARJO_composition_layer_depth_test_SPEC_VERSION;
6335 pub const NAME: &'static [u8] = sys::VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME;
6336 }
6337 #[derive(Copy, Clone)]
6338 pub struct EnvironmentDepthEstimationVARJO {
6339 pub set_environment_depth_estimation: pfn::SetEnvironmentDepthEstimationVARJO,
6340 }
6341 impl EnvironmentDepthEstimationVARJO {
6342 pub const VERSION: u32 = sys::VARJO_environment_depth_estimation_SPEC_VERSION;
6343 pub const NAME: &'static [u8] = sys::VARJO_ENVIRONMENT_DEPTH_ESTIMATION_EXTENSION_NAME;
6344 #[doc = r" Load the extension's function pointer table"]
6345 #[doc = r""]
6346 #[doc = r" # Safety"]
6347 #[doc = r""]
6348 #[doc = r" `instance` must be a valid instance handle."]
6349 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6350 Ok(Self {
6351 set_environment_depth_estimation: mem::transmute(entry.get_instance_proc_addr(
6352 instance,
6353 CStr::from_bytes_with_nul_unchecked(b"xrSetEnvironmentDepthEstimationVARJO\0"),
6354 )?),
6355 })
6356 }
6357 }
6358 #[derive(Copy, Clone)]
6359 pub struct MarkerTrackingVARJO {
6360 pub set_marker_tracking: pfn::SetMarkerTrackingVARJO,
6361 pub set_marker_tracking_timeout: pfn::SetMarkerTrackingTimeoutVARJO,
6362 pub set_marker_tracking_prediction: pfn::SetMarkerTrackingPredictionVARJO,
6363 pub get_marker_size: pfn::GetMarkerSizeVARJO,
6364 pub create_marker_space: pfn::CreateMarkerSpaceVARJO,
6365 }
6366 impl MarkerTrackingVARJO {
6367 pub const VERSION: u32 = sys::VARJO_marker_tracking_SPEC_VERSION;
6368 pub const NAME: &'static [u8] = sys::VARJO_MARKER_TRACKING_EXTENSION_NAME;
6369 #[doc = r" Load the extension's function pointer table"]
6370 #[doc = r""]
6371 #[doc = r" # Safety"]
6372 #[doc = r""]
6373 #[doc = r" `instance` must be a valid instance handle."]
6374 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6375 Ok(Self {
6376 set_marker_tracking: mem::transmute(entry.get_instance_proc_addr(
6377 instance,
6378 CStr::from_bytes_with_nul_unchecked(b"xrSetMarkerTrackingVARJO\0"),
6379 )?),
6380 set_marker_tracking_timeout: mem::transmute(entry.get_instance_proc_addr(
6381 instance,
6382 CStr::from_bytes_with_nul_unchecked(b"xrSetMarkerTrackingTimeoutVARJO\0"),
6383 )?),
6384 set_marker_tracking_prediction: mem::transmute(entry.get_instance_proc_addr(
6385 instance,
6386 CStr::from_bytes_with_nul_unchecked(b"xrSetMarkerTrackingPredictionVARJO\0"),
6387 )?),
6388 get_marker_size: mem::transmute(entry.get_instance_proc_addr(
6389 instance,
6390 CStr::from_bytes_with_nul_unchecked(b"xrGetMarkerSizeVARJO\0"),
6391 )?),
6392 create_marker_space: mem::transmute(entry.get_instance_proc_addr(
6393 instance,
6394 CStr::from_bytes_with_nul_unchecked(b"xrCreateMarkerSpaceVARJO\0"),
6395 )?),
6396 })
6397 }
6398 }
6399 #[derive(Copy, Clone)]
6400 pub struct ViewOffsetVARJO {
6401 pub set_view_offset: pfn::SetViewOffsetVARJO,
6402 }
6403 impl ViewOffsetVARJO {
6404 pub const VERSION: u32 = sys::VARJO_view_offset_SPEC_VERSION;
6405 pub const NAME: &'static [u8] = sys::VARJO_VIEW_OFFSET_EXTENSION_NAME;
6406 #[doc = r" Load the extension's function pointer table"]
6407 #[doc = r""]
6408 #[doc = r" # Safety"]
6409 #[doc = r""]
6410 #[doc = r" `instance` must be a valid instance handle."]
6411 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6412 Ok(Self {
6413 set_view_offset: mem::transmute(entry.get_instance_proc_addr(
6414 instance,
6415 CStr::from_bytes_with_nul_unchecked(b"xrSetViewOffsetVARJO\0"),
6416 )?),
6417 })
6418 }
6419 }
6420 #[derive(Copy, Clone)]
6421 pub struct Xr4ControllerInteractionVARJO {}
6422 impl Xr4ControllerInteractionVARJO {
6423 pub const VERSION: u32 = sys::VARJO_xr4_controller_interaction_SPEC_VERSION;
6424 pub const NAME: &'static [u8] = sys::VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME;
6425 }
6426 #[derive(Copy, Clone)]
6427 pub struct ControllerInteractionYVR {}
6428 impl ControllerInteractionYVR {
6429 pub const VERSION: u32 = sys::YVR_controller_interaction_SPEC_VERSION;
6430 pub const NAME: &'static [u8] = sys::YVR_CONTROLLER_INTERACTION_EXTENSION_NAME;
6431 }
6432 #[derive(Copy, Clone)]
6433 pub struct OverlayEXTX {}
6434 impl OverlayEXTX {
6435 pub const VERSION: u32 = sys::EXTX_overlay_SPEC_VERSION;
6436 pub const NAME: &'static [u8] = sys::EXTX_OVERLAY_EXTENSION_NAME;
6437 }
6438 #[derive(Copy, Clone)]
6439 pub struct EglEnableMNDX {}
6440 impl EglEnableMNDX {
6441 pub const VERSION: u32 = sys::MNDX_egl_enable_SPEC_VERSION;
6442 pub const NAME: &'static [u8] = sys::MNDX_EGL_ENABLE_EXTENSION_NAME;
6443 }
6444 #[derive(Copy, Clone)]
6445 pub struct ForceFeedbackCurlMNDX {
6446 pub apply_force_feedback_curl: pfn::ApplyForceFeedbackCurlMNDX,
6447 }
6448 impl ForceFeedbackCurlMNDX {
6449 pub const VERSION: u32 = sys::MNDX_force_feedback_curl_SPEC_VERSION;
6450 pub const NAME: &'static [u8] = sys::MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME;
6451 #[doc = r" Load the extension's function pointer table"]
6452 #[doc = r""]
6453 #[doc = r" # Safety"]
6454 #[doc = r""]
6455 #[doc = r" `instance` must be a valid instance handle."]
6456 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6457 Ok(Self {
6458 apply_force_feedback_curl: mem::transmute(entry.get_instance_proc_addr(
6459 instance,
6460 CStr::from_bytes_with_nul_unchecked(b"xrApplyForceFeedbackCurlMNDX\0"),
6461 )?),
6462 })
6463 }
6464 }
6465 #[derive(Copy, Clone)]
6466 pub struct ViveTrackerInteractionHTCX {
6467 pub enumerate_vive_tracker_paths: pfn::EnumerateViveTrackerPathsHTCX,
6468 }
6469 impl ViveTrackerInteractionHTCX {
6470 pub const VERSION: u32 = sys::HTCX_vive_tracker_interaction_SPEC_VERSION;
6471 pub const NAME: &'static [u8] = sys::HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME;
6472 #[doc = r" Load the extension's function pointer table"]
6473 #[doc = r""]
6474 #[doc = r" # Safety"]
6475 #[doc = r""]
6476 #[doc = r" `instance` must be a valid instance handle."]
6477 pub unsafe fn load(entry: &Entry, instance: sys::Instance) -> Result<Self> {
6478 Ok(Self {
6479 enumerate_vive_tracker_paths: mem::transmute(entry.get_instance_proc_addr(
6480 instance,
6481 CStr::from_bytes_with_nul_unchecked(b"xrEnumerateViveTrackerPathsHTCX\0"),
6482 )?),
6483 })
6484 }
6485 }
6486}
6487#[allow(unused)]
6488pub(crate) mod builder {
6489 use crate::*;
6490 use std::{marker::PhantomData, mem, ops::Deref};
6491 #[derive(Copy, Clone)]
6492 #[repr(transparent)]
6493 pub struct SwapchainSubImage<'a, G: Graphics> {
6494 inner: sys::SwapchainSubImage,
6495 _marker: PhantomData<&'a G>,
6496 }
6497 impl<'a, G: Graphics> SwapchainSubImage<'a, G> {
6498 #[inline]
6499 pub fn new() -> Self {
6500 Self {
6501 inner: sys::SwapchainSubImage {
6502 ..unsafe { mem::zeroed() }
6503 },
6504 _marker: PhantomData,
6505 }
6506 }
6507 #[doc = r" Initialize with the supplied raw values"]
6508 #[doc = r""]
6509 #[doc = r" # Safety"]
6510 #[doc = r""]
6511 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6512 #[doc = r" preserved."]
6513 #[inline]
6514 pub unsafe fn from_raw(inner: sys::SwapchainSubImage) -> Self {
6515 Self {
6516 inner,
6517 _marker: PhantomData,
6518 }
6519 }
6520 #[inline]
6521 pub fn into_raw(self) -> sys::SwapchainSubImage {
6522 self.inner
6523 }
6524 #[inline]
6525 pub fn as_raw(&self) -> &sys::SwapchainSubImage {
6526 &self.inner
6527 }
6528 #[inline]
6529 pub fn swapchain(mut self, value: &'a Swapchain<G>) -> Self {
6530 self.inner.swapchain = value.as_raw();
6531 self
6532 }
6533 #[inline]
6534 pub fn image_rect(mut self, value: Rect2Di) -> Self {
6535 self.inner.image_rect = value;
6536 self
6537 }
6538 #[inline]
6539 pub fn image_array_index(mut self, value: u32) -> Self {
6540 self.inner.image_array_index = value;
6541 self
6542 }
6543 }
6544 impl<'a, G: Graphics> Default for SwapchainSubImage<'a, G> {
6545 fn default() -> Self {
6546 Self::new()
6547 }
6548 }
6549 #[derive(Copy, Clone)]
6550 #[repr(transparent)]
6551 pub struct CompositionLayerProjectionView<'a, G: Graphics> {
6552 inner: sys::CompositionLayerProjectionView,
6553 _marker: PhantomData<&'a G>,
6554 }
6555 impl<'a, G: Graphics> CompositionLayerProjectionView<'a, G> {
6556 #[inline]
6557 pub fn new() -> Self {
6558 Self {
6559 inner: sys::CompositionLayerProjectionView {
6560 ty: sys::StructureType::COMPOSITION_LAYER_PROJECTION_VIEW,
6561 ..unsafe { mem::zeroed() }
6562 },
6563 _marker: PhantomData,
6564 }
6565 }
6566 #[doc = r" Initialize with the supplied raw values"]
6567 #[doc = r""]
6568 #[doc = r" # Safety"]
6569 #[doc = r""]
6570 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6571 #[doc = r" preserved."]
6572 #[inline]
6573 pub unsafe fn from_raw(inner: sys::CompositionLayerProjectionView) -> Self {
6574 Self {
6575 inner,
6576 _marker: PhantomData,
6577 }
6578 }
6579 #[inline]
6580 pub fn into_raw(self) -> sys::CompositionLayerProjectionView {
6581 self.inner
6582 }
6583 #[inline]
6584 pub fn as_raw(&self) -> &sys::CompositionLayerProjectionView {
6585 &self.inner
6586 }
6587 #[inline]
6588 pub fn pose(mut self, value: Posef) -> Self {
6589 self.inner.pose = value;
6590 self
6591 }
6592 #[inline]
6593 pub fn fov(mut self, value: Fovf) -> Self {
6594 self.inner.fov = value;
6595 self
6596 }
6597 #[inline]
6598 pub fn sub_image(mut self, value: SwapchainSubImage<'a, G>) -> Self {
6599 self.inner.sub_image = value.inner;
6600 self
6601 }
6602 }
6603 impl<'a, G: Graphics> Default for CompositionLayerProjectionView<'a, G> {
6604 fn default() -> Self {
6605 Self::new()
6606 }
6607 }
6608 #[derive(Copy, Clone)]
6609 #[repr(transparent)]
6610 pub struct ActionSetCreateInfo<'a> {
6611 inner: sys::ActionSetCreateInfo,
6612 _marker: PhantomData<&'a ()>,
6613 }
6614 impl<'a> ActionSetCreateInfo<'a> {
6615 #[inline]
6616 pub fn new() -> Self {
6617 Self {
6618 inner: sys::ActionSetCreateInfo {
6619 ty: sys::StructureType::ACTION_SET_CREATE_INFO,
6620 ..unsafe { mem::zeroed() }
6621 },
6622 _marker: PhantomData,
6623 }
6624 }
6625 #[doc = r" Initialize with the supplied raw values"]
6626 #[doc = r""]
6627 #[doc = r" # Safety"]
6628 #[doc = r""]
6629 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6630 #[doc = r" preserved."]
6631 #[inline]
6632 pub unsafe fn from_raw(inner: sys::ActionSetCreateInfo) -> Self {
6633 Self {
6634 inner,
6635 _marker: PhantomData,
6636 }
6637 }
6638 #[inline]
6639 pub fn into_raw(self) -> sys::ActionSetCreateInfo {
6640 self.inner
6641 }
6642 #[inline]
6643 pub fn as_raw(&self) -> &sys::ActionSetCreateInfo {
6644 &self.inner
6645 }
6646 #[inline]
6647 pub fn action_set_name(mut self, value: &str) -> Self {
6648 place_cstr(&mut self.inner.action_set_name, value);
6649 self
6650 }
6651 #[inline]
6652 pub fn localized_action_set_name(mut self, value: &str) -> Self {
6653 place_cstr(&mut self.inner.localized_action_set_name, value);
6654 self
6655 }
6656 #[inline]
6657 pub fn priority(mut self, value: u32) -> Self {
6658 self.inner.priority = value;
6659 self
6660 }
6661 }
6662 impl<'a> Default for ActionSetCreateInfo<'a> {
6663 fn default() -> Self {
6664 Self::new()
6665 }
6666 }
6667 #[derive(Copy, Clone)]
6668 #[repr(transparent)]
6669 pub struct ActionCreateInfo<'a> {
6670 inner: sys::ActionCreateInfo,
6671 _marker: PhantomData<&'a ()>,
6672 }
6673 impl<'a> ActionCreateInfo<'a> {
6674 #[inline]
6675 pub fn new() -> Self {
6676 Self {
6677 inner: sys::ActionCreateInfo {
6678 ty: sys::StructureType::ACTION_CREATE_INFO,
6679 ..unsafe { mem::zeroed() }
6680 },
6681 _marker: PhantomData,
6682 }
6683 }
6684 #[doc = r" Initialize with the supplied raw values"]
6685 #[doc = r""]
6686 #[doc = r" # Safety"]
6687 #[doc = r""]
6688 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6689 #[doc = r" preserved."]
6690 #[inline]
6691 pub unsafe fn from_raw(inner: sys::ActionCreateInfo) -> Self {
6692 Self {
6693 inner,
6694 _marker: PhantomData,
6695 }
6696 }
6697 #[inline]
6698 pub fn into_raw(self) -> sys::ActionCreateInfo {
6699 self.inner
6700 }
6701 #[inline]
6702 pub fn as_raw(&self) -> &sys::ActionCreateInfo {
6703 &self.inner
6704 }
6705 #[inline]
6706 pub fn action_name(mut self, value: &str) -> Self {
6707 place_cstr(&mut self.inner.action_name, value);
6708 self
6709 }
6710 #[inline]
6711 pub fn action_type(mut self, value: ActionType) -> Self {
6712 self.inner.action_type = value;
6713 self
6714 }
6715 #[inline]
6716 pub fn subaction_paths(mut self, value: &'a [Path]) -> Self {
6717 self.inner.subaction_paths = value.as_ptr() as *const _ as _;
6718 self.inner.count_subaction_paths = value.len() as u32;
6719 self
6720 }
6721 #[inline]
6722 pub fn localized_action_name(mut self, value: &str) -> Self {
6723 place_cstr(&mut self.inner.localized_action_name, value);
6724 self
6725 }
6726 }
6727 impl<'a> Default for ActionCreateInfo<'a> {
6728 fn default() -> Self {
6729 Self::new()
6730 }
6731 }
6732 #[repr(transparent)]
6733 pub struct CompositionLayerBase<'a, G: Graphics> {
6734 _inner: sys::CompositionLayerBaseHeader,
6735 _marker: PhantomData<&'a G>,
6736 }
6737 #[derive(Copy, Clone)]
6738 #[repr(transparent)]
6739 pub struct CompositionLayerProjection<'a, G: Graphics> {
6740 inner: sys::CompositionLayerProjection,
6741 _marker: PhantomData<&'a G>,
6742 }
6743 impl<'a, G: Graphics> CompositionLayerProjection<'a, G> {
6744 #[inline]
6745 pub fn new() -> Self {
6746 Self {
6747 inner: sys::CompositionLayerProjection {
6748 ty: sys::StructureType::COMPOSITION_LAYER_PROJECTION,
6749 ..unsafe { mem::zeroed() }
6750 },
6751 _marker: PhantomData,
6752 }
6753 }
6754 #[doc = r" Initialize with the supplied raw values"]
6755 #[doc = r""]
6756 #[doc = r" # Safety"]
6757 #[doc = r""]
6758 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6759 #[doc = r" preserved."]
6760 #[inline]
6761 pub unsafe fn from_raw(inner: sys::CompositionLayerProjection) -> Self {
6762 Self {
6763 inner,
6764 _marker: PhantomData,
6765 }
6766 }
6767 #[inline]
6768 pub fn into_raw(self) -> sys::CompositionLayerProjection {
6769 self.inner
6770 }
6771 #[inline]
6772 pub fn as_raw(&self) -> &sys::CompositionLayerProjection {
6773 &self.inner
6774 }
6775 #[inline]
6776 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
6777 self.inner.layer_flags = value;
6778 self
6779 }
6780 #[inline]
6781 pub fn space(mut self, value: &'a Space) -> Self {
6782 self.inner.space = value.as_raw();
6783 self
6784 }
6785 #[inline]
6786 pub fn views(mut self, value: &'a [CompositionLayerProjectionView<'a, G>]) -> Self {
6787 self.inner.views = value.as_ptr() as *const _ as _;
6788 self.inner.view_count = value.len() as u32;
6789 self
6790 }
6791 }
6792 impl<'a, G: Graphics> Deref for CompositionLayerProjection<'a, G> {
6793 type Target = CompositionLayerBase<'a, G>;
6794 #[inline]
6795 fn deref(&self) -> &Self::Target {
6796 unsafe { mem::transmute(&self.inner) }
6797 }
6798 }
6799 impl<'a, G: Graphics> Default for CompositionLayerProjection<'a, G> {
6800 fn default() -> Self {
6801 Self::new()
6802 }
6803 }
6804 #[derive(Copy, Clone)]
6805 #[repr(transparent)]
6806 pub struct CompositionLayerQuad<'a, G: Graphics> {
6807 inner: sys::CompositionLayerQuad,
6808 _marker: PhantomData<&'a G>,
6809 }
6810 impl<'a, G: Graphics> CompositionLayerQuad<'a, G> {
6811 #[inline]
6812 pub fn new() -> Self {
6813 Self {
6814 inner: sys::CompositionLayerQuad {
6815 ty: sys::StructureType::COMPOSITION_LAYER_QUAD,
6816 ..unsafe { mem::zeroed() }
6817 },
6818 _marker: PhantomData,
6819 }
6820 }
6821 #[doc = r" Initialize with the supplied raw values"]
6822 #[doc = r""]
6823 #[doc = r" # Safety"]
6824 #[doc = r""]
6825 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6826 #[doc = r" preserved."]
6827 #[inline]
6828 pub unsafe fn from_raw(inner: sys::CompositionLayerQuad) -> Self {
6829 Self {
6830 inner,
6831 _marker: PhantomData,
6832 }
6833 }
6834 #[inline]
6835 pub fn into_raw(self) -> sys::CompositionLayerQuad {
6836 self.inner
6837 }
6838 #[inline]
6839 pub fn as_raw(&self) -> &sys::CompositionLayerQuad {
6840 &self.inner
6841 }
6842 #[inline]
6843 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
6844 self.inner.layer_flags = value;
6845 self
6846 }
6847 #[inline]
6848 pub fn space(mut self, value: &'a Space) -> Self {
6849 self.inner.space = value.as_raw();
6850 self
6851 }
6852 #[inline]
6853 pub fn eye_visibility(mut self, value: EyeVisibility) -> Self {
6854 self.inner.eye_visibility = value;
6855 self
6856 }
6857 #[inline]
6858 pub fn sub_image(mut self, value: SwapchainSubImage<'a, G>) -> Self {
6859 self.inner.sub_image = value.inner;
6860 self
6861 }
6862 #[inline]
6863 pub fn pose(mut self, value: Posef) -> Self {
6864 self.inner.pose = value;
6865 self
6866 }
6867 #[inline]
6868 pub fn size(mut self, value: Extent2Df) -> Self {
6869 self.inner.size = value;
6870 self
6871 }
6872 }
6873 impl<'a, G: Graphics> Deref for CompositionLayerQuad<'a, G> {
6874 type Target = CompositionLayerBase<'a, G>;
6875 #[inline]
6876 fn deref(&self) -> &Self::Target {
6877 unsafe { mem::transmute(&self.inner) }
6878 }
6879 }
6880 impl<'a, G: Graphics> Default for CompositionLayerQuad<'a, G> {
6881 fn default() -> Self {
6882 Self::new()
6883 }
6884 }
6885 #[derive(Copy, Clone)]
6886 #[repr(transparent)]
6887 pub struct CompositionLayerCylinderKHR<'a, G: Graphics> {
6888 inner: sys::CompositionLayerCylinderKHR,
6889 _marker: PhantomData<&'a G>,
6890 }
6891 impl<'a, G: Graphics> CompositionLayerCylinderKHR<'a, G> {
6892 #[inline]
6893 pub fn new() -> Self {
6894 Self {
6895 inner: sys::CompositionLayerCylinderKHR {
6896 ty: sys::StructureType::COMPOSITION_LAYER_CYLINDER_KHR,
6897 ..unsafe { mem::zeroed() }
6898 },
6899 _marker: PhantomData,
6900 }
6901 }
6902 #[doc = r" Initialize with the supplied raw values"]
6903 #[doc = r""]
6904 #[doc = r" # Safety"]
6905 #[doc = r""]
6906 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6907 #[doc = r" preserved."]
6908 #[inline]
6909 pub unsafe fn from_raw(inner: sys::CompositionLayerCylinderKHR) -> Self {
6910 Self {
6911 inner,
6912 _marker: PhantomData,
6913 }
6914 }
6915 #[inline]
6916 pub fn into_raw(self) -> sys::CompositionLayerCylinderKHR {
6917 self.inner
6918 }
6919 #[inline]
6920 pub fn as_raw(&self) -> &sys::CompositionLayerCylinderKHR {
6921 &self.inner
6922 }
6923 #[inline]
6924 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
6925 self.inner.layer_flags = value;
6926 self
6927 }
6928 #[inline]
6929 pub fn space(mut self, value: &'a Space) -> Self {
6930 self.inner.space = value.as_raw();
6931 self
6932 }
6933 #[inline]
6934 pub fn eye_visibility(mut self, value: EyeVisibility) -> Self {
6935 self.inner.eye_visibility = value;
6936 self
6937 }
6938 #[inline]
6939 pub fn sub_image(mut self, value: SwapchainSubImage<'a, G>) -> Self {
6940 self.inner.sub_image = value.inner;
6941 self
6942 }
6943 #[inline]
6944 pub fn pose(mut self, value: Posef) -> Self {
6945 self.inner.pose = value;
6946 self
6947 }
6948 #[inline]
6949 pub fn radius(mut self, value: f32) -> Self {
6950 self.inner.radius = value;
6951 self
6952 }
6953 #[inline]
6954 pub fn central_angle(mut self, value: f32) -> Self {
6955 self.inner.central_angle = value;
6956 self
6957 }
6958 #[inline]
6959 pub fn aspect_ratio(mut self, value: f32) -> Self {
6960 self.inner.aspect_ratio = value;
6961 self
6962 }
6963 }
6964 impl<'a, G: Graphics> Deref for CompositionLayerCylinderKHR<'a, G> {
6965 type Target = CompositionLayerBase<'a, G>;
6966 #[inline]
6967 fn deref(&self) -> &Self::Target {
6968 unsafe { mem::transmute(&self.inner) }
6969 }
6970 }
6971 impl<'a, G: Graphics> Default for CompositionLayerCylinderKHR<'a, G> {
6972 fn default() -> Self {
6973 Self::new()
6974 }
6975 }
6976 #[derive(Copy, Clone)]
6977 #[repr(transparent)]
6978 pub struct CompositionLayerCubeKHR<'a, G: Graphics> {
6979 inner: sys::CompositionLayerCubeKHR,
6980 _marker: PhantomData<&'a G>,
6981 }
6982 impl<'a, G: Graphics> CompositionLayerCubeKHR<'a, G> {
6983 #[inline]
6984 pub fn new() -> Self {
6985 Self {
6986 inner: sys::CompositionLayerCubeKHR {
6987 ty: sys::StructureType::COMPOSITION_LAYER_CUBE_KHR,
6988 ..unsafe { mem::zeroed() }
6989 },
6990 _marker: PhantomData,
6991 }
6992 }
6993 #[doc = r" Initialize with the supplied raw values"]
6994 #[doc = r""]
6995 #[doc = r" # Safety"]
6996 #[doc = r""]
6997 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
6998 #[doc = r" preserved."]
6999 #[inline]
7000 pub unsafe fn from_raw(inner: sys::CompositionLayerCubeKHR) -> Self {
7001 Self {
7002 inner,
7003 _marker: PhantomData,
7004 }
7005 }
7006 #[inline]
7007 pub fn into_raw(self) -> sys::CompositionLayerCubeKHR {
7008 self.inner
7009 }
7010 #[inline]
7011 pub fn as_raw(&self) -> &sys::CompositionLayerCubeKHR {
7012 &self.inner
7013 }
7014 #[inline]
7015 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
7016 self.inner.layer_flags = value;
7017 self
7018 }
7019 #[inline]
7020 pub fn space(mut self, value: &'a Space) -> Self {
7021 self.inner.space = value.as_raw();
7022 self
7023 }
7024 #[inline]
7025 pub fn eye_visibility(mut self, value: EyeVisibility) -> Self {
7026 self.inner.eye_visibility = value;
7027 self
7028 }
7029 #[inline]
7030 pub fn swapchain(mut self, value: &'a Swapchain<G>) -> Self {
7031 self.inner.swapchain = value.as_raw();
7032 self
7033 }
7034 #[inline]
7035 pub fn image_array_index(mut self, value: u32) -> Self {
7036 self.inner.image_array_index = value;
7037 self
7038 }
7039 #[inline]
7040 pub fn orientation(mut self, value: Quaternionf) -> Self {
7041 self.inner.orientation = value;
7042 self
7043 }
7044 }
7045 impl<'a, G: Graphics> Deref for CompositionLayerCubeKHR<'a, G> {
7046 type Target = CompositionLayerBase<'a, G>;
7047 #[inline]
7048 fn deref(&self) -> &Self::Target {
7049 unsafe { mem::transmute(&self.inner) }
7050 }
7051 }
7052 impl<'a, G: Graphics> Default for CompositionLayerCubeKHR<'a, G> {
7053 fn default() -> Self {
7054 Self::new()
7055 }
7056 }
7057 #[derive(Copy, Clone)]
7058 #[repr(transparent)]
7059 pub struct CompositionLayerEquirectKHR<'a, G: Graphics> {
7060 inner: sys::CompositionLayerEquirectKHR,
7061 _marker: PhantomData<&'a G>,
7062 }
7063 impl<'a, G: Graphics> CompositionLayerEquirectKHR<'a, G> {
7064 #[inline]
7065 pub fn new() -> Self {
7066 Self {
7067 inner: sys::CompositionLayerEquirectKHR {
7068 ty: sys::StructureType::COMPOSITION_LAYER_EQUIRECT_KHR,
7069 ..unsafe { mem::zeroed() }
7070 },
7071 _marker: PhantomData,
7072 }
7073 }
7074 #[doc = r" Initialize with the supplied raw values"]
7075 #[doc = r""]
7076 #[doc = r" # Safety"]
7077 #[doc = r""]
7078 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7079 #[doc = r" preserved."]
7080 #[inline]
7081 pub unsafe fn from_raw(inner: sys::CompositionLayerEquirectKHR) -> Self {
7082 Self {
7083 inner,
7084 _marker: PhantomData,
7085 }
7086 }
7087 #[inline]
7088 pub fn into_raw(self) -> sys::CompositionLayerEquirectKHR {
7089 self.inner
7090 }
7091 #[inline]
7092 pub fn as_raw(&self) -> &sys::CompositionLayerEquirectKHR {
7093 &self.inner
7094 }
7095 #[inline]
7096 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
7097 self.inner.layer_flags = value;
7098 self
7099 }
7100 #[inline]
7101 pub fn space(mut self, value: &'a Space) -> Self {
7102 self.inner.space = value.as_raw();
7103 self
7104 }
7105 #[inline]
7106 pub fn eye_visibility(mut self, value: EyeVisibility) -> Self {
7107 self.inner.eye_visibility = value;
7108 self
7109 }
7110 #[inline]
7111 pub fn sub_image(mut self, value: SwapchainSubImage<'a, G>) -> Self {
7112 self.inner.sub_image = value.inner;
7113 self
7114 }
7115 #[inline]
7116 pub fn pose(mut self, value: Posef) -> Self {
7117 self.inner.pose = value;
7118 self
7119 }
7120 #[inline]
7121 pub fn radius(mut self, value: f32) -> Self {
7122 self.inner.radius = value;
7123 self
7124 }
7125 #[inline]
7126 pub fn scale(mut self, value: Vector2f) -> Self {
7127 self.inner.scale = value;
7128 self
7129 }
7130 #[inline]
7131 pub fn bias(mut self, value: Vector2f) -> Self {
7132 self.inner.bias = value;
7133 self
7134 }
7135 }
7136 impl<'a, G: Graphics> Deref for CompositionLayerEquirectKHR<'a, G> {
7137 type Target = CompositionLayerBase<'a, G>;
7138 #[inline]
7139 fn deref(&self) -> &Self::Target {
7140 unsafe { mem::transmute(&self.inner) }
7141 }
7142 }
7143 impl<'a, G: Graphics> Default for CompositionLayerEquirectKHR<'a, G> {
7144 fn default() -> Self {
7145 Self::new()
7146 }
7147 }
7148 #[derive(Copy, Clone)]
7149 #[repr(transparent)]
7150 pub struct CompositionLayerEquirect2KHR<'a, G: Graphics> {
7151 inner: sys::CompositionLayerEquirect2KHR,
7152 _marker: PhantomData<&'a G>,
7153 }
7154 impl<'a, G: Graphics> CompositionLayerEquirect2KHR<'a, G> {
7155 #[inline]
7156 pub fn new() -> Self {
7157 Self {
7158 inner: sys::CompositionLayerEquirect2KHR {
7159 ty: sys::StructureType::COMPOSITION_LAYER_EQUIRECT2_KHR,
7160 ..unsafe { mem::zeroed() }
7161 },
7162 _marker: PhantomData,
7163 }
7164 }
7165 #[doc = r" Initialize with the supplied raw values"]
7166 #[doc = r""]
7167 #[doc = r" # Safety"]
7168 #[doc = r""]
7169 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7170 #[doc = r" preserved."]
7171 #[inline]
7172 pub unsafe fn from_raw(inner: sys::CompositionLayerEquirect2KHR) -> Self {
7173 Self {
7174 inner,
7175 _marker: PhantomData,
7176 }
7177 }
7178 #[inline]
7179 pub fn into_raw(self) -> sys::CompositionLayerEquirect2KHR {
7180 self.inner
7181 }
7182 #[inline]
7183 pub fn as_raw(&self) -> &sys::CompositionLayerEquirect2KHR {
7184 &self.inner
7185 }
7186 #[inline]
7187 pub fn layer_flags(mut self, value: CompositionLayerFlags) -> Self {
7188 self.inner.layer_flags = value;
7189 self
7190 }
7191 #[inline]
7192 pub fn space(mut self, value: &'a Space) -> Self {
7193 self.inner.space = value.as_raw();
7194 self
7195 }
7196 #[inline]
7197 pub fn eye_visibility(mut self, value: EyeVisibility) -> Self {
7198 self.inner.eye_visibility = value;
7199 self
7200 }
7201 #[inline]
7202 pub fn sub_image(mut self, value: SwapchainSubImage<'a, G>) -> Self {
7203 self.inner.sub_image = value.inner;
7204 self
7205 }
7206 #[inline]
7207 pub fn pose(mut self, value: Posef) -> Self {
7208 self.inner.pose = value;
7209 self
7210 }
7211 #[inline]
7212 pub fn radius(mut self, value: f32) -> Self {
7213 self.inner.radius = value;
7214 self
7215 }
7216 #[inline]
7217 pub fn central_horizontal_angle(mut self, value: f32) -> Self {
7218 self.inner.central_horizontal_angle = value;
7219 self
7220 }
7221 #[inline]
7222 pub fn upper_vertical_angle(mut self, value: f32) -> Self {
7223 self.inner.upper_vertical_angle = value;
7224 self
7225 }
7226 #[inline]
7227 pub fn lower_vertical_angle(mut self, value: f32) -> Self {
7228 self.inner.lower_vertical_angle = value;
7229 self
7230 }
7231 }
7232 impl<'a, G: Graphics> Deref for CompositionLayerEquirect2KHR<'a, G> {
7233 type Target = CompositionLayerBase<'a, G>;
7234 #[inline]
7235 fn deref(&self) -> &Self::Target {
7236 unsafe { mem::transmute(&self.inner) }
7237 }
7238 }
7239 impl<'a, G: Graphics> Default for CompositionLayerEquirect2KHR<'a, G> {
7240 fn default() -> Self {
7241 Self::new()
7242 }
7243 }
7244 #[repr(transparent)]
7245 pub struct HapticBase<'a> {
7246 _inner: sys::HapticBaseHeader,
7247 _marker: PhantomData<&'a ()>,
7248 }
7249 #[derive(Copy, Clone)]
7250 #[repr(transparent)]
7251 pub struct HapticVibration<'a> {
7252 inner: sys::HapticVibration,
7253 _marker: PhantomData<&'a ()>,
7254 }
7255 impl<'a> HapticVibration<'a> {
7256 #[inline]
7257 pub fn new() -> Self {
7258 Self {
7259 inner: sys::HapticVibration {
7260 ty: sys::StructureType::HAPTIC_VIBRATION,
7261 ..unsafe { mem::zeroed() }
7262 },
7263 _marker: PhantomData,
7264 }
7265 }
7266 #[doc = r" Initialize with the supplied raw values"]
7267 #[doc = r""]
7268 #[doc = r" # Safety"]
7269 #[doc = r""]
7270 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7271 #[doc = r" preserved."]
7272 #[inline]
7273 pub unsafe fn from_raw(inner: sys::HapticVibration) -> Self {
7274 Self {
7275 inner,
7276 _marker: PhantomData,
7277 }
7278 }
7279 #[inline]
7280 pub fn into_raw(self) -> sys::HapticVibration {
7281 self.inner
7282 }
7283 #[inline]
7284 pub fn as_raw(&self) -> &sys::HapticVibration {
7285 &self.inner
7286 }
7287 #[inline]
7288 pub fn duration(mut self, value: Duration) -> Self {
7289 self.inner.duration = value;
7290 self
7291 }
7292 #[inline]
7293 pub fn frequency(mut self, value: f32) -> Self {
7294 self.inner.frequency = value;
7295 self
7296 }
7297 #[inline]
7298 pub fn amplitude(mut self, value: f32) -> Self {
7299 self.inner.amplitude = value;
7300 self
7301 }
7302 }
7303 impl<'a> Deref for HapticVibration<'a> {
7304 type Target = HapticBase<'a>;
7305 #[inline]
7306 fn deref(&self) -> &Self::Target {
7307 unsafe { mem::transmute(&self.inner) }
7308 }
7309 }
7310 impl<'a> Default for HapticVibration<'a> {
7311 fn default() -> Self {
7312 Self::new()
7313 }
7314 }
7315 #[derive(Copy, Clone)]
7316 #[repr(transparent)]
7317 pub struct HapticAmplitudeEnvelopeVibrationFB<'a> {
7318 inner: sys::HapticAmplitudeEnvelopeVibrationFB,
7319 _marker: PhantomData<&'a ()>,
7320 }
7321 impl<'a> HapticAmplitudeEnvelopeVibrationFB<'a> {
7322 #[inline]
7323 pub fn new() -> Self {
7324 Self {
7325 inner: sys::HapticAmplitudeEnvelopeVibrationFB {
7326 ty: sys::StructureType::HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB,
7327 ..unsafe { mem::zeroed() }
7328 },
7329 _marker: PhantomData,
7330 }
7331 }
7332 #[doc = r" Initialize with the supplied raw values"]
7333 #[doc = r""]
7334 #[doc = r" # Safety"]
7335 #[doc = r""]
7336 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7337 #[doc = r" preserved."]
7338 #[inline]
7339 pub unsafe fn from_raw(inner: sys::HapticAmplitudeEnvelopeVibrationFB) -> Self {
7340 Self {
7341 inner,
7342 _marker: PhantomData,
7343 }
7344 }
7345 #[inline]
7346 pub fn into_raw(self) -> sys::HapticAmplitudeEnvelopeVibrationFB {
7347 self.inner
7348 }
7349 #[inline]
7350 pub fn as_raw(&self) -> &sys::HapticAmplitudeEnvelopeVibrationFB {
7351 &self.inner
7352 }
7353 #[inline]
7354 pub fn duration(mut self, value: Duration) -> Self {
7355 self.inner.duration = value;
7356 self
7357 }
7358 #[inline]
7359 pub fn amplitudes(mut self, value: &'a [f32]) -> Self {
7360 self.inner.amplitudes = value.as_ptr() as *const _ as _;
7361 self.inner.amplitude_count = value.len() as u32;
7362 self
7363 }
7364 }
7365 impl<'a> Deref for HapticAmplitudeEnvelopeVibrationFB<'a> {
7366 type Target = HapticBase<'a>;
7367 #[inline]
7368 fn deref(&self) -> &Self::Target {
7369 unsafe { mem::transmute(&self.inner) }
7370 }
7371 }
7372 impl<'a> Default for HapticAmplitudeEnvelopeVibrationFB<'a> {
7373 fn default() -> Self {
7374 Self::new()
7375 }
7376 }
7377 #[derive(Copy, Clone)]
7378 #[repr(transparent)]
7379 pub struct HapticPcmVibrationFB<'a> {
7380 inner: sys::HapticPcmVibrationFB,
7381 _marker: PhantomData<&'a ()>,
7382 }
7383 impl<'a> HapticPcmVibrationFB<'a> {
7384 #[inline]
7385 pub fn new() -> Self {
7386 Self {
7387 inner: sys::HapticPcmVibrationFB {
7388 ty: sys::StructureType::HAPTIC_PCM_VIBRATION_FB,
7389 ..unsafe { mem::zeroed() }
7390 },
7391 _marker: PhantomData,
7392 }
7393 }
7394 #[doc = r" Initialize with the supplied raw values"]
7395 #[doc = r""]
7396 #[doc = r" # Safety"]
7397 #[doc = r""]
7398 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7399 #[doc = r" preserved."]
7400 #[inline]
7401 pub unsafe fn from_raw(inner: sys::HapticPcmVibrationFB) -> Self {
7402 Self {
7403 inner,
7404 _marker: PhantomData,
7405 }
7406 }
7407 #[inline]
7408 pub fn into_raw(self) -> sys::HapticPcmVibrationFB {
7409 self.inner
7410 }
7411 #[inline]
7412 pub fn as_raw(&self) -> &sys::HapticPcmVibrationFB {
7413 &self.inner
7414 }
7415 #[inline]
7416 pub fn buffer(mut self, value: &'a [f32]) -> Self {
7417 self.inner.buffer = value.as_ptr() as *const _ as _;
7418 self.inner.buffer_size = value.len() as u32;
7419 self
7420 }
7421 #[inline]
7422 pub fn sample_rate(mut self, value: f32) -> Self {
7423 self.inner.sample_rate = value;
7424 self
7425 }
7426 #[inline]
7427 pub fn append(mut self, value: bool) -> Self {
7428 self.inner.append = value.into();
7429 self
7430 }
7431 #[inline]
7432 pub fn samples_consumed(mut self, value: &'a mut u32) -> Self {
7433 self.inner.samples_consumed = value as *mut _ as _;
7434 self
7435 }
7436 }
7437 impl<'a> Deref for HapticPcmVibrationFB<'a> {
7438 type Target = HapticBase<'a>;
7439 #[inline]
7440 fn deref(&self) -> &Self::Target {
7441 unsafe { mem::transmute(&self.inner) }
7442 }
7443 }
7444 impl<'a> Default for HapticPcmVibrationFB<'a> {
7445 fn default() -> Self {
7446 Self::new()
7447 }
7448 }
7449 #[repr(transparent)]
7450 pub struct BindingModificationBase<'a> {
7451 _inner: sys::BindingModificationBaseHeaderKHR,
7452 _marker: PhantomData<&'a ()>,
7453 }
7454 #[derive(Copy, Clone)]
7455 #[repr(transparent)]
7456 pub struct InteractionProfileDpadBindingEXT<'a> {
7457 inner: sys::InteractionProfileDpadBindingEXT,
7458 _marker: PhantomData<&'a ()>,
7459 }
7460 impl<'a> InteractionProfileDpadBindingEXT<'a> {
7461 #[inline]
7462 pub fn new() -> Self {
7463 Self {
7464 inner: sys::InteractionProfileDpadBindingEXT {
7465 ty: sys::StructureType::INTERACTION_PROFILE_DPAD_BINDING_EXT,
7466 ..unsafe { mem::zeroed() }
7467 },
7468 _marker: PhantomData,
7469 }
7470 }
7471 #[doc = r" Initialize with the supplied raw values"]
7472 #[doc = r""]
7473 #[doc = r" # Safety"]
7474 #[doc = r""]
7475 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7476 #[doc = r" preserved."]
7477 #[inline]
7478 pub unsafe fn from_raw(inner: sys::InteractionProfileDpadBindingEXT) -> Self {
7479 Self {
7480 inner,
7481 _marker: PhantomData,
7482 }
7483 }
7484 #[inline]
7485 pub fn into_raw(self) -> sys::InteractionProfileDpadBindingEXT {
7486 self.inner
7487 }
7488 #[inline]
7489 pub fn as_raw(&self) -> &sys::InteractionProfileDpadBindingEXT {
7490 &self.inner
7491 }
7492 #[inline]
7493 pub fn binding(mut self, value: Path) -> Self {
7494 self.inner.binding = value;
7495 self
7496 }
7497 #[inline]
7498 pub fn action_set(mut self, value: &'a ActionSet) -> Self {
7499 self.inner.action_set = value.as_raw();
7500 self
7501 }
7502 #[inline]
7503 pub fn force_threshold(mut self, value: f32) -> Self {
7504 self.inner.force_threshold = value;
7505 self
7506 }
7507 #[inline]
7508 pub fn force_threshold_released(mut self, value: f32) -> Self {
7509 self.inner.force_threshold_released = value;
7510 self
7511 }
7512 #[inline]
7513 pub fn center_region(mut self, value: f32) -> Self {
7514 self.inner.center_region = value;
7515 self
7516 }
7517 #[inline]
7518 pub fn wedge_angle(mut self, value: f32) -> Self {
7519 self.inner.wedge_angle = value;
7520 self
7521 }
7522 #[inline]
7523 pub fn is_sticky(mut self, value: bool) -> Self {
7524 self.inner.is_sticky = value.into();
7525 self
7526 }
7527 #[inline]
7528 pub fn on_haptic(mut self, value: &'a HapticBase<'a>) -> Self {
7529 self.inner.on_haptic = value as *const _ as _;
7530 self
7531 }
7532 #[inline]
7533 pub fn off_haptic(mut self, value: &'a HapticBase<'a>) -> Self {
7534 self.inner.off_haptic = value as *const _ as _;
7535 self
7536 }
7537 }
7538 impl<'a> Deref for InteractionProfileDpadBindingEXT<'a> {
7539 type Target = BindingModificationBase<'a>;
7540 #[inline]
7541 fn deref(&self) -> &Self::Target {
7542 unsafe { mem::transmute(&self.inner) }
7543 }
7544 }
7545 impl<'a> Default for InteractionProfileDpadBindingEXT<'a> {
7546 fn default() -> Self {
7547 Self::new()
7548 }
7549 }
7550 #[derive(Copy, Clone)]
7551 #[repr(transparent)]
7552 pub struct InteractionProfileAnalogThresholdVALVE<'a> {
7553 inner: sys::InteractionProfileAnalogThresholdVALVE,
7554 _marker: PhantomData<&'a ()>,
7555 }
7556 impl<'a> InteractionProfileAnalogThresholdVALVE<'a> {
7557 #[inline]
7558 pub fn new() -> Self {
7559 Self {
7560 inner: sys::InteractionProfileAnalogThresholdVALVE {
7561 ty: sys::StructureType::INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE,
7562 ..unsafe { mem::zeroed() }
7563 },
7564 _marker: PhantomData,
7565 }
7566 }
7567 #[doc = r" Initialize with the supplied raw values"]
7568 #[doc = r""]
7569 #[doc = r" # Safety"]
7570 #[doc = r""]
7571 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7572 #[doc = r" preserved."]
7573 #[inline]
7574 pub unsafe fn from_raw(inner: sys::InteractionProfileAnalogThresholdVALVE) -> Self {
7575 Self {
7576 inner,
7577 _marker: PhantomData,
7578 }
7579 }
7580 #[inline]
7581 pub fn into_raw(self) -> sys::InteractionProfileAnalogThresholdVALVE {
7582 self.inner
7583 }
7584 #[inline]
7585 pub fn as_raw(&self) -> &sys::InteractionProfileAnalogThresholdVALVE {
7586 &self.inner
7587 }
7588 #[inline]
7589 pub fn action<ATY: ActionTy>(mut self, value: &'a Action<ATY>) -> Self {
7590 self.inner.action = value.as_raw();
7591 self
7592 }
7593 #[inline]
7594 pub fn binding(mut self, value: Path) -> Self {
7595 self.inner.binding = value;
7596 self
7597 }
7598 #[inline]
7599 pub fn on_threshold(mut self, value: f32) -> Self {
7600 self.inner.on_threshold = value;
7601 self
7602 }
7603 #[inline]
7604 pub fn off_threshold(mut self, value: f32) -> Self {
7605 self.inner.off_threshold = value;
7606 self
7607 }
7608 #[inline]
7609 pub fn on_haptic(mut self, value: &'a HapticBase<'a>) -> Self {
7610 self.inner.on_haptic = value as *const _ as _;
7611 self
7612 }
7613 #[inline]
7614 pub fn off_haptic(mut self, value: &'a HapticBase<'a>) -> Self {
7615 self.inner.off_haptic = value as *const _ as _;
7616 self
7617 }
7618 }
7619 impl<'a> Deref for InteractionProfileAnalogThresholdVALVE<'a> {
7620 type Target = BindingModificationBase<'a>;
7621 #[inline]
7622 fn deref(&self) -> &Self::Target {
7623 unsafe { mem::transmute(&self.inner) }
7624 }
7625 }
7626 impl<'a> Default for InteractionProfileAnalogThresholdVALVE<'a> {
7627 fn default() -> Self {
7628 Self::new()
7629 }
7630 }
7631 #[repr(transparent)]
7632 pub struct SwapchainStateBase<'a> {
7633 _inner: sys::SwapchainStateBaseHeaderFB,
7634 _marker: PhantomData<&'a ()>,
7635 }
7636 #[cfg(target_os = "android")]
7637 #[derive(Copy, Clone)]
7638 #[repr(transparent)]
7639 pub struct SwapchainStateAndroidSurfaceDimensionsFB<'a> {
7640 inner: sys::SwapchainStateAndroidSurfaceDimensionsFB,
7641 _marker: PhantomData<&'a ()>,
7642 }
7643 #[cfg(target_os = "android")]
7644 impl<'a> SwapchainStateAndroidSurfaceDimensionsFB<'a> {
7645 #[inline]
7646 pub fn new() -> Self {
7647 Self {
7648 inner: sys::SwapchainStateAndroidSurfaceDimensionsFB {
7649 ty: sys::StructureType::SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB,
7650 ..unsafe { mem::zeroed() }
7651 },
7652 _marker: PhantomData,
7653 }
7654 }
7655 #[doc = r" Initialize with the supplied raw values"]
7656 #[doc = r""]
7657 #[doc = r" # Safety"]
7658 #[doc = r""]
7659 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7660 #[doc = r" preserved."]
7661 #[inline]
7662 pub unsafe fn from_raw(inner: sys::SwapchainStateAndroidSurfaceDimensionsFB) -> Self {
7663 Self {
7664 inner,
7665 _marker: PhantomData,
7666 }
7667 }
7668 #[inline]
7669 pub fn into_raw(self) -> sys::SwapchainStateAndroidSurfaceDimensionsFB {
7670 self.inner
7671 }
7672 #[inline]
7673 pub fn as_raw(&self) -> &sys::SwapchainStateAndroidSurfaceDimensionsFB {
7674 &self.inner
7675 }
7676 #[inline]
7677 pub fn width(mut self, value: u32) -> Self {
7678 self.inner.width = value;
7679 self
7680 }
7681 #[inline]
7682 pub fn height(mut self, value: u32) -> Self {
7683 self.inner.height = value;
7684 self
7685 }
7686 }
7687 #[cfg(target_os = "android")]
7688 impl<'a> Deref for SwapchainStateAndroidSurfaceDimensionsFB<'a> {
7689 type Target = SwapchainStateBase<'a>;
7690 #[inline]
7691 fn deref(&self) -> &Self::Target {
7692 unsafe { mem::transmute(&self.inner) }
7693 }
7694 }
7695 #[cfg(target_os = "android")]
7696 impl<'a> Default for SwapchainStateAndroidSurfaceDimensionsFB<'a> {
7697 fn default() -> Self {
7698 Self::new()
7699 }
7700 }
7701 #[derive(Copy, Clone)]
7702 #[repr(transparent)]
7703 pub struct SwapchainStateSamplerOpenGLESFB<'a> {
7704 inner: sys::SwapchainStateSamplerOpenGLESFB,
7705 _marker: PhantomData<&'a ()>,
7706 }
7707 impl<'a> SwapchainStateSamplerOpenGLESFB<'a> {
7708 #[inline]
7709 pub fn new() -> Self {
7710 Self {
7711 inner: sys::SwapchainStateSamplerOpenGLESFB {
7712 ty: sys::StructureType::SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB,
7713 ..unsafe { mem::zeroed() }
7714 },
7715 _marker: PhantomData,
7716 }
7717 }
7718 #[doc = r" Initialize with the supplied raw values"]
7719 #[doc = r""]
7720 #[doc = r" # Safety"]
7721 #[doc = r""]
7722 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7723 #[doc = r" preserved."]
7724 #[inline]
7725 pub unsafe fn from_raw(inner: sys::SwapchainStateSamplerOpenGLESFB) -> Self {
7726 Self {
7727 inner,
7728 _marker: PhantomData,
7729 }
7730 }
7731 #[inline]
7732 pub fn into_raw(self) -> sys::SwapchainStateSamplerOpenGLESFB {
7733 self.inner
7734 }
7735 #[inline]
7736 pub fn as_raw(&self) -> &sys::SwapchainStateSamplerOpenGLESFB {
7737 &self.inner
7738 }
7739 #[inline]
7740 pub fn min_filter(mut self, value: EGLenum) -> Self {
7741 self.inner.min_filter = value;
7742 self
7743 }
7744 #[inline]
7745 pub fn mag_filter(mut self, value: EGLenum) -> Self {
7746 self.inner.mag_filter = value;
7747 self
7748 }
7749 #[inline]
7750 pub fn wrap_mode_s(mut self, value: EGLenum) -> Self {
7751 self.inner.wrap_mode_s = value;
7752 self
7753 }
7754 #[inline]
7755 pub fn wrap_mode_t(mut self, value: EGLenum) -> Self {
7756 self.inner.wrap_mode_t = value;
7757 self
7758 }
7759 #[inline]
7760 pub fn swizzle_red(mut self, value: EGLenum) -> Self {
7761 self.inner.swizzle_red = value;
7762 self
7763 }
7764 #[inline]
7765 pub fn swizzle_green(mut self, value: EGLenum) -> Self {
7766 self.inner.swizzle_green = value;
7767 self
7768 }
7769 #[inline]
7770 pub fn swizzle_blue(mut self, value: EGLenum) -> Self {
7771 self.inner.swizzle_blue = value;
7772 self
7773 }
7774 #[inline]
7775 pub fn swizzle_alpha(mut self, value: EGLenum) -> Self {
7776 self.inner.swizzle_alpha = value;
7777 self
7778 }
7779 #[inline]
7780 pub fn max_anisotropy(mut self, value: f32) -> Self {
7781 self.inner.max_anisotropy = value;
7782 self
7783 }
7784 #[inline]
7785 pub fn border_color(mut self, value: Color4f) -> Self {
7786 self.inner.border_color = value;
7787 self
7788 }
7789 }
7790 impl<'a> Deref for SwapchainStateSamplerOpenGLESFB<'a> {
7791 type Target = SwapchainStateBase<'a>;
7792 #[inline]
7793 fn deref(&self) -> &Self::Target {
7794 unsafe { mem::transmute(&self.inner) }
7795 }
7796 }
7797 impl<'a> Default for SwapchainStateSamplerOpenGLESFB<'a> {
7798 fn default() -> Self {
7799 Self::new()
7800 }
7801 }
7802 #[derive(Copy, Clone)]
7803 #[repr(transparent)]
7804 pub struct SwapchainStateSamplerVulkanFB<'a> {
7805 inner: sys::SwapchainStateSamplerVulkanFB,
7806 _marker: PhantomData<&'a ()>,
7807 }
7808 impl<'a> SwapchainStateSamplerVulkanFB<'a> {
7809 #[inline]
7810 pub fn new() -> Self {
7811 Self {
7812 inner: sys::SwapchainStateSamplerVulkanFB {
7813 ty: sys::StructureType::SWAPCHAIN_STATE_SAMPLER_VULKAN_FB,
7814 ..unsafe { mem::zeroed() }
7815 },
7816 _marker: PhantomData,
7817 }
7818 }
7819 #[doc = r" Initialize with the supplied raw values"]
7820 #[doc = r""]
7821 #[doc = r" # Safety"]
7822 #[doc = r""]
7823 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7824 #[doc = r" preserved."]
7825 #[inline]
7826 pub unsafe fn from_raw(inner: sys::SwapchainStateSamplerVulkanFB) -> Self {
7827 Self {
7828 inner,
7829 _marker: PhantomData,
7830 }
7831 }
7832 #[inline]
7833 pub fn into_raw(self) -> sys::SwapchainStateSamplerVulkanFB {
7834 self.inner
7835 }
7836 #[inline]
7837 pub fn as_raw(&self) -> &sys::SwapchainStateSamplerVulkanFB {
7838 &self.inner
7839 }
7840 #[inline]
7841 pub fn min_filter(mut self, value: VkFilter) -> Self {
7842 self.inner.min_filter = value;
7843 self
7844 }
7845 #[inline]
7846 pub fn mag_filter(mut self, value: VkFilter) -> Self {
7847 self.inner.mag_filter = value;
7848 self
7849 }
7850 #[inline]
7851 pub fn mipmap_mode(mut self, value: VkSamplerMipmapMode) -> Self {
7852 self.inner.mipmap_mode = value;
7853 self
7854 }
7855 #[inline]
7856 pub fn wrap_mode_s(mut self, value: VkSamplerAddressMode) -> Self {
7857 self.inner.wrap_mode_s = value;
7858 self
7859 }
7860 #[inline]
7861 pub fn wrap_mode_t(mut self, value: VkSamplerAddressMode) -> Self {
7862 self.inner.wrap_mode_t = value;
7863 self
7864 }
7865 #[inline]
7866 pub fn swizzle_red(mut self, value: VkComponentSwizzle) -> Self {
7867 self.inner.swizzle_red = value;
7868 self
7869 }
7870 #[inline]
7871 pub fn swizzle_green(mut self, value: VkComponentSwizzle) -> Self {
7872 self.inner.swizzle_green = value;
7873 self
7874 }
7875 #[inline]
7876 pub fn swizzle_blue(mut self, value: VkComponentSwizzle) -> Self {
7877 self.inner.swizzle_blue = value;
7878 self
7879 }
7880 #[inline]
7881 pub fn swizzle_alpha(mut self, value: VkComponentSwizzle) -> Self {
7882 self.inner.swizzle_alpha = value;
7883 self
7884 }
7885 #[inline]
7886 pub fn max_anisotropy(mut self, value: f32) -> Self {
7887 self.inner.max_anisotropy = value;
7888 self
7889 }
7890 #[inline]
7891 pub fn border_color(mut self, value: Color4f) -> Self {
7892 self.inner.border_color = value;
7893 self
7894 }
7895 }
7896 impl<'a> Deref for SwapchainStateSamplerVulkanFB<'a> {
7897 type Target = SwapchainStateBase<'a>;
7898 #[inline]
7899 fn deref(&self) -> &Self::Target {
7900 unsafe { mem::transmute(&self.inner) }
7901 }
7902 }
7903 impl<'a> Default for SwapchainStateSamplerVulkanFB<'a> {
7904 fn default() -> Self {
7905 Self::new()
7906 }
7907 }
7908 #[derive(Copy, Clone)]
7909 #[repr(transparent)]
7910 pub struct SwapchainStateFoveationFB<'a> {
7911 inner: sys::SwapchainStateFoveationFB,
7912 _marker: PhantomData<&'a ()>,
7913 }
7914 impl<'a> SwapchainStateFoveationFB<'a> {
7915 #[inline]
7916 pub fn new() -> Self {
7917 Self {
7918 inner: sys::SwapchainStateFoveationFB {
7919 ty: sys::StructureType::SWAPCHAIN_STATE_FOVEATION_FB,
7920 ..unsafe { mem::zeroed() }
7921 },
7922 _marker: PhantomData,
7923 }
7924 }
7925 #[doc = r" Initialize with the supplied raw values"]
7926 #[doc = r""]
7927 #[doc = r" # Safety"]
7928 #[doc = r""]
7929 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7930 #[doc = r" preserved."]
7931 #[inline]
7932 pub unsafe fn from_raw(inner: sys::SwapchainStateFoveationFB) -> Self {
7933 Self {
7934 inner,
7935 _marker: PhantomData,
7936 }
7937 }
7938 #[inline]
7939 pub fn into_raw(self) -> sys::SwapchainStateFoveationFB {
7940 self.inner
7941 }
7942 #[inline]
7943 pub fn as_raw(&self) -> &sys::SwapchainStateFoveationFB {
7944 &self.inner
7945 }
7946 #[inline]
7947 pub fn flags(mut self, value: SwapchainStateFoveationFlagsFB) -> Self {
7948 self.inner.flags = value;
7949 self
7950 }
7951 #[inline]
7952 pub fn profile(mut self, value: &'a FoveationProfileFB) -> Self {
7953 self.inner.profile = value.as_raw();
7954 self
7955 }
7956 }
7957 impl<'a> Deref for SwapchainStateFoveationFB<'a> {
7958 type Target = SwapchainStateBase<'a>;
7959 #[inline]
7960 fn deref(&self) -> &Self::Target {
7961 unsafe { mem::transmute(&self.inner) }
7962 }
7963 }
7964 impl<'a> Default for SwapchainStateFoveationFB<'a> {
7965 fn default() -> Self {
7966 Self::new()
7967 }
7968 }
7969 #[repr(transparent)]
7970 pub struct SpaceQueryInfoBase<'a> {
7971 _inner: sys::SpaceQueryInfoBaseHeaderFB,
7972 _marker: PhantomData<&'a ()>,
7973 }
7974 #[derive(Copy, Clone)]
7975 #[repr(transparent)]
7976 pub struct SpaceQueryInfoFB<'a> {
7977 inner: sys::SpaceQueryInfoFB,
7978 _marker: PhantomData<&'a ()>,
7979 }
7980 impl<'a> SpaceQueryInfoFB<'a> {
7981 #[inline]
7982 pub fn new() -> Self {
7983 Self {
7984 inner: sys::SpaceQueryInfoFB {
7985 ty: sys::StructureType::SPACE_QUERY_INFO_FB,
7986 ..unsafe { mem::zeroed() }
7987 },
7988 _marker: PhantomData,
7989 }
7990 }
7991 #[doc = r" Initialize with the supplied raw values"]
7992 #[doc = r""]
7993 #[doc = r" # Safety"]
7994 #[doc = r""]
7995 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
7996 #[doc = r" preserved."]
7997 #[inline]
7998 pub unsafe fn from_raw(inner: sys::SpaceQueryInfoFB) -> Self {
7999 Self {
8000 inner,
8001 _marker: PhantomData,
8002 }
8003 }
8004 #[inline]
8005 pub fn into_raw(self) -> sys::SpaceQueryInfoFB {
8006 self.inner
8007 }
8008 #[inline]
8009 pub fn as_raw(&self) -> &sys::SpaceQueryInfoFB {
8010 &self.inner
8011 }
8012 #[inline]
8013 pub fn query_action(mut self, value: SpaceQueryActionFB) -> Self {
8014 self.inner.query_action = value;
8015 self
8016 }
8017 #[inline]
8018 pub fn max_result_count(mut self, value: u32) -> Self {
8019 self.inner.max_result_count = value;
8020 self
8021 }
8022 #[inline]
8023 pub fn timeout(mut self, value: Duration) -> Self {
8024 self.inner.timeout = value;
8025 self
8026 }
8027 #[inline]
8028 pub fn filter(mut self, value: &'a SpaceFilterInfoBase<'a>) -> Self {
8029 self.inner.filter = value as *const _ as _;
8030 self
8031 }
8032 #[inline]
8033 pub fn exclude_filter(mut self, value: &'a SpaceFilterInfoBase<'a>) -> Self {
8034 self.inner.exclude_filter = value as *const _ as _;
8035 self
8036 }
8037 }
8038 impl<'a> Deref for SpaceQueryInfoFB<'a> {
8039 type Target = SpaceQueryInfoBase<'a>;
8040 #[inline]
8041 fn deref(&self) -> &Self::Target {
8042 unsafe { mem::transmute(&self.inner) }
8043 }
8044 }
8045 impl<'a> Default for SpaceQueryInfoFB<'a> {
8046 fn default() -> Self {
8047 Self::new()
8048 }
8049 }
8050 #[repr(transparent)]
8051 pub struct SpaceFilterInfoBase<'a> {
8052 _inner: sys::SpaceFilterInfoBaseHeaderFB,
8053 _marker: PhantomData<&'a ()>,
8054 }
8055 #[derive(Copy, Clone)]
8056 #[repr(transparent)]
8057 pub struct SpaceUuidFilterInfoFB<'a> {
8058 inner: sys::SpaceUuidFilterInfoFB,
8059 _marker: PhantomData<&'a ()>,
8060 }
8061 impl<'a> SpaceUuidFilterInfoFB<'a> {
8062 #[inline]
8063 pub fn new() -> Self {
8064 Self {
8065 inner: sys::SpaceUuidFilterInfoFB {
8066 ty: sys::StructureType::SPACE_UUID_FILTER_INFO_FB,
8067 ..unsafe { mem::zeroed() }
8068 },
8069 _marker: PhantomData,
8070 }
8071 }
8072 #[doc = r" Initialize with the supplied raw values"]
8073 #[doc = r""]
8074 #[doc = r" # Safety"]
8075 #[doc = r""]
8076 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
8077 #[doc = r" preserved."]
8078 #[inline]
8079 pub unsafe fn from_raw(inner: sys::SpaceUuidFilterInfoFB) -> Self {
8080 Self {
8081 inner,
8082 _marker: PhantomData,
8083 }
8084 }
8085 #[inline]
8086 pub fn into_raw(self) -> sys::SpaceUuidFilterInfoFB {
8087 self.inner
8088 }
8089 #[inline]
8090 pub fn as_raw(&self) -> &sys::SpaceUuidFilterInfoFB {
8091 &self.inner
8092 }
8093 #[inline]
8094 pub fn uuids(mut self, value: &'a [UuidEXT]) -> Self {
8095 self.inner.uuids = value.as_ptr() as *const _ as _;
8096 self.inner.uuid_count = value.len() as u32;
8097 self
8098 }
8099 }
8100 impl<'a> Deref for SpaceUuidFilterInfoFB<'a> {
8101 type Target = SpaceFilterInfoBase<'a>;
8102 #[inline]
8103 fn deref(&self) -> &Self::Target {
8104 unsafe { mem::transmute(&self.inner) }
8105 }
8106 }
8107 impl<'a> Default for SpaceUuidFilterInfoFB<'a> {
8108 fn default() -> Self {
8109 Self::new()
8110 }
8111 }
8112 #[derive(Copy, Clone)]
8113 #[repr(transparent)]
8114 pub struct SpaceComponentFilterInfoFB<'a> {
8115 inner: sys::SpaceComponentFilterInfoFB,
8116 _marker: PhantomData<&'a ()>,
8117 }
8118 impl<'a> SpaceComponentFilterInfoFB<'a> {
8119 #[inline]
8120 pub fn new() -> Self {
8121 Self {
8122 inner: sys::SpaceComponentFilterInfoFB {
8123 ty: sys::StructureType::SPACE_COMPONENT_FILTER_INFO_FB,
8124 ..unsafe { mem::zeroed() }
8125 },
8126 _marker: PhantomData,
8127 }
8128 }
8129 #[doc = r" Initialize with the supplied raw values"]
8130 #[doc = r""]
8131 #[doc = r" # Safety"]
8132 #[doc = r""]
8133 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
8134 #[doc = r" preserved."]
8135 #[inline]
8136 pub unsafe fn from_raw(inner: sys::SpaceComponentFilterInfoFB) -> Self {
8137 Self {
8138 inner,
8139 _marker: PhantomData,
8140 }
8141 }
8142 #[inline]
8143 pub fn into_raw(self) -> sys::SpaceComponentFilterInfoFB {
8144 self.inner
8145 }
8146 #[inline]
8147 pub fn as_raw(&self) -> &sys::SpaceComponentFilterInfoFB {
8148 &self.inner
8149 }
8150 #[inline]
8151 pub fn component_type(mut self, value: SpaceComponentTypeFB) -> Self {
8152 self.inner.component_type = value;
8153 self
8154 }
8155 }
8156 impl<'a> Deref for SpaceComponentFilterInfoFB<'a> {
8157 type Target = SpaceFilterInfoBase<'a>;
8158 #[inline]
8159 fn deref(&self) -> &Self::Target {
8160 unsafe { mem::transmute(&self.inner) }
8161 }
8162 }
8163 impl<'a> Default for SpaceComponentFilterInfoFB<'a> {
8164 fn default() -> Self {
8165 Self::new()
8166 }
8167 }
8168 #[repr(transparent)]
8169 pub struct FutureCompletionBase<'a> {
8170 _inner: sys::FutureCompletionBaseHeaderEXT,
8171 _marker: PhantomData<&'a ()>,
8172 }
8173 #[derive(Copy, Clone)]
8174 #[repr(transparent)]
8175 pub struct FutureCompletionEXT<'a> {
8176 inner: sys::FutureCompletionEXT,
8177 _marker: PhantomData<&'a ()>,
8178 }
8179 impl<'a> FutureCompletionEXT<'a> {
8180 #[inline]
8181 pub fn new() -> Self {
8182 Self {
8183 inner: sys::FutureCompletionEXT {
8184 ty: sys::StructureType::FUTURE_COMPLETION_EXT,
8185 ..unsafe { mem::zeroed() }
8186 },
8187 _marker: PhantomData,
8188 }
8189 }
8190 #[doc = r" Initialize with the supplied raw values"]
8191 #[doc = r""]
8192 #[doc = r" # Safety"]
8193 #[doc = r""]
8194 #[doc = r" The guarantees normally enforced by this builder (e.g. lifetimes) must be"]
8195 #[doc = r" preserved."]
8196 #[inline]
8197 pub unsafe fn from_raw(inner: sys::FutureCompletionEXT) -> Self {
8198 Self {
8199 inner,
8200 _marker: PhantomData,
8201 }
8202 }
8203 #[inline]
8204 pub fn into_raw(self) -> sys::FutureCompletionEXT {
8205 self.inner
8206 }
8207 #[inline]
8208 pub fn as_raw(&self) -> &sys::FutureCompletionEXT {
8209 &self.inner
8210 }
8211 #[inline]
8212 pub fn future_result(mut self, value: sys::Result) -> Self {
8213 self.inner.future_result = value;
8214 self
8215 }
8216 }
8217 impl<'a> Deref for FutureCompletionEXT<'a> {
8218 type Target = FutureCompletionBase<'a>;
8219 #[inline]
8220 fn deref(&self) -> &Self::Target {
8221 unsafe { mem::transmute(&self.inner) }
8222 }
8223 }
8224 impl<'a> Default for FutureCompletionEXT<'a> {
8225 fn default() -> Self {
8226 Self::new()
8227 }
8228 }
8229}